| |
| """Does agreement between n0 and the fitted midpoint depend on fixed service times? |
| |
| Additive reference condition with type-specific service times that share the |
| published MEANS but differ in variance: fixed (as published), exponential |
| (coefficient of variation 1), and lognormal with coefficient of variation 2. |
| The mean-based balance index n0 is identical across rows; a median-based index |
| is shown only to illustrate why the median is the wrong estimand for offered |
| load. Synthetic constructions only. |
| """ |
| from __future__ import annotations |
| import json, math |
| from pathlib import Path |
| import numpy as np |
| import capacity_simulation as S |
|
|
| SESSIONS = 500 |
| DISTS = {"fixed": 0.0, "exponential": 1.0, "lognormal_cv2": 2.0} |
|
|
|
|
| def draw_cost(rng, mean, dist): |
| if dist == "fixed": |
| return mean |
| if dist == "exponential": |
| return float(rng.exponential(mean)) |
| cv = DISTS[dist]; s2 = math.log(1 + cv * cv) |
| return float(rng.lognormal(math.log(mean) - s2 / 2, math.sqrt(s2))) |
|
|
|
|
| def session(rng, n, dist): |
| events = [] |
| for minute in range(S.DURATION_MIN): |
| for agent in range(n): |
| for _ in range(rng.poisson(S.LAMBDA)): |
| k = int(rng.choice(3, p=S.TYPE_PROBS)) |
| events.append((minute + rng.random(), agent, k, draw_cost(rng, S.TYPE_COSTS[k], dist))) |
| if not events: |
| return np.nan |
| events.sort(key=lambda e: e[0]) |
| available, correct = 0.0, 0 |
| for arrival, _, k, cost in events: |
| completion = max(arrival, available) + cost / S.BUDGET |
| ok = completion - arrival <= S.TYPE_DEADLINES[k] |
| correct += int(rng.random() < (0.95 if ok else 0.15)) |
| available = completion |
| return correct / len(events) |
|
|
|
|
| def median_factor(dist): |
| if dist == "fixed": return 1.0 |
| if dist == "exponential": return math.log(2) |
| return 1 / math.sqrt(1 + DISTS[dist] ** 2) |
|
|
|
|
| def main(): |
| n0 = S.BUDGET / (S.LAMBDA * float(S.TYPE_PROBS @ S.TYPE_COSTS)) |
| out = {"n0_mean_based": n0} |
| for i, dist in enumerate(DISTS): |
| rng = np.random.default_rng(S.SEED + 100 + i) |
| values, means = {}, [] |
| for n in S.TEAM_SIZES.astype(int): |
| sc = np.array([session(rng, n, dist) for _ in range(SESSIONS)]); sc = sc[np.isfinite(sc)] |
| values[n] = sc; means.append(float(sc.mean())) |
| theta = S.fit_curve(S.TEAM_SIZES, np.array(means)) |
| lo, hi = S.bootstrap_midpoint(rng, values) |
| out[dist] = {"cv": DISTS[dist], "midpoint": float(theta[2]), "midpoint_ci": [float(lo), float(hi)], |
| "tau": float(theta[3]), "gap_to_n0": float(theta[2] - n0), |
| "n0_if_median_used": n0 / median_factor(dist)} |
| Path("service_variance.json").write_text(json.dumps(out, indent=2) + "\n") |
| print(f"mean-based n0 = {n0:.2f} in every row") |
| print(f"{'service times':15}{'CV':>5}{'fitted n_mid':>22}{'tau':>7}{'gap':>8}{'n0 from median':>16}") |
| for d in DISTS: |
| r = out[d] |
| print(f"{d:15}{r['cv']:>5.0f}{r['midpoint']:>9.2f} [{r['midpoint_ci'][0]:.2f},{r['midpoint_ci'][1]:.2f}]" |
| f"{r['tau']:>7.2f}{r['gap_to_n0']:>+8.2f}{r['n0_if_median_used']:>16.2f}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
