pmcontrols 0.1.0__tar.gz

pmcontrols-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atakan Arikan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pmcontrols-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: pmcontrols
+Version: 0.1.0
+Summary: Project scheduling and earned value control for Python: CPM, PERT with Monte Carlo schedule risk, minimum-cost crashing, EVM and earned schedule, validated against published reference values.
+Author: Atakan Arikan
+License: MIT
+Project-URL: Homepage, https://github.com/arikanatakan/pmcontrols
+Project-URL: Documentation, https://arikanatakan.github.io/pmcontrols/
+Project-URL: Repository, https://github.com/arikanatakan/pmcontrols
+Project-URL: Issues, https://github.com/arikanatakan/pmcontrols/issues
+Keywords: project-management,critical-path,cpm,pert,earned-value,evm,earned-schedule,schedule-risk,crashing,project-controls,eia-748
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == "docs"
+Dynamic: license-file
+
+# pmcontrols
+
+[![CI](https://github.com/arikanatakan/pmcontrols/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/pmcontrols/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/arikanatakan/pmcontrols)](LICENSE)
+
+Project scheduling and earned value control for Python.
+
+CPM, PERT with Monte Carlo schedule risk, minimum-cost crashing, and
+EVM/earned-schedule control — computed from the defining formulations,
+never from spreadsheet conventions, and checked against published
+reference values in the test suite.
+
+Companion to [lotsampling](https://github.com/arikanatakan/lotsampling) (acceptance
+sampling): lotsampling judges the lot, pmcontrols keeps the project honest.
+
+## Motivation
+
+Every project office computes CPI and SPI; almost all of it happens in
+Excel. R and commercial tools (Primavera, Deltek, @RISK) cover schedule
+risk and earned value; in Python the landscape is a 4 KB CPM toy and an
+abandoned ERP add-on. There is no maintained library a cost engineer or
+a project-controls researcher can `pip install` to get:
+
+- the **critical path** with full ES/EF/LS/LF/slack accounting
+- **PERT** three-point analysis plus what the textbook procedure cannot
+  give you: a Monte Carlo completion distribution and per-activity
+  **criticality indices**
+- **crashing as optimization** — the cheapest set of compressions
+  meeting a deadline, solved as the classical time/cost trade-off LP
+  rather than by manual marginal-cost inspection
+- **EVM with earned schedule** — the full indicator set (CV, SV, CPI,
+  SPI, the EAC family, TCPI, VAC) plus Lipke's time-based ES, SPI(t)
+  and duration forecast IEAC(t), which plain EVM gets wrong late in
+  projects
+
+## Quickstart
+
+```python
+import pmcontrols as pm
+
+activities = [
+    {"id": "A", "predecessors": [],         "duration": 2},
+    {"id": "B", "predecessors": [],         "duration": 3},
+    {"id": "C", "predecessors": ["A"],      "duration": 2},
+    {"id": "D", "predecessors": ["B"],      "duration": 4},
+    {"id": "E", "predecessors": ["C"],      "duration": 4},
+    {"id": "F", "predecessors": ["C"],      "duration": 3},
+    {"id": "G", "predecessors": ["D", "E"], "duration": 5},
+    {"id": "H", "predecessors": ["F", "G"], "duration": 2},
+]
+
+r = pm.cpm(activities)
+r.stats["project_duration"]        # 15.0
+r.meta["critical_activities"]      # ['A', 'C', 'E', 'G', 'H']
+r.table                            # tidy ES/EF/LS/LF/slack DataFrame
+
+# Cheapest way to finish in 13 periods (linear program):
+r = pm.crash(crash_activities, target=13)
+r.stats["total_crash_cost"]        # optimal, not greedy
+
+# Plan once, freeze, control forever:
+pm.plan(periods, pv_curve).save("pmb.json")     # commit this to git
+r = pm.evm("pmb.json", ev=30_000, ac=35_000, at=4)
+r.ok                 # False — CPI and SPI(t) below threshold
+print(r.summary())   # audit text with plain-language verdict
+r.stats["ieac_t"]    # earned-schedule duration forecast
+```
+
+`r.ok` is the automation primitive: a weekly cron job can evaluate the
+latest actuals against the frozen PMB and exit nonzero the moment cost
+or schedule efficiency breaches a threshold.
+
+## Validation philosophy
+
+Every release must reproduce, in `tests/validation_cases.json` (each
+case ships with its full derivation):
+
+1. the General Foundry reference network — complete ES/EF/LS/LF/slack
+   table, 15-period critical path, and optimal crash costs to 14 and 13
+   periods,
+2. hand-derived EVM/earned-schedule cases covering the full indicator
+   set and the ES interpolation formula,
+3. identity and property checks (slack = LS−ES = LF−EF; SPI(t) = ES/AT;
+   crash cost monotone in target; Monte Carlo means converging to
+   analytic values),
+4. (before 0.1) published PMI/Lipke earned-schedule case studies,
+   verified privately where copyright prevents redistribution.
+
+## Status
+
+0.1.0 — first public release. The API surface is small on purpose; the
+`Result`/`PMB` contract is frozen and append-only from this version on.
+
+## Roadmap
+
+| Version | Scope |
+| ------- | ----- |
+| 0.2 | Published PMI/Lipke earned-schedule case-study validation; Gantt and OC plotting (separate from the statistics) |
+| 0.3 | Resource leveling and constrained scheduling; schedule risk drivers (correlation, risk events); EVM from time-phased ledgers (DataFrame in, indicators out) |
+| 0.4 | Critical chain buffers; probabilistic crashing (crash under uncertainty); ES forecasting variants (performance factors); JOSS paper |
+
+Out of scope: Gantt-chart project *editors* (use dedicated PM tools),
+process control, acceptance sampling (see lotsampling), generic LP modeling
+(use scipy/pyomo directly).
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

pmcontrols-0.1.0/README.md

@@ -0,0 +1,109 @@
+# pmcontrols
+
+[![CI](https://github.com/arikanatakan/pmcontrols/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/pmcontrols/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/arikanatakan/pmcontrols)](LICENSE)
+
+Project scheduling and earned value control for Python.
+
+CPM, PERT with Monte Carlo schedule risk, minimum-cost crashing, and
+EVM/earned-schedule control — computed from the defining formulations,
+never from spreadsheet conventions, and checked against published
+reference values in the test suite.
+
+Companion to [lotsampling](https://github.com/arikanatakan/lotsampling) (acceptance
+sampling): lotsampling judges the lot, pmcontrols keeps the project honest.
+
+## Motivation
+
+Every project office computes CPI and SPI; almost all of it happens in
+Excel. R and commercial tools (Primavera, Deltek, @RISK) cover schedule
+risk and earned value; in Python the landscape is a 4 KB CPM toy and an
+abandoned ERP add-on. There is no maintained library a cost engineer or
+a project-controls researcher can `pip install` to get:
+
+- the **critical path** with full ES/EF/LS/LF/slack accounting
+- **PERT** three-point analysis plus what the textbook procedure cannot
+  give you: a Monte Carlo completion distribution and per-activity
+  **criticality indices**
+- **crashing as optimization** — the cheapest set of compressions
+  meeting a deadline, solved as the classical time/cost trade-off LP
+  rather than by manual marginal-cost inspection
+- **EVM with earned schedule** — the full indicator set (CV, SV, CPI,
+  SPI, the EAC family, TCPI, VAC) plus Lipke's time-based ES, SPI(t)
+  and duration forecast IEAC(t), which plain EVM gets wrong late in
+  projects
+
+## Quickstart
+
+```python
+import pmcontrols as pm
+
+activities = [
+    {"id": "A", "predecessors": [],         "duration": 2},
+    {"id": "B", "predecessors": [],         "duration": 3},
+    {"id": "C", "predecessors": ["A"],      "duration": 2},
+    {"id": "D", "predecessors": ["B"],      "duration": 4},
+    {"id": "E", "predecessors": ["C"],      "duration": 4},
+    {"id": "F", "predecessors": ["C"],      "duration": 3},
+    {"id": "G", "predecessors": ["D", "E"], "duration": 5},
+    {"id": "H", "predecessors": ["F", "G"], "duration": 2},
+]
+
+r = pm.cpm(activities)
+r.stats["project_duration"]        # 15.0
+r.meta["critical_activities"]      # ['A', 'C', 'E', 'G', 'H']
+r.table                            # tidy ES/EF/LS/LF/slack DataFrame
+
+# Cheapest way to finish in 13 periods (linear program):
+r = pm.crash(crash_activities, target=13)
+r.stats["total_crash_cost"]        # optimal, not greedy
+
+# Plan once, freeze, control forever:
+pm.plan(periods, pv_curve).save("pmb.json")     # commit this to git
+r = pm.evm("pmb.json", ev=30_000, ac=35_000, at=4)
+r.ok                 # False — CPI and SPI(t) below threshold
+print(r.summary())   # audit text with plain-language verdict
+r.stats["ieac_t"]    # earned-schedule duration forecast
+```
+
+`r.ok` is the automation primitive: a weekly cron job can evaluate the
+latest actuals against the frozen PMB and exit nonzero the moment cost
+or schedule efficiency breaches a threshold.
+
+## Validation philosophy
+
+Every release must reproduce, in `tests/validation_cases.json` (each
+case ships with its full derivation):
+
+1. the General Foundry reference network — complete ES/EF/LS/LF/slack
+   table, 15-period critical path, and optimal crash costs to 14 and 13
+   periods,
+2. hand-derived EVM/earned-schedule cases covering the full indicator
+   set and the ES interpolation formula,
+3. identity and property checks (slack = LS−ES = LF−EF; SPI(t) = ES/AT;
+   crash cost monotone in target; Monte Carlo means converging to
+   analytic values),
+4. (before 0.1) published PMI/Lipke earned-schedule case studies,
+   verified privately where copyright prevents redistribution.
+
+## Status
+
+0.1.0 — first public release. The API surface is small on purpose; the
+`Result`/`PMB` contract is frozen and append-only from this version on.
+
+## Roadmap
+
+| Version | Scope |
+| ------- | ----- |
+| 0.2 | Published PMI/Lipke earned-schedule case-study validation; Gantt and OC plotting (separate from the statistics) |
+| 0.3 | Resource leveling and constrained scheduling; schedule risk drivers (correlation, risk events); EVM from time-phased ledgers (DataFrame in, indicators out) |
+| 0.4 | Critical chain buffers; probabilistic crashing (crash under uncertainty); ES forecasting variants (performance factors); JOSS paper |
+
+Out of scope: Gantt-chart project *editors* (use dedicated PM tools),
+process control, acceptance sampling (see lotsampling), generic LP modeling
+(use scipy/pyomo directly).
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

pmcontrols-0.1.0/pmcontrols/__init__.py

@@ -0,0 +1,27 @@
+"""pmcontrols — project scheduling and earned value control for Python.
+
+Validated, pandas-native, automation-first project controls.
+
+    import pmcontrols as pm
+
+    r = pm.cpm(activities)        # critical path, slack, float
+    r = pm.pert(activities)       # three-point + Monte Carlo risk
+    r = pm.crash(activities, target=14)   # cheapest compression (LP)
+
+    # plan once, freeze, control forever:
+    pm.plan(periods, pv).save("project_pmb.json")
+    r = pm.evm("project_pmb.json", ev=30_000, ac=35_000, at=4)
+    r.ok          # True iff CPI and SPI(t) clear thresholds
+    r.summary()   # plain-language verdict
+"""
+
+from ._result import PMB, Alert, Result
+from ._version import __version__
+from .crash import crash
+from .evm import earned_schedule, evm, plan
+from .network import cpm, pert
+
+__all__ = [
+    "cpm", "pert", "crash", "evm", "plan", "earned_schedule",
+    "Result", "Alert", "PMB", "__version__",
+]

pmcontrols-0.1.0/pmcontrols/_result.py

@@ -0,0 +1,173 @@
+"""The Result protocol: the one object every pmcontrols analysis returns.
+
+Design contract (append-only from v0.1 on):
+
+    Result.method    stable analysis alias ("cpm", "pert", "evm", "crash")
+    Result.params    echo of the user's inputs
+    Result.stats     named scalars (durations, indices, forecasts, costs)
+    Result.alerts    tuple of structured threshold events; empty == on track
+    Result.meta      provenance: n, version, input hash, timestamp
+    Result.table     tidy per-activity / per-period DataFrame
+
+    r.ok             True iff no alerts  ->  sys.exit(0 if r.ok else 1)
+    r.summary()      fixed-width audit text with a plain-language verdict
+    r.to_dict()      JSON-safe, integer-versioned schema
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import datetime
+import hashlib
+import json
+import pathlib
+from typing import Any, Mapping
+
+import numpy as np
+import pandas as pd
+
+_SCHEMA = 1
+
+
+def utcnow() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds")
+
+
+def data_hash(values: Any) -> str:
+    payload = json.dumps(values, sort_keys=True, default=str).encode()
+    return "sha256:" + hashlib.sha256(payload).hexdigest()[:16]
+
+
+def _jsonable(obj: Any) -> Any:
+    if isinstance(obj, (str, int, float, bool)) or obj is None:
+        return obj
+    if isinstance(obj, Mapping):
+        return {str(k): _jsonable(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_jsonable(v) for v in obj]
+    if isinstance(obj, (np.integer, np.floating)):
+        return obj.item()
+    return str(obj)
+
+
+@dataclasses.dataclass(frozen=True)
+class Alert:
+    """One threshold event: which indicator, where, how bad."""
+
+    indicator: str
+    value: float
+    threshold: float
+    note: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "indicator": self.indicator,
+            "value": self.value,
+            "threshold": self.threshold,
+            "note": self.note,
+        }
+
+    def __str__(self) -> str:
+        base = f"{self.indicator}={self.value:.3f} breaches {self.threshold:g}"
+        return base + (f" - {self.note}" if self.note else "")
+
+
+@dataclasses.dataclass(frozen=True)
+class Result:
+    method: str
+    params: Mapping[str, Any]
+    stats: Mapping[str, float]
+    table: pd.DataFrame
+    alerts: tuple[Alert, ...] = ()
+    meta: Mapping[str, Any] = dataclasses.field(default_factory=dict)
+
+    @property
+    def ok(self) -> bool:
+        return len(self.alerts) == 0
+
+    def to_dict(self) -> dict:
+        return {
+            "schema": _SCHEMA,
+            "method": self.method,
+            "params": _jsonable(self.params),
+            "stats": _jsonable(self.stats),
+            "alerts": [a.to_dict() for a in self.alerts],
+            "meta": _jsonable(self.meta),
+            "table": _jsonable(self.table.to_dict(orient="list")),
+        }
+
+    def summary(self) -> str:
+        lines = [f"pmcontrols {self.method} — {self.meta.get('computed_at', '')}"]
+        for k, v in self.stats.items():
+            lines.append(f"  {k:<24} {v:>12.4f}" if isinstance(v, float) else f"  {k:<24} {v}")
+        if self.alerts:
+            lines.append("Alerts:")
+            lines += [f"  ! {a}" for a in self.alerts]
+            lines.append("Verdict: ATTENTION — indicators breach thresholds.")
+        else:
+            lines.append("Verdict: on track — no indicator breaches thresholds.")
+        return "\n".join(lines)
+
+
+@dataclasses.dataclass(frozen=True)
+class PMB:
+    """Performance Measurement Baseline: plan once, freeze, control forever.
+
+    The EVM sibling of a control-chart baseline: the time-phased planned
+    value curve and budget at completion are fixed at planning time,
+    committed to version control, and every reporting period is evaluated
+    against them.
+    """
+
+    periods: tuple[float, ...]
+    pv: tuple[float, ...]
+    bac: float
+    created_at: str
+    version: str
+
+    def __post_init__(self) -> None:
+        if len(self.periods) != len(self.pv):
+            raise ValueError("periods and pv must have the same length")
+        if len(self.periods) < 2:
+            raise ValueError("a PMB needs at least two points")
+        if any(b > a for a, b in zip(self.pv[1:], self.pv[:-1])):
+            raise ValueError("planned value must be non-decreasing")
+        if abs(self.pv[-1] - self.bac) > 1e-9 * max(1.0, self.bac):
+            raise ValueError("planned value must end at BAC")
+
+    @property
+    def planned_duration(self) -> float:
+        return float(self.periods[-1] - self.periods[0])
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "schema": _SCHEMA,
+                "periods": list(self.periods),
+                "pv": list(self.pv),
+                "bac": self.bac,
+                "created_at": self.created_at,
+                "pmcontrols_version": self.version,
+            },
+            indent=2,
+        )
+
+    def save(self, path: str | pathlib.Path) -> pathlib.Path:
+        path = pathlib.Path(path)
+        path.write_text(self.to_json() + "\n", encoding="utf-8")
+        return path
+
+    @classmethod
+    def from_json(cls, text: str) -> "PMB":
+        raw = json.loads(text)
+        return cls(
+            periods=tuple(float(x) for x in raw["periods"]),
+            pv=tuple(float(x) for x in raw["pv"]),
+            bac=float(raw["bac"]),
+            created_at=raw["created_at"],
+            version=raw["pmcontrols_version"],
+        )
+
+    @classmethod
+    def load(cls, path: str | pathlib.Path) -> "PMB":
+        return cls.from_json(pathlib.Path(path).read_text(encoding="utf-8"))

pmcontrols-0.1.0/pmcontrols/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pmcontrols-0.1.0/pmcontrols/crash.py

@@ -0,0 +1,128 @@
+"""Minimum-cost schedule compression (crashing) as a linear program.
+
+Decision variables are activity start times s_i, crash amounts y_i and
+the project finish time F:
+
+    minimize    sum_i  c_i * y_i
+    subject to  s_j >= s_i + (d_i - y_i)      for every precedence i -> j
+                F   >= s_i + (d_i - y_i)      for every terminal activity i
+                F   <= T_target
+                0 <= y_i <= d_i - crash_i,    s_i >= 0
+
+This is the classical CPM time/cost trade-off LP (Kelley 1961), solved
+with scipy.optimize.linprog (HiGHS).
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Mapping
+
+import numpy as np
+from scipy.optimize import linprog
+
+from ._result import Result, data_hash, utcnow
+from ._version import __version__
+from .network import _normalize, _passes
+
+__all__ = ["crash"]
+
+
+def crash(
+    activities: Iterable[Mapping[str, object]],
+    target: float,
+    duration: str = "duration",
+    crash_duration: str = "crash_duration",
+    cost_per_period: str = "crash_cost",
+) -> Result:
+    """Cheapest set of crash decisions meeting a target completion time.
+
+    Each activity mapping must carry: ``id``, ``predecessors``, a normal
+    duration, a fully-crashed duration, and a (linear) crash cost per
+    period.  Returns the optimal crash amount per activity, the resulting
+    schedule, and the total crash cost.
+    """
+    acts = _normalize(activities)
+    names = list(acts)
+    idx = {a: i for i, a in enumerate(names)}
+    n = len(names)
+    d = np.array([float(acts[a][duration]) for a in names])
+    dc = np.array([float(acts[a][crash_duration]) for a in names])
+    cost = np.array([float(acts[a][cost_per_period]) for a in names])
+    if np.any(dc > d):
+        raise ValueError("crash duration cannot exceed normal duration")
+    if np.any(cost < 0):
+        raise ValueError("crash costs must be non-negative")
+
+    normal = _passes(acts, {a: float(acts[a][duration]) for a in names})
+    normal_finish = float(normal["ef"].max())
+    if target > normal_finish:
+        raise ValueError(
+            f"target {target} exceeds the uncrashed duration {normal_finish}; "
+            "nothing to crash"
+        )
+
+    # Variables: [s_0..s_{n-1}, F, y_0..y_{n-1}]
+    nv = 2 * n + 1
+    c = np.zeros(nv)
+    c[n + 1:] = cost
+
+    A_ub, b_ub = [], []
+    succs: dict[str, list[str]] = {a: [] for a in acts}
+    for a in acts:
+        for p in acts[a]["preds"]:
+            succs[p].append(a)
+    # Precedence: s_i + d_i - y_i - s_j <= 0
+    for a in names:
+        for s in succs[a]:
+            row = np.zeros(nv)
+            row[idx[a]] = 1.0
+            row[idx[s]] = -1.0
+            row[n + 1 + idx[a]] = -1.0
+            A_ub.append(row)
+            b_ub.append(-d[idx[a]])
+    # Terminal: s_i + d_i - y_i - F <= 0
+    for a in names:
+        if not succs[a]:
+            row = np.zeros(nv)
+            row[idx[a]] = 1.0
+            row[n] = -1.0
+            row[n + 1 + idx[a]] = -1.0
+            A_ub.append(row)
+            b_ub.append(-d[idx[a]])
+
+    bounds = [(0, None)] * n + [(0, target)] + [
+        (0, float(d[i] - dc[i])) for i in range(n)
+    ]
+    res = linprog(c, A_ub=np.array(A_ub), b_ub=np.array(b_ub), bounds=bounds,
+                  method="highs")
+    if not res.success:
+        raise RuntimeError(f"crashing LP infeasible or failed: {res.message}")
+
+    y = res.x[n + 1:]
+    new_dur = {a: float(d[idx[a]] - y[idx[a]]) for a in names}
+    sched = _passes(acts, new_dur)
+    sched["normal_duration"] = sched["activity"].map(
+        {a: float(d[idx[a]]) for a in names}
+    )
+    sched["crash_amount"] = sched["activity"].map(
+        {a: float(y[idx[a]]) for a in names}
+    )
+    sched["crash_cost"] = sched["activity"].map(
+        {a: float(y[idx[a]] * cost[idx[a]]) for a in names}
+    )
+
+    stats = {
+        "normal_duration_total": normal_finish,
+        "target": float(target),
+        "achieved_duration": float(sched["ef"].max()),
+        "total_crash_cost": float(res.fun),
+    }
+    meta = {
+        "computed_at": utcnow(),
+        "version": __version__,
+        "input_hash": data_hash({a: [float(d[idx[a]]), float(dc[idx[a]]),
+                                     float(cost[idx[a]])] for a in names}),
+        "solver": "scipy.linprog/highs",
+    }
+    return Result(method="crash", params={"target": target}, stats=stats,
+                  table=sched, meta=meta)