Wolfram Language & System Documentation Center

StandbyDistribution

StandbyDistribution[dist₁,{dist₂,…,dist_n}]

represents a standby distribution with component lifetime distributions dist_i. When component fails, component will become active.

StandbyDistribution[dist₁,{dist₂,…,dist_n},p]

represents a standby distribution where switching from component to component succeeds with probability p.

StandbyDistribution[dist₁,{dist₂,…,dist_n},sdist]

represents a standby distribution where the switch component has lifetime distribution sdist.

StandbyDistribution[dist₁,{…,{dist_i,inactive,dist_i,active},…},…]

represents a standby distribution where the component lifetime distribution follows dist_i,inactive in inactive mode and dist_i,active in active mode.

StandbyDistribution

StandbyDistribution[dist₁,{dist₂,…,dist_n}]

represents a standby distribution with component lifetime distributions dist_i. When component fails, component will become active.

StandbyDistribution[dist₁,{dist₂,…,dist_n},p]

represents a standby distribution where switching from component to component succeeds with probability p.

StandbyDistribution[dist₁,{dist₂,…,dist_n},sdist]

represents a standby distribution where the switch component has lifetime distribution sdist.

StandbyDistribution[dist₁,{…,{dist_i,inactive,dist_i,active},…},…]

represents a standby distribution where the component lifetime distribution follows dist_i,inactive in inactive mode and dist_i,active in active mode.

Details

StandbyDistribution[…,…] represents a system with perfect switching where transitioning between components always succeeds.
StandbyDistribution[…,…,s] represents a system with imperfect switching. If s is a distribution, it represents that lifetime of the switch; otherwise it represents the probability of a successful transition between components.
StandbyDistribution[…,{…,A_i,…},…] represents a standby distribution where the component follows a cold standby distribution A_i when it is active, and does not deteriorate when it is inactive.
StandbyDistribution[…,{…,{I_i,A_i},…},…] represents a standby distribution where the component follows a warm standby distribution. The component deteriorates following distribution I_i when it is inactive and distribution A_i when it is active.
Any mix of cold and warm standby component distributions can be used.
The survival function and other properties for StandbyDistribution can be derived from the equivalent TransformedDistribution[expr,dists] with the distribution assumptions dists given by {a₁A₁,a₂A₂,…,i₂I₂,i₃I₃,…,sS,uUniformDistribution[{0,1}]}.

	StandbyDistribution[…]	TransformedDistribution[…,dists]
	$A_(1),{A_(2),A_(3),...}$	a₁+a₂+a₃+⋯
	A₁,{A₂,A₃,…},p	a₁+ a₂Boole[p>u]+a₃Boole[p²>u]+⋯
	A₁,{A₂,A₃,…},S	a₁+a₂Boole[s>a₁]+a₃Boole[s>a₁+a₂]+⋯
	A₁,{{I₂,A₂},{I₃,A₃},…}	a₁+a₂Boole[i₂>a₁]+a₃Boole[i₃>a₁+a₂Boole[i₂>a₁]]+⋯
	A₁,{{I₂,A₂},{I₃,A₃},…},p	a₁+a₂ Boole[i₂>a₁∧p>u]+a₃Boole[i₃>a₁+ a₂Boole[i₂>a₁]∧p²>u]+⋯
	A₁,{{I₂,A₂},{I₃,A₃},…},S	a₁+a₂ Boole[i₂>a₁∧s>a₁]+a₃Boole[i₃>a₁+a₂Boole[i₂>a₁]∧s>a₁+a₂Boole[i₂>a₁]]+⋯

StandbyDistribution can be used with such functions as Mean, SurvivalFunction, HazardFunction, ReliabilityDistribution, and RandomVariate.

Examples

open all close all

Basic Examples (3)

Define a cold standby system with perfect switching:

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

Compute its PDF:

Wolfram Language code: PDF[𝒟, t]

Mean time to failure:

Wolfram Language code: Mean[𝒟]

Compare to a non-standby system:

Wolfram Language code:

Plot[{SurvivalFunction[𝒟 /. {Subscript[λ, 1] -> 2, Subscript[λ, 2] -> 1}, t], SurvivalFunction[ExponentialDistribution[2], t]}, {t, 0, 5}]

Define a cold standby system with imperfect switching:

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

Compute its PDF:

Wolfram Language code: PDF[𝒟, t]

Mean time to failure:

Wolfram Language code: Mean[𝒟]

Compare to a non-standby system:

Wolfram Language code:

Plot[{SurvivalFunction[𝒟 /. {Subscript[λ, 1] -> 2, Subscript[λ, 2] -> 1, p -> 0.9}, t], SurvivalFunction[ExponentialDistribution[2], t]}//Evaluate, {t, 0, 5}]

Define cold and warm standby systems, with inactive failure rate half the active failure rate:

Wolfram Language code:

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

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

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

Compute the mean time to failure:

Wolfram Language code: {Mean[𝒟c], Mean[𝒟w]}

Compare the survival functions:

Wolfram Language code:

Plot[Map[SurvivalFunction[# /. {Subscript[λ, 1] -> 2, Subscript[λ, 2] -> 1}, t]&, {𝒟c, 𝒟w}]//Evaluate, {t, 0, 5}, Filling -> Axis]

Scope (17)

Cold Standby and Perfect Switching (3)

Define a cold standby system with three identical components:

Wolfram Language code: 𝒟 = StandbyDistribution[ExponentialDistribution[λ], {ExponentialDistribution[λ], ExponentialDistribution[λ]}];

Compute mean time to failure:

Wolfram Language code: Mean[𝒟]

Define a cold standby system with two different components:

Wolfram Language code: 𝒟 = StandbyDistribution[WeibullDistribution[1, β], {ExponentialDistribution[λ]}];

Compute the survival function:

Wolfram Language code: SurvivalFunction[𝒟, t]

Study a component with three identical components in standby:

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

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

Generate random variates:

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

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, 25, "PDF"], 
	Plot[PDF[𝒟, x]//Evaluate, {x, 0, 12}, PlotStyle -> Thick]]

Cold Standby and Imperfect Switching (4)

A cold standby system where the switch succeeds with probability p:

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

Find the mean time to failure:

Wolfram Language code: Mean[𝒟]

Compare perfect switching to imperfect switching where the switch works half the time:

Wolfram Language code: sf = SurvivalFunction[𝒟, t] /. {Subscript[λ, 1] -> 1, Subscript[λ, 2] -> 1 / 2};

Wolfram Language code: Plot[{sf /. p -> 0.5, sf /. p -> 1}, {t, 0, 10}]

A cold standby system where the switch is modeled by a lifetime distribution:

Wolfram Language code:

𝒟 = StandbyDistribution[ExponentialDistribution[1], {ExponentialDistribution[1 / 5]}, ExponentialDistribution[Subscript[λ, s]]];

Find the survival function:

Wolfram Language code: SurvivalFunction[𝒟, t]//Simplify

Study the effect of having worse switches:

Wolfram Language code:

Plot[Table[SurvivalFunction[𝒟 /. Subscript[λ, s] -> i, t], {i, {.1, 1, 3, 5}}]//Evaluate, {t, 0, 15}, PlotRange -> {0, 1}]

Cold standby system with three components and a switch modeled by a distribution:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, S]} = {WeibullDistribution[2, 3], ExponentialDistribution[5], ExponentialDistribution[1]};

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

Generate random variates:

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

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, 25, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 12}, WorkingPrecision -> 20, PlotStyle -> Thick]]

A switch modeled with a probability of success:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, S]} = {ExponentialDistribution[1 / 2], ExponentialDistribution[1], ExponentialDistribution[2], ExponentialDistribution[1 / 3]};

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

Wolfram Language code: data = RandomVariate[𝒮, 10^5];

Compare with the probability density:

Wolfram Language code:

Show[Histogram[data, {0, 11, 1 / 2}, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 11}, PlotStyle -> Thick]]

Warm Standby and Perfect Switching (3)

Standby system where the component can fail while in standby:

Wolfram Language code:

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

Find the mean time to failure:

Wolfram Language code: Mean[𝒟]

System with multiple components that can fail in standby:

Wolfram Language code:

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

Compare the survival function to a cold standby system:

Wolfram Language code: ℛ = StandbyDistribution[ExponentialDistribution[1], {ExponentialDistribution[1], ExponentialDistribution[5]}];

Wolfram Language code: Plot[{SurvivalFunction[𝒟, t], SurvivalFunction[ℛ, t]}//Evaluate, {t, 0, 6}, PlotRange -> {0, 1}, Filling -> Axis]

Warm standby system with two components in standby:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o]} = {ExponentialDistribution[1 / 2], ExponentialDistribution[1], ExponentialDistribution[2]};

Wolfram Language code:

𝒮 = StandbyDistribution[Subscript[𝒟, 1], {{Subscript[𝒟, 2s], Subscript[𝒟, 2o]}, {Subscript[𝒟, 2s], Subscript[𝒟, 2o]}}];

Generate random variates:

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

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, {0, 11, 0.4}, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 11}, WorkingPrecision -> 20, PlotStyle -> Thick]]

Warm Standby and Imperfect Switching (4)

Warm standby system where the switch succeeds with a probability p:

Wolfram Language code:

𝒟 = StandbyDistribution[ExponentialDistribution[Subscript[λ, 1]], {{ExponentialDistribution[Subscript[λ, 2s]], ExponentialDistribution[Subscript[λ, 2o]]}}, p];

Compute the mean time to failure:

Wolfram Language code: Mean[𝒟]

Warm standby system where the switch has a lifetime distribution:

Wolfram Language code:

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

Compute the mean time to failure:

Wolfram Language code: Mean[𝒟]

Warm standby system where the switch is modeled with a lifetime distribution:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, S]} = {ExponentialDistribution[1 / 2], ExponentialDistribution[1], ExponentialDistribution[2], ExponentialDistribution[1 / 3]};

Wolfram Language code:

𝒮 = StandbyDistribution[Subscript[𝒟, 1], {{Subscript[𝒟, 2s], Subscript[𝒟, 2o]}, {Subscript[𝒟, 2s], Subscript[𝒟, 2o]}}, Subscript[𝒟, S]];

Generate random variates:

Wolfram Language code: data = RandomVariate[𝒮, 10^5];

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, {0, 11, 0.4}, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 11}, PlotStyle -> Thick]]

System where the switch succeeds with a probability:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, S]} = {ExponentialDistribution[1 / 2], ExponentialDistribution[1], ExponentialDistribution[2], ExponentialDistribution[1 / 3]};

Wolfram Language code:

𝒮 = StandbyDistribution[Subscript[𝒟, 1], {{Subscript[𝒟, 2s], Subscript[𝒟, 2o]}, {Subscript[𝒟, 2s], Subscript[𝒟, 2o]}}, 9 / 10];

Wolfram Language code: data = RandomVariate[𝒮, 10^5];

Wolfram Language code:

Show[Histogram[data, {0, 8, 1 / 3}, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 11}, PlotStyle -> Thick]]

Mixed Warm and Cold Standby Systems (3)

Standby system where the second component can fail while in standby:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, 3]} = {ExponentialDistribution[10], ExponentialDistribution[1], ExponentialDistribution[2], ExponentialDistribution[3]};

Wolfram Language code:

Subscript[𝒟, wc] = StandbyDistribution[Subscript[𝒟, 1], {{Subscript[𝒟, 2s], Subscript[𝒟, 2o]}, Subscript[𝒟, 3]}];

The system where the second and third component switch places:

Wolfram Language code:

Subscript[𝒟, cw] = StandbyDistribution[Subscript[𝒟, 1], {Subscript[𝒟, 3], {Subscript[𝒟, 2s], Subscript[𝒟, 2o]}}];

Compare the survival functions:

Wolfram Language code:

Plot[{Legended[SurvivalFunction[Subscript[𝒟, wc], t], "Warm first"], Legended[SurvivalFunction[Subscript[𝒟, cw], t], "Cold first"]}//Evaluate, {t, 0, 3}, PlotRange -> {0, 1}, Filling -> Axis]

A mixed cold and warm standby system, where the switch succeeds with probability :

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, 3]} = {ExponentialDistribution[1], ExponentialDistribution[1 / 10], ExponentialDistribution[2], ExponentialDistribution[3]};

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

Find the hazard function:

Wolfram Language code: Plot[HazardFunction[𝒮, t]//Evaluate, {t, 0, 5}, PlotRange -> {0, Full}, Filling -> Axis]

Generate random numbers and compare with probability density:

Wolfram Language code: data = RandomVariate[𝒮, 10^5];

Wolfram Language code:

Show[Histogram[data, {0, 6, 1 / 3}, "PDF"], 
	Plot[PDF[𝒮, t]//Evaluate, {t, 0, 11}, PlotStyle -> Thick]]

Standby system where one component can fail while in standby, and a switch with a lifetime:

Wolfram Language code:

{Subscript[𝒟, 1], Subscript[𝒟, 2s], Subscript[𝒟, 2o], Subscript[𝒟, 3], Subscript[𝒟, S]} = {ExponentialDistribution[1], ExponentialDistribution[1 / 10], ExponentialDistribution[2], ExponentialDistribution[3], ExponentialDistribution[Subscript[λ, s]]};

Wolfram Language code:

𝒮 = StandbyDistribution[Subscript[𝒟, 1], {{Subscript[𝒟, 2s], Subscript[𝒟, 2o]}, Subscript[𝒟, 3]}, Subscript[𝒟, S]];

Compare the survival functions with different switch failure rates:

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

Wolfram Language code:

Plot[Table[Legended[sf /. Subscript[λ, s] -> f, Subscript[λ, s] == f], {f, 0.1, 3.1}]//Evaluate, {t, 0, 4}, PlotRange -> {0, 1}]

Applications (2)

The lifetime of a component is exponentially distributed. To improve reliability, a second identical component is acquired. Find the most efficient use of this second component:

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

One alternative is a parallel configuration:

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

Another alternative is a standby configuration, with a switch that succeeds with probability p:

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

Plot the survival function of the two alternatives and compare with the original component, assuming perfect switching:

Wolfram Language code:

Plot[Evaluate[Legended[SurvivalFunction[#[[2]], t], #[[1]]]& /@ {{"Component", 𝒟}, {"Parallel", ℛ}, {"Standby", 𝒮 /. p -> 1}}], {t, 0, 400}]

Simulate failure times for 30 standby systems and find the best configuration:

Wolfram Language code: μ = NExpectation[t, t𝒮 /. p -> 1];

Wolfram Language code: ListPlot[{RandomVariate[𝒮 /. p -> 1, 30], {{0, μ}, {30, μ}}}, Joined -> {False, True}, Filling -> Axis]

Check how bad a switch you can use while still being better than a parallel system:

Wolfram Language code:

Plot[Evaluate[Legended[SurvivalFunction[#[[2]], t], #[[1]]]& /@ Join[{{"Parallel", ℛ}}, Table[{p == i, 𝒮 /. p -> i}, {i, {0.2, 0.5, 0.8}}]]], {t, 0, 400}]

The requirement on the switch to equal a parallel system gets lower with time:

Wolfram Language code: {r} = Quiet[Solve[SurvivalFunction[ℛ, t] == SurvivalFunction[𝒮, t], p]]

Wolfram Language code: Plot[p /. r, {t, 0, 400}, AxesOrigin -> {0, 0}, AxesLabel -> {t, p}]

Consider a computer server. It requires a power supply, hard drives, a network card, and a router to fulfill its intended function. The power supply is backed by a backup power outlet and a diesel generator in cold standby:

Wolfram Language code:

𝒮power = StandbyDistribution[ExponentialDistribution[1 / 615], {ExponentialDistribution[1], ExponentialDistribution[1]}];

The hard drives are in a RAID configuration, which requires 2 out of 3 to work:

Wolfram Language code:

ℛhdd = ReliabilityDistribution[BooleanCountingFunction[{2, 3}, {x, y, z}], {{x, LogNormalDistribution[4, 1]}, {y, LogNormalDistribution[3, 1]}, {z, LogNormalDistribution[4, 1]}}];

The network card has a second card in standby:

Wolfram Language code: 𝒮net = StandbyDistribution[WeibullDistribution[1, 3], {WeibullDistribution[1, 2]}];

Two routers are connected in parallel:

Wolfram Language code: ℛrouter = ReliabilityDistribution[a∨b, {{a, ExponentialDistribution[1 / 3]}, {b, ExponentialDistribution[1 / 4]}}];

Wolfram Language code:

ℛ = ReliabilityDistribution[power∧hdd∧net∧router, {{power, 𝒮power}, {hdd, ℛhdd}, {net, 𝒮net}, {router, ℛrouter}}];

The resulting survival function:

Wolfram Language code: Refine[SurvivalFunction[ℛ, t], t > 0]

Plot it:

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

Compute the mean time to failure numerically:

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

Find the probability that the server survives for three months:

Wolfram Language code: Probability[t > 3, tℛ]//N

Define a consumer version that does not contain any redundancy:

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

Wolfram Language code: 𝒟hdd = ReliabilityDistribution[x∧y, {{x, LogNormalDistribution[4, 1]}, {y, LogNormalDistribution[3, 1]}}];

Wolfram Language code: 𝒟net = WeibullDistribution[1, 3];

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

Wolfram Language code:

ℛconsumer = ReliabilityDistribution[power∧hdd∧net∧router, {{power, 𝒟power}, {hdd, 𝒟hdd}, {net, 𝒟net}, {router, 𝒟router}}];

Compare the survival functions:

Wolfram Language code: Plot[Evaluate[SurvivalFunction[#, t]& /@ {ℛ, ℛconsumer}], {t, 0, 10}, Filling -> Axis]

Properties & Relations (9)

Cold standby corresponds to the sum of component lifetimes:

Wolfram Language code:

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

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

Wolfram Language code: 𝒯 = TransformedDistribution[x + y, {xSubscript[𝒟, 1], ySubscript[𝒟, 2]}];

Compare the survival functions:

Wolfram Language code: SurvivalFunction[𝒮, t]

Wolfram Language code: SurvivalFunction[𝒯, t]

Wolfram Language code: FullSimplify[%% - %]

Cold standby with identical exponentially distributed components is an ErlangDistribution:

Wolfram Language code:

𝒮 = StandbyDistribution[ExponentialDistribution[λ], {ExponentialDistribution[λ]}];
ℰ = ErlangDistribution[2, λ];

Wolfram Language code: SurvivalFunction[ℰ, t]

Wolfram Language code: SurvivalFunction[𝒮, t]

Wolfram Language code: Simplify[%% - %]

Cold standby where component lifetimes follow the ExponentialDistribution corresponds to the HypoexponentialDistribution:

Wolfram Language code:

𝒮 = StandbyDistribution[ExponentialDistribution[Subscript[λ, 1]], {ExponentialDistribution[Subscript[λ, 2]]}];
ℋ = HypoexponentialDistribution[{Subscript[λ, 1], Subscript[λ, 2]}];

Wolfram Language code: SurvivalFunction[ℋ, t]

Wolfram Language code: SurvivalFunction[𝒮, t]

Wolfram Language code: Simplify[%% - %]

StandbyDistribution is a special case of TransformedDistribution:

Wolfram Language code:

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

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

Wolfram Language code:

𝒯 = TransformedDistribution[x + y Boole[s ≥ x], {xSubscript[𝒟, 1], ySubscript[𝒟, 2], sSubscript[𝒟, s]}];

Compare the survival functions:

Wolfram Language code: SurvivalFunction[𝒮, t]

Wolfram Language code: SurvivalFunction[𝒯, t]

Wolfram Language code: FullSimplify[%% - %]

StandbyDistribution is a special case of MixtureDistribution:

Wolfram Language code:

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

Wolfram Language code:

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

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

Compare the probability density function:

Wolfram Language code: PDF[ℳ, t]

Wolfram Language code: PDF[𝒟, t]

Wolfram Language code: FullSimplify[%% - %, t > 0]

StandbyDistribution can be used in ReliabilityDistribution:

Wolfram Language code:

𝒟 = ReliabilityDistribution[x∨y, {{x, StandbyDistribution[ExponentialDistribution[Subscript[λ, 1]], {ExponentialDistribution[Subscript[λ, 2]]}]}, {y, WeibullDistribution[α, β]}}];

Compute the survival function:

Wolfram Language code: SurvivalFunction[𝒟, t]

ReliabilityDistribution can be used in StandbyDistribution:

Wolfram Language code:

𝒟 = StandbyDistribution[ReliabilityDistribution[x∧y, {{x, ExponentialDistribution[2]}, {y, ExponentialDistribution[3]}}], {ExponentialDistribution[1]}];

Generate random numbers:

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

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, 35, "PDF"], 
	Plot[PDF[𝒟, x]//Evaluate, {x, 0, 10}, PlotStyle -> Thick, PlotRange -> All]]

StandbyDistribution can be used in FailureDistribution:

Wolfram Language code:

𝒟 = FailureDistribution[x∧y, {{x, StandbyDistribution[ExponentialDistribution[Subscript[λ, 1]], {ExponentialDistribution[Subscript[λ, 2]]}]}, {y, WeibullDistribution[α, β]}}];

Compute the survival function:

Wolfram Language code: SurvivalFunction[𝒟, t]

FailureDistribution can be used in StandbyDistribution:

Wolfram Language code:

𝒟 = StandbyDistribution[FailureDistribution[x∧y, {{x, ExponentialDistribution[2]}, {y, ExponentialDistribution[3]}}], {ExponentialDistribution[1]}];

Generate random numbers:

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

Compare with the probability density function:

Wolfram Language code:

Show[Histogram[data, 35, "PDF"], 
	Plot[PDF[𝒟, x]//Evaluate, {x, 0, 10}, PlotStyle -> Thick, PlotRange -> All]]

Possible Issues (1)

Component distributions need to have a positive domain:

Wolfram Language code: 𝒮 = StandbyDistribution[NormalDistribution[6, 2], {ExponentialDistribution[3]}];

Wolfram Language code: SurvivalFunction[𝒮, x]

Use TruncatedDistribution to restrict the domain to positive values only:

Wolfram Language code: 𝒮 = StandbyDistribution[ExponentialDistribution[3], {TruncatedDistribution[{0, ∞}, NormalDistribution[6, 2]]}];

Wolfram Language code: SurvivalFunction[𝒮, t]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

StandbyDistribution

Details

Examples

Basic Examples (3)

Scope (17)

Cold Standby and Perfect Switching (3)

Cold Standby and Imperfect Switching (4)

Warm Standby and Perfect Switching (3)

Warm Standby and Imperfect Switching (4)

Mixed Warm and Cold Standby Systems (3)

Applications (2)

Properties & Relations (9)

Possible Issues (1)

Text

CMS

APA

BibTeX

BibLaTeX

StandbyDistribution

Details

Examples

Basic Examples (3)

Scope (17)

Cold Standby and Perfect Switching (3)

Cold Standby and Imperfect Switching (4)

Warm Standby and Perfect Switching (3)

Warm Standby and Imperfect Switching (4)

Mixed Warm and Cold Standby Systems (3)

Applications (2)

Properties & Relations (9)

Possible Issues (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX