Contents of Report
1. Introduction
2. Symbolic Language Representation
3. Basics of Mathematica
Structure of Mathematica
Simple Arithmetic
Precision
Basic Functions
Symbolic Notation
4. More Advanced Mathematica Techniques
Solving Equations
Calculus
User-defined functions
Lists
5. Control System Professional
intro to capabilities
control object representation
examples of functions available
6. Summary

1. Introduction

Since its emergence in 1989, the use of Mathematica symbolic programming language has
become increasingly widespread. Originally Mathematica began as a computer tool which was used
predominantly by mathematicians. In recent years the range of possible applications for Mathematica has
increased with the development of a set of toolboxes, the Mathematica Applications Library. These
toolboxes extend the functionality of the language, supplying additional features relevant to their
subject area . Since each application package is written in the Mathematica language they can be
integrated with each other seamlessly. Some examples of application packages currently available are
Mechanical Systems, Scientific Astronomer, Signals and Systems and Dynamic Visualiser.
With the introduction of the Control System Professional toolbox, a collection of programs
have been introduced which extend Mathematica by enabling it to solve a wide range of control
system design problems. The advantage of applying Mathematica to control problems is the ability of the
package to solve equations symbolically. This allows the solution to control problems
to be given in terms of actual problem parameters. A deeper insight can be gained into a control
problem if system solutions are synthesized in this way as opposed to conventional control packages
which provide numerical solutions only.
This report describes the functionality of the Mathematica language and the Control Systems
Professional Application package. Illustrative examples are provided throughout to give a better
understanding of the software.

2. Symbolic Language Representation

Symbolic algebra computing, in its earliest form, was first developed in the late 70s. Initially the
technique was computationally intensive due to the limited processing power available at that time.
The mathematical tools were considered useful only to a small group of scientists such as
mathematicians and astro-physicists. However, with the advance in the computing power of the
microprocessor, workstations and modern PCs are now capable of running symbolic manipulation
packages. Symbolic algebra allows a range of mathematical operations such as linear algebra,
differential and integral calculus and differential geometry to be performed.
The advantage of working with calculations in symbolic form is that generic results can be
computed when finding the solution to a problem. This reduces the computational redundancy of
repeatedly calculating numerical results in order to fully understand a problem. Symbolic
manipulation can also improve calculations by performing mathematical operations in a more
accurate way. Many of the numerical approximations for operations such as algebraic, differential or
integral calculations can be replaced with the exact value of the operation.
Symbolic languages are also of particular use to the control engineer due to their accuracy
when performing calculations using high order polynomials. This accuracy is not found in many of
the computing facilities currently available to the engineer. Many techniques used in control, such as
high order polynomial manipulation and polynomial matrix inversion, would greatly benefit from
having infinite accuracy.

3. Basics of Mathematica

3.1 Structure of Mathematica
The structure of the Mathematica package is divided into two different sections : the front end and
the kernel. The kernel is the computational engine of the package which performs all numerical
calculations and symbolic operations. The kernel of the package can be run separately if there is
no requirement to record results. All results calculated using the kernel will be lost when the user exits the
Mathematica package at the end of a session.
The front end is a notebook document editor which allows the user to perform calculations and
to include text around them to provide a fuller description of the work covered in the session..If a session of
work is to be recorded, or a report with embedded calculations written, then the front end is required. The
front end communicates, unseen to the user, with the kernel which performs all calculations. The entire script
of the session can be saved to a notebook file allowing the session to be recalled at a later date.
As well as simply recording interactions with the package, the front end can be used to
construct documents. It can be displayed in a number of different formats, for example tutorial style
or textbook style, depending on the purpose of the session. An advantage of the notebook style front
end is that when a saved session is reloaded the calculations are still active. This means it is
possible to modify or update a series calculations embedded within a document without disturbing
other parts of the document.
Mathematica has the ability to communicate with other languages such as C or C++. This
communication is facilitated by the MathLink protocol. This allows Mathematica access to existing
software libraries or other applications.

3.2 Standard Arithmetic
Mathematica performs all calculations by accepting an expression from the user, processing
the expression and outputting a result. This process can be demonstrated with a simple addition
operation

A variable can be assigned to the value of the result of a calculation as follows :

The current value of a Mathematica variable can be displayed simply by supplying the name of the
variable as the input expression

