repyability 0.11__tar.gz → 0.13__tar.gz

{repyability-0.11 → repyability-0.13}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2020 The Python Packaging Authority
+Copyright (c) 2023 Derryn Knife
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{repyability-0.11/repyability.egg-info → repyability-0.13}/PKG-INFO

@@ -1,27 +1,9 @@
 Metadata-Version: 2.4
 Name: repyability
-Version: 0.11
+Version: 0.13
 Summary: Reliability engineering tools for Python
 Author-email: derrynknife <derrynknife@gmail.com>
-License: Copyright (c) 2020 The Python Packaging Authority
-        
-        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.
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/derrynknife/RePyability
 Project-URL: Documentation, https://derrynknife.github.io/RePyability/
 Project-URL: Repository, https://github.com/derrynknife/RePyability
@@ -30,7 +12,6 @@ Keywords: reliability,reliability-engineering,reliability-block-diagram,rbd,surv
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Education
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -43,9 +24,9 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy<3,>=2.0
-Requires-Dist: scipy>=1.7
+Requires-Dist: scipy>=1.13
 Requires-Dist: networkx>=3.0
-Requires-Dist: surpyval>=0.21
+Requires-Dist: surpyval>=0.23
 Requires-Dist: tqdm>=4.64
 Provides-Extra: fast
 Requires-Dist: numba>=0.60; extra == "fast"
@@ -79,8 +60,8 @@ taking already-fitted lifetime models (from
 `sf`/`ff`) as its components:
 
 - **Fault trees**: static fault trees (OR, AND and VOTE gates, repeated
-  events) evaluated exactly, with cut sets, importance measures and
-  conversion to and from block diagrams.
+  events) evaluated exactly, with common-cause groups, cut sets, importance
+  measures and conversion to and from block diagrams.
 - **Reliability**: exact system reliability, hazard and conditional survival;
   the exact MTTF (or simulated, with confidence intervals); B*X* life;
   uncertainty intervals on the reliability, MTTF, B*X* life and time to a
@@ -92,28 +73,43 @@ taking already-fitted lifetime models (from
   landing), each with its own diagram over the same components: the exact
   mission reliability and the chance of failing in each phase.
 - **Testing**: demonstration test plans (the units, or the test time, that
-  demonstrate a reliability or an MTBF), what a test demonstrated, and the
+  demonstrate a reliability or an MTBF), plans that keep both the
+  producer's and the consumer's risk, what a test demonstrated, and the
   chance a design passes.
 - **Importance**: Birnbaum, improvement potential, RAW, RRW, criticality,
-  Fussell–Vesely, structural importance and parameter sensitivity.
+  Fussell–Vesely, structural importance and parameter sensitivity, on
+  repairable systems in the long run or over time.
+- **Sensitivity, the Greeks**: how far the system moves with each
+  component (delta) and with each lever, a life, a repair, the maintenance
+  or a crew; the shares of a change, which add up (differential
+  importance); whether two improvements are complements or substitutes
+  (gamma); which component is moving the availability now, and which
+  caused the failures (theta, Barlow–Proschan); and whose parameter
+  uncertainty widens the answer (vega).
 - **Live state**: reliability, remaining life and importance given each
   component's current age, and covariate-dependent components.
 - **Redundancy and dependence**: cold, warm and hot standby; repeated nodes;
-  load sharing; beta-factor and MGL common-cause groups.
+  load sharing; junctions (a vote point that never fails); beta-factor and
+  MGL common-cause groups, splitting a probability or a failure rate, in
+  block diagrams, repairable systems and fault trees.
 - **Repairable systems**: exact long-run availability, failure frequency and
