insurance.loss-ratio Unreviewed

pub fn loss_ratios(earned_premium: &Money, incurred_claims: &Money, expenses: &Money, mode: &str) -> LossRatios

/// The three ratios, each in basis points: 6500 = 65%.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LossRatios {
    pub loss_ratio_basis_points: i64,
    pub expense_ratio_basis_points: i64,
    /// claims plus expenses over premium, rounded once; may differ by 1 from the sum of the other two
    pub combined_ratio_basis_points: i64,
}

fune!(insurance.loss-ratio@^1);  // then call loss_ratios(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_round_div::round_div;  ← from math.round-div ^1.0.0 · built alongside by fune
use super::money_amount::{assert_same_currency, money_from_value, Money};  ← from money.amount ^1.0.0 · built alongside by fune

/// Loss, expense and combined ratios against earned premium, in basis points.
///
/// The combined ratio is worked from claims plus expenses, rounded once, not
/// by adding the two rounded ratios, so it can differ from their sum by one
/// basis point: 1.00 and 1.00 on 3.00 are 33.33% each but 66.67% together.
///
/// # Panics
/// Panics on mixed currencies or an earned premium that is not positive.
pub fn loss_ratios(earned_premium: &Money, incurred_claims: &Money, expenses: &Money, mode: &str) -> LossRatios {
    assert_same_currency(earned_premium, incurred_claims);
    assert_same_currency(earned_premium, expenses);
    if earned_premium.minor <= 0 {
        panic!("earnedPremium must be more than zero, received {}", earned_premium.minor);
    }
    let p = earned_premium.minor;
    LossRatios {
        loss_ratio_basis_points: round_div(incurred_claims.minor * 10000, p, mode),
        expense_ratio_basis_points: round_div(expenses.minor * 10000, p, mode),
        combined_ratio_basis_points: round_div((incurred_claims.minor + expenses.minor) * 10000, p, mode),
    }
}

pub fn loss_ratios_to_value(r: &LossRatios) -> Value {
    Value::obj(vec![
        ("lossRatioBasisPoints", Value::Int(r.loss_ratio_basis_points)),
        ("expenseRatioBasisPoints", Value::Int(r.expense_ratio_basis_points)),
        ("combinedRatioBasisPoints", Value::Int(r.combined_ratio_basis_points)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    loss_ratios_to_value(&loss_ratios(
        &money_from_value(&args[0]),
        &money_from_value(&args[1]),
        &money_from_value(&args[2]),
        args[3].as_str(),
    ))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 2 dependencies, pins them in fune.lock, downloads only the Rust 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. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add insurance.loss-ratio

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./insurance.loss-ratio-1.0.1-rust.fune, or fetch it from a terminal with fune pull insurance.loss-ratio@1.0.1:rust.

The whole function, every language, is one file too: insurance.loss-ratio-1.0.1.fune, 13,994 bytes, sha256 ead1e8afc8af61bdb43581a65bd1f4a3c88a8b48c6b97e1f1a676c0c8e05590e. It installs into a project of any language.

// fune: before insurance.loss-ratio

// fune: after insurance.loss-ratio

// fune: replace math.round-div in insurance.loss-ratio
// fune: replace money.amount in insurance.loss-ratio

// fune: step insurance.loss-ratio after <n|label>

More from the author

Below 10000 (100%) the book made an underwriting profit.

## Choices

- Everything is over **earned** premium, the usual UK and IFRS 17 practice and what most published combined ratios use. US statutory reporting puts expenses over *written* premium instead; for that, call this twice or work the expense ratio with `math.round-div` directly. - The combined ratio is worked from the totals and rounded once, not by adding two rounded ratios, so it can differ by one basis point from their sum (1.00 and 1.00 on 3.00: 33.33% + 33.33%, combined 66.67%). If a report must add up, show the combined ratio from this and derive the display of the others from it, not the other way round. - Incurred claims may be negative in a period where reserve releases outweigh new claims (see `insurance.claim-reserve` for incurred movements), and the ratio is then negative rather than refused. - Earned premium must be more than zero: a ratio over nothing is undefined. - What counts as an expense (commission, acquisition costs, claims handling costs) is the caller's reporting policy.

## 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