ISEVEN

What it does

ISEVEN(number)

ISEVEN(number) tests whether a number is even, returning a logical value. Microsoft's ordinary rule is to discard a fractional part before testing parity: ISEVEN(2.5) is TRUE. Sign does not change parity; truncating a negative number moves toward zero.

Excel has an additional near-integer tolerance. On the recorded build, ISEVEN(2.99999999999) is FALSE: the value counts as 3 even though truncating its exact stored value alone would give 2. This is a numerical quirk, not the ordinary mathematical parity test.

Try it

Compare =ISEVEN(2.5), =ISEVEN(2.99999999999) and =ISEVEN(-2.99999999999). Use =ISODD(2.99999999999) to compare the paired predicate.

Quirks

The documented description of truncation omits the tolerance visible near an integer. Recorded ISODD calls distinguish 2.99999999991 (TRUE) from 2.99999999989 (FALSE). Those points constrain a boundary; they do not establish one universal tolerance on every build or at every magnitude.

The pair also differs from strict classifiers such as ISNUMBER. The recorded ISEVEN accepts numeric text "2" and " 2 ", while ISEVEN(TRUE) returns #VALUE!. An error input is propagated rather than classified as FALSE. Do not apply a blanket rule that every IS-prefixed function performs no conversion.

At magnitudes of 2^53 and above, all finite binary64 numbers are even integers. Converting a large input to a signed machine integer can saturate or overflow and create a false odd answer.

How to implement

Keep argument reading separate from the parity kernel: read a one-cell reference, handle blanks, coerce permitted numeric text, reject logical values where the measured rule requires it, and propagate errors. References spanning multiple cells need their own measured shape rule.

A compatibility candidate used by OneCalc is to add binary64 1e-10 to the input's absolute magnitude, round that addition to binary64, truncate the result, and take the remainder modulo 2. The predicate returns whether that remainder is zero. The rounded addition is part of the candidate; replacing it with a test on the original value changes results near an integer.

Test both sides of each observed transition and both signs, direct versus referenced text, logical arguments and magnitudes beyond signed-integer range. Keep this compatibility algorithm separate from a mathematical integer-parity routine.

Rust code

unary(ISEVEN, "ISEVEN", NUMBER, iseven)

/// ISEVEN: whether the number, truncated toward zero, is even.
fn iseven(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    let site = Site::new(ISEVEN, services);
    Site::finish(each(&site, &arguments[0], services, |site, value, services| {
        odd(site, value, services).map(|odd| CalcValue::logical(!odd))
    }))
}

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Alternatives

ISODD tests the other parity. MOD and an explicitly specified truncation rule can express mathematical parity, but they need not reproduce the tolerance. ISNUMBER classifies a value without performing a parity calculation.

Named variants

No named variants are recorded yet.