manufacturing.yield-scrap

export function inputForYield(requiredOutput: number, yieldBasisPoints: number): YieldPlan

/** What to start and what the process is expected to lose. */
export interface YieldPlan {
  /** units to start: the smallest whole number whose yield covers requiredOutput */
  readonly input: number;
  /** input minus requiredOutput: the units the yield allows to be lost */
  readonly scrap: number;
}

import { inputForYield } from "#fune/manufacturing.yield-scrap@^1";

import { roundDiv } from "./math_round_div.ts";  ← from math.round-div ^1.0.0 · built alongside by fune
import { type YieldPlan } from "./manufacturing_yield_scrap_types.ts";

const MAX_OUTPUT = Math.floor(Number.MAX_SAFE_INTEGER / 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.
 */
export function inputForYield(requiredOutput: number, yieldBasisPoints: number): YieldPlan {
  if (!Number.isInteger(requiredOutput) || requiredOutput < 0 || requiredOutput > MAX_OUTPUT) {
    throw new RangeError(`requiredOutput must be a whole number of units from 0 to ${MAX_OUTPUT}, received ${requiredOutput}`);
  }
  if (!Number.isInteger(yieldBasisPoints) || yieldBasisPoints < 1 || yieldBasisPoints > 10000) {
    throw new RangeError(`yieldBasisPoints must be a whole number from 1 to 10000, received ${yieldBasisPoints}`);
  }
  const input = roundDiv(requiredOutput * 10000, yieldBasisPoints, "up");
  return { input, scrap: input - requiredOutput };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the TypeScript 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 manufacturing.yield-scrap

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

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