AMORLINC

What it does

AMORLINC(cost, date_purchased, first_period, salvage, period, rate, [basis])

The schedule is as simple as depreciation gets:

annual charge      = cost × rate
first charge (period 0) = cost × rate × f,  where f = fraction of the first period held
every later charge = cost × rate,  until the depreciable basis (cost − salvage) runs out
final charge       = whatever is left of the depreciable basis

f is a day-count fraction from date_purchased to first_period, computed on the chosen basis. When the asset is bought exactly on first_period the fraction is 1 and the first period is a full one.

The only genuinely interesting quantity is f, and f is a YEARFRAC computation under a different name. Everything else is a constant repeated until the money runs out.

period is 0-based — period 0 is the prorated first period. This is the same convention as AMORDEGRC and the opposite of DB and DDB, which count from 1. Mixing the two conventions in one model is the most common way to get a plausible but wrong depreciation schedule.

Arguments

AMORLINC(cost, date_purchased, first_period, salvage, period, rate, [basis])

first_period is the argument readers misread most often. It is not the length of the first period and it is not the start of anything: it is the date on which the first accounting period ends. The prorated fraction is measured from date_purchased up to it.

The basis table for this function has four rows, not five. Microsoft's Learn page gives:

Date arguments are Excel date serials in numeric slots. Microsoft's page carries the standard warning that dates should come from DATE or from other formulas rather than being typed as text; ordinary coercion rules are in Coercion and lifting.

Try it

Quirks

Result and edge cases

Returns a Number: the charge for the requested period, in the units of cost.

• Period 0 is the prorated one. Period 1 is a full annual charge even when the asset was bought a week before first_period.
• The schedule terminates on the depreciable basis. Charges continue at cost × rate until the cumulative total reaches cost − salvage; the final period takes only the remainder, and every period after that returns 0 rather than an error.
• salvage = cost gives a depreciable basis of zero, so period 0 returns 0.
• date_purchased = first_period gives a fraction of exactly 1 — a full first period, with no proration.
• Empty, missing and error arguments follow the shared call model; see The value universe.

Errors

Microsoft's Learn page documents no error conditions for this function at all — it carries the parameter table, the basis table, the proration sentence and the date-system notes, and stops. Its sibling's page documents a #NUM! band; this one documents nothing. That silence is itself a finding: there is no published statement of what AMORLINC does with a negative cost, a salvage above cost, or a basis of 2, even though the basis table's omission of 2 implies the last one.

How to implement

Numerical notes

1. The only computed quantity is the first-period fraction. Everything downstream is repeated multiplication and subtraction of a constant, so an implementation's accuracy is entirely the accuracy of its day count.
2. Basis 1 ("Actual") is under-specified, as everywhere in this category. The reference engine splits the interval at calendar-year boundaries and divides each piece by that year's own length; other constructions are defensible and give different fractions across a leap day. See YEARFRAC.
3. The schedule must be iterated. The last charge depends on the cumulative total, so there is no closed form for period n; the cost is O(period), and an error in the first fraction propagates to the termination point of the whole schedule.

Rust code

26 amorlinc_fn "AMORLINC" (6, 7) [V "cost", V "date_purchased", V "first_period", V "salvage", V "period", V "rate", V "basis"] |s, a, sv| {
    let purchased = date_1900(s, a, 1, sv)?;
    let first = date_1900(s, a, 2, sv)?;
    let basis = if given(a, 6) { num(s, a, 6)? } else { 0.0 };
    amor_out(s, amor::amorlinc_kernel(num(s, a, 0)?, purchased, first, num(s, a, 3)?, num(s, a, 4)?, num(s, a, 5)?, Some(basis)))
}

fn normalize_amorlinc_period(value: f64) -> Result<i64, AmorDepreciationEvalError> {
    if !value.is_finite() || value < 0.0 {
        return Err(AmorDepreciationEvalError::Domain(WorksheetErrorCode::Num));
    }
    if value.abs() <= EPSILON {
        Ok(0)
    } else if value < 1.0 {
        Ok(1)
    } else {
        Ok(value.floor() as i64)
    }
}

pub fn amorlinc_kernel(
    cost: f64,
    date_purchased: f64,
    first_period: f64,
    salvage: f64,
    period: f64,
    rate: f64,
    basis: Option<f64>,
) -> Result<f64, AmorDepreciationEvalError> {
    if !cost.is_finite() || !salvage.is_finite() || !rate.is_finite() {
        return Err(AmorDepreciationEvalError::Domain(WorksheetErrorCode::Num));
    }
    if cost <= 0.0 || salvage < 0.0 || salvage > cost || rate <= 0.0 {
        return Err(AmorDepreciationEvalError::Domain(WorksheetErrorCode::Num));
    }

    let purchase = parse_date_serial(date_purchased)?;
    let first = parse_date_serial(first_period)?;
    let basis = parse_basis(basis.unwrap_or(0.0))?;
    let normalized_period = normalize_amorlinc_period(period)?;
    let annual_depreciation = cost * rate;
    let initial_fraction = first_period_fraction(purchase, first, basis)?;
    // Excel multiplies the rate by the fraction first (dc-j9k: cost*(rate*fraction) matches 78 of
    // the 80 AMORLINC readings of sheet dcj9k_closed_form, and the other two were the basis-1
    // fraction; (cost*rate)*fraction matched 68).
    let first_depreciation = cost * (rate * initial_fraction);
    let depreciable_basis = cost - salvage;

    if normalized_period == 0 {
        return Ok(first_depreciation.min(depreciable_basis).max(0.0));
    }

    let mut remaining = (depreciable_basis - first_depreciation).max(0.0);
    for current in 1..=normalized_period {
        let depreciation = remaining.min(annual_depreciation).max(0.0);
        if current == normalized_period {
            return Ok(depreciation);
        }
        remaining = (remaining - depreciation).max(0.0);
        if remaining <= EPSILON {
            return Ok(0.0);
        }
    }
    Ok(0.0)
}

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

Version differences

No comparison between specific Excel builds is recorded here yet. This does not establish that all builds behave alike.

Alternatives

Relationships

• AMORDEGRC — the accelerated sibling, with the same seven arguments, the same proration and the same four-row basis table. Microsoft describes the difference in one clause: AMORDEGRC applies "a depreciation coefficient … depending on the life of the assets". Set that coefficient to 1 and remove the end-of-life 50/100 per cent steps and you have this function.
• SLN — the plain straight-line function. SLN(cost, salvage, life) is a flat (cost − salvage)/life. AMORLINC differs on three axes at once: it charges cost × rate rather than (cost − salvage) × rate, it prorates the first period by calendar date, and it truncates the last charge at the depreciable basis instead of dividing it evenly.
• DB — the other function in Excel that prorates a partial first year, but by a month count rather than by a date pair, and on a declining rather than a linear balance.
• DDB, VDB, SYD — the rest of the depreciation category, all 1-based in period and none of them date-aware.
• YEARFRAC — the standalone day-count engine that computes the same first-period fraction this function needs.
• Confused with: SLN (above). The two answer the same accounting question and give different numbers, because SLN spreads cost − salvage while AMORLINC charges rate on cost and stops when it hits salvage.

Named variants

No named variants are recorded yet.