One slightly unusual property of Mathematica of which the user must aware is the multiplication
operation. The standard multiplication operator is provided as shown

In mathematical convention, when two symbols are written together,a multiplication is indicated.
This notation is supported in Mathematica. If two numbers are written with a space between them
then a multiplicaton is performed. This notation is more useful when applied to symbolic
manipulation (see later), however, it is demonstrated on two numerical values below.

The standard set of arithmetic operations as they are implemented in Mathematica are as
follows:

x+y add
x-y subtract
x/y divide
x y z or x*y*z multiply
x^y power

Precision Calculation

The benefits of Mathematica become more apparent when larger numbers are required
with high precision. Exact results can be obtained for numbers which are out of the range of many
numeric packages. For example, computing the number produces an exact answer for a number which
has 34 digits

The user is not forced to use this degree of precision if the calculation does not warrant it. The //N
tag limits precision during the calculation ensuring the output of the calculation will be a numerical
approximation to the result.

Fractions can be computed without rounding errors being introduced into the answer. The following
example would introduce round-off error into both terms, as they were converted into decimals, if
implemented on numerical packages.

Again the numerical equivalent of the exact result can be substituted if precision is not necessary

The user can also select the precision of the calculation by placing a decimal point in the input
expression. The following expression will be evaluated exactly

Replacing any of the integers in an input expression by a decimal number ensures that the output will also
be in decimal form

Standard Functions

Mathematica has a large number built-in functions to perform of mathematical functions. These
functions all follow the same general syntax rules. Built-in functions in Mathematica start with a capital
letter. This allows functions to be easily distinguishable from symbolic expressions. In addition
Mathematica functions tend to have longer names with little use of abbreviation. This convention is
intended to remove any uncertainty as to the actual mathematical function being performed.
Arguments to any function are enclosed in square brackets '[]' after the function name. This differs
from many languages which use parenthesis '()'. This notation removes any ambiguity as to whether a
letter is representing a function or is simply a multiplicative term. For example f(1+x) could
represent a function of (1+x) or could represent f*(1+x). The Mathematica representation f[1+x]
clearly shows that f is a function.

An example of a built-in function is the exponential function

Mathematica has the ability to produce arbitrary precision based depending on the needs of the
user.The built-in function N[] allows any degree of precision to be selected. This can be
demonstrated by generating the previous result with 11 digits.

Examples of some standard mathematical functions are Sqrt[], Sin[], Cos[], Log[], Random[] and
Abs[].

Use of previous results

In Mathematia the result of any previous calculation in the session can be recalled for future
processing. The most simple use of this facility is to recall the previous result.

The symbol '%' is used to refer to the previous result as follows

This symbol can be repeated for results further back in the session. To recall the answer two
calculations ago

An faster method to recall outputs further back in the sequence is to stipulate the number of the
output result required.

Variables can assigned simply in Mathematica as follows

All occurences of the variable x will now be interpreted as 12 .

The numerical accuracy of variables can be specified as they are defined using the N[] function. For
example, a variable can represent Pi to 10 significant figures.

The values assigned to variables are permanent until explicitly changed. If a large program is being
written in Mathematica it is advisable to clear the value of a variable after it has been used. This
avoids accidental use of an old variable at another point in the session.

The variable x now stores no value and is ready to be reassigned if used in the future.

The above output verifies that x has no value associated with it.

Mathemathematica is distinguishable from standard data manipulation packages by its
ability to perform symbolic manipulation. This means that variables can be present in an equation
without having a value assigned to then. The package can then solve the equation in the presence of
these unknown variables. The solution to the equation will be given in terms of the unkown variables

Mathematica recognises that unknown variables will be part of the input expression.

Symbolic computation can be performed in the same way as numerical computation. Mathematica
automatically simplifies the following expression using basic algebraic rules :

More complicated simplifications are also done automatically

Expressions can be displayed in expanded or factorised form. The command Expand[] multiplies
out any factors in an expression.

The expression can be converted back into its original form with the Factor[] command

The ability to perform symbolic manipulation allows solutions to problems to be expressed in terms
of unknown variables. It is likely, however, that the unknown variables will be eventually be
replaced by numerical values if a numerical result is necessary. The replacement operator, -> , is
used for this purpose.

This transformation rule can also be used to replace a variable by an expression. In the following
example all occurrences of x will be replaced by the expression y+1

It is also possible to perform several replacements in the same expression.

