Wolfram Language & System Documentation Center

StateTransformationLinearize

StateTransformationLinearize[asys]

linearizes the AffineStateSpaceModel asys by state transformation.

StateTransformationLinearize[asys,{z,lform}]

specifies the new states z and form of linearization lform.

StateTransformationLinearize[asys,…,"prop"]

computes the property "prop".

Details and Options

StateTransformationLinearize attempts to transform an affine system to a linear one so that linear control techniques can be used on the linearized dynamics.
Using a state transformation x->p[z], the original affine system with dynamics and output gets transformed to an input-output, input-state, or state-output linear system.
The following forms of exact linearization lform can be used:
Automatic automatically linearize

"InputOutput" ,

"InputState" ,

"StateOutput" ,
The Automatic setting will attempt "InputOutput", "InputState", or "StateOutput".
StateTransformationLinearize returns a LinearizingTransformationData object that can be used to extract detailed properties for further analysis and design.
Properties related to the state transformation include:

	"InverseStateTransformation"	inverse state transformation
	"StateTransformation"	state transformation
	"TransformedSystem"	linearized or partially linearized transformed system tsys
	"Linearization"	form of linearization "lform"

Properties related to controller and estimator design include:

	{"OriginalSystemController",cs}	controller for asys based on controller cs designed for tsys
	{"OriginalSystemEstimator",es}	estimator for asys based on estimator es designed for tsys
	{"ClosedLoopSystem",cs}	closed-loop system based on the linear controller cs

Examples

open all close all

Basic Examples (1)

