Create transfer function model, convert to transfer function model
sys
= tf(num
,den
) sys
= tf(num
,den
,Ts
) sys
= tf(M
) sys
= tf(num
,den
,ltisys
) tfsys
=
tf(sys
)
tfsys = tf(sys,
'measured')
tfsys = tf(sys, 'noise')
tfsys = tf(sys, 'augmented')
Use tf
to create real or complexvalued
transfer function models (TF objects) or to convert statespace or
zeropolegain models to transfer function form. You can also use tf
to
create generalized statespace (genss
)
models or uncertain statespace (uss
)
models.
creates a continuoustime transfer function with numerator(s) and
denominator(s) specified by sys
= tf(num
,den
) num
and den
.
The output sys
is:
A tf
model object, when num
and den
are
numeric arrays.
A generalized statespace model (genss
)
when num
or den
include tunable
parameters, such as realp
parameters or generalized
matrices (genmat
).
An uncertain statespace model (uss
)
when num
or den
are uncertain
(requires Robust Control Toolbox™ software).
In the SISO case, num
and den
are
the real or complexvalued row vectors of numerator and denominator
coefficients ordered in descending powers of s.
These two vectors need not have equal length and the transfer function
need not be proper. For example, h = tf([1 0],1)
specifies
the pure derivative h(s) = s.
To create MIMO transfer functions, using one of the following approaches:
Concatenate SISO tf
models.
Use the tf
command with cell
array arguments. In this case, num
and den
are
cell arrays of row vectors with as many rows as outputs and as many
columns as inputs. The row vectors num{i,j}
and den{i,j}
specify
the numerator and denominator of the transfer function from input j
to
output i
.
For examples of creating MIMO transfer functions, see Examples and MIMO Transfer Functions in the Control System Toolbox™ User Guide.
If all SISO entries of a MIMO transfer
function have the same denominator, you can set den
to
the row vector representation of this common denominator. See "Examples"
for more details.
creates a discretetime transfer function with sample time sys
= tf(num
,den
,Ts
) Ts
(in
seconds). Set Ts = 1
to leave the sample time
unspecified. The input arguments num
and den
are
as in the continuoustime case and must list the numerator and denominator
coefficients in descending powers of z.
creates a static gain sys
= tf(M
) M
(scalar
or matrix).
creates a transfer function with properties inherited from the dynamic
system model sys
= tf(num
,den
,ltisys
) ltisys
(including the sample time).
There are several ways to create arrays of transfer functions.
To create arrays of SISO or MIMO TF models, either specify the numerator
and denominator of each SISO entry using multidimensional cell arrays,
or use a for
loop to successively assign each TF
model in the array. See Model Arrays.
Any of the previous syntaxes can be followed by property name/property value pairs
'Property',Value
Each pair specifies a particular property of the model, for
example, the input names or the transfer function variable. For information
about the properties of tf
objects, see Properties. Note that
sys = tf(num,den,'Property1',Value1,...,'PropertyN',ValueN)
is a shortcut for
sys = tf(num,den) set(sys,'Property1',Value1,...,'PropertyN',ValueN)
You can also use real or complexvalued rational expressions to create a TF model. To do so, first type either:
s = tf('s')
to specify a TF model
using a rational function in the Laplace variable, s
.
z =
tf('z',Ts)
to
specify a TF model with sample time Ts
using a
rational function in the discretetime variable, z
.
Once you specify either of these variables, you can specify
TF models directly as rational expressions in the variable s
or z
by
entering your transfer function as a rational expression in either s
or z
.
converts the dynamic
system model tfsys
=
tf(sys
) sys
to transfer function form. The
output tfsys
is a tf
model
object representing sys
expressed as a transfer
function.
If sys
is a model with tunable components,
such as a genss
, genmat
, ltiblock.tf
,
or ltiblock.ss
model, the
resulting transfer function tfsys
takes the current
values of the tunable components.
An identified model is represented by an inputoutput equation
of the form y(t) = Gu(t) + He(t)
, where u(t)
is
the set of measured input channels and e(t)
represents
the noise channels. If Λ = LL' represents
the covariance of noise e(t)
, this equation can
also be written as: y(t) = Gu(t) + HLv(t)
, where cov(v(t))
= I
.
tfsys = tf(sys)
, or tfsys = tf(sys,
'measured')
converts the measured component of an identified
linear model into the transfer function form. sys
is
a model of type idss
, idproc
, idtf
, idpoly
,
or idgrey
. tfsys
represents
the relationship between u
and y
.
tfsys = tf(sys, 'noise')
converts the noise
component of an identified linear model into the transfer function
form. It represents the relationship between the noise input, v(t)
and
output, y_noise = HL v(t)
. The noise input channels
belong to the InputGroup
'Noise'
.
The names of the noise input channels are v@yname
,
where yname
is the name of the corresponding output
channel. tfsys
has as many inputs as outputs.
tfsys = tf(sys, 'augmented')
converts both
the measured and noise dynamics into a transfer function. tfsys
has ny+nu
inputs
such that the first nu
inputs represent the channels u(t)
while
the remaining by channels represent the noise channels v(t)
. tfsys.InputGroup
contains
2 input groups 'measured'
and 'noise'
.
tfsys.InputGroup.Measured
is set to 1:nu
while tfsys.InputGroup.Noise
is
set to nu+1:nu+ny
. tfsys
represents
the equation y(t) = [G HL] [u; v]
.
Tip
An identified nonlinear model cannot be converted into a transfer
function. Use linear approximation functions such as 
You can use the syntax:
gensys = tf(num,den)
to create a Generalized statespace (genss
)
model when one or more of the entries num
and den
depends
on a tunable realp
or genmat
model. For more information about
Generalized statespace models, see Models with Tunable Coefficients.
Create the oneinput, twooutput transfer function
$$H\left(p\right)=\left[\begin{array}{c}\frac{p+1}{{p}^{2}+2p+2}\\ \frac{1}{p}\end{array}\right]$$
with input current
and outputs torque
and ang
velocity
.
To do this, enter
num = {[1 1] ; 1}; den = {[1 2 2] ; [1 0]}; H = tf(num,den,'inputn','current',... 'outputn',{'torque' 'ang. velocity'},... 'variable','p')
These commands produce the result:
Transfer function from input "current" to output... p + 1 torque:  p^2 + 2 p + 2 1 ang. velocity:  p
Setting the 'variable'
property to 'p'
causes
the result to be displayed as a transfer function of the variable p.
To use a rational expression to create a SISO TF model, type
s = tf('s'); H = s/(s^2 + 2*s +10);
This produces the same transfer function as
h = tf([1 0],[1 2 10]);
Create a tf
model that represents a secondorder system with known natural frequency and damping ratio.
The transfer function of a secondorder system, expressed in terms of its damping ratio and natural frequency , is:
Represent this transfer function in MATLAB using the tf
command. For example, suppose you have a system with
= 0.25 and
= 3 rad/s.
zeta = 0.25; w0 = 3; H = tf(w0^2,[1,2*zeta*w0,w0^2])
H = 9  s^2 + 1.5 s + 9 Continuoustime transfer function.
Examine the response of this transfer function to a step input.
stepplot(H)
The plot shows the ringdown expected of a secondorder system with a low damping ratio.
Specify the discrete MIMO transfer function
$$H\left(z\right)=\left[\begin{array}{cc}\frac{1}{z+0.3}& \frac{z}{z+0.3}\\ \frac{z+2}{z+0.3}& \frac{3}{z+0.3}\end{array}\right]$$
with common denominator d (z) = z + 0.3 and sample time of 0.2 seconds.
nums = {1 [1 0];[1 2] 3}; Ts = 0.2; H = tf(nums,[1 0.3],Ts) % Note: row vector for common den. d(z)
Compute the transfer function of the statespace model with the following data.
$$A=\left[\begin{array}{cc}2& 1\\ 1& 2\end{array}\right],\text{\hspace{1em}}B=\left[\begin{array}{cc}1& 1\\ 2& 1\end{array}\right],\text{\hspace{1em}}C=\left[\begin{array}{cc}1& 0\end{array}\right],\text{\hspace{1em}}D=\left[\text{\hspace{0.05em}}\begin{array}{cc}0& 1\end{array}\right].$$
To do this, type
sys = ss([2 1;1 2],[1 1;2 1],[1 0],[0 1]); tf(sys)
These commands produce the result:
Transfer function from input 1 to output: s  4.441e016  s^2 + 4 s + 5 Transfer function from input 2 to output: s^2 + 5 s + 8  s^2 + 4 s + 5
You can use a for
loop to specify a 10by1
array of SISO TF models.
H = tf(zeros(1,1,10)); s = tf('s') for k=1:10, H(:,:,k) = k/(s^2+s+k); end
The first statement preallocates the TF array and fills it with zero transfer functions.
This example shows how to create the lowpass filter F = a/(s + a) with one tunable parameter a.
You cannot use ltiblock.tf
to
represent F, because the numerator and denominator
coefficients of an ltiblock.tf
block are independent.
Instead, construct F using the tunable real parameter
object realp
.
Create a tunable real parameter.
a = realp('a',10);
The realp
object a
is
a tunable parameter with initial value 10.
Use tf
to create the tunable filter F
:
F = tf(a,[1 a]);
F
is a genss
object
which has the tunable parameter a
in its Blocks
property.
You can connect F
with other tunable or numeric
models to create more complex models of control systems. For an example,
see Control System with Tunable Components.
Extract the measured and noise components of an identified polynomial model into two separate transfer functions (requires System Identification Toolbox™). The measured component can serve as a plant model, while the noise component can serve as a disturbance model for control system design.
load icEngine; z = iddata(y,u,0.04); nb = 2; nf = 2; nc = 1; nd = 3; nk = 3; sys = bj(z, [nb nc nd nf nk]);
sys
is a model of the form: y(t)
= B/F u(t) + C/D e(t)
, where B/F
represents
the measured component and C/D
the noise component.
sysMeas = tf(sys, 'measured') sysNoise = tf(sys, 'noise')
Alternatively, use can simply use tf(sys)
to
extract the measured component.
The control and digital signal processing (DSP) communities tend to use different conventions to specify discrete transfer functions. Most control engineers use the z variable and order the numerator and denominator terms in descending powers of z, for example,
$$h\left(z\right)=\frac{{z}^{2}}{{z}^{2}+2z+3}.$$
The polynomials z^{2} and z^{2} + 2z + 3 are then specified by the row vectors [1
0 0]
and [1 2 3]
, respectively. By contrast,
DSP engineers prefer to write this transfer function as
$$h\left({z}^{1}\right)=\frac{1}{1+2{z}^{1}+3{z}^{2}}$$
and specify its numerator as 1
(instead of [1
0 0]
) and its denominator as [1 2 3]
.
tf
switches convention based on your choice
of variable (value of the 'Variable'
property).
Variable  Convention 

 Use the row vector 
 Use the row vector 
For example,
g = tf([1 1],[1 2 3],0.1);
specifies the discrete transfer function
$$g\left(z\right)=\frac{z+1}{{z}^{2}+2z+3}$$
because z is the default variable. In contrast,
h = tf([1 1],[1 2 3],0.1,'variable','z^1');
uses the DSP convention and creates
$$h\left({z}^{1}\right)=\frac{1+{z}^{1}}{1+2{z}^{1}+3{z}^{2}}=zg\left(z\right).$$
See also filt
for direct
specification of discrete transfer functions using the DSP convention.
Note that tf
stores data so that the numerator
and denominator lengths are made equal. Specifically, tf
stores
the values
num = [0 1 1]; den = [1 2 3];
for g
(the numerator is padded with zeros
on the left) and the values
num = [1 1 0]; den = [1 2 3];
for h
(the numerator is padded with zeros
on the right).
tf
objects have the following properties:

Transfer function numerator coefficients. For SISO transfer functions, For MIMO transfer functions with 

Transfer function denominator coefficients. For SISO transfer functions, For MIMO transfer functions with 

String specifying the transfer function display variable.
The value of Default: 

Transport delays. For continuoustime systems, specify transport delays in the
time unit stored in the For a MIMO system with Default: 

Input delay for each input channel, specified as a scalar value
or numeric vector. For continuoustime systems, specify input delays
in the time unit stored in the For a system with You can also set Default: 0 

Output delays. For a system with Default: 0 for all output channels 

Sample time. For continuoustime models, Changing this property does not discretize or resample the model.
Use Default: 

String representing the unit of the time variable. This property
specifies the units for the time variable, the sample time
Changing this property has no effect on other properties, and
therefore changes the overall system behavior. Use Default: 

Input channel names. Set Alternatively, use automatic vector expansion to assign input
names for multiinput models. For example, if sys.InputName = 'controls'; The input names automatically expand to You can use the shorthand notation Input channel names have several uses, including:
Default: Empty string 

Input channel units. Use Default: Empty string 

Input channel groups. The sys.InputGroup.controls = [1 2]; sys.InputGroup.noise = [3 5]; creates input groups named sys(:,'controls') Default: Struct with no fields 

Output channel names. Set Alternatively, use automatic vector expansion to assign output
names for multioutput models. For example, if sys.OutputName = 'measurements'; The output names automatically expand to You can use the shorthand notation Output channel names have several uses, including:
Default: Empty string 

Output channel units. Use Default: Empty string 

Output channel groups. The sys.OutputGroup.temperature = [1]; sys.InputGroup.measurement = [3 5]; creates output groups named sys('measurement',:) Default: Struct with no fields 

System name. Set Default: 

Any text that you want to associate with the system. Set Default: 

Any type of data you want to associate with system. Set Default: 

Sampling grid for model arrays, specified as a data structure. For model arrays that are derived by sampling one or more independent variables, this property tracks the variable values associated with each model in the array. This information appears when you display or plot the model array. Use this information to trace results back to the independent variables. Set the field names of the data structure to the names of the sampling variables. Set the field values to the sampled variable values associated with each model in the array. All sampling variables should be numeric and scalar valued, and all arrays of sampled values should match the dimensions of the model array. For example, suppose you create a 11by1
array of linear models, sysarr.SamplingGrid = struct('time',0:10) Similarly, suppose you create a 6by9
model array, [zeta,w] = ndgrid(<6 values of zeta>,<9 values of w>) M.SamplingGrid = struct('zeta',zeta,'w',w) When you display M M(:,:,1,1) [zeta=0.3, w=5] = 25  s^2 + 3 s + 25 M(:,:,2,1) [zeta=0.35, w=5] = 25  s^2 + 3.5 s + 25 ... For model arrays generated by linearizing a Simulink^{®} model
at multiple parameter values or operating points, the software populates Default: 