WOLFRAM

Wolfram Language & System Documentation Center

FullInformationOutputRegulator[sys,rspec]

gives the full state information output regulator for sys using specification rspec.

FullInformationOutputRegulator[{sys,{out1,…},{in1,…}},…]

specifies the regulated outputs outi and the controlled inputs inj.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Applications  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

FullInformationOutputRegulator

FullInformationOutputRegulator[sys,rspec]

gives the full state information output regulator for sys using specification rspec.

FullInformationOutputRegulator[{sys,{out1,…},{in1,…}},…]

specifies the regulated outputs outi and the controlled inputs inj.

Details and Options

  • FullInformationOutputRegulator returns a regulator that drives the sys outputs to zero and is typically used to suppress or track known inputs to the system.
  • The system sys is taken to have state equations and and outputs , with being the controllable input. The state is not affected by the input and is used to model signals to suppress or track, as indicated by the output function .
  • Typical output functions , which the regulator will drive to zero:
  • suppress the effects of on the states
    cause to track
  • The system sys can be StateSpaceModel, AffineStateSpaceModel, or NonlinearStateSpaceModel.
  • The computed state feedback regulates sys about an operating point using .
  • The state feedback has the form , where , , and is computed following rspec.
  • Possible regulator specifications rspec:
  • {"Poles",{p1,…}}computed with StateFeedbackGains
    {"Weights",{p,…}}computed with LQRegulatorGains
    {"Gains",κ}explicitly given gains
  • With the specification {"method",pars,opts}, the options opts are passed to the gain computation function.
  • The outputs {out1,…} and inputs {in1,…} are part specifications and by default are taken to be All.

Examples

open all close all

Basic Examples  (1)

Compute the regulating feedback for a system with a constant disturbance of 0.5:

Wolfram Language code: sys = AffineStateSpaceModel[{{w + 2*Subscript[x, 1] + Subscript[x, 2], Subscript[x, 1] - 2*Subscript[x, 2], 0}, {{1}, {0}, {0}}, {Subscript[x, 1] + Subscript[x, 2]}, {{0}}}, {{Subscript[x, 1], 0}, {Subscript[x, 2], 0}, {w, 0.5}}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None];

The regulator is a function of the states and the disturbance state :

Wolfram Language code: k = FullInformationOutputRegulator[sys, {"Poles", {-1, -2}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, k]

The output is regulated to zero:

Wolfram Language code: res1 = OutputResponse[{sys, {1, 1, 0.5}}, 0, {t, 0, 5}]; res2 = OutputResponse[{csys, {1, 1, 0.5}}, 0, {t, 0, 5}];
Wolfram Language code: Plot[{res1, res2}, {t, 0, 5}, PlotRange -> {0, 5}, PlotLegends -> {"unregulated", "regulated"}]

Scope  (8)

The regulator for a linear system with the exosystem pole at the origin:

Wolfram Language code: FullInformationOutputRegulator[ssm = StateSpaceModel[{{{p, r}, {0, 0}}, {{b}, {0}}, {{c, 0}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {"Poles", {Subscript[p, f]}}]

The closed-loop system:

Wolfram Language code: SystemsModelStateFeedbackConnect[ssm, %]//Simplify

The exosystem has a pair of complex poles:

Wolfram Language code: ssm = StateSpaceModel[{{{p, Subscript[r, 1], Subscript[r, 2]}, {0, 0, ω}, {0, -ω, 0}}, {{b}, {0}, {0}}, {{c, 0, 0}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];
Wolfram Language code: Assuming[ω ∈ Reals, FullInformationOutputRegulator[ssm, {"Poles", {Subscript[p, f]}}]]

The closed-loop system:

Wolfram Language code: SystemsModelStateFeedbackConnect[ssm, %]//Simplify

The exosystem's states are part of the regulator:

Wolfram Language code: ssm = StateSpaceModel[{{{p, Subscript[r, 1], Subscript[r, 2]}, {0, 0, ω}, {0, -ω, 0}}, {{b}, {0}, {0}}, {{c, Subscript[c, 1], Subscript[c, 2]}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];
Wolfram Language code: Assuming[ω ∈ Reals, FullInformationOutputRegulator[ssm, {"Poles", {Subscript[p, f]}}]]

The closed-loop system:

Wolfram Language code: SystemsModelStateFeedbackConnect[ssm, %]

The response:

Wolfram Language code: OutputResponse[{%, {Subscript[x, 10], Subscript[w, 10], Subscript[w, 20]}}, 0, t]//FullSimplify

The system is regulated if pf is negative:

Wolfram Language code: % /. Subscript[p, f] -> -5 /. Thread[{c, Subscript[c, 1], Subscript[c, 2], Subscript[x, 10], Subscript[w, 10], Subscript[w, 20]} -> RandomReal[1, 6]]

Regulate an AffineStateSpaceModel:

Wolfram Language code: Assuming[ω∈Reals, FullInformationOutputRegulator[AffineStateSpaceModel[{{p*x + x^2 + Subscript[c, 1]*Subscript[w, 1] + Subscript[c, 2]* Subscript[w, 2], ω*Subscript[w, 2], (-ω)*Subscript[w, 1]}, {{b}, {0}, {0}}, {x}, {{0}}}, {x, Subscript[w, 1], Subscript[w, 2]}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {"Poles", {Subscript[p, f]}}]]

Regulate a NonlinearStateSpaceModel:

Wolfram Language code: FullInformationOutputRegulator[NonlinearStateSpaceModel[ {{p*x + w*Subscript[c, 1] + u*Subscript[c, 2] + u*w*x* Subscript[c, 3], 0}, {x}}, {x, w}, {u}, {Automatic}, Automatic, SamplingPeriod -> None], {"Poles", {Subscript[p, f]}}]

Specify the regulated outputs and feedback inputs:

Wolfram Language code: FullInformationOutputRegulator[{StateSpaceModel[{{{0, 0}, {r, p}}, {{0, Subscript[b, 1]}, {Subscript[b, 2], 0}}, {{1, 0}, {0, 1}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {2}, {1}}, {"Poles", {Subscript[p, f]}}]

Use LQRegulatorGains to compute the stabilizing gains by specifying the weights:

Wolfram Language code: FullInformationOutputRegulator[AffineStateSpaceModel[{{w + x, 0}, {{1}, {0}}, {x}, {{0}}}, {x, w}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {"Weights", {{{1}}, {{1}}}}]

Specify the gains to use:

Wolfram Language code: FullInformationOutputRegulator[AffineStateSpaceModel[{{w + x, 0}, {{1}, {0}}, {x}, {{0}}}, {x, w}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {"Gains", {{k}}}]

Applications  (6)

Reject a disturbance modeled as :

Wolfram Language code: dModel = NonlinearStateSpaceModel[w''[t] + w[t] == 0, {{w[t], 0}, {w'[t], 1}}, {}, {}, t];

The full model of the system with disturbance:

Wolfram Language code: nsys = NonlinearStateSpaceModel[{{x[t] + Subscript[, 1][t] + v[t]}, {x[t]}}, {{x[t], 0}}, {v[t]}, Automatic, t];
Wolfram Language code: sys = SystemsModelMerge[{dModel, nsys}]

The regulator:

Wolfram Language code: k = FullInformationOutputRegulator[sys, {"Poles", {-2}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, k]

The output is regulated in the presence of the disturbance:

Wolfram Language code: OutputResponse[{csys, {0, 1, 1}}, 0, {t, 0, 3}];
Wolfram Language code: Plot[%, {t, 0, 3}, PlotRange -> All]

Track an input modeled as :

Wolfram Language code: iModel = NonlinearStateSpaceModel[w''[t] + w[t] == 0, {{w[t], 0}, {w'[t], 1}}, {}, {}, t];

The full model of the system and input model:

Wolfram Language code: nsys = NonlinearStateSpaceModel[{{x[t] + Subscript[, 1][t] + v[t]}, {x[t], x[t] - Subscript[, 1][t]}}, {{x[t], 0}}, {Subscript[, 1][t], v[t]}, Automatic, t];
Wolfram Language code: sys = SystemsModelMerge[{iModel, nsys}]

The regulator:

Wolfram Language code: k = FullInformationOutputRegulator[{sys, 2}, {"Poles", {-2}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelExtract[SystemsModelStateFeedbackConnect[sys, k], All, 1]

The output tracks the input:

Wolfram Language code: or = OutputResponse[{csys, {0, 1, 0.5}}, 0, {t, 0, 10}]; Plot[or, {t, 0, 10}, PlotRange -> All]

Simultaneously track a step input and reject a sinusoidal disturbance:

Wolfram Language code: iModel = NonlinearStateSpaceModel[{{0}, {x - r}}, {{r, 1}}, {}]
Wolfram Language code: dModel = NonlinearStateSpaceModel[{{Subscript[w, 2], -Subscript[w, 1]}, {}}, {{Subscript[w, 1], 0}, {Subscript[w, 2], 1}}, {}]

The complete system:

Wolfram Language code: nsys = NonlinearStateSpaceModel[{{x + r + Subscript[w, 1] + v}, {x}}, {{x, 0}}, {r, Subscript[w, 1], v}]
Wolfram Language code: sys = SystemsModelMerge[{nsys, iModel, dModel}]

Obtain the regulator:

Wolfram Language code: k = FullInformationOutputRegulator[{sys, 2}, {"Poles", {-8}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelExtract[SystemsModelStateFeedbackConnect[sys, k], All, 1]

The simulation shows the output tracking a step signal:

Wolfram Language code: OutputResponse[NonlinearStateSpaceModel[csys, {x -> -1, r -> 1, Subscript[w, 1] -> 0, Subscript[w, 2] -> 1}], 0, {t, 0, 5}]; Plot[%, {t, 0, 5}, PlotRange -> All]

Regulate an aircraft's longitudinal dynamics in the presence of disturbances:»

Wolfram Language code: aircraft = StateSpaceModel[{{{0, 14.3877, 0, -31.5311}, {-0.0012, -0.4217, 1, -0.0284}, {0.0002, -0.3816, -0.4658, 0}, {0, 0, 1, 0}}, {{0.7898, -0.6526, -0.335, 0.4637, 0.9185}, {-0.00588, 0.0049, 0.0025, -0.0035, -0.0068}, {-0.2541, 0.21, 0.1078, -0.1492, -0.2959}, {0, 0, 0, 0, 0}}, {{1, 0, 0, 0}}, {{0, 0, 0, 0, 0}}}, {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4]}, {u, Subscript[w, 1], Subscript[w, 2], Subscript[w, 3], Subscript[w, 4]}, SamplingPeriod -> None, SystemsModelLabels -> None];

The disturbances consist of two frequency components:

Wolfram Language code: dist = StateSpaceModel[{{{0, -0.1, 0, 0}, {0.1, 0, 0, 0}, {0, 0, 0, -0.2}, {0, 0, 0.2, 0}}, {{}, {}, {}, {}}, {}}, {Subscript[w, 1], Subscript[w, 2], Subscript[w, 3], Subscript[w, 4]}, SamplingPeriod -> None, SystemsModelLabels -> None];

The complete system:

Wolfram Language code: sys = SystemsModelMerge[{aircraft, dist}]

A control law that regulates the output (speed) in the presence of the disturbances:

Wolfram Language code: fb = FullInformationOutputRegulator[sys, {"Poles", {-1, -2, -2.5 + I, -2.5 - I}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, fb]

Simulation showing regulation being achieved:

Wolfram Language code: OutputResponse[{csys, {0.1, 0.001, 0, 0, 1, 0, 1, 0}}, 0, {t, 0, 8}]; Plot[%, {t, 0, 8}, PlotRange -> All]

The control effort:

Wolfram Language code: fb.StateResponse[{csys, {0.1, 0.001, 0, 0, 1, 0, 1, 0}}, 0, {t, 0, 150}]; Plot[%, {t, 0, 150}, PlotRange -> All]

Regulate a Rössler prototype-4 system:»

Wolfram Language code: asys = AffineStateSpaceModel[{{-Subscript[x, 2] - Subscript[x, 3], Subscript[x, 1], 0.5*(Subscript[x, 2] - Subscript[x, 2]^2) - 0.5*Subscript[x, 3]}, {{0}, {0}, {1}}, {-w + Subscript[x, 2]}, {{0}}}, {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None];

Its chaotic behavior:

Wolfram Language code: StateResponse[{asys /. w -> 0, RandomReal[{-1, 1}, 3]}, 0, {t, 0, 300}]; ParametricPlot3D[%, {t, 0, 300}]

The complete model such that the state is regulated and kept constant:

Wolfram Language code: tmodel = NonlinearStateSpaceModel[{{0}, {}}, w, {}]; sys = SystemsModelMerge[{asys, tmodel}]

A feedback law:

Wolfram Language code: fb = FullInformationOutputRegulator[sys, {"Poles", {-1, -1.5 + I, -1.5 - I}}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, fb]

Simulations show that is regulated and the system has no chaotic behavior with feedback:

Wolfram Language code: StateResponse[{csys, Join[RandomReal[{-1, 1}, 3], {1}]}, 0, {t, 0, 8}]; Plot[Evaluate[Most[%]], {t, 0, 8}, PlotLegends -> {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}]

Regulate the voltage in a Chua circuit to follow a sinusoid while rejecting a disturbance that is the output of another Chua circuit:»

The affine model of the Chua circuit where the nonlinearity is a cubic polynomial:

Wolfram Language code: pars = {Subscript[𝒞, 1] -> 1, Subscript[𝒞, 2] -> 1, ℒ -> 1, ℛ -> 1};
Wolfram Language code: asys = AffineStateSpaceModel[{{(-2*Subscript[𝒱, 1] - Subscript[𝒱, 1]^3 + (-Subscript[𝒱, 1] + Subscript[𝒱, 2])/ℛ)/ Subscript[𝒞, 1], (-𝒾 + (Subscript[𝒱, 1] - Subscript[𝒱, 2])/ ℛ)/Subscript[𝒞, 2], (-Subscript[ℰ, 2] + Subscript[𝒱, 2])/ℒ}, {{-Subscript[𝒞, 1]^(-1)}, {0}, {0}}, {-Subscript[ℰ, 4] + Subscript[𝒱, 2]}, {{0}}}, {Subscript[𝒱, 1], Subscript[𝒱, 2], 𝒾}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None] /. pars;

The exosystem, where ω is the frequency of the sinusoid to be tracked:

Wolfram Language code: pars1 = {Subscript[𝒞, 1] -> 1, Subscript[𝒞, 2] -> 1, ℒ -> 1, ℛ -> 1, ω -> 10};
Wolfram Language code: nsys = NonlinearStateSpaceModel[ {{(-Subscript[ℰ, 1] - 2*Subscript[ℰ, 1]^3 + (-Subscript[ℰ, 1] + Subscript[ℰ, 2])/ℛ)/ Subscript[𝒞, 1], ((Subscript[ℰ, 1] - Subscript[ℰ, 2])/ℛ - Subscript[ℰ, 3])/Subscript[𝒞, 2], Subscript[ℰ, 2]/ℒ, ω*Subscript[ℰ, 5], (-ω)*Subscript[ℰ, 4]}, {}}, {Subscript[ℰ, 1], Subscript[ℰ, 2], Subscript[ℰ, 3], Subscript[ℰ, 4], Subscript[ℰ, 5]}, {}, Automatic, Automatic, SamplingPeriod -> None, SystemsModelLabels -> {{}, None}] /.  pars1;

The complete system:

Wolfram Language code: sys = SystemsModelMerge[{asys, nsys}]

The poles of the disturbance model:

Wolfram Language code: Subscript[poles, d] = Eigenvalues@First@Normal@StateSpaceModel[nsys]//N

The system poles consist of the three new poles and the stabilizable poles:

Wolfram Language code: decays = Join[{-1, -2, -3}, DeleteCases[%, Complex[_ ? PossibleZeroQ, _]]]

The regulator:

Wolfram Language code: k = FullInformationOutputRegulator[{sys, All, All, {7, 8}}, {"Poles", decays}]

The closed-loop system:

Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, k]//Simplify

The simulation shows that the regulation is achieved:

Wolfram Language code: OutputResponse[{csys, {10, 0, 0.1, 0, 0, 0, 0, -1}}, 0, {t, 0, 10}]; Plot[%, {t, 0, 10}, PlotRange -> All]

Properties & Relations  (4)

StateFeedbackGains is a special case:

Wolfram Language code: ssm = StateSpaceModel[{{{2, 0, -1}, {0, -2, 1}, {1, -1, 1}}, {{1, 1}, {0, 1}, {1, -1}}, {{1, -1, 0}, {0, 1, -1}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]; poles = {-1, -2, -3};
Wolfram Language code: FullInformationOutputRegulator[ssm, {"Poles", poles}]
Wolfram Language code: StateFeedbackGains[ssm, poles]

LQRegulatorGains is a special case:

Wolfram Language code: ssm = StateSpaceModel[{{{2, 0, -1}, {0, -2, 1}, {1, -1, 1}}, {{1, 1}, {0, 1}, {1, -1}}, {{1, -1, 0}, {0, 1, -1}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]; weights = {IdentityMatrix[3], IdentityMatrix[2]};
Wolfram Language code: FullInformationOutputRegulator[N@ssm, {"Weights", weights}]
Wolfram Language code: LQRegulatorGains[N@ssm, weights]

Obtain the closed-loop system using SystemsModelStateFeedbackConnect:

Wolfram Language code: sys = NonlinearStateSpaceModel[{{u + w + p*x, 0}, {x}}, {x, w}, {u}, {Automatic}, Automatic, SamplingPeriod -> None];
Wolfram Language code: SystemsModelStateFeedbackConnect[sys, FullInformationOutputRegulator[sys, {"Poles", {Subscript[p, f]}}]]

Output regulation is achieved:

Wolfram Language code: sys = StateSpaceModel[{{{2, 0, -1, 1}, {0, -2, 1, 0}, {1, -1, 1, 0}, {0, 0, 0, 0}}, {{1, 1}, {0, 1}, {1, -1}, {0, 0}}, {{1, -1, 0, 0}, {0, 1, -1, 0}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];
Wolfram Language code: k = FullInformationOutputRegulator[sys, {"Poles", N@{-1, -2, -3}}]
Wolfram Language code: csys = SystemsModelStateFeedbackConnect[sys, k]
Wolfram Language code: OutputResponse[{csys, RandomReal[2, 4]}, 0, {t, 0, 5}]; Plot[Evaluate[%], {t, 0, 5}, PlotRange -> All]
Wolfram Research (2014), FullInformationOutputRegulator, Wolfram Language function, https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html.

Text

Wolfram Research (2014), FullInformationOutputRegulator, Wolfram Language function, https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html.

CMS

Wolfram Language. 2014. "FullInformationOutputRegulator." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html.

APA

Wolfram Language. (2014). FullInformationOutputRegulator. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html

BibTeX

@misc{reference.wolfram_2026_fullinformationoutputregulator, author="Wolfram Research", title="{FullInformationOutputRegulator}", year="2014", howpublished="\url{https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_fullinformationoutputregulator, organization={Wolfram Research}, title={FullInformationOutputRegulator}, year={2014}, url={https://reference.wolfram.com/language/ref/FullInformationOutputRegulator.html}, note=[Accessed: 13-June-2026]}