NOMINAL

What it does

NOMINAL(effect_rate, npery)

NOMINAL(effect_rate, npery) converts an effective annual rate into the nominal annual rate compounded npery times a year that would produce it.

NOMINAL = npery × ( (1 + effect_rate)^(1/npery) − 1 )

The construction reads directly: (1 + effect_rate)^(1/npery) is the per-period growth factor whose npery-fold repetition gives one year's growth; subtracting 1 turns it into a per-period rate; and multiplying by npery restates it as an annual figure by the nominal convention — that is, by simple multiplication, ignoring the compounding it has just accounted for. That deliberate inconsistency is the nominal convention, and it is why nominal rates are always at or below their effective counterparts.

NOMINAL is the exact inverse of EFFECT:

NOMINAL(EFFECT(r, n), n) = r        and        EFFECT(NOMINAL(e, n), n) = e

in exact arithmetic. In binary64 the round trip is accurate but not bitwise idempotent; see Numerical notes.

Domain and range: for effect_rate > 0 and integer npery ≥ 1, the result is positive, strictly less than effect_rate for every npery > 1, and strictly decreasing in npery. At npery = 1 it equals effect_rate.

The limit as npery → ∞ is ln(1 + effect_rate) — the continuously-compounded equivalent, the force of interest. As with EFFECT, that limit is approached and never reached, because npery is truncated to an integer.

Arguments

Two documented rules, identical to EFFECT's:

1. npery is truncated to an integer.
2. npery must be at least 1 and effect_rate must be greater than zero; both violations are #NUM!.

npery is not restricted to the conventional 1, 2, 4, 12; weekly (52) and daily (365) are ordinary inputs.

Try it

Quirks

Result and edge cases

Returns Number — a nominal annual rate as a decimal fraction.

• npery = 1 returns effect_rate, up to floating-point rounding; the computation still forms (1 + e)^1 − 1 rather than short-circuiting, so exact bit recovery is not guaranteed.
• effect_rate ≤ 0 is an error, not a computation. As with EFFECT, this is a documented restriction rather than a mathematical one: the expression is well defined at e = 0 (giving 0) and for small negative e. Excel refuses both. Negative-rate environments therefore need the formula written out.
• Large npery approaches LN(1 + effect_rate) from above and stays finite.
• Non-integer npery truncates toward zero, so 0.9 becomes 0 and is #NUM!.
• Empty, missing and error arguments follow the shared call model; see The value universe and Coercion and lifting.

Errors

As documented on Microsoft's NOMINAL page:

How to implement

Numerical notes

The evaluation npery × ((1 + effect_rate)^(1/npery) − 1) has a cancellation problem that is worse than EFFECT's, because the root extraction drives the intermediate toward 1 as npery grows.

For a 5% effective rate compounded daily, (1.05)^(1/365) ≈ 1.000133..., and subtracting 1 from a value that close to 1 discards roughly four significant decimal digits before the multiplication by 365 restores the magnitude. The relative error of the answer is the relative error of the subtraction, and no amount of care in the multiplication recovers it. The larger npery is — that is, the closer the function gets to its continuous limit — the more accuracy the naive form loses.

The stable form uses the same primitive pair as the rest of this family:

NOMINAL = npery × expm1( log1p(effect_rate) / npery )

log1p computes ln(1 + e) without forming 1 + e, and expm1 computes e^x − 1 without forming the near-1 intermediate that cancels. This holds full relative accuracy for every admissible npery, and it makes the continuous limit visible directly: as npery → ∞, npery·expm1(L/npery) → L = log1p(effect_rate). The expm1/log1p treatment descends from the fdlibm lineage that modern libms inherit.

1. It calls the plain floating-point power, whereas its inverse EFFECT calls the worksheet POWER kernel. Two functions that are exact inverses of one another routed through different power implementations will not round-trip cleanly, and the discrepancy will look like noise rather than like a bug.
2. The exponent is formed as 1.0/npery, which is inexact for every npery that is not a power of two — so npery = 12 and npery = 365 both introduce a rounding before the power is even evaluated.

The Handbook does not claim what Excel does internally.

Rust code

14 nominal_fn "NOMINAL" (2, 2) [V "effect_rate", V "npery"] |s, a, sv| {
    tv_out(s, tv::nominal(num(s, a, 0)?, num(s, a, 1)?))
}

pub fn nominal(effect_rate: f64, periods_per_year: f64) -> Result<f64, FinancialError> {
    validate_finite(&[effect_rate, periods_per_year])?;
    let periods = periods_per_year.trunc();
    if effect_rate <= 0.0 || periods < 1.0 {
        return Err(FinancialError::Num);
    }
    // W109 G6-14 / BUG-FUNC-045: NOMINAL has two legacy x87 power routes after
    // truncating npery. For n<=2 (equivalently reciprocal exponent >=0.5), the
    // base and exponent stay register-continuous through FYL2X/F2XM1/FSCALE;
    // for n>=3, Excel uses the stored-ln/product `excel_pow_chain` substrate.
    // Both routes store the completed power to binary64 before subtracting one,
    // then multiply by the truncated period count. The `1+effect` base itself
    // is an x87 double-rounded add (targeted live discriminators 4/4).
    let base = excel_x87_add(1.0, effect_rate);
    let reciprocal = 1.0 / periods;
    let powered = if periods <= 2.0 {
        excel_pow_x87_direct(base, reciprocal)
    } else {
        excel_pow_chain(base, reciprocal)
    };
    let result = periods * (powered - 1.0);
    if result.is_finite() {
        Ok(result)
    } else {
        Err(FinancialError::Num)
    }
}

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-NOMINAL-001: build 20228 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

• EFFECT — the exact inverse. The two carry identical arguments, identical domain restrictions and identical error conditions; only the direction differs. Round-tripping through both is the natural self-test.
• LN — the continuous limit, LN(1 + effect_rate), which NOMINAL approaches as npery grows.
• RRI — the compound rate implied by observed values rather than translated from a quote. RRI(npery, 1, 1 + effect_rate) computes exactly the per-period rate NOMINAL divides out, which makes it an independent route to the same intermediate.
• RATE — the annuity solver. Unrelated in mechanism (RATE iterates, NOMINAL is closed form) but frequently confused because both return "a rate".
• Confused with: APR versus APY. NOMINAL maps APY back to APR. Which one a disclosure regime requires is a legal question.
• FV / PMT / PV — the annuity functions consume a periodic rate. NOMINAL(e, 12)/12, not NOMINAL(e, 12), is what belongs in a monthly FV call. Passing the annual nominal rate to a monthly annuity is one of the most common financial-modelling errors in spreadsheets, and no function in the family can detect it.

Named variants

No named variants are recorded yet.