To replace a variable in an equation is only a temporary assignment to the variable. For example,
although x was replaced by 1 in the previous example, it can be seen that 1 is not a permanent
assignment to x

Assignment to a variable using the '=' operator causes all occurrences of that variable in future
expressions to be replaced by the assigned value.

A possible danger while using symbolic languages is that there can be some confusion between
using a variable, x for example, as a name for another expression and also using it as a symbolic
value that stands for itself only.
For example suppose x is assigned a value

For example, later in a session, it is attempted to use x symbolically to calculate a product of
polynomials.

The answer is not the symbolic solution to the product but a numeric answer. Because the symbol has a
value associated with it the answer is not as expected. This type of error could possibly occur in a large
program and would be harder to detect.
This type of error can be avoided if explicit definitions, such as x=3, are used sparingly and
replacement operations such as expr/. x->3, where expr is any expression, are used. This prevents the
value of x being assigned globally.

More Advanced Mathematica Techniques

Solving Equations

Mathematica can solve polynomial equations using the command Solve[]. The symbol '==' is used
to signify 'equals to' when defining an equation. The following is a valid definition of an equation

When solving an equation the user must stipulate the variable for which the equation is to be solved.
In the previous example the equation could be solved for a,b or x. To solve for x

Mathematica assumes that a space between variables signifies a multiplication operation. The space
between a and x in the precious calculation cannot be omitted else Mathematica assumes a variable
called 'ax' is present. For example

No solution was found because Mathematica treats ax as one symbol thus it cannot find any
variable called x in the equation. Therefore no solution is found.

Higher order polynomial equations are solved in exactly the same manner as linear equations.

Mathematica attempts to find an exact solution when solving polynomial equations as can be
seen in the follow equation solution.

In this case it is better to force the roots to be output as a numerical approximation to their exact
position.

Calculus
Mathematica can perform integration and differentiation using the D[] and Integrate[] commands.

A use of the differentiation command is now illustrated .

The derivative of the first expression is found with respect to the second expression. Multiple
derivatives can also be calculated by including the number of the derivative required. For example,
the third derivative of x^4, with repect to x, is calculated by

Simple integration is performed with the Integrate[] command. As with differentiation the variable
with repect to which the integration is being carried out must be listed after the expression.

Mathematica can integrate and differentiate standard mathematical functions as well.

Functions

Mathematica treats functions in the same way as all other expressions. They can be added, subtracted
and have all standard operations performed upon them. As well as operating on ordinary data such as
numbers and symbols. Functions can also operate on other functions.

Function names can be replaced using transformation rules as follows

To define a simple function in Mathematica some additional symbols must be introduced. A function
which squares its argument is defined as follows

There are two new concepts used in this expression. The argument to the function is the symbol x_.
The underscore after the x indicates to Mathematica that this is an argument to a function. Every
time the symbol x appears in the function definition it will be recognised as an instance of the
function argument, not as an arbitrary symbol.
The second new aspect of the function definition is the function assignment term (:=). This
term effectively delays the evaluation of the function definition until the function is called.

Symbols and numbers can be used as arguments to user defined functions.

When defining functions it may be necessary to check the symbol being used to represent the
function is not already in use. The '?' symbol lists the current definition associated with a variable.

As can be seen the '?' operator displays the scope of the variable as well as its current value.

Since all built-in functions in Mathematica have names which begin with capital letters it is a
useful convention to begin the names of user-defined functions with lower case letters to avoid
confusion.
Functions can accept multiple arguments, some or all of which can be other functions.
The following function has another function as its first argument.

The first argument supplied to this function will be interpreted as a function.

In Mathematica one of the most powerful and flexible objects is the list. A list contains a group of
elements which can be either numbers or symbols. Lists are a convenient way of grouping together
several expressions Curly brackets are used to signify the start and the end of the list with the elements
separated by commas.

Most of the mathematical functions available in Mathematica are constructed so that they can act
separately on each element of a list.This property is known as being 'listable'. The following
expression raises 2 to the power of each element in the list.

Not all functions within Mathematica are listable. User-defined functions do not automatically have
the power to act on each element of a list.
There are more efficient methods of creating lists rather than by manual entry. Using the
function Table[] is one such method. This function, in its standard format, has two arguments, the first
being an expression with a varying parameter, and the second being an expression describing how the
parameter varies. To construct a list of the first five positive integers squared we use

