manufacturing.batch-size

export function economicBatchQuantity(annualDemand: number, annualProductionRate: number, setupCost: Money, holdingCost: Money, mode: RoundingMode): number

import { economicBatchQuantity } from "#fune/manufacturing.batch-size@^1";

import { type RoundingMode } from "./math_round_div.ts";  ← from math.round-div ^1.0.0 · built alongside by fune
import { integerSqrt } from "./math_integer_sqrt.ts";  ← from math.integer-sqrt ^1.0.0 · built alongside by fune
import { type Money, assertSameCurrency } from "./money_amount.ts";  ← from money.amount ^1.0.0 · built alongside by fune

const MAX_I64 = (1n << 63n) - 1n;

/**
 * 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.
 */
export function economicBatchQuantity(
  annualDemand: number,
  annualProductionRate: number,
  setupCost: Money,
  holdingCost: Money,
  mode: RoundingMode,
): number {
  if (!Number.isSafeInteger(annualDemand) || annualDemand < 0) {
    throw new RangeError(`annualDemand must be a whole number of units, not negative, received ${annualDemand}`);
  }
  if (!Number.isSafeInteger(annualProductionRate) || annualProductionRate <= annualDemand) {
    throw new RangeError(
      `annualProductionRate must be a whole number greater than annualDemand, received ${annualProductionRate}`,
    );
  }
  assertSameCurrency(setupCost, holdingCost);
  if (setupCost.minor < 0) {
    throw new RangeError(`setupCost must not be negative, received ${setupCost.minor}`);
  }
  if (holdingCost.minor <= 0) {
    throw new RangeError(`holdingCost must be greater than zero, received ${holdingCost.minor}`);
  }
  const d = BigInt(annualDemand);
  const p = BigInt(annualProductionRate);
  const s = BigInt(setupCost.minor);
  const eight = 8n * d * s * p;
  if (eight > MAX_I64) {
    throw new RangeError("annualDemand, setupCost and annualProductionRate are too large: 8 x D x S x P must stay within 2^63 - 1");
  }
  const two = 2n * d * s * p;
  const m = BigInt(holdingCost.minor) * (p - d);
  const n = BigInt(integerSqrt(Number(two / m)));
  const odd = 2n * n + 1n;
  switch (mode) {
    case "down":
      return Number(n);
    case "up":
      return Number(n * n * m === two ? n : n + 1n);
    case "half-up":
      return Number(odd * odd * m <= eight ? n + 1n : n);
    case "half-even": {
      const half = odd * odd * m;
      if (half < eight) return Number(n + 1n);
      if (half > eight) return Number(n);
      return Number(n % 2n === 0n ? n : n + 1n);
    }
    default:
      throw new RangeError(`unknown rounding mode "${mode}"`);
  }
}

Install

fune build

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

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

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