-  MUT/MDT/MTBF; exact availability over time and over a mission; simulated
+  MUT/MDT/MTBF; exact availability over time and over a mission, and the
+  unavailability to its own precision (a PFD of 1e-17); simulated
   histories with criticality measures; shared repair crews, exact for
   exponential components in the long run and numerical over time, with
   their importance; repairable standby groups (a duty unit and its spares,
-  repaired one at a time); and imperfect repair
-  (Kijima's virtual age), with replacement at the N-th failure.
+  repaired one at a time); imperfect repair (Kijima's virtual age), with
+  replacement at the N-th failure; and uncertainty intervals on the
+  availability and the cost rate from uncertain (fitted) models of the
+  lives, repairs and maintenance.
 - **Capacity**: how much a system delivers, from its components'
   capacities (with several levels, or degrading through stages): the exact
   distribution of its capacity at a time or in the long run, the
   probability of meeting a demand, and the production availability.
 - **Spares**: how many spares each component uses over a horizon, for a
   system or a fleet, and the stock that meets a fill rate or a stock-out
-  target for a replenishment lead time.
+  target for a replenishment lead time, with interchangeable components'
+  spares pooled on one shelf.
 - **Timelines**: up/down histories, from outage logs or simulated, with
   their measures (time up, failures and who caused them, first failure);
   merged as a diagram's structure, so a system's history follows from its
@@ -131,11 +127,15 @@ taking already-fitted lifetime models (from
   maintenance of grouped components at each other's stops,
   with its intervals chosen for a cost or availability target, hidden
   failures found by periodic inspection, with the test intervals chosen for a
-  PFDavg target, the total cost of ownership, optimal redundancy allocation
-  (for the lowest total cost of a repairable system, too), reliability
+  PFDavg target, the total cost of ownership, discounted to a present
+  value from new or in the long run, optimal redundancy allocation (for the
+  lowest total cost of a repairable system, too, with whole trains given
+  copies together), reliability
   allocation by the classic named methods (equal and ARINC-style
   apportionment, minimum effort, cost-based), availability allocation to
   MTTF and MTTR targets, and age-replacement and overhaul policies.
+- **Saving**: diagrams to and from JSON, seeded results that repeat, and
+  every result as plain data (`to_dict()`, ready for `json.dumps`).
 
 ```python
 import surpyval as surv
@@ -178,8 +178,9 @@ only when
 places, nested diagrams):
 
 - **components:** surpyval lifetime distributions and fixed
-  probabilities (non-parametric fits, such as Kaplan–Meier, are
-  deprecated and go in 0.12); repeated nodes; cold standby with one or
+  probabilities (a diagram refuses a non-parametric fit, such as
+  Kaplan–Meier: fit a parametric distribution in surpyval); repeated
+  nodes; cold standby with one or
   two units operating (any units) or more (identical units); warm standby
   with one unit operating, and hot standby (any units); load sharing of
   identical units; common-cause groups, for the system's reliability,
@@ -189,17 +190,21 @@ places, nested diagrams):
   importance measures at any time, also given each component's current age;
   the distribution of the system's capacity;
 - **repairable questions,** for independent components repaired when they
-  fail, replaced on age or block schedules or on condition at inspections
-  (the long run), or tested for hidden failures (with instant tests and
-  repairs, any life): the long-run availability,
+  fail, replaced on age or block schedules or on condition at inspections,
+  or tested for hidden failures (any life, the tests and repairs instant or
+  taking time, the tests finding every failure or missing some): the
+  long-run availability,
   failure frequency, MUT/MDT/MTBF and cost rate; the availability over time
   and over a mission, and the expected failures, outages, downtime and cost
   over a window, from new or from the components' current states (their
   ages, the repairs going on, where they are in their calendars, or the
   long run); the capacity distribution in the long run and over time, with
   the production availability of a window; and the spares used over a
-  horizon, and the stock to hold for a lead time (but under block
-  replacement).
+  horizon, and the stock to hold for a lead time (under block replacement,
+  with repairs and block replacements in no time). Common-cause groups of
+  members with exponential lives, tested or repaired, take nothing away:
+  the long-run values, importance and allocations stay exact, and the
+  values over time from new numerical.
 
 **Simulated**, or refused with the simulation to run instead:
 
@@ -207,25 +212,33 @@ places, nested diagrams):
 |---|---|---|
 | **What you ask** | | |
 | Sampled lifetimes or histories, and distributions or percentiles of an outcome over a window | Simulated (from new, or from the components' current states); each simulation's histories, the system's and its components', kept whole as timelines by `simulate_timelines` (from new) | Yes: the answer is a sample. Its mean over a window (failures, outages, downtime, cost, the capacity delivered) is exact, from new or from a state: `expected_events`, `expected_cost`, `mission_capacity`. |
-| Comparing two designs (`compare`) | Simulated, with common random numbers | No, where both are exact: compare their exact values. |
-| The uncertainty from fitted component parameters (`sf_uncertainty`, `mean_uncertainty`, `bx_life_uncertainty`, `time_to_reliability_uncertainty`) | Sampled over the parameters, each draw exact | Sampling is the method. |
-| Small failure probabilities, with a simulated node | Rare-event simulation (`unreliability_interval`) | Only while the node is simulated: an exact diagram gives `ff` directly, to full precision however small (a numerical node, such as a cold-standby group of non-exponential units, to its own accuracy, about 1e-6). |
+| Comparing two designs (`compare`) | Exact where both designs' expected values are (their MTTFs; a repairable system's mission availability and expected cost), with no simulation (#236); otherwise, or on request (`method="simulate"`, `control_variate=False`), simulated with common random numbers | Only where a design's own values are simulated. |
+| The uncertainty from fitted component parameters (`sf_uncertainty`, `mean_uncertainty`, `bx_life_uncertainty`, `time_to_reliability_uncertainty`; for a repairable system `mean_availability_uncertainty`, `point_availability_uncertainty`, `mission_availability_uncertainty`, `expected_cost_rate_uncertainty`) | Sampled over the parameters, randomly or quasi-randomly (`sampling="sobol"`), each draw exact or numerical as the diagram's own value is | Sampling is the method. |
+| Small failure probabilities, with a node only simulations take | Rare-event simulation (`unreliability_interval`); `ff` refused | Only while the node has no reliability of its own: an exact diagram gives `ff` directly, to full precision however small (a numerical node, such as a cold-standby group of non-exponential units, to its own accuracy, about 1e-6). |
 | **Components** | | |
-| Warm standby with two or more units operating, of non-exponential units | Simulated: a fit to simulated lifetimes, deprecated (from 0.12, simulated only in the system's simulations: #149) | Yes, in general: which spare is switched in where, and how much each has aged, branch with the order of the failures. With one unit operating it is numerical, and hot standby (k-out-of-*n*) exact. |
-| Cold standby with three or more different units operating, and load sharing of different units | Simulated: a fit to simulated lifetimes, deprecated (from 0.12, simulated only in the system's simulations: #149) | Yes, in general: which spare goes where, and how old the others are, branch with the order of the failures. Identical units are numerical in both, and so are two different units operating. |
-| Anything a simulated node is part of | Simulated through that node | Only while the node is simulated. |
+| Warm standby with two or more units operating, of non-exponential units | Simulated in the system's simulations; the analyses that need the group's reliability refused | Yes, in general: which spare is switched in where, and how much each has aged, branch with the order of the failures. With one unit operating it is numerical, and hot standby (k-out-of-*n*) exact. |
+| Cold standby with three or more different units operating, and load sharing of different units | Simulated in the system's simulations; the analyses that need the group's reliability refused | Yes, in general: which spare goes where, and how old the others are, branch with the order of the failures. Identical units are numerical in both, and so are two different units operating. |
+| Anything such a node is part of | Simulated in the system's simulations; the analyses that need the node's reliability refused | Only while the node has no reliability of its own. |
 | Common-cause groups: analyses given ages, and the MTTF of a group splitting a failure probability | Refused (a simulated MTTF leaves a probability split out) | No: the analyses given ages need a model of members of different ages. A group splitting the failure rate (`basis="rate"`) has an exact MTTF, and the simulations draw its shared shocks. Importance, parameter sensitivity and redundancy allocation are exact with groups (a beta-factor member's copies join its group), and parameter uncertainty is sampled with them. |
-| Kaplan–Meier lives in a repairable system | Long run refused; over time numerical | Non-parametric nodes are deprecated and go in 0.12 (#149): fit a parametric distribution in surpyval. |
 | **Architecture and maintenance** | | |
-| Phased missions and networks whose decision diagrams pass a million nodes | Refused, pointing to `method="simulate"` | Only in practice: the diagrams grow with the phases' and the network's width rather than their paths, so meshed missions and networks are exact (a grid of 64 nodes in about a second); a square grid of about 100 nodes passes the limit. |
-| Hidden failures whose tests or repairs take time, or whose tests miss failures of a life that is not exponential | Simulated (with instant tests and repairs, any life is numerical, summed over the test intervals; a constant failure rate is exact, staggered or with tests that miss failures too) | No: could be numerical, the next unit starting at a random phase of the test calendar, or the renewals on the lattice of the full tests (#159). |
-| Common-cause groups in a repairable diagram | Long run and importance exact, for exponential lives, tested or repaired; over time, allocation and the simulations refused | No: over time could be exact from the same Markov chain, the simulations could draw the shared causes, and an allocation could build each design's chain (#158). |
-| Replacement on condition at periodic inspections, over time | Simulated (the long-run values are numerical: a renewal cycle from one inspection that replaces the unit to the next) | No: could be numerical on the same grid (#161). |
-| Shared repair crews | For exponential lives and repairs, the long run and importance exact, and the values over time numerical (the same Markov chain, followed by uniformization), but the allocations; other lives simulated | Other lives: yes, in general. Around a nested RBD the expected events and the capacity over time are refused, and could be numerical too (#162). |
+| Phased missions and networks too large for their decision diagrams | Refused, pointing to `method="simulate"` | Only in practice: the diagrams grow with the phases' and the network's width rather than their paths, so meshed missions and networks are exact (a network grid of 100 nodes in a second and a half); one of 121 nodes passes the limit, `repyability.network.MAX_STATES`, which can be raised. |
+| Block diagrams too meshed for their decision diagrams | Simulated (lifetimes, availability, cost and timelines, in Python); the exact and numerical analyses refused | Only in practice: the diagram grows with how wide the mesh is rather than with its paths, so most meshes are exact (a 10 × 10 grid in 0.04 seconds, a random mesh of 60 nodes and 345 links in 2); one of 70 nodes and 485 links passes the limit, `repyability.rbd.bdd.STEP_LIMIT`, which can be raised. |
+| Common-cause groups in a repairable diagram | For exponential lives, tested or repaired: the long run, importance and the allocations exact (a beta-factor member's copies join its group, and the availability allocations keep the members' availability), and numerical where the members' tests and repairs take a fixed or an exponential time (#220); the values over time from new numerical (the groups' Markov chains), and the simulations draw the shared causes, in Python. Members of other lives refused, as are tests and repairs of other lengths, copies of members whose tests or repairs take time, the failure frequency where their tests do, and members held or started from a current state | Other lives: a shared cause has no one rate for members of different ages, so they need a model first. Tests and repairs of other lengths, no: the chain could follow them on a grid, as a single component's model does. From a current state, no: the chains and the simulations could start from the members' states. |
+| Shared repair crews | For exponential lives and repairs, the long run and importance exact, and the values over time numerical (the same Markov chain, followed by uniformization), but the allocations; other lives simulated. The maintenance and test intervals are chosen as if every repair started at once on request (`assume_unlimited_crews=True`), for a plan to simulate with the crews | Other lives: yes, in general. |
 | Standby groups (a duty unit and its spares, repaired) | For exponential units, the long run and importance exact, and the values over time numerical (the units' Markov chain, followed by uniformization); other units simulated | Other units: yes, in general. |
 | Opportunistic maintenance (renewals at a group's stops) | Simulated | Yes: each member's renewals depend on the others' ages. |
-| Imperfect repair (Kijima), with or without replacement at the *N*-th failure | Simulated | Yes, in general: a repair does not renew the unit. |
-| Spares of tested components whose tests or repairs take time, and the stock of block-replaced ones | Simulated (`spares_demand(method="simulate")`); the stock refused (block-replaced components' demand, and tested ones', are numerical) | No: the tests' calendar phase (#159) and the stock over the block calendar (#160) could be numerical. With crews, standby groups, opportunistic maintenance or imperfect repair: yes. |
+| Imperfect repair (Kijima), with or without replacement at the *N*-th failure | Simulated; but minimal repair (`q = 1`) in no time is numerical over a window from new (it fails `H(t)` times by `t`), its long run refused | Yes, in general: a repair does not renew the unit. |
+| Spares with repair crews, standby groups, opportunistic maintenance or imperfect repair | Refused, pointing to `spares_demand(method="simulate")`. Otherwise numerical, demand and stock: block-replaced components' whether their repairs and block replacements take time or not (from a typical replacement in the long run), but for one dead on arrival while they may take none, and tested components', whatever their tests and repairs take and whether their tests miss failures | Yes, in general: a crew's queue, a group's switching or stops and an imperfect repair make the replacements depend on more than each unit's own lives. A unit dead on arrival whose renewals may take no time: no, the replacements at one instant could be counted. |
+
+Where a system's expected values over a window are exact,
+`availability()` and `cost()` give them by default, with no error, and the
+simulations give their spread. Where a system needs simulating for a few of
+its nodes (a standby group of other lives, a nested RBD sharing a crew, a
+unit repaired imperfectly), their mean intervals by default take each
+simulation's expected values given those nodes' histories, every other node
+exact given their states: a fraction of the error of the simulations' own.
+`conditional=True` simulates only those nodes, for the same means in less
+time.
 
 For your own diagram, `analysis_routes()` says how each analysis will be
 computed (exact, numerical, simulated or refused) and why, without running

{repyability-0.11 → repyability-0.13}/README.md

@@ -13,8 +13,8 @@ taking already-fitted lifetime models (from
 `sf`/`ff`) as its components:
 
 - **Fault trees**: static fault trees (OR, AND and VOTE gates, repeated
-  events) evaluated exactly, with cut sets, importance measures and
-  conversion to and from block diagrams.
+  events) evaluated exactly, with common-cause groups, cut sets, importance
+  measures and conversion to and from block diagrams.
 - **Reliability**: exact system reliability, hazard and conditional survival;
   the exact MTTF (or simulated, with confidence intervals); B*X* life;
   uncertainty intervals on the reliability, MTTF, B*X* life and time to a
@@ -26,28 +26,43 @@ taking already-fitted lifetime models (from
   landing), each with its own diagram over the same components: the exact
   mission reliability and the chance of failing in each phase.
 - **Testing**: demonstration test plans (the units, or the test time, that
-  demonstrate a reliability or an MTBF), what a test demonstrated, and the
+  demonstrate a reliability or an MTBF), plans that keep both the
+  producer's and the consumer's risk, what a test demonstrated, and the
   chance a design passes.
 - **Importance**: Birnbaum, improvement potential, RAW, RRW, criticality,
-  Fussell–Vesely, structural importance and parameter sensitivity.
+  Fussell–Vesely, structural importance and parameter sensitivity, on
+  repairable systems in the long run or over time.
+- **Sensitivity, the Greeks**: how far the system moves with each
+  component (delta) and with each lever, a life, a repair, the maintenance
+  or a crew; the shares of a change, which add up (differential
+  importance); whether two improvements are complements or substitutes
+  (gamma); which component is moving the availability now, and which
+  caused the failures (theta, Barlow–Proschan); and whose parameter
+  uncertainty widens the answer (vega).
 - **Live state**: reliability, remaining life and importance given each
   component's current age, and covariate-dependent components.
 - **Redundancy and dependence**: cold, warm and hot standby; repeated nodes;
-  load sharing; beta-factor and MGL common-cause groups.
+  load sharing; junctions (a vote point that never fails); beta-factor and
+  MGL common-cause groups, splitting a probability or a failure rate, in
+  block diagrams, repairable systems and fault trees.
 - **Repairable systems**: exact long-run availability, failure frequency and
-  MUT/MDT/MTBF; exact availability over time and over a mission; simulated
+  MUT/MDT/MTBF; exact availability over time and over a mission, and the
+  unavailability to its own precision (a PFD of 1e-17); simulated
   histories with criticality measures; shared repair crews, exact for
   exponential components in the long run and numerical over time, with
   their importance; repairable standby groups (a duty unit and its spares,
-  repaired one at a time); and imperfect repair
-  (Kijima's virtual age), with replacement at the N-th failure.
+  repaired one at a time); imperfect repair (Kijima's virtual age), with
+  replacement at the N-th failure; and uncertainty intervals on the
+  availability and the cost rate from uncertain (fitted) models of the
+  lives, repairs and maintenance.
 - **Capacity**: how much a system delivers, from its components'
   capacities (with several levels, or degrading through stages): the exact
   distribution of its capacity at a time or in the long run, the
   probability of meeting a demand, and the production availability.
 - **Spares**: how many spares each component uses over a horizon, for a
   system or a fleet, and the stock that meets a fill rate or a stock-out
-  target for a replenishment lead time.
+  target for a replenishment lead time, with interchangeable components'
+  spares pooled on one shelf.
 - **Timelines**: up/down histories, from outage logs or simulated, with
   their measures (time up, failures and who caused them, first failure);
   merged as a diagram's structure, so a system's history follows from its
@@ -65,11 +80,15 @@ taking already-fitted lifetime models (from
   maintenance of grouped components at each other's stops,
   with its intervals chosen for a cost or availability target, hidden
   failures found by periodic inspection, with the test intervals chosen for a
-  PFDavg target, the total cost of ownership, optimal redundancy allocation
-  (for the lowest total cost of a repairable system, too), reliability
+  PFDavg target, the total cost of ownership, discounted to a present
+  value from new or in the long run, optimal redundancy allocation (for the
+  lowest total cost of a repairable system, too, with whole trains given
+  copies together), reliability
   allocation by the classic named methods (equal and ARINC-style
   apportionment, minimum effort, cost-based), availability allocation to
   MTTF and MTTR targets, and age-replacement and overhaul policies.
+- **Saving**: diagrams to and from JSON, seeded results that repeat, and
+  every result as plain data (`to_dict()`, ready for `json.dumps`).
 
 ```python
 import surpyval as surv
@@ -112,8 +131,9 @@ only when
 places, nested diagrams):
 
 - **components:** surpyval lifetime distributions and fixed
-  probabilities (non-parametric fits, such as Kaplan–Meier, are
-  deprecated and go in 0.12); repeated nodes; cold standby with one or
+  probabilities (a diagram refuses a non-parametric fit, such as
+  Kaplan–Meier: fit a parametric distribution in surpyval); repeated
+  nodes; cold standby with one or
   two units operating (any units) or more (identical units); warm standby
   with one unit operating, and hot standby (any units); load sharing of
   identical units; common-cause groups, for the system's reliability,
@@ -123,17 +143,21 @@ places, nested diagrams):
   importance measures at any time, also given each component's current age;
   the distribution of the system's capacity;
 - **repairable questions,** for independent components repaired when they