The parameter variation argument to the Table function is itself a form of list. In its most general
form it has the following structure {parameter,lower value, upper value, increment}. The parameter
steps fom lowervalue to uppervalue in steps of increment. The increment term can be omitted from
the list resulting in the default increment of 1. In addition the lower value term can be omitted from
the list resulting in a defrault starting value of 1.

Lists can be converted into "tabular" format to improve the presentation of the list

Particular elements of lists can be accessed much in the manner as computer languages. Consider
the following list

Individual elements of a list can be accessed using the rather unusual double square bracket notation i.e.
[[elementnumber]]. Elements are numbered starting at 1. Therefore to access the second element of list, L

The double brackets are necessary to distinguish from single brakets which are used to group the
arguments of a function.

In Mathematica vectors and matrices are represented by lists and lists of lists repectively. A 2 by 2
matrix is defined as follows

The matrix can be displayed in the standard matrix format using the //MatrixForm command.

Rows of the matrix can be extracted by using the row number as the access number.

Individual elements of the matrix can be accessed by supplying the row number and the column
number.

Individual rows and elements can also be modified using by using the list access operator.

Introduction
The Control System Professional is one of the numerous packages in the Mathematica
Applications Library which extend the functionality of Mathematica. The Control System
Professional is an integrated set of tools which allows key aspects of control engineering to be
performed. The software makes provision for modelling, design, analysis, refinement and simulation.
Discrete and continuous-time systems, time and frequency domain analysis, as well as scalar and
multivariable systems are all features of the package. Systems can be composed of blocks using
a number of interconnection techniques. In addition time delay systems can be handled and a library
of linearization methods are provided for non-linear systems.
The advantage of Mathematica providing control tools is that symbolic and numeric models
can be used together so greater analytic insight can be given into problems. The arbitrary precision
provided removes concern over numerical error which may be a factor in other computing
environments. An object orientated approach is taken to represent simplify the manipulation of control
techniques.

Control Objects
The Control System Professional toolbox uses object orientated methodology to describe
basic control systems. There are three different types of control system object available: Transfer
Function, StateSpace and ZeroPoleGain. All three system types store information about a control
system but using different parameters. Each can be considered as a 'wrapper' within which the
system data is stored. It is a simple process to convert one system type to another if desired. For
greater convenience the same data structures are used to represent SISO or MIMO and continuous-time
or discrete-time systems.
To make use of the Control Systems Professional functionality the following command is used :

The basic form for representing transfer function matrices is the TransferFunction[] data structure.
This function accepts one formal parameter and a matrix of transfer functions of that parameter. A
simple integrator can be generated using the TransferFunction[] wrapper as follows

Although s has been used as the formal parameter any symbol could be used and the
TransferFunction object would still represent a continuous-time function.

At this point the complex variable, I, can be introduced. I represents the square root of -1 as
can be seen below

The value of a transfer function at a particular numeric frequency can be obtained using the
complex variable. First a 2x1 matrix of transfer functions is generated.

The two transfer functions can be evaluated at a frequency of 10 radians by passing the argument
10 I to the transfer function matrix.

The result shows the values of the responses at this frequency.
All transfer functions entered are considered as matrices, with a scalar (SISO) function
automatically internally converted into a matrix. This internal representaion should not concern the user.

Transfer functions can be represented in a number of different forms depending on the needs of the
user. Consider the following transfer function matrix:

The FactorRational[] command can be used to factorise every transfer function within an array.

A factored transfer function can also be converted into its expanded form using ExpandRational[]

The coeffeicients of the factored form of individual transfer function matrix elements can be stored
using the data structure ZeroPoleGain[]. As the name suggests the transfer functions stored in this
way are represented as an array of zeros, poles and gains. To allow a ZeroPoleGain format transfer
function to converted into standard TranferFunction format the variable symbol of the equation
must also be stored.

The above equation can be converted into its ZeroPoleGain format.

The new format shows that the transfer function has one zero at -3 and poles at -5 and -4. Since
the variable s is stored the transfer function can be converted to its original format.

It is also possible to extract the zeros and poles information separately from a ZeroPoleGain format
transfer function.

State-Space Representations

Continuous time state-space systems are represented by the following equations

where A is the state matrix, B the input matrix, C the output matrix and D the feedthrough matrix.

The StateSpace object is used to represent state-space systems. To define a StateSpace object it is
not necessary to define all the constituent matrices. If the D matrix only is omitted it is assumed to be zero.
If the C and D matrices are omitted then no assumptions are made about them.

A second order SISO system can be defeined as follows

State space representations of TransferFunction objects can be simply generated.

The state-space 'wrapper' is now applied to the transfer function

The standard notation for displaying the state space matrices can be somewhat unclear so
ReviewForm[] can be used to clarify the matrices structure.

One drawback of the StateSpace function is that it does not check the consistency of the componenet
matrices it generates. This can be harmful since many follow on functions which operate on
state space realisations require consistent matrices. By asserting that the symbolic variables of the
system are complex the realization can be simplified

All of the system objects, TransferFunction, StateSpace and ZeroPoleGain, can represent
systems in either the continuous-time or the discrete-time domain. This is done by setting the option
Sampled to either True or False (or Period[Value]). Once the option is set it remains part of the
data structure allowing the same object to represent either form of system.

It is not necessary to explicitly set the option Sampled for each object since the global option
$Sampled is set by default to False. If discrete systems are being used predominantly then this
global variable can be set to True.

A simple continuous-time integrator can be converted to discrete-time as follows

The symbol used to represent imaginary frequencies remains s although the equation now
represents a discrete-time system. It is possible, to avoid confusion, to replace the symbol by z.

State space systems can be converted to discrete-time representation in the same way.

The conversion between analog and sampled systems is an approximation which depends on the
conversion method and the sampling time. The default conversion, the bilinear transform, is a numerical
integration method. Hold equivalence methods and the zero-pole mapping method are also available within
the package.

In practice , control systems are constructed using a series of blocks to represent different
components of the physical system. Such interconnections can be reproduced in the CSP environment.
Systems can either be connected in series, parallel, or feedback configuration. Two simple
subsystems will be used to demonstrate this facility.

These subsystems can now be connected in series and in parallel as follows :

The system transfer function created when system sub1 is connected in negative unity feedback
configuration can be derived using :

SeriesConnect,ParallelConnect and FeedbackConnect can all be used on state space systems as
well as transfer functions.There is also a GenericConnect function in CSP which allows arbitrary
connections to be made between blocks

Control System Professional allows linear systems to be analysed in both the time domain and the
frequency domain. This section will consider time domain responses. Mathematica can obtain time domain
system responses using either a symbolic approach, or a simulation based method The functions
StateResponse and OutputResponse can use either approach, while SimulationPlot function always uses
the simulation based method.

Symbolic Responses
The function OutputResponse[],given a system in either transfer function or system
matrix form, and an input signal, produces an expression which describes the system output. These
methods will be demonstrated below.

The response of the above system to a sinusodial input with a frequency of 10 radians per
second can be found using the following command :

As well as supplying the OutputResponse[] function with the system transfer function and input function,
the time variable, in this case t, must also be provided as an argument. Once the output expression
has been generated Mathematica can plot the function over a user selected time interval

As well as sinusoids, step responses can be created using the UnitStep[] function to generate
the input signal. If necessary, a single transfer function from a matrix of transfer functions can be
analysed using the Subsystem[] command. These two techniques are shown below.

Firstly, a two-input system is generated

To determine the signal propagation from the second input to the output a unit step is
applied after 1 second.

The response can now be plotted as follows

Obtaining time responses for state space systems is a slightly more complex process. Firstly the
state responses due to each input signal must first be calculated, then based on these responses,
the output response of the system is then calculated.

When input signals are supplied to StateResponse and OutputResponse functions then a symbolic
solution is found. In some instances, however, a symbolic computation of a system response can be
impossible or very time consuming to calculate. In these situations a time simulation is used to generate
the response of a system to an input signal avoiding the need to compute exact symbolic responses. A
simulation can be performed starting at time, t=0, with the initial condition set by the variable InitialConditions.

The following transfer function defines a second order system with natural frequency wn and damping ratio
zeta.

The step response of an underdamped second order system can be observed by selecting a damping
ratio of 0.1 and simulating the response.

Control System Professional provides a range of tools which assist in the design of control
systems. In this section the classical design techniques available are demonstrated.

Root Locus

The RootLocusPlot[] command allows the position of poles of the characteristic function of a
system to be plotted. Consider the following transfer function :

Root locus plots are used to plot the variation in the position of the poles as a parameter
of the system varies.

Because the original transfer function does not have the parameter specified k it is assumed to be the
system gain. In this case the gain has been varied from 0 to 10.
An additional function RootLocusAnimation[] is available, which plots a separate diagram for each
value of k.

The Bode plot, used as a frequency analysis tool for control systems design, is also available within CSP.

The bode plot of a simple first order system is obtained as follows

The advantage of using a symbolic language to represent control systems can be illustrated with the
following simple example. A second order system with a natural frequency of 1 rad/sec and a variable
damping ratio is defined by the following :

The symbolic representation of the general system allows the specific cases to be quickly
generated. The varying frequency characteristics of the transfer functions can be observed on
a Bode plot, which can be easily obtained

The effect of varying the parameter on the system response can be easily observed using this process.
Another feature of the bode plot is the ability to display gain and phase margins of the system. This is
illustrated below, where the vertical lines on the magnitude and phase plots show the gain and phase
margins respectively

The Nyquist plot allows the stability of the closed-loop system to be assessed by analysing
the frequency response of a system in the complex plane. An example of the CSP Nyquist
plot is shown below.

Measures such as gain and phase margins can be determined from the Nyquist chart

The Nichols plot is another method of displaying the frequency characteristics of a system. The
magnitude response is plotted versus the phase response on a semilogarithmic scale. An example
of the CSP Nichols plot is shown below.

Nichols plots are often used to assist in the design of controllers to loop-shape open-loop responses.
Quantitative Feedback Theory (QFT) is a control systems design method which utilises the Nichols
Chart. The open-loop and closed-loop response of the controlled system can be shown on the same
Nichols plot
Singular value plots are also available within the package if the stability of multiple-input
multiple-output systems is to be determined.

Advanced Control Design Methods

Feedback Control Systems Design
One method used to design feedback control systems is to design a controller which places the poles of the system in a desired position in the complex plane. Pole placement design is supported within the CSP using a two different algorithms.The function StateFeedbackGains is used to calculate the gains of the feedback matrix which will place the system poles as desired. This function is applicable to both continuous and discrete systems. A VerifyPoles function is used to check the design process has been successful.
The feedback gains can be calculated using two methods, Ackermann or Kausty-Nichols-Van Doreen (KNVD). Ackermann's method is more useful for single input systems or systems where a single input is used to control a multi-input sinal. KNVD is a more robust algorithm used in multi-input systems.

Optimal Control Systems Design

Linear Quadratic Regulators
Optimal control systems operate by penalising the magnitude of certain system signals. Steady-state errors, transient errors and the control effort are combined into a quadratic cost function which is minimised to find an optimal control system.
For linear and quadratic systems the optimal control problem is linear-quadratic. The function LQRegulatorGains[] is used to find the optimal feedback gains which will minmise the cost function for such a system.
The cost function of a system can be defined such that its behaviour is optimised with respect to the output signal. In this case the function LQOutputRegulatorGains[] is used to determine the optimal feedback gains for the given system.
To find an optimal controller for a continuous system with a quadratic cost function a Riccati equation must be solved. CSP allows Riccati equations to be explicity solved using the the RiccatiSolve[] function. When feedback gains are calculated with LQRegulatorGains[] the RiccatiSolve[] function is automatically used.

Optimal Estimation

If a system is subject signals such as randon disturbances, process noise and measurement noise then the
state vector of this system can be estimated using a least-squares unbiased approximation. The function
LQEstimatorGains[] is provided by CSP for this purpose. An optimal controller for such a system can be
designed, based on the separation principle, using the function Controller[]. This function requires that the
state estimates of the system and the LQ gains of the system have been calculated previously.

Non-linear Systems Control Design

CSP does not extesively deal with the non-linear control problem. It does, however, allow non-linear
functions to be linearised at particular operating points using the Linearize[] command. A controller can
then be designed, using a suitable method, for the resulting linear function.

Utility Functions

The previous sections have outlined the main contents of the Control Systems Professional toolbox.
However there a some additional features provided which may be of some use when solving control
problems. These include Schur decomposition, Lypunov equation solving, matrix rank calculation and
consistency checking for system dimensions.

Summary

Mathematica is a powerful computing package capable of performing infinite precision numerical calculations as well as symbolic calculations. With the development of the Control System Professional toolbox the benefits of the Mathematica environment have been applied to the field of control engineering. The analysis and design features included make the Control System Professional a valuable tool for the control engineer.