Wagner-Whitin Dynamic Lot-Sizing

ForecastAI 2026.01 · Mirabelle · tag_code: wagner_whitin O(T²) per item globally optimal

Wagner-Whitin (1958) finds the globally optimal replenishment schedule for a finite horizon of discrete, arbitrarily-varying demand periods. Unlike Classic EOQ — which assumes constant, continuous demand and yields a single fixed order quantity $Q^*$ — Wagner-Whitin decides when to order and how much, period by period, so that total ordering + holding cost is minimised exactly.

Overview & When to use

Classic EOQ is visualised by the Wilson cost curve (a U-shaped total cost with minimum at $Q^*$). Wagner-Whitin is visualised by the inventory sawtooth profile — order arrivals as vertical spikes, demand as downward slopes, returning to zero before each new order.

Intuition & the Zero-Inventory Property

Given $T$ weekly demand values $d_1 \ldots d_T$, a fixed ordering cost $S$ per order, and a holding cost $h$ per unit per week, choose a lot size $q_t \ge 0$ for each week to minimise:

where $I_t$ is the on-hand inventory at the end of period $t$ (units carried into the next period). No backorders: every period's demand must be met by an order in that period or earlier.

Graphical View: the Sawtooth

The diagram below is the optimal schedule for the running example (demand [100, 0, 100, 0, 100, 0], $S=$€100, $h=$€0.30/unit/week). The WW algorithm orders 100 in week 1 and 200 in week 3. Note how each order lands exactly when inventory hits zero.

Compare with Classic EOQ's sawtooth under constant demand: equal-height, evenly-spaced teeth. Wagner-Whitin's teeth are irregular — tall where demand clusters, absent in zero-demand weeks — because it batches lumpy demand optimally.

The O(T²) Dynamic Program

Define $f(t)$ as the minimum cost to satisfy all demand in periods $1 \ldots t$.

The inner sum is the holding cost when a single order placed at the start of period $j$ covers demand through period $t$: $d_j$ is carried 0 weeks, $d_{j+1}$ one week, …, $d_t$ carried $t{-}j$ weeks. (Equivalently it is the sum of end-of-period inventories over weeks $j \ldots t$ for that one order.)

Base case: $f(0) = 0$. After filling the table to $f(T)$, backtrack through the recorded best $j$ (order_at[t]) to reconstruct the schedule.

Implementation

# files/kcurve/wagner_whitin.py
def wagner_whitin(demands, S, h):
    T = len(demands)
    if T == 0 or S <= 0:
        return demands[:]
    INF = float("inf")
    f = [INF] * (T + 1);  f[0] = 0.0
    order_at = [0] * (T + 1)
    for t in range(1, T + 1):
        for j in range(1, t + 1):
            hold = sum((i - j) * demands[i - 1] for i in range(j, t + 1))
            cost = f[j - 1] + S + h * hold
            if cost < f[t]:
                f[t] = cost
                order_at[t] = j
    lots = [0.0] * (T + 1)
    t = T
    while t > 0:
        j = order_at[t]
        lots[j] = sum(demands[j - 1:t])   # order covers weeks j..t
        t = j - 1
    return lots[1:]

Weekly holding conversion: $h = p \cdot i / 52$ (e.g. price €52, carrying rate 30%/yr → $h =$ €0.30/unit/week).

Worked Example — Full DP Table

Demand [100, 0, 100, 0, 100, 0], $S=$€100, $h=$€0.30. For each $t$ (cover weeks $1 \ldots t$) we test every candidate order period $j$. Candidate $= f(j{-}1) + S + h \cdot \text{hold}$.

Backtrack: $f(6)=260$, order_at[6]=3 → order in week 3 covers weeks 3..6 = $100{+}0{+}100{+}0 = 200$. Then $t{=}2$, order_at[2]=1 → order in week 1 covers weeks 1..2 = $100{+}0 = 100$. Done.

WW beats both extremes — it skips the third €100 setup and avoids carrying all 300 units from week 1. Saving €40 (13%) vs lot-for-lot.

The per-item eoq field

Wagner-Whitin produces a dynamic schedule (different lot each order), not a single quantity. To give MEIO and supply one comparable batch size — the same role Classic EOQ's $Q^*$ plays — the result exposes an annualised average order quantity:

For the example: $n_{orders}{=}2$, $T{=}6$ → $17.33$ orders/yr; $D_{annual}{=}2600$ → eoq ≈ 150 (between the two actual lots 100 and 200). avg_lot_size (= 150 here) is the raw per-horizon average kept for display.

Shared EOQ Overrides

Wagner-Whitin uses the same override mechanism as Classic EOQ and K-Curve: the interact_io_overrides table, with scenario_id = 0 as the pipeline-level sentinel. One override row per (pipeline_id, item_id, site_id) applies to all three methods — there is no separate WW override store.

The endpoint annotates each item with eoq (post-override) and eoq_override (raw value, null if none) — identical shape to /kcurve/eoq and /kcurve/solve.

MEIO & Supply Propagation

When a pipeline's linked inventory_scenario has tag_code = 'wagner_whitin', the pipeline eoq step runs run_wagner_whitin_for_pipeline (instead of the K-Curve solver) and persists results.items[] in the same shape MEIO and supply already consume:

{ "unique_id": "...", "item_id": 1, "site_id": 2, "eoq": 150.0,
  "eoq_override": null, "orders_per_year": 17.33, "annual_demand": 2600, ... }

API, Pipeline & UI

Endpoint

GET /api/kcurve/wagner-whitin?pipeline_id=...&periods=24&ordering_cost_mult=1&holding_rate_mult=1

Returns per-item eoq, eoq_override, orders_per_year, n_orders, avg_lot_size, schedule[], plus portfolio totals.

Pipeline step

The eoq step (run_pipeline.py) calls run_eoq_for_pipeline, which branches on the scenario's tag_code: wagner_whitin → run_wagner_whitin_for_pipeline; otherwise the K-Curve solver. The runner honours parameters.periods (default 24, max 52).

UI — WagnerWhitinWorkbench

Rendered inside the K-Curve modal when tag_code='wagner_whitin'. Provides:

• 1KPI strip — total orders, holding cost, total cost, gross margin value.
• 2Per-item table with an EOQ column (asterisk marks overrides), sortable, expandable to the weekly schedule.
• 3Sawtooth inventory chart on row hover (WwSawtoothChart, pure SVG) — the graphical analog of the Wilson cost curve.

Method Comparison

$N$ = SKUs, $P$ = k-points (80), $F$ = allowed frequencies, $T$ = horizon weeks.