manufacturing.yield-scrap

def input_for_yield(required_output: int, yield_basis_points: int) -> YieldPlan

@dataclass(frozen=True)
class YieldPlan:
    """What to start and what the process is expected to lose."""

    #: units to start: the smallest whole number whose yield covers requiredOutput
    input: int
    #: input minus requiredOutput: the units the yield allows to be lost
    scrap: int

from fune.manufacturing.yield_scrap import input_for_yield  # manufacturing.yield-scrap@^1

from .manufacturing_yield_scrap_types import YieldPlan
from .math_round_div import round_div  ← from math.round-div ^1.0.0 · built alongside by fune

MAX_OUTPUT = (2**53 - 1) // 10000


def input_for_yield(required_output: int, yield_basis_points: int) -> YieldPlan:
    """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.
    """
    if (
        isinstance(required_output, bool)
        or not isinstance(required_output, int)
        or required_output < 0
        or required_output > MAX_OUTPUT
    ):
        raise ValueError(
            "requiredOutput must be a whole number of units from 0 to %d, received %r" % (MAX_OUTPUT, required_output)
        )
    if (
        isinstance(yield_basis_points, bool)
        or not isinstance(yield_basis_points, int)
        or yield_basis_points < 1
        or yield_basis_points > 10000
    ):
        raise ValueError("yieldBasisPoints must be a whole number from 1 to 10000, received %r" % (yield_basis_points,))
    input_units = round_div(required_output * 10000, yield_basis_points, "up")
    return YieldPlan(input=input_units, scrap=input_units - required_output)

Install

fune build

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

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

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