({{, (RefLink[OutputResponse, paclet:ref/OutputResponse])[sys,u,{t,(Subscript[t, min]),(Subscript[t, max])}] 
gives the numeric output response of systems model sys to the input u for (Subscript[t, min])≤t≤(Subscript[t, max]).}, {, (RefLink[OutputResponse, paclet:ref/OutputResponse])[sys,{u[0],u[1],…}] 
gives the output response of the discrete-time system sys to the input sequence u[i].}, {, (RefLink[OutputResponse, paclet:ref/OutputResponse])[sys,u,t]
gives the symbolic output response of system sys to the input u as a function of time t.}, {, (RefLink[OutputResponse, paclet:ref/OutputResponse])[sys,{(Subscript[u, 1]),…,(Subscript[u, m])},…]
gives the output response for multiple inputs (Subscript[u, i]). }})

OpenersNotesSection(Spacer1)Details

(RefLink[OutputResponse, paclet:ref/OutputResponse]) is also known as impulse response, step response, and ramp response.

(RefLink[OutputResponse, paclet:ref/OutputResponse]) solves the underlying differential or difference equations for the given input.

The systems model sys can be a (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]), a (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]), a continuous-time (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]), or a continuous-time (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]).

A linear (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]) or (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) sys can also be a descriptor and delay system.

The initial values for the differential and difference equations are taken to be zero for a (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]). For the state-space models, they are taken to be the state operating values of sys unless specified.

(RefLink[OutputResponse, paclet:ref/OutputResponse])[{sys,{(Subscript[x, 10]),(Subscript[x, 20]),…,(Subscript[x, n0])}},…] can be used to specify the initial state for a state-space model sys.

For descriptor state-space systems, the initial states need to be consistent.

For delay state-space systems, the initial states include history and can be given as (Subscript[x, i0])[t] for t≤0. »

OpenersPrimaryExamplesSection(Spacer1)Examples  (59)

OpenersExampleSection0(Spacer1)Basic Examples  (4)

The step response of a second-order system:

Simplify[OutputResponse[(TransferFunctionModelFull[((ω^2)/((ω^2)+2 ζ ω s+(s^2))), , , ]),UnitStep[t],t]]

The output response of a transfer-function model to a sinusoidal input:

OutputResponse[(TransferFunctionModelFull[(1/(1+s)), , , ]),Sin[10 t],t]

Visualize the response:

Plot[%,{t,0,10}]

The response of a state-space model from nonzero initial conditions:

OutputResponse[{(StateSpaceModelFull[-2, 0.8`, 0, 1, -0.8`, -2, 0, 0, 0, 0, -1, -1, 1, 0, 0, 0, , , ]),{1,0.1,1}},0,t]

Plot[%,{t,0,3},PlotRange->All]

The response of a discrete-time system to a sampled sinusoid:

OutputResponse[(StateSpaceModelFull[-0.1`, 0, 1, 0, 0.3`, -1, 1, 0, 0, 0.1`, , ]),Table[Sin[k],{k,0,20}]]

ListPlot[Map[Thread[{Range[Length[#]]-1,#}]&,%],Joined->True,InterpolationOrder->0]

OpenersExampleSection1(Spacer1)Scope  (41)

OpenersExampleSubsection0(Spacer1)Basic Uses  (13)

Find the initial value response for a scalar continuous-time state-space model:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, , , ]),{x0}},{0},t]

Find the zero initial condition response for a symbolic input:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, , , ]),{0}},{u[t]},t]

Find the numeric response of a fourth-order system to a sinusoidal input:

OutputResponse[(StateSpaceModelFull[-(1/3), 0, 1, 3, 1, 0, -2, 1, 2, -1, -1, 0, -1, 0, 0, 0, 0, 1, -(1/2), 0, 1, 0, 0, 1, 0, , , ]),{Sin[2Pit]},{t,0,10}]

Plot[%,{t,0,10}, PlotRange->All]

Find the numeric step response for a continuous-time transfer-function model:

tfm=(TransferFunctionModelFull[(1/(5+s+(s^2))), , , ]);

OutputResponse[tfm,UnitStep[t],{t,0,10}]

Plot[%,{t,0,10}, PlotRange->All]

Get the symbolic solution:

Simplify[OutputResponse[tfm,UnitStep[t],t]]

Plot[%,{t,0,10}, PlotRange->All]

Find the numeric step response for a discrete-time state-space model:

OutputResponse[(StateSpaceModelFull[0, 1, 0, -0.2`, 0.5`, 1.`, 1.`, 1, 0, 0.5`, , ]),{1},{t,0,10}]

Find the step response for a discrete-time transfer function with a numeric simulation:

(Subscript[tfm, d])=(TransferFunctionModelFull[((1.` +z)/((1/10)-((2 z)/3)+(z^2))), 1, , ]);

OutputResponse[(Subscript[tfm, d]),UnitStep[t],{t,0,10}]

ListPlot[%,PlotRange->All]

Get the symbolic solution:

OutputResponse[(Subscript[tfm, d]),UnitStep[t],t]

ListPlot[Table[First[%],{t,0,10}],PlotRange->All]

Find the numeric response of a two-output fourth-order system to a triangle wave:

OutputResponse[(StateSpaceModelFull[-1, 2, 2, 0, 1, -1, -2, -1, -1, 2, -2, 0, -2, -2, 0, 2, 1, 0, -1, -1, 1, -1, 0, 0, 0, 0, 0, 1, -1, 0, , , ]),{TriangleWave[t]},{t,0,5}];
Plot[Evaluate@%,{t,0,5}]

Find the symbolic response of a three-output transfer-function model:

Simplify[OutputResponse[(TransferFunctionModelFull[(2/(1+3 s)), (1/(1+((5 s)/4)+(s^2))), 7, , , ]),{Sin[t]},t]]

Find the response of a state-space model with output delays:

OutputResponse[(StateSpaceModelFull[0, 1, 0, -0.8`, -2.`, 1, 3 (SystemsModelDelay[2]), 0, 0, 0, (SystemsModelDelay[1]), 0, , , ]),Sin[2 π t],{t,0,7}];
Plot[Evaluate@%,{t,0,7}]

A system with two inputs:

OutputResponse[(StateSpaceModelFull[1, -1, 0, 1, 2, 0, 1, 1, 0, 0, 0, 0, -1, 0, 2, 1, -1, 0, 0, 0, , , ]),{1,3},t]

When a multiple-input system receives a single input, it is applied separately to each input:

OutputResponse[(StateSpaceModelFull[0, (Subscript[b, 1]), (Subscript[b, 2]), 1, 0, 0, , , ]),UnitStep[t],t]

A numeric response for a multiple-input, multiple-output transfer-function model:

OutputResponse[(TransferFunctionModelFull[(1/s), (1/(1+s)), (1/(2+s)), (1/(3+s)), , , ]),{Sin[2t-Pi/2],Sin[t]},{t,0,20}];
Plot[Evaluate@%,{t,0,20}]

A second-order system settling from nonzero initial states:

OutputResponse[{(StateSpaceModelFull[0, 1, 0, -(1/10), -(1/2), 1, 1, 0, 0, , , ]),{0,3}},{0},t]

Plot[Evaluate@%,{t,0,40}]

OpenersExampleSubsection1(Spacer1)Continuous-Time Systems  (19)

The output response of a continuous-time system to a step input:

tf[ω_,ζ_]:=(TransferFunctionModelFull[((ω^2)/((ω^2)+2 ζ ω s+(s^2))), , , ])
OutputResponse[tf[1,(1/2)],UnitStep[t],t]

The response for various damping ratios:

Plot[Evaluate@Table[Tooltip[OutputResponse[tf[1,ξ],UnitStep[t],t],ξ],{ξ,Range[0,1.4,0.2]}],{t,0,15},Frame->True,PlotRange->All,GridLines->Automatic]

The response to a unit step input:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, , ]),(Subscript[x, 0])},UnitStep[t],t]

The response of a descriptor (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]):

Expand[OutputResponse[{(StateSpaceModelFull[e, a, b, c, d, , ]),(Subscript[x, 0])},u[t],t]]

The response when there is an algebraic equation:

Simplify[OutputResponse[{(StateSpaceModelFull[(Subscript[e, 1]), 0, (Subscript[a, 1]), 0, (Subscript[b, 1]), 0, 0, 0, (Subscript[a, 2]), (Subscript[b, 2]), (Subscript[c, 1]), (Subscript[c, 2]), (Subscript[d, 1]), , ]),{(Subscript[x, 1]),(Subscript[x, 2])}},u[t],t]]

The response of a state-space model:

y=OutputResponse[(StateSpaceModelFull[-1, 1, 0, 0, -2, 1, 1, 0, 0, , , ]),UnitStep[t],t]

Plot[y,{t,0,7}]

The initial values of the states are assumed to be zero:

OutputResponse[{(StateSpaceModelFull[-1, 1, 0, 0, -2, 1, 1, 0, 0, , , ]),{0,0}},UnitStep[t],t]==y

The response of a two-output system to a delayed step input:

OutputResponse[(TransferFunctionModelFull[(1/(1+s)), (1/(1+2 s+(s^2))), , , ]),UnitStep[t-1],t]

Plot[Evaluate@%,{t,0,7},PlotRange->All]

The output response for nonzero initial conditions:

OutputResponse[{(StateSpaceModelFull[-1, 1, 0, 0, -2, 1, 1, 0, 0, , , ]),{2,5}},UnitStep[t],t]

Plot the response:

Plot[Evaluate@%,{t,0,7}]

The output response for a system with two inputs:

OutputResponse[(TransferFunctionModelFull[(s/(1+s)), (1/(3+s)), ((2+s)/(1+s)), (s/(3+s)), , , ]),{Sin[t],Cos[2 t]},t]

A second-order system step response goes from oscillations at ζ==0 to overdamped at ζ==1.2`:

Plot3D[Evaluate[OutputResponse[(TransferFunctionModelFull[(1/(1+2 ζ s+(s^2))), , , ]),UnitStep[t],t]],{ζ,0,1.2},{t,0,15},AxesLabel->{"ζ",t,"y(t)"},MeshFunctions->{#1&},PlotRange->All]

If there are fewer input signals than system inputs, the remaining signals are set to zero:

Simplify[OutputResponse[(TransferFunctionModelFull[(s/(1+s)), (1/(3+s)), ((2+s)/(1+s)), (s/(3+s)), , , ]),{Sin[t]},t]]

A multi-input system:

tfm=(TransferFunctionModelFull[((2+s)/(1+s+(s^2))), (1/(1+s)), , , ]);

When a scalar input signal is given, it is applied to each input in turn:

OutputResponse[tfm,UnitStep[t],t]==
(OutputResponse[tfm,#,t]&/@Permutations[{UnitStep[t],0},{2}])

If the time interval is specified, the result is computed numerically:

tfm=(TransferFunctionModelFull[((80+72 s+25 (s^2)+3 (s^3))/(80+96 s+40 (s^2)+8 (s^3)+(s^4))), , , ]);
y1=OutputResponse[tfm,UnitStep[t],{t,6}]

The symbolic result:

y2=OutputResponse[tfm,UnitStep[t],t]

The results are equivalent:

Plot[{y1,y2},{t,0,6},PlotRange-> All]

The response of a generic continuous-time system:

Expand[OutputResponse[{(StateSpaceModelFull[a, b, c, d, , , ]),(Subscript[x, 0])},u[t],t]]

The response to a sine wave:

Expand[OutputResponse[{(StateSpaceModelFull[a, b, c, d, , , ]),(Subscript[x, 0])},Sin[t],t]]

Step response of a time-delay transfer-function model:

OutputResponse[(TransferFunctionModelFull[((E^(-3 s))/(6+(s^2))), , , ]),{UnitStep[t]},{t,0,7}];
Plot[%,{t,0,7}]

Step response of a time-delay state-space model:

OutputResponse[(StateSpaceModelFull[0, 1, 0, -3, 0.5` (SystemsModelDelay[1]), 1, (SystemsModelDelay[2]), 0, 0, , , ]),Sin[t],{t,0,20}];
Plot[%,{t,0,20}]

A (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) with a singular descriptor matrix:

OutputResponse[(StateSpaceModelFull[2, 3, 1, 3, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 3, 1, 3, 1, 3, 3, 1, 1, 1, 0, 1, 3, 0, 1, 0, 1, 3, -9, -6, -5, -11, 1, 1, 0, 0, 0, 0, , , ]),1,t]

Plot the response:

Plot[%,{t,0,8}]

The output response of an (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]) to a (RefLink[UnitStep, paclet:ref/UnitStep]) input:

OutputResponse[(AffineStateSpaceModelFull[(Subscript[x, 2]), -Sin[(Subscript[x, 1])]-(Subscript[x, 1]^3)-(Subscript[x, 2]^2), 0, 1, (Subscript[x, 1]), 0, (Subscript[x, 1]), (Subscript[x, 2]), \[Null], \[Null], AutomaticAutomatic, ]),UnitStep[t],{t,0,12}]

Plot the response:

Plot[%,{t,0,12}]

The response from nonzero initial conditions:

OutputResponse[(AffineStateSpaceModelFull[(Subscript[x, 2]), -Sin[(Subscript[x, 1])]-(Subscript[x, 1]^3)-(Subscript[x, 2]^2), 0, 1, (Subscript[x, 1]), 0, {(Subscript[x, 1]),-1}, {(Subscript[x, 2]),0.25`}, \[Null], \[Null], AutomaticAutomatic, ]),UnitStep[t],{t,0,12}];
Plot[%,{t,0,12}]

The output response of a (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]) to a (RefLink[UnitStep, paclet:ref/UnitStep]) input:

OutputResponse[(NonlinearStateSpaceModelFull[(Subscript[x, 2]), (Sin[u]-Sin[(Subscript[x, 1])]) (Subscript[x, 1]), (Subscript[x, 1]), {(Subscript[x, 1]),0.1`}, {(Subscript[x, 2]),0}, \[Null], \[Null], {u}Automatic, ]),UnitStep[t],{t,0,30}]

Plot the response:

Plot[%,{t,0,30}]

OpenersExampleSubsection2(Spacer1)Discrete-Time Systems  (9)

The output response of a single-input system to a sampled sinusoid:

OutputResponse[(StateSpaceModelFull[0, 1, 0, -0.5`, 1.5`, 1, 0, 1, 0, 1, , ]),Table[Sin[t],{t,0,15}]]

Plot of the sampled output with a zero-order hold:

ListPlot[Map[Thread[{Range[Length[#]]-1,#}]&,%],Joined->True,InterpolationOrder->0]

The response for a generic discrete-time system:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, T, ]),(Subscript[x, 0])},u[k],k]

The response to a unit step sequence:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, T, ]),(Subscript[x, 0])},1,k]

The response for a symbolic descriptor system:

Simplify[OutputResponse[{(StateSpaceModelFull[(Subscript[e, 1]), 0, (Subscript[a, 1]), 0, (Subscript[b, 1]), 0, 0, 0, (Subscript[a, 2]), (Subscript[b, 2]), (Subscript[c, 1]), (Subscript[c, 2]), (Subscript[d, 1]), T, , ]),{(Subscript[x, 1]),Automatic}},u[t],t]]

The response of a two-input system:

OutputResponse[(TransferFunctionModelFull[(z/(-0.5`+z)), ((-0.1`+z)/(0.5` +z)), (1/(-0.5`+z)), (4/(0.5` +z)), 1, , ]),{Table[Sin[k],{k,0,3,0.1}],Table[SquareWave[k],{k,0,3,0.1}]}]

ListPlot[Map[Thread[{Range[Length[#]]-1,#}]&,%],Joined->True,InterpolationOrder->0]

The response of a first-order discrete-time system:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, T, , ]),(Subscript[x, 0])},u[k],k]

The response to a unit step sequence:

OutputResponse[{(StateSpaceModelFull[a, b, c, d, T, , ]),(Subscript[x, 0])},1,k]

The output response of a discrete-time system to a time-dependent input:

Simplify[OutputResponse[(TransferFunctionModelFull[(((T^2) (1+z))/(2 (((-1+z))^2))), τ, , ]),(Sqrt[k]),k]]

The response for T=0.1:

ListPlot[Flatten[Table[%/.T->0.1,{k,Range[20]}]]]

Ramp response of a time-delay system:

OutputResponse[(StateSpaceModelFull[0, 1.`, 0, -1, -0.75`, 1, (SystemsModelDelay[2]), (SystemsModelDelay[3]), 0, 0.2`, , ]),{{1,2,3,4,5,6,7,8,9}}];
ListPlot[%]

OpenersExampleSection2(Spacer1)Generalizations & Extensions  (3)

If the initial time is not specified, it is assumed to be zero:

OutputResponse[(StateSpaceModelFull[-3, 1, 2, 0, , ]),{UnitStep[t]},{t,2}];

Plot[%, {t, 0,2}]

When a system has state delays, the initial states can include history:

OutputResponse[{(StateSpaceModelFull[-1+((SystemsModelDelay[2])/2), 0, 1, 0, , ]),{-t}},{0},{t,10}];

Plot[%, {t, 0,10}]

For discrete-time systems with delays, the initial states can be given as a sequence:

OutputResponse[{(StateSpaceModelFull[(1/2) (-1-(SystemsModelDelay[3])), 0, 1, 0, 1, ]),{{-3,-1,-3,-1}}},{0},{t,0,10}]

ListPlot[%]

OpenersExampleSection3(Spacer1)Applications  (3)

Determine the steady-state output value of a stable first-order system in response to a unit step input:

y=OutputResponse[(TransferFunctionModelFull[(1/(1+10 s)), , , ]),UnitStep[t],t][[1]];(Subscript[y, ss])=Limit[y,t->∞]

The time constant:

τ=t/.FindRoot[y==(1-(1/E)) (Subscript[y, ss]),{t,1}]

Visualize it:

With[{y1=y/.t->τ},Plot[y,{t,0,40},Epilog->{Dashed,Line[{{τ,0},{τ,y1},{0,y1}}],PointSize[Medium],Point[{{τ,y1}}]}]]

Visualize the response of an unstable system, and its response after feedback stabilization:

antenna=(TransferFunctionModelFull[((0.0019` (1+z))/(0.9802` -1.9802` z+(z^2))), 0.2`, , ]);
ListPlot[OutputResponse[antenna,UnitStep[k],{k,10}]]

comp=(TransferFunctionModelFull[((9.15` (-0.9802`+z))/(-0.8187`+z)), 0.2`, , ]);ListPlot[OutputResponse[SystemsModelFeedbackConnect[SystemsModelSeriesConnect[antenna,comp]],UnitStep[k],{k,10}]]

The zero-input response of a system:

Simplify[OutputResponse[{(StateSpaceModelFull[0, 1, 0, -0.18`, 0.9`, 1, 1, 0, 0, 0.5`, , ]),{0.1,-0.1}},0,k]]

OpenersExampleSection4(Spacer1)Properties & Relations  (5)

The natural response is determined by the poles of the system:

ssm=(StateSpaceModelFull[0, 1, 0, -0.18`, 0.9`, 1, 1.`, 0, 0, 0.3`, , ]);
Simplify[OutputResponse[{ssm,0.02},0,k]]

The poles:

Eigenvalues[First[Normal[ssm]]]

The results of (RefLink[StateResponse, paclet:ref/StateResponse]) and (RefLink[OutputResponse, paclet:ref/OutputResponse]) match for state output:

ssm=(StateSpaceModelFull[0.5`, 0.1`, 1, 0, 1, , ]);
With[{seq=RandomReal[1,20]},OutputResponse[ssm,seq]==StateResponse[ssm,seq]]

A discrete-time system responding to a continuous-time input:

Length[OutputResponse[(TransferFunctionModelFull[(z/(-0.5`+z)), 1, , ]),UnitStep[t],{t,0,50}][[1]]]

For a smaller sampling period, more sample points are needed:

Length[OutputResponse[(TransferFunctionModelFull[(z/(-0.5`+z)), 0.5`, , ]),UnitStep[t],{t,0,50}][[1]]]

The impulse response of a system:

sys=((2 s+1)/((s^2)+3 s+2));
u=DiracDelta[t];
y=OutputResponse[TransferFunctionModel[sys,s],u,t][[1]]//Simplify

(RefLink[OutputResponse, paclet:ref/OutputResponse]) assumes that the input is zero for t<0:

Refine[y,t<0]

Thus the solution obtained using (RefLink[InverseLaplaceTransform, paclet:ref/InverseLaplaceTransform]) is different for t<0:

InverseLaplaceTransform[sys LaplaceTransform[u,t,s],s,t]

Refine[y,t>0]==%

The initial states for a descriptor systems are chosen to be consistent for the inputs:

ssm=(StateSpaceModelFull[1, 0, 1, -5, 2, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, , , ]);
u={Sin[t]};

y=OutputResponse[ssm,u,t]

The second output equals the derivative of the input:

y/.t->0

When inconsistent conditions are given, they are replaced:

OutputResponse[{ssm,{0,0,0}},u,t]

%/.t->0

Consistent initial states depend on the slow subsystem from (RefLink[KroneckerModelDecomposition, paclet:ref/KroneckerModelDecomposition]):

kssm=Last@KroneckerModelDecomposition[ssm];
slowsystem=SystemsModelExtract[kssm,All,All,{2,3}]

For continuous-time systems, the initial conditions are given by (Subscript[x, 2])(0)==-(∑_(i=0)^(h-1))(Subscript[e, 2]^i).(Subscript[b, 2]).((∂^i)/(∂(t^i)))u(0):

{b2,e2}=Normal[slowsystem][[{2,5}]];
-(b2.u+e2.b2.D[u,t])/.t->0

OpenersExampleSection5(Spacer1)Possible Issues  (3)

A continuous-time system cannot be simulated with sampled inputs:

ssm=(StateSpaceModelFull[0, 1, 0, -1, -10.2`, 1, 0, -10, 0, , , ]);
OutputResponse[ssm,RandomReal[{0,1},10]]

Discretize the system:

OutputResponse[ToDiscreteTimeModel[ssm,1],RandomReal[{0,1},10]]

Computations with machine numbers can be unstable:

tfm=(TransferFunctionModelFull[((100 s)/(1000000+100 s+0.0001` (s^2))), , , ]);
OutputResponse[tfm,UnitStep[t],t]/.t->1

Rationalize the system:

Plot[OutputResponse[Rationalize[tfm],UnitStep[t],t]//Evaluate,{t,0,0.0005}]

For descriptor systems, solutions only exist when (RefLink[Det, paclet:ref/Det])[λ e - a]≠0 for some λ:

ssm=(StateSpaceModelFull[1, 0, -1, 0, 1, 0, 0, 2, 0, -1, 1, 0, 0, , , ]);
OutputResponse[ssm,{Sin[t]},{t,0,10}]

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[StateResponse, paclet:ref/StateResponse])  ▪  (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel])  ▪  (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel])  ▪  (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel])  ▪  (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel])  ▪  (RefLink[NDSolve, paclet:ref/NDSolve])  ▪  (RefLink[RecurrenceFilter, paclet:ref/RecurrenceFilter])  ▪  (RefLink[RecurrenceTable, paclet:ref/RecurrenceTable])  ▪  (RefLink[DSolve, paclet:ref/DSolve])  ▪  (RefLink[RSolve, paclet:ref/RSolve])  ▪  (RefLink[InverseLaplaceTransform, paclet:ref/InverseLaplaceTransform])  ▪  (RefLink[InverseZTransform, paclet:ref/InverseZTransform])  ▪  (RefLink[GreenFunction, paclet:ref/GreenFunction])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Control Systems, paclet:guide/ControlSystems])}, {▪(RefLinkPlain[Delay Control Systems, paclet:guide/DelayControlSystems])}, {▪(RefLinkPlain[Nonlinear Control Systems, paclet:guide/NonlinearControlSystems])}, {▪(RefLinkPlain[Descriptor Control Systems, paclet:guide/DescriptorControlSystems])}})}})