Linearize an affine system using state transformation:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[
 {{(-4*Subscript[x, 1]^2 + 6*Subscript[x, 1]*
      Subscript[x, 2])/(Subscript[x, 1] + Subscript[x, 2]), 
   2*(3*Subscript[x, 1] - 2*Subscript[x, 2])*
    (Subscript[x, 2]/(Subscript[x, 1] + Subscript[x, 2]))}, 
  {{(1 - Subscript[x, 1])/(Subscript[x, 1] + 
      Subscript[x, 2])}, {(1 + Subscript[x, 2])/
     (Subscript[x, 1] + Subscript[x, 2])}}, 
  {Subscript[x, 1]*(-1 + Subscript[x, 2]) + 
    Subscript[x, 2]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {Subscript[, 1]}, {Automatic}, Automatic, 
 SamplingPeriod -> None]]

The transformed system is completely linear:

Wolfram Language code: ℒ["TransformedSystem"]

Compute feedback gains for the system, using the linearized system:

Wolfram Language code: κ = StateFeedbackGains[%, {-4 + 2 I, -4 - 2I}]

The closed-loop system:

Wolfram Language code: ℒ[{"ClosedLoopSystem", κ}]//Simplify

The closed-loop system is stable:

Wolfram Language code:

OutputResponse[{%, {2, 1}}, UnitStep[t], {t, 0, 10}];
Plot[%, {t, 0, 3}, PlotRange -> All]

Scope (12)

Basic Uses (5)

Linearize an affine system:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[{{Subscript[x, 2] - 2*Subscript[x, 2]*
     Subscript[x, 3] + Subscript[x, 3]^2, Subscript[x, 3], 
   0}, {{4*Subscript[x, 2]*Subscript[x, 3]}, 
   {-2*Subscript[x, 3]}, {1}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

The transformed system shows that the state-to-output dynamics have been linearized:

Wolfram Language code: ℒ["TransformedSystem"]

Explicitly obtain the type of linearization:

Wolfram Language code: ℒ["Linearization"]

Specify the new state variables to use:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[{{Subscript[x, 2] - 2*Subscript[x, 2]*
     Subscript[x, 3] + Subscript[x, 3]^2, Subscript[x, 3], 
   0}, {{4*Subscript[x, 2]*Subscript[x, 3]}, 
   {-2*Subscript[x, 3]}, {1}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {Subscript[z, 1], Subscript[z, 2], Subscript[z, 3]}];

Wolfram Language code: ℒ["TransformedSystem"]

Specify the type of linearization to use:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[{{Subscript[x, 2] - 2*Subscript[x, 2]*
     Subscript[x, 3] + Subscript[x, 3]^2, Subscript[x, 3], 
   0}, {{4*Subscript[x, 2]*Subscript[x, 3]}, 
   {-2*Subscript[x, 3]}, {1}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {{Subscript[z, 1], Subscript[z, 2], Subscript[z, 3]}, "InputState"}];

The input dynamics are linear, but the output is nonlinear:

Wolfram Language code: ℒ["TransformedSystem"]

Wolfram Language code: ℒ["Linearization"]

Specify the property upfront:

Wolfram Language code:

StateTransformationLinearize[AffineStateSpaceModel[{{Subscript[x, 2] - 2*Subscript[x, 2]*
     Subscript[x, 3] + Subscript[x, 3]^2, Subscript[x, 3], 
   0}, {{4*Subscript[x, 2]*Subscript[x, 3]}, 
   {-2*Subscript[x, 3]}, {1}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], {{Subscript[z, 1], Subscript[z, 2], Subscript[z, 3]}, "InputState"}, "TransformedSystem"]

Multiple properties can be specified:

Wolfram Language code:

asys = AffineStateSpaceModel[{{Subscript[x, 2] - 2*Subscript[x, 2]*
     Subscript[x, 3] + Subscript[x, 3]^2, Subscript[x, 3], 
   0}, {{4*Subscript[x, 2]*Subscript[x, 3]}, 
   {-2*Subscript[x, 3]}, {1}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys, {{Subscript[z, 1], Subscript[z, 2], Subscript[z, 3]}, "InputState"}];

Specify several properties:

Wolfram Language code: ℒ[{"StateTransformation", "InverseStateTransformation"}]

Input-Output Linearize (3)

Get transformation-related properties:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[{{5*Subscript[x, 1] + Subscript[x, 2] + 
    Subscript[x, 2]^2, Subscript[x, 2]*
    ((1 + Subscript[x, 2])/(1 + 2*Subscript[x, 2]))}, 
  {{1, 0}, {0, (1 + 2*Subscript[x, 2])^(-1)}}, {Subscript[x, 1]}, 
  {{0, 0}}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {{Subscript[, 1], 0}, {Subscript[, 2], 0}}, {Automatic}, Automatic, SamplingPeriod -> None]]

Forward and inverse state transformations:

Wolfram Language code: {ℒ["StateTransformation"], ℒ["InverseStateTransformation"]}

The transformed linear system:

Wolfram Language code: ℒ["TransformedSystem"]

Design controllers using exact and approximate linearization, and compare:

Wolfram Language code:

asys = AffineStateSpaceModel[{{(Subscript[x, 1]*(1 - 4*Subscript[x, 2]) - 
     Subscript[x, 2]*(3 + 14*Subscript[x, 2] + 
       16*Subscript[x, 2]^2))/(2 + 4*Subscript[x, 2]), 
   (3*(Subscript[x, 1] + Subscript[x, 2] + 
      2*Subscript[x, 2]^2))/(2 + 4*Subscript[x, 2])}, 
  {{1, -(2 + 4*Subscript[x, 2])^(-1)}, 
   {0, -(2 + 4*Subscript[x, 2])^(-1)}}, 
  {Subscript[x, 1] - Subscript[x, 2]}, {{0, 0}}}, 
 {Subscript[x, 1], Subscript[x, 2]}, 
 {{Subscript[, 1], 0}, {Subscript[, 2], 0}}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys];

The transformed system:

Wolfram Language code: tsys = ℒ["TransformedSystem"]

Design a controller and observer for the linearized system:

Wolfram Language code:

egains = EstimatorGains[tsys, {-8, -10}];
rgains = StateFeedbackGains[tsys, {-2, -3}];

Wolfram Language code: EstimatorRegulator[tsys, {egains, rgains}, "EstimatorRegulatorFeedbackModel"]

The closed-loop system:

Wolfram Language code: csys1 = ℒ[{"ClosedLoopSystem", %}]

The simulation of the closed-loop system:

Wolfram Language code: res1 = OutputResponse[{csys1, {0.2, 0.1, 0, 0}}, {0, 0}, {t, 0, 3}];

Wolfram Language code: Plot[res1, {t, 0, 3}, PlotRange -> All]

A controller based on approximate linearization, using same specifications:

Wolfram Language code: lsys = StateSpaceModel[asys];

Wolfram Language code:

egains = EstimatorGains[lsys, {-8, -10}];
rgains = StateFeedbackGains[lsys, {-2, -3}];

Wolfram Language code: EstimatorRegulator[lsys, {egains, rgains}, "EstimatorRegulatorFeedbackModel"]

Simulate the system:

Wolfram Language code: csys2 = SystemsModelFeedbackConnect[asys, %];

Wolfram Language code: res2 = OutputResponse[{csys2, {0.2, 0.1, 0, 0}}, {0, 0}, {t, 0, 3}];

Wolfram Language code: Plot[res2, {t, 0, 3}, PlotRange -> All]

Compare the responses:

Wolfram Language code: Plot[{res1, res2}, {t, 0, 3}, PlotLegends -> {"exact linearization", "approximate linearization"}]

Design estimators using exact and approximate linearization, and compare:

Wolfram Language code:

ℒ = StateTransformationLinearize[asys = AffineStateSpaceModel[{{(-(1 + Subscript[x, 1]))*
    ((3*Subscript[x, 1] - 2*Subscript[x, 2])/
     (1 + Subscript[x, 1] + Subscript[x, 2])), 
   (-1 + 2*Subscript[x, 1] - 3*Subscript[x, 2])*
    (Subscript[x, 2]/(1 + Subscript[x, 1] + 
      Subscript[x, 2]))}, 
  {{-Subscript[x, 1]/(1 + Subscript[x, 1] + 
      Subscript[x, 2])}, {(1 + Subscript[x, 2])/
     (1 + Subscript[x, 1] + Subscript[x, 2])}}, 
  {Subscript[x, 1]*(-1 + Subscript[x, 2]) + 
    2*Subscript[x, 2]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {Subscript[, 1]}, {Automatic}, Automatic, 
 SamplingPeriod -> None]]

The transformed system:

Wolfram Language code: tsys = ℒ["TransformedSystem"]

The estimator for the original system:

Wolfram Language code: EstimatorGains[tsys, {-6 + 4I, -6 - 4I}];

Wolfram Language code: estim = ℒ[{"OriginalSystemEstimator", StateOutputEstimator[tsys, %]}]

The trajectories of the estimated states:

Wolfram Language code: or = OutputResponse[{asys, {-2, -1}}, 0, {t, 0, 5}];

Wolfram Language code: res1 = OutputResponse[SystemsModelDelete[estim, None, 3], Join[{0}, or], {t, 0, 5}];

Wolfram Language code: Plot[res1, {t, 0, 5}, PlotRange -> All]

An estimator based on approximate linearization, using the same specification:

Wolfram Language code: lsys = StateSpaceModel[asys];

Wolfram Language code: aestim = StateOutputEstimator[asys, EstimatorGains[lsys, {-6 + 4I, -6 - 4I}]]

The trajectories of the estimated states, based on approximate linearization:

Wolfram Language code: res2 = OutputResponse[SystemsModelDelete[aestim, None, 3], Join[{0}, or], {t, 0, 5}];

Wolfram Language code: Plot[Evaluate[%], {t, 0, 5}, PlotRange -> All]

Compute the actual state trajectories:

Wolfram Language code: res = StateResponse[{asys, {-2, -1}}, 0, {t, 0, 10}];

Compare the actual and estimated trajectories of the first state:

Wolfram Language code:

Plot[Evaluate[First /@ {res, res1, res2}], {t, 0, 4}, PlotRange -> All, PlotLegends -> {"Actual", "Exact linearization", "Approximate linearization"}]

Compare the actual and estimated trajectories of the second state:

Wolfram Language code:

Plot[Evaluate[Last /@ {res, res1, res2}], {t, 0, 4}, PlotRange -> All, PlotLegends -> {"Actual", "Exact linearization", "Approximate linearization"}]

State-Output Linearize (2)

Get transformation-related properties:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[
 {{((-1 + Subscript[x, 1])*(Subscript[x, 1]*
       (-2 + Subscript[x, 2]) + Subscript[x, 2]))/
    (-1 + Subscript[x, 1] - 2*Subscript[x, 2]), 
   (-(-1 + Subscript[x, 1] - 2*Subscript[x, 2])^(-1))*
    Subscript[x, 2]*(-3 - 5*Subscript[x, 2] + 
     Subscript[x, 1]*(1 + Subscript[x, 2]))}, 
  {{(2 + Subscript[x, 1])/(1 - Subscript[x, 1] + 
      2*Subscript[x, 2])}, 
   {(-1 + Subscript[x, 1] - 2*Subscript[x, 2])^(-1)}}, 
  {Subscript[x, 1]*(1 + 2*Subscript[x, 2])}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2]}, {{Subscript[, 1], 0}}, 
 {Automatic}, Automatic, SamplingPeriod -> None]]

Forward and inverse state transformations:

Wolfram Language code: ℒ["StateTransformation"]

Wolfram Language code: ℒ["InverseStateTransformation"]

The transformed system with linear dynamics from state to output:

Wolfram Language code: ℒ["TransformedSystem"]

Design an estimator using exact linearization:

Wolfram Language code:

asys = AffineStateSpaceModel[{{(Subscript[x, 1]*(2 - 8*Subscript[x, 2]) - 
     6*Subscript[x, 2]^2)/(-1 + 2*Subscript[x, 2]), 
   (2*(Subscript[x, 1] - (-2 + Subscript[x, 2])*
       Subscript[x, 2]))/(-1 + 2*Subscript[x, 2])}, 
  {{(-(-1 + 2*Subscript[x, 2])^(-1))*(Subscript[x, 1] + 
      (1 + Subscript[x, 2])^2)}, 
   {(2 + Subscript[x, 1] + Subscript[x, 2]^2)/
     (-1 + 2*Subscript[x, 2])}}, 
  {2*Subscript[x, 1] + Subscript[x, 2] + Subscript[x, 2]^2}, 
  {{0}}}, {Subscript[x, 1], Subscript[x, 2]}, Automatic, {Automatic}, 
 Automatic, SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys]

The transformed system:

Wolfram Language code: tsys = ℒ["TransformedSystem"]

The estimator for the original system:

Wolfram Language code: EstimatorGains[StateSpaceModel@tsys, {-6, -7}];

Wolfram Language code: estim = ℒ[{"OriginalSystemEstimator", StateOutputEstimator[StateSpaceModel@tsys, %]}]

The trajectories of the estimated states:

Wolfram Language code: or = OutputResponse[{asys, {0.1, 0.2}}, 0, {t, 0, 10}];

Wolfram Language code: res1 = OutputResponse[SystemsModelDelete[estim, None, 3], Join[{0}, or], {t, 0, 2}];

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

The actual state trajectories:

Wolfram Language code: res = StateResponse[{asys, {0.1, 0.2}}, 0, {t, 0, 2}];

Compare the estimated and actual state trajectories:

Wolfram Language code:

Plot[Evaluate@Join[res, res1], {t, 0, 2}, PlotRange -> All, PlotLegends -> {"State 1", "State 2", "Estimated State 1", "Estimated State 2"}]

Input-State Linearize (2)

Get transformation-related properties:

Wolfram Language code:

ℒ = StateTransformationLinearize[AffineStateSpaceModel[{{4*Subscript[x, 1], 7*Subscript[x, 1]^2 + 
    Subscript[x, 2]}, {{1}, {-1 + 2*Subscript[x, 1]}}, 
  {Subscript[x, 1] - Subscript[x, 2]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2]}, {{Subscript[, 1], 0}}, 
 {Automatic}, Automatic, SamplingPeriod -> None]]

Forward and inverse state transformations:

Wolfram Language code: {ℒ["StateTransformation"], ℒ["InverseStateTransformation"]}

The transformed system with linear dynamics from input to state:

Wolfram Language code: ℒ["TransformedSystem"]//Simplify

Design controllers using exact and approximate linearization, and compare:

Wolfram Language code:

ℒ = StateTransformationLinearize[asys = AffineStateSpaceModel[{{Subscript[x, 1] - 5*Subscript[x, 2]^2 + 
    Subscript[x, 2]*Subscript[x, 3] + 2*Subscript[x, 3]^2, 
   -Subscript[x, 2] - 2*Subscript[x, 3], 
   5*Subscript[x, 2] + Subscript[x, 3]}, 
  {{1, (Subscript[x, 2] + Subscript[x, 3])/3}, {0, -1/3}, {0, -1/3}}, 
  {Subscript[x, 1]}, {{0, 0}}}, {Subscript[x, 1], 
  Subscript[x, 2], Subscript[x, 3]}, 
 {{Subscript[, 1], 0}, {Subscript[, 2], 0}}, {Automatic}, Automatic, SamplingPeriod -> None]]

The transformed system:

Wolfram Language code: tsys = ℒ["TransformedSystem"]

A controller based on exact linearization:

Wolfram Language code: κ1 = LQRegulatorGains[StateSpaceModel[N@tsys], {IdentityMatrix[3], 5 IdentityMatrix[2]}];

Wolfram Language code: ℒ[{"OriginalSystemController", κ1}]//Expand

The closed-loop system:

Wolfram Language code: csys1 = ℒ[{"ClosedLoopSystem", κ1}]//Simplify

The design based on approximate linearization:

Wolfram Language code: lsys = StateSpaceModel[asys];

Wolfram Language code: k2 = LQRegulatorGains[lsys, {IdentityMatrix[3], 5 IdentityMatrix[2]}]//N

The closed-loop system with feedback, based on approximate linearization:

Wolfram Language code: csys2 = SystemsModelStateFeedbackConnect[asys, k2]//Simplify//Chop

Compare the two designs:

Wolfram Language code:

OutputResponse[AffineStateSpaceModel[#, {Subscript[x, 1] -> -6, Subscript[x, 2] -> 4, Subscript[x, 3] -> -1}], {0, 0}, {t, 0, 10}]& /@ {csys1, csys2};

Wolfram Language code: Plot[Evaluate[%], {t, 0, 10}, PlotLegends -> {"Exact linearization", "Approximate linearization"}, PlotRange -> All]

Properties & Relations (4)

The transformed system is related to the input system by StateSpaceTransform:

Wolfram Language code:

asys = AffineStateSpaceModel[{{3*(1 + Subscript[x, 1])*Subscript[x, 2], 
   ((2 - 3*Subscript[x, 2])*Subscript[x, 2] + 
     Subscript[x, 1]*(1 + 2*Subscript[x, 2] - 
       3*Subscript[x, 2]^2))/(1 + Subscript[x, 1])}, 
  {{-1}, {Subscript[x, 2]/(1 + Subscript[x, 1])}}, 
  {-2*(Subscript[x, 2] + Subscript[x, 1]*
      (1 + Subscript[x, 2]))}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {{Subscript[, 1], 0}}, {Automatic}, Automatic, 
 SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys, {Subscript[z, 1], Subscript[z, 2]}];

Wolfram Language code:

{AffineStateSpaceModel@ℒ["TransformedSystem"], 
	StateSpaceTransform[asys, ℒ[{"StateTransformation", "InverseStateTransformation"}]]}

The input-output linearized system is controllable and observable:

Wolfram Language code:

asys = AffineStateSpaceModel[{{3*(1 + Subscript[x, 1])*Subscript[x, 2], 
   ((2 - 3*Subscript[x, 2])*Subscript[x, 2] + 
     Subscript[x, 1]*(1 + 2*Subscript[x, 2] - 
       3*Subscript[x, 2]^2))/(1 + Subscript[x, 1])}, 
  {{-1}, {Subscript[x, 2]/(1 + Subscript[x, 1])}}, 
  {-2*(Subscript[x, 2] + Subscript[x, 1]*
      (1 + Subscript[x, 2]))}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {{Subscript[, 1], 0}}, {Automatic}, Automatic, 
 SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys, {{Subscript[z, 1], Subscript[z, 2]}, "InputOutput"}];

Wolfram Language code: {ControllableModelQ[ℒ["TransformedSystem"]], ObservableModelQ[ℒ["TransformedSystem"]]}

The state-output linearized system is observable:

Wolfram Language code:

asys = AffineStateSpaceModel[{{(4*Subscript[x, 1] - 6*Subscript[x, 1]^2 + 
     6*Subscript[x, 2])/(1 + 6*Subscript[x, 1]), 
   (30*Subscript[x, 1]^2 - 2*Subscript[x, 2] + 
     24*Subscript[x, 1]*Subscript[x, 2])/
    (1 + 6*Subscript[x, 1])}, {{0}, {1 + Subscript[x, 1]}}, 
  {Subscript[x, 1] - 3*Subscript[x, 1]^2 + 
    2*Subscript[x, 2]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {{Subscript[, 1], 0}}, {Automatic}, Automatic, 
 SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys, {{Subscript[z, 1], Subscript[z, 2]}, "StateOutput"}];

Wolfram Language code: ObservableModelQ[ℒ["TransformedSystem"]]

The input-state linearized system is controllable:

Wolfram Language code:

asys = AffineStateSpaceModel[{{4*Subscript[x, 1], 7*Subscript[x, 1]^2 + 
    Subscript[x, 2]}, {{1}, {-1 + 2*Subscript[x, 1]}}, 
  {Subscript[x, 2]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {{Subscript[, 1], 0}}, {Automatic}, Automatic, 
 SamplingPeriod -> None];

Wolfram Language code: ℒ = StateTransformationLinearize[asys, {{Subscript[z, 1], Subscript[z, 2]}, "InputState"}];

Wolfram Language code: ControllableModelQ[ℒ["TransformedSystem"]]

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

StateTransformationLinearize

Details and Options

Examples

Basic Examples (1)

Scope (12)

Basic Uses (5)

Input-Output Linearize (3)

State-Output Linearize (2)

Input-State Linearize (2)

Properties & Relations (4)

Text

CMS

APA

BibTeX

BibLaTeX

	Automatic	automatically linearize
	"InputOutput"	,
	"InputState"	,
	"StateOutput"	,

StateTransformationLinearize

Details and Options

Examples

Basic Examples (1)

Scope (12)

Basic Uses (5)

Input-Output Linearize (3)

State-Output Linearize (2)

Input-State Linearize (2)

Properties & Relations (4)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX