inventory.eoq

export function economicOrderQuantity(annualDemand: number, orderCost: Money, holdingCost: Money, mode: RoundingMode): number

import { economicOrderQuantity } from "#fune/inventory.eoq@^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

/**
 * Economic order quantity, sqrt(2DS / H), 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, so an exact
 * half (sqrt(6.25) = 2.5) rounds by `mode` and not by the language.
 */
export function economicOrderQuantity(annualDemand: number, orderCost: Money, holdingCost: Money, mode: RoundingMode): number {
  if (!Number.isInteger(annualDemand) || annualDemand < 0) {
    throw new RangeError(`annualDemand must be a whole number of units, not negative, received ${annualDemand}`);
  }
  assertSameCurrency(orderCost, holdingCost);
  if (orderCost.minor < 0) {
    throw new RangeError(`orderCost must not be negative, received ${orderCost.minor}`);
  }
  if (holdingCost.minor <= 0) {
    throw new RangeError(`holdingCost must be greater than zero, received ${holdingCost.minor}`);
  }
  const d = BigInt(annualDemand);
  const s = BigInt(orderCost.minor);
  const h = BigInt(holdingCost.minor);
  const eightDS = 8n * d * s;
  if (eightDS > BigInt(Number.MAX_SAFE_INTEGER)) {
    throw new RangeError("annualDemand and orderCost are too large: 8 x demand x order cost must stay within 2^53 - 1");
  }
  const twoDS = 2n * d * s;
  const n = BigInt(integerSqrt(Number(twoDS / h)));
  const odd = 2n * n + 1n;
  switch (mode) {
    case "down":
      return Number(n);
    case "up":
      return Number(n * n * h === twoDS ? n : n + 1n);
    case "half-up":
      return Number(odd * odd * h <= eightDS ? n + 1n : n);
    case "half-even": {
      const half = odd * odd * h;
      if (half < eightDS) return Number(n + 1n);
      if (half > eightDS) 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 inventory.eoq

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

The whole function, every language, is one file too: inventory.eoq-1.0.0.fune, 14,944 bytes, sha256 f6c821a1432734350964c729182dcec1ec2b14422daa6830c0e1a6c227918003. It installs into a project of any language.

// fune: before inventory.eoq

// fune: after inventory.eoq

// fune: replace math.integer-sqrt in inventory.eoq
// fune: replace math.round-div in inventory.eoq
// fune: replace money.amount in inventory.eoq

// fune: step inventory.eoq after <n|label>

More from the author

where `D` is annual demand in units, `S` the fixed cost of placing an order and `H` the cost of holding one unit in stock for a year. It is the order size at which annual ordering cost (`D / Q * S`) equals annual holding cost (`Q / 2 * H`), and their sum is least.

**Whole units, rounded exactly.** The answer is a square root, so it is rarely whole. Rounding it through floating point is where implementations disagree: `sqrt(6.25)` is exactly 2.5, and JavaScript's `Math.round` makes that 3 while Python's `round` makes it 2. Here the root is never taken in floating point. The floor comes from `math.integer-sqrt` applied to `floor(2DS / H)` (the floor of a square root only changes at whole numbers, so this is exact), and the rounding decision compares whole numbers:

- `down`: the floor. - `up`: the floor, plus one unless `2DS / H` is a perfect square. - `half-up`: plus one when `(2n + 1)^2 * H <= 8DS`, i.e. the root is at least `n + 0.5`. - `half-even`: as half-up, but an exact half goes to the even neighbour.

`half-up` is the usual choice; `up` never under-orders.

**Money is exact.** `orderCost` and `holdingCost` are `Money` in minor units and must be in the same currency; the currencies cancel, so the result is a plain unit count. A holding cost quoted as a percentage of unit cost (a 25% carrying rate) is `money.apply-rate(unitCost, 2500, ...)` first. `8 * D * S` has to stay within 2^53 - 1, which allows, for example, a million units a year at £1,000,000 an order.

Zero demand gives 0. Holding cost must be positive (with free holding the EOQ is unbounded) and neither demand nor order cost may be negative.

Sources: F. W. Harris, "How Many Parts to Make at Once", Factory, The Magazine of Management 10(2), 1913; R. H. Wilson, "A Scientific Routine for Stock Control", Harvard Business Review 13, 1934.

Files