-  fail, replaced on age or block schedules or on condition at inspections
-  (the long run), or tested for hidden failures (with instant tests and
-  repairs, any life): the long-run availability,
+  fail, replaced on age or block schedules or on condition at inspections,
+  or tested for hidden failures (any life, the tests and repairs instant or
+  taking time, the tests finding every failure or missing some): the
+  long-run availability,
   failure frequency, MUT/MDT/MTBF and cost rate; the availability over time
   and over a mission, and the expected failures, outages, downtime and cost
   over a window, from new or from the components' current states (their
   ages, the repairs going on, where they are in their calendars, or the
   long run); the capacity distribution in the long run and over time, with
   the production availability of a window; and the spares used over a
-  horizon, and the stock to hold for a lead time (but under block
-  replacement).
+  horizon, and the stock to hold for a lead time (under block replacement,
+  with repairs and block replacements in no time). Common-cause groups of
+  members with exponential lives, tested or repaired, take nothing away:
+  the long-run values, importance and allocations stay exact, and the
+  values over time from new numerical.
 
 **Simulated**, or refused with the simulation to run instead:
 
@@ -141,25 +165,33 @@ places, nested diagrams):
 |---|---|---|
 | **What you ask** | | |
 | Sampled lifetimes or histories, and distributions or percentiles of an outcome over a window | Simulated (from new, or from the components' current states); each simulation's histories, the system's and its components', kept whole as timelines by `simulate_timelines` (from new) | Yes: the answer is a sample. Its mean over a window (failures, outages, downtime, cost, the capacity delivered) is exact, from new or from a state: `expected_events`, `expected_cost`, `mission_capacity`. |
-| Comparing two designs (`compare`) | Simulated, with common random numbers | No, where both are exact: compare their exact values. |
-| The uncertainty from fitted component parameters (`sf_uncertainty`, `mean_uncertainty`, `bx_life_uncertainty`, `time_to_reliability_uncertainty`) | Sampled over the parameters, each draw exact | Sampling is the method. |
-| Small failure probabilities, with a simulated node | Rare-event simulation (`unreliability_interval`) | Only while the node is simulated: an exact diagram gives `ff` directly, to full precision however small (a numerical node, such as a cold-standby group of non-exponential units, to its own accuracy, about 1e-6). |
+| Comparing two designs (`compare`) | Exact where both designs' expected values are (their MTTFs; a repairable system's mission availability and expected cost), with no simulation (#236); otherwise, or on request (`method="simulate"`, `control_variate=False`), simulated with common random numbers | Only where a design's own values are simulated. |
+| The uncertainty from fitted component parameters (`sf_uncertainty`, `mean_uncertainty`, `bx_life_uncertainty`, `time_to_reliability_uncertainty`; for a repairable system `mean_availability_uncertainty`, `point_availability_uncertainty`, `mission_availability_uncertainty`, `expected_cost_rate_uncertainty`) | Sampled over the parameters, randomly or quasi-randomly (`sampling="sobol"`), each draw exact or numerical as the diagram's own value is | Sampling is the method. |
+| Small failure probabilities, with a node only simulations take | Rare-event simulation (`unreliability_interval`); `ff` refused | Only while the node has no reliability of its own: an exact diagram gives `ff` directly, to full precision however small (a numerical node, such as a cold-standby group of non-exponential units, to its own accuracy, about 1e-6). |
 | **Components** | | |
-| Warm standby with two or more units operating, of non-exponential units | Simulated: a fit to simulated lifetimes, deprecated (from 0.12, simulated only in the system's simulations: #149) | Yes, in general: which spare is switched in where, and how much each has aged, branch with the order of the failures. With one unit operating it is numerical, and hot standby (k-out-of-*n*) exact. |
-| Cold standby with three or more different units operating, and load sharing of different units | Simulated: a fit to simulated lifetimes, deprecated (from 0.12, simulated only in the system's simulations: #149) | Yes, in general: which spare goes where, and how old the others are, branch with the order of the failures. Identical units are numerical in both, and so are two different units operating. |
-| Anything a simulated node is part of | Simulated through that node | Only while the node is simulated. |
+| Warm standby with two or more units operating, of non-exponential units | Simulated in the system's simulations; the analyses that need the group's reliability refused | Yes, in general: which spare is switched in where, and how much each has aged, branch with the order of the failures. With one unit operating it is numerical, and hot standby (k-out-of-*n*) exact. |
+| Cold standby with three or more different units operating, and load sharing of different units | Simulated in the system's simulations; the analyses that need the group's reliability refused | Yes, in general: which spare goes where, and how old the others are, branch with the order of the failures. Identical units are numerical in both, and so are two different units operating. |
+| Anything such a node is part of | Simulated in the system's simulations; the analyses that need the node's reliability refused | Only while the node has no reliability of its own. |
 | Common-cause groups: analyses given ages, and the MTTF of a group splitting a failure probability | Refused (a simulated MTTF leaves a probability split out) | No: the analyses given ages need a model of members of different ages. A group splitting the failure rate (`basis="rate"`) has an exact MTTF, and the simulations draw its shared shocks. Importance, parameter sensitivity and redundancy allocation are exact with groups (a beta-factor member's copies join its group), and parameter uncertainty is sampled with them. |
-| Kaplan–Meier lives in a repairable system | Long run refused; over time numerical | Non-parametric nodes are deprecated and go in 0.12 (#149): fit a parametric distribution in surpyval. |
 | **Architecture and maintenance** | | |
-| Phased missions and networks whose decision diagrams pass a million nodes | Refused, pointing to `method="simulate"` | Only in practice: the diagrams grow with the phases' and the network's width rather than their paths, so meshed missions and networks are exact (a grid of 64 nodes in about a second); a square grid of about 100 nodes passes the limit. |
-| Hidden failures whose tests or repairs take time, or whose tests miss failures of a life that is not exponential | Simulated (with instant tests and repairs, any life is numerical, summed over the test intervals; a constant failure rate is exact, staggered or with tests that miss failures too) | No: could be numerical, the next unit starting at a random phase of the test calendar, or the renewals on the lattice of the full tests (#159). |
-| Common-cause groups in a repairable diagram | Long run and importance exact, for exponential lives, tested or repaired; over time, allocation and the simulations refused | No: over time could be exact from the same Markov chain, the simulations could draw the shared causes, and an allocation could build each design's chain (#158). |
-| Replacement on condition at periodic inspections, over time | Simulated (the long-run values are numerical: a renewal cycle from one inspection that replaces the unit to the next) | No: could be numerical on the same grid (#161). |
-| Shared repair crews | For exponential lives and repairs, the long run and importance exact, and the values over time numerical (the same Markov chain, followed by uniformization), but the allocations; other lives simulated | Other lives: yes, in general. Around a nested RBD the expected events and the capacity over time are refused, and could be numerical too (#162). |
+| Phased missions and networks too large for their decision diagrams | Refused, pointing to `method="simulate"` | Only in practice: the diagrams grow with the phases' and the network's width rather than their paths, so meshed missions and networks are exact (a network grid of 100 nodes in a second and a half); one of 121 nodes passes the limit, `repyability.network.MAX_STATES`, which can be raised. |
+| Block diagrams too meshed for their decision diagrams | Simulated (lifetimes, availability, cost and timelines, in Python); the exact and numerical analyses refused | Only in practice: the diagram grows with how wide the mesh is rather than with its paths, so most meshes are exact (a 10 × 10 grid in 0.04 seconds, a random mesh of 60 nodes and 345 links in 2); one of 70 nodes and 485 links passes the limit, `repyability.rbd.bdd.STEP_LIMIT`, which can be raised. |
+| Common-cause groups in a repairable diagram | For exponential lives, tested or repaired: the long run, importance and the allocations exact (a beta-factor member's copies join its group, and the availability allocations keep the members' availability), and numerical where the members' tests and repairs take a fixed or an exponential time (#220); the values over time from new numerical (the groups' Markov chains), and the simulations draw the shared causes, in Python. Members of other lives refused, as are tests and repairs of other lengths, copies of members whose tests or repairs take time, the failure frequency where their tests do, and members held or started from a current state | Other lives: a shared cause has no one rate for members of different ages, so they need a model first. Tests and repairs of other lengths, no: the chain could follow them on a grid, as a single component's model does. From a current state, no: the chains and the simulations could start from the members' states. |
+| Shared repair crews | For exponential lives and repairs, the long run and importance exact, and the values over time numerical (the same Markov chain, followed by uniformization), but the allocations; other lives simulated. The maintenance and test intervals are chosen as if every repair started at once on request (`assume_unlimited_crews=True`), for a plan to simulate with the crews | Other lives: yes, in general. |
 | Standby groups (a duty unit and its spares, repaired) | For exponential units, the long run and importance exact, and the values over time numerical (the units' Markov chain, followed by uniformization); other units simulated | Other units: yes, in general. |
 | Opportunistic maintenance (renewals at a group's stops) | Simulated | Yes: each member's renewals depend on the others' ages. |
-| Imperfect repair (Kijima), with or without replacement at the *N*-th failure | Simulated | Yes, in general: a repair does not renew the unit. |
-| Spares of tested components whose tests or repairs take time, and the stock of block-replaced ones | Simulated (`spares_demand(method="simulate")`); the stock refused (block-replaced components' demand, and tested ones', are numerical) | No: the tests' calendar phase (#159) and the stock over the block calendar (#160) could be numerical. With crews, standby groups, opportunistic maintenance or imperfect repair: yes. |
+| Imperfect repair (Kijima), with or without replacement at the *N*-th failure | Simulated; but minimal repair (`q = 1`) in no time is numerical over a window from new (it fails `H(t)` times by `t`), its long run refused | Yes, in general: a repair does not renew the unit. |
+| Spares with repair crews, standby groups, opportunistic maintenance or imperfect repair | Refused, pointing to `spares_demand(method="simulate")`. Otherwise numerical, demand and stock: block-replaced components' whether their repairs and block replacements take time or not (from a typical replacement in the long run), but for one dead on arrival while they may take none, and tested components', whatever their tests and repairs take and whether their tests miss failures | Yes, in general: a crew's queue, a group's switching or stops and an imperfect repair make the replacements depend on more than each unit's own lives. A unit dead on arrival whose renewals may take no time: no, the replacements at one instant could be counted. |
+
+Where a system's expected values over a window are exact,
+`availability()` and `cost()` give them by default, with no error, and the
+simulations give their spread. Where a system needs simulating for a few of
+its nodes (a standby group of other lives, a nested RBD sharing a crew, a
+unit repaired imperfectly), their mean intervals by default take each
+simulation's expected values given those nodes' histories, every other node
+exact given their states: a fraction of the error of the simulations' own.
+`conditional=True` simulates only those nodes, for the same means in less
+time.
 
 For your own diagram, `analysis_routes()` says how each analysis will be
 computed (exact, numerical, simulated or refused) and why, without running

{repyability-0.11 → repyability-0.13}/pyproject.toml

@@ -1,5 +1,6 @@
 [build-system]
-requires = ["setuptools>=61", "wheel"]
+# 77 reads the licence as an SPDX expression (PEP 639).
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -7,7 +8,8 @@ name = "repyability"
 dynamic = ["version"]
 description = "Reliability engineering tools for Python"
 readme = "README.md"
-license = { file = "LICENSE" }
+license = "MIT"
+license-files = ["LICENSE"]
 requires-python = ">=3.11"
 authors = [{ name = "derrynknife", email = "derrynknife@gmail.com" }]
 keywords = [
@@ -23,7 +25,6 @@ classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
     "Intended Audience :: Education",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
@@ -35,16 +36,20 @@ classifiers = [
 ]
 dependencies = [
     "numpy>=2.0,<3",
-    "scipy>=1.7",
+    # The first SciPy built for NumPy 2.
+    "scipy>=1.13",
     "networkx>=3.0",
     # Deliberately uncapped: RePyability consumes a small surface of surpyval
     # (sf/ff/qf/random/mean, extras/with_params, regression sf/sf_tvc,
     # to_dict/from_dict). A surpyval release reaches every fresh install at
     # once, so the upstream workflow runs the tests against surpyval's
     # development branch to show a break before it is released. CI also tests
-    # this minimum. 0.21 draws lifetimes of limited-failure and zero-inflated
-    # models, and takes random_state, as RePyability relies on.
-    "surpyval>=0.21",
+    # this minimum. 0.23 names the limited-failure proportion lfp_p (p goes
+    # in its next release), takes success_run's level as alpha_ci, and
+    # pickles its fits (for n_jobs' worker processes), as RePyability relies
+    # on; 0.22 named a distribution's parameters parameter_names and
+    # computes the Normal and LogNormal quantiles directly.
+    "surpyval>=0.23",
     "tqdm>=4.64",
 ]
 
@@ -85,6 +90,12 @@ Issues = "https://github.com/derrynknife/RePyability/issues"
 # cannot silently rot.
 testpaths = ["repyability"]
 addopts = "--doctest-modules"
+# A surpyval deprecation that RePyability or its tests run into fails them
+# ("... will be removed in v0.23"), so that the upstream workflow, on
+# surpyval's development branch, shows it before the name is removed.
+filterwarnings = [
+    "error:.*will be removed in v[0-9]:DeprecationWarning:repyability",
+]
 
 [tool.setuptools.dynamic]
 version = { attr = "repyability._version.__version__" }
@@ -92,6 +103,12 @@ version = { attr = "repyability._version.__version__" }
 [tool.setuptools.packages.find]
 include = ["repyability*"]
 
+# The type-checking marker, and the data the installed tests read (#167):
+# test_packaging checks that every data file in the package is listed here.
+[tool.setuptools.package-data]
+"repyability" = ["py.typed"]
+"repyability.tests" = ["*.json"]
+
 # For Black pre-commit hook
 [tool.black]
 line-length = 79
@@ -131,9 +148,15 @@ follow_imports = 'skip'
 # Coverage
 [tool.coverage.run]
 source = ["repyability"]
-# The compiled loop runs as machine code, which coverage cannot trace (its
-# equivalence with the Python loop is tested instead).
-omit = ["*/tests/*", "*/rbd/_kernel.py"]
+# The compiled loop, decision diagram and random streams' Philox run as
+# machine code, which coverage cannot trace (their equivalence with the
+# Python code is tested instead).
+omit = [
+    "*/tests/*",
+    "*/rbd/_kernel.py",
+    "*/rbd/_bdd_kernel.py",
+    "*/rbd/_philox_kernel.py",
+]
 
 [tool.coverage.report]
 # The library (excluding tests) must stay above this bar.