ReliabilityDistribution

ReliabilityDistribution[bexpr,{{x₁,dist₁},{x₂,dist₂},…}]

表示一个系统的可靠性分布，其中元件 x_i 具有可靠性分布 dist_i，当布尔表达式 bexpr 为 True，整个系统工作；当 x_i 为 True，元件 x_i 工作.

范例

打开所有单元关闭所有单元

基本范例 (3)

串联系统：

Wolfram Language code:

ℛ = ReliabilityDistribution[x∧y, {{x, ExponentialDistribution[Subscript[λ, 1]]}, {y, ExponentialDistribution[Subscript[λ, 2]]}}]

失效的平均时间：

Wolfram Language code: Mean[ℛ]

并联系统：

Wolfram Language code:

ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[Subscript[λ, 1]]}, {y, ExponentialDistribution[Subscript[λ, 2]]}}];

失效的平均时间：

Wolfram Language code: Mean[ℛ]

串联中的一个元件具有两个并联元件：

Wolfram Language code:

ℛ = ReliabilityDistribution[x∧(y∨z), {{x, ExponentialDistribution[3]}, {y, ExponentialDistribution[1]}, {z, ExponentialDistribution[2]}}];

分布函数：

Wolfram Language code:

Table[Plot[df[ℛ, t], {t, 0, 2}, PlotLabel -> df, PlotRange -> All], {df, {SurvivalFunction, HazardFunction, PDF, CDF}}]

失效的平均和中位数时间：

Wolfram Language code: {Mean[ℛ], Median[ℛ]}

Wolfram Language code: N[%]

系统在时间前失效的概率：

Wolfram Language code: Probability[t < 0.5, tℛ]

范围 (26)

基本用途 (4)

求具有两个元件的并联系统失效的平均时间：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, WeibullDistribution[1, β]}, {y, ExponentialDistribution[2]}}];

Wolfram Language code: Mean[ℛ]

Wolfram Language code: Plot[%, {β, 0, 1}]

求3个元件中2个工作的系统的 SurvivalFunction：

Wolfram Language code: {𝒟1, 𝒟2, 𝒟3} = {ExponentialDistribution[1], ExponentialDistribution[2], ExponentialDistribution[3]};

Wolfram Language code: ℛ = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, 𝒟1}, {y, 𝒟2}, {z, 𝒟3}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: Plot[%, {t, 0, 2}, Filling -> Axis, PlotRange -> All]

求具有一个备用元件的串联系统失效的平均时间（MTTF）：

Wolfram Language code:

{𝒟1, 𝒟2} = {StandbyDistribution[ExponentialDistribution[1 / 10], {ExponentialDistribution[1 / 5]}], WeibullDistribution[1, 7]};

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, 𝒟1}, {y, 𝒟2}}];

Wolfram Language code: NExpectation[t, tℛ]

产生串联系统的随机数：

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, ExponentialDistribution[1]}, {y, WeibullDistribution[2, 3]}}];

Wolfram Language code: data = RandomVariate[ℛ, 10 ^ 4];

比较直方图和 PDF：

Wolfram Language code:

Show[
	Histogram[data, {0, 4, 1 / 3}, "PDF"], 
	Plot[Evaluate[PDF[ℛ, x]], {x, 0, 4}, PlotStyle -> Thick], PlotRange -> All]

结构函数 (7)

带有两个并联元件的两个元件串联组成的系统：

Wolfram Language code:

ℛ = ReliabilityDistribution[(x∧y)∧(z∨w), {{x, ExponentialDistribution[1]}, {y, ExponentialDistribution[1]}, {z, ExponentialDistribution[1]}, {w, ExponentialDistribution[1]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

具有三个元件和选举门的系统：

Wolfram Language code:

ℛ = ReliabilityDistribution[Majority[x, y, z], {{x, ExponentialDistribution[1]}, {y, ExponentialDistribution[1]}, {z, ExponentialDistribution[1]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

四个元件中至少有3个元件工作才工作的系统：

Wolfram Language code: Subscript[𝒟, c] = ExponentialDistribution[1];

Wolfram Language code:

ℛ = ReliabilityDistribution[BooleanCountingFunction[{3, 4}, {x, y, z, v}], {{x, Subscript[𝒟, c]}, {y, Subscript[𝒟, c]}, {z, Subscript[𝒟, c]}, {v, Subscript[𝒟, c]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

任何正单边布尔表达式可用作结构函数：

Wolfram Language code: ℛ = ReliabilityDistribution[¬x⊽¬y, {{x, WeibullDistribution[α, β]}, {y, ErlangDistribution[k, λ]}}];

Wolfram Language code: CDF[ℛ, t]

使用 UnateQ 检验布尔表达式是否为正单边（unate）：

Wolfram Language code: UnateQ[¬x⊽¬y]

构建多阶段系统，其中每个组件都是中取的系统：

Wolfram Language code: 𝒟 = ExponentialDistribution[1];

Wolfram Language code: ℛinner = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}}];

Wolfram Language code:

ℛouter = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {v, w, a}], {{v, ℛinner}, {w, ℛinner}, {a, ℛinner}}];

Wolfram Language code: SurvivalFunction[ℛouter, t]

一个冗余连续取系统，其中每个连续结构元件中都有冗余：

Wolfram Language code: 𝒟 = ExponentialDistribution[1];

Wolfram Language code: ℛcomponent = ReliabilityDistribution[x∨y, {{x, 𝒟}, {y, 𝒟}}];

Wolfram Language code:

ℛ = ReliabilityDistribution[BooleanConsecutiveFunction[2, 3][z, v, w], {{z, ℛcomponent}, {v, ℛcomponent}, {w, ℛcomponent}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

连续取系统的串联：

Wolfram Language code: 𝒟 = ExponentialDistribution[1];

Wolfram Language code:

ℛ1 = ReliabilityDistribution[BooleanConsecutiveFunction[2, 3][z, v, w], {{z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];
ℛ2 = ReliabilityDistribution[BooleanConsecutiveFunction[{2, True}, 3][z, v, w], {{z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, ℛ1}, {y, ℛ2}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

参数寿命分布 (5)

具有递增和递减失效率的系统：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[1]}, {y, ExponentialDistribution[7]}}];

Wolfram Language code: Plot[HazardFunction[ℛ, t], {t, 0, 1}, Filling -> Axis, PlotRange -> All]

使用任何包括 LogNormalDistribution 的参数寿命分布：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[1]}, {y, LogNormalDistribution[1, 2]}}];

数值计算失效的平均时间：

Wolfram Language code: NExpectation[t, tℛ]

计算失效的平均时间作为分布参数的函数：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[λ]}, {y, GammaDistribution[2, β]}}];

Wolfram Language code: μ = Mean[ℛ]

Wolfram Language code: Plot3D[μ, {λ, 1 / 2, 4}, {β, 0, 2}]

当一个元件具有相当长的寿命，它会决定系统的寿命：

Wolfram Language code: Limit[μ, λ -> ∞] == Mean[GammaDistribution[2, β]]

定义两个具有相同失效平均时间的分布：

Wolfram Language code: {Subscript[𝒟, 1], Subscript[𝒟, 2]} = {WeibullDistribution[2, β], ExponentialDistribution[1 / (Sqrt[π] β / 2)]};

Wolfram Language code: Mean /@ {Subscript[𝒟, 1], Subscript[𝒟, 2]}

定义具有这些分布的并联和串联系统：

Wolfram Language code:

{Subscript[ℛ, P], Subscript[ℛ, S]} = Map[ReliabilityDistribution[#[x, y], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}]&, {Or, And}];

显示失效的平均时间不同如何随着而变化：

Wolfram Language code:

Plot[Evaluate[Mean /@ {Subscript[ℛ, P], Subscript[𝒟, 1], Subscript[ℛ, S]}], {β, 0, 10}, PlotLegends -> {"SubscriptBox[ℛ, P]", "SubscriptBox[𝒟, 1]", "SubscriptBox[ℛ, S]"}]

可以使用离散寿命分布：

Wolfram Language code: {Subscript[𝒟, 1] = PoissonDistribution[10], Subscript[𝒟, 2] = PoissonDistribution[11]};

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

计算失效的平均时间：

Wolfram Language code: NExpectation[t, tℛ]

绘制 SurvivalFunction 图线：

Wolfram Language code: DiscretePlot[SurvivalFunction[ℛ, t], {t, 0, 10}]

非参数寿命分布 (3)

使用 SmoothKernelDistribution 模拟飞机玻璃的强度：

Wolfram Language code: data = ExampleData[{"Statistics", "AirplaneGlass"}]

Wolfram Language code: 𝒟 = TruncatedDistribution[{0, ∞}, SmoothKernelDistribution[data]]

考虑具有一个元件（飞机玻璃）的串联系统：

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, 𝒟}, {y, ExponentialDistribution[1 / 30]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: Plot[SurvivalFunction[ℛ, x], {x, 0, 50}]

用 HistogramDistribution 模拟元件：

Wolfram Language code: hd = HistogramDistribution[RandomVariate[WeibullDistribution[1, 2], 1000]];

绘制具有两个和三个元件的串联系统的生存函数：

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, hd}, {y, ExponentialDistribution[1 / 30]}}]

Wolfram Language code:

{Subscript[𝒟, two], Subscript[𝒟, three]} = {ReliabilityDistribution[x∧y, {{x, hd}, {y, hd}}], 
	ReliabilityDistribution[x∧y∧z, {{x, hd}, {y, hd}, {z, hd}}]};

Wolfram Language code:

Plot[{SurvivalFunction[Subscript[𝒟, two], t], SurvivalFunction[Subscript[𝒟, three], t]}, {t, 0, 5}, Filling -> Axis, Exclusions -> None, PlotPoints -> 200, PlotLegends -> {"SubscriptBox[𝒟, two]", "SubscriptBox[𝒟, three]"}]

直接从具有 EmpiricalDistribution 的数据中模拟元件：

Wolfram Language code: data = ExampleData[{"Statistics", "AirplaneGlass"}];

Wolfram Language code: Histogram[data]

Wolfram Language code: ℰ = EmpiricalDistribution[data]

Wolfram Language code: Plot[SurvivalFunction[ℰ, t], {t, 0, 50}, PlotPoints -> 100]

绘制具有两个元件的并联系统的生存函数：

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, ℰ}, {y, GeometricDistribution[1 / 30]}}];

Wolfram Language code: Plot[SurvivalFunction[ℛ, x], {x, 0, 50}]

导出的寿命分布 (7)

用 StandbyDistribution 模拟一个元件：

Wolfram Language code: {Subscript[𝒟, 1], Subscript[𝒟, 2]} = {ExponentialDistribution[1 / 10], ExponentialDistribution[2 / 5]};

Wolfram Language code: 𝒮 = StandbyDistribution[Subscript[𝒟, 1], {Subscript[𝒟, 2], Subscript[𝒟, 2]}];

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, Subscript[𝒟, 1]}, {y, 𝒮}}];

计算失效的平均时间：

Wolfram Language code: NExpectation[t, tℛ]

绘制 SurvivalFunction：

Wolfram Language code: Plot[SurvivalFunction[ℛ, t]//Evaluate, {t, 0, 40}]

复杂系统可按步模拟：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]], ExponentialDistribution[Subscript[λ, 3]]};

Wolfram Language code: Subscript[ℛ, 1] = ReliabilityDistribution[x∨y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

Wolfram Language code: ℛ = ReliabilityDistribution[z∧v, {{z, Subscript[ℛ, 1]}, {v, Subscript[𝒟, 3]}}];

求失效的平均时间：

Wolfram Language code: Mean[ℛ]

这个等价于立即模拟整个系统：

Wolfram Language code: Mean[ReliabilityDistribution[(x∨y)∧v, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {v, Subscript[𝒟, 3]}}]]

Wolfram Language code: FullSimplify[%% - %]

用 StandbyDistribution 模拟一个元件：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {StandbyDistribution[ExponentialDistribution[1], {ExponentialDistribution[2]}], ExponentialDistribution[3]};

两个元件均需工作，系统才工作：

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

绘制生存函数并与备用元件比较：

Wolfram Language code:

Plot[Evaluate[SurvivalFunction[#, t]& /@ {Subscript[𝒟, 1], ℛ}], {t, 0, 4}, Filling -> Axis, PlotLegends -> {"SubscriptBox[𝒟, 1]", "ℛ"}]

具有 ParameterMixtureDistribution 的系统：

Wolfram Language code: 𝒟 = ParameterMixtureDistribution[GammaDistribution[2, β], βUniformDistribution[{1, 2}]];

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, 𝒟}, {y, ExponentialDistribution[λ]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

模拟具有 MixtureDistribution 的两元件冷备用系统：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]], WeibullDistribution[α, β]};

Wolfram Language code:

ℳ = MixtureDistribution[{p, 1 - p}, {TransformedDistribution[x + y, {xSubscript[𝒟, 1], ySubscript[𝒟, 2]}], Subscript[𝒟, 1]}];

在 ReliabilityDistribution 中使用并计算生存函数：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ℳ}, {y, Subscript[𝒟, 3]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

显示与 StandbyDistribution 的等价：

Wolfram Language code:

SurvivalFunction[ReliabilityDistribution[x∨y, {{x, StandbyDistribution[Subscript[𝒟, 1], {Subscript[𝒟, 2]}, p]}, {y, Subscript[𝒟, 3]}}], t]

Wolfram Language code: FullSimplify[%% - %]

OrderDistribution 可用于模拟元件寿命：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {OrderDistribution[{ExponentialDistribution[3], 5}, 3], WeibullDistribution[1 / 10, 2]};

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

Wolfram Language code: sf = SurvivalFunction[ℛ, t]

绘制 SurvivalFunction：

Wolfram Language code: Plot[sf, {t, 0, 2}]

MarginalDistribution 可用于模拟元件寿命：

Wolfram Language code: 𝒟 = ProbabilityDistribution[6 x ^ 2 y, {x, 0, 1}, {y, 0, 1}];

Wolfram Language code: ℳ1 = MarginalDistribution[𝒟, 1];

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ℳ1}, {y, ExponentialDistribution[1]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

绘制 SurvivalFunction：

Wolfram Language code: Plot[%, {t, 0, 3}]

应用 (12)

模拟飞机的发射. 机库的门可以电动或手动开启：

Wolfram Language code: hangarDoor = power∨manual;

两个燃料泵需要电力才能运行：

Wolfram Language code: fuelTransferA2 = power∧pumpA2;

Wolfram Language code: fuelTransferB2 = power∧pumpB2;

可靠的电池支持两个泵的运行，给出以下燃料传递结构：

Wolfram Language code: fuelTransfer = (pumpA1∧(pumpB1∨fuelTransferB2))∨(fuelTransferA2∧(pumpB1∨fuelTransferB2));

也需要飞机的除冰和燃料存储罐：

Wolfram Language code: launch = fuelStorage∧fuelTransfer∧hangarDoor∧deicing;

定义每小时失效率的分布. 让提供的电源失效率是可变的：

Wolfram Language code: vars = {deicing, fuelStorage, manual, power, pumpA1, pumpB1, pumpA2, pumpB2};

Wolfram Language code: lifetimes = ExponentialDistribution /@ {10^-7, 10^-8, 10^-3, λ, 5×10^-4, 5×10^-4, 5×10^-4, 5×10^-4};

Wolfram Language code: dists = Transpose[{vars, lifetimes}];

Wolfram Language code: ℛ = ReliabilityDistribution[launch, dists];

计算生存函数和均值：

Wolfram Language code: sf = SurvivalFunction[ℛ, t];

Wolfram Language code: μ = Mean[ℛ];

研究当失效率从 /小时减小时，可靠性是如何变化的：

Wolfram Language code:

Plot[Evaluate[Table[Legended[sf /. λ -> f, TraditionalForm[λ == f]], {f, {2×10^-4, 1×10^-4, 1 / 2×10^-4}}]], {t, 0, 5000}]

Wolfram Language code: Table[μ /. λ -> f, {f, {2×10^-4, 1×10^-4, 1 / 2×10^-4}}]//N

小的电子加速器中真空系统包含 20 个排成圆圈的真空灯泡. 如果至少三个邻接的真空灯泡失效，则真空系统会失效：

Wolfram Language code: n = 20;k = 3;

Wolfram Language code: bexpr = And@@Map[Or@@#&, Partition[Array[Subscript[x, #]&, n], k, 1, {-1, -1}]];

Wolfram Language code: dists = Array[{Subscript[x, #], ExponentialDistribution[1]}&, n];

Wolfram Language code: ℛ = ReliabilityDistribution[bexpr, dists];

绘制生存函数：

Wolfram Language code: Plot[SurvivalFunction[ℛ, t]//Evaluate, {t, 0, 1}]

计算失效的平均时间：

Wolfram Language code: Mean[ℛ]//N

卫星需要由太阳能电池板充电的电池供电. 计算系统能够经得起考验的负载周期数：

Wolfram Language code:

𝒟Battery = ExponentialDistribution[1 / 300];
𝒟Solarpanels = ExponentialDistribution[1 / 1000];

电池具有备用电池：

Wolfram Language code: 𝒮battery = StandbyDistribution[𝒟Battery, {𝒟Battery}];

Wolfram Language code: ℛsatellite = ReliabilityDistribution[solarpanel∧battery, {{solarpanel, 𝒟Solarpanels}, {battery, 𝒮battery}}];

Wolfram Language code: μ = NExpectation[t, tℛsatellite]

Wolfram Language code: Plot[SurvivalFunction[ℛsatellite, t], {t, 0, 600}, Filling -> Axis]

仿真卫星可以管理的负载周期数：

Wolfram Language code:

ListPlot[{RandomVariate[ℛsatellite, 100], {{0, μ}, {100, μ}}}, Joined -> {False, True}, Filling -> Axis, AxesOrigin -> {0, 0}]

考虑在每个车轮上有球轴承的滑板，求该滑板的寿命：

Wolfram Language code: ExampleData[{"Statistics", "FatigueLifeFailures"}, "LongDescription"]

Wolfram Language code: data = ExampleData[{"Statistics", "FatigueLifeFailures"}];

用已知的分布模拟球轴承：

Wolfram Language code: d = EstimatedDistribution[data, ErlangDistribution[α, β]]

假设当四个轮子中至少三个可用时，滑板可用：

Wolfram Language code: ℛ = ReliabilityDistribution[BooleanCountingFunction[{3, 4}, {x, y, z, v}], {{x, d}, {y, d}, {z, d}, {v, d}}];

绘制生存函数：

Wolfram Language code: Plot[SurvivalFunction[ℛ, t]//Evaluate, {t, 0, 100}]

汽车有四个均要驾驶的轮胎. 给出轮胎的寿命分布为 ExponentialDistribution[0.0004]，计算关于轮胎的汽车的失效率和失效平均时间：

Wolfram Language code: 𝒟 = ExponentialDistribution[0.0004];

Wolfram Language code: ℛcar = ReliabilityDistribution[x∧y∧z∧v, {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}];

Wolfram Language code: HazardFunction[ℛcar, t]

Wolfram Language code: Mean[ℛcar]

仿真汽车的寿命：

Wolfram Language code:

ListPlot[{RandomVariate[ℛcar, 100], {{0, Mean[ℛcar]}, {100, Mean[ℛcar]}}}, Joined -> {False, True}, Filling -> Axis, AxesOrigin -> {0, 0}]

为了飞行，飞机需要两个机翼，每个机翼上两个引擎中的一个以及空气控制系统操控. 模拟该引擎系统：

Wolfram Language code:

{𝒟Motor, 𝒟Fuel, 𝒟Cooling, 𝒟Propeller} = {WeibullDistribution[1.58, 4830], WeibullDistribution[1.44, 5130], WeibullDistribution[1.60, 4190], WeibullDistribution[1.63, 3740]};

Wolfram Language code:

ℛSingleEngine = ReliabilityDistribution[motor∧fuel∧cooling∧propeller, {{motor, 𝒟Motor}, {fuel, 𝒟Fuel}, {cooling, 𝒟Cooling}, {propeller, 𝒟Propeller}}];

Wolfram Language code:

ℛEngines = ReliabilityDistribution[(engine1∨engine2)∧(engine3∨engine4), {{engine1, ℛSingleEngine}, {engine2, ℛSingleEngine}, {engine3, ℛSingleEngine}, {engine4, ℛSingleEngine}}];

模拟空气控制系统：

Wolfram Language code:

parameters = {{1.85, 1.57, 2.25, 0.95, 0.73, 1.14, 0.92, 1.65}, {4729.02, 4718.22, 5843.58, 3956, 2672.1, 3977.39, 2895.62, 3994.78}};

Wolfram Language code:

{𝒟Directional, 𝒟Longitudinal, 𝒟Lateral, 𝒟Flaps, 𝒟Trim, 𝒟Hydraulic, 𝒟LandingGear, 𝒟Steering} = Flatten[Transpose[{MapThread[WeibullDistribution, parameters]}]];

Wolfram Language code:

ℛACS = ReliabilityDistribution[x1∧x2∧x3∧x4∧x5∧x6∧x7∧x8, {{x1, 𝒟Directional}, {x2, 𝒟Longitudinal}, {x3, 𝒟Lateral}, {x4, 𝒟Flaps}, {x5, 𝒟Trim}, {x6, 𝒟Hydraulic}, {x7, 𝒟LandingGear}, {x8, 𝒟Steering}}];

放在一起：

Wolfram Language code: 𝒟Wing = WeibullDistribution[1.79, 4250];

Wolfram Language code:

ℛAirplane = ReliabilityDistribution[enginesystem∧wing1∧wing2∧acs, {{enginesystem, ℛEngines}, {wing1, 𝒟Wing}, {wing2, 𝒟Wing}, {acs, ℛACS}}];

计算飞机失效的平均时间：

Wolfram Language code: NExpectation[t, tℛAirplane]

计算成功飞行6个小时的概率：

Wolfram Language code: NProbability[t ≥ 6, tℛAirplane]

求飞机工作300小时后又工作200小时仍然工作的概率：

Wolfram Language code: NProbability[t ≥ 500t ≥ 300, tℛAirplane]

绘制生存函数：

Wolfram Language code: Plot[SurvivalFunction[ℛAirplane, t]//Evaluate, {t, 0, 2000}, Filling -> Axis]

仿真飞机的寿命：

Wolfram Language code:

ListPlot[{RandomVariate[ℛAirplane, 100], {{0, NExpectation[t, tℛAirplane]}, {100, NExpectation[t, tℛAirplane]}}}, Joined -> {False, True}, Filling -> Axis, AxesOrigin -> {0, 0}]

数据中心需要20台服务器，一个电源，一个冷却系统和一个网络连接. 电源有一个备份. 网络连接由两个并联连接组成. 模拟服务器：

Wolfram Language code:

ℛhdd = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, WeibullDistribution[4, 1.25 10^6]}, {y, WeibullDistribution[4, 1.25 10^6]}, {z, WeibullDistribution[4, 1.25 10^6]}}];

Wolfram Language code:

𝒟cpu = ExponentialDistribution[1 / 30000];
𝒟ram = WeibullDistribution[.82, 2500];

Wolfram Language code: ℛServer = ReliabilityDistribution[hdd∧cpu∧ram, {{hdd, ℛhdd}, {cpu, 𝒟cpu}, {ram, 𝒟ram}}];

用 StandbyDistribution 模拟电源：

Wolfram Language code: 𝒮PowerSupply = StandbyDistribution[ExponentialDistribution[1 / 5000], {ExponentialDistribution[1 / 2000]}];

模拟数据中心：

Wolfram Language code:

𝒟Network = ParetoDistribution[1500, 10];
𝒟Cooling = ExponentialDistribution[1 / 5000];

Wolfram Language code:

servervars = Table[Subscript[s, i], {i, 20}];
serverdists = Table[{i, ℛServer}, {i, servervars}];
ℛDatacenter = ReliabilityDistribution[(And@@servervars)∧power∧(net1∨net2)∧cooling, Join[serverdists, {{power, 𝒮PowerSupply}, {net1, 𝒟Network}, {net2, 𝒟Network}, {cooling, 𝒟Cooling}}]];

计算失效的平均时间（MTTF）：

Wolfram Language code: NExpectation[t, tℛDatacenter]

模拟数据中心的正常运行时间：

Wolfram Language code:

ListPlot[{RandomVariate[ℛDatacenter, 100], {{0, NExpectation[t, tℛDatacenter]}, {100, NExpectation[t, tℛDatacenter]}}}, Joined -> {False, True}, Filling -> Axis, AxesOrigin -> {0, 0}]

找到改善单个服务器最重要的元件：

Wolfram Language code: bi = ImprovementImportance[ℛServer, t];

Wolfram Language code: Plot[MapThread[Legended, {bi, {hdd, cpu, ram}}]//Evaluate, {t, 0, 20}]

具有以下结构和寿命分布的系统：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3], Subscript[𝒟, 4]} = {ExponentialDistribution[λ], WeibullDistribution[5, 6], ErlangDistribution[3, 1], WeibullDistribution[4, 4]};

Wolfram Language code:

ℛ = ReliabilityDistribution[x∨BooleanCountingFunction[{2, 3}, {y, z, v}], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}, {v, Subscript[𝒟, 4]}}];

求生存5天的的概率为 0.9995 的对失效率的要求：

Wolfram Language code: Reduce[SurvivalFunction[ℛ, 5] ≥ 0.9995, λ, Reals]

太阳能电池板由光电电池阵列组成. 每个阵列有10块电池：

Wolfram Language code:

dists = Table[{Subscript[x, i], WeibullDistribution[5.87, 50]}, {i, 10}];
bexpr = And@@Table[Subscript[x, i], {i, 10}];
𝒟 = ReliabilityDistribution[bexpr, dists];

太阳能电池板需要三-五阵列和一个逆变器：

Wolfram Language code:

ℛSolarGrid = ReliabilityDistribution[BooleanCountingFunction[{3, 5}, {x, y, z, v, w}]∧inverter, {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}, {w, 𝒟}, {inverter, ExponentialDistribution[1 / 170]}}];

求年失效平均时间：

Wolfram Language code: NExpectation[t, tℛSolarGrid]

仿真太阳能电池板的寿命：

Wolfram Language code:

ListPlot[{RandomVariate[ℛSolarGrid, 100], {{0, NExpectation[t, tℛSolarGrid]}, {100, NExpectation[t, tℛSolarGrid]}}}, Joined -> {False, True}, Filling -> Axis, AxesOrigin -> {0, 0}]

销售太阳能电池板的公司提供10年的保证. 可以再添加10年. 求公司应如何给延长的保质期定价：

Wolfram Language code: Probability[10 < t ≤ 20, tℛSolarGrid] * meanCostOfRepair + profit

一家物流公司使用车、船和火车将货物交付给客户. 道路运输需要两三辆卡车和明确的道路路线. 船运需要正常运作的船舶和平静的天气条件，铁运需要一个正常运作的列车和轨道. 模拟道路运输：

Wolfram Language code:

{𝒟truck, 𝒟road} = {ExponentialDistribution[1 / 400], ExponentialDistribution[1 / 365]};
ℛroad = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {truck1, truck2, truck3}]∧roads, {{truck1, 𝒟truck}, {truck2, 𝒟truck}, {truck3, 𝒟truck}, {roads, 𝒟road}}];

模拟海洋运输：

Wolfram Language code:

{𝒟ship, 𝒟sea} = {ExponentialDistribution[1 / 400], ExponentialDistribution[1 / 200]};
ℛmarine = ReliabilityDistribution[ship∧sea, {{ship, 𝒟ship}, {sea, 𝒟sea}}];

模拟火车运输：

Wolfram Language code:

{𝒟train, 𝒟railroad} = {WeibullDistribution[1 / 2, 150], ExponentialDistribution[1 / 200]};
ℛrailroad = ReliabilityDistribution[train∧railroad, {{train, 𝒟train}, {railroad, 𝒟railroad}}];

把系统放在一起：

Wolfram Language code:

ℛsupplychain = ReliabilityDistribution[roadtransport∨marine∨railroad, {{roadtransport, ℛroad}, {marine, ℛmarine}, {railroad, ℛrailroad}}];

计算分发给客户在系统出现故障之前所期待的天数：

Wolfram Language code: NExpectation[t, tℛsupplychain]

公司考虑租赁一架飞机以改善分发的可靠性. 计算飞机能改善多少故障的平均时间：

Wolfram Language code:

{𝒟airplane, 𝒟airport} = {WeibullDistribution[1.06, 517], ExponentialDistribution[1 / 400]};
ℛflight = ReliabilityDistribution[airplane∧airport, {{airplane, 𝒟airplane}, {airport, 𝒟airport}}];

Wolfram Language code:

ℛnewsupplychain = ReliabilityDistribution[oldsupplychain∨flight, {{oldsupplychain, ℛsupplychain}, {flight, ℛflight}}];

Wolfram Language code: NExpectation[t, tℛnewsupplychain]

比较两个系统：

Wolfram Language code:

Plot[{SurvivalFunction[ℛsupplychain, t], SurvivalFunction[ℛnewsupplychain, t]}, {t, 0, 800}, Filling -> Axis, PlotLegends -> {"ℛsupplychain", "ℛnewsupplychain"}]

假设 Charles Lindbergh 在纽约和巴黎之间可以选择一个或两个引擎的飞机. 调查哪个引擎的配置可以给出最高的可靠性：

Wolfram Language code: 𝒟 = ExponentialDistribution[1 / 200];

Wolfram Language code:

ℛSingleEngine = ReliabilityDistribution[x, {{x, 𝒟}}];
ℛSerialEngines = ReliabilityDistribution[x∧y, {{x, 𝒟}, {y, 𝒟}}];
ℛParallelEngines = ReliabilityDistribution[x∨y, {{x, 𝒟}, {y, 𝒟}}];

绘制三种不同配置的生存函数：

Wolfram Language code:

Plot[{Legended[SurvivalFunction[ℛSingleEngine, t], "One engine"], Legended[SurvivalFunction[ℛSerialEngines, t], "Serial engines"], Legended[SurvivalFunction[ℛParallelEngines, t], "Parallel engines"]}, {t, 0, 1200}, Filling -> Axis]

最佳选择是并联两种引擎，但是这在当时不可行，因此 Lindbergh 选择一个引擎. 计算一个引擎存活33.5个小时飞行的概率：

Wolfram Language code: Probability[t > 33.5, tℛSingleEngine]

模拟发射进入太空的三个阶段：地面检测、发射阶段和进入轨道. 定义运行和待用模式的寿命分布：

Wolfram Language code:

{Subscript[𝒟, oGuidance], Subscript[𝒟, iGuidance], Subscript[𝒟, oIgnition], Subscript[𝒟, iIgnition], Subscript[𝒟, oSeparation], Subscript[𝒟, iSeparation], Subscript[𝒟, oPower], Subscript[𝒟, oCom], Subscript[𝒟, iCom], Subscript[𝒟, oInstrument], Subscript[𝒟, iInstrument], Subscript[𝒟, oPropulsion], Subscript[𝒟, structure]} = ExponentialDistribution[k # / 1000]& /@ {0.01, 0.0001, 0.1, 0.001, 0.01, 0.0001, 0.02, 0.05, 0.0005, 0.01, 0.0005, 0.05, 0.001};

地面阶段，使用环境加速器因子5：

Wolfram Language code:

ground = guidance1∧guidance2∧ignition1A∧ignition1B∧ignition2A∧ignition2B∧separation1∧separation2∧powerA∧powerB∧comA∧comB∧instrumentA∧instrumentB∧structure;

Wolfram Language code:

Subscript[ℛ, ground] = ReliabilityDistribution[ground, {{guidance1, Subscript[𝒟, iGuidance]}, {guidance2, Subscript[𝒟, iGuidance]}, {ignition1A, Subscript[𝒟, iIgnition]}, {ignition1B, Subscript[𝒟, iIgnition]}, {ignition2A, Subscript[𝒟, iIgnition]}, {ignition2B, Subscript[𝒟, iIgnition]}, {separation1, Subscript[𝒟, iSeparation]}, {separation2, Subscript[𝒟, iSeparation]}, {powerA, Subscript[𝒟, oPower]}, {powerB, Subscript[𝒟, oPower]}, {comA, Subscript[𝒟, iCom]}, {comB, Subscript[𝒟, iCom]}, {instrumentA, Subscript[𝒟, iInstrument]}, {instrumentB, Subscript[𝒟, oInstrument]}, {structure, Subscript[𝒟, structure]}} /. k -> 5];

发射阶段环境更恶劣，环境因子为400：

Wolfram Language code:

launch = guidance1∧guidance2∧(ignition1A∨ignition1B)∧propulsion1∧separation1∧(ignition2A∨ignition2B)∧propulsion2∧separation2∧(powerA∨powerB)∧(comA∨comB)∧instrumentA∧instrumentB∧structure;

Wolfram Language code:

Subscript[ℛ, launch] = ReliabilityDistribution[launch, {{guidance1, Subscript[𝒟, oGuidance]}, {guidance2, Subscript[𝒟, iGuidance]}, {ignition1A, Subscript[𝒟, oIgnition]}, {ignition1B, Subscript[𝒟, oIgnition]}, {ignition2A, Subscript[𝒟, oIgnition]}, {ignition2B, Subscript[𝒟, oIgnition]}, {separation1, Subscript[𝒟, oSeparation]}, {separation2, Subscript[𝒟, oSeparation]}, {powerA, Subscript[𝒟, oPower]}, {powerB, Subscript[𝒟, oPower]}, {comA, Subscript[𝒟, oCom]}, {comB, Subscript[𝒟, oCom]}, {instrumentA, Subscript[𝒟, oInstrument]}, {instrumentB, Subscript[𝒟, iInstrument]}, {structure, Subscript[𝒟, structure]}, {propulsion1, Subscript[𝒟, oPropulsion]}, {propulsion2, Subscript[𝒟, oPropulsion]}} /. k -> 400];

轨道中的环境不是很恶劣，所以使用因子1：

Wolfram Language code: orbit = guidance2∧(powerA∨powerB)∧(comA∨comB)∧instrumentB∧structure;

Wolfram Language code:

Subscript[ℛ, orbit] = ReliabilityDistribution[orbit, {{guidance2, Subscript[𝒟, oGuidance]}, {powerA, Subscript[𝒟, oPower]}, {powerB, Subscript[𝒟, oPower]}, {comA, Subscript[𝒟, oCom]}, {comB, Subscript[𝒟, oCom]}, {instrumentB, Subscript[𝒟, oInstrument]}, {structure, Subscript[𝒟, structure]}} /. k -> 1];

如果地面检验使用24小时，发射为0.1小时，轨道阶段为100天，求成功的概率：

Wolfram Language code:

SurvivalFunction[Subscript[ℛ, ground], 24] * SurvivalFunction[Subscript[ℛ, launch], 0.1] * SurvivalFunction[Subscript[ℛ, orbit], 100 * 24]

属性和关系 (14)

在输入中，ReliabilityDistribution 使用变量的局部名称：

Wolfram Language code:

ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[Subscript[λ, 1]]}, {y, ExponentialDistribution[Subscript[λ, 2]]}}]

因此可以用原来的变量名进行随后的计算：

Wolfram Language code: SurvivalFunction[ℛ, x]

两个元件的寿命大于的概率：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]]};

Wolfram Language code:

Probability[τ < Subscript[t, 1]∧τ < Subscript[t, 2], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2]}]//PiecewiseExpand

Wolfram Language code:

Probability[τ < Min[Subscript[t, 1], Subscript[t, 2]], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2]}]//PiecewiseExpand

以下对应的是串联连接：

Wolfram Language code: SurvivalFunction[ReliabilityDistribution[x∧y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}], τ]

Wolfram Language code: FullSimplify[%% - %]

至少一个元件的寿命大于的概率：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]]};

Wolfram Language code:

Probability[τ < Subscript[t, 1]∨τ < Subscript[t, 2], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2]}]//PiecewiseExpand

Wolfram Language code:

Probability[τ < Max[Subscript[t, 1], Subscript[t, 2]], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2]}]//PiecewiseExpand

以下对应的是并联连接：

Wolfram Language code: SurvivalFunction[ReliabilityDistribution[x∨y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}], τ]

Wolfram Language code: FullSimplify[%% - %]

至少两个元件的寿命大于的概率：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]], ExponentialDistribution[Subscript[λ, 3]]};

Wolfram Language code:

Probability[BooleanCountingFunction[{2, 3}, {τ < Subscript[t, 1], τ < Subscript[t, 2], τ < Subscript[t, 3]}], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2], Subscript[t, 3]Subscript[𝒟, 3]}]//PiecewiseExpand

Wolfram Language code:

Probability[τ < RankedMin[{Subscript[t, 1], Subscript[t, 2], Subscript[t, 3]}, 2], {Subscript[t, 1]Subscript[𝒟, 1], Subscript[t, 2]Subscript[𝒟, 2], Subscript[t, 3]Subscript[𝒟, 3]}]//PiecewiseExpand

以下对应的是 2-3 系统：

Wolfram Language code:

SurvivalFunction[ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}}], τ]

Wolfram Language code: FullSimplify[%% - %]

同样元件的串联连接对应于 OrderDistribution：

Wolfram Language code: d = ExponentialDistribution[λ];

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y∧z, {{x, d}, {y, d}, {z, d}}];

Wolfram Language code: SurvivalFunction[ℛ, t] - SurvivalFunction[OrderDistribution[{d, 3}, 1], t]//FullSimplify

同样元件的并联连接对应于 OrderDistribution：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y∨z, {{x, d}, {y, d}, {z, d}}];

Wolfram Language code: SurvivalFunction[ℛ, t] - SurvivalFunction[OrderDistribution[{d, 3}, 3], t]//FullSimplify

串联连接系统的寿命是元件寿命的最小值：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]]};

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

Wolfram Language code: 𝒯 = TransformedDistribution[Min[t, s], {tSubscript[𝒟, 1], sSubscript[𝒟, 2]}];

Wolfram Language code: SurvivalFunction[𝒯, t] - SurvivalFunction[ℛ, t]//FullSimplify

并联连接系统的寿命是元件寿命的最大值：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]]};

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}}];

Wolfram Language code: 𝒯 = TransformedDistribution[Max[t, s], {tSubscript[𝒟, 1], sSubscript[𝒟, 2]}];

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: SurvivalFunction[𝒯, t]

Wolfram Language code: FullSimplify[%% - %]

- 系统对应于具有 RankedMin 函数的 TransformedDistribution：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = {ExponentialDistribution[Subscript[λ, 1]], WeibullDistribution[1, β], ExponentialDistribution[Subscript[λ, 3]]};

Wolfram Language code:

ℛ = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}}];

Wolfram Language code:

𝒯 = TransformedDistribution[RankedMin[{x, y, z}, 2], {xSubscript[𝒟, 1], ySubscript[𝒟, 2], zSubscript[𝒟, 3]}];

比较生存函数：

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: SurvivalFunction[𝒯, t]

Wolfram Language code: FullSimplify[%% - %]

指数分布元件的串联系统是指数分布：

Wolfram Language code: Subscript[𝒟, c] = ExponentialDistribution[λ];

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y∧z, {{x, Subscript[𝒟, c]}, {y, Subscript[𝒟, c]}, {z, Subscript[𝒟, c]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: SurvivalFunction[ExponentialDistribution[3λ], t]

具有韦伯寿命分布的元件的串联系统是另一种韦伯分布：

Wolfram Language code: Subscript[𝒟, c] = WeibullDistribution[α, β];

Wolfram Language code: ℛ = ReliabilityDistribution[x∧y∧z, {{x, Subscript[𝒟, c]}, {y, Subscript[𝒟, c]}, {z, Subscript[𝒟, c]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

Wolfram Language code: SurvivalFunction[WeibullDistribution[α, 3^-1 / α (β^-α)^-1 / α], t]

Wolfram Language code: FullSimplify[%% - %]

ReliabilityDistribution 模拟元件或必须工作，系统才会工作：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, ExponentialDistribution[λ]}, {y, ExponentialDistribution[μ]}}];

对应的 FailureDistribution 模拟和均有故障的事件：

Wolfram Language code: ℱ = FailureDistribution[x∧y, {{x, ExponentialDistribution[λ]}, {y, ExponentialDistribution[μ]}}];

元件或工作正常等同于和均有故障的事件：

Wolfram Language code: SurvivalFunction[ℛ, t] == SurvivalFunction[ℱ, t]

模拟四个元件中两个元件正常工作则系统正常运作的情况：

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3], Subscript[𝒟, 4]} = {ExponentialDistribution[Subscript[λ, 1]], ExponentialDistribution[Subscript[λ, 2]], ExponentialDistribution[Subscript[λ, 3]], ExponentialDistribution[Subscript[λ, 4]]};

Wolfram Language code:

ℛ = ReliabilityDistribution[BooleanCountingFunction[{2, 4}, {x, y, z, v}], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}, {v, Subscript[𝒟, 4]}}];

这等价于四个元件中三个元件出故障，系统才出故障的系统：

Wolfram Language code:

ℱ = FailureDistribution[BooleanCountingFunction[{3, 4}, {x, y, z, v}], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}, {v, Subscript[𝒟, 4]}}];

Wolfram Language code: SurvivalFunction[ℛ, t] - SurvivalFunction[ℱ, t]//FullSimplify

ReliabilityDistribution[f[x₁,…],…]FailureDistribution[¬f[¬x₁,…],…]:

Wolfram Language code: comp = {{x, ExponentialDistribution[λ]}, {y, ExponentialDistribution[μ]}};

Wolfram Language code:

ℛ = ReliabilityDistribution[x∧y, comp];
ℱ = FailureDistribution[¬(¬x∧¬y), comp];

Wolfram Language code: SurvivalFunction[ℛ, t] == SurvivalFunction[ℱ, t]

为带有可靠性信息的 SystemModel 提取 ReliabilityDistribution：

Wolfram Language code: SystemModelReliability[[image]]

可能存在的问题 (3)

元件分布需要正域：

Wolfram Language code: ℛ = ReliabilityDistribution[x∨y, {{x, NormalDistribution[6, 2]}, {y, ExponentialDistribution[3]}}];

Wolfram Language code: SurvivalFunction[ℛ, x]

使用 TruncatedDistribution 限制域只为正值：

Wolfram Language code:

ℛ = ReliabilityDistribution[x∨y, {{x, TruncatedDistribution[{0, ∞}, NormalDistribution[6, 2]]}, {y, ExponentialDistribution[3]}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

不能总是计算精确或符号属性：

Wolfram Language code:

ℛ = ReliabilityDistribution[(x∧y), {{x, ExponentialDistribution[1]}, {y, InverseGaussianDistribution[1, 3, 1 / 2]}}];

Wolfram Language code: CDF[ℛ, t]

仍然可以找到近似值：

Wolfram Language code: CDF[ℛ, 0.5]

ReliabilityDistribution 只对正单边（unate）结构表达式有定义：

Wolfram Language code: decfn = ¬x∨y;

Wolfram Language code: SurvivalFunction[ReliabilityDistribution[decfn, {{x, ExponentialDistribution[3]}, {y, ExponentialDistribution[3]}}], t]

使用 UnateQ 检验布尔表达式是否为正单边（unate）：

Wolfram Language code: UnateQ[decfn]

Wolfram Language code: incfn = ¬x⊽¬y;

Wolfram Language code: UnateQ[incfn]

Wolfram Language code: SurvivalFunction[ReliabilityDistribution[incfn, {{x, ExponentialDistribution[3]}, {y, ExponentialDistribution[3]}}], t]

巧妙范例 (2)

显示具有至多四个相同组件的所有系统的风险函数：

Wolfram Language code: 𝒟 = ExponentialDistribution[1];

产生系统：

Wolfram Language code: schemes = Select[Table[BooleanFunction[i, {x, y, z, v}], {i, 2 ^ 2 ^ 4 - 2}], UnateQ[#]&];

构建唯一风险函数的列表：

Wolfram Language code: hf[scheme_, t_] := HazardFunction[ReliabilityDistribution[scheme, {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}], t]

Wolfram Language code: hfs = DeleteDuplicates[Table[{hf[expr, t], expr}, {expr, schemes}], First[#1] === First[#2]&];

绘制风险函数和相同系统的图线：

Wolfram Language code: Plot[Evaluate[hfs[[All, 1]]], {t, 0, 3}, PlotStyle -> AbsoluteThickness[.75], PlotLegends -> hfs[[All, 2]]]

使用 Graph 作为可靠性方框图：

Wolfram Language code:

visit[g_, x_, e_, trail_] /; (FreeQ[trail, x]) := Block[{newtrail = Append[trail, x]}, trailholder[x] = Join[trailholder[x], {newtrail}];If[x =!= e, Do[visit[g, v, e, newtrail], {v, DeleteCases[VertexList[NeighborhoodGraph[g, x]], x]}];];];

Wolfram Language code:

graphToBoolean[g_, start_, end_] /; VertexQ[g, start] && VertexQ[g, end] := Block[{trailholder}, trailholder[_] := {};visit[g, start, end, {}];BooleanMinimize[Or@@(And@@@trailholder[end])]]

计算使用绿车和红车作为开始和结束车辆的平均故障时间：

Wolfram Language code: g = PetersenGraph[8, 1, VertexSize -> Large, ImageSize -> Tiny];

Wolfram Language code: bexpr = graphToBoolean[g, 12, 16];

Wolfram Language code: dist = ReliabilityDistribution[bexpr, Table[{i, ExponentialDistribution[1]}, {i, 16}]];

Wolfram Language code: GraphicsRow@{HighlightGraph[g, {Style[12, Green], Style[16, Red]}], Plot[PDF[dist, t]//Evaluate, {t, 0, 1}]}

Top

		串联系统
		并联系统
		k-n 系统
	BooleanConsecutiveFunction[k,n]	连续的 k-n 系统

	x_iTrue	表明元件 x_i 工作
	x_iFalse	表明元件 x_i 失效

更多学习资源

技术支持

数据科学、金融与商业

工程

科学与技术

教育科技

教育举措

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

ReliabilityDistribution

更多信息

范例

基本范例 (3)

范围 (26)

基本用途 (4)

结构函数 (7)

参数寿命分布 (5)

非参数寿命分布 (3)

导出的寿命分布 (7)

应用 (12)

属性和关系 (14)

可能存在的问题 (3)

巧妙范例 (2)

文本

CMS

APA

BibTeX

BibLaTeX

ReliabilityDistribution

更多信息

范例

基本范例 (3)

范围 (26)

基本用途 (4)

结构函数 (7)

参数寿命分布 (5)

非参数寿命分布 (3)

导出的寿命分布 (7)

应用 (12)

属性和关系 (14)

可能存在的问题 (3)

巧妙范例 (2)

参见

相关指南

历史

文本

CMS

APA

BibTeX

BibLaTeX