inventory.eoq

def economic_order_quantity(annual_demand: int, order_cost: Money, holding_cost: Money, mode: RoundingMode) -> int

from fune.inventory.eoq import economic_order_quantity  # inventory.eoq@^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


def economic_order_quantity(annual_demand: int, order_cost: Money, holding_cost: Money, mode: RoundingMode) -> int:
    """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.
    """
    if isinstance(annual_demand, bool) or not isinstance(annual_demand, int) or annual_demand < 0:
        raise ValueError(
            "annualDemand must be a whole number of units, not negative, received %r" % (annual_demand,)
        )
    assert_same_currency(order_cost, holding_cost)
    if order_cost.minor < 0:
        raise ValueError("orderCost must not be negative, received %d" % order_cost.minor)
    if holding_cost.minor <= 0:
        raise ValueError("holdingCost must be greater than zero, received %d" % holding_cost.minor)
    eight_ds = 8 * annual_demand * order_cost.minor
    if eight_ds > MAX_SAFE:
        raise ValueError(
            "annualDemand and orderCost are too large: 8 x demand x order cost must stay within 2^53 - 1"
        )
    two_ds = 2 * annual_demand * order_cost.minor
    h = holding_cost.minor
    n = integer_sqrt(two_ds // h)
    odd = 2 * n + 1
    if mode == "down":
        return n
    if mode == "up":
        return n if n * n * h == two_ds else n + 1
    if mode == "half-up":
        return n + 1 if odd * odd * h <= eight_ds else n
    if mode == "half-even":
        half = odd * odd * h
        if half < eight_ds:
            return n + 1
        if half > eight_ds:
            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 inventory.eoq

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

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