ROUNDUP

What it does

ROUNDUP(number, num_digits)

ROUNDUP(number, num_digits) rounds away from zero when a nonzero part is discarded. Positive digit counts address places after the decimal point, zero the integer position, and negative counts places to its left.

Try it

=ROUNDUP(-7.21,1) returns -7.3; =ROUNDUP(721,-1) returns 730. “Up” means a larger magnitude, so a negative result becomes more negative.

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, ROUNDUP returns #NUM! for the overflowing decimal result. 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.
3. If a nonzero digit was discarded, convert one unit separately to binary64, add it to the truncated magnitude with the stored 64-bit-significand operation from the variance recipe, and restore the sign. Do not convert the already-incremented decimal in one step: that has a different rounding history.
4. Suppress the added unit if it is subnormal. For positive inputs also suppress it when the stored reading minus the stored truncation is below 2^-1026. Negative inputs do not use that distance test. Out-of-range positive counts add no unit; negative ones give #NUM! when a unit would be required.

Worked: ROUNDUP(-1.125,2) truncates its exact reading to -1.12. The separately converted 1.12 and 0.01 add to the recorded 1.1300000000000001, whose sign is then restored. The final value is -1.1300000000000001, rather than the nearest binary64 conversion of the decimal -1.13.

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(ROUNDUP, "ROUNDUP", 2, DIGITS, roundup)

/// ROUNDUP: as ROUND, away from zero whenever a dropped digit is not zero.
fn roundup(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    numeric(ROUNDUP, arguments, services, |site, n| {
        directed(site, n[0], n[1], Direction::AwayFromZero)
    })
}

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