Sysquake Pro – Table of Contents

Sysquake for LaTeX – Table of Contents

# Library - `lti`

Library `lti`
defines methods related to objects which represent
linear time-invariant dynamical systems. LTI systems may be used to model many
different systems: electro-mechanical devices, robots, chemical processes,
filters, etc. LTI systems map one or more inputs `u` to one or more
outputs `y`. The mapping is defined as a state-space model or
as a matrix of transfer functions, either in continuous time or in discrete
time. Methods are provided to create, combine, and analyze LTI objects.

Graphical methods are based on the corresponding graphical functions; the numerator and denominator coefficient vectors or the state-space matrices are replaced with an LTI object. They accept the same optional arguments, such as a character string for the style.

The following statement makes available functions defined in `lti`:

use lti

Methods for conversion to MathML are defined in library `lti_mathml`.
Both libraries can be loaded with a single statement:

use lti, lti_mathml

### Class overview

The LTI library defines six classes. The three central ones correspond to the
main model structures used for linear time-invariant systems in automatic control:
`ss` for state-space models, `tf` for rational transfer functions
given by the coefficients of the numerator and denominator polynomials, and
`zpk` for rational transfer functions given by their zeros, poles and gain.
State-space representation is restricted to causal systems, while transfer functions
can be non-causal. Three additional classes are more specialized: `frd`
(frequency response data) for systems described by a discrete set of frequency/complex
response pairs, and `pid` or `pidstd` for PID controllers.

LTI classes share many properties and methods. They can represent systems with
single or multiple inputs and/or outputs. Inputs, outputs and internal states are
continuous in time (*continuous-time systems*) or defined at a fixed sampling
frequency (*discrete-time systems*).

The variable of the Laplace transform can be `'s'` or `'p'`.
The variable of the z transform can be `'z'` or `'q'`. By
multiplying the numerator and the denominator of a rational transfer function by a
suitable power of `q^-1` (or `z^-1`), polynomials in `q^-1`
can be obtained, where `q^-1` is the delay operator; this yields directly
a recurrence relation.

### Conversion

Conversion between `ss`, `tf` and `zpk` can be done
simply by calling the target constructor. The only restriction is that systems to be
converted to state-space models must be causal. For instance, a transfer function given
by its zeros, poles and gain can be converted to a state-space model as follows:

use lti; P = zpk([1], [-3+1j, -3-1j], 2) P = continuous-time zero-pole-gain transfer function 2(s-1)/(s-(-3+1j))(s-(-3-1j)) S = ss(P) S = continuous-time LTI state-space system A = -6 -10 1 0 B = 1 0 C = 2 -2 D = 0

Conversion from `pid` or `pidstd` objects is performed the same
way. Conversion to `pid` or `pidstd` objects is possible only if
the system to be converted has the structure of a P, PI, PD, or PID controller, with
or without filter on the derivative term.

Conversion to an `frd` object requires an array of frequency
points where the frequency response is evaluated. Conversion of `frd`
objects to other LTI objects is not possible.

Conversion between continuous-time and discrete-time objects of the same
class is performed with `c2d` and `d2c`.

### Building large systems

Simple systems can be combined to create larger ones. All systems can be
seen as matrices mapping inputs to outputs via a matrix product. Larger
systems can be created by matrix concatenation, addition or multiplication.
More specialized connections can be obtained with methods `connect`
and `feedback`.

Mixing objects of different classes is possible for all classes except for
`frd` (where a frequency array must be provided explicitly, which
can only be done with a call of the `frd` constructor). Continuous-time
objects cannot be connected with discrete-time objects, and discrete-time objects
must have the same sampling period.

## Functions

### frd::frd

LTI frequency response data constructor.

#### Syntax

use lti a = frd a = frd(resp, freq) a = frd(resp, freq, Ts)

#### Description

`frd(response,frequency,Ts)` creates an LTI object which represents
a discrete set of frequency response data.
Argument `response` is an array of complex frequency responses corresping
to frequency array `freq`.

A single-input single-output (SISO) PID controller has scalar parameters. If the parameters are matrices, they must all have the same size (scalar values are replicated as required), and the resulting controller has as many inputs as parameters have columns and as many outputs as parameters have rows; mapping from each input to each output is and independent SISO PID controller.

#### Examples

Simple continuous-time `frd` object:

use lti freq = 0:100; resp = 3 ./ (1 + 0.1 * freq * 1j) + 0.1 * randn(size(freq)); r = frd(resp, freq) r = continuous-time frequency response, units=rad/s 1 input, 1 output 101 frequencies

Conversion from a transfer function object:

freq = 0:100; G = tf(1, [1, 2, 3, 4]); r = frd(G, freq) r = continuous-time frequency response, units=rad/s 1 input, 1 output 101 frequencies

#### See also

### pid::pid

LTI PID controller constructor.

#### Syntax

use lti a = pid a = pid(Kp, Ki, Kd, Tf) a = pid(Kp, Ki, Kd, Tf, Ts) a = pid(Kp, Ki, Kd, Tf, Ts, var) a = pid(..., IFormula=f1, DFormula=f2)

#### Description

`pid(Kp, Ki, Kd, Tf)` creates an LTI object which represents the
continuous-time PID controller
`Kp+Ki/s+Kd.s/(Tf.s+1)``s``Kp` is the proportional gain, `Ki` is the integral gain,
`Kd` is the derivative gain, and `Tf` is the time constant
of the first-order filter of the derivative term. Missing `Ki`,
`Kd` or `Tf` default to 0; without any input argument,
`Kp` defaults to 1. If `Tf=0` and `Kd!=0`, the
derivative term is not filtered and the controller is not causal.

A single-input single-output (SISO) PID controller has scalar parameters. If the parameters are matrices, they must all have the same size (scalar values are replicated as required), and the resulting controller has as many inputs as parameters have columns and as many outputs as parameters have rows; mapping from each input to each output is an independent SISO PID controller.

`pid(Kp, Ki, Kd, Tf, Ts)` creates an LTI object which represents
the discrete-time PID controller
`Kp+Ki.Ii(z)+Kd/(Tf+Id(z))``Ii(z)``Id(z)``z``IFormula` and `DFormula`, strings with the following values:

Name | Value |
---|---|

'ForwardEuler' |
Ts/(z-1) |

'BackwardEuler' |
Ts.z/(z-1) |

'Trapezoidal' |
(Ts/2)(z+1)/(z-1) |

The default formula for both the integral and the derivative terms is
`'ForwardEuler'`.

An additional argument `var` may be used to specify the variable
of the Laplace (`'s'` (default) or `'p'`) or z transform
(`'z'` (default) or `'q'` for forward time shift,
`'z^-1'` or `'q^-1'` for backward time shift).

For PID controllers based on the standard parameters `Kp`,
`Ti` and `Td`, where `Ki=Kp/Ti` and
`Kd=Kp*Td`, `pidstd` objects should be used instead.

#### Examples

Simple continuous-time PID controller:

use lti C = pid(5,2,1) C = continuous-time PID controller Kp + Ki/s + Kd s/(Tf s + 1) Kp = 5 Ki = 2 Kd = 1 Tf = 0

Discrete-time PD controller where the derivative term, filtered with a time
constant of 20ms, is approximated with the Backward Euler formula,
with a sampling period of 1ms. The controller is displayed with the backward-shift
operator `q^-1`.

C = pid(5,0,1,20e-3,1e-3,'q^-1',DFormula='BackwardEuler') C = discrete-time PD controller, Ts=1e-3 Kp + Kd/(Tf + Id(q^-1)) Id(q^-1) = Ts/(1-q^-1) (BackwardEuler) Kp = 5 Kd = 1 Tf = 2e-2

Conversion of a first-order continuous-time transfer function with pole at 0 (integrator effect) to a continuous-time PI controller:

G = tf([1, 2], [1, 0]) G = continuous-time transfer function (s+2)/s C = pid(G) C = continuous-time PI controller Kp + Ki/s Kp = 1 Ki = 2

Conversion of a discrete-time PID controller with the Backward Euler formula for the integral term and the Trapezoidal formula for the derivative term to a transfer function, and back to a PID controller:

C1 = pid(5, 2, 3, 0.1, 0.01, IFormula='BackwardEuler', DFormula='Trapezoidal') C1 = discrete-time PID controller, Ts=1e-2 Kp + Ki Ii(z) + Kd/(Tf + Id(z)) Ii(z) = Ts z/(z-1) (BackwardEuler) Id(z) = Ts/2 (z+1)/(z-1) (Trapezoidal) Kp = 5 Ki = 2 Kd = 3 Tf = 0.1 G = tf(C1) G = discrete-time transfer function, Ts=1e-2 (3.5271z^2-7.0019z+3.475)/(0.105z^2-0.2z+9.5e-2) C2 = pid(G, IFormula='BackwardEuler', DFormula='Trapezoidal') C2 = discrete-time PID controller, Ts=1e-2 Kp + Ki Ii(z) + Kd/(Tf + Id(z)) Ii(z) = Ts z/(z-1) (BackwardEuler) Id(z) = Ts/2 (z+1)/(z-1) (Trapezoidal) Kp = 5 Ki = 2 Kd = 3 Tf = 10e-2

#### See also

### pidstd::pidstd

LTI standard PID controller constructor.

#### Syntax

use lti a = pidstd a = pidstd(Kp, Ti, Td, N) a = pidstd(Kp, Ti, Td, N, Ts) a = pidstd(Kp, Ti, Td, N, Ts, var) a = pidstd(..., IFormula=f1, DFormula=f2)

#### Description

`pidstd(Kp,Ti,Td,N)` creates an LTI object which represents the
standard continuous-time PID controller
`Kp(1/sTi+sTd/(sTd/N+1)``s``Kp` is the proportional gain, `Ti` is the integral time,
`Td` is the derivative time, and `N` is the relative frequency
of the first-order filter of the derivative term. Missing `Ti` defaults
to infinity (no integral term), missing `Td` to zero (no derivative term),
and missing `N` to infinity (no filter on the derivative term, which means
that the controller is noncausal if `Td` is nonzero).

A single-input single-output (SISO) PID controller has scalar parameters. If the parameters are matrices, they must all have the same size (scalar values are replicated as required), and the resulting controller has as many inputs as parameters have columns and as many outputs as parameters have rows; mapping from each input to each output is and independent SISO PID controller.

`pid(Kp,Ti,Td,N,Ts)` creates an LTI object which represents
the standard discrete-time PID controller
`Kp(Ii(z)/Ti+Td/(Td/N+Id(z)))``Ii(z)``Id(z)``z``IFormula` and `DFormula`, strings with the following values:

Name | Value |
---|---|

'ForwardEuler' |
Ts/(z-1) |

'BackwardEuler' |
Ts.z/(z-1) |

'Trapezoidal' |
(Ts/2)(z+1)/(z-1) |

The default formula for both the integral and the derivative terms is
`'ForwardEuler'`.

An additional argument `var` may be used to specify the variable
of the Laplace (`'s'` (default) or `'p'`) or z transform
(`'z'` (default) or `'q'` for forward time shift,
`'z^-1'` or `'q^-1'` for backward time shift).

For PID controllers based on the gain parameters `Kp`,
`Ki=Kp/Ti`, `Kd=Kp*Td`, and `Tf=Td/N`, `pid`
objects should be used instead. Class `pidstd` is a subclass of `pid`.
The only differences are the arguments of their constructors and the way their
objects are displayed by `char`, `disp` and `mathml`.

#### Examples

Simple standard continuous-time PID controller:

use lti C = pidstd(5,4,1) C = continuous-time PID controller Kp (1 + 1/(Ti s) + Td s/(Td/N s + 1)) Kp = 5 Ti = 4 Td = 1 N = inf

Conversion to a `pid` object:

C1 = pid(C) C1 = continuous-time PID controller Kp + Ki/s + Kd s/(Tf s + 1) Kp = 5 Ki = 1.25 Kd = 5 Tf = 0

Standard discrete-time PD controller where the derivative term, filtered with a time
constant 20 times smaller than the derivator time, is approximated with the Backward Euler
formula, with a sampling period of 1ms. The controller is displayed with the backward-shift
operator `q^-1`.

C = pidstd(5,0,1,20,1e-3,'q^-1',DFormula='BackwardEuler') C = discrete-time PID controller, Ts=1e-3 Kp (1 + Ii(q^-1)/Ti + Td/(Td/N + Id(q^-1))) Ii(q^-1) = Ts q^-1/(1-q^-1) (ForwardEuler) Id(q^-1) = Ts/(1-q^-1) (BackwardEuler) Kp = 5 Ti = 0 Td = 1 N = 20

#### See also

### ss::ss

LTI state-space constructor.

#### Syntax

use lti a = ss a = ss(A, B, C, D) a = ss(A, B, C, D, Ts) a = ss(A, B, C, D, Ts, var) a = ss(A, B, C, D, b) a = ss(b)

#### Description

`ss(A,B,C,D)` creates an LTI object which represents the
continuous-time state-space model

x'(t) = A x(t) + B u(t) y(t) = C x(t) + D u(t)

`ss(A,B,C,D,Ts)` creates an LTI object which represents the
discrete-time state-space model with sampling period `Ts`

x(k+1) = A x(k) + B u(k) y(k) = C x(k) + D u(k)

In both cases, if `D` is 0, it is resized to match the size of `B`
and `C` if necessary. An additional argument `var` may be used to specify the variable
of the Laplace (`'s'` (default) or `'p'`) or z transform
(`'z'` (default) or `'q'`).

`ss(A,B,C,D,b)`, where `b` is an LTI object, creates
a state-space model of the same kind (continuous/discrete time, sampling time
and variable) as `b`.

`ss(b)` converts the LTI object `b` to a state-space
model.

#### Examples

use lti sc = ss(-1, [1,2], [2;5], 0) sc = continuous-time LTI state-space system A = -1 B = 1 2 C = 2 5 D = 0 0 0 0 sd = ss(tf(1,[1,2,3,4],0.1)) sd = discrete-time LTI state-space system, Ts=0.1 A = -2 -3 -4 1 0 0 0 1 0 B = 1 0 0 C = 0 0 1 D = 0

#### See also

### tf::tf

LTI transfer function constructor.

#### Syntax

use lti a = tf a = tf(num, den) a = tf(numlist, denlist) a = tf(..., Ts) a = tf(..., Ts, var) a = tf(..., b) a = tf(gain) a = tf(b)

#### Description

`tf(num,den)` creates an LTI object which represents the
continuous-time transfer function specified by descending-power coefficient
vectors `num` and `den`. `tf(num,den,Ts)`
creates an LTI object which represents a discrete-time transfer function with
sampling period `Ts`.

In both cases, `num` and `den` can be replaced with
cell arrays of coefficients whose elements are the descending-power coefficient
vectors. The number of rows is the number of system outputs,
and the number of columns is the number of system inputs.

An additional argument `var` may be used to specify the variable
of the Laplace (`'s'` (default) or `'p'`) or z transform
(`'z'` (default) or `'q'`).

`tf(...,b)`, where `b` is an LTI object, creates
a transfer function of the same kind (continuous/discrete time, sampling time
and variable) as `b`.

`tf(b)` converts the LTI object `b` to a transfer
function.

`tf(gain)`, where `gain` is a matrix, creates a
matrix of gains.

#### Examples

Simple continuous-time system with variable `p` (`p`
is used only for display):

use lti sc = tf(1,[1,2,3,4],'p') sc = continuous-time transfer function 1/(p^3+2p^2+3p+4)

Matrix of discrete-time transfer functions for one input and two outputs, with a sampling period of 1ms:

sd = tf({0.1; 0.15}, {[1, -0.8]; [1; -0.78]}, 1e-3) sd = discrete-time transfer function, Ts=1e-3 y1/u1: 0.1/(s-0.8) y2/u1: 0.15/(s-0.78)

#### See also

`zpk::zpk`,
`pid::pid`,
`pidstd::pidstd`,
`ss::ss`

### zpk::zpk

LTI zero-pole-gain constructor.

#### Syntax

use lti a = zpk(z, p, k) a = zpk(Z, P, K) a = zpk(..., Ts) a = zpk(..., Ts, var) a = zpk(..., b) a = zpk(b)

#### Description

`zpk` creates a zero-pole-gain LTI object. It accepts a vector
of zeros, a vector of poles, and a scalar gain for a simple-input simple-output (SISO)
system; or a cell array of zeros, a cell array of poles, and a real array of gains
for multiple-input multiple-output (MIMO) systems. `zpk(z,p,k,Ts)`
creates an LTI object which represents a discrete-time transfer function with
sampling period `Ts`.

In both cases, `z` and `p` can be replaced with
cell arrays of coefficients whose elements are the zeros and poles
vectors, and `k` with a matrix of the same size. The number of rows is
the number of system outputs, and the number of columns is the number of system
inputs.

An additional argument `var` may be used to specify the variable
of the Laplace (`'s'` (default) or `'p'`) or z transform
(`'z'` (default) or `'q'`).

`zpk(...,b)`, where `b` is an LTI object, creates
a zero-pole-gain transfer function of the same kind (continuous/discrete time,
sampling time and variable) as `b`.

`zpk(b)` converts the LTI object `b` to a zero-pole-gain
transfer function.

#### Example

use lti sd = zpk(0.3, [0.8+0.5j; 0.8-0.5j], 10, 0.1) discrete-time zero-pole-gain transfer function, Ts=0.1 10(z-0.3)/(z-(0.8+0.5j)(z-(0.8-0.5j)

#### See also

`tf::tf`,
`pid::pid`,
`pidstd::pidstd`,
`ss::ss`

### lti::append

Append the inputs and outputs of systems.

#### Syntax

use lti b = append(a1, a2, ...)

#### Description

`append(a1,a2)` builds a system with inputs `[u1;u2]` and outputs
`[y1;y2]`, where `u1` and `u2` are the inputs of
`a1` and `y1` and `y2` their outputs, respectively.
`append` accepts any number of input arguments.

#### See also

### ss::augstate

Extend the output of a system with its states.

#### Syntax

use lti b = augstate(a)

#### Description

`augstate(a)` extends the `ss` object `a`
by adding its states to its outputs. The new output is `[y;x]`, where
`y` is the output of `a` and `x` is its states.

#### See also

### lti::beginning

First index.

#### Syntax

use lti var(...beginning...)

#### Description

In an expression used as an index between parenthesis, `beginning(a)`
gives the first valid value for an index. It is always 1.

#### See also

`lti::end`,
`lti::subsasgn`,
`lti::subsref`

### lti::c2d

Conversion from continuous time to discrete time.

#### Syntax

use lti b = c2d(a, Ts) b = c2d(a, Ts, method)

#### Description

`c2d(a,Ts)` converts the
continuous-time system `a` to a discrete-time
system with sampling period `Ts`.

`c2d(a,Ts,method)` uses the specified conversion
method. `method` is one of the methods supported by `c2dm`
for classes `ss`, `tf` and `zpk`,
and `'ForwardEuler'`, `'BackwardEuler'` or
`'Trapezoidal'` for classes `pid` and
`pidstd`.

#### See also

### lti::connect

Arbitrary feedback connections.

#### Syntax

use lti b = connect(a, links, in, out)

#### Description

`connect(a,links,in,out)` modifies `lti` object
`a` by connecting some of the outputs to some of the inputs and
by keeping some of the inputs and some of the outputs. Connections are
specified by the rows of matrix `link`. In each row, the first
element is the index of the system input where the connection ends; other
elements are indices to system outputs which are summed. The sign of
the indices to outputs gives the sign of the unit weight in the sum.
Zeros are ignored. Arguments `in` and `out`
specify which input and output to keep.

#### See also

### lti::ctranspose

Conjugate transpose.

#### Syntax

use lti b = a' b = ctranspose(a)

#### Description

`a'` or `ctranspose(a)` gives the conjugate transpose of `a`.

The conjugate of the single-input single-output (SISO) continuous-time transfer function `G(s)` is
defined as `G(-s)`, and the conjugate of the SISO discrete-time transfer function
`G(z)` is defined as `G(1/z)`; the conjugate transpose is the
conjugate of the transpose of the original system.

#### See also

### ss::ctrb

Controllability matrix.

#### Syntax

use lti C = crtb(a)

#### Description

`ctrb(a)` gives the controllability matrix of system `a`,
which is full-rank if and only if `a` is controllable.

#### See also

### lti::d2c

Conversion from discrete time to continuous time.

#### Syntax

use lti b = d2c(a) b = d2c(a, method)

#### Description

`d2c(a)` converts the
discrete-time system `a` to a continuous-time system.

`d2c(a,method)` uses the specified conversion
method. `method` is one of the methods supported by `d2cm`
for classes `ss`, `tf` and `zpk`,
and is ignored for class `pid` and `pidstd`.

#### See also

### lti::dcgain

Steady-state gain.

#### Syntax

use lti g = dcgain(a)

#### Description

`dcgain(a)` gives the steady-state gain of system `a`.

#### See also

### lti::end

Last index.

#### Syntax

use lti var(...end...)

#### Description

In an expression used as an index between parenthesis, `end`
gives the last valid value for that index. It is `size(var,1)`
or `size(var,2)`.

#### Example

Time response when the last input is a step:

use lti P = ss([1,2;-3,-4],[1,0;0,1],[3,5]); P1 = P(:, end) continuous-time LTI state-space system A = 1 2 -3 -4 B = 0 1 C = 3 5 D = 0 step(P1);

#### See also

`lti::beginning`,
`lti::subsasgn`,
`lti::subsref`

### lti::evalfr

Frequency value.

#### Syntax

use lti y = evalfr(a, x)

#### Description

`evalfr(a,x)` evaluates system `a` at complex value or
values `x`. If `x` is a vector of values, results are
stacked along the third dimension.

#### Example

use lti sys = [tf(1, [1,2,3]), tf(2, [1,2,3,4])]; evalfr(sys, 0:1j:3j) ans = 1x2x4 array (:,:,1) = 0.3333 0.5 (:,:,2) = 0.25 -0.25j 0.5 -0.5j (:,:,3) = -5.8824e-2-0.2353j -0.4 +0.2j (:,:,4) = -8.3333e-2-8.3333e-2j -5.3846e-2+6.9231e-2j

#### See also

### frd::fcat

Frequency concatenation.

#### Syntax

use lti c = fcat(a, b)

#### Description

`fcat(a,b)` concatenates the frequency response data of `frd` objects
`a` and `b` along the frequency axis, and sort data by increasing frequency.
The size of `a` and `b` must be the same (same numbers of inputs and
outputs).

#### Example

use lti G = tf(1, [1, 2, 3, 4]); a = frd(G, 0:5); b = frd(G, 6:20); c = fcat(a, b); d = frd(G, 0:20); // same as c

#### See also

### lti::feedback

Feedback connection.

#### Syntax

use lti c = feedback(a, b) c = feedback(a, b, sign) c = feedback(a, b, ina, outa) c = feedback(a, b, ina, outa, sign)

#### Description

`feedback(a,b)` connects all the outputs of `lti` object
`a` to all its inputs via the negative feedback `lti` object
`b`.

`feedback(a,b,sign)` applies positive feedback with weight `sign`;
the default value of `sign` is `-1`.

`feedback(a,b,ina,outa)` specifies which inputs and outputs of
`a` to use for feedback. The inputs and outputs of the result always
correspond to the ones of `a`.

#### See also

### frd::frdata

Get frequency response data.

#### Syntax

use lti (resp, freq) = frdata(f) (resp, freq, Ts) = frdata(f)

#### Description

`frdata(f)`, where `f` is an `frd` object,
gives the complex frequency response, the corresponding frequencies, and optionally the
sampling period or the empty array `[]` for continuous-time
systems.

#### See also

### frd::fselect

Frequency selection.

#### Syntax

use lti b = fselect(a, ix) b = fselect(a, sel) b = fselect(a, freqmin, freqmax)

#### Description

`fselect(a,ix)` selects frequencies of `frd` object `a`
whose index are in array `ix`. The frequencies of the result are `a.freq(ix)`.

`fselect(a,sel)` selects frequencies of `frd` object `a`
corresponding to `true` values in logical array `sel`. The frequencies of the
result are `a.freq(sel)`.

`fselect(a,freqmin,freqmax)` selects frequencies of `frd` object `a`
which are greater than or equal to `freqmin` and less than or equal to `freqmax`.
The frequencies of the result are `a.freq(a.freq>=freqmin&a.freq<=freqmax)`.

#### See also

### frd::interp

Frequency interpolation.

#### Syntax

use lti b = interp(a, freq) b = interp(a, freq, method)

#### Description

`interp(a,freq)` interpolates response data of `frd` object `a`
at the frequencies in array `freq`. The frequencies of the result are `freq`.
The interpolation method is linear. Interpolation for frequencies outside the frequency range of
`a` yields `nan` (not a number).

`interp(a,freq,method)` use the specified method for interpolation. Method is one
of the strings accepted by `interp1` (`'0'` or `'nearest'`,
`'<'`, `'>'`, `'1'` or `'linear'`,
`'3'` or `'cubic'`, `'p'` or `'pchip'`).

#### See also

### lti::inv

System inverse.

#### Syntax

use lti b = inv(a)

#### Description

`inv(a)` gives the inverse of system `a`.

#### See also

### isct

Test for a continous-time LTI.

#### Syntax

use lti b = isct(a)

#### Description

`isct(a)` is true if system `a` is continuous-time or
static, and false otherwise.

#### See also

### isdt

Test for a discrete-time LTI.

#### Syntax

use lti b = isdt(a)

#### Description

`isdt(a)` is true if system `a` is discrete-time or
static, and false otherwise.

#### See also

### lti::isempty

Test for an LTI without input/output.

#### Syntax

use lti b = isempty(a)

#### Description

`isempty(a)` is true if system `a` has no input and/or
no output, and false otherwise.

#### See also

### lti::isproper

Test for a proper (causal) LTI.

#### Syntax

use lti b = isproper(a)

#### Description

`isproper(a)` is `true` if `lti` object
`a` is causal, or `false` otherwise. An `ss` object
is always causal. A `tf` object is causal if all the transfer functions
are proper, i.e. if the degrees of the denominators are at least as large as
the degrees of the numerators.

### lti::issiso

Test for a single-input single-output LTI.

#### Syntax

use lti b = issiso(a)

#### Description

`issiso(a)` is `true` if `lti` object
`a` has one input and one output (single-input single-output system, or
SISO), or `false` otherwise.

### tf::mathml zpk::mathml pid::mathml pidstd::mathml

Conversion to MathML.

#### Syntax

use lti, lti_mathml str = mathml(G) str = mathml(G, false) str = mathml(..., Format=f, NPrec=n)

#### Description

`mathml(x)` converts its argument `x` to MathML
presentation, returned as a string.

By default, the MathML top-level element is `<math>`.
If the result is to be used as a MathML subelement of a larger equation,
a last input argument equal to the logical value `false` can
be specified to suppress `<math>`.

By default, `mathml` converts numbers like format `'%g'`
of `sprintf`. Named arguments can override them:
`format` is a single letter format recognized by `sprintf`
and `NPrec` is the precision (number of decimals).

#### Example

use lti, lti_mathml G = zpk(-1, [1, 2+j, 2-j], 2); m = mathml(G); math(0, 0, m);

#### See also

### lti::minreal

Minimum realization.

#### Syntax

use lti b = minreal(a) b = minreal(a, tol)

#### Description

`minreal(a)` modifies `lti` object `a` in
order to remove states which are not controllable and/or not observable. For
`tf` objects, identical zeros and poles are canceled out.

`minreal(a,tol)` uses tolerance `tol` to
decide whether to discard a state or a pair of pole/zero.

### lti::minus

System difference.

#### Syntax

use lti c = a - b c = minus(a, b)

#### Description

`a-b` computes the system whose inputs are fed to both
`a` and `b` and whose outputs are the difference between
outputs of `a` and `b`.
If `a` and `b` are transfer functions or matrices
of transfer functions, this is equivalent to a difference of matrices.

#### See also

`lti::parallel`,
`lti::plus`,
`lti::uminus`

### lti::mldivide

System left division.

#### Syntax

use lti c = a \ b c = mldivide(a, b)

#### Description

`a/b` is equivalent to `inv(a)*b`.

#### See also

`lti::mrdivide`,
`lti::times`,
`lti::inv`

### lti::mrdivide

System right division.

#### Syntax

use lti c = a / b c = mrdivide(a, b)

#### Description

`a/b` is equivalent to `a*inv(b)`.

#### See also

`lti::mldivide`,
`lti::times`,
`lti::inv`

### lti::mtimes

System product.

#### Syntax

use lti c = a * b c = mtimes(a, b)

#### Description

`a*b` connects the outputs of `lti` object
`b` to the inputs of `lti` object `a`.
If `a` and `b` are transfer functions or matrices
of transfer functions, this is equivalent to a product of matrices.

#### See also

### lti::norm

H2 norm.

#### Syntax

use lti h2 = norm(a)

#### Description

`norm(a)` gives the H2 norm of the system `a`.

#### See also

### ss::obsv

Observability matrix.

#### Syntax

use lti O = obsv(a)

#### Description

`obsv(a)` gives the observability matrix of system `a`,
which is full-rank if and only if `a` is observable.

#### See also

### lti::parallel

Parallel connection.

#### Syntax

use lti c = parallel(a, b) c = parallel(a, b, ina, inb, outa, outb)

#### Description

`parallel(a,b)` connects `lti` objects `a`
and `b` in such a way that the inputs of the result is applied to
both `a` and `b`, and the outputs of the result is
their sum.

`parallel(a,b,ina,inb,outa,outb)` specifies which inputs are
shared between `a` and `b`, and which outputs
are summed. The inputs of the result are partitioned as `[ua,uab,ub]`
and the outputs as `[ya,yab,yb]`. Inputs `uab` are
fed to inputs `ina` of `a` and `inb` of
`b`; inputs `ua` are fed to the remaining inputs
of `a`, and `ub` to the remaining inputs
of `b`. Similarly, outputs `yab` are the sum
of outputs `outa` of `a` and outputs `outb`
of `b`, and `ya` and `yb` are the remaining
outputs of `a` and `b`, respectively.

#### See also

### lti::piddata

Get PID parameters.

#### Syntax

use lti (Kp, Ki, Kd, Tf) = piddata(a) (Kp, Ki, Kd, Tf, Ts) = piddata(a)

#### Description

`piddata(a)`, where `a` is any kind of LTI object which
has the structure of a PID controller except for `frd`,
gives the PID parameters `Kp`, `Ki`, `Kd` and
`Tf`, and optionally the
sampling period or the empty array `[]` for continuous-time
systems. The parameters are given as matrices; the rows correspond
to the outputs, and their columns to the inputs.

#### See also

`pid::pid`,
`lti::pidstddata`,
`lti::tfdata`

### lti::pidstddata

Get standard PID parameters.

#### Syntax

use lti (Kp, Ti, Td, N) = pidstddata(a) (Kp, Ti, Td, N, Ts) = pidstddata(a)

#### Description

`pidstddata(a)`, where `a` is any kind of LTI object which
has the structure of a PID controller except for `frd`,
gives the standard PID parameters `Kp`, `Ti`, `Td` and
`N`, and optionally the
sampling period or the empty array `[]` for continuous-time
systems. The parameters are given as matrices; the rows correspond
to the outputs, and their columns to the inputs.

#### See also

`pidstd::pidstd`,
`lti::piddata`,
`lti::tfdata`

### lti::plus

System sum.

#### Syntax

use lti c = a + b c = plus(a, b)

#### Description

`a+b` computes the system whose inputs are fed to both
`a` and `b` and whose outputs are the sum of the
outputs of `a` and `b`.
If `a` and `b` are transfer functions or matrices
of transfer functions, this is equivalent to a sum of matrices.

#### See also

### lti::repmat

Replicate a system.

#### Syntax

use lti b = repmat(a, n) b = repmat(a, [m,n]) b = repmat(a, m, n)

#### Description

`repmat(a,m,n)`, when `a` is an `lti` object
and `m` and `n` are positive integers,
creates a new system of the same class with `m` times as many outputs
and `n` times as many inputs. If `a` is a matrix of transfer
functions, it is replicated `m` times vertically and `n`
horizontally, as if `a` were a numeric matrix.
If `a` is a state-space system, matrices B, C, and D are replicated to
obtain the same effect.

`repmat(a,[m,n])` gives the same result as `repmat(a,m,n)`;
`repmat(a,n)` gives the same result as `repmat(a,n,n)`.

#### See also

### lti::series

Series connection.

#### Syntax

use lti c = series(a, b) c = series(a, b, outa, inb)

#### Description

`series(a,b)` connects the outputs of `lti` object
`a` to the inputs of `lti` object `b`.

`series(a,b,outa,inb)` connects outputs `outa` of
`a` to inputs `inb` of `b`. Unconnected
outputs of `a` and inputs of `b` are discarded.

#### See also

### lti::size

Number of outputs and inputs.

#### Syntax

use lti s = size(a) (nout, nin) = size(a) n = size(a, dim)

#### Description

With one output argument, `size(a)` gives the row vector
`[nout,nin]`, where
`nout` is the number of outputs of system `a` and
`nin` its number of inputs. With two output arguments, `size(a)`
returns these results separately as scalars.

`size(a,1)` gives only the number of outputs, and `size(a,2)`
only the number of inputs.

#### See also

### lti::ssdata

Get state-space matrices.

#### Syntax

use lti (A, B, C, D) = ssdata(a) (A, B, C, D, Ts) = ssdata(a)

#### Description

`ssdata(a)`, where `a` is any kind of LTI object
except for `frd`,
gives the four matrices of the state-space model, and optionally the
sampling period or the empty array `[]` for continuous-time
systems.

#### See also

### lti::subsasgn

Assignment to a part of an LTI system.

#### Syntax

use lti var(i,j) = a var(ix) = a var(select) = a var.field = value a = subsasgn(a, s, b)

#### Description

The method `subsasgn(a)` permits the use of all kinds of assignments
to a part of an LTI system. If the variable is a matrix of transfer functions,
`subsasgn` produces the expected result, converting the right-hand
side of the assignment to a matrix of transfer function if required. If the
variable is a state-space model, the result is equivalent; the result remains
a state-space model. For state-space models, changing all the inputs or all the
outputs with the syntax `var(expr,:)=sys` or `var(:,expr)=sys`
is much more efficient than specifying both subscripts or a single index.

The syntax for field assignment, `var.field=value`, is defined
for the following fields: for state-space models, `A`, `B`,
`C`, and `D` (matrices of the state-space model); for transfer
functions, `num` and `den` (cell arrays of coefficients);
for zero-pole-gain transfer functions, `z` and `p` (cell arrays
of zero or pole vectors), and `k` (gain matrix); for PID controllers,
`Kp`, `Ki`, `Kd`, `Tf`, `Ti`
and `Td` (controller parameter matrices); for all LTI objects,
`var` (string) and `Ts` (scalar, or empty array
for continuous-time systems).
Field assignment must preserve the size of matrices and arrays.

The syntax with braces (`var{i}=value`) is not supported.

#### See also

`lti::subsref`,
operator `()`,
`subsasgn`

### lti::subsref

Extraction of a part of an LTI system.

#### Syntax

use lti var(i,j) var(ix) var(select) var.field b = subsref(a, s)

#### Description

The method `subsref(a)` permits the use of all kinds of extraction
of a part of an LTI system. If the variable is a matrix of transfer functions,
`subsref` produces the expected result. If the
variable is a state-space model, the result is equivalent; the result remains
a state-space model, with the same state vector (the same matrix `A`)
as the original system. For state-space models, extracting all the inputs or all the
outputs with the syntax `var(expr,:)` or `var(:,expr)`
is much more efficient than specifying both subscripts or a single index.

If the variable is an `frd` object, `var('freq',i)`
produces a new `frd` object where the frequency vector is
`var.frequency(i)` amd the response array contains the corresponding
reponse. `i` can be a scalar index, a vector of indices or a logical
array with the same size as `var.frequency`.

The syntax for field access, `var.field`, is defined
for the following fields: for state-space models, `A`, `B`,
`C`, and `D` (matrices of the state-space model); for transfer
functions, `num` and `den` (cell arrays of coefficients);
for zero-pole-gain transfer functions, `z` and `p` (cell arrays
of zero or pole vectors), and `k` (gain matrix); for PID controllers,
`Kp`, `Ki`, `Kd`, `Tf`, `Ti`
and `Td` (controller parameter matrices); for all LTI objects,
`var` (string) and `Ts` (scalar, or empty array
for continuous-time systems).

The syntax with braces (`var{i}`) is not supported.

#### See also

`lti::subsasgn`,
operator `()`,
`subsasgn`

### lti::tfdata

Get transfer functions.

#### Syntax

use lti (num, den) = tfdata(a) (num, den, Ts) = tfdata(a)

#### Description

`tfdata(a)`, where `a` is any kind of LTI object except
for `frd`,
gives the numerator and denominator of the transfer function model, and optionally the
sampling period or the empty array `[]` for continuous-time
systems. The numerators and denominators are given as a cell array of
power-descending coefficient vectors; the rows of the cell arrays correspond
to the outputs, and their columns to the inputs.

#### See also

`tf::tf`,
`lti::zpkdata`,
`lti::ssdata`

### lti::transpose

Transpose.

#### Syntax

use lti b = a.' b = transpose(a)

#### Description

`a.'` or `transpose(a)` gives the transpose of `a`,
i.e. `a.'(i,j)=a(j,i)`.

#### See also

### lti::uminus

Negative.

#### Syntax

use lti b = -a b = uminus(a)

#### Description

`-a` multiplies all the outputs (or all the inputs) of system
`a` by -1.
If `a` is a transfer functions or a matrix
of transfer functions, this is equivalent to the unary minus.

#### See also

### lti::uplus

Positive.

#### Syntax

use lti b = +a b = uplus(a)

#### Description

`+a` gives `a`.

#### See also

### lti::zpkdata

Get zeros, poles and gains.

#### Syntax

use lti (z, p, k) = zpkdata(a) (z, p, k, Ts) = zpkdata(a)

#### Description

`zpkdata(a)`, where `a` is any kind of LTI object except
for `frd`,
gives the zeros, poles and gains of the transfer function model, and optionally the
sampling period or the empty array `[]` for continuous-time
systems. The zeros and poles are given as a cell array of
vectors; the rows of the cell arrays correspond
to the outputs, and their columns to the inputs.