manufacturing.batch-size

def economic_batch_quantity(annual_demand: int, annual_production_rate: int, setup_cost: Money, holding_cost: Money, mode: RoundingMode) -> int

from fune.manufacturing.batch_size import economic_batch_quantity  # manufacturing.batch-size@^1

from .math_integer_sqrt import integer_sqrt  ← from math.integer-sqrt ^1.0.0 · built alongside by fune
from .math_round_div import RoundingMode  ← from math.round-div ^1.0.0 · built alongside by fune
from .money_amount import Money, assert_same_currency  ← from money.amount ^1.0.0 · built alongside by fune

MAX_SAFE = 2**53 - 1
MAX_I64 = 2**63 - 1


def economic_batch_quantity(
    annual_demand: int,
    annual_production_rate: int,
    setup_cost: Money,
    holding_cost: Money,
    mode: RoundingMode,
) -> int:
    """Economic batch quantity, sqrt(2DSP / (H(P - D))), in whole units.

    The root is never taken in floating point: the floor is an exact integer
    square root and the rounding decision compares whole numbers.
    """
    if isinstance(annual_demand, bool) or not isinstance(annual_demand, int) or annual_demand < 0 or annual_demand > MAX_SAFE:
        raise ValueError("annualDemand must be a whole number of units, not negative, received %r" % (annual_demand,))
    if (
        isinstance(annual_production_rate, bool)
        or not isinstance(annual_production_rate, int)
        or annual_production_rate <= annual_demand
        or annual_production_rate > MAX_SAFE
    ):
        raise ValueError(
            "annualProductionRate must be a whole number greater than annualDemand, received %r"
            % (annual_production_rate,)
        )
    assert_same_currency(setup_cost, holding_cost)
    if setup_cost.minor < 0:
        raise ValueError("setupCost must not be negative, received %d" % setup_cost.minor)
    if holding_cost.minor <= 0:
        raise ValueError("holdingCost must be greater than zero, received %d" % holding_cost.minor)
    d, p, s = annual_demand, annual_production_rate, setup_cost.minor
    eight = 8 * d * s * p
    if eight > MAX_I64:
        raise ValueError(
            "annualDemand, setupCost and annualProductionRate are too large: 8 x D x S x P must stay within 2^63 - 1"
        )
    two = 2 * d * s * p
    m = holding_cost.minor * (p - d)
    n = integer_sqrt(two // m)
    odd = 2 * n + 1
    if mode == "down":
        return n
    if mode == "up":
        return n if n * n * m == two else n + 1
    if mode == "half-up":
        return n + 1 if odd * odd * m <= eight else n
    if mode == "half-even":
        half = odd * odd * m
        if half < eight:
            return n + 1
        if half > eight:
            return n
        return n if n % 2 == 0 else n + 1
    raise ValueError('unknown rounding mode "%s"' % (mode,))

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and its 3 dependencies, 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.batch-size

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

The whole function, every language, is one file too: manufacturing.batch-size-1.0.0.fune, 16,906 bytes, sha256 3df9331cc9df8c218c15180f723cc8186675afb8e740d946e9b518896efdd2e5. It installs into a project of any language.

# fune: before manufacturing.batch-size

# fune: after manufacturing.batch-size

# fune: replace math.integer-sqrt in manufacturing.batch-size
# fune: replace math.round-div in manufacturing.batch-size
# fune: replace money.amount in manufacturing.batch-size

# fune: step manufacturing.batch-size after <n|label>

More from the author

`D` is annual demand, `P` the annual production rate (what the process would make in a year of running), `S` the set-up cost of one batch and `H` the cost of holding one unit for a year.

**Why not just EOQ.** Because stock is used while the batch is still being made, the peak stock is `Q * (1 - D/P)`, not `Q`, so the batch is larger than the economic order quantity by `sqrt(P / (P - D))`. With demand 1,000, rate 2,000, set-up £5 and holding 50p, EOQ (`inventory.eoq`) says 141; the EBQ is 200. As `P` grows the EBQ falls back to the EOQ.

**Whole units, rounded exactly.** As in `inventory.eoq`, the root is never taken in floating point. The floor comes from `math.integer-sqrt` applied to `floor(2DSP / (H(P - D)))`, and the rounding decision compares whole numbers, so an exact half (sqrt(6.25) = 2.5) goes by `mode`, not by the language:

- `down`: the floor; `up`: the floor plus one unless the ratio is a perfect square - `half-up`: plus one when `(2n + 1)^2 * H(P - D) <= 8DSP` - `half-even`: as half-up, but an exact half goes to the even neighbour

**Limits.** `8 * D * S * P` must stay within 2^63 - 1 and the ratio under the root within 2^53 - 1 (the range `math.integer-sqrt` takes); both are far beyond real plants. Money is `Money` in minor units, set-up and holding in the same currency; the currencies cancel, so the answer is a plain unit count.

Zero demand gives 0. The production rate must be greater than demand (at or below it the process can never build stock and the formula has no answer), holding cost must be positive, and neither demand nor set-up cost may be negative.

Sources: E. W. Taft, "The most economical production lot", The Iron Age 101, 1918; any operations-management text, e.g. Slack, Brandon-Jones and Johnston, *Operations Management*, chapter on inventory planning (the EBQ model).

Files