insurance.no-claims-discount Unreviewed

def next_no_claims_discount(scale: Sequence[NcdLevel], current_years: int, claims: int, protection: Optional[NcdProtection]) -> NcdOutcome

@dataclass(frozen=True)
class NcdLevel:
    """One step of an NCD scale."""

    #: claim-free years from which this level applies
    years: int
    #: discount at this level, 6500 = 65%
    discount_basis_points: int
    #: years held after 1, 2, 3... claims from this level; more claims than listed use the last
    step_back: List[int]

@dataclass(frozen=True)
class NcdProtection:
    """Protected NCD: claims up to a limit in a window leave the years untouched."""

    #: the most claims the protection allows in its window, e.g. 2 in 5 years
    claim_limit: int
    #: claims in the window, this year's included
    claims_in_window: int

@dataclass(frozen=True)
class NcdOutcome:
    """The NCD held at renewal."""

    years: int
    discount_basis_points: int
    #: true when protection kept the years from stepping back
    protection_applied: bool

from fune.insurance.no_claims_discount import next_no_claims_discount  # insurance.no-claims-discount@^1

from typing import Optional, Sequence

from .insurance_no_claims_discount_types import NcdLevel, NcdOutcome, NcdProtection


def _whole_at_least_zero(value: object, name: str) -> None:
    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
        raise ValueError("%s must be a whole number of 0 or more, received %s" % (name, value))


def _level_for(scale: Sequence[NcdLevel], years: int) -> NcdLevel:
    found = scale[0]
    for level in scale:
        if level.years <= years:
            found = level
    return found


def next_no_claims_discount(
    scale: Sequence[NcdLevel], current_years: int, claims: int, protection: Optional[NcdProtection]
) -> NcdOutcome:
    """The no-claims discount held at renewal.

    A claim-free year earns a year. A year with claims steps back to what the
    scale says for the level held and the number of claims, unless protected
    NCD covers them, in which case the years stay where they were (a year with
    a claim earns nothing). Years keep counting past the top of the scale; the
    discount is the highest level not above them.
    """
    if len(scale) == 0:
        raise ValueError("the NCD scale must not be empty")
    if scale[0].years != 0:
        raise ValueError("the NCD scale must start at 0 years")
    for i, level in enumerate(scale):
        _whole_at_least_zero(level.years, "years")
        if i > 0 and level.years <= scale[i - 1].years:
            raise ValueError("the NCD scale must be in ascending order of years")
        bp = level.discount_basis_points
        if isinstance(bp, bool) or not isinstance(bp, int) or bp < 0 or bp > 10000:
            raise ValueError("discountBasisPoints must be from 0 to 10000, received %s" % (bp,))
        previous = level.years
        for back in level.step_back:
            _whole_at_least_zero(back, "stepBack")
            if back > previous:
                raise ValueError(
                    "stepBack from %d years must not rise above the level or the step before it" % (level.years,)
                )
            previous = back
    _whole_at_least_zero(current_years, "currentYears")
    _whole_at_least_zero(claims, "claims")

    protection_applied = False
    if claims == 0:
        years = current_years + 1
    else:
        covered = False
        if protection is not None:
            _whole_at_least_zero(protection.claim_limit, "claimLimit")
            _whole_at_least_zero(protection.claims_in_window, "claimsInWindow")
            if protection.claims_in_window < claims:
                raise ValueError("claimsInWindow must include this year's claims")
            covered = protection.claims_in_window <= protection.claim_limit
        if covered:
            years = current_years
            protection_applied = True
        else:
            steps = _level_for(scale, current_years).step_back
            years = 0 if len(steps) == 0 else steps[min(claims, len(steps)) - 1]
    return NcdOutcome(
        years=years,
        discount_basis_points=_level_for(scale, years).discount_basis_points,
        protection_applied=protection_applied,
    )

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add insurance.no-claims-discount

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./insurance.no-claims-discount-1.0.1-python.fune, or fetch it from a terminal with fune pull insurance.no-claims-discount@1.0.1:python.

The whole function, every language, is one file too: insurance.no-claims-discount-1.0.1.fune, 40,702 bytes, sha256 27923c7f066fa8f20dfcb109cdee16c333ccada33e48bdf747d60c63e1e3d800. It installs into a project of any language.

# fune: before insurance.no-claims-discount

# fune: after insurance.no-claims-discount

# fune: step insurance.no-claims-discount after <n|label>

More from the author

Every insurer publishes its own scale: the discount at each number of claim-free years, and how far a claim steps you back. So the scale is an argument, not data in this package. Each level says:

- `years`: the claim-free years from which it applies (the scale starts at 0 and rises; gaps are fine: years 6 to 8 on a scale with levels at 5 and 9 get the 5-year discount); - `discountBasisPoints`: its discount; - `stepBack`: the years held after 1, 2, 3... claims in a year from this level. More claims than listed use the last entry, and an empty list means any claim goes back to 0. A step never rises above the level or the step before it.

The vectors use an illustrative scale (0, 30, 40, 50, 60, 65% up to 5 years, 70% at 9; one claim at 5 years steps back to 3), not any insurer's.

## The rules applied

- A claim-free year earns one year. Years keep counting beyond the top of the scale (UK insurers quote "9+ years"), and the discount is that of the highest level not above them. - A year with claims steps back by the level the policyholder held at the start of the year: 12 years with a top level at 9 uses the 9-year steps. - **Protected NCD**: when `claimsInWindow` (this year's claims included) is within `claimLimit` (commonly 2 claims in 5 years), the years stay as they were. The claim year earns no extra year, which is how protection is usually sold: it protects the discount, not the premium. Beyond the limit the normal step-back applies. Some insurers do let a protected claim year earn; add one to `years` if yours does.

Which claims count against NCD (a non-fault claim where costs are fully recovered usually does not) is for the caller to decide before calling. Applying the discount to a premium is `money.apply-rate` or `insurance.rating-factors`.

## Before you rely on this

**Not professional advice.** This capability calculates insurance figures from published rules. It is a software component for developers, not financial advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have an actuary review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified actuary has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

1.0.1 marks it unreviewed. The code and the tests are unchanged.

Files