manufacturing.yield-scrap

pub fn input_for_yield(required_output: i64, yield_basis_points: i64) -> YieldPlan

/// What to start and what the process is expected to lose.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct YieldPlan {
    /// units to start: the smallest whole number whose yield covers requiredOutput
    pub input: i64,
    /// input minus requiredOutput: the units the yield allows to be lost
    pub scrap: i64,
}

fune!(manufacturing.yield-scrap@^1);  // then call input_for_yield(…)

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

const MAX_OUTPUT: i64 = ((1i64 << 53) - 1) / 10000;

/// Starts needed for a good output at a yield, rounded up in integers so an
/// exact answer (95 at 95% is 100) never becomes 101 through a float.
///
/// # Panics
/// Panics on a negative or oversized output, or a yield outside 1-10000.
pub fn input_for_yield(required_output: i64, yield_basis_points: i64) -> YieldPlan {
    if !(0..=MAX_OUTPUT).contains(&required_output) {
        panic!(
            "requiredOutput must be a whole number of units from 0 to {}, received {}",
            MAX_OUTPUT, required_output
        );
    }
    if !(1..=10000).contains(&yield_basis_points) {
        panic!("yieldBasisPoints must be a whole number from 1 to 10000, received {}", yield_basis_points);
    }
    let input = round_div(required_output * 10000, yield_basis_points, "up");
    YieldPlan {
        input,
        scrap: input - required_output,
    }
}

pub fn yield_plan_to_value(plan: &YieldPlan) -> Value {
    Value::obj(vec![("input", Value::Int(plan.input)), ("scrap", Value::Int(plan.scrap))])
}

pub fn fune_vector(args: &[Value]) -> Value {
    if let Value::Float(f) = &args[0] {
        panic!("requiredOutput must be a whole number of units from 0 to {}, received {}", MAX_OUTPUT, f);
    }
    if let Value::Float(f) = &args[1] {
        panic!("yieldBasisPoints must be a whole number from 1 to 10000, received {}", f);
    }
    yield_plan_to_value(&input_for_yield(args[0].as_i64(), args[1].as_i64()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 1 dependency, 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 manufacturing.yield-scrap

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

The whole function, every language, is one file too: manufacturing.yield-scrap-1.0.0.fune, 9,473 bytes, sha256 ab5b9cd98e14ed85a740cf8e559162cb6e2553b2573427c955d5584c4f4351aa. It installs into a project of any language.

// fune: before manufacturing.yield-scrap

// fune: after manufacturing.yield-scrap

// fune: replace math.round-div in manufacturing.yield-scrap

// fune: step manufacturing.yield-scrap after <n|label>

More from the author

With a 95% yield, 100 good units need 106 starts (105.26 rounded up), and the plan allows 6 to be scrapped.

**Rounded up, exactly.** You cannot start part of a unit, and rounding down would leave you short, so the input is always rounded up. The division is done in integers (`requiredOutput * 10000 / yieldBasisPoints`, rounded up by `math.round-div`), never as a float: 563 good units at a 56.3% yield need exactly 1000 starts, but `563 / 0.563` in floating point is 1000.0000000000001, and its ceiling is 1001.

**Scrap is the allowance.** At the stated yield, `input` starts are expected to give at least `requiredOutput` good units and fewer than `requiredOutput + 1` (the rounding never buys a whole extra unit), so `scrap` is the whole number of units the plan expects to lose. The actual scrap is whatever the process does on the day.

**Yield is in basis points**, 1 to 10000 (0.01% to 100%). A yield of 0 is an error: no number of starts gives any good output. A required output of 0 needs no input.

For a routing with several steps, apply this from the last step backwards: the input of one step is the required output of the one before, rounded up at each step, because each step has to start whole units.

Files