SLN

What it does

SLN(cost, salvage, life)

SLN(cost,salvage,life) returns one period’s straight-line depreciation: an equal share of the depreciable amount over the stated life.

Try it

=SLN(1200,200,5) returns 200. The depreciable amount is 1000 and five equal periods divide it into shares of 200.

Quirks

Life is a count of periods, with the same time unit used for the requested allowance. There is no current-period argument and no accumulated balance. The current kernel admits either sign of cost and salvage and any nonzero life, including negative life; it returns #DIV/0! for exactly zero life. That arithmetic admission is broader than an ordinary asset-depreciation schedule.

The subtraction and division have different rounding steps. A subnormal difference is retained until division, while a final subnormal amount is published as positive zero. Nonfinite numeric inputs or a nonfinite result give #NUM! in this kernel; failed worksheet numeric conversion is handled outside it. Microsoft's opened page defines the arguments but does not enumerate these edge codes.

How to implement

1. Validate finite numeric inputs. Reject life=0 with #DIV/0!; do not introduce a positive-life guard when reproducing the current route.
2. Compute difference=cost-salvage with ordinary binary64 subtraction. Preserve a subnormal difference at this point.
3. Compute result=R(difference/life) with the stored operation: round the quotient to a 64-bit significand, then store to binary64. A single ordinary binary64 divide is a different graph.
4. If the result is nonfinite, return #NUM!. If its magnitude is below the minimum normal binary64 value, return positive zero. Otherwise publish it.

For 1200,200,5, the difference is exactly 1000 and the quotient exactly 200. Changing life to -5 makes this code return -200; it does not create a different depreciation method. Changing salvage changes the depreciable amount before the division.

The source attributes this quotient and final-flush route to retained Excel build-20430, compatibility-version-2 probes. Its input conversion and worksheet context are separate obligations; this recipe is not a published Handbook conformance suite.

Rust code

21 sln_fn "SLN" (3, 3) [V "cost", V "salvage", V "life"] |s, a, sv| {
    out(s, dep::sln_kernel(num(s, a, 0)?, num(s, a, 1)?, num(s, a, 2)?))
}

pub fn sln_kernel(cost: f64, salvage: f64, life: f64) -> Result<f64, WorksheetErrorCode> {
    validate_finite(&[cost, salvage, life])?;
    if life == 0.0 {
        return Err(WorksheetErrorCode::Div0);
    }
    // SLN admits either sign and every nonzero life. The observed quotient is
    // rounded through the existing extended-precision division substrate.
    // Preserve subnormal differences until division: only the published result
    // is flushed to positive zero (Excel 16.0 build 20430, CV2, W111 probes).
    let result = crate::ported::excel_numeric::excel_x87_div(cost - salvage, life);
    if !result.is_finite() {
        Err(WorksheetErrorCode::Num)
    } else if result.abs() < f64::MIN_POSITIVE {
        Ok(0.0)
    } else {
        Ok(result)
    }
}

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

SYD front-loads the allowance; DB and DDB use declining-balance methods.

Named variants

No named variants are recorded yet.