finance.markup-price

pub fn markup_price(cost: &Money, basis_points: i64, basis: &str, mode: &str) -> Money

// PricingBasis is a string in Rust, one of: "margin", "markup".
// Parameters take it as &str and results hold it as String.

fune!(finance.markup-price@^1);  // then call markup_price(…)

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::{money, money_from_value, money_to_value, Money};  ← from money.amount ^1.0.0 · built alongside by fune

const MAX_SAFE: i128 = 9_007_199_254_740_991;

/// The selling price that hits a target margin or markup on `cost`.
///
/// Margin divides by the price and markup by the cost, so the same 5000 basis
/// points means 200.00 or 150.00 on a cost of 100.00; the basis is explicit.
///
/// # Panics
/// Panics on a negative cost, a margin of 100% or more, a markup below -100%,
/// an unknown basis, or a calculation beyond 2^53 - 1.
pub fn markup_price(cost: &Money, basis_points: i64, basis: &str, mode: &str) -> Money {
    if cost.minor < 0 {
        panic!("cost must not be negative, received {}", cost.minor);
    }
    let (numerator, denominator): (i128, i128) = match basis {
        "markup" => {
            if basis_points < -10000 {
                panic!("a markup of {} basis points gives a negative price", basis_points);
            }
            (cost.minor as i128 * (10000 + basis_points as i128), 10000)
        }
        "margin" => {
            if basis_points >= 10000 {
                panic!("a margin of {} basis points has no finite price", basis_points);
            }
            (cost.minor as i128 * 10000, 10000 - basis_points as i128)
        }
        other => panic!("unknown pricing basis \"{}\"", other),
    };
    // i64 could go further, but TypeScript cannot, and all three must agree.
    if numerator > MAX_SAFE {
        panic!("the price calculation exceeds 2^53 - 1");
    }
    money(
        round_div(numerator as i64, denominator as i64, mode),
        &cost.currency,
    )
}

pub fn fune_vector(args: &[Value]) -> Value {
    money_to_value(&markup_price(
        &money_from_value(&args[0]),
        args[1].as_i64(),
        args[2].as_str(),
        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 finance.markup-price

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./finance.markup-price-1.0.0-rust.fune, or fetch it from a terminal with fune pull finance.markup-price@1.0.0:rust.

The whole function, every language, is one file too: finance.markup-price-1.0.0.fune, 15,136 bytes, sha256 bfaa16042b3d9d9018be2d19e2ead48b179a814facd04d7ea13796de6f55ac33. It installs into a project of any language.

// fune: before finance.markup-price

// fune: after finance.markup-price

// fune: replace math.round-div in finance.markup-price
// fune: replace money.amount in finance.markup-price

// fune: step finance.markup-price after <n|label>

More from the author

Confusing the two is the classic pricing mistake - a retailer aiming for a 40% margin who adds 40% to cost gets a 28.57% margin - so the basis is a required argument with no default.

The price is rounded once, to the currency's minor unit, with the `math.round-div` mode you pass. Rounding can land a fraction of a basis point either side of the target. Use `up` for a margin or markup target you must not fall below: 1,000 at a 30% margin is 1,428.57..., and `down` gives 1,428, which is a 29.97% margin, while `up` gives 1,429.

The results agree with `finance.margin`: several vectors here are that capability's vectors run backwards (60.00 at a 40% margin is 100.00; 6.99 at a 30.03% margin is 9.99; 120.00 at a -20% margin is 100.00), and feeding the price back into `finance.margin` returns the target to within its rounding.

Edges: a margin of 100% or more has no finite price and is an error. A negative margin or markup is a price below cost and is allowed (clearance, loss leaders); a markup of -100% is a price of zero, and below that the price would be negative, which is an error. A negative cost is an error. Zero cost gives a zero price on either basis. `cost × 10000` (or `cost × (10000 + markup)`) must stay within 2^53 - 1, which is costs up to about 900 million pounds; beyond that the calculation is refused rather than rounded.

Files