ROUNDDOWN

What it does

ROUNDDOWN(number, num_digits)

ROUNDDOWN(number, num_digits) rounds toward zero by discarding the unwanted decimal part. Positive digit counts address places after the decimal point, zero the integer position, and negative counts places to its left.

Try it

=ROUNDDOWN(-7.29,1) returns -7.2; =ROUNDDOWN(729,-1) returns 720. “Down” means toward zero.

Quirks

The recorded functions first read fifteen significant decimal digits. Asking to retain more digits can therefore change an input that mathematically needs no rounding. The recorded ROUNDDOWN(283025097725723.5,0) returns 283025097725724, showing that the preliminary reading can move the number upward before truncation. Huge digit counts have recorded integer-conversion behaviour rather than a simple “keep everything” rule. Near the normal-range boundary and overflow, worksheet publication needs separate handling.

The exact-cell minimum normal input 0x0010000000000000 has a recorded early return of 0x000ffffffffffffa, even at zero requested digits. That return happens before ordinary digit rounding. At the upper end, the current model can publish a tagged NaN bit pattern as a worksheet number. See the packing rules and worked encodings.

How to implement

The current worksheet wrapper reads numeric arguments in order and flushes subnormal numeric operands to zero. Return zero for a zero number before finding its decimal exponent. The following steps start with a finite, nonzero admitted input. The stored-arithmetic chapter explains exact binary decoding and significand rounding.

First construct the number’s fifteen-significant-digit reading. Extract the exact binary64 value and find its decimal exponent e by comparisons with exact powers of ten, so 10^e <= abs(x) < 10^(e+1). Put s=14-e. When abs(s)<=27, evaluate abs(x)*10^s (or abs(x)/10^(-s)) with a 64-bit significand and extended exponent range, rounding to nearest/even. Do not store that scaled value to binary64 before the integer decision. Round it to an integer: exact halves go down for ROUND’s reading, up for the directed functions’ readings. Retain the sign and the exact decimal value integer*10^(-s).

This reading step is a measured reconstruction with a known counterexample even inside the stated scale range. For abs(s)>27, Excel’s scaling is still open; the current code falls back to exact binary64-to-decimal rounding to fifteen digits. That fallback is a candidate, not an identified Excel stage.

1. Truncate the magnitude of num_digits and retain its low sixteen bits, then restore the sign. Magnitudes at least 2^32, or low bits at least 32768, select an out-of-range sentinel of 100 places with the original sign.
2. Before digit rounding, check the special initial-reading return described below. If it applies, return its packed result immediately. Otherwise truncate the exact decimal reading at unit 10^(-D), then convert that truncation to nearest binary64, using the overflow packing exception when required.
3. Return that stored truncation without adding a unit. Flush final subnormal results to zero, apart from the special initial-reading path below.

Worked: x=-7.29, D=1 retains 72 tenths of the magnitude and restores the negative sign, giving -7.2. A count of 65537 uses low bits equal to one, so it selects the same decimal position. This conversion rule is distinct from ROUND’s signed 32-bit count.

The current boundary reconstruction handles a normal input below twice the minimum normal value whose initial reading becomes subnormal: convert twice the reading (a normal number) and decrement its encoded exponent field by one, retaining the sign and significand. This reproduces the observed packing rather than an ordinary subnormal conversion. Other final subnormals still flush. The large-scale reading and remaining last-bit discrepancies stay open; consult the dated failure breakdown.

Rust code

call(ROUNDDOWN, "ROUNDDOWN", 2, DIGITS, rounddown)

/// ROUNDDOWN: as ROUND, toward zero.
fn rounddown(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    numeric(ROUNDDOWN, arguments, services, |site, n| {
        directed(site, n[0], n[1], Direction::TowardZero)
    })
}

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-ROUNDDOWN-001: build 19929 versus build 20430; 3 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.

Retained controls from the indexed captures:

These are earlier recorded answers, not new Excel runs or an additional cross-build comparison. The function JSON retains each source locator, exact argument bits where available, and input-route status. Call notation does not imply that captured binary64 values were entered as decimal formula literals.

Alternatives

ROUND chooses a nearest decimal; MROUND chooses a multiple. INT floors negatives; TRUNC removes their fraction toward zero.

Named variants

No named variants are recorded yet.