EVEN

What it does

EVEN(number)

EVEN(number) rounds its argument to an even integer, moving away from zero. Microsoft's page states the rule in exactly that form: regardless of the sign, the adjustment is away from zero, and an argument that is already an even integer is not moved.

In closed form:

EVEN(x) = 2 · sign(x) · ceil( ABS(x) / 2 )      for x ≠ 0
EVEN(0) = 0

The last row is the one that surprises people, and it is pure format arithmetic rather than function design. Above 2^53 the spacing between consecutive doubles is at least 2, so every representable value in that range is already an even integer. EVEN is therefore the identity map on the entire upper half of the format's range, and the function only does anything at all below 2^53.

The half-open-interval reading is worth keeping in mind: EVEN maps (0, 2] to 2, (2, 4] to 4, and symmetrically on the negative side. The endpoints belong to the lower tread because an even integer is not moved.

Arguments

Try it

Quirks

Result and edge cases

Returns Number, always an even integer.

• Zero — EVEN(0) is 0. Zero is even, so no adjustment is required, and the closed form above handles it as the degenerate case rather than as an exception.
• Negative arguments — move away from zero: an argument between -2 and 0 becomes -2. This is the documented rule and it is the opposite of what "round up" would mean if read as "toward +∞". Microsoft's own wording — a value is rounded up when adjusted away from zero — is a definition of "up" as "away from zero", and the whole page turns on it.
• Already-even integers — unchanged, documented explicitly.
• Odd integers — move by exactly 1, away from zero.
• Values already above 2^53 — unchanged, as above.
• Signed zero — an argument of -0 is at a fixed point; whether the sign survives is not documented and has not been checked.

Errors

As documented on Microsoft's EVEN page:

No other error condition is documented, and none is structurally required: the function cannot overflow and has no domain restriction.

How to implement

Numerical notes

EVEN is one of the few functions in this batch that can be, and should be, exact.

Every step of the closed form is exact in binary64:

1. ABS(x) is exact — a sign-bit clear.
2. ABS(x) / 2 is exact — division by a power of two only changes the exponent, and it cannot underflow into the subnormal range in a way that loses bits unless x was already subnormal, where the result is 0 or 2 anyway.
3. ceil is exact — it is an IEEE 754 roundToIntegral operation, which is by definition exactly rounded and, for a value already integral, the identity.
4. Multiplying by 2 is exact, and cannot overflow: the input to this step is at most ceil(DBL_MAX/2), so the product is at most DBL_MAX.

So a correct implementation commits no rounding error at all on any argument, and any disagreement between two implementations of EVEN is a disagreement about the rule, never about the arithmetic. That is a rare and pleasant situation, and it means the interesting probes here are all about tie behaviour and sign conventions rather than about ulp.

Two traps for implementers:

• Do not use 2 * ceil(x / 2) without the absolute value. For negative x, ceil rounds toward +∞, i.e. toward zero, which is the opposite of the documented rule. The sign must be factored out first and restored afterwards.
• Do not test "is already even" by MOD(x, 2) = 0 on large arguments. Above 2^53 this is true of everything, which happens to be correct, but the test itself involves a division that is exact only because of the power of two; the same pattern with a non-power-of-two step is not exact, and the habit transfers badly to MROUND and CEILING.MATH.

The identity region above 2^53 deserves one more sentence, because it is a fact about the format that this function makes visible: a spreadsheet user who applies EVEN to a large identifier — an account number stored as a number, say — will see it returned unchanged and may conclude the function is broken. It is not; the value was already even, and had been since it crossed 2^53.

Rust code

call(EVEN, "EVEN", 1, NUMBER, even)

/// EVEN: rounded away from zero to an even integer; an even integer is unchanged.
fn even(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    numeric(EVEN, arguments, services, |site, n| {
        to_parity(site, n[0], false)
    })
}

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.

• XC-EVEN-001: build 19929 versus build 20430; 2 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.

Agreement on these compared inputs does not establish agreement on unmeasured inputs.

Recorded environments and comparison details.

Alternatives

Relationships

• ODD — the parity partner, rounding away from zero to an odd integer. The pair is not symmetric: ODD has no fixed point at zero (ODD(0) is documented as 1) and its identity region above 2^53 does not exist, because no double above 2^53 is odd. That asymmetry makes ODD the more interesting of the two at the top of the range and EVEN the more interesting at the bottom.
• CEILING.MATH — the general away-from-zero-or-toward--∞ rounding. CEILING.MATH(x, 2, 1) is the away-from-zero reading and coincides with EVEN there; CEILING.MATH(x, 2) with the default mode rounds negatives toward -∞ and does not match EVEN. Substituting one for the other on a column containing negatives changes results.
• FLOOR.MATH, FLOOR.PRECISE — the downward family, for contrast: they round toward -∞, where EVEN rounds away from zero. The worksheet's rounding functions do not share a single direction convention, and knowing which convention a given one uses is most of the skill in choosing between them.
• ROUNDUP — rounds away from zero to a digit position, the same direction convention as EVEN with a different grid.
• MROUND(x, 2) — rounds to the nearest multiple of 2 rather than away from zero, so it disagrees with EVEN on every argument in the lower half of each tread.
• ISEVEN — the predicate, which tests parity rather than producing it, and which truncates rather than rounding.

Named variants

No named variants are recorded yet.