Mupad Tutorial

Symbolic Math Toolbox™ 5
MuPAD® Tutorial
How to Contact The MathWorks
www.mathworks.com Web
comp.soft-sys.matlab Newsgroup
www.mathworks.com/contact_TS.html Technical Support
[email protected] Product enhancement suggestions

[email protected] Bug reports
[email protected] Documentation error reports
[email protected] Order status, license renewals, passcodes
[email protected] Sales, pricing, and general information
508-647-7000 (Phone)
508-647-7001 (Fax)
The MathWorks, Inc.

3 Apple Hill Drive
Natick, MA 01760-2098
For contact information about worldwide offices, see the MathWorks Web site.
Symbolic Math Toolbox™ MuPAD® Tutorial
© COPYRIGHT 1997–2008 by SciFace Software GmbH & Co. KG.
The software described in this document is furnished under a license agreement. The software may be used
or copied only under the terms of the license agreement. No part of this manual may be photocopied or
reproduced in any form without prior written consent from The MathWorks, Inc.
FEDERAL ACQUISITION: This provision applies to all acquisitions of the Program and Documentation
by, for, or through the federal government of the United States. By accepting delivery of the Program or
Documentation, the government hereby agrees that this software or documentation qualifies as commercial
computer software or commercial computer software documentation as such terms are used or defined
in FAR 12.212, DFARS Part 227.72, and DFARS 252.227-7014. Accordingly, the terms and conditions of
this Agreement and only those rights specified in this Agreement, shall pertain to and govern the use,
modification, reproduction, release, performance, display, and disclosure of the Program and Documentation
by the federal government (or other entity acquiring for or through the federal government) and shall
supersede any conflicting contractual terms or conditions. If this License fails to meet the government’s
needs or is inconsistent in any respect with federal procurement law, the government agrees to return the
Program and Documentation, unused, to The MathWorks, Inc.
Trademarks
MuPAD is a registered trademark of SciFace Software GmbH & Co. KG. MATLAB and Simulink
are registered trademarks of The MathWorks, Inc. See www.mathworks.com/trademarks for a list
of additional trademarks. Other product or brand names may be trademarks or registered
trademarks of their respective holders.
Patents
The MathWorks products are protected by one or more U.S. patents. Please see
www.mathworks.com/patents for more information.
Preface
This book explains the basic use of the MuPAD® computer algebra system, and
gives some insight into the power of the system. MuPAD is available as part of the
Symbolic Math Toolbox™ in MATLAB® .
This introduction addresses mathematicians, engineers, computer scientists,
natural scientists and, more generally, all those in need of mathematical
computations for their education or their profession. Generally speaking, this
book addresses anybody who wants to use the power of a modern computer
algebra package.
There are two ways to use a computer algebra system. On the one hand, you may
use the mathematical knowledge it incorporates by calling system functions
interactively. For example, you can compute symbolic integrals or generate and
invert matrices by calling appropriate functions. They comprise the system’s
mathematical intelligence and may implement sophisticated algorithms.
Chapters 2 through 14 discuss this way of using the MuPAD engine.
On the other hand, with the help of the MuPAD programming language, you can
easily add functionality to the system by implementing your own algorithms as
MuPAD procedures. This is useful for special purpose applications if no
appropriate system functions exist. Chapters 15 through 17 are an introduction to
MuPAD programming.
You can read this book in the standard way “linearly” from the first to the last
page. However, there are reasons to proceed otherwise. This may be the case, e.g.,
if you are interested in a particular problem, or if you already know something
about MuPAD.
For beginners, we recommend to start reading Chapter 2, which gives a first
survey of MuPAD. The description of the online help system in Section 2.2 is
probably the most important part of this chapter. The help system provides
information about details of system functions, their syntax, their calling
parameters, etc. It is available online whenever the MuPAD notebook interface is
running. In the beginning, requesting a help page is probably your most frequent
query to the system. After you have grown familiar with the help system, you may
start to experiment with MuPAD. Chapter 2 demonstrates some of the most
important system functions “at work.” You will find further details about these
functions in later parts of the book or in the help pages. For a deeper
Preface
understanding of the data structures involved, you may consult the corresponding
sections in Chapter 4.
Chapter 3 discusses the MuPAD libraries and their use. They contain many
functions and algorithms for particular mathematical topics.
The basic data types and the most important system functions for their
manipulation are introduced in Chapter 4. It is not necessary to study all of them
in the same depth. Depending on your intended application, you may selectively
read only the passages about the relevant topics.
Chapter 5 explains how MuPAD evaluates objects; we strongly recommend to read
this chapter.
Chapters 6 through 11 discuss the use of some particularly important system
functions: substitution, differentiation, symbolic integration, equation solving,
random number generation, and graphic commands.
Several useful features such as the history mechanism, input and output routines,
or the definition of user preferences are described in Chapters 13.2 through 13.
Preferences can be used to configure the system’s interactive behavior after the
user’s fancy to a certain extent.
Chapters 15 through 17 give an introduction to the basic concepts of the MuPAD
programming language.
MuPAD provides algorithms that can handle a large class of mathematical objects
and computational tasks related to them. Upon reading this introduction, it is
possible that you encounter unknown mathematical notions such as rings or
fields. This introduction is not intended to explain the mathematical background
for such objects. Basic mathematical knowledge is helpful but not mandatory to
understand the text. Sometimes you may ask what algorithm MuPAD uses to
solve a particular problem. The internal mode of operation of the MuPAD
procedures is not addressed here: we do not intend to give a general introduction
to computer algebra and its algorithms. The interested reader may consult text
books such as, e.g., [GCL 92] or [GG 99].
This book gives an elementary introduction to MuPAD. Somewhat more abstract
mathematical objects such as, e.g., field extensions, are easy to describe and to
handle in MuPAD. However, such advanced aspects of the system are not
discussed here. The mathematical applications that are mentioned in the text are
ii
Preface
intentionally kept on a rather elementary level. This is to keep this text plain for
readers with little mathematical background and to make it applicable at school
level.
We cannot explain the complete functionality of MuPAD in this introduction.
Some parts of the system are mentioned only briefly. It is beyond the scope of this
tutorial to go into the details of the full power of the MuPAD programming
language. You find these in the MuPAD help system, available online during a
MuPAD session.
This tutorial refers to MuPAD version 5 and later. Since the development of the
system advances continuously, some of the details described may change in the
future. Future versions will definitely provide additional functionality through
new system functions and application packages. In this tutorial, we mainly
present the basic tools and their use, which will probably remain essentially
unchanged. We try to word all statements in the text in such a way that they stay
basically valid for future MuPAD versions.
iii
Contents
Preface
i
Introduction
1
Numerical Computations . . . . . . . . . . . . . . . . . . . . . . . . . . 1-2
Computer Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-3
Characteristics of Computer Algebra Systems . . . . . . . . . . . . . . . 1-5
MuPAD® Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-6
First Steps in MuPAD®

2
Notebook interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-2
Explanations and Help . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-4
Computing with Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5
Exact Computations . . . . . . . . . . . . . . . . . . . . . . . . . 2-6
Numerical Approximations . . . . . . . . . . . . . . . . . . . . . 2-7
Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9
Symbolic Computation . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-11
Introductory Examples . . . . . . . . . . . . . . . . . . . . . . . . 2-11
Curve Sketching . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-21
Elementary Number Theory . . . . . . . . . . . . . . . . . . . . . 2-24
Contents
The MuPAD® Libraries

3
Information About a Particular Library . . . . . . . . . . . . . . . . . . 3-2
Exporting Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-4
The Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-6
MuPAD® Objects
4
Operands: the Functions op and nops . . . . . . . . . . . . . . . . . . . 4-3
Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-6
Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-8
Symbolic Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-12
Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-12
Expression Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-19
Operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-21
Sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-24
Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-28
Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-36
Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-40
Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-44
Boolean Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-47
Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-49
Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-52
Series Expansions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-56
Algebraic Structures: Fields, Rings, etc. . . . . . . . . . . . . . . . . . . 4-60
Vectors and Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-64
Definition of Matrices and Vectors . . . . . . . . . . . . . . . . . 4-64
Computing with Matrices . . . . . . . . . . . . . . . . . . . . . . 4-70
Special Methods for Matrices . . . . . . . . . . . . . . . . . . . . 4-72
The Libraries linalg and numeric . . . . . . . . . . . . . . . . . 4-74
Sparse Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-77
An Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-78
Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-81
vi
Contents
Definition of Polynomials . . . . . . . . . . . . . . . . . . . . . . 4-81

Computing with Polynomials . . . . . . . . . . . . . . . . . . . . 4-85
Hardware Float Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-92
Interval Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-94
Null Objects: null(), NIL, FAIL, undefined . . . . . . . . . . . . . . . . 4-99
Evaluation and Simplification

5
Identifiers and Their Values . . . . . . . . . . . . . . . . . . . . . . . . . 5-1
Complete, Incomplete, and Enforced Evaluation . . . . . . . . . . . . . 5-4
Automatic Simplification . . . . . . . . . . . . . . . . . . . . . . . . . . 5-10
Evaluation at a Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5-13
Substitution: subs, subsex, and subsop

6
Differentiation and Integration

7
Differentiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7-2
Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7-4
Solving Equations: solve

8
Polynomial Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-2
General Equations and Inequalities . . . . . . . . . . . . . . . . . . . . 8-9
Differential Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-12
vii
Contents
Recurrence Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-15
Manipulating Expressions
9
Transforming Expressions . . . . . . . . . . . . . . . . . . . . . . . . . 9-3
Simplifying Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . 9-13
Assumptions about Mathematical Properties . . . . . . . . . . . . . . . 9-18
Chance and Probability

10
Graphics
11
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-1
Easy Plotting: Graphs of Functions . . . . . . . . . . . . . . . . . . . . 11-2
2D Function Graphs . . . . . . . . . . . . . . . . . . . . . . . . . 11-2
3D Function Graphs . . . . . . . . . . . . . . . . . . . . . . . . . 11-18
Advanced Plotting: Principles and First Examples . . . . . . . . . . . . 11-33
General Principles . . . . . . . . . . . . . . . . . . . . . . . . . . 11-33
Some Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-39
The Full Picture: Graphical Trees . . . . . . . . . . . . . . . . . . . . . 11-46
Viewer, Browser, and Inspector: Interactive Manipulation . . . . . . . 11-50
Primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-54
Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-57
Default Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-57
Inheritance of Attributes . . . . . . . . . . . . . . . . . . . . . . . 11-58
Primitives Requesting Scene Attributes: “Hints” . . . . . . . . . 11-62
The Help Pages of Attributes . . . . . . . . . . . . . . . . . . . . . 11-65
viii
Contents
Colors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-67
RGB Colors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-67
HSV Colors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-69
Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-71
Generating Simple Animations . . . . . . . . . . . . . . . . . . . 11-71
Playing Animations . . . . . . . . . . . . . . . . . . . . . . . . . . 11-75
The Number of Frames and the Time Range . . . . . . . . . . . . 11-76
What Can Be Animated? . . . . . . . . . . . . . . . . . . . . . . . 11-78
Advanced Animations: The Synchronization Model . . . . . . . . 11-79
Frame by Frame Animations . . . . . . . . . . . . . . . . . . . . . 11-83
Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-90
Groups of Primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-95
Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-97
Legends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-100
Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-104
Saving and Exporting Pictures . . . . . . . . . . . . . . . . . . . . . . . 11-107
Interactive Saving and Exporting . . . . . . . . . . . . . . . . . . 11-107
Batch Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-108
Importing Pictures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-110
Cameras in 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-112
Strange Effects in 3D? Accelerated OpenGL® library? . . . . . . . . . . 11-120
Input and Output

12
Output of Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12-1
Printing Expressions on the Screen . . . . . . . . . . . . . . . . . 12-1
Modifying the Output Format . . . . . . . . . . . . . . . . . . . . 12-3
Reading and Writing Files . . . . . . . . . . . . . . . . . . . . . . . . . . 12-5
The Functions write and read . . . . . . . . . . . . . . . . . . . . 12-5
Saving a MuPAD® Session . . . . . . . . . . . . . . . . . . . . . . 12-6
Reading Data from a Text File . . . . . . . . . . . . . . . . . . . . 12-6
ix
Contents
Utilities
13
User-Defined Preferences . . . . . . . . . . . . . . . . . . . . . . . . . . 13-2
The History Mechanism . . . . . . . . . . . . . . . . . . . . . . . . . . . 13-6
Information on MuPAD® Algorithms . . . . . . . . . . . . . . . . . . . 13-9
Restarting a MuPAD® Session . . . . . . . . . . . . . . . . . . . . . . . 13-11
Executing Commands of the Operating System . . . . . . . . . . . . . . 13-12
Type Specifiers
14
The Functions type and testtype . . . . . . . . . . . . . . . . . . . . . 14-2
Comfortable Type Checking: the Type Library . . . . . . . . . . . . . . 14-4
Loops
15
Branching: if-then-else and case

16
MuPAD® Procedures
17
Defining Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-3
The Return Value of a Procedure . . . . . . . . . . . . . . . . . . . . . . 17-5
Returning Symbolic Function Calls . . . . . . . . . . . . . . . . . . . . . 17-7
Local and Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . 17-9
x
Contents
Subprocedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-14
Scope of Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-17
Type Declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-20
Procedures with a Variable Number of Arguments . . . . . . . . . . . . 17-21
Options: the Remember Table . . . . . . . . . . . . . . . . . . . . . . . 17-23
Input Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-27
Evaluation Within Procedures . . . . . . . . . . . . . . . . . . . . . . . 17-29
Function Environments . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-31
A Programming Example: Differentiation . . . . . . . . . . . . . . . . . 17-38
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . 17-41
Solutions to Exercises
A
Documentation and References

B
Graphics Gallery
C
Comments on the Graphics Gallery

D
xi
Contents
Index
Index
xii
1
Introduction
To explain the notion of computer algebra, we compare algebraic and numerical

computations. Both kinds are supported by a computer, but there are
fundamental differences, which are discussed in what follows.
1 Introduction
Numerical Computations
Many a mathematical problem can be solved approximately by numerical
computations. The computation steps operate on numbers, which are stored
internally in floating-point representation. This representation has the drawback
that neither computations nor solutions are exact due to rounding errors. In
general, numerical algorithms find approximate solutions as fast as possible.
Often such solutions are the only way to handle a mathematical problem
computationally, in particular if there is no “closed form” solution known. (The
most popular example for this situation are roots of polynomials of high degrees.)
Moreover, approximate solutions are useful if exact results are unnecessary (e.g.,
in visualization).
1-2
Computer Algebra
Computer Algebra
In contrast to numerical computations, there are symbolic computations in
computer algebra. [Hec 93] defines them as “computations with symbols
representing mathematical objects.” Here, an object may be a number, but also a
polynomial, an equation, an expression or a formula, a function, a group, a ring,
or any other mathematical object. Symbolic computations with numbers are
carried out exactly. Internally, numbers are represented as quotients of integers
of arbitrary length (limited by the amount of storage available, of course). These
kinds of computations are called symbolic or algebraic. [Hec 93] gives the
following definitions:
1. “Symbolic” emphasizes that in many cases the ultimate goal of mathematical

problem solving is expressing the answer in a closed formula or finding a
symbolic approximation.
2. “Algebraic” means that computations are carried out exactly, according to

the rules of algebra, instead of using approximate floating-point arithmetic.
Sometimes “symbolic manipulation” or “formula manipulation” are used as

synonyms for computer algebra, since computations operate on symbols and
formulae. Examples are symbolic integration or differentiation such as
Z Z 4
x2 15 d 1
x dx = , x dx = , ln ln x =
2 1 2 dx x ln x
or symbolic solutions of equations. For example, we consider the equation

x4 + p x2 + 1 = 0 in x with one parameter p. Its solution set is
 √ q p √ q p 
 2 −p − p2 − 4 2 −p + p2 − 4 
± , ± .
 2 2 
The symbolic computation of an exact solution usually requires more computing

time and more storage than the numeric computation of an approximate solution.
However, a symbolic solution is exact, more general, and often provides more
information about the problem and its solution. The above formula expresses the
solutions of the equation in terms of the parameter p. It shows how the solutions
1-3
1 Introduction
depend functionally on p. This information can be used, for example, to examine

how sensitive the solutions behave when the parameter changes.
Combinations of symbolic and numeric methods are useful for special
applications. For example, there are algorithms in computer algebra that benefit
from efficient hardware floating-point arithmetic. On the other hand, it may be
useful to simplify a problem from numerical analysis symbolically before applying
the actual approximation algorithm.
1-4
Characteristics of Computer Algebra Systems
Characteristics of Computer Algebra Systems

Most of the current computer algebra systems can be used interactively. The user
enters some formulae and commands, and the system evaluates them. Then it
returns an answer, which can be manipulated further if necessary.
In addition to exact symbolic computations, most computer algebra packages can
approximate solutions numerically as well. The user can set the precision to the
desired number of digits. In MuPAD® , the global variable DIGITS handles this.
For example, if you enter the simple command DIGITS:= 100, then MuPAD
performs all floating-point calculations with a precision of 100 decimal digits. Of
course, such computations need more computing time and more storage than the
use of hardware floating-point arithmetic.
Moreover, modern computer algebra systems provide a powerful programming
language1 and tools for visualization and animation of mathematical data. Also,
many systems can produce layouted documents (known as notebooks or
worksheets). The MuPAD system has such a notebook concept, but we will only
sketch it briefly in this tutorial. Please check the user interface documentation
instead for more details. The goal of this book is to give an introduction to the
mathematical power of the MuPAD language.
1 The MuPAD programming language is structured similarly to Pascal, with extensions such as lan-
guage constructs for object oriented programming.
1-5
1 Introduction
MuPAD® Software
In comparison to other computer algebra systems, MuPAD® has the following
noteworthy features, which are not discussed in detail in this book:
• There are MuPAD language constructs for object oriented programming.

You can define your own data types, e.g., to represent mathematical
structures. Almost all existing operators and functions can be overloaded.
• There is a highly interactive MuPAD source code debugger.
• Programs written in C or C++ can be added to the kernel by the MuPAD

dynamic module concept.
The heart of the MuPAD engine is its kernel, which is implemented in C++. It
comprises the following main components:
– The parser reads the input to the system and performs a syntax check. If no
errors are found, it converts the input to a MuPAD data type.
– The evaluator processes and simplifies the input. Its mode of operation is
discussed later.
– The memory management is responsible for the efficient storage of MuPAD

objects.
– Some frequently used algorithms such as, e.g., arithmetical functions are
implemented as kernel functions in C.
Parser and evaluator define the MuPAD language as described in this book. The
MuPAD libraries, which contain most of the mathematical knowledge of the
system, are implemented in this language.
In addition, MuPAD offers comfortable user interfaces for generating notebooks
or graphics, or to debug programs written in the MuPAD language. The MuPAD
help system has hypertext functionality. You can navigate within documents and
execute examples by a mouse click.
Symbolic Math Toolbox™ also offers a way of using the MuPAD engine to solve
problems directly from the MATLAB® environment, using either commands as
1-6
MuPAD® Software
presented here or, for a selected subset of commands, alternatives fitting more
closely into a MATLAB language program. This book does not discuss these
options, but limits itself to using the MuPAD engine directly, along with the
MuPAD GUIs.
1-7
2
First Steps in MuPAD®
Computer algebra systems such as MuPAD® are often used interactively. For
example, you can enter an instruction to multiply two numbers and have MuPAD
compute the result and print it on the screen.
The following section will give a short description of the user interface. The next
one after that describes the help system. Requesting a help page is probably the
most frequently used command for the beginner. The section after that is about
using MuPAD as an “intelligent pocket calculator”: calculating with numbers.
This is the easiest and the most intuitive part of this tutorial. Afterwards we
introduce some system functions for symbolic computations. The corresponding
section is written quite informally and gives a first insight into the symbolic
features of the system.
2 First Steps in MuPAD®
Notebook interface
After you call the MuPAD® program, you will see the welcome dialog. From there,
you can enter the help system (which is, of course, also available later and will be
described on page 2-4), open an existing file, create a new MuPAD source file or
open a new notebook. Usually, you will wish to open an existing or a new
notebook.
After starting the program, you can enter commands in the MuPAD language.
These commands should be typed into “input regions,” which look like this:
If you press the <Return> key, this finishes your input and MuPAD evaluates the
command that you have entered. Holding <Shift> while pressing <Return>
provokes a linefeed, which you can use to format your input.
After invoking the command, you will see its result printed in the same bracket,
below the input, and if you were at the end of the notebook, a new input region
will be opened below:
sin(3.141)
0.0005926535551
The system evaluated the usual sine function at the point 3.141 and returned a
floating-point approximation of the value, similar to the output of a pocket
calculator.
You can at any time go back to older inputs and edit them. Also, you can click
between the brackets and add text. Editing output is not possible, but you can
copy formulas from the output and paste them someplace else. (When copying a
formula to an input region, it will be automatically translated into an equivalent
command in textual form.)
If you terminate your command with a colon, then MuPAD executes the command
without printing its result on the screen. This enables you to suppress the output
of irrelevant intermediate results.
2-2
Notebook interface
You can enter more than one command in one line. Two subsequent commands
have to be separated by a semicolon or a colon, if the result of the first command
is to be printed or not, respectively:
diff(sin(x^2), x); int(%, x)

2 x cos x2

sin x2
Here x^2 denotes the square of x, and the MuPAD functions diff and int
perform the operations “differentiate” and “integrate” (Chapter 7). The character
% returns the previous expression (in the example, this is the derivative of sin(x2 )).
The concept underlying % is discussed in Chapter 13.2.
In the following example, the output of the first command is suppressed by the
colon, and only the result of the second command appears on the screen:
equations := {x + y = 1, x - y = 1}:
solve(equations)
{[x = 1, y = 0]}
In the previous example, a set of two equations is assigned to the identifier

equations. The command solve(equations) computes the solution. Chapter 8
discusses the solver in more detail.
To quit a MuPAD session, use the corresponding entry in the “File” menu.
2-3
Explanations and Help

If you do not know the correct syntax of a MuPAD® command, you can obtain this
information directly from the online help system. For a brief explanation, simply
type the command name, point your mouse cursor at the command and let it rest
there for a moment. You will get a tooltip with a brief explanation.
The help page of the corresponding function provides more detailed information.
You can request it by entering help("name"), where name is the name of the
function. The function help expects its argument to be a string, which is
generated by double quotes " (Section 4.11). The operator ? is a short form for
help. It is used without parenthesis or quotes:
?solve
The help system is a hypertext system, i.e., similar to browsing the web. Active
keywords are underlined. If you click on them, you obtain further information
about the corresponding notion. The tooltips mentioned above also work in the
help system. You can edit and execute the examples in the help system or copy
and paste them to a notebook.
Exercise 2.1: Find out how to use the MuPAD differentiator diff, and compute
the fifth derivative of sin(x2 ).
2-4
Computing with Numbers

To compute with numbers, you can use MuPAD® like a pocket calculator. The
result of the following input is a rational number:
1 + 5/2
7
2
You see that the returns are exact results (and not rounded floating-point
numbers) when computing with integers and rational numbers:
(1 + (5/2*3))/(1/7 + 7/9)^2
67473
6728
The symbol ^ represents exponentiation. MuPAD can compute big numbers

efficiently. The length of a number that you may compute is only limited by the
available main storage. For example, the 123rd power of 1234 is a fairly big
integer:1
1234^123
17051580621272704287505972762062628265430231311106829\
04705296193221839138348680074713663067170605985726415\
92314554345900570589670671499709086102539904846514793\
13561730556366999395010462203568202735575775507008323\
84441477783960263870670426857004040032870424806396806\
96865587865016699383883388831980459159942845372414601\
80942971772610762859524340680101441852976627983806720\
3562799104
Besides the basic arithmetic functions, MuPAD provides a variety of functions

operating on numbers.
1 In this printout, the “backslash” \ at the end of a line indicates that the result is continued on the
next line. To break long lines in this way, you need to switch off typesetting in the “Notebook” menu.
2-5
A simple example is the factorial n! = 1 · 2 · · · n of a nonnegative integer, which

can be entered in mathematical notation:
100!
93326215443944152681699238856266700490715968264381621\
46859296389521759999322991560894146397615651828625369\
7920827223758251185210916864000000000000000000000000
The function isprime checks whether a positive integer is prime. It returns either
TRUE or FALSE.
isprime(123456789)
FALSE
Using ifactor, you can obtain the prime factorization:

ifactor(123456789)
32 · 3607 · 3803
Exact Computations
√
Now suppose that we want to “compute” the number 56. The problem is that the
value of this irrational number cannot be expressed as a quotient
numerator/denominator of two integers exactly. Thus “computation” can only
mean √to find an exact representation that is as simple as possible. When you
input 56 via sqrt, MuPAD returns the following:
sqrt(56)
√
2 14
√ √ √
The result of the simplification of 56 is the exact value 2 · 14. In MuPAD, 14
(or, sometimes, 14^(1/2)) represents the positive solution of the equation
x2 = 14. Indeed,
√ this is probably the most simple representation of the result. We
stress that 14 is a genuine object with certain properties (e.g., that its square can
be simplified to 14). The system applies them automatically when computing with
such objects. For example:
sqrt(14)^4
196
2-6
As another example for exact computation, let us determine the limit

n
1
e = lim 1 + .
n→∞ n
We use the function limit and the symbol infinity:

limit((1 + 1/n)^n, n = infinity)
e
To enter this number in MuPAD, you have to use E or exp(1), where exp
represents the exponential function. MuPAD knows exact rules of manipulation
for this object. For example, using the natural logarithm ln we find:
ln(1/exp(1))
−1
We will encounter more exact computations later in this tutorial.
Numerical Approximations
Besides exact computations, MuPAD can also perform numerical approximations.

√ example, you can use the function float to find a decimal approximation to
For
56. This function computes the value of its argument in floating-point
representation:
float(sqrt(56))
7.483314774
The precision of the approximation depends on the value of the global variable
DIGITS, which determines the number of decimal digits for numerical
computations. Its default value is 10:
DIGITS; float(67473/6728)
10
10.02868609
2-7
Global variables such as DIGITS affect the behavior of MuPAD, and are also called
environment variables.2 You find a complete list of all environment variables in
Section “Environment Variables” of the MuPAD Quick Reference in the online
documentation. The variable DIGITS can assume any integral value between 1 and
232 − 1, although 1000 can already be considered very large and it is unlikely that
using more than 10 000 digits is reasonable for anything but the most unusual
calculations:
DIGITS := 100: float(67473/6728); DIGITS := 10:
10.02868608799048751486325802615933412604042806183115\
338882282996432818073721759809750297265160523187
We have reset the value of DIGITS to 10 for the following computations. This can
also be achieved via the command delete DIGITS. For arithmetic operations with
numbers, MuPAD automatically uses approximate computation as soon as at
least one of the numbers involved is a floating-point value:
(1.0 + (5/2*3))/(1/7 + 7/9)^2
10.02868609
Please note that none of the two following calls

2/3*sin(2), 0.6666666666*sin(2)
results in an approximate computation of sin(2), since, technically, sin(2) is an

expression representing the (exact) value of sin(2) and not a number:
2/3*sin(2), 0.6666666666*sin(2)
2 sin(2)
, 0.6666666666 sin(2)
3
(The separation of both values by a comma generates a special data type, namely a
sequence, which is described in Section 4.5.)
2 You should be particularly cautious when the same computation is performed with different values
of DIGITS. Some of the more intricate numerical algorithms in MuPAD employ the option “remember.”
This implies that they store previously computed values to be used again (Section 17.9), which can lead
to inaccurate numerical results if the remembered values were computed with lower precision. To be
safe, you should restart the MuPAD session using reset() before increasing the value of DIGITS. This
command clears memory and resets all environment variables to their default values (Section 13.4).
2-8
You have to use the function float to compute floating-point approximations of

the above expressions:3
float(2/3*sin(2)), 0.6666666666*float(sin(2))
0.6061982846, 0.6061982845
Most arithmetic functions,such as the square root, the trigonometric functions,

the exponential function, or the logarithm, automatically return approximate
values when their argument is a floating-point number:
sqrt(56.0), sin(3.14)
7.483314774, 0.001592652916
The constants π and e are denoted by PI and E = exp(1), respectively. MuPAD can
perform exact computations with them:
cos(PI), ln(E)
−1, 1
If desired, you can obtain numerical approximations of these constants by

applying float:
DIGITS := 100: float(PI); float(E); delete DIGITS:
3.141592653589793238462643383279502884197169399375105\
820974944592307816406286208998628034825342117068
2.718281828459045235360287471352662497757247093699959\
574966967627724076630353547594571382178525166427
√ √
Exercise 2.2: Compute 27 − 2 3 and cos(π/8) exactly. Determine numerical
approximations to a precision of 5 digits.
Complex Numbers
√
The imaginary unit −1 is represented in MuPAD by the symbol I in the input
and an upright i in the typeset output:
3 Take a look at the last digits. The second command yields a slightly less accurate result, since
0.666 . . . is already an approximation of 2/3 and the rounding error is propagated to the final result.
2-9
sqrt(-1), I^2
i, −1
You can input complex numbers in the usual mathematical notation x + y i. Both
the real part x and the imaginary part y may be integers, rational numbers, or
floating-point numbers:
(1 + 2*I)*(4 + I), (1/2 + I)*(0.1 + I/2)^3
2 + 9 i, 0.073 − 0.129 i
If you use symbolic expressions such as, e.g., sqrt(2), MuPAD may not return the
result of a calculation in Cartesian coordinates:
1/(sqrt(2) + I)
1
√
2+i
The function rectform (short for: rectangular form) ensures that the result is split
into its real and imaginary parts:
rectform(1/(sqrt(2) + I))
√
2 i
−
3 3
The functions Re and Im return the real part x and the imaginary part y ,
respectively, of a complex number x + y i. The functions conjugate, abs
p , and arg
compute the complex conjugate x − y i, the absolute value |x + y i| = x2 + y 2 ,
and the polar angle, respectively:
Re(1/(sqrt(2) + I)), Im(1/(sqrt(2) + I)),
conjugate(1/(sqrt(2) + I)),
abs(1/(sqrt(2) + I)), arg(1/(sqrt(2) + I)),
rectform(conjugate(1/(sqrt(2) + I)))
√ √ √ ! √
2 1 1 3 2 2 i
, − , √ , , − arctan , +
3 3 2−i 3 2 3 3
2-10
Symbolic Computation
This section comprises some examples of MuPAD® sessions that illustrate a small
selection of the system’s power for symbolic manipulation. The mathematical
knowledge is contained essentially in the MuPAD functions for differentiation,
integration, simplification of expressions etc. This demonstration does not
proceed in a particularly systematic manner: we apply the system functions to
objects of various types, such as sequences, sets, lists, expressions etc. They are
explained in detail one by one in Chapter 4.
Introductory Examples
A symbolic expression may contain undetermined quantities (identifiers). The

following expression contains two unknowns x and y :
f := y^2 + 4*x + 6*x^2 + 4*x^3 + x^4
x4 + 4 x3 + 6 x2 + 4 x + y 2
Using the assignment operator :=, we have assigned the expression to an

identifier f, which can now be used as an abbreviation for the expression. We say
that the latter is the value of the identifier f. We note that MuPAD has exchanged
the order of the terms.4
MuPAD offers the system function diff for differentiating expressions:
diff(f, x), diff(f, y)
4 x3 + 12 x2 + 12 x + 4, 2 y
Here, we have computed both the derivative with respect to x and to y . You may
obtain higher derivatives either by nested calls of diff, or by a single call:
diff(diff(diff(f, x), x), x) = diff(f, x, x, x)
24 x + 24 = 24 x + 24
4 Internally, symbolic sums are ordered according to certain rules that enable the system to access
the terms faster. Of course, such a reordering of the input happens only for commutative operations such
as, e.g., addition or multiplication, where changing the order of the operands yields a mathematically
equivalent object.
2-11
Alternatively, you can use the differential operator ', which maps a function to its
derivative:
sin', sin'(x)
cos, cos(x)
The symbol ' for the derivative is a short form of the differential operator D. The
call D(function) returns the derivative:
D(sin), D(sin)(x)
cos, cos(x)
Note: MuPAD uses a mathematically strict notation for the differential operator: D
(or, equivalently, the ' operator) differentiates functions, while diff differentiates
expressions. In the example, the ' maps the (name of the) function to the (name
of the) function representing the derivative. You often find a sloppy notation such
as, e.g., (x + x2 )′ for the derivative of the function F : x 7→ x + x2 . This notation
confuses the map F and the image point f = F (x) at a point x. MuPAD has a
strict distinction between the function F and the expression f = F (x), which are
realized as different data types. The map corresponding to f can be defined by
F := x -> x + x^2:
Then
diff(f, x) = F'(x)
2x + 1 = 2x + 1
are equivalent ways of obtaining the derivative as expressions. The call

f:= x + x^2; f'; does not make sense in MuPAD.
You can compute integrals by using int. The following command computes a
definite integral on the real interval between 0 and 1:
int(f, x = 0..1)
26
y2 +
5
2-12
The next command determines an indefinite integral and returns an expression

containing the integration variable x and a symbolic parameter y :
int(f, x)
x5
+ x4 + 2 x3 + 2 x2 + x y 2
5
Note that int returns a special antiderivative, not a general one (with additive
constant).
If you try to compute the indefinite integral of an expression and it cannot be
represented by elementary functions, then int returns the call symbolically:
integral := int(1/(exp(x^2) + 1), x)
Z
1
dx
ex2 + 1
Nevertheless, this object has mathematical properties. The differentiator

recognizes that its derivative is the integrand:
diff(integral, x)
1
e x2 + 1
Definite integrals may also be returned symbolically by int:

int(1/(exp(x^2) + 1), x = 0..1)
Z 1
1
dx
0 ex2 + 1
The corresponding mathematical object is a real number, and the output is an

exact representation of this number, which MuPAD was unable to simplify further.
As usual, you can obtain a floating-point approximation by applying float:
float(%)
0.41946648
As already noted, the symbol % is an abbreviation for the previously computed

expression (Chapter 13.2).
MuPAD knows the most important mathematical functions such as the square
2-13
root sqrt, the exponential function exp, the trigonometric functions sin, cos, tan,
the hyperbolic functions sinh, cosh, tanh, the corresponding inverse functions ln,
arcsin, arccos, arctan, arcsinh, arccosh, arctanh, as well as a variety of other
special functions such as, e.g., the gamma function, the error function erf, Bessel
functions (besselI, besselJ, …), etc. (Section “Special Mathematical Functions”
of the MuPAD Quick Reference gives a survey.) In particular, MuPAD knows the
rules of manipulation for these functions (e.g., the addition theorems for the
trigonometric functions) and applies them. It can compute floating-point
approximations such as, e.g., float(exp(1)) = 2.718..., and knows special
values (e.g., sin(PI) = 0).
If you call these functions, they often return themselves symbolically, since this is
the most simple exact representation of the corresponding value:
sqrt(2), exp(1), sin(x + y)
√
2, e, sin(x + y)
For many users, the main feature of the system is to simplify or transform such
expressions using the rules for computation. For example, the system function
expand “expands” functions such as exp, sin, etc. by means of the addition
theorems if their argument is a symbolic sum:
expand(exp(x + y)), expand(sin(x + y)),
expand(tan(x + 3*PI/2))
1
ex ey , cos(x) sin(y) + cos(y) sin(x) , −
tan(x)
Generally speaking, one of the main tasks of a computer algebra system is to

manipulate and to simplify expressions. Besides expand, MuPAD provides the
functions collect, combine, factor, normal, partfrac, radsimp, rewrite,
simplify, and Simplify for manipulation. They are presented in greater detail in
Chapter 9. We briefly mention some of them in what follows.
The function normal finds a common denominator for rational expressions:
f := x/(1 + x) - 2/(1 - x): g := normal(f)
x2 + x + 2
x2 − 1
2-14
Moreover, normal automatically cancels common factors in the numerator and

the denominator:
normal(x^2/(x + y) - y^2/(x + y))
x−y
Conversely, partfrac (short for “partial fraction”) decomposes a rational

expression into a sum of rational terms with simple denominators:
partfrac(g, x)
2 1
− +1
x−1 x+1
The functions simplify and Simplify are universal simplifiers and try to find a
representation that is as “simple” as possible:
simplify((exp(x) - 1)/(exp(x/2) + 1))
x
e2 − 1
You may control the simplification by supplying simplify or Simplify with

additional arguments (see the online documentation for details).
The function radsimp simplifies arithmetical expressions containing radicals
(roots):
f := sqrt(4 + 2*sqrt(3)): f = radsimp(f)
q
√ √ √
2 3+2= 3+1
Here, we have generated an equation, which is a genuine MuPAD object.

Another important function is factor, which decomposes an expression into a
product of simpler ones:
factor(x^3 + 3*x^2 + 3*x + 1),
factor(2*x*y - 2*x - 2*y + x^2 + y^2),
factor(x^2/(x + y) - z^2/(x + y))
3 (x − z) · (x + z)
(x + 1) , (x + y − 2) · (x + y) ,
(x + y)
2-15
The function limit does what its name suggests. For example, the function
sin(x)/x has a removable pole at x = 0. Its limit for x → 0 is 1:
limit(sin(x)/x, x = 0)
1
In a MuPAD session, you can define functions of your own in several ways. A
simple and intuitive method is to use the arrow operator -> (the minus symbol
followed by the “greater than” symbol):
F := x -> (x^2): F(x), F(y), F(a + b), F'(x)
2 2 2
x , y , (a + b) , 2 x
In Chapter 17, we discuss MuPAD programming features and describe how to

implement more complex algorithms as MuPAD procedures.
You can also use the graphics facilities to visualize mathematical objects
immediately. The relevant MuPAD functions for generating graphics are the plot
command and the routines from the graphics library plot. Here, we present
simple calls only, please consult Chapter 11 for in-depth information:
plot(sin(x^2), x = -2..5)
2-16
plot(sin(x^2 + y^2), x = 0..PI, y = 0..PI, #3D)
Solving equations or systems of equations is certainly an important task for a

computer algebra system. This is done via solve:
equations := {x + y = a, x - a*y = b}:
unknowns := {x, y}:
solve(equations, unknowns, IgnoreSpecialCases)

a2 + b a−b
x= ,y =
a+1 a+1
Here, we have generated a set of two equations and a set of unknowns which we
wish to solve for. solve returns the result in terms of simplified equations, from
which you can read off the solution. In the above example, there are two more
symbolic parameters a and b. This is why we have told solve which of the symbols
it should express in terms of the others. The “option” IgnoreSpecialCases tells
MuPAD to ignore the possibility that a could be −1, where the above solution
would be incorrect. Without this option, MuPAD returns a complete solution with
three branches:
2-17
solve(equations, unknowns)
 nh io

 x = a2 +b
, y = a−b
if a ̸= −1
 a+1 a+1
 {[x = −z − 1, y = z]} if a = −1 ∧ b = −1


∅ if a = −1 ∧ b ̸= −1
In the following example, we have only one equation in one unknown. MuPAD
automatically recognizes the unknown and solves for it:
solve(x^2 - 2*x + 2 = 0)
{[x = 1 − i] , [x = 1 + i]}
If we supply the unknown x to solve for, the format of the output changes:
solve(x^2 - 2*x + 2 = 0, x)
{1 − i, 1 + i}
The result is a set containing the two (complex) solutions of the quadratic
equation. You find a detailed description of solve in Chapter 8.
The functions sum and product handle symbolic sums and products. For example,
the well-known sum 1 + 2 + · · · + n is:
sum(i, i = 1..n)
n (n + 1)
2
The product 1 · 2 · · · n is known as factorial n!:

product(i^3, i = 1..n)
n!3
2-18
There exist several data structures for vectors and matrices. In principle, you may
use arrays (Section 4.9) to represent such objects. However, it is far more intuitive
to work with the data type “matrix.” You can generate matrices by using the
system function matrix:
A := matrix([[1, 2], [a, 4]])
!
1 2
a 4
Matrix objects constructed this way have the convenient property that the basic
arithmetic operations +, *, etc. are specialized (“overloaded”) according to the
appropriate mathematical context. For example, you may use + or * to add or
multiply matrices, respectively (if the dimensions match):
B := matrix([[y, 3], [z, 5]]):
A, B, A + B, A*B
! ! ! !
1 2 y 3 y+1 5 y + 2z 13
, , ,
a 4 z 5 a+z 9 4 z + a y 3 a + 20
The power A^(-1), equivalent to 1/A, denotes the inverse of the matrix:
A^(-1)
!
− a−2
2 1
a−2
a
2 a−4 − 2 a−4
1
The function linalg::det, from the MuPAD linalg library for linear algebra
(Section 4.15), computes the determinant:
linalg::det(A)
4 − 2a
Column vectors of dimension n can be interpreted as n × 1 matrices:

b := matrix([1, x])
!
1
x
2-19
You can comfortably determine the solution A−1⃗b of the system of linear
equations A⃗x = ⃗b, with the above coefficient matrix A and the previously defined ⃗b
on the right-hand side:
solutionVector := A^(-1)*b
!
x
a−2 − 2
a−2
a
2 a−4 − x
2 a−4
Now you can apply the function normal to each component of the vector by means
of the system function map, thus simplifying the representation:
map(%, normal)
!
x−2
a−2
a−x
2 a−4
To verify the computation, you may multiply the solution vector by the matrix A:
A * %
!
x−2 2 (a−x)
a−2 + 2 a−4
4 (a−x) a (x−2)
2 a−4 + a−2
After simplification, you can check that the result equals b:

map(%, normal)
!
1
x
Section 4.15 provides more information on handling matrices and vectors.
Exercise 2.3: Compute an expanded form of the expression (x2 + y)5 .
x2 − 1
Exercise 2.4: Use MuPAD to check that = x − 1 holds.
x+1
Exercise 2.5: Generate a plot of the function 1/ sin(x) for 1 ≤ x ≤ 10 .
2-20
Exercise 2.6: Obtain detailed information about the function limit. Use
MuPAD to verify the following limits:
sin(x) 1 − cos(x)
lim = 1, lim = 0, lim ln(x) = −∞ ,
x→0 x x
x→0 x→0+
1 x ln(x)
lim xsin(x) = 1 , lim 1 + = e, lim = 0,
x→0 x→∞ x x→∞ ex
π x 2
lim xln(x) = ∞ , lim 1 + = eπ , lim = 0.
x→0+ x→∞ x x→0− 1 + e−1/x
The limit lim ecot(x) does not exist. How does MuPAD react?
x→0
Exercise 2.7: Obtain detailed information about the function sum. The call
sum(f(k), k = a..b) computes a closed form of a finite or infinite sum, if possible.
Use MuPAD to verify the following identity:
X
n
n (n2 + 3 n + 5)
(k 2 + k + 1) = .
3
k=1
Determine the values of the following series:

∞
X ∞
X
2k − 3 k
, .
(k + 1) (k + 2) (k + 3) (k − 1)2 (k + 1)2
k=0 k=2
Exercise 2.8: Compute 2 · (A + B), A · B , and (A − B)−1 for the following

matrices:    
1 2 3 1 1 0
A =  4 5 6 , B =  0 0 1 .
7 8 0 0 1 0
Curve Sketching
In the following sample session, we use some of the system functions from the
previous section to sketch and discuss the curve given by the rational function
(x − 1)2
f : x 7→ +a
x−2
2-21
with a parameter a. First, we determine some characteristics of this function:

discontinuities, extremal values, and behavior for large x. We assume that a is a
real number.
assume(a in R_):
f := x -> (x - 1)^2/(x - 2) + a:
singularities := discont(f(x), x)
{2}
The function discont determines the discontinuities of the function f with

respect to the variable x. It returns a set of such points. Thus, the above f is
defined and continuous for all x ̸= 2. Obviously, x = 2 is a pole. Indeed, MuPAD®
finds the limit ∓∞ when you approach this point from the left or from the right,
respectively:
limit(f(x), x = 2, Left), limit(f(x), x = 2, Right)
−∞, ∞
You find the roots of f by solving the equation f (x) = 0:

roots := solve(f(x) = 0, x)
( √ √ )
a2 + 4 a a a2 + 4 a a
1− − , − +1
2 2 2 2
Depending on a, either both or none of the two roots are real. Now, we want to
find the local extrema of f . To this end, we determine the roots of the first
derivative f ′ :
f'(x)
2
2 x − 2 (x − 1)
−
x−2 (x − 2)
2
extrema := solve(f'(x) = 0, x)
{1, 3}
These are the candidates for local extrema. However, some of them might be
saddle points. If the second derivative f ′′ does not vanish at these points, then
both are really extrema. We check:
2-22
f''(1), f''(3)
−2, 2
Our results imply that f has the following properties: for any choice of the
parameter a, there is a local maximum at x = 1, a pole at x = 2, and a local
minimum at x = 3. The corresponding values of f at these points are
maxvalue := f(1); minvalue := f(3)
a
a+4
f tends to ∓∞ for x → ∓∞:

limit(f(x), x = -infinity), limit(f(x), x = infinity)
−∞, ∞
We can specify the behavior of f more precisely for large values of x. It

asymptotically approaches the linear function x 7→ x + a:
series(f(x), x = infinity)

1 2 4 8 1
x+a+ + 2 + 3 + 4 +O 5
x x x x x
Here we have employed the function series to compute an asymptotic expansion

of f (Section 4.13). We can easily check our results visually by plotting the graph
of f for several values of a:
F := f(x) | a = -4: G := f(x) | a = 0: H := f(x) | a = 4:
F, G, H
2 2 2
(x − 1) (x − 1) (x − 1)
− 4, , +4
x−2 x−2 x−2
The operator | (Chapter 6) evaluates an expression at some point: in the example,

we have substituted the concrete values −4, 0 and 4, respectively, for a. We now
can plot the three functions together in one picture:
2-23
plot(F, G, H, x = -1..4)
Elementary Number Theory
MuPAD® provides a lot of elementary number theoretic functions, for example:
• isprime(n) tests whether n ∈ N is a prime number,
• ithprime(n) returns the n-th prime number,
• nextprime(n) finds the least prime number ≥ n,
• prevprime(n) finds the largest prime number ≤ n,
• ifactor(n) computes the prime factorization of n.
These routines are quite fast. However, since they employ probabilistic primality
tests, they may return wrong results with very small probability. 5 Instead of
isprime, you can use the (slower) function numlib::proveprime as an error-free
primality test.
5 In practice, you need not worry about this because the chances of a wrong answer are negligible:
the probability of a hardware failure is much higher than the probability that the randomized test returns
the wrong answer on correctly working hardware.
2-24
Let us generate a list of all primes up to 10 000. Here is one of many ways to do
this:
primes := select([$ 1..10000], isprime)
[2, 3, 5, 7, 11, 13, 17, ..., 9949, 9967, 9973]
First, we have generated the sequence of all positive integers up to 10 000 by

means of the sequence generator $ (Section 4.5). The square brackets [ ] convert
this to a MuPAD list. Then select (Section 4.6) eliminates all those list elements
for which the function isprime, supplied as second argument, returns FALSE. The
number of these primes equals the number of list elements, which we can obtain
via nops (“number of operands,” Section 4.1):
nops(primes)
1229
Alternatively, we may generate the same prime list by

primes := [ithprime(i) $ i = 1..1229]:
Here we have used the fact that we already know the number of primes up to
10 000. Another possibility is to generate a large list of primes and discard the
ones greater than 10 000:
primes := select([ithprime(i) $ i=1..5000],
x -> (x<=10000)):
Here, the object x -> (x <= 10000) represents the function that maps each x to the
inequality x <= 10000. The select command then keeps only those list elements
for which the inequality evaluates to TRUE.
In the next example, we use a repeat loop (Chapter 15) to generate the list of
primes. With the help of the concatenation operator . (Section 4.6), we
successively append primes i to a list until nextprime(i+1), the next prime greater
than i, exceeds 10 000. We start with the empty list and the first prime i = 2:
primes := []: i := 2:
repeat
primes := primes . [i];
i := nextprime(i + 1)
until i > 10000 end_repeat:
2-25
Now, we consider Goldbach’s famous conjecture:
“Every even integer greater than 2 is the sum of two primes.”
We want to verify this conjecture for all even numbers up to 10 000. First, we
generate the list of even integers [4, 6, …, 10000]:
list := [2*i $ i = 2..5000]:
nops(list)
4999
Now, we select those numbers from the list that cannot be written in the form
“prime + 2.” This is done by testing for each i in the list whether i − 2 is a prime:
list := select(list, i -> (not isprime(i - 2))):
nops(list)
4998
The only integer that has been eliminated is 4 (since for all other even positive
integers i − 2 is even and greater than 2, and hence not prime). Now we discard all
numbers of the form “prime + 3”:
list := select(list, i -> (not isprime(i - 3))):
nops(list)
3770
The remaining 3770 integers are neither of the form “prime + 2” nor of the form
“prime + 3.” We now continue this procedure by means of a while loop
(Chapter 15). In the loop, j successively runs through all primes > 3, and the
numbers of the form “prime + j ” are eliminated. A print command (Section 12.1)
outputs the number of remaining integers in each step. The loop ends as soon as
the list is empty:
j := 3:
2-26
while list <> [] do

j := nextprime(j + 1):
list := select(list, i -> (not isprime(i - j))):
print(j, nops(list)):
end_while:
5, 2747
7, 1926
11, 1400
...
163, 1
167, 1
173, 0
Thus we have confirmed that Goldbach’s conjecture holds true for all even
positive integers up to 10 000. We have even shown that all those numbers can be
written as a sum of a prime less or equal to 173 and another prime.
In the next example, we generate a list of distances between two successive primes
up to 500:
primes := select([$ 1..500], isprime):
distances := [primes[i] - primes[i - 1]
$ i = 2..nops(primes)]
[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2,
6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 14, 4, 6, 2,
10, 2, 6, 6, 4, 6, 6, 2, 10, 2, 4, 2, 12, 12, 4,
2, 4, 6, 2, 10, 6, 6, 6, 2, 6, 4, 2, 10, 14, 4, 2,
4, 14, 6, 10, 2, 4, 6, 8, 6, 6, 4, 6, 8, 4, 8, 10,
2, 10, 2, 6, 4, 6, 8, 4, 2, 4, 12, 8, 4, 8]
The indexed call primes[i] returns the ith element in the list.
2-27
The function zip (Section 4.6) provides an alternative method. The call
zip(a, b, f) combines two lists a = [a1 , a2 , . . . ] and b = [b1 , b2 , . . . ]
componentwise by means of the function f : the resulting list is
[f (a1 , b1 ), f (a2 , b2 ), . . . ]
and has as many elements as the shorter of the two lists. In our example, we apply
this to the prime list a = [a1 , . . . , an ], the “shifted” prime list b = [a2 , . . . , an ], and
the function (x, y) 7→ y − x. We first generate a shifted copy of the prime list by
deleting the first element, thus shortening the list:
b := primes: delete b[1]:
The following command returns the same result as above:

distances := zip(primes, b, (x, y) -> (y - x)):
We have presented another useful function in Section 2.3, the routine ifactor for
factoring an integer into primes. The call ifactor(n) returns an object of the
same type as factor: it is a special data type called Factored. Objects of this type
are printed on the screen in a form that is easily readable:
ifactor(-123456789)
−32 · 3607 · 3803
Internally, the prime factors and the exponents are stored in form of a list, and
you can extract them by using op or by an indexed access. Consult the help pages
of ifactor and Factored for details. The internal list has the format
[s, p1 , e1 , . . . , pk , ek ]
with primes p1 , . . . , pk , their exponents e1 , . . . , ek , and the sign s = ±1, such that
n = s · pe11 · pe22 · · · pekk :
op(%)
−1, 3, 2, 3607, 1, 3803, 1
2-28
We now employ the function ifactor to find out how many integers between 2
and 10 000 are divisible by exactly two distinct prime numbers. We note that the
object returned by ifactor(n) has 2 m + 1 elements in its list representation,
where m is the number of distinct prime divisors of n. Thus, the function
m := n -> (nops(ifactor(n)) - 1)/2:
returns the number of distinct prime factors. We construct the list of values m(k)
for k = 2, . . . , 10000:
list := [m(k) $ k = 2..10000]:
The following for loop (Section 15) displays the number of integers with precisely
i = 1, 2, . . . , 6 distinct prime divisors:
for i from 1 to 6 do
print(i, nops(select(list, x -> (x = i))))
end_for:
1, 1280
2, 4097
3, 3695
4, 894
5, 33
6, 0
Thus there are 1280 integers with exactly one prime divisor in the scanned
interval,6 4097 integers with precisely two distinct prime factors, and so on. It is
easy to see why the interval contains no integer with six or more prime divisors:
the smallest such number 2 · 3 · 5 · 7 · 11 · 13 = 30 030 exceeds 10 000.
The numlib library comprises various number theoretic functions. Among others,
it contains the routine numlib::numprimedivisors, equivalent to the above m, for
computing the number of prime divisors. We refer to Chapter 3 for a description
of the MuPAD libraries.
6 We have already seen that the interval contains 1229 prime numbers. Can you explain the dif-
ference?
2-29
Exercise 2.9: Primes of the form 2n ± 1 always have produced particular

interest.
a) Primes of the form 2p − 1, where p is a prime, are called Mersenne primes.

Find all Mersenne primes for 1 < p ≤ 1000.
n
b) For a positive integer n, the n-th Fermat number is 2(2 )
+ 1. Refute
Fermat’s conjecture that all those numbers are primes.
2-30
3
The MuPAD® Libraries
Most of MuPAD® ’s mathematical knowledge is organized in libraries. Such a

library comprises a collection of functions for solving problems in a particular
area, such as linear algebra, number theory, numerical analysis, etc. Library
functions are written in the MuPAD programming language. You can use them in
the same way as kernel functions, without knowing anything about the
programming language.
Section “Libraries and Modules” of the MuPAD Quick Reference contains a survey
of all libraries. Alternatively, the help viewer contains a list of libraries (and
third-party packages installed) in its contents pane on the left.
The libraries are developed continuously, and future versions of MuPAD will
provide additional functionality.
In this chapter, we do not address the mathematical functionality of libraries but
rather discuss their general use.
3 The MuPAD® Libraries
Information About a Particular Library

You can obtain information and help for libraries by calling the functions info
and help. The function info gives a list of all functions installed in the library.
The numlib library is a collection of number theoretic functions:
info(numlib)
Library 'numlib': the package for elementary
number theory
-- Interface:
numlib::Lambda, numlib::Omega,
numlib::contfrac, numlib::cornacchia,
numlib::decimal, numlib::divisors,
numlib::ecm, numlib::factorGaussInt,
numlib::fibonacci, numlib::fromAscii,
...
The commands help or ? supply a more detailed description of the library.

The function numlib::decimal of the numlib library computes the decimal
expansion of a rational number:1
numlib::decimal(123/7)
17, [5, 7, 1, 4, 2, 8]
As for other system functions, you will see information when hovering your mouse
pointer over the name of a library function and you may request information on
the function by means of help or ?:
?numlib::decimal
1 The result is to be interpreted as: 123/7 = 17.571428 = 17.571428 571428 . . .
3-2
Information About a Particular Library
You can have a look at the implementation of a library function by using expose:
expose(numlib::decimal)
proc(a)
name numlib::decimal;
local p, q, s, l, i;
begin
if not testtype(a, Type::Numeric) then
...
end_proc
3-3
Exporting Libraries
In the previous section, you have seen that the calling syntax for a library function
is library::function, where library and function are the names of the library
and the function, respectively. For example, the library numeric for numerical
computations contains the function numeric::fsolve. It implements a modified
version of the well-known Newton method for numerical root finding. In the
following example, we approximate a root of the sine function in the interval [2, 4]:
numeric::fsolve(sin(x), x = 2..4)
[x = 3.141592654]
The function use2 makes functions of a library “globally known,” so that you can
use them without specifying the library name:
use(numeric, fsolve): fsolve(sin(x), x = 2..4)
[x = 3.141592654]
If you already have assigned a value to the name of the function to be exported,
use returns a warning and the function is not exported. In the following, the
numerical integrator numeric::quadrature cannot be exported to the name
quadrature, because this identifier has a value:
quadrature := 1: use(numeric, quadrature)

Warning: 'quadrature' already has a value, not exported.
After deletion of the value, the name of the function is available and the
corresponding library function can be exported successfully. One can export
several functions at once:
delete quadrature:
use(numeric, realroots, quadrature):
Now you can use realroots (to find all real roots of an expression in an interval)
and quadrature (for numerical integration) directly. Please refer to the
corresponding help pages for the meaning of the input parameters and the
returned output. Please note that neither tooltips nor the help command will
2 This function used to be called export, but that name is more appropriately used for the library
exporting data in formats for other programs.
3-4
Exporting Libraries
react to exported names. You will need to use the full name (or the search
functionality of the help browser) in these cases.
realroots(x^4 + x^3 - 6*x^2 + 11*x - 6,
x = -10..10, 0.001)
[[−3.623046875, −3.62109375] , [0.8217773438, 0.822265625]]
quadrature(exp(x) + 1, x = 0..1)
2.718281828
If you call use with only one argument, namely the name of the library, then all
functions in that library are exported. If there are name conflicts with already
existing identifiers, then use issues warnings:
eigenvalues := 1: use(numeric)
Info: 'numeric::quadrature' already is exported.
Info: 'numeric::realroots' already is exported.
Warning: 'indets' already has a value, not exported.
Info: 'numeric::fsolve' already is exported.
Warning: 'rationalize' already has a value, not
exported.
Warning: 'linsolve' already has a value, not exported.
Warning: 'sum' already has a value, not exported.
Warning: 'int' already has a value, not exported.
Warning: 'solve' already has a value, not exported.
Warning: 'sort' already has a value, not exported.
Warning: 'eigenvalues' already has a value, not
exported.
After deleting the value of the identifier eigenvalues, the library function with the
same name can be exported successfully:
delete eigenvalues: use(numeric, eigenvalues):
However, the other name conflicts int, solve etc. cannot be resolved. The
important symbolic system functions int, solve etc. should not be replaced by
their numerical counterparts numeric::int, numeric::solve etc.
3-5
The Standard Library

The standard library is the most important MuPAD® library. It contains the most
frequently used functions such as diff, simplify, etc. (For an even more
restricted selection of frequently used commands, check the command bar at the
right-hand side of the notebook interface and the MuPAD source code editor.)
The functions of the standard library do not have a prefix separated with ::, as
other functions do (unless exported). In this respect, there is no notable
difference between the MuPAD kernel functions, which are written in the C++
programming language, and the other functions from the standard library, which
are implemented in the MuPAD programming language.
You obtain more information about the available functions of the standard library
by navigating to the relevant section in the help system, which is the first
reference section. The MuPAD Quick Reference lists all functions of the standard
library in MuPAD version 5.
Many of these functions are implemented as function environments
(Section 17.12). You can view the source code via expose(name):
expose(exp)
proc(x)
name exp;
local y, lny, c;
option noDebug;
begin
if args(0) = 0 then
error("expecting one argument")
else
if x::dom::exp <> FAIL then
return(x::dom::exp(args()))
else
if args(0) <> 1 then
error("expecting one argument")
end_if
end_if
end_if;
...
end_proc
3-6
4
MuPAD® Objects
In Chapter 2, we introduced MuPAD® objects such as numbers, symbolic

expressions, maps, or matrices. Now, we discuss these objects more
systematically.
The objects sent to the kernel for evaluation can be of various forms: arithmetic
expressions with numbers such as 1 + (1+I)/3, arithmetic expressions with
symbolic objects such as x + (y + I)/3, lists, sets, equations, inequalities, maps,
arrays, abstract mathematical objects, and more. Every MuPAD object belongs to
some data type, called the domain type. It corresponds to a certain internal
representation of the object. In what follows, we discuss the following
fundamental domain types. As a convention, the names of domains provided by
the MuPAD kernel consist of capital letters, such as DOM_INT, DOM_RAT etc., while
domains implemented in the MuPAD language such as Series::Puiseux or
Dom::Matrix(R) involve small letters:
✞ ☎
domain type meaning
DOM_INT integers, e.g., -3, 10^5
DOM_RAT rational numbers, e.g., 7/11
DOM_FLOAT floating-point numbers, e.g., 0.123
DOM_COMPLEX complex numbers, e.g., 1 + 2/3*I
DOM_INTERVAL floating-point intervals, e.g., 2.1 ... 3.2
DOM_IDENT symbolic identifiers, e.g., x, y, f
DOM_EXPR symbolic expressions, e.g., x + y
Series::Puiseux symbolic series expansions, e.g.,
1 + x + x^2 + O(x^3)
DOM_LIST lists, e.g., [1, 2, 3]
DOM_SET sets, e.g., {1, 2, 3}
DOM_ARRAY arrays
✝ ✆
4 MuPAD® Objects
✞ ☎
domain type meaning
DOM_TABLE tables
DOM_BOOL Boolean values: TRUE, FALSE, UNKNOWN
DOM_STRING strings, e.g., "I am a string"
Dom::Matrix(R) matrices and vectors over the ring R
DOM_POLY polynomials, e.g., poly(x^2 + x + 1, [x])
DOM_PROC functions and procedures
✝ ✆
Moreover, you can define your own data types, but we do not discuss this here.
The system function domtype returns the domain type of a MuPAD object.
In the following section, we first present the important operand function op,
which enables you to decompose a MuPAD object into its building blocks. The
following sections discuss the above data types and some of the main system
functions for handling them.
4-2
Operands: the Functions op and nops

It is often necessary to decompose a MuPAD® object into its components in order
to process them individually. The building blocks of an object are called operands.
The system functions for accessing them are op and nops (short for: number of
operands):
✞ ☎
nops(object) : the number of operands,
op(object,i) : the i-th operand, 0 ≤ i ≤ nops(object),
op(object,i..j) : the sequence of operands i through j ,
where 0 ≤ i ≤ j ≤ nops(object),
op(object) : the sequence op(object, 1), op(object, 2), ...
of all operands.
✝ ✆
The meaning of an operand depends on the data type of the object. We discuss this
for each data type in detail in the following sections. For example, the operands of
a rational number are the numerator and the denominator, the operands of a list
or set are the elements, and the operands of a function call are the arguments.
However, there are also objects where the decomposition into operands is less
intuitive, such as series expansions as generated by the system functions taylor
or series (Section 4.13). Here is an example with a list (Section 4.6):
list := [a, b, c, d, sin(x)]: nops(list)
5
op(list, 2)
b
op(list, 3..5)
c, d, sin(x)
op(list)
a, b, c, d, sin(x)
By repeatedly calling the op function, you can decompose arbitrary MuPAD

expressions into “atomic” ones. In this model, a MuPAD atom is an expression
4-3
4 MuPAD® Objects
that cannot be further decomposed by op, such that op(atom) = atom holds.1 This
is essentially the case for integers, floating-point numbers, identifiers that have
not been assigned a value, and for strings:
op(-2), op(0.1234), op(a), op("I am a text")
−2, 0.1234, a, ”I am a text”
In the following example, a nested list is decomposed completely into its atoms
a11, a12, a21, x, 2:
list := [[a11, a12], [a21, x^2]]
The operands and suboperands are:

✞ ☎
op(list, 1) : [a11, a12]
op(list, 2) : [a21, x^2]
op(op(list, 1), 1) : a11
op(op(list, 1), 2) : a12
op(op(list, 2), 1) : a21
op(op(list, 2), 2) : x^2
op(op(op(list, 2), 2), 1) : x
op(op(op(list, 2), 2), 2) : 2
✝ ✆
1 This model is a good approximation to MuPAD’s internal mode of operation, but there are some
exceptions. For example, you can decompose rational numbers via op, but the kernel regards them as
atoms. On the other hand, although strings are indecomposable with respect to op, it is still possible to
access the characters of a string individually (Section 4.11).
4-4
Instead of the annoying nested calls of op, you may also use the following short
form to access subexpressions:
✞ ☎
op(list, [1]) : [a11, a12]
op(list, [2]) : [a21, x^2]
op(list, [1, 1]) : a11
op(list, [1, 2]) : a12
op(list, [2, 1]) : a21
op(list, [2, 2]) : x^2
op(list, [2, 2, 1]) : x
op(list, [2, 2, 2]) : 2
✝ ✆
Exercise 4.1: Determine the operands of the power a^b, the equation a = b, and
the symbolic function call f(a, b).
Exercise 4.2: The following call of solve (Chapter 8) returns a set:

set := solve({x + sin(3)*y = exp(a),
y - sin(3)*y = exp(-a)}, {x,y})
(" sin(3)
#)
ea sin(3) − ea + 1
x= ea
,y = − a
sin(3) − 1 e (sin(3) − 1)
Extract the value of the solution for y and assign it to the identifier y.
4-5
4 MuPAD® Objects
Numbers
We have demonstrated in Section 2.3 how to work with numbers. There are
various data types for numbers:
domtype(-10), domtype(2/3), domtype(0.1234),
domtype(0.1 + 2*I)
DOM_INT, DOM_RAT, DOM_FLOAT, DOM_COMPLEX
A rational number is a compound object: the building blocks are the numerator
and the denominator. Similarly, a complex number consists of the real and the
imaginary part. You can use the operand function op from the previous section to
access these components:
op(111/223, 1), op(111/223, 2)
111, 223
op(100 + 200*I, 1), op(100 + 200*I, 2)
100, 200
Alternatively, you can use the system functions numer, denom, Re, and Im:
numer(111/223), denom(111/223),
Re(100 + 200*I), Im(100 + 200*I)
111, 223, 100, 200
Besides the common arithmetic operations +, -, *, and /, there are the arithmetic
operators div and mod for division of an integer x by a non-zero integer p with
remainder. If x = k p + r holds with integers k and 0 ≤ r < |p|, then x div p
returns the “integral quotient” k and x mod p returns the “remainder” r:
25 div 4, 25 mod 4
6, 1
Table 4.2 gives a compilation of the main MuPAD functions and operators for
handling numbers. We refer to the help system (i.e., ?abs, ?ceil etc.) for a
detailed
√ description of these functions. We stress that while expressions such as
2 mathematically represent numbers, MuPAD treats them as symbolic
expressions (Section 4.4):
4-6
Numbers
✞ ☎
+, -, *, /, ^ : basic arithmetic operations
abs : absolute value
ceil : rounding up
div : quotient “modulo”
fact : factorial
float : approximation by floating-point numbers
floor : rounding down
frac : fractional part
ifactor, factor : prime factorization
isprime : primality test
mod : remainder “modulo”
round : rounding to nearest
sign : sign
sqrt : square root
trunc : integral part
✝ ✆
®
Table 4.2: MuPAD functions and operators for numbers
domtype(sqrt(2))
DOM_EXPR
Exercise 4.3: What is the difference between 1/3 + 1/3 + 1/3 and
1.0/3 + 1/3 + 1/3 in MuPAD?
π 1
√
Exercise 4.4: Compute the decimal expansions of π (π ) and e 3 π 163 with a
precision of 10 and 100 digits, respectively. What is the 234-th digit after the
decimal point of π ?
Exercise 4.5: After you execute x:= 10^50/3.0, only the first DIGITS decimal
digits of x are guaranteed to be correct.
a) Truncating the fractional part via trunc is therefore questionable. What

does MuPAD do?
b) What is returned for x after increasing DIGITS?
4-7
4 MuPAD® Objects
Identifiers
Identifiers are names such as x or f that may represent variables and unknowns.
They may consist of arbitrary combinations of letters, digits, the hash mark “ #,”
and the underscore “_,” with the only exception that the first symbol must not be a
digit. Identifiers starting with a hash mark can never have values or properties.
MuPAD® distinguishes uppercase and lowercase letters. Examples of admissible
identifiers are x, _x23, and the_MuPAD_system, while MuPAD would not accept
12x, p-2, and x>y as identifiers. MuPAD also accepts any sequence of characters
starting and ending with a ‘backtick’ ` as an identifier, so `x>y` is, in fact, an
identifier. We will not use such identifiers in this tutorial.
Identifiers that have not been assigned a value evaluate to their name. In MuPAD,
they represent symbolic objects such as unknowns in equations. Their domain
type is DOM_IDENT:
domtype(x)
DOM_IDENT
Identifiers can contain special characters, such as an α. We recommend using the

Symbol library for generating these. Using _, ^, $, and {}, you can also create
identifiers with super- and subscripts, as in a11 . We recommend using the Symbol
library for generating these, too.
You can assign an arbitrary object to an identifier by means of the assignment
operator :=. Afterwards, this object is the value of the identifier. For example,
after the command
x := 1 + I:
the identifier x has the value 1 + I, which is a complex number of domain type
DOM_COMPLEX. You should be careful to distinguish between an identifier, its value,
and its evaluation. We refer to the important Chapter 5, where MuPAD’s
evaluation strategy is described.
If an identifier already has been assigned a value, another assignment overwrites
the previous value. The statement y:= x does not assign the identifier x to the
identifier y, but the current value (the evaluation) of x:
4-8
Identifiers
x := 1: y := x: x, y
1, 1
If the value of x is changed later on, this does not affect y:

x := 2: x, y
2, 1
However, if x is a symbolic identifier, which evaluates to itself, the new identifier y

refers to this symbol:
delete x: y := x: x, y; x := 2: x, y
x, x
2, 2
Here we have deleted the value of the identifier x by means of the function delete.
After deletion, x is again a symbolic identifier without a value.
The assignment operator := is a short form of the system function _assign, which
may also be called directly:
_assign(x, value): x
value
This function returns its second argument, namely the right-hand side of an
assignment. This explains the screen output after an assignment:
y := 2*x
2 value
You can work with the returned value immediately. For example, the following
construction is allowed (the assignment must be put in parentheses):
y := cos((x := 0)): x, y
0, 1
Here the value 0 is assigned to the identifier x. The return value of the assignment,
i.e., 0, is fed directly as argument to the cosine function, and the result cos (0) = 1
is assigned to y. Thus, we have simultaneously assigned values to both x and y.
4-9
4 MuPAD® Objects
Another assignment function is assign. Its input are sets or lists of equations,
which are transformed into assignments:
delete x, y: assign({x = 0, y = 1}): x, y
0, 1
This function is particularly useful in connection with solve (Section 8), which
returns solutions as a set containing lists of equations of the form
identifier = value without assigning these values.
There exist many identifiers with predefined values. They represent mathematical
functions (such as sin, exp, or sqrt), mathematical constants (such as PI), or
MuPAD algorithms (such as diff, int, or limit). If you try to change the value of
such a predefined identifier, MuPAD issues a warning or an error message:
sin := 1
Error: Identifier 'sin' is protected [_assign]
You can protect your own identifiers against overwriting via the command
protect(identifier). The write protection of both your own and of system
identifiers can be removed by unprotect(identifier). However, we strongly
recommend not to overwrite predefined identifiers, since they are used by many
system functions which would return unpredictable results after a redefinition.
Identifiers starting with a hash mark (#) are always protected and cannot be
unprotected. The command anames(All) lists all currently defined identifiers.
You can use the concatenation operator “.” to generate names of identifiers
dynamically. If x and i are identifiers, then x.i generates a new identifier by
concatenating the evaluations (see Chapter 5) of x and i:
x := z: i := 2: x.i
z2
x.i := value: z2
value
In the following example, we use a for loop (Chapter 15) to assign values to the
identifiers x1, ..., x1000:
delete x:
for i from 1 to 1000 do x.i := i^2 end_for:
4-10
Identifiers
Due to possible side effects or conflicts with already existing identifiers, we

strongly recommend to use this concept only interactively and not within MuPAD
procedures.
The function genident generates a new identifier that has not been used before in
the current MuPAD session:
X3 := (X2 := (X1 := 0)): genident()
X4
You may use strings enclosed in quotation marks " (Section 4.11) to generate
identifiers dynamically:
a := email: b := "4you": a.b
email4you
Even if the string contains blanks or operator symbols, a valid identifier is

generated, which MuPAD displays using the backtick notation mentioned above:
a := email: b := "4you + x": a.b
email4you + x
Strings are not identifiers and cannot be assigned a value:

"string" := 1
Error: Invalid left-hand side in assignment [line 1, col 10]
Exercise 4.6: Which of the following names x, x2, 2x, x_t, diff, exp,
caution!-!, x-y, Jack&Jill, a_valid_identifier, #1 are valid identifiers?Which
of them can be assigned values?
Exercise 4.7: Read the help page for solve. Solve the system of equations
x1 + x2 = 1, x2 + x3 = 1, . . . , x19 + x20 = 1, x20 = π
in the unknowns x1 , x2 , . . . , x20 . Read the help page for assign and assign the
values of the solution to the unknowns.
4-11
4 MuPAD® Objects
Symbolic Expressions
We say that an object containing symbolic terms such as the equation
f (x, y)
0.3 + sin(3) + =0
5
is an expression. Expressions of domain type DOM_EXPR are probably the most
general data type in MuPAD® . Expressions are built of atomic components, as all
MuPAD objects, and are composed by means of operators. This comprises binary
operators, such as the basic arithmetic operations +, -, *, /, ^, and function calls
such as sin(·), f(·), etc.
Operators
MuPAD® throughout uses functions to combine or manipulate objects.2 It would

be little intuitive, however, to use function calls everywhere, 3 say, _plus(a, b) for
the addition a + b. For that reason, a variety of important operations is
implemented in such a way that you can use the familiar mathematical notation
(“operator notation”) for input. Also the output is given in such a form. In the
following, we list the operators for building more complex MuPAD expressions
from atoms.
The operators +, -, *, / for the basic arithmetic operations and ^ for
exponentiation are valid for symbolic expressions as well:
a + b + c, a - b, -a, a*b*c, a/b, a^b
a b
a + b + c, a − b, −a, a b c, , a
b
You may input these operators in the familiar mathematical way, but internally
they are function calls:
2 Remarkably, the MuPAD kernel treats not only genuine function calls, such as sin(0.2), assign-
ments, or arithmetical operations in a functional way, but also loops (Chapter 15) and case distinctions
(Chapter 16).
3 LISP programmers may disagree.
4-12
_plus(a,b,c), _subtract(a,b), _negate(a),

_mult(a,b,c), _divide(a,b), _power(a,b)
a b
a + b + c, a − b, −a, a b c, , a
b
The same holds for the factorial of a nonnegative integer. You may input it in the
mathematical notation n!. Internally it is converted to a call of the function fact:
n! = fact(n), fact(10)
n! = n!, 3628800
The arithmetic operators div and mod4 were presented in Chapter 4.2. They may
also be used in a symbolic context, but then return only symbolic results:
x div 4, 25 mod p
x div 4, 25 mod p
Several MuPAD objects separated by commas form a sequence:

sequence := a, b, c + d
a, b, c + d
The operator $ is an important tool to generate such sequences:

i^2 $ i = 2..7; xî $ i = 1..5
4, 9, 16, 25, 36, 49
x, x2 , x3 , x4 , x5
Equations and inequalities are valid MuPAD objects. They are generated by the
equality sign = and by <>, respectively:
equation := x + y = 2; inequality := x <> y
x+y =2
x ̸= y
4 The object x mod p is converted to the function call _mod(x, p). The function _mod can be redefined,
e.g., _mod:= modp or _mod:= mods. The behavior of modp and mods is documented on the corresponding
help pages. A redefinition of _mod also redefines the operator mod.
4-13
4 MuPAD® Objects
The operators <, <=, >, and >= compare the magnitudes of their arguments. The
corresponding expressions represent conditions:
condition := i <= 2
i≤2
In a concrete context, they usually can be evaluated to one of the truth (“Boolean”)
values TRUE or FALSE. Typically, they are used in if statements or as termination
conditions in loops. You may combine Boolean expressions via the logical
operators and and or, or negate them via not:
condition3 := condition1 and (not condition2)
condition1 ∧ ¬condition2
You can define maps (functions) in several ways in MuPAD. The simplest method
is to use the arrow operator -> (the minus symbol followed by the “greater than”
symbol):
f := x -> x^2
x → x2
After defining a function in this way, you may call it like a system function:
f(4), f(x + 1), f(y)
2
16, (x + 1) , y 2
If you wish to define a function that first treats the right-hand side as a command
to be performed, use the double arrow operator -->:
g1 := x -> int(f(x), x);
g2 := x --> int(f(x), x)
Z
x→ f (x) dx
x3
x→
3
4-14
The composition of functions is defined by means of the composition operator @:

c := a@b: c(x)
a(b(x))
The iteration operator @@ denotes iterated composition of a function with itself:

f := g@@4: f(x)
g(g(g(g(x))))
Some system functions, such as definite integration via int or the $ operator,
require a range. You generate a range by means of the operator ..:
range := 0..1; int(x, x = range)
0..1
1
2
Ranges should not be confused with floating-point intervals of domain type

DOM_INTERVAL, which may be created via the operator ... or the function hull:
PI ... 20/3, hull(PI, 20/3)

3.141592653 . . . 6.666666667, 3.141592653 . . . 6.666666667
This data type is explained in Section 4.18.

MuPAD treats any expression of the form identifier(argument) as a function
call:
delete f:
expression := sin(x) + f(x, y) + int(g(x), x = 0..1)
Z 1
sin(x) + f (x, y) + g(x) dx
0
Table 4.3 lists all operators presented above together with their equivalent
functional form. You may use either form to input expressions:
2/14 = _divide(2, 14);
1 1
=
7 7
4-15
4 MuPAD® Objects
✞ ☎
system
operator function meaning example
+ _plus addition SUM:= a + b
- _subtract
subtraction Difference:= a - b
* _mult multiplication Product:= a * b
/ _dividedivision Quotient:= a/b
^ _power exponentiation Power:= a^b
div _div quotient Quotient:= a div p
modulo p
mod _mod remainder Remainder:= a mod p
modulo p
! fact factorial n!
$ _seqgen sequence Sequence:= i^2 $ i = 3..5
generation
, _exprseq sequence Seq:= Seq1, Seq2
concatenation
union _union set union S:= Set1 union Set2
intersect _intersect set intersection S:= Set1 intersect Set2
minus _minus set difference S:= Set1 minus Set2
= _equal equation Equation:= x+y = 2
<> _unequal inequality Condition:= x <> y
< _less comparison Condition:= a < b
> comparison Condition:= a > b
<= _leequal comparison Condition:= a <= b
>= comparison Condition:= a >= b
not _not negation Condition2:= not Condition1
and _and logical ‘and’ Condition:= a < b and b < c
or _or logical ‘or’ Condition:= a < b or b < c
-> mapping Square:= x -> x^2
' D differential f'(x)
operator
@ _fconcat composition h:= f @ g
@@ _fnest iteration g:= f @@ 3
. _concat concatenation NewName:= Name1.Name2
.. _range range Range:= a..b
... interval interval IV:= 2.1 ... 3.5
name() function call sin(1), f(x), reset()
✝ ✆
Table 4.3: The main operators for generating MuPAD® expressions
4-16
[i $ i = 3..5] = [_seqgen(i, i, 3..5)];

[3, 4, 5] = [3, 4, 5]
a < b = _less(a, b);

(a < b) = (a < b)
(f@g)(x) = _fconcat(f, g)(x)

f (g(x)) = f (g(x))
We remark that some of the system functions such as _plus, _mult, _union, or
_concat accept arbitrarily many arguments, while the corresponding operators
are only binary:
_plus(a, b, u, v), _concat(a, b, u, v), _union()
a + b + u + v, abuv, ∅
It is often useful to know and to use the functional form of the operators. For
example, it is very efficient to form longer sums by applying _plus to many
arguments. You may generate the argument sequence quickly by means of the
sequence generator $:
_plus(1/i! $ i = 0..100): float(%)
2.718281828
The function map is a useful tool. It applies a function to all operands of a MuPAD
object. For example:
_plus(1/i! $ i = 0..100): float(%)
[function (x1, y, z) , function (x2, y, z) , function (x3, y, z)]
If you want to apply operators via map, use their functional equivalent:
map([x1, x2, x3], _power, 5), map([f, g], _fnest, 5)
5
x1 , x25 , x35 , [f ◦ f ◦ f ◦ f ◦ f, g ◦ g ◦ g ◦ g ◦ g]
For the most common operators, namely +, -, *, /, ^, =, <>, <, >, <=, >=, ==>, and
<=>, the corresponding functions can be accessed in the form `+`, `-`, `*` etc.:
4-17
4 MuPAD® Objects
map([1, 2, 3, 4], `*`, 3), map([1, 2, 3, 4], `^`, 2)

[3, 6, 9, 12] , [1, 4, 9, 16]
Note that `-` is negation, not subtraction.

Some operations are invalid because they do not make sense mathematically:
3 and x
Error: Illegal operand [_and]
The system function _and recognizes that the argument 3 cannot represent a
Boolean value and issues an error message. However, MuPAD accepts a symbolic
expression such as a and b with symbolic identifiers a, b. As soon as a and b get
Boolean values, the expression can be evaluated to a Boolean value as well:
c := a and b: a := TRUE: b := TRUE: c
TRUE
The operators have different priorities, for example:

✞ ☎
a.fact(3) means a.(fact(3)) and returns a6,
a.6^2 means (a.6)^2 and returns a6^2,
a * b^c means a * (b^c),
a+b*c means a + (b * c),
a + b mod c means (a + b) mod c,
a = b mod c means a = (b mod c),
a, b $ 3 means a, (b $ 3) and returns a, b, b, b.
✝ ✆
If we denote the relation “is of lower priority than” by ≺, then we have:
, ≺ $ ≺ = ≺ mod ≺ + ≺ ∗ ≺ ^ ≺ . ≺ function call.
You find a complete list of the operators and their priorities in Section “Operators”
of the MuPAD Quick Reference. Parentheses can always be used to enforce an
evaluation order that differs from the standard priority of the operators:
1 + 1 mod 2, 1 + (1 mod 2)
0, 2
4-18
i := 2: x.i^2, x.(i^2)
x22 , x4
u, v $ 3; (u, v) $ 3
u, v, v, v
u, v, u, v, u, v
Expression Trees
A useful model for representing a MuPAD® expression is the expression tree. It

reflects the internal representation. The operators or their corresponding
functions, respectively, are the vertices, and the arguments are subtrees. The
operator of lowest priority is at the root. Here are some examples:
a + b * c + d * e *sin(f)^g
a * *
b c
d e ^
sin g
f
int(exp(x^4), x = 0..1)
int
exp =
^ x ..
x 4 0 1
4-19
4 MuPAD® Objects
The difference a - b is internally represented as a + b * (-1):

+
a *
b -1
Similarly, a quotient a/b has the internal representation a * b^(-1):

*
a ^
b -1
The leaves of an expression tree are MuPAD atoms.

The function prog::exprtree allows to display expression trees. Operators are
replaced by the names of the corresponding system functions:
prog::exprtree(a/b):
_mult
|
+-- a
|
`-- _power
|
+-- b
|
`-- -1
Exercise 4.8: Sketch the expression tree of a^b - sin(a/b).
Exercise 4.9: Determine the operands of 2/3, x/3, 1 + 2*I, and x + 2*I. Explain
the differences that you observe.
4-20
Operands
You can decompose expressions systematically by means of the operand functions

op and nops, which were already presented in Section 4.1. The operands of an
expression correspond to the subtrees below the root in the expression tree.
expression := a + b + c + sin(x): nops(expression)
4
op(expression)
a, b, c, sin(x)
Additionally, expressions of domain type DOM_EXPR have a “0th operand,” which is

accessible via op(·,0). It corresponds to the root of the expression tree and tells
you which function is used to build the expression:
op(a + b*c, 0), op(a*b^c, 0), op(a^(b*c), 0),
op(f(sin(x)),0)
_plus, _mult, _power, f
sequence := a, b, c: op(sequence, 0)
_exprseq
If the expression is a symbolic function call, op(·, 0) returns the identifier of that
function:
op(sin(1), 0), op(f(x), 0), op(diff(y(x), x), 0),
op(int(exp(x^4), x), 0)
sin, f, diff, int
You may regard the 0th operand of an expression as a “mathematical type.” For
example, an algorithm for differentiation of arbitrary expressions must find out
whether the expression is a sum, a product, or a function call. To this end, it may
look at the 0th operand to decide whether linearity, the product rule, or the chain
rule of differentiation applies.
4-21
4 MuPAD® Objects
As an example, we decompose the expression

expression := a + b + sin(x) + c^2:
with the expression tree

+
a b sin ^
x c 2
systematically by means of the op function:

op(expression, 0..nops(expression))
_plus, a, b, sin(x) , c2
We can put these expressions together again in the following form:

root := op(expression, 0): operands := op(expression):
root(operands)
c2 + a + b + sin(x)
Note that the output order visible on the screen is different from the internal
order accessible by op. You can access the building blocks of an expression in
output order with the index operator [ ], as in the following:
expression[1], expression[4]
c2 , sin(x)
In the following example, we decompose an expression completely into its atoms

(compare with Section 4.1):
expression := sin(x + cos(a*b)):
4-22
The operands and subexpressions are:

✞ ☎
op(expression, 0) : sin
op(expression, 1) : x+cos(a*b)
op(expression, [1, 0]) : _plus
op(expression, [1, 1]) : x
op(expression, [1, 2]) : cos(a*b)
op(expression, [1, 2, 0]) : cos
op(expression, [1, 2, 1]) : a*b
op(expression, [1, 2, 1, 0]) : _mult
op(expression, [1, 2, 1, 1]) : a
op(expression, [1, 2, 1, 2]) : b
✝ ✆
Exercise 4.10: Sketch the expression tree of the following Boolean expression:
condition := (not a) and (b or c):
How can you use op to pick the symbolic identifiers a, b, and c out of the object
condition?
4-23
4 MuPAD® Objects
Sequences
Sequences form an important MuPAD® data structure. Lists and sets are built
from sequences. As discussed in Section 4.4, a sequence is a series of MuPAD
objects separated by commas.
sequence1 := a, b, c; sequence2 := c, d, e
a, b, c
c, d, e
You may also use the comma to concatenate sequences:

sequence3 := sequence1, sequence2
a, b, c, c, d, e
Sequences are MuPAD expressions of domain type DOM_EXPR.

If m and n are integers, the call object(i) $ i = m..n generates the sequence
object(m), object(m + 1), . . . , object(n) :
i^2 $ i = 2..7, xî $ i = 1..5

4, 9, 16, 25, 36, 49, x, x2 , x3 , x4 , x5
The operator $ is called the sequence generator. The equivalent functional form is
_seqgen(object(i), i, m..n)
_seqgen(i^2, i, 2..7), _seqgen(xî, i, 1..5)

4, 9, 16, 25, 36, 49, x, x2 , x3 , x4 , x5
Usually, you will prefer the operator notation. The functional form is useful in
connection with map, zip or similar functions.
You may use $ in the following way to generate a sequence of successive integers:
$ 23..30
23, 24, 25, 26, 27, 28, 29, 30
4-24
Sequences
The command object $ n returns a sequence of n identical objects:

x^2 $ 10
x2 , x2 , x2 , x2 , x2 , x2 , x2 , x2 , x2 , x2
You can also use the sequence generator in connection with the keyword in. (The
functional equivalent in this case in _seqin.) The loop variable then runs through
all operands of the stated object:
f(x) $ x in [a, b, c, d]
f (a) , f (b) , f (c) , f (d)
f(x) $ x in a + b + c + d + sin(sqrt(2))
√
f (a) , f (b) , f (c) , f (d) , f sin 2
It may be tempting to abuse the $ operator for loops, as in these commands:

(x.i := sin(i); y.i := x.i) $ i=1..4:
For readability, memory consumption and therefore speed, we recommend

against this usage. The assignments above should use a loop instead (cf.
Chapter 15):
x.i := sin(i);
y.i := x.i;
end_for:
As a simple application of sequences, we now consider the MuPAD differentiator

diff. The call diff(f(x), x) returns the derivative of f with respect to x. Higher
derivatives are given by diff(f(x), x, x), diff(f(x), x, x, x) etc. Thus, the
10-th derivative of f (x) = sin(x2 ) can be computed conveniently by means of the
sequence generator:
diff(sin(x^2), x $ 10)
2 4 2
30240 cos(x ) - 403200 x cos(x ) +
8 2 2 2
23040 x cos(x ) - 302400 x sin(x ) +
6 2 10 2
161280 x sin(x ) - 1024 x sin(x )
4-25
4 MuPAD® Objects
The “void” object (Section 4.19) may be regarded as an empty sequence. You may
generate it by calling null() or _exprseq(). The system automatically eliminates
this object from sequences:
Seq := null(): Seq := Seq, a, b, null(), c
a, b, c
Some system functions such as the print command for screen output
(Section 12.1) return the null() object:
sequence := a, b, print(Hello), c
Hello
a, b, c
You can access the i-th entry of a sequence by sequence[i]. Redefinitions of the
form sequence[i]:= newvalue are also possible:
F := a, b, c: F[2]
b
F[2] := newvalue: F
a, newvalue, c
Alternatively, you may use the operand function op (Section 4.1) to access
subsequences:5
F := a, b, c, d, e: op(F, 2); op(F, 2..4)
b
b, c, d
5 Note that, in this example, the identifier F of the sequence is provided as argument to op. The op
function regards a direct call of the form op(a, b, c, d, e, 2) as an (invalid) call with six arguments and
issues an error message. You may use parentheses to avoid this error: op((a, b, c, d, e), 2).
4-26
Sequences
You may use delete to delete entries from a sequence, thus shortening the
sequence:
F; delete F[2]: F; delete F[3]: F
a, b, c, d, e
a, c, d, e
a, c, e
The main usage of MuPAD sequences is the generation of lists and sets and
supplying arguments to function calls. For example, the functions max and min
can compute the maximum and minimum, respectively, of arbitrarily many
arguments:
Seq := 1, 2, -1, 3, 0: max(Seq), min(Seq)
3, −1
Exercise 4.11: Assign the values x1 = 1, x2 = 2, . . . , x100 = 100 to the identifiers

x1 , x2 , . . . , x100 .
Exercise 4.12: Generate the sequence
x1 , x2 , x2 , x3 , x3 , x3 , . . . , x10 , x10 , . . . , x10 .

| {z } | {z } | {z }
2 3 10
Exercise 4.13: Use a simple command to generate the double sum
X
10 X
i
1
.
i=1 j=1
i+j
Hint: the function _plus accepts arbitrarily many arguments. Generate a suitable
argument sequence.
4-27
4 MuPAD® Objects
Lists
A list is an ordered sequence of arbitrary MuPAD® objects enclosed in square
brackets:
list := [a, 5, sin(x)^2 + 4, [a, b, c], hello,
3/4, 3.9087]

2 3
a, 5, sin(x) + 4, [a, b, c] , hello, , 3.9087
4
A list may contain lists as elements. It may also be empty:

list := []
[]
The possibility to generate sequences via $ is helpful for constructing lists:

sequence := i $ i = 1..10: list := [sequence]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list := [xî $ i = 0..12]

1, x, x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12
A list may occur on the left hand side of an assignment. This may be used to
assign values to several identifiers simultaneously:
[A, B, C] := [a, b, c]: A + B^C
a + bc
A useful property of this construction is that all the assignments are performed at
the same time, so you can swap values:
a := 1: b:= 2: a, b
1, 2
[a, b] := [b, a]: a, b
2, 1
4-28
Lists
The function nops returns the number of elements of a list. You can access the
elements of a list by means of indexed access: list[i] returns the i-th list
element, and list[i..j] returns the sub-list starting at the i-th and extending up
to and including the j -th element. Negative values for i and j are counted from
the end:
list := [a, b, c, d, e, f]: list[1], list[3..-2]
2, [c, d, e]
As with almost any MuPAD object, you can also access the elements of a list with
the op function: op(list) returns the sequence of elements, i.e., the sequence
that has been used to construct the list by enclosing it in square brackets [ ]. The
call op(list, i) returns the i-th list element, and op(list, i..j) extracts the
sequence of the i-th up to the j -th list element:
delete a, b, c: list := [a, b, sin(x), c]: op(list)
a, b, sin(x) , c
op(list, 2..3)
b, sin(x)
You may change a list element by an indexed assignment:

list := [a, b, c]: list[1] := newvalue: list
[newvalue, b, c]
Writing to a sublist may change the length of the list:

list[2..3] := [d,e,f,g]: list
[newvalue, d, e, f, g]
Alternatively, the command subsop(list, i = newvalue) (Chapter 6) returns a

copy with the i-th operand redefined:
list := [a, b, c]: list2 := subsop(list, 1 = newvalue)
[newvalue, b, c]
4-29
4 MuPAD® Objects
Caution: If L is an identifier without a value, then the indexed assignment

L[index] := value:
generates a table (Section 4.8) and not a list:

delete L: L[1] := a: L
1 a
You can remove elements from a list by using delete. This shortens the list:
list := [a, b, c]: delete list[1]: list
[b, c]
The function contains checks whether a MuPAD object belongs to a list. It

returns the index of (the first occurrence of) the element in the list. If the list does
not contain the element, then contains returns the integer 0:
contains([x + 1, a, x + 1], x + 1)
1
contains([sin(a), b, c], a)
0
The function append adds elements to the tail of a list:

list := [a, b, c]: append(list, 3, 4, 5)
[a, b, c, 3, 4, 5]
The dot operator . concatenates lists:

list1 := [1, 2, 3]: list2 := [4, 5, 6]:
list1.list2, list2.list1
[1, 2, 3, 4, 5, 6] , [4, 5, 6, 1, 2, 3]
The corresponding system function is _concat and accepts arbitrarily many

arguments. You can use it to combine many lists:
_concat(list1 $ 5)
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
4-30
Lists
A list can be sorted by means of the function sort. This arranges numerical values
according to their magnitude, strings (Section 4.11) are sorted lexicographically:
sort([-1.23, 4, 3, 2, 1/2])

1
−1.23, , 2, 3, 4
2
sort(["A", "b", "a", "c", "C", "c", "B", "a1", "abc"])

[”A”, ”B”, ”C”, ”a”, ”a1”, ”abc”, ”b”, ”c”, ”c”]
sort(["x10002", "x10011", "x10003"])

[”x10002”, ”x10003”, ”x10011”]
Note that the lexicographical order only applies to strings generated with ".
Names of identifiers are sorted according to different (internal) rules, which only
reduce to lexicographic order for short identifiers (and may change in future
releases):
delete A, B, C, a, b, c, a1, abc:
sort([A, b, a, c, C, c, B, a1, abc])
[A, B, C, a, a1, abc, b, c, c]
sort([x10002, x10011, x10003])

[x10002, x10011, x10003]
MuPAD regards lists of function names as list-valued functions:

[sin, cos, f](x)
[sin(x) , cos(x) , f (x)]
The function map applies a function to all elements of a list:

map([x, 1, 0, PI, 0.3], sin)
[sin(x) , sin(1) , 0, 0, 0.2955202067]
4-31
4 MuPAD® Objects
If the function has more than one argument, then map substitutes the list elements
for the first argument and takes the remaining arguments from its own argument
list:
map([a, b, c], f, y, z)
[f (a, y, z) , f (b, y, z) , f (c, y, z)]
This map construction is a powerful tool for handling lists as well as other MuPAD
objects. In the following example, we have a nested list L. We want to extract the
first elements of the sublists using op(·, 1). This is easily done using map:
L := [[a1, b1], [a2, b2], [a3, b3]]: map(L, op, 1)
[a1, a2, a3]
The MuPAD function select enables you to extract elements with a certain
property from a list. To this end, you need a function that checks whether an
object has this property and returns TRUE or FALSE. For example, the call
has(object1, object2) returns TRUE if object2 is an operand or suboperand of
object1, and FALSE otherwise:
has(1 + sin(1 + x), x), has(1 + sin(1 + x), y)

TRUE, FALSE
Now,
select([a + 2, x, y, z, sin(a)], has, a)
[a + 2, sin(a)]
extracts all those list elements for which has(·,a) returns TRUE, i.e., those which
contain the identifier a.
The function split divides a list into three lists, as follows. The first list contains
all elements with a certain property, the second list collects all those elements
without the property. If the test for the property returns the value UNKNOWN for
some elements, then these are put into the third list. Otherwise, the third list is
empty:
split([sin(x), x^2, y, 11], has, x)

sin(x) , x2 , [y, 11] , []
4-32
Lists
The MuPAD function zip combines elements of two lists pairwise into a new list:
L1 := [a, b, c]: L2 := [d, e, f]:
zip(L1, L2, _plus), zip(L1, L2, _mult),
zip(L1, L2, _power)

[a + d, b + e, c + f ] , [a d, b e, c f ] , ad , be , cf
The third argument of zip must be a function that takes two arguments. This
function is then applied to the pairs of list elements. In the above example, we
have used the MuPAD functions _plus, _mult, and _power for addition,
multiplication, and exponentiation, respectively. If the two input lists have
different lengths, then the behavior of zip depends on the optional fourth
argument. If this is not present, then the length of the resulting list is the
minimum of the lengths of the two input lists. Otherwise, if you supply an
additional fourth argument, then zip replaces the “missing” list entries by this
argument:
L1 := [a, b, c, 1, 2]: L2 := [d, e, f]:
zip(L1, L2, _plus)
[a + d, b + e, c + f ]
zip(L1, L2, _plus, hello)

[a + d, b + e, c + f, hello + 1, hello + 2]
Table 4.4 gives a summary of all list operations that we have discussed.
Exercise 4.14: Generate two lists with the elements a, b, c, d and 1, 2, 3, 4,

respectively. Concatenate the lists. Multiply the lists pairwise.
Exercise 4.15: Multiply all entries of the list [1, x, 2] by 2. Suppose you are
given a list, whose elements are lists of numbers or expressions, such as
[[1, x, 2], [PI], [2/3, 1]], how can you multiply all entries by 2?
4-33
4 MuPAD® Objects
✞ ☎
. or _concat : concatenating lists
append : appending elements
contains(list, x) : does list contain the element x?
list[i] : accessing the i-th element
map : applying a function
nops : length
op : accessing elements
select : select according to properties
sort : sorting
split : split according to properties
subsop : replacing elements
delete : deleting elements
zip : combining two lists
✝ ✆
Table 4.4: MuPAD® functions and operators for lists
Exercise 4.16: Let X = [x1 , . . . , xn ] and Y = [y1 , . . . , yn ] be two lists of the same
length. Find a simple method to compute
• their “inner product” (X as row vector and Y as column vector)
x1 y1 + · · · + xn yn ,
• their “matrix product” (X as column vector and Y as row vector)
[ [x1 y1 , x1 y2 , . . . , x1 yn ], [x2 y1 , x2 y2 , . . . , x2 yn ],
. . . , [xn y1 , xn y2 , . . . , xn yn ]] .
You can achieve this by using zip, _plus, map and appropriate functions
(Section 4.12) within a single command line in each case. Loops (Chapter 15) are
not required.
Exercise 4.17: In number theory, one is often interested in the density of prime
numbers in sequences of the form f (1), f (2), . . . , where f is a polynomial. For
each value of m = 0, 1, . . . , 41, find out how many of the integers n2 + n + m with
n = 1, 2, . . . , 100 are primes.
4-34
Lists
Exercise 4.18: In which ordering will n children be selected for “removal” by a

counting-out rhyme composed of m words? For example, using the rhyme
“eenie–meenie–miney–moe–catch a–tiger–by the–toe”
with 8 “words,” 12 children are counted out in the order

8–4–1–11–10–12–3–7–6–2–9–5. Hint: represent the children by a list [1, 2, …]
and remove an element from this list after it is counted out.
4-35
4 MuPAD® Objects
Sets
A set is an unordered sequence of arbitrary objects enclosed in curly braces. Sets
are of domain type DOM_SET:
{34, 1, 89, x, -9, 8}
{−9, 1, 8, 34, 89, x}
The order of the elements in a MuPAD® list seems to be random. The MuPAD
kernel sorts the elements according to internal principles. You should use sets
only if the order of the elements does not matter. If you want to process a sequence
of expressions in a certain order, use lists as discussed in the previous section.
Sets may be empty:
emptyset := {}
∅
A set contains each element only once, i.e., duplicate elements are removed
automatically:
set := {a, 1, 2, 3, 4, a, b, 1, 2, a}
{1, 2, 3, 4, a, b}
The function nops determines the number of elements in a set. As for sequences
and lists, op extracts elements from a set:
op(set)
a, 1, 2, 3, 4, b
op(set, 2..4)
1, 2, 3
Warning: Since elements of a set may be reordered internally, you should check
carefully whether it makes sense to access the i-th element. For example,
subsop(set, i = newvalue) (Section 6) replaces the i-th element by a new value.
However, you should check in advance (using op) that the element that you want
to replace really is the i-th element. Especially note that replacing an element of a
set often reorders other entries.
4-36
Sets
The command op(set, i) returns the i-th element of set in the internal order,
which usually is different from the i-th element of set that you see on the screen.
However, you can access elements by using set[i], where the returned elements
is the i-th element as printed on the screen.
The functions union, intersect, and minus form the union, the intersection, and
the set-theoretic difference, respectively, of sets:
M1 := {1, 2, 3, a, b}: M2 := {a, b, c, 4, 5}:
M1 union M2, M1 intersect M2, M1 minus M2, M2 minus M1
{1, 2, 3, 4, 5, a, b, c} , {a, b} , {1, 2, 3} , {4, 5, c}
In particular, you can use minus to remove elements from a set:

{1, 2, 3, a, b} minus {3, a}
{1, 2, b}
You can also replace an element by a new value without caring about the order of
the elements:
set := {a, b, oldvalue, c, d}
{a, b, c, d, oldvalue}
set minus {oldvalue} union {newvalue}

{a, b, c, d, newvalue}
The function contains checks whether an element belongs to a set, and returns
either TRUE or FALSE:6
contains({a, b, c}, a), contains({a, b, c + d}, c)
TRUE, FALSE
MuPAD regards sets of function names as set-valued functions:

{sin, cos, f}(x)
{cos(x) , f (x) , sin(x)}
6 Note the difference to the behavior of contains for lists: there the ordering of the elements is
determined when you generate the list, and contains returns the position of the element in the list.
4-37
4 MuPAD® Objects
✞ ☎
contains(M, x) : does M contain the element x?
intersect : intersection
map : applying a function
minus : set-theoretic difference
nops : number of elements
op : accessing elements
select : select according to properties
split : split according to properties
subsop : replacing elements
union : set-theoretic union
✝ ✆
Table 4.5: MuPAD® functions and operators for sets
You can apply a function to all elements of a set by means of map:

map({x, 1, 0, PI, 0.3}, sin)
{0, 0.2955202067, sin(1) , sin(x)}
You can use the function select to extract elements with a certain property from
a set. This works as for lists, but the returned object is a set:
select({{a, x, b}, {a}, {x, 1}}, contains, x)
{{1, x} , {a, b, x}}
Similarly, you can use the function split to divide a set into three subsets of
elements with a certain property, elements without that property, and elements
for which the system cannot decide this and returns UNKNOWN. The result is a list
comprising these three sets:
split({{a, x, b}, {a}, {x, 1}}, contains, x)
[{{1, x} , {a, b, x}} , {{a}} , ∅]
Table 4.5 contains a summary of the set operations discussed so far.

MuPAD also provides the data structure Dom::ImageSet for handling infinite sets;
see page 8-9 in Chapter 8.
Exercise 4.19: How can you convert a list to a set and vice versa?
4-38
Sets
Exercise 4.20: Generate the sets A = {a, b, c}, B = {b, c, d}, and C = {b, c, e}.
Compute the union and the intersection of the three sets, as well as the difference
A \ (B ∪ C).
Exercise 4.21: Instead of the binary operators intersect and union, you can
also use the corresponding MuPAD functions _intersect and _union to compute
unions and intersections of sets. These functions accept arbitrarily many
arguments. Use simple commands to compute the union and the intersection of
all sets belonging to M:
M := {{2, 3}, {3, 4}, {3, 7}, {5, 3}, {1, 2, 3, 4}}:
4-39
4 MuPAD® Objects
Tables
A table is a MuPAD® object of domain type DOM_TABLE. It is a collection of
equations of the form index = value. Both indices and values may be arbitrary
MuPAD objects. You can generate a table by using the system function table
(“explicit generation”):
T := table(a = b, c = d)
a b
c d
You can generate more entries or change existing ones by “indexed assignments”
of the form Table[index]:= value:
T[f(x)] := sin(x): T[1, 2] := 5:
T[1, 2, 3] := {a, b, c}: T[a] := B:
T
a B
c d
f (x) sin(x)
1, 2 5
1, 2, 3 {a, b, c}
It is not necessary to initialize a table via table. If T is an identifier that does not
have a value, or has a value which does not allow indexed access (such as an
integer or a function), then an indexed assignment of the form T[index]:= value
automatically turns T into a table (“implicit generation”):
delete T: T[a] := b: T[b] := c: T
a b
b c
4-40
Tables
A table may be empty:

T := table()
You may delete table entries via delete Table[index]:

T := table(a = b, c = d, d = a*c):
delete T[a], T[c]: T
d ac
You can access table entries in the form Table[index]; this returns the element
corresponding to the index. If there is no entry for the index, then MuPAD returns
Table[index] symbolically:
T := table(a = b, c = d, d = a*c):
T[a], T[b], T[c], T[d]
b, Tb , d, a c
The call op(Table) returns all entries of a table, i.e., the sequence of all equations
index = value:
op(table(a = A, b = B, c = C, d = D))
a = A, b = B, c = C, d = D
Note that the internal order of the table entries may differ both from the order in
which you have generated the table and from the order of entries printed on the
screen. It may look quite random:
op(table(a.i = i^2 $ i = 1..17))
a16 = 256, a9 = 81, a12 = 144, a6 = 36, a3 = 9,
a15 = 225, a11 = 121, a8 = 64, a5 = 25, a2 = 4,
a14 = 196, a10 = 100, a17 = 289, a7 = 49, a4 = 16,
a13 = 169, a1 = 1
4-41
4 MuPAD® Objects
The function map applies a given function to the values (not the indices) of all
table entries:
T := table(1 = PI, 2 = 4, 3 = exp(1)): map(T, float)
1 3.141592654
2 4.0
3 2.718281828
The function contains checks whether a table contains a particular index. It

ignores the values:
T := table(a = b): contains(T, a), contains(T, b)
TRUE, FALSE
You may employ the functions select and split to inspect both indices and
values of a table and to extract them according to certain properties. This works
similarly as for lists (Section 4.6) and for sets (Section 4.7):
T := table(1 = "number", 1.0 = "number", x = "symbol"):
select(T, has, "symbol")
x ”symbol”
select(T, has, 1.0)
1.0 ”number”
split(T, has, "number")

" #
1 ”number”
, x ”symbol” ,
1.0 ”number”
Tables are particularly well suited for storing large amounts of data. Indexed
accesses to individual elements are implemented efficiently also for big tables:
a write or read does not file through the whole data structure.
4-42
Tables
Exercise 4.22: Generate a table telephoneDirectory with the following entries:
Ford 1815, Reagan 4711, Bush 1234, Clinton 5678.
Look up Ford’s number. How can you find out whose number is 5678?
Exercise 4.23: Given a table, how can you generate a list of all indices and a list
of all values, respectively?
Exercise 4.24: Generate the table table(1 = 1, 2 = 2, …, n = n) and the list

[1, 2, …, n] of length n = 100000. Add a new entry to the table and to the list.
How long does this take? Hint: the call time((a:= b)) returns the execution time
for an assignment.
4-43
4 MuPAD® Objects
Arrays
Arrays, of domain type DOM_ARRAY, may be regarded as special tables. You may
think of them as a collection of equations of the form index = value, but in
contrast to tables, the indices must be integers. A one-dimensional array consists
of equations of the form i = value. Mathematically, it represents a vector whose
i-th component is value. A two-dimensional array represents a matrix, whose
(i, j)-th component is stored in the form (i, j) = value. You may generate arrays
of arbitrary dimension, with entries of the form (i, j, k, …) = value.
The system function array generates arrays. In its simplest form, you only specify
a sequence of ranges that determine the dimension and the size of the array:
A := array(0..1, 1..3)
+- -+
| ?[0, 1], ?[0, 2], ?[0, 3] |
| |
| ?[1, 1], ?[1, 2], ?[1, 3] |
+- -+
You can see here that the first range 0..1 and the second range 1..3 determine
the array’s number of rows and columns, respectively. The output ?[0, 1] signals
that the corresponding index has not been assigned a value, yet. Thus, the above
command has generated an empty array. Now, you can assign values to the
indices:
A[0, 1] := 1: A[0, 2] := 2: A[0, 3] := 3:
A[1, 3] := HELLO: A
!
1 2 3
A1,1 A1,2 HELLO
You can also initialize the complete array directly when generating it by array.
Just supply the values as a (nested) list:
A := array(1..2, 1..3, [[1, 2, 3], [4, 5, 6]])
!
1 2 3
4 5 6
4-44
Arrays
You can access and modify array elements in the same way as table elements:
A[2, 3] := A[2, 3] + 10: A
!
1 2 3
4 5 16
Again, you may delete an array element by using delete:

delete A[1, 1], A[2, 3]: A, A[2, 3]
!
A1,1 2 3
, A2,3
4 5 A2,3
Arrays possess a “0-th operand” op(Array, 0) providing information on the

dimension and the size of the array. The call op(Array, 0) returns a sequence d,
a1 .. b1 , . . . , ad .. bd , where d is the dimension (i.e., the number of indices) and ai .. bi
is the valid range for the i-th index:
Vec := array(1..3, [x, y, z]): op(Vec, 0)
1, 1..3
Mat := array(1..2, 1..3, [[a, b, c], [d, e, f]]):
op(Mat, 0)
2, 1..2, 1..3
Thus, the dimension of an m × n matrix array(1..m, 1..n) may be obtained as
m = op(Mat, [0, 2, 2]), n = op(Mat, [0, 3, 2]).
The internal structure of arrays differs from the structure of tables. The entries
are not stored in the form of equations:
op(Mat)
a, b, c, d, e, f
4-45
4 MuPAD® Objects
The table type is more flexible than the array type: tables admit arbitrary indices,
and their size may grow dynamically. Arrays are intended for storing vectors and
matrices of a fixed size. When you enter an indexed call, the system checks
whether the indices are within the specified ranges. For example:
Mat[4, 7]
Error: Illegal argument [array]
You may apply a function to all array components via map. For example, here is
the simplest way to convert all array entries to floating-point numbers:
A := array(1..2, [PI, 1/7]): map(A, float)

3.141592654 0.1428571429
Warning: If M is an identifier without a value, then an indexed assignment of the

form M[index, index, ...]:= value generates a table and not an array of type
DOM_ARRAY (Section 4.8):
M[1, 1] := a: M
1, 1 a
Additionally, MuPAD provides the more powerful data structures of domain type
Dom::Matrix for handling vectors and matrices. These are discussed in
Section 4.15. Such objects are very convenient to use: you can multiply two
matrices or a matrix and a vector by means of the usual multiplication symbol *.
Similarly, you can add matrices of equal dimension via +. To achieve the same
functionality with arrays, you have to write your own procedures. We refer to the
examples MatrixProduct and MatrixMult in Sections 17.4 and 17.5, respectively.
Exercise 4.25: Generate a so-called Hilbert matrix H of dimension 20 × 20 with

entries Hij = 1/(i + j − 1).
4-46
Boolean Expressions
Boolean Expressions
MuPAD® implements three logical (“Boolean”) values: TRUE, FALSE, and UNKNOWN:
domtype(TRUE), domtype(FALSE), domtype(UNKNOWN)
DOM_BOOL, DOM_BOOL, DOM_BOOL
The operators and, or, and not operate on Boolean values:

TRUE and FALSE, not (TRUE or FALSE), TRUE and UNKNOWN,
TRUE or UNKNOWN
FALSE, FALSE, UNKNOWN, TRUE
The functions corresponding to these operators are _and, _or, and _not,
respectively.
The function bool evaluates equations, inequalities, or comparisons via >, >=, < ,
<=, to TRUE or FALSE:
bool(1 = 2), bool(1 <> 2),

bool(1 <= 2) or not bool(1 > 2)
FALSE, TRUE, TRUE
Note that bool can only compare real numbers sufficiently distinct from one
another. Especially exact symbolic representations of the same number cannot be
compared with bool:
bool(3 <= PI)
TRUE
bool(sqrt(2)*sqrt(3) <= sqrt(6))
Error: Can't evaluate to boolean [_leequal]
bool(14885392687/4738167652 <= PI)
Error: Can't evaluate to boolean [_leequal]
Typically, you will use Boolean constructs in branching conditions of if

instructions (Chapter 16) or in termination conditions of repeat loops (Chapter
15). In the following example, we test the integers 1, 2, 3 for primality. The system
function isprime (“is the argument a prime number?”) returns TRUE or FALSE. The
repeat loop stops as soon as the termination condition i = 3 evaluates to TRUE:
4-47
4 MuPAD® Objects
i := 0:
repeat
i := i + 1;
if isprime(i)
then print(i, "is a prime")
else print(i, "is no prime")
end_if
until i = 3 end_repeat
1, "is no prime"
2, "is a prime"
3, "is a prime"
Here we have used strings enclosed in " for the screen output. They are discussed
in detail in Section 4.11. Note that it is not necessary to use the function bool in
branching or termination conditions in order to evaluate the condition to TRUE or
FALSE.
Exercise 4.26: Let ∧ denote the logical “and,” let ∨ denote the logical “or,” let ¬
denote logical negation. To which Boolean value does
TRUE ∧ (FALSE ∨ ¬ (FALSE ∨ ¬ FALSE))
evaluate?
Exercise 4.27: Let L1, L2 be two MuPAD lists of equal length. How can you find
out whether L1[i] < L2[i] holds true for all list elements?
4-48
Strings
Strings
Strings are pieces of text, which may be used for formatted screen output. A string
is a sequence of arbitrary symbols enclosed in “string delimiters” ". Its domain
type is DOM_STRING.
string1 := "Use * for multiplication";
string2 := ", ";
string3 := "use ^ for exponentiation."
”Use * for multiplication”
”, ”
”use ˆ for exponentiation.”
The concatenation operator . combines strings:

string4 := string1.string2.string3
”Use * for multiplication, use ˆ for exponentiation.”
The dot operator is a short form of the MuPAD® function _concat, which
concatenates (arbitrarily many) strings:
_concat("This is ", "a string", ".")
”This is a string.”
The index operator [ ] extracts the characters from a string:

string4[1], string4[2], string4[3],
string4[4], string4[5]
”U”, ”s”, ”e”, ” ”, ”*”
When using a range as index, substrings are returned; negative indices count from
the end of the string:
string4[19..21], string4[-15..-8]
”cat”, ”exponent”
You may use the command print to output intermediate results in loops or
procedures on the screen (Section 12.1). By default, this function prints strings
4-49
4 MuPAD® Objects
with the enclosing double quotes. You may change this behavior by using the
option Unquoted:
print(string4)
"Use * for multiplication, use ^ for exponentiation."
print(Unquoted, string4)
Use * for multiplication, use ^ for exponentiation.
Strings are not valid identifiers in MuPAD, so you cannot assign values to them:
"name" := sin(x)
Error: Invalid left-hand side in assignment [line 1, col 8]
Also, arithmetic with strings is not allowed:

1 + "x"
Error: Illegal operand [_plus]
However, you may use strings in equations:

"derivative of sin(x)" = cos(x)
”derivative of sin(x)” = cos(x)
The function expr2text converts a MuPAD object to a string. You can employ this
function to customize print commands:
i := 7:
print(Unquoted, expr2text(i)." is a prime.")
7 is a prime.
a := sin(x):
print(Unquoted, "The derivative of " . expr2text(a) .
" is " . expr2text(diff(a, x)). ".")
The derivative of sin(x) is cos(x).
The documentation of print contains more advanced examples of user-defined

output, see ?print.
You find numerous other useful functions for handling strings in the standard
library (Section “Manipulation of Strings” of the MuPAD Quick Reference) and in
the string library (?stringlib).
4-50
Strings
Exercise 4.28: The command anames(All) returns a set of all identifiers that
have a value in the current session. Generate a lexicographically ordered list of
these identifiers.
Exercise 4.29: How can you obtain the “mirror image” of a string? Hint: the
function length returns the number of symbols in a string.
4-51
4 MuPAD® Objects
Functions
The arrow operators -> (a minus sign followed by a “greater than” sign) and -->
(two minus signs followed by a “greater than” sign) generate simple objects that
represent mathematical functions:
f := (x, y) -> x^2 + y^2
(x, y) → x2 + y 2
The function f can now be called like any system function. It takes two arbitrary
input parameters (or “arguments”) and returns the sum of their squares:
f(a, b + 1)
2
(b + 1) + a2
In the following example, the return value of the function is generated by an if

statement:
absValue := x -> if x >= 0 then x else -x end_if:
absValue(-2.3)
2.3
As discussed in Section 4.4, the operator @ generates the composition

h : x → f (g(x)) of two functions f and g :
f := x -> 1/(1 + x): g := x -> sin(x^2):
h := f@g: h(a)
1
sin(a2 ) + 1
You can define a repeated composition f (f (f (·))) of a function with itself by using
the iteration operator @@:
fff := f@@3: fff(a)
1
1
1 +1
a+1 +1
4-52
Functions
Of course, these constructions also work for system functions. For example, the
function abs @ Re computes the absolute value of the real part of a complex
number:
f := abs@Re: f(-2 + 3*I)
2
In symbolic computations, you often have the choice to represent a mathematical

function either as a map arguments 7→ value or as an expression:
Map := x -> 2*x*cos(x^2):
Expression := 2*x*cos(x^2):
int(Map(x), x), int(Expression, x)

sin x2 , sin x2
If you try to convert an expression into a function by means of the -> operator,
you will find that it does not quite work:
h := x -> Expression:
h(1)

2 x cos x2
Instead, use the long arrow operator -->, which evaluates the right hand side
expression, as explained in Chapter 5 and returns a function, which you can
manipulate further:
h := x --> Expression;

x → 2 x cos x2
h'

x → 2 cos x2 − 4 x2 sin x2
Indeed, h' is the functional equivalent of diff(Expression, x):

h'(x) = diff(Expression, x)

2 cos x2 − 4 x2 sin x2 = 2 cos x2 − 4 x2 sin x2
4-53
4 MuPAD® Objects
MuPAD can represent maps by means of functional expressions: functions are

constructed from simple functions (such as sin, cos, exp, ln, id) by means of
operators (such as the composition operator @ or the arithmetic operators +, *,
etc.). Note that the arithmetic operators generate functions that are defined
pointwise, which is mathematically sound. For example, f + g represents the map
x → f (x) + g(x), f · g represents the map x → f (x) · g(x), etc.:
delete f, g:
a := f + g: b := f*g: c := f/g:
a(x), b(x), c(x)
f (x)
f (x) + g(x) , f (x) g(x) ,
g(x)
You are allowed to have numerical values in functional expressions. MuPAD

regards them as constant functions which always return the particular value:
1(x), 0.1(x, y, z), PI(x)
1, 0.1, π
a := f + 1: b := f*3/4: c := f + 0.1: d := f + sqrt(2):
a(x), b(x), c(x), d(x)
3 f (x) √
f (x) + 1, , f (x) + 0.1, f (x) + 2
4
It is also possible to use functions without assigning them to an identifier and to

pass them as arguments to other functions. We have used this possibility before,
so for recapitulation, we just give another simple example:
map([1, 2, 3, 4], i -> i^2)
[1, 4, 9, 16]
The operator -> is useful for defining functions whose return value can be
obtained by simple operations. Functions implementing more complex
algorithms usually require many commands and auxiliary variables to store
intermediate results. In principle, you can define such functions via -> as well.
However, this has the drawback that you often use global variables. Instead, we
recommend to define a procedure via proc() begin ... end_proc. This concept
of the MuPAD programming language is much more flexible and is discussed in
4-54
Functions
more detail in Chapter 17.
√
Exercise 4.30: Define the functions f (x) = x2 and g(x) = x. Compute
f (f (g(2)) and f (f (. . . f (x) . . . )) .
| {z }
100 times
Exercise 4.31: Define a function that reverses the order of the elements in a list.
Exercise 4.32: The Chebyshev polynomials are defined recursively by the

following formulae:
T0 (x) = 1 , T1 (x) = x , Tk (x) = 2 x Tk−1 (x) − Tk−2 (x) .
Compute the values of T2 (x), . . . , T5 (x) for x = 1/3, x = 0.33, and for a symbolical
value x.
4-55
4 MuPAD® Objects
Series Expansions
Expressions such as 1/(1 - x) admit series expansions for symbolic parameters.
This particularly simple example is the sum of the geometric series:
1
= 1 + x + x2 + x3 + · · ·
1−x
The function taylor computes the leading terms of such series:
t := taylor(1/(1 - x), x = 0, 9)

1 + x + x2 + x3 + x4 + x5 + x6 + x7 + x8 + O x9
This is the Taylor series expansion of the expression around the point x = 0, as
requested by the second argument. MuPAD® has truncated the infinite series
before the term x9 and has collected the tail in the “big Oh” term O(x9 ) (also
called the “Landau symbol”). The (optional) third argument of taylor controls
the truncation. If it is not present, then MuPAD uses the value of the environment
variable ORDER instead, whose default value is 6:
t := taylor(1/(1 - x), x = 0)

1 + x + x2 + x3 + x4 + x5 + O x6
The resulting series looks like an ordinary sum with an additional O(·) term.
Internally, however, it is represented by a special data structure of domain type
Series::Puiseux
domtype(t)
Series::Puiseux
The big-Oh term itself is a data structure on its own, of domain type O and with
special rules of manipulation:
2*O(x^2) + O(x^3), x^2*O(x^10), O(x^5)*O(x^20),
diff(O(x^3), x)

O x2 , O x12 , O x25 , O x2
The ordering of the terms in a Taylor series is fixed: powers with smaller
exponents precede those with higher exponents. This is in contrast to the ordering
in ordinary sums, where high exponents precede small exponents:
4-56
Series Expansions
S := expr(t)
x5 + x4 + x3 + x2 + x + 1
Here we have used the system function expr to convert the series to an expression
of domain type DOM_EXPR. As you can see in the output, the O(·) term has been cut
off.
The op command acts on series in a non-obvious way and should not be used:
op(t)
0, 1, 0, 6, [1, 1, 1, 1, 1, 1] , x = 0, Undirected
Therefore, the function coeff is provided to extract the coefficients. This is more
intuitive than op. The call coeff(t, i) returns the coefficient of xi :
t := taylor(cos(x^2), x, 20)
x4 x8 x12 x16
1− + − + + O x20
2 24 720 40320
coeff(t, 0), coeff(t, 1), coeff(t, 12), coeff(t, 25)
1
1, 0, − , FAIL
720
In the previous example, we have supplied x as second argument to specify the

point of expansion. This is equivalent to x = 0.
The usual arithmetic operations also work for series:
a := taylor(cos(x), x, 3): b := taylor(sin(x), x, 4):
a, b
x2 x3
1− + O x4 , x − + O x5
2 6
a + b, 2*a*b, a^2
x2 x3 4 x3
1+x− − + O x4 , 2 x − + O x5 , 1 − x2 + O x4
2 6 3
4-57
4 MuPAD® Objects
Both the composition operator @ and the iteration operator @@ apply to series as
well:
a := taylor(sin(x), x, 20):
b := taylor(arcsin(x), x, 20): a@b

x + O x21
If you try to compute the Taylor series of a function that does not have one, then
taylor aborts with an error. The function series can compute more general
expansions (Laurent series, Puiseux series):
taylor(cos(x)/x, x = 0, 10)
Error: 1/x*cos(x) does not have a Taylor series \
expansion, try 'series' [taylor]
series(cos(x)/x, x = 0, 10)
1 x x3 x5 x7
− + − + + O x9
x 2 24 720 40320
You can generate series expansions in terms of negative powers by expanding

around the point infinity:
series((x^2 + 1)/(x + 1), x = infinity)

2 2 2 2 1
x−1+ − 2 + 3 − 4 +O 5
x x x x x
This is an example for an “asymptotic” expansion, which approximates the

behavior of a function for large values of the argument. In simple cases, series
returns an expansion in terms of negative powers of x, but other functions may
turn up as well:
series((exp(x) - exp(-x))/(exp(x) + exp(-x)),
x = infinity)
2 2 2 2 2
1− + − + − + O e−12 x
e2 x e4 x e6 x e8 x e10 x
4-58
Series Expansions
Exercise 4.33: The order p of a root x of a function f is the maximal number of

derivatives that vanish at the point x:
f (x) = f ′ (x) = · · · = f (p−1) (x) = 0 , f (p) (x) ̸= 0 .
What is the order of the root x = 0 of f (x) = tan(sin(x)) − sin(tan(x))?
Exercise 4.34: Besides the arithmetical operators, some other system functions
such as diff or int work directly for series. Compare the result of
taylor(diff(1/(1 - x), x), x) and the derivative of taylor(1/(1 - x), x).
Mathematically, both series are identical. Can you explain the difference in
MuPAD?
√ √
Exercise 4.35: The function f (x) = x + 1 − x − 1 tends to zero for large x,
√
i.e., limx→∞ f (x) = 0. Show that the approximation f (x) ≈ 1/ x is valid for large
values of x. Find better asymptotic approximations of f .
Exercise 4.36: Compute the first three terms in the series expansion of the
function f:= sin(x + x^3) around x = 0. Read the help page for the MuPAD
function revert. Use this function to compute the leading terms of the series
expansion of the inverse function f −1 (which is well-defined in a certain
neighborhood of x = 0).
4-59
4 MuPAD® Objects
Algebraic Structures: Fields, Rings, etc.

The MuPAD® kernel provides domain types for the basic data structures such as
numbers, sets, tables, etc. In addition, you can define your own data structures in
the MuPAD language and work with them symbolically. We do not discuss the
construction of such new “domains” in this elementary introduction, but
demonstrate some special “library” domains provided by the system.
Besides the kernel domains, the Dom library contains a variety of predefined
domains that were implemented by the MuPAD developers. For an overview, see
the reference documentation. In this section, we present some particularly useful
domains representing complex mathematical objects such as fields, rings, etc.
Section 4.15 discusses a data type for matrices, which is well-suited for problems
in linear algebra.
The main part of a domain is its constructor, which generates objects of the
domain. Each such object “knows” its domain, which has methods attached to it.
They represent the mathematical operations for these objects.
Here is a list of some of the well-known mathematical structures implemented in
the Dom library:
• the ring of integers Z : Dom::Integer,
• the field of rational numbers Q : Dom::Rational,
• the field of real numbers R : Dom::Real or Dom::Float,7
• the field of complex numbers C : Dom::Complex,
• the ring of integers modulo n: Dom::IntegerMod(n).
We consider the residue class ring of integers modulo n. Its elements are the
integers 0, 1, . . . , n − 1, and addition and multiplication are defined “modulo n.”
This works by adding or multiplying in Z, dividing the result by n, and taking the
remainder of this division in {0, 1, . . . , n − 1}:
7 Dom::Real is for symbolic representations of real numbers, while Dom::Float represents them as
floating-point numbers.
4-60
3*5 mod 7
1
In this example, we have used the data types of the MuPAD kernel: the operator *
multiplies the integers 3 and 5 in the usual way to get 15, and the operator mod
computes the decomposition 15 = 2 · 7 + 1 and returns 1 as remainder modulo 7.
Alternatively, you may tell MuPAD that you want to compute in Z7 = Z/7 Z by
using the input syntax Dom::IntegerMod(7). The latter object acts as a
constructor for elements of the residue class ring8 modulo 7:
constructor := Dom::IntegerMod(7):
x := constructor(3); y := constructor(5)
3 mod 7
5 mod 7
As you can see from the screen output, the identifiers x and y do not have the
integers 3 and 5, respectively, as values. Instead, the numbers are elements of the
residue class ring of integers modulo 7:
domtype(x), domtype(y)
Z7 , Z7
Now, you can use the usual arithmetic operations, and MuPAD automatically uses
the computation rules of the residue class ring:
x*y, x^123*y^17 - x + y
1 mod 7, 6 mod 7
The ring Dom::IntegerMod(7) even has a field structure, so that you can divide by
all ring elements except 0 mod 7:
8 If you want to execute only a small number of modulo operations, it is often preferable to use
the operator mod, which is implemented in the MuPAD kernel and quite fast. This approach may
require some additional understanding how the system functions work. For example, the compu-
tation of 17^29999 mod 7 takes quite a long time, since MuPAD first computes the very big num-
ber 1729999 and then reduces the result modulo 7. In this case, the computation x^29999, where
x:= Dom::IntegerMod(7)(17), is much faster since the internal modular arithmetic avoids such big
numbers. Alternatively, the call powermod(17, 29999, 7) uses the system function powermod to com-
pute the result quickly without employing Dom::IntegerMod(7).
4-61
4 MuPAD® Objects
x/y
2 mod 7
A more abstract example is the field extension

√ √
K = Q[ 2 ] = {p + q 2 ; p, q ∈ Q } .
You may define this field via

K := Dom::AlgebraicExtension(Dom::Rational,
Sqrt2^2 = 2, Sqrt2):
√
b 2), defined by its algebraic property Sqrt2^2 = 2, is
Here the identifier Sqrt2 (=
used to extend the rational numbers Dom::Rational. Now, you can compute in
this field:
x := K(1/2 + 2*Sqrt2): y := K(1 + 2/3*Sqrt2):
x^2*y + y^4
677 Sqrt2 5845
+
54 324
The domain Dom::ExpressionField(normalizer, zerotest) represents the

“field” of (symbolic) MuPAD expressions. The constructor is parametrized by two
functions normalizer and zerotest, which may be chosen by the user.
The function zerotest is called internally by all algorithms that want to decide
whether a domain object is mathematically 0. Typically, you will use the system
function iszero, which recognizes not only the integer 0 as zero, but also other
objects such as the floating-point number 0.0 or the polynomial poly(0, [x])
(Section 4.16).
The task of the function normalizer is to generate a normal form for MuPAD
objects of type Dom::ExpressionField(·, ·). Operations on such objects will use
this function to simplify the result before returning it. For example, if you supply
the identity function id for the normalizer argument, then operations on objects
of this domain work like for the usual MuPAD expressions without additional
normalization:
constructor := Dom::ExpressionField(id, iszero):
x := constructor(a/(a + b)^2):
y := constructor(b/(a + b)^2):
4-62
x + y
a b
2 + 2
(a + b) (a + b)
If you supply the system function normal instead, the result is simplified
automatically (Section 9.1):
constructor := Dom::ExpressionField(normal, iszero):
x := constructor(a/(a + b)^2):
y := constructor(b/(a + b)^2):
x + y
1
a+b
We note that the purpose of such MuPAD domains is not necessarily the direct
generation of data structures or the computation with the corresponding objects.
Indeed, some constructors simply return objects of the underlying kernel
domains, if such domains exist:
domtype(Dom::Integer(2)),
domtype(Dom::Rational(2/3)),
domtype(Dom::Float(PI)),
domtype(Dom::ExpressionField(id, iszero)(a + b))
DOM_INT, DOM_RAT, DOM_FLOAT, DOM_EXPR
In these cases, there is no immediate benefit in using such a constructor; you may
as well compute directly with the corresponding kernel objects. The main
application of such special data structures is the construction of more complex
mathematical structures. A simple example is the generation of matrices
(Section 4.15) or polynomials (Section 4.16) with entries in a particular ring, such
that matrix or polynomial arithmetic, respectively, is performed according to the
computation rules of the coefficient ring.
4-63
4 MuPAD® Objects
Vectors and Matrices

In Section 4.14, we have given examples of special data types (“domains”) for
defining algebraic structures such as rings, fields, etc. in MuPAD ® . In this section,
we discuss two further domains for generation and convenient computation with
vectors and matrices: Dom::Matrix and Dom::SquareMatrix. In principle, you
may use arrays for working with vectors or matrices (Section 4.9). However, then
you have to define you own routines for addition, multiplication, inversion, or
determinant computation, using the MuPAD programming language (Chapter 17).
For the special matrix type that we present in what follows, such routines exist
and are “attached” to the matrices as methods. Moreover, you may use the
functions of the linalg library (linear algebra, Section 4.15), which can handle
matrices of this type.
Definition of Matrices and Vectors
Vectors in MuPAD® are regarded as special matrices of dimension 1 × n or n × 1,

respectively. The command matrix may be used for creating matrices and vectors
of arbitrary dimension:
matrix([[ 1, 2, 3, 4 ],
[ a, b, c, d ],
[sin(x), cos(x), exp(x), ln(x)]]),
matrix([x1, x2, x3, x4])
 
  x1
1 2 3 4  
   x2 

 a b c d ,  
 x3 
sin(x) cos(x) ex ln(x)
x4
Arbitrary arithmetical expressions may be used as elements. Although matrices

created by matrix are suitable for most applications and will be the most widely
used matrix objects, MuPAD’s concept for matrices is more general. Typically, a
specific coefficient ring for the elements is attached to a MuPAD matrix. In fact,
the function matrix is just a constructor with a short name for special matrices of
domain type Dom::Matrix(R), where R = Dom::ExpressionField() represents
arbitrary MuPAD expressions.
4-64
We explain the general concept. MuPAD provides the data type Dom::Matrix for
matrices of arbitrary dimension m × n. The type Dom::SquareMatrix represents
square matrices of dimension n × n. They belong to the library Dom, which also
comprises data types for mathematical structures such as rings and fields
(Section 4.14). Matrices may have entries from a set that must be equipped with a
ring structure in the mathematical sense. For example, you may use the
predefined rings and fields such as Dom::Integer, Dom::IntegerMod(n), etc. from
the Dom library.
The call Dom::Matrix(R) creates the constructor for matrices of arbitrary
dimension m × n with coefficients in the ring R. When you construct such a
matrix, you are required to ensure that its entries belong to (or may be converted
to) this ring. You should keep this in mind when trying to generate matrices with
entries outside the coefficient ring in a computation (for example, the inverse of
an integer matrix in general has non-integral rational entries).
The following example yields the constructor for matrices with rational number
entries:
constructor := Dom::Matrix(Dom::Rational)
Dom::Matrix(Q)
Now, you may generate matrices of arbitrary dimensions. In the following

example, we generate a 2 × 3 matrix with all entries initialized to 0:
A := constructor(2, 3)
!
0 0 0
0 0 0
When generating a matrix, you may supply a function f that takes two arguments.
Then the entry in row i and column j is initialized with f (i, j):
f := (i, j) -> (i*j): A := constructor(2, 3, f)
!
1 2 3
2 4 6
4-65
4 MuPAD® Objects
Alternatively, you can initialize a matrix by specifying a (nested) list. Each list
element is itself a list and corresponds to one row of the matrix. The following
command generates the same matrix as in the previous example:
constructor(2, 3, [[1, 2, 3], [2, 4, 6]]):
The parameters for the dimension are optional here, since they are also given by
the structure of the list. Thus,
constructor([[1, 2, 3], [2, 4, 6]]):
also returns the same matrix. An array of domain type DOM_ARRAY (Section 4.9) is
also valid for initializing a matrix:
Array := array(1..2, 1..3, [[1, 2, 3], [2, 4, 6]]):
Mat := constructor(Array):
You may define column and row vectors as m × 1 and 1 × n matrices, respectively.
Plain lists can be used for defining column or row vectors:
column := constructor(3, 1, [1, 2, 3])
 
1
 
 2 
3
row := constructor(1, 3, [1, 2, 3])

1 2 3
If no dimensions are specified, a plain list generates a column vector:

column := constructor([1, 2, 3])
 
1
 
 2 
3
4-66
The entries of a matrix or a vector may be accessed in the forms matrix[i, j],
row[i], or column[j]. Since vectors are special matrices, you may access the
components of a vector also in the form row[1, i] or column[j, 1], respectively:
A[2, 3], row[3], row[1, 3],
column[2], column[2, 1]
6, 3, 3, 2, 2
Submatrices are generated as follows:

Mat[1..2, 1..2], row[1..1, 1..2],
column[1..2, 1..1]
! !
1 2 1
, 1 2 ,
2 4 2
You may change a matrix entry by an indexed assignment:

Mat[2, 3] := 23: row[2] := 5: column[2, 1] := 5:
Mat, row, column
 
! 1

1 2 3  
, 1 5 3 ,  5 
2 4 23
3
You can use loops (Chapter 15) to change all components of a matrix:
m := 2: n := 3: Mat := constructor(m, n):
for i from 1 to m do
for j from 1 to n do
Mat[i, j] := i*j
end_for
end_for:
You can generate diagonal matrices by supplying the option Diagonal. In this
case, the third argument to the constructor may either be a list of the diagonal
elements or a function f such that the i-th diagonal element is f (i):
constructor(2, 2, [11, 12], Diagonal)
!
11 0
0 12
4-67
4 MuPAD® Objects
In the next example, we generate an identity matrix by supplying 1 as a function9

defining the diagonal elements:
constructor(2, 2, 1, Diagonal)
!
1 0
0 1
Alternatively, identity matrices can be generated by the "identity" method of the

constructor:
constructor::identity(2)
!
1 0
0 1
The constructor considered so far returns matrices with rational (i.e., real)
number entries. Thus, the following attempt to generate a matrix with complex
coefficients does not work:
constructor([[1, 2, 3], [2, 4, 1 + I]])
Error: unable to define matrix over Dom::Rational \
[(Dom::Matrix(Dom::Rational))::new]
You have to choose a suitable coefficient ring to generate a matrix with the above
entries. In the following example, we define a new constructor for matrices with
complex number entries:
constructor := Dom::Matrix(Dom::Complex):
constructor([[1, 2, 3], [2, 4, 1 + I]])
!
1 2 3
2 4 1+i
You may generate matrices whose entries are arbitrary MuPAD expressions by
means of the field Dom::ExpressionField(id, iszero) (see Section 4.14). This is
the standard coefficient ring for matrices. You may always use this ring when the
coefficients and their properties are irrelevant.
9 Cf. page 4-54.
4-68
Dom::Matrix() with no argument is a constructor for such matrices. As a

shorthand notation, this matrix ring is attached to the identifier matrix:
matrix
Dom::Matrix()
matrix([[1, x + y, 1/x^2], [sin(x), 0, cos(x)],

[x*PI, 1 + I, -x*PI]])
 
1
1 x+y x2
 
 sin(x) 0 cos(x) 
πx 1+i −π x
If you use Dom::ExpressionField(normal, iszero) as the coefficient ring, then

all matrix entries are simplified via the function normal, as described in
Section 4.14. Arithmetical operations with such matrices are comparatively slow,
since a call to normal may be quite time consuming. However, the results are in
general simpler than the (equivalent) results of computations with the standard
coefficient ring Dom::ExpressionField(id, iszero) used by Dom::Matrix().
The constructor Dom::SquareMatrix(n,R) corresponds to the ring of
n-dimensional square matrices with coefficient ring R. If the argument R is
missing, then MuPAD automatically uses the coefficient ring of all MuPAD
expressions. The following statement yields the constructor for 2 × 2 matrices,
whose entries may be arbitrary MuPAD expressions:
constructor := Dom::SquareMatrix(2)
Dom::SquareMatrix(2)
constructor([[0, y], [x^2, 1]])

!
0 y
x2 1
4-69
4 MuPAD® Objects
Computing with Matrices
You can use the standard arithmetical operators for doing basic arithmetic with
matrices:
A := matrix([[1, 2], [3, 4]]):
B := matrix([[a, b], [c, d]]):
A + B, A*B;
A*B - B*A, A^2 + B
! !
a+1 b+2 a + 2c b + 2d
,
c+3 d+4 3a + 4c 3b + 4d
! !
2c − 3b 2d − 3b − 2a a + 7 b + 10
,
3a + 3c − 3d 3b − 2c c + 15 d + 22
Multiplication of a matrix and a number works componentwise (scalar

multiplication):
2*B
!
2a 2b
2c 2d
The inverse of a matrix is represented by 1/A or A^(-1):

C := A^(-1)
!
−2 1
3
2 − 12
A simple test shows that the computed inverse is correct:

A*C, C*A
! !
1 0 1 0
,
0 1 0 1
4-70
An inversion returns FAIL when MuPAD is unable to compute the result. The
following matrix is not invertible:
C := matrix([[1, 1], [1, 1]]):
C^(-1)
FAIL
The concatenation operator ., which combines lists (Section 4.6) or strings

(Section 4.11), is “overloaded” for matrices. You can use it to combine matrices
with the same number of rows:
A, B, A.B
! ! !
1 2 a b 1 2 a b
, ,
3 4 c d 3 4 c d
Besides the arithmetic operators, other system functions are applicable to

matrices. Here is a list of examples:
• conjugate(A) replaces all components by their complex conjugates,
• diff(A, x) differentiates componentwise with respect to x,

X∞
1 i
• exp(A) computes eA = A,
i=0
i!
• expand(A) applies expand to all components of A,
• expr(A) converts A to an array of domain type DOM_ARRAY,
• float(A) applies float to all components of A,
• has(A, expression) checks whether an expression is contained in at least

one entry of A,
• int(A, x) integrates componentwise with respect to x,
• iszero(A) checks whether all components of A vanish,
• map(A, function) applies the function to all components,
4-71
4 MuPAD® Objects
• norm(A) (identical with norm(A, Infinity)) computes the infinity norm,10
• A | equation applies · | equation to all entries of A,
• subs(A, equation) applies subs(·, equation) to all entries of A,
• C :=zip(A, B, f) returns the matrix defined by Cij = f (Aij , Bij ).
The linear algebra library linalg and the numerics library numeric (Section 4.15)
comprise many other functions for handling matrices.
Exercise 4.37: Generate the 15 × 15 Hilbert matrix H = (Hij ) with

Hij = 1/(i + j − 1). Generate the vector ⃗b = H ⃗e, where ⃗e = (1, . . . , 1)t . Compute
the exact solution vector ⃗x of the system of equations H ⃗x = ⃗b (of course, this
should yield ⃗x = ⃗e). Convert all entries of H to floating-point values and solve the
system of equations again. Compare the result to the exact solution. You will note
a dramatic difference, which is caused by numerical rounding errors. Larger
Hilbert matrices cannot be inverted with the standard precision of common
numerical software!
Special Methods for Matrices
A constructor that has been generated by means of either Dom::Matrix(·) or

Dom::SquareMatrix(·) contains many special functions for the corresponding
data type. If M:= Dom::Matrix(ring) is a constructor and A:= M(·) is a matrix
generated with this constructor, as described in Section 4.15, then, among may
others, the following methods are available:
• M::col(A, i) returns the i-th column of A,
• M::delCol(A, i) removes the i-th column from A,
• M::delRow(A, i) removes the i-th row from A,
• M::matdim(A) returns the dimension [m, n] of the m × n matrix A,
10 norm(A, 1) returns the one-norm, norm(A, Frobenius) yields the Frobenius norm
X 1/2
|Aij |
2
.
i,j
4-72
• M::random() returns a matrix with random entries,
• M::row(A, i) returns the i-th row of A,
• M::swapCol(A, i, j) exchanges columns i and j ,
• M::swapRow(A, i, j) exchanges rows i and j ,

P
• M::tr(A) returns the trace i Aii of A,
• M::transpose(A) returns the transpose (Aji ) of A = (Aij ).
M := Dom::Matrix(): A := M([[x, 1], [2, y]])

!
x 1
2 y
M::col(A, 1), M::delCol(A, 1), M::matdim(A)

! !
x 1
, , [2, 2]
2 y
M::swapCol(A, 1, 2), M::tr(A), M::transpose(A)

! !
1 x x 2
, x + y,
y 2 1 y
Since the domain is attached to the object A as A::dom, one can also call the
domain methods via A::dom::method. For example:
A::dom::tr(A)
x+y
The documentation of Dom::Matrix contains a survey of these methods.
4-73
4 MuPAD® Objects
The Libraries linalg and numeric
Besides system functions operating on matrices, the library 11 linalg contains a

variety of other linear algebra functions:
info(linalg)
Library 'linalg': the linear algebra package
-- Interface:
linalg::addCol, linalg::addRow,
linalg::adjoint, linalg::angle,
linalg::basis, linalg::charmat,
linalg::charpoly, linalg::col,
linalg::companion, linalg::concatMatrix,
linalg::crossProduct, linalg::curl,
linalg::delCol, linalg::delRow,
linalg::det, linalg::divergence,
linalg::eigenvalues, linalg::eigenvectors,
linalg::expr2Matrix, linalg::factorCholesky,
linalg::factorLU, linalg::factorQR,
linalg::frobeniusForm, linalg::gaussElim,
linalg::gaussJordan, linalg::grad,
linalg::hermiteForm, linalg::hessenberg,
linalg::hessian, linalg::hilbert,
linalg::intBasis, linalg::inverseLU,
linalg::invhilbert, linalg::invpascal,
linalg::invvandermonde, linalg::isHermitean,
linalg::isPosDef, linalg::isUnitary,
linalg::jacobian, linalg::jordanForm,
linalg::kroneckerProduct, linalg::laplacian,
linalg::matdim, linalg::matlinsolve,
linalg::matlinsolveLU, linalg::minpoly,
linalg::multCol, linalg::multRow,
linalg::ncols, linalg::nonZeros,
linalg::normalize, linalg::nrows,
linalg::nullspace, linalg::ogCoordTab,
linalg::orthog, linalg::pascal,
linalg::permanent, linalg::potential,
linalg::pseudoInverse, linalg::randomMatrix,
linalg::rank, linalg::row,
11 We refer to Chapter 3 for a description of general library organization, exporting, etc.
4-74
linalg::scalarProduct, linalg::setCol,
linalg::setRow, linalg::smithForm,
linalg::stackMatrix, linalg::submatrix,
linalg::substitute, linalg::sumBasis,
linalg::swapCol, linalg::swapRow,
linalg::sylvester, linalg::toeplitz,
linalg::toeplitzSolve, linalg::tr,
linalg::transpose, linalg::vandermonde,
linalg::vandermondeSolve, linalg::vecdim,
linalg::vectorOf, linalg::vectorPotential,
linalg::wiedemann
Some of these functions, such as linalg::col or linalg::delCol, simply call the

internal methods for matrices that we have described in Section 4.15, and hence
do not add new functionality. However, linalg also contains many additional
algorithms. The command ?linalg yields a short description of all functions. You
can find a detailed description of a function on the corresponding help page.
You may use the full name library::function to call a function:
A := matrix([[a, b], [c, d]]): linalg::det(A)
ad − bc
The characteristic polynomial det(x In − A) of this matrix is

linalg::charpoly(A, x)
x2 + (−a − d) x + a d − b c
The eigenvalues are

linalg::eigenvalues(A)
( √ √ )
a d a2 − 2 a d + d2 + 4 b c a d a2 − 2 a d + d2 + 4 b c
+ − , + +
2 2 2 2 2 2
4-75
4 MuPAD® Objects
The numerics library numeric (see ?numeric) contains many functions for
numerical computations with matrices:
✞ ☎
numeric::det : determinant
numeric::expMatrix : exp(Matrix)
numeric::factorCholesky : Cholesky factorization
numeric::factorLU : LU factorization
numeric::factorQR : QR factorization
numeric::fMatrix : functional calculus
numeric::inverse : inversion
numeric::eigenvalues : eigenvalues
numeric::eigenvectors : eigenvalues and –vectors
numeric::singularvalues : singular values
numeric::singularvectors : singular values and vectors
✝ ✆
Partially, these routines work for matrices with symbolic entries of type
Dom::ExpressionField and then are more efficient for large matrices than the
linalg functions. However, the latter can handle arbitrary coefficient rings.
 
1ab
Exercise 4.38: Find the values of a, b, c for which the matrix  1 1 c  is not
111
invertible.
Exercise 4.39: Consider the following matrices:

   
1 3 0 7 −1
A =  −1 2 7 , B =  2 3  .
0 8 1 0 1
Let B T be the transpose of B . Compute the inverse of 2 A + B B T , both over the

rational numbers and over the residue class ring modulo 7.
4-76
Exercise 4.40: Generate the 3 × 3 matrix

0 for i = j ,
Aij =
1 for i ̸= j .
Compute its determinant, its characteristic polynomial, and its eigenvalues. For
each eigenvalue, compute a basis of the corresponding eigenspace.
Sparse Matrices
The internal storage of matrices is optimized for sparse data, i.e., for matrices
consisting largely of zeroes, since such matrices appear often in practice. Here are
some remarks concerning efficiency when your matrices are large and sparse:
• Use the standard coefficient ring Dom::ExpressionField() of arbitrary

MuPAD® expressions whenever possible. As discussed in the previous
sections, the constructor Dom::Matrix() creates matrices of this type. For
convenience, this constructor is also available as the function matrix.
• Indexed reading and writing to large matrices is somewhat expensive. If

possible, one should avoid creating large empty matrices of the desired
dimension by matrix(m, n) and filling in the non-zero entries by indexed
assignments. One should set the entries directly when creating the matrix.
Lists of equations can be used to specify the entries when creating a matrix. The
following matrix A of dimension 1000 × 1000 consists of a diagonal band and two
additional entries in the upper right and the lower left corner. We display some
entries of its 10-th power:
n := 1000:
A := matrix(n, n, [(i, i) = i $ i = 1..n,
(n, 1) = 1, (1, n) = 1]):
B := A^10:
B[1, 1], B[1, n]
1002010022050086122130089, 1001009015040066101119105055
4-77
4 MuPAD® Objects
In the following example, we generate a 100 × 100 tri-diagonal Toeplitz matrix A

and solve the equation A x = b, where b is the column vector (1, . . . , 1):
A := matrix(100, 100, [-1, 2, -1], Banded):
b := matrix(100, 1, [1 $ 100]):
x := (1/A)*b
 
50
 
 99 
 
 
 ... 
50
Here we have applied the inverse 1/A of A to the right-hand side of the equation.
Note, however, that inverting a sparse matrix is not a good idea because the
inverse of a sparse matrix is, in general, not sparse. It is much more efficient to
use sparse matrix factorization to compute the solution of a sparse system of
linear equations. We use the linear solver numeric::matlinsolve with the option
Symbolic to compute the solution of a sparse system representing 1000 equations
for 1000 unknowns. The numeric routine employs sparsity in an optimal way:
A := matrix(1000, 1000, [-1, 2, -1], Banded):
b := matrix(1000, 1, [1 $ 1000]):
[x, kernel] := numeric::matlinsolve(A, b, Symbolic):
We display only a few components of the solution vector:

x[1], x[2], x[3], x[4], x[5], x[999], x[1000]
500, 999, 1497, 1994, 2490, 999, 500
An Application
We want to compute the symbolic solution a(t), b(t) of the system of second order
differential equations
2 2
d d d d
a(t) = 2 c b(t) , b(t) = −2 c a(t) + 3 c2 b(t)
dt2 dt d t2 dt
with an arbitrary constant c. Writing a′ (t) = ddt a(t), b′ (t) = ddt b(t), these equations
may be equivalently written as a system of first order differential equations in the
4-78
variables x(t) = (a(t), a′ (t), b(t), b′ (t)):

 
0 1 0 0
d  0 0 0 2c 
x(t) = A x(t), A=
 0
.
dt 0 0 1 
0 −2 c 3 c2 0
The solution of this system is given by applying the exponential matrix etA to the
initial condition x(0):
x(t) = etA x(0) .
delete c, t:
A := matrix([[0, 1, 0, 0 ],
[0, 0, 0, 2*c],
[0, 0, 0, 1 ],
[0, -2*c, 3*c^2, 0 ]]):
We use the function exp to compute B = etA :

B := exp(t*A)
 −c t i cti cti −c t i

1 −3 t + e c 2 i − e c 2 i ec t i 3 i + 6 c t − e−c t i 3 i 2
− ec − e c
 c 
 0 2 e−c t i + 2 ec t i − 3 6 c − 3 c e−c t i − 3 c ec t i e−c t i i − ec t i i 
 
 e−c t i ec t i cti −c t i
e−c t i i ec t i i 
0 c + c −c 2
4 − 3 e2 − 3 e 2 c2 − c2 
−c t i cti
e−c t i ec t i
0 −e−c t i i + ec t i i ce
2
3i
− ce 2 3i 2 + 2
To simplify this matrix, we use the function Simplify, which for matrices simply
maps itself to the entries:
B := Simplify(B)
 
4 sin(c t)
1 − 3t 6 c t − 6 sin(c t) − 2 (cos(cc t)−1)
 c 
 0 4 cos(c t) − 3 −6 c (cos(c t) − 1) 2 sin(c t) 
 
 2 (cos(c t)−1) sin(c t) 
 0 c 4 − 3 cos(c t) c 
0 −2 sin(c t) 3 c sin(c t) cos(c t)
4-79
4 MuPAD® Objects
We assign a symbolic initial condition to the vector x0 . The following call creates a
4 × 1 matrix to be interpreted as a column vector:
x_0 := matrix([a_0, a_0', b_0, b_0'])
 
a0
 ′ 
 a0 
 
 
 b0 
b′0
Thus, the desired symbolic solution of the system of differential equations is

x := t --> B*x_0:
The solution functions a(t) and b(t) with the symbolic initial conditions a(0) = a0 ,
a′ (0) = a′0 , b(0) = b0 , b′ (0) = b′0 are:
a := t --> expand(x(t)[1]): a(t)
2 b′0 2 cos(c t) b′0 4 a′0 sin(c t)
a0 − 6 b0 sin(c t) − 3 t a′0 + − + + 6 b0 c t
c c c
b := t --> expand(x(t)[3]): b(t)
2 a′0 2 cos(c t) a′0 b′ sin(c t)
4 b0 − 3 b0 cos(c t) − + + 0
c c c
Finally, we check that the above expressions really solve the system of differential
equations:
expand(diff(a(t),t,t) - 2*c*diff(b(t),t)),
expand(diff(b(t),t,t) + 2*c*diff(a(t),t) - 3*c^2*b(t))
0, 0
4-80
Polynomials
Polynomials
Computation with polynomials is an important task for a computer algebra
system. Of course, you may realize a polynomial in MuPAD® as an expression in
the sense of Section 4.4 and use the standard arithmetic:
polynomialExpression := 1 + x + x^2:
expand(polynomialExpression^2)
x4 + 2 x3 + 3 x2 + 2 x + 1
However, there exists a special data type DOM_POLY together with some kernel and
library functions, which simplifies such computations and makes them more
efficient.
Definition of Polynomials
The system function poly generates polynomials:

poly(1 + 2*x + 3*x^2)

poly 3 x2 + 2 x + 1, [x]
Here we have supplied the expression 1 + 2 x + 3 x2 (of domain type DOM_EXPR) to

poly, which converts this expression to a new object of domain type DOM_POLY.
The indeterminate [x] is a fixed part of this data type. This is relevant for
distinguishing between indeterminates and (symbolic) coefficients or parameters.
For example, if you want to regard the expression a0 + a1 x + a2 x2 as a
polynomial in x with coefficients a0 , a1 , a2 , then the above form of the call to poly
does not yield the desired result:
poly(a_0 + a_1*x + a_2*x^2)

poly a0 + a1 x + a2 x2 , [a0 , a1 , a2 , x]
This does not represent a polynomial in x but a “multivariate” polynomial in four

indeterminates x, a0 , a1 , a2 . You can specify the indeterminates of a polynomial in
form of a list as argument to poly. The system then regards all other symbolic
identifiers as symbolic coefficients:
4-81
4 MuPAD® Objects
poly(a_0 + a_1*x + a_2*x^2, [x])

poly a2 x2 + a1 x + a0 , [x]
If you do not specify a list of indeterminates, then poly calls the function indets
to determine all symbolic identifiers in the expression and interprets them as
indeterminates of the polynomial:
indets(a_0 + a_1*x + a_2*x^2, PolyExpr)
{a0 , a1 , a2 , x}
The distinction between indeterminates and coefficients is relevant for the

representation of the polynomial:
expression := 1 + x + x^2 + a*x + PI*x^2 - b
x − b + a x + π x2 + x2 + 1
poly(expression, [a, x])

poly a x + (π + 1) x2 + x + (1 − b) , [a, x]
poly(expression, [x])

poly (π + 1) x2 + (a + 1) x + (1 − b) , [x]
You can see that MuPAD collects the coefficients of equal powers of the
indeterminate. The terms are sorted according to falling exponents.
Instead of using an expression, you may also generate a polynomial by specifying
a list of the non-zero coefficients together with the respective exponents. The
Pk
command poly(list, [x]) generates the polynomial i=0 ai xni from the list
[[a0 , n0 ], [a1 , n1 ], . . . , [ak , nk ]]:
list := [[1, 0], [a, 3], [b, 5]]: poly(list, [x])

poly b x5 + a x3 + 1, [x]
If you want to construct a multivariate polynomial in this way, specify lists of

exponents for all variables:
poly([[3, [2, 1]], [2, [3, 4]]], [x, y])

poly 2 x3 y 4 + 3 x2 y, [x, y]
4-82
Polynomials
Conversely, the function poly2list converts a polynomial to a list of coefficients

and exponents:
poly2list(poly(b*x^5 + a*x^3 + 1, [x]) )
[[b, 5] , [a, 3] , [1, 0]]
For more abstract computations, you may want to restrict the coefficients of a
polynomial to a certain set (mathematically: a ring) which is represented by a
special data structure. We have already seen typical examples of rings and their
corresponding MuPAD domains in Section 4.14: the integers Dom::Integer, the
rational numbers Dom::Rational, or the residue class ring Dom::IntegerMod(n)
of integers modulo n. You may specify the coefficient ring as argument to poly:
poly(x + 1, [x], Dom::Integer)
poly (x + 1, [x] , Z)
poly(2*x - 1/2, [x], Dom::Rational)

1
poly 2 x − , [x] , Q
2
poly(4*x + 11, [x], Dom::IntegerMod(3))

poly (x + 2, [x] , Z3 )
Note that in the last example, the system has automatically simplified the
coefficients according to the rules for computing with integers modulo 3:12
4 mod 3, 11 mod 3
1, 2
In the following example, poly converts the coefficients to floating-point

numbers, as specified by the third argument:
poly(PI*x - 1/2, [x], Dom::Float)
poly (3.141592654 x − 0.5, [x] , Dom::Float)
12 For polynomials, you may also use IntMod(3) instead of Dom::IntegerMod(3), in the form
poly(4 * x + 11, [x], IntMod(3)). Then the integers modulo 3 are represented by −1, 0, 1 and not, as
for Dom::IntegerMod(3), by 0, 1, 2. Polynomial arithmetic is much faster when you use IntMod(3).
4-83
4 MuPAD® Objects
If no coefficient ring is specified, then MuPAD by default uses the ring Expr which
symbolizes arbitrary MuPAD expressions. In this case, you may use symbolic
identifiers as coefficients:
polynomial := poly(a + x + b*y, [x, y]);
op(polynomial)
poly (x + b y + a, [x, y])
a + x + b y, [x, y] , Expr
We summarize that a MuPAD polynomial comprises three parts:

P
1. a polynomial expression of the form ai1 i2 ... xi11 xi22 . . .,
2. a list of indeterminates [x1 , x2 , . . .],
3. the coefficient ring.
These are the three operands of a MuPAD polynomial p, which can be accessed via
op(p, 1), op(p, 2), and op(p, 3), respectively. Thus, you may convert a
polynomial to a mathematically equivalent expression13 of domain type DOM_EXPR
by
expression := op(polynomial, 1):
However, you should preferably use the system function expr, which can convert
various domain types such as polynomials to expressions:
polynomial := poly(x^3 + 5*x + 3)

poly x3 + 5 x + 3, [x]
op(polynomial, 1) = expr(polynomial)
x3 + 5 x + 3 = x3 + 5 x + 3
13 If the polynomial is defined over a ring other than Dom::ExpressionField or Expr, the result may
not be equivalent.
4-84
Polynomials
Computing with Polynomials
The function degree determines the degree of a polynomial:

p := poly(1 + x + a*x^2*y, [x, y]):
degree(p, x), degree(p, y)
2, 1
If you do not specify the name of an indeterminate as second argument, then

degree returns the “total degree”:
degree(p), degree(poly(x^27 + x + 1))

3, 27
The function coeff extracts coefficients from a polynomial:

p := poly(1 + a*x + 7*x^7, [x]):
coeff(p, 1), coeff(p, 2), coeff(p, 8)
a, 0, 0
For multivariate polynomials, the coefficient of a power of one particular

indeterminate is again a polynomial in the remaining indeterminates:
p := poly(1 + x + a*x^2*y, [x, y]):
coeff(p, y, 0), coeff(p, y, 1)

poly (x + 1, [x]) , poly a x2 , [x]
The standard operators +, -, * and ^ work for polynomial arithmetic as well:

p := poly(1 + a*x^2, [x]): q := poly(b + c*x, [x]):
p + q, p - q;
p*q, p^2

poly a x2 + c x + (b + 1) , [x] , poly a x2 + (−c) x + (1 − b) , [x]

poly (a c) x3 + (a b) x2 + c x + b, [x] , poly a2 x4 + (2 a) x2 + 1, [x]
4-85
4 MuPAD® Objects
The function divide performs a “division with remainder”:

p := poly(x^3 + 1): q := poly(x^2 - 1): divide(p, q)
poly (x, [x]) , poly (x + 1, [x])
The result is a sequence with two operands: the quotient and the remainder of the
division:
[quotient, remainder] := [divide(p, q)]:
We check:
p = quotient*q + remainder

poly x3 + 1, [x] = poly x3 + 1, [x]
The polynomial denoted by remainder is of lower degree than q, which makes the
decomposition p = quotient * q + remainder unique. Dividing two polynomials by
means of the usual division operator / is only allowed in the special case when the
remainder that divide would return vanishes:
p := poly(x^2 - 1): q := poly(x - 1): p/q
poly (x + 1, [x])
p := poly(x^2 + 1): q := poly(x - 1): p/q

FAIL
Note that the arithmetic operators process only polynomials of exactly identical
types:
poly(x + y, [x, y]) + poly(x^2, [x, y]),
poly(x) + poly(x, [x], Expr)

poly x2 + x + y, [x, y] , poly (2 x, [x])
Both the list of indeterminates and the coefficient ring must coincide, otherwise
the system returns the input as a symbolic expression:
poly(x + y, [x, y]) + poly(x^2, [x])

poly (x + y, [x, y]) + poly x2 , [x]
4-86
Polynomials
poly(x, Dom::Integer) + poly(x)

poly (x, [x] , Z) + poly (x, [x])
The polynomial arithmetic performs coefficient additions and multiplications

according to the rules of the coefficient ring:
p := poly(4*x + 11, [x], Dom::IntegerMod(3)):
p; p + p; p*p
poly (x + 2, [x] , Z3 )
poly (2 x + 1, [x] , Z3 )

poly x2 + x + 1, [x] , Z3
The standard operator * does not work immediately for multiplying a polynomial
by a scalar; you need to convert the scalar factor to a polynomial first:
p := poly(x^2 + y):
scalar*p; poly(scalar, op(p, 2..3))*p

scalar poly x2 + y, [x, y]

poly scalar x2 + scalar y, [x, y]
Here we have ensured that the polynomial generated from the scalar factor is of
the same type as p by passing op(p, 2..3) (=[x, y], Expr) as further arguments to
poly. Alternatively, the function multcoeffs multiplies all coefficients of a
polynomial by a scalar factor:
multcoeffs(p, scalar)

poly scalar x2 + scalar y, [x, y]
The function mapcoeffs applies an arbitrary function to all coefficients of a

polynomial:
p := poly(2*x^2 + 3*y): mapcoeffs(p, f)

poly f (2) x2 + f (3) y, [x, y]
4-87
4 MuPAD® Objects
This yields another way of multiplication by a scalar:

mapcoeffs(p, _mult, scalar)

poly (2 scalar) x2 + (3 scalar) y, [x, y]
Another important operation is the evaluation of a polynomial at a point

(computing the image value). The function evalp achieves this:
p := poly(x^2 + 1, [x]):
evalp(p, x = 2), evalp(p, x = x + y)
2
5, (x + y) + 1
This computation is also valid for multivariate polynomials and yields a

polynomial in the remaining indeterminates or, for a univariate polynomial, an
element of the coefficient ring:
p := poly(x^2 + y):
q := evalp(p, x = 0); evalp(q, y = 2)
poly (y, [y])
You can also use the more general evaluation operator | for the same effect:
p | x = 0; p | [x = 0, y = 2]
poly (y, [y])
You may also regard a polynomial as a function of the indeterminates and call this
function with arguments:
p(2, z)
z+4
A variety of MuPAD functions accept polynomials as input. An important

operation is factorization, which is performed according to the rules of the
coefficient ring. You can do factorization with the MuPAD function factor:
4-88
Polynomials
factor(poly(x^3 - 1))

poly (x − 1, [x]) · poly x2 + x + 1, [x]
factor(poly(x^2 + 1, Dom::IntegerMod(2)))
2
poly (x + 1, [x] , Z2 )
The function D differentiates polynomials:

D(poly(x^7 + x + 1))

poly 7 x6 + 1, [x]
Equivalently, you may also use diff(polynomial, x).

Integration also works for polynomials:
p := poly(x^7 + x + 1): int(p, x)

1 8 1 2
poly x + x + x, [x]
8 2
The function gcd computes the greatest common divisor of polynomials:

p := poly((x + 1)^2*(x + 2)):
q := poly((x + 1)*(x + 2)^2):
factor(gcd(p, q))
poly (x + 2, [x]) · poly (x + 1, [x])
The internal representation of a polynomial stores only those powers of the

indeterminates with non-zero coefficients. This is particularly advantageous for
“sparse” polynomials of high degree and makes arithmetic with such polynomials
efficient. The function nterms returns the number of non-zero terms of a
polynomial. The function nthmonomial extracts individual monomials (coefficient
times powers of the indeterminates), nthcoeff and nthterm return the
appropriate coefficient and product of powers of the indeterminates, respectively:
p := poly(a*x^100 + b*x^10 + c, [x]):
4-89
4 MuPAD® Objects
nterms(p), nthmonomial(p, 2),

nthcoeff(p, 2), nthterm(p, 2)

3, poly b x10 , [x] , b, poly x10 , [x]
Table 4.6 is a summary of the operations for polynomials discussed above. Section
“Functions for Polynomials” of the MuPAD Quick Reference lists further functions
for polynomials in the standard library. The groebner library comprises functions
for handling multivariate polynomial ideals (see ?groebner).
Exercise 4.41: Consider the polynomials p = x7 − x4 + x3 − 1 and q = x3 − 1.

Compute p − q 2 . Does q divide p? Factor p and q .
Exercise 4.42: A polynomial is called irreducible (over a coefficient field) if it

cannot be factored into a product of more than one nonconstant polynomials. The
function irreducible tests a polynomial for irreducibility. Find all irreducible
quadratic polynomials a x2 + b x + c , a ̸= 0 over the field of integers modulo 3.
4-90
Polynomials
✞ ☎
+, -, *, ^ : arithmetic
coeff : extract coefficients
degree : polynomial degree
diff, D : differentiation
divide : division with remainder
evalp : evaluation
expr : conversion to expression
factor : factorization
gcd : greatest common divisor
mapcoeffs : apply a function
multcoeffs : multiplication by a scalar
nterms : number of non-zero coefficients
nthcoeff : n-th coefficient
nthmonomial : n-th monomial
nthterm : n-th term
poly : construct a polynomial
poly2list : conversion to list
✝ ✆
®
Table 4.6: MuPAD functions operating on polynomials
4-91
4 MuPAD® Objects
Hardware Float Arrays

Usually, floating-point computations in computer algebra systems are performed
in “software floats,” providing user-controllable precision (in MuPAD ® , via the
environment variable DIGITS) at the expense of memory and speed. There are
cases, however, where especially the memory requirements of software floats are
prohibitive, especially when importing data from an external source, such as
image files. For such occasions, MuPAD version 5 introduced a new data type,
arrays of hardware floating point numbers, DOM_HFARRAY.
A hardware floating point array is created by the function hfarray, which mimics
array (cf. Chapter 4.9) closely. It can contain only floating point numbers (real
and/or complex), and completely ignores the values of DIGITS for its
computations, which are performed on hardware floats with whatever precision
the underlying hardware and/or operating system provide. (Usually, this means
something around 15 decimal digits.) Accessing elements converts them to and
from software floats:
A := hfarray(1..10, 1..10, [frandom() $ i = 1..100]):
domtype(A), domtype(A[1, 1])
DOM_HFARRAY, DOM_FLOAT
Most of the numeric library accepts hardware floating point arrays as inputs and
returns objects of the same type:
B := numeric::fft(A): domtype(B)
DOM_HFARRAY
numeric::eigenvalues(A)
[5.173121022, 0.8239615051, 0.3962245484 + 0.3259514491 i, . . . ]
4-92
Hardware Float Arrays
In addition to standard array operations, hf-arrays allow addition of arrays of the

same size as well as matrix multiplication for two-dimensional hf-arrays of
compatible sizes:
A := hfarray(1..3, 1..4, [$ 1..12]);
B := hfarray(1..4, 1..2, [1/(i+j) $ j = 1..2 $ i= 1..4])
 
1.0 2.0 3.0 4.0
 
 5.0 6.0 7.0 8.0 
9.0 10.0 11.0 12.0
 
0.5 0.3333333333
 
 0.3333333333 0.25 
 
 
 0.25 0.2 
0.2 0.1666666667
A + A; A*B
 
2.0 4.0 6.0 8.0
 
 10.0 12.0 14.0 16.0 
18.0 20.0 22.0 24.0
 
2.716666667 2.1
 
 7.85 5.9 
12.98333333 9.7
4-93
4 MuPAD® Objects
Interval Arithmetic
There is another kernel data type, called DOM_INTERVAL. Objects of this type
represent real or complex intervals of floating-point numbers. They provide,
among other possibilities, a means of controlling one of the most fundamental
problems of floating-point arithmetic: round-off errors.
The basic idea is as follows: Instead of floating-point numbers x1 , x2 etc., where
almost each operation leads to (usually small) errors, consider intervals X1 , X2
etc. which are known to contain the precise numbers coming from the application.
One would like to have a verified statement that the value y = f (x1 , x2 , . . . ) of a
function f lies in some interval Y . Mathematically, the image set
Y = f (X1 , X2 , . . . ) = {f (ξ1 , ξ2 , . . . ); ξ1 ∈ X1 ; ξ2 ∈ X2 ; . . .}
is wanted. Computing this image set exactly is a formidable task. In fact, it is too
ambitious to ask for an exact representation when using fast and memory efficient
floating-point arithmetic. Instead, the interval version of a function f is an
algorithm fˆ that produces a larger set fˆ(X1 , X2 , . . . ) which is guaranteed to
contain the exact image set of f :
f (X1 , X2 , . . . ) ⊂ fˆ(X1 , X2 , . . . ).
If we think about the intervals X1 , X2 etc. as incorporating the inaccuracies in x1 ,

x2 etc. caused by round-off, the interval version fˆ of the function f provides
verified upper and lower bounds for the result y = f (x1 , x2 , . . . ) in which the
round-off errors of x1 , x2 etc. have propagated. Alternatively, you can also regard
X1 , . . . as imprecise measurements or in some other way underdetermined
quantity (“this parameter is somewhere between 0 and 1,” “this resistor has a
tolerance of 10%”). In such a setting, the result fˆ(X1 , X2 , . . . ) is a set guaranteed
to contain all possible true results.
Floating-point intervals are created from exact numbers or floating-point
numbers using the function hull or its operator equivalent ...:
X1 := hull(PI)
3.141592653 . . . 3.141592654
X2 := cos(7*PI/9 ... 13*PI/9)
−1.0 . . . − 0.1736481776
4-94
Interval Arithmetic
Complex intervals are rectangular areas in the complex plain consisting of an

interval for the real part and an interval for the imaginary part. Using hull or ...,
you may specify the rectangle by its “lower left” and “upper right” corners:
X3 := (2 - 3*I) ... (4 + 5*I)
(2.0 . . . 4.0) + i (−3.0 . . . 5.0)
The MuPAD® functions that support interval arithmetic include the basic
arithmetical operations +, -, *, /, ^ as well as most of the special functions such as
sin, cos, exp, ln, abs etc.:
X1^2 + X2
8.869604401 . . . 9.695956224
X1 - I*X2 + X3
(5.141592653 . . . 7.141592654) + i (−2.826351823 . . . 6.0)
sin(X1) + exp(abs(X3))
7.389056098 . . . 603.728285
When dividing by an interval containing 0, infinite intervals are produced. The

objects RD_INF and RD_NINF (“rounded infinity” and “rounded negative infinity,”
respectively) represent the values ±∞ in an interval context:
sin(X2^2 - 1/2)
−0.4527492553 . . . 0.4794255387
1/%
RD_NINF . . . − 2.208728094 ∪ 2.085829642 . . . RD_INF
The last example shows that the arithmetic may produce “symbolic” unions of
floating-point intervals. Actually, the union is still of type DOM_INTERVAL:
domtype(%)
DOM_INTERVAL
4-95
4 MuPAD® Objects
In fact, the functions union and intersect for creating unions and intersections of
sets can be used for creating intervals (which are, after all, a special kind of sets):
X1 union X2^2
0.0301536896 . . . 1.0 ∪ 3.141592653 . . . 3.141592654
cos(X1*X2) intersect X2
−1.0 . . . − 0.1736481776
Symbolic objects such as identifiers (Chapter 4.3) and floating point intervals can
be mixed. The function interval replaces all numerical subexpressions of an
expression (Chapter 4.4) by floating-point intervals:
interval(2*x^2 + PI)
(2.0 . . . 2.0) x2 + (3.141592653 . . . 3.141592654)
In MuPAD, identifiers are implicitly assumed to represent arbitrary complex

values. Consequently, the function hull replaces x by the interval representing
the whole complex plane:
hull(%)
(RD_NINF . . . RD_INF) + i (RD_NINF . . . RD_INF)
There is a number of specialized functions for floating-point intervals attached as

methods to the kernel domain DOM_INTERVAL. Here, we only mention
DOM_INTERVAL::center (the center of an interval or a union of intervals) and
DOM_INTERVAL::width (the width of an interval or a union of intervals):
DOM_INTERVAL::center(2 ... 5 union 7 ... 9)

5.5
DOM_INTERVAL::width(2 ... 5 union 7 ... 9)
7.0
See ?DOM_INTERVAL for a survey of the available methods.

Further, a library domain Dom::FloatIV exists which is just a façade for the
floating-point intervals of the kernel type DOM_INTERVAL. It is useful for
embedding floating-point intervals in “containers” such as matrices (Chapter
4.15) or polynomials (Chapter 4.16). These containers require the specificiation of
a coefficient domain that has the mathematical properties of a ring. In order to
4-96
Interval Arithmetic
make floating-point intervals embeddable in such containers, the domain

Dom::FloatIV was given a variety of mathematical attributes (“categories”)
required for such purposes:
Dom::FloatIV::allCategories()
[Cat::Field, ..., Cat::Ring, ...]
In particular, the set of all floating point intervals is not only regarded as a ring,
but even as a field. Strictly speaking, however, these mathematical categories are
not really adequate for interval objects. For example, subtracting an interval from
itself does not yield the zero element (the neutral element with respect to
addition):
(2 ... 3) - (2 ... 3)
−1.0 . . . 1.0
Pragmatically, however, the mathematical categories were set, anyway, to enable

embedding. After all, the operations implied by these categories do work. For
example, we consider the inverse of a Hilbert matrix (also see Exercise 4.37).
These matrices are notoriously ill-conditioned. For the 8 × 8 Hilbert matrix, the
condition number (the ratio of the largest and the smallest eigenvalue) is
A := linalg::hilbert(8):
ev := numeric::eigenvalues(A):
max(op(ev))/min(op(ev))
15257575299.0
Roughly speaking, when inverting this matrix by a floating-point algorithm, one

should expect to loose about 10 decimal digits of accuracy:
log(10, %)
10.18348552
Consequently, with low values of DIGITS, the inverse should be substantially

marred by round-off. Indeed, after conversion of A to a matrix of floating-point
intervals, we can use the generic algorithm for matrix inversion:
4-97
4 MuPAD® Objects
B := 1/Dom::Matrix(Dom::FloatIV)(A)
array(1..8, 1..8,
(1, 1) = -73.29144677 ... 201.2914468,
...
(3, 2) = -955198.1290 ... -949921.8709,
...
(8, 8) = 176679046.2 ... 176679673.8
)
The entries of the inverse are guaranteed to lie in the indicated intervals. The
component (8, 8) is determined to a precision of 6 leading decimal digits, whereas
the component (1, 1) is only known to lie somewhere between −73.29 and 201.3.
Note, however, that the generic inversion algorithm tends to overestimate the
intervals drastically. The results returned by a numerical inversion with
“standard” floating-point numbers might actually be more accurate than
predicted by this interval computation.
The exact components of the inverse are available, too. All entries of inverse
Hilbert matrices are integers:
C := linalg::invhilbert(8)
array(1..8, 1..8,
(1, 1) = 64,
...
(3, 2) = -952560,
...
(8, 8) = 176679360
)
Using the operator in, it is possible to determine whether a number or expression

is inside an interval. To combine the matrices, we use zip (Chapter 4.15) and
check for each entry of the exact inverse C if it is inside the interval in the matrix B.
To this end, the following input converts both matrices into lists of their entries
and then performs the check:
zip([op(C)], [op(B)], (c, b) -> bool(c in b))
[TRUE, TRUE, TRUE, TRUE, ..., TRUE]
4-98
Null Objects: null(), NIL, FAIL, undefined
Null Objects: null(), NIL, FAIL, undefined

There are several objects representing the “void” in MuPAD ® . First, we have the
“empty sequence” generated by null(). It is of domain type DOM_NULL and
generates no output on the screen. System functions such as reset (Section 13.4),
print (Section 12.1), or if (Chapter 16) without an else branch, which cannot
return mathematically useful values, return this MuPAD object instead:
a := reset(): b := print("hello"):
"hello"
domtype(a), domtype(b)
DOM_NULL, DOM_NULL
The object null() is particularly useful in connection with sequences

(Section 4.5). The system automatically removes this object from sequences, and
you can use it, for example, to remove sequence entries selectively:
delete a, b, c:
Seq := a, b, c: Seq := subs(Seq, b = null())
a, c
Here we have used the substitution command subs (Chapter 6) to replace b by

null().
The MuPAD object NIL, which is distinct from null(), intuitively means “no
value.” Some system functions return the NIL object when you call them with
arguments for which they need not compute anything. A typical example are
uninitialized operands of arrays:
A := array(1..2): op(A, 1)
NIL
Uninitialized local variables and parameters of MuPAD procedures also have the
value NIL (Section 17.4).
The MuPAD object FAIL intuitively means “I could not find a value.” System
functions return this object when there is no meaningful result for the given input
parameters.
4-99
4 MuPAD® Objects
In the following example, we try to compute the inverse of a singular matrix:

A := matrix([[1, 2], [2, 4]])
!
1 2
2 4
A^(-1)
FAIL
Another object with a similar meaning is undefined. For example, the MuPAD
function limit returns this object when the requested limit does not exist:
limit(1/x, x = 0)
undefined
Arithmetical operations with undefined return again undefined:

undefined + 1, 2ûndefined
undefined, undefined
4-100
5
Evaluation and Simplification
Identifiers and Their Values

Consider:
delete x, a: y := a + x
a+x
Since the identifiers a and x only represent themselves, the “value” of y is the
symbolic expression a + x. We have to distinguish carefully between the identifier
y and its value. More precisely, the value of an identifier denotes the MuPAD®
object that the system computes by evaluation and simplification of the
right-hand side of the assignment identifier:= value at the time of assignment.
Note that in the example above, the value of y is composed of the symbolic
identifiers a and x, which may be assigned values at a later time. For example, if
we assign the value 1 to the identifier a, then a is replaced by its value 1 in the
expression a + x, and the call y returns x + 1:
a := 1: y
x+1
We say that the evaluation of the identifier y returns the result x + 1, but its value
is still a + x:
We distinguish between an identifier, its value, and its evaluation: the

value denotes the evaluation at the time of assignment, a later
evaluation may return a different “current value”.
5 Evaluation and Simplification
If we now assign the value 2 to x, then both a and x are replaced by their values at
the next evaluation of y. Hence we obtain the sum 2 + 1 as a result, which MuPAD
automatically simplifies to 3:
x := 2: y
3
The evaluation of y now returns the number 3; its value is still a + x.

It is reasonable to say that the value of y is the result at the time of assignment.
Namely, if we delete the values of the identifiers a and x in the above example,
then the evaluation of y yields its original value immediately after the assignment:
delete a, x: y
a+x
If a or x already have a value before we assign the expression a + x to y, then the

following happens:
x := 1: y := a + x: y
a+1
At the time of assignment, y is assigned the evaluation of a + x, i.e., a + 1. Indeed,

this is now the value of y, which contains no reference to x:
delete x: y
a+1
Here are some further examples for this mechanism. We first assign the rational
number 1/3 to x, then we assign the object [x, x^2, x^3] to the identifier list. In
the assignment, the system evaluates the right-hand side and automatically
replaces the identifier x by its value. Thus, at the time of assignment, the identifier
list gets the value [1/3, 1/9, 1/27] and not [x, x2 , x3 ]:
x := 1/3: list := [x, x^2, x^3]

1 1 1
, ,
3 9 27
5-2
Identifiers and Their Values
delete x: list

1 1 1
, ,
3 9 27
MuPAD applies the same evaluation scheme to symbolic function calls:

delete f: y := f(PI)
f (π)
After the assignment

f := sin:
we obtain the evaluation

y
0
When evaluating y, the system replaced the identifier f by its value, which is the
value of the identifier sin. This is a procedure which is executed when y is
evaluated and returns sin(π) as 0.
5-3
Complete, Incomplete, and Enforced Evaluation

We consider once again the first example from the previous section. There we have
assigned the expression a + x to the identifier y, and a and x did not have a value:
delete a, x: y := a + x: a := 1: y
x+1
We now explain in greater detail how MuPAD® performs the final evaluation.
First (“level 1”) the evaluator considers the value a + x of y. Since this value
contains identifiers x and a, a second evaluation step (“level 2”) is necessary to
determine the value of these identifiers. The system recognizes that a has the
value 1, while x has no value (and thus mathematically represents an unknown).
Now the system’s arithmetic combines these results to x + 1, and this is the
evaluation of y. Figures 5.1–5.3 illustrate this process. A box represents an
identifier and its value (or ·, respectively, if it has no value). An arrow represents
one evaluation step.
y · y y
+ x · a · + x · a
Figure 5.1: The identifier Figure 5.2: After the as- Figure 5.3: After the as-
y without a value. signment y:= a + x. signment a:= 1, we finally
obtain x + 1 as the evalua-
tion of y.
In analogy to the expression trees for representing symbolic expressions

(Section 4.4), you may imagine the process of evaluation as an evaluation tree,
whose vertices are expressions with symbolic identifiers, with branches pointing
to the corresponding values of these identifiers. The system traverses this tree
until there are either no identifiers left or all remaining identifiers have no value.
5-4
The user may control the levels of this tree via the system function level. We look
at an example:
delete a, b, c: x := a + b: a := b + 1: b := c:
The evaluation tree for x is:
level 0 : x
level 1 : + a b
level 2 : + b 1 c ·
level 3 : c ·
The identifier x forms the top level (the root, level 0) of its own evaluation tree:
level(x, 0)
x
The next level 1 determines the value of x:

level(x, 1)
a+b
At the following level 2, a and b are replaced by their values b + 1 and c,

respectively:
level(x, 2)
b+c+1
5-5
The remaining b is replaced by its value c only in the next level 3:

level(x, 3)
2c + 1
We call the type of evaluation described here a complete evaluation. This means
that identifiers are replaced by their values recursively until no further evaluations
are possible. The environment variable LEVEL, which has the default value 100,
determines how far MuPAD descends at most in an evaluation tree.
In interactive mode, MuPAD always evaluates completely!
More precisely, this means that MuPAD evaluates up to depth LEVEL in interactive
mode.1
delete a0, a1, a2: LEVEL := 2:
a0 := a1: a0
a1
a1 := a2: a0
a2
Up to now, the evaluation tree for a0 has depth 2, and the LEVEL value of 2
achieves a complete evaluation. However, in the next step, the value of a2 is not
taken into account:
a2 := a3: a0
a2
To restore the default value of LEVEL, we use delete:

delete LEVEL:
As soon as MuPAD realizes that the current evaluation level exceeds the value of
the environment variable MAXLEVEL (whose default value is 100), then it assumes
to be in an infinite loop and aborts the evaluation with an error message:
1 One should not confuse this with the effect of a system function call, which may return a not com-
pletely evaluated object, such as subs (Chapter 6). The call subs(sin(x), x = 0), for example, returns
sin(0) and not 0! The functionality of subs is to perform a substitution and to return the resulting object
without further evaluation.
5-6
MAXLEVEL := 2: a0
Error: Recursive definition [See ?MAXLEVEL]
delete MAXLEVEL:
We now present some important exceptions to the rule of complete evaluation.

The calls last(i), %i, or % (Chapter 13.2) do not lead to an evaluation! We
consider the example
delete x: [sin(x), cos(x)]: x := 0:
Now, %2 accesses the list without evaluating it:

%2
[sin(x) , cos(x)]
However, you can enforce evaluation by means of eval:

eval(%)
[0, 1]
Compare this to the following statements, where requesting the identifier list
causes the usual complete evaluation:
delete x: list := [sin(x), cos(x)]: x := 0: list
[0, 1]
Arrays of domain type DOM_ARRAY are always evaluated with level 1:

delete a, b: A := array(1..2, [a, b]):
b := a: a := 1: A

a b
As you can see, the call of A returns the value (the array), but does not replace a, b
by their values. You can evaluate the entries via map(A, eval):
map(A, eval)

1 1
5-7
Note that in contrast to the above behavior, the indexed access of an individual
entry is evaluated completely:
A[1], A[2]
1, 1
Matrices (of type Dom::Matrix(·)), tables (of domain type DOM_TABLE), and
polynomials (DOM_POLY) are treated in the same way as arrays. Moreover, within
procedures, MuPAD always evaluates only up to level 1 (Section 17.11). If this is
not sufficient, you may control this behavior explicitly by means of level.
The command hold(object) is similar to level(object, 0) and prevents the
evaluation of object.2 This may be desirable in many situations. The following
function, which cannot be executed for symbolic arguments, yields an example
where the (premature) evaluation is undesirable:
absValue := X -> (if X >= 0 then X else -X end_if):
absValue(X)
Error: Can't evaluate to boolean [_leequal];
during evaluation of 'absValue'
If you want to numerically integrate this function using numeric::int, the

obvious input returns the same error:
numeric::int(absValue(X), X = -1..1)
Error: Can't evaluate to boolean [_leequal];
during evaluation of 'absValue'
If you delay the evaluation of absValue(X) by hold, the value is computed:

numeric::int(hold(absValue)(X), X = -1..1)
1.0
The reason is that numeric::int internally substitutes numerical values for X, for
which absValue can be evaluated without problems.
2 See ?hold for the exact difference between hold(object) and level(object, 0).
5-8
Here is another example: like most MuPAD functions, the function domtype first
evaluates its argument, so that the command domtype(object) returns the
domain type of the evaluation of object:
x := 1: y := 1: x, x + y, sin(0), sin(0.1)
1, 2, 0, 0.09983341665
domtype(x), domtype(x + y), domtype(sin(0)),
domtype(sin(0.1))
DOM_INT, DOM_INT, DOM_INT, DOM_FLOAT
Using hold, you obtain the domain types of the objects themselves: x is an
identifier, x + y is an expression, and sin(0) and sin(0.1) are function calls and
hence expressions as well:
domtype(hold(x)), domtype(hold(x + y)),
domtype(hold(sin(0))), domtype(hold(sin(0.1)))
DOM_IDENT, DOM_EXPR, DOM_EXPR, DOM_EXPR
The commands ?level and ?hold provide further information from the
corresponding help pages.
Exercise 5.1: What are the values of the identifiers x, y, and z after the following
statements? What is the evaluation of the last statement in each case?
delete a1, b1, c1, x:
x := a1: a1 := b1: a1 := c1: x
delete a2, b2, c2, y:
a2 := b2: y := a2: b2 := c2: y
delete a3, b3, z:
b3 := a3: z := b3: a3 := 10: z
Predict the results of the following statement sequences:

delete u1, v1, w1:
u1 := v1: v1 := w1: w1 := u1: u1
delete u2, v2:
u2 := v2: u2 := u2^2 - 1: u2
5-9
Automatic Simplification
MuPAD® automatically simplifies many objects such as certain function calls or
arithmetical expressions with numbers:
sin(15*PI), exp(0), (1 + I)*(1 - I)
0, 1, 2
The same holds true for arithmetic expressions containing infinity:

2*infinity - 5
∞
Such automatic simplifications serve for reducing the complexity of expressions

without an explicit request by the user:
cos(1 + exp((-1)^(1/2)*PI))
1
The user can neither control nor extend the automatic simplifier.
In most cases, however, MuPAD does not automatically simplify expressions. The
reason is that the system generally cannot decide which is the most reasonable
way of simplification. For example, consider the following expression which is not
simplified:
y := (-4*x + x^2 + x^3 - 4)*(7*x - 5*x^2 + x^3 - 3)

− x3 − 5 x2 + 7 x − 3 −x3 − x2 + 4 x + 4
Naturally, you can expand this expression, which may be reasonable, for example,
before computing its symbolic integral:
expand(y)
x6 − 4 x5 − 2 x4 + 20 x3 − 11 x2 − 16 x + 12
5-10
Automatic Simplification
However, if you are interested in the roots of the polynomial, it makes more sense
to compute its linear factors:
factor(y)
2
(x − 3) · (x − 1) · (x − 2) · (x + 2) · (x + 1)
No universal answer is possible to the question which of the two representations is

“simpler.” Depending on the intended application, you can selectively apply
appropriate system functions (such as expand or factor) to simplify an
expression.
There is another argument against automatic simplification. The symbol f , for
example, might represent a bounded function, for which the limit lim x→0 x f (x) is
0. However, simplifying this expression to 0 can be wrong for functions f with a
singularity at the origin such as f (x) = 1/x! Thus, automatic simplifications such
as 0 · f (0) = 0 are questionable as long as the system has no additional knowledge
about the symbols involved. In general, MuPAD cannot know which rule can be
applied and which must not. Now you might object that MuPAD should perform
no simplifications at all instead of wrong ones. Unfortunately, this is not
reasonable either, since in symbolic computations, expressions tend to grow very
quickly, and this seriously affects the performance of the system. In fact, in most
cases MuPAD simplifies an expression of the form 0 * y to 0, except, e.g., when the
value of y is infinity, FAIL, or undefined. You should always keep in mind that
such a simplified result may be wrong in extreme cases.
For that reason, MuPAD performs only some simplifications automatically, and
you must explicitly request other simplifications yourself. For this purpose
MuPAD provides a variety of functions, some of which are described in
Section 9.2.
While the automatic simplifications have been carefully chosen, there are still
examples where they lead to unexpected results, usually because of ambiguities in
mathematical notation. An example is the solution of the equation x/x = 1 for
x ̸= 0:
solve(x/x = 1, x)
C
5-11
The MuPAD equation solver solve (Chapter 8) returns the set C of all complex
numbers.3 Thus, solve claims that arbitrary complex values of x yield a solution
of the equation x/x = 1. The reason is that the system first automatically
simplifies the expression x/x to 1, and then in fact solves the equation 1 = 1. The
exceptional case x = 0, for which the original problem makes no sense, is
completely ignored in the simplified output!
3 To enter this set, type “C_.”
5-12
Evaluation at a Point
Evaluation at a Point
There is also another concept commonly known as “evaluation,” namely replacing
some placeholder (free variable) by a specific value and simplifying the resulting
expression. This operation is implemented by the function evalAt, which is also
accessible as the | operator. (The | operator mimics the notation f (x)|x=1
commonly used in math texts.)
f := sin(x):
f | x=0, f | x=1
0, sin(1)
Note that, unlike subs, evalAt respects the mathematical meaning and only
substitutes free variables, not bound ones:
delete f:
F := int(f(x), x=0..infinity) + sin(x):
subs(F, x = 1), F | x=1
Z ∞ Z ∞
sin(1) + f (1) d1, sin(1) + f (x) dx
0 0
5-13
6
Substitution: subs, subsex, and

subsop
All MuPAD® objects consist of operands (Section 4.1). An important feature of a

computer algebra system is that it can replace these building blocks by new
values. For that purpose, MuPAD provides the functions subs, subsex (short for:
substitute expression), and subsop (short for: substitute operand).
The command subs(object, Old = New) replaces all occurrences of the
subexpression Old in object by the value New:
f := a + b*c^b: g := subs(f, b = 2): f, g
a + b cb , 2 c2 + a
You see that subs returns the result of the substitution, but the identifier f
remains unchanged. If you represent a map F by the expression f = F (x), then
you may use subs to evaluate the function at some point:
f := 1 + x + x^2:
subs(f, x = 0), subs(f, x = 1),
subs(f, x = 2), subs(f, x = 3)
1, 3, 7, 13
Note, however, that subs (as well as the commands subsex and subsop to be
handled shortly) performs a purely syntactical replacement, which may lead to
incorrect results when evaluating a function in this way:
f := x/sin(x): subs(f, x = 0)
0
6 Substitution: subs, subsex, and subsop
delete g: G := int(g(x), x=0..infinity):

subs(G, x=0)
Z ∞
g(0) d0
0
To get substitutions respecting mathematical meaning, use the | operator or its

equivalent function evalAt instead, which has already been described at the end
of Chapter 5:
f | x=0
Error: Division by zero [_power];
during evaluation of 'evalAt'
G | x=0
Z ∞
g(x) dx
0
The output of the subs command is subjected to the usual simplifications of the
internal simplifier. In the above example, the call subs(f, x = 0) produces the
object 1 + 0 + 0^2, which is automatically simplified to 1. You must not confuse this
with evaluation (Chapter 5), where in addition all identifiers in an expression are
replaced by their values.
The function subs performs a substitution. The system only simplifies

the resulting object, but does not evaluate it upon return!
In the following example

f := x + sin(x): g := subs(f, x = 0)
sin(0)
the identifier sin for the sine function is not replaced by the corresponding
MuPAD function, which would return sin(0) = 0. Only the next call to g performs
a complete evaluation:
g
0
6-2
You can enforce evaluation by using eval:

eval(subs(f, x = 0))
0
You may replace arbitrary MuPAD objects by substitution. In particular, you can
substitute functions or procedures as new values:
eval(subs(h(a + b), h = (x -> 1 + x^2)))
2
(a + b) + 1
If you want to replace a system function, enclose its name in a hold command:
eval(subs(sin(a + b), hold(sin) = (x -> x - x^3/3)))
3
(a + b)
a+b−
3
You can also replace more complex subexpressions:

subs(sin(x)/(sin(x) + cos(x)), sin(x) + cos(x) = 1)
sin(x)
You should be careful with such substitutions: the command

subs(object,Old = New) replaces all those occurrences of the expression Old that
can be found by means of op. This explains why nothing happens in the following
example:
subs(a + b + c, a + b = 1), subs(a * b * c, a * b = 1)
a + b + c, a b c
Here the sum a + b and the product a * b are not operands of the corresponding
expressions. Even worse, we find:
f := a + b + sin(a + b): subs(f, a + b = 1)
a + b + sin(1)
Again, you cannot obtain the subexpression a + b of the outer sum by means of op.
However, the argument of the sine is the sub-operand op(f, [3, 1]) (see
Sections 4.1 and 4.4), and hence it is replaced by 1.
6-3
In contrast to subs, the function subsex also replaces subexpressions in sums and
products:
subsex(f, a + b = x + y), subsex(a * b * c, a * b = x + y)
x + y + sin(x + y) , c (x + y)
This kind of substitution requires a closer analysis of the expression tree, and
hence subsex is much slower than subs for large objects. When replacing more
complex subexpressions, you should not be misled by the screen output of
expressions:
f := a/(b*c)
a
bc
subs(f, b*c = New), subsex(f, b*c = New)
a a
,
b c New
If you look at the operands of f, you see that the expression tree does not contain
the product b*c. This explains why no substitution took place in the subs call:
op(f)
1 1
a, ,
b c
You can perform several substitutions with a single call of subs:

subs(a + b + c, a = A, b = B, c = C)
A+B+C
This is equivalent to the nested call

subs(subs(subs(a + b + c, a = A), b = B), c = C):
Thus we obtain:
subs(a + b^2, a = b, b = a)
a2 + a
First, MuPAD replaces a by b, yielding b + b^2. Then it substitutes a for b in this

new expression and returns the above result. In contrast, you may achieve a
6-4
simultaneous substitution by specifying the substitution equations in form of a

list or a set:
subs(a + b^2, [a = b, b = a]),
subs(a + b^2, {a = b, b = a})
a2 + b, a2 + b
The output of the equation solver solve (Chapter 8) supports the functionality of
subs. In general, solve returns lists of equations, which may be used in subs:
equations := {x + y = 2, x - y = 1}:
solution := solve(equations, {x, y})

3 1
x = ,y =
2 2
subs(equations, op(solution, 1))

{1 = 1, 2 = 2}
The function subsop provides another variant of substitution:

subsop(object, i = New) selectively replaces the i-th operand of the object by the
value New:
subsop(2*c + a^2, 2 = d^5)
d5 + 2 c
Here, we have replaced the second operand a^2 of the sum by d^5. In the
following example, we first replace the exponent of the second term (this is the
operand [2, 2] of the sum), and then the first term:
subsop(2*c + a^2, [2, 2] = 4, 1 = x*y)
a4 + x y
In the following expression, we first replace the first term, yielding the expression
x * y + c^2. Then we substitute z for the second factor of the first term (which now
is y):
subsop(a*b + c^2, 1 = x*y, [1, 2] = z)
c2 + x z
6-5
The expression a + 2 is a symbolic sum, which has a 0-th operand, namely, the
system function _plus for generating sums:
op(a + 2, 0)
_plus
You can replace this operand by any other function (for example, by the system
function _mult which multiplies its arguments):
subsop(a + 2, 0 = _mult)
2a
When using subsop, you need to know the position of the operand that you want
to replace. Nonetheless, you should be cautious, since the system may change the
order of the operands when this is mathematically valid (for example, in sums,
products, or sets):
set := {sin(1 + a), a, b, c^2}

a, b, sin(a + 1) , c2
If you use subs, you need not know the position of the subexpression. Another
difference between subs and subsop is that subs traverses the expression tree of
the object recursively, and thus also replaces suboperands:
subs(set, a = a^2)

b, sin a2 + 1 , a2 , c2
6-6
Exercise 6.1: Does the command subsop(b + a, 1 = c) replace

the identifier b by c?
Exercise 6.2: The commands

delete f: g := diff(f(x)/diff(f(x), x), x $ 5)
25 diff(f(x), x, x) diff(f(x), x, x, x, x)
------------------------------------------ -
2
diff(f(x), x)
4 diff(f(x), x, x, x, x, x)
--------------------------- - ...
diff(f(x), x)
generate a lengthy expression containing symbolic derivatives. Make this

expression more readable by replacing these derivatives by simpler names
f0 = f (x), f1 = f ′ (x), etc.
6-7
7
Differentiation and Integration
We have already used the MuPAD® commands for differentiation and integration.
Since they are important, we recapitulate the usage of these routines here.
7 Differentiation and Integration
Differentiation
The call diff(expression, x) computes the derivative of the expression with
respect to the unknown x:
diff(sin(x^2), x)

2 x cos x2
If the expression contains symbolic calls to functions whose derivative is not

known, then diff returns itself symbolically:
diff(x*f(x), x)
∂
f (x) + x f (x)
∂x
You may compute higher derivatives via diff(expression, x, x, ...). The

sequence x, x, ... of identifiers may be generated conveniently via the sequence
operator $ (Section 4.5):
diff(sin(x^2), x, x, x) = diff(sin(x^2), x $ 3)

−12 x sin x2 − 8 x3 cos x2 = −12 x sin x2 − 8 x3 cos x2
You can compute partial derivatives in the same way. MuPAD ® assumes that
mixed partial derivatives of symbolic expressions are symmetric:
diff(f(x,y), x, y) - diff(f(x,y), y, x)
0
If a mathematical map is represented by a function instead of an expression, then

the differential operator D computes the derivative as a function:
D(sin), D(exp), D(ln), D(sin*cos), D(sin@ln), D(f+g)
1 cos ◦ ln ′
cos, exp, , cos2 − sin2 , , f + g′
id id
f := x -> (sin(ln(x))): D(f)
cos(ln(x))
x→
x
7-2
Differentiation
Here, id denotes the identity map x → x. The expression D(f)(x) returns the
value of the derivative at a point:
D(f)(1), D(f)(y^2), D(g)(0)

cos ln y 2
1, , g ′ (0)
y2
The system converts the prime ' for the derivative to a call of D:
f'(1), f'(y^2), g'(0)

cos ln y 2
1, , g ′ (0)
y2
For a function with more than one argument, D([i], f) is the partial derivative
with respect to the i-th argument, and D([i, j, ...], f) is equivalent to
D([i], D([j], ...)), for higher partial derivatives.
Exercise 7.1: Consider the function f : x → sin(x)/x. Compute first the value of
f at the point x = 1.23, and then the derivative f ′ (x). Why does the following
input not yield the desired result?
f := sin(x)/x: x := 1.23: diff(f, x)
Exercise 7.2: De l’Hospital’s rule states that
f (x) f ′ (x) f (k−1) (x) f (k) (x0 )

lim = lim ′ = · · · = lim (k−1) = (k) ,
x→x0 g(x) x→x0 g (x) x→x0 g (x) g (x0 )
if f (x0 ) = g(x0 ) = · · · = f (k−1) (x0 ) = g (k−1) (x0 ) = 0 and g (k) (x0 ) ̸= 0. Compute
x3 sin(x)
lim by applying this rule interactively. Use the function limit to
x→0 (1 − cos(x))2
check your result.
Exercise 7.3: Determine the first and second order partial derivatives of
f1 (x1 , x2 ) = sin(x1 x2 ) . Let x = x(t) = sin(t), y = y(t) = cos(t), and
f2 (x, y) = x2 y 2 . Compute the derivative of f2 (x(t), y(t)) with respect to t.
7-3
Integration
The function int features both definite and indefinite integration:
int(sin(x), x), int(sin(x), x = 0..PI/2)
− cos(x) , 1
If int is unable to compute a result, it returns itself symbolically. In the following

example, the integrand is split into two terms. Only one of these has an integral
that can be respresented by elementary functions:
int((x - 1)/(x*sqrt(x^3 + 1)), x)
Z
x−1
√ dx
x x3 + 1
Z x
The function Si(x) = sin(t)/t dt is implemented as a special function in
0
MuPAD:
int(sin(a*x)/x, x)
Si(a x)
While integrating, the integration variable itself is assumed to be real. Other than
this, all computations take place over the complex numbers, and the system
regards every symbolic parameter in the integrand as a complex number unless
told otherwise. In the following example, the definite integral exists only for
specific ranges of the parameter a, and the system returns a symbolic limit call:
int(sin(a*x)/x, x = 0..infinity)
lim Si(x a)
x→∞
You can tell the system that an identifier has certain properties by using the
operator assuming (Section 9.3). The following call stipulates that a be a positive
real number:
int(sin(a*x)/x, x = 0..infinity) assuming a > 0
π
2
7-4
Integration
Besides the exact computation of definite integrals, MuPAD also provides several
numerical methods:
float(int(sin(x)/x, x = 0..2))
1.605412977
In the previous computation, int first returns a symbolic result (the error
function erf), which is then approximated by float. If you want to compute
numerically from the beginning, then you can suppress the symbolic computation
via int by using hold (Section 5.2):
float(hold(int)(sin(x)/x, x = 0..2))
1.605412977
Alternatively, the function numeric::int from the numeric library can be used:
numeric::int(sin(x)/x, x = 0..2)
1.605412977
This function allows you to choose different numerical methods for computing the
integral. You find more detailed information using ?numeric::int. It works in a
purely numerical fashion without any symbolic preprocessing of the integrand.
For smooth integrands without singularities, numeric::int is quite efficient.
Exercise 7.4: Compute the following integrals:

Z π/2 Z 1 Z 1
dx
sin(x) cos(x) dx , ,√ x arctan(x) dx .
0 0 1 − x2 0
Z −1
dx
Use MuPAD to verify the following equality: = − ln(2) .
−2 x
Exercise 7.5: Use MuPAD to determine the following indefinite integrals:

Z x Z xp Z x
t dt dt
q , t2 − a2 dt , √ .
(2 a t − t2 )
3 t 1 + t2
7-5
Exercise 7.6: The function intlib::changevar performs a change of variable in

a symbolic integral. Read the corresponding help page. MuPAD cannot compute
the integral
Z π/2 p
sin(x) 1 + sin(x) dx.
−π/2
Assist the system by using the substitution t = sin(x). Compare the value that you
get to the numerical result returned by the function numeric::int.
7-6
8
Solving Equations: solve
The function solve solves equations, inequalities, systems of these, differential

equations, recurrence equations etc. This routine can handle various different
types of equations. Besides “algebraic” equations, also certain classes of
differential and recurrence equations can be solved. Further, there is a variety of
specialized solvers that only handle special classes of equations. Many of these
algorithms are actually called by the “universal” solve once it has identified the
type of the equations. The user can also call the specialized solvers directly. You
can find a survey of all available MuPAD® solvers in in the “Quick Reference” in
the online documentation.
8 Solving Equations: solve
Polynomial Equations
You can supply an individual equation as first argument to solve. The unknown
for which you want to solve is the second argument:
solve(x^2 + x = y/4, x), solve(x^2 + x - y/4 = 0, y)
√ √
y+1 1 y+1 1
− − , − , 4 x2 + 4 x
2 2 2 2
In this case, the system returns a set of solutions. If you specify an expression
instead of an equation, then solve assumes the equation expression = 0:
solve(x^2 + x - y/4, y)

4 x2 + 4 x
For polynomials of higher degree, it is provably impossible to always find a closed

form for the solutions by means of radicals etc. In such cases, MuPAD ® uses the
RootOf object:
solve(x^7 + x^2 + x, x)
{0} ∪ RootOf(X16 + X1 + 1, X1)
The above RootOf object represents all solutions of the equation x^6 + x + 1 = 0.
You can use float to approximate such objects by floating-point numbers. The
system internally employs a numerical procedure to determine all (complex) roots
of the polynomial:
float(%)
{0.0, - 0.1547351445 + 1.038380754 I,
- 0.7906671888 + 0.3005069203 I,
0.9454023333 - 0.6118366938 I,
0.9454023333 + 0.6118366938 I,
- 0.7906671888 - 0.3005069203 I,
- 0.1547351445 - 1.038380754 I}
8-2
If you want to solve a collection of equations for possibly several unknowns,

specify both the equations and the unknowns as sets or lists. In the following
example, we solve two linear equations in three unknowns:
delete x, y, z:
equations := {x + y + z = 3, x + y = 2}:
solution := solve(equations, {x, y, z})
{[x = 2 − z1, y = z1, z = 1]}
If you solve equations for several variables, then MuPAD returns a set of “solved
equations” equivalent to the original system of equations. You can now read off
the solutions immediately: the unknown z has the value 1, the unknown y may be
arbitrary (indicated by the new indeterminate z1) and, for any given value of y , we
have x = 2 − y . It is possible to get a clearer indication of the new parameter not
present in the input by giving the option VectorFormat to the solve command:
solve(equations, {x, y, z}, VectorFormat)
    
 
x  2 − z1 
   
 y  ∈  z1  z1 ∈ C

 

z 1
However, this return format is more difficult to use in subsequent commands.

The call to solve does not assign the values to the unknowns; x, y , and z are still
unknowns. However, the form of the output as a list of solved equations is chosen
in such a way that you can conveniently use | (Chapter 5.4) to substitute these
values in other objects. For example, you may substitute the solution in the
original equations to verify the result:
equations | solution[1]
{2 = 2, 3 = 3}
You can use assign(solution[1]) to assign the solution values to the identifiers
x, y, and z.
8-3
In the next example, we solve two nonlinear polynomial equations in several

unknowns:
equations := {x^2 + y = 1, x - y = 2}:
solutions := solve(equations, {x, y})
(" √ √ # " √ √ #)
13 1 13 5 13 1 13 5
x=− − ,y = − − , x= − ,y = −
2 2 2 2 2 2 2 2
MuPAD found two distinct solutions. Again, you can use | to substitute the
solutions in other expressions:
map(equations | solutions[1], expand),
map(equations | solutions[2], expand)
{1 = 1, 2 = 2} , {1 = 1, 2 = 2}
Often, solutions are represented by RootOf expressions:

solve({x^3 + x^2 + 2*x = y, y^2 = x^3}, {x, y})
+- -+ { +- -+ }
| x | { | 0 | }
| | in { | | } union
| y | { | 0 | }
+- -+ { +- -+ }
{ +- -+ |
{ | 3 | |
{ | - z + 4 z + 4 | |
{ | | | z in
{ | z | |
{ +- -+ |
}
}
4 3 2 }
RootOf(z1 - 3 z1 - 2 z1 + 5 z1 + 8, z1) }
}
}
8-4
If you use the option MaxDegree = n, then RootOf expressions for polynomials of
degree up to n are replaced by representations in terms of radicals if this is
possible. Note that such solutions tend to be rather complicated:
solve({x^3 + x^2 + 2*x = y, y^2 = x^3}, {x, y},
MaxDegree = 4)
 s 13


√ √
√ √ 2

3485 3 73 5 i
129 54 +

  18
+9 3485
+ 3 73 5 i 3
+ 145
  4 54 18
x = 7 +  + ...
  √ √ 1

  3485 3 73 5 i 6

 6 54 + 18
Specifying the unknowns to solve for is optional. For the special case where you
have one unknown, however, the format of the output depends on whether you
specify the unknown or not. The general rule is as follows:
A call of the form solve(equation, unknown), where unknown is an

identifier, returns a MuPAD object representing a set of numbers. All
other forms of solve for (one or several) polynomial equations,
without special options like VectorFormat, return a set of lists of
equations or an expression involving RootOf.
Here are some examples:

solve(x^2 - 3*x + 2 = 0, x), solve(x^2 - 3*x + 2, x)
{1, 2} , {1, 2}
solve(x^2 - 3*x + 2 = 0), solve(x^2 - 3*x + 2)

{[x = 1] , [x = 2]} , {[x = 1] , [x = 2]}
solve({x^2 - 3*x + 2 = 0}, x),

solve({x^2 - 3*x + 2}, x)
{1, 2} , {1, 2}
solve({x^2 - 3*x + y = 0, y - 2*x = 0}, {x, y})

{[x = 0, y = 0] , [x = 1, y = 2]}
solve({x^2 - 3*x + y = 0, y - 2*x = 0})

{[x = 0, y = 0] , [x = 1, y = 2]}
8-5
If you do not supply unknowns to solve for, solve internally uses the system
function indets to find the symbolic identifiers in the equations and regards all of
them as unknowns:
solve({x + y^2 = 1, x^2 - y = 0})
! ( ! )

x 1 − z2
∈ z ∈ RootOf(z1 − 2 z1 − z1 + 1, z1)
4 2
y z
By default, solve tries to find all complex solutions of the given equation(s). If
you want to find only the real solutions of a single equation, use the option
Domain = Dom::Real or assume x to be real:
solve(x^3 + x = 0, x)
{0, −i, i}
solve(x^3 + x = 0, x) assuming x in R_
{0}
Other assumptions, such as x > 0, x in Q_, x in Z_ and x > 2, etc., are handled as well.
In some (usually exotic) cases, the “real solutions” may include unexpected values:
solve(ln(x)^4=PI^4, x) assuming x in R_

−1, e−π , eπ
When replacing the x in our input by −1, we get an ln(−1), which is π i, a complex
value. In the end, we get a real-valued result, but a common request is to find
solutions for a problem restricted to the reals, including all intermediate values
(“solving over the reals”). To make solve tackle this problem, use the option Real
instead of the assumption:
solve(ln(x)^4=PI^4, x, Real)

e−π , eπ
Of course, using the option saves a bit of typing, too.
8-6
If all complex numbers satisfy a given equation, then solve returns C, the set of
all complex numbers:
solve(sin(x) = cos(x - PI/2), x)
C
domtype(%)
solvelib::BasicSet
There are four such “basic sets”: the integers Z (entered as Z_ in MuPAD input),
the rational numbers Q (Q_), the real numbers R (R_), and the complex numbers C
(C_).
You can use the function float to find numerical solutions. However, with a
statement of the form float(solve(equations, unknowns)), solve first tries to
solve the equations symbolically. If an exact solution is found, float converts the
result to floating-point approximations. If you want to compute in a purely
numerical way, you can use hold (Section 5.2) to avoid symbolic preprocessing:
float(hold(solve)({x^3 + x^2 + 2*x = y, y^2 = x^2},
{x, y}))
{[x = - 0.5 + 1.658312395 I, y = 0.5 - 1.658312395 I],
[x = - 0.5 - 1.658312395 I, y = 0.5 + 1.658312395 I
], [x = - 0.5 + 0.8660254038 I,
y = - 0.5 + 0.8660254038 I], [x = 0.0, y = 0.0],
[x = - 0.5 - 0.8660254038 I,
y = - 0.5 - 0.8660254038 I]}
Alternatively, the library numeric provides various functions for numerical

equation solving such as numeric::solve1 , numeric::fsolve, or
numeric::realroots. The help system gives details about these routines: call
?solvers for a survey or see ?numeric::solve etc.
1 In fact, the calls float(hold(solve)(...)) and numeric::solve(...) are equivalent.
8-7
Exercise 8.1: Compute the general solution of the system of linear equations
a + b + c + d + e = 1,
a + 2b + 3c + 4d + 5e = 2,
a − 2b − 3c − 4d − 5e = 2,
a − b − c − d − e = 3.
How many free parameters does the solution have?
8-8
General Equations and Inequalities

solve can handle a variety of (non-polynomial) equations. For example, the
equation exp(x) = 8 has infinitely many solutions of the form ln(8) + 2 i π k with
k ∈ Z in the complex plane:
S := solve(exp(x) = 8, x)
{ ln(8) + π k 2 i| k ∈ Z}
The data type of the returned result is a so-called “image set.” It represents a
mathematical set of the form {f (x) | x ∈ A}, where A is some other set:
domtype(S)
Dom::ImageSet
This data type is capable of representing infinitely many elements.

If you omit the variable to solve for, the system returns a logical formula, using the
operator in:
solve(exp(x) = 8)
n o

x ∈ ln(8) + π k 2 i k ∈ Z
You can use map to apply a function to an image set:

map(S, _plus, -ln(8))
{ π k 2 i| k ∈ Z}
Alternatively, most arithmetical operations can be applied directly:

exp(S)
{8}
The function is (Section 9.3) can handle image sets:

S := solve(sin(PI*x/2) = 0, x)
{ 2 k| k ∈ Z}
8-9
is(1 in S), is(4 in S)

FALSE, TRUE
The equation exp(x) = sin(x) also has infinitely many solutions, which, however,
MuPAD® cannot represent exactly. In this case, it returns the call to solve
symbolically:
solutions := solve(exp(x) = sin(x), x)
solve(ex − sin(x) = 0, x)
Warning: In contrast to polynomial equations, the numerical solver computes at

most one solution of a non-polynomial equation:
float(solutions)
{−226.1946711}
However, you can specify a search range to select a particular numerical solution:
numeric::solve(exp(x) = sin(x), x = -10..-9)
{−9.424858654}
Using numeric::realroots, you can find enclosures for all real roots in a given
interval:
numeric::realroots(exp(x) = sin(x), x = -10..-5)
[[−9.43359375, −9.423828125] , [−6.2890625, −6.279296875]]
MuPAD has a special data type for the solution of parametric equations:
piecewise. For example, the set of solutions x ∈ C of the equation
(a x2 − 4) (x − b) = 0 takes on different forms, depending on the value of the
parameter a:
delete a: p := solve((a*x^2 - 4)*(x - b), x)
(
n {b} o if a = 0
b, − √2a , √2a if a ̸= 0
domtype(p)
piecewise
8-10
The function map applies a function to all branches of a piecewise object:

map(p, _power, 2)
(
b2 if a = 0
4 2
a, b if a ̸= 0
After the following substitution, the piecewise object is simplified to a set:

% | [a = 4, b = 2]
{1, 4}
The function solve can also handle inequalities. It then returns an interval or a
union of intervals, of domain type Dom::Interval:
solve(x^2 < 1, x)
(−1, 1) ∪ { x i| x ∈ (−∞, ∞)}
domtype(%)
DOM_EXPR
S := solve(x^2 >= 1, x)
[1, ∞) ∪ (−∞, −1]
is(-2 in S), is(0 in S)

TRUE, FALSE
8-11
Differential Equations
The function ode defines an ordinary differential equation. Such an object has two
components: an equation and the function to solve for.
diffEquation := ode(y'(x) = y(x)^2, y(x))

∂ 2
ode y(x) − y(x) , y(x)
∂x
The following call to solve finds the general solution containing an arbitrary
constant C3 :
solve(diffEquation)

1
0, −
C3 + x
Differential equations of higher order can be handled as well:

solve(ode(y''(x) = y(x), y(x)))

C6
C7 ex + x
e
You can specify initial conditions or boundary values by passing the differential
equation together with the initial/boundary conditions as a set when calling ode:
diffEquation :=
ode({y''(x) = y(x), y(0) = 1, y'(0) = 0}, y(x)):
MuPAD now adjusts the free constants in the general solution according to the
initial/boundary conditions:
solve(diffEquation)

1 ex
+
2 ex 2
8-12
Differential Equations
You can specify systems of equations with several functions in form of a set:
solve(ode({y'(x) = y(x) + 2*z(x), z'(x) = y(x)},
{y(x), z(x)}))

C12 e2 x C11 C11
z(x) = − x , y(x) = x + C12 e 2x
2 e e
The function numeric::odesolve of the numeric library solves the ordinary

differential equation Y ′ (x) = f (x, Y (x)) with the initial condition Y (x0 ) = Y0
numerically. You must supply the right-hand side of the differential equation as a
function f (x, Y ) of two arguments, where x is a scalar and Y is a vector. If you
combine the components y and z in the previous example to a vector Y = (y, z),
you can define the right-hand side of the equation

d d y y + 2z Y[1] + 2 · Y[2]
Y = = = =: f(x, Y)
dx dx z y Y [1 ]
in the form
f := (x, Y) -> [Y[1] + 2*Y[2], Y[1]]:
Note that f (x, Y ) must be a vector. Here, this is realized by means of a list
containing the components on the right-hand side of the differential equation.
The call
numeric::odesolve(0..1, f, [1, 1])
[9.729448318, 5.04866388]
integrates the system of differential equations with the initial values

Y (0) = (y(0), z(0)) = (1, 1) over the interval x ∈ [0, 1]; the initial conditions are
specified by the list [1, 1]. The numerical solver returns the numerical solution
vector Y (1) = (y(1), z(1)) as a list.
Exercise 8.2: Check the numerical solutions y(1) = 9.729 . . . and

z(1) = 5.048 . . . of the system of differential equations
y ′ (x) = y(x) + 2 z(x) , z ′ (x) = y(x)
computed above by substituting the initial values y(0) = 1, z(0) = 1 in the general
symbolic solution, determining the values for the free constants, and evaluating
the symbolic solution at x = 1.
8-13
Exercise 8.3:
1) Compute the general solution y(x) of the differential equation y ′ = y 2 /x .
2) Determine the solution y(x) for each of the following initial value problems:
a) y ′ − y sin(x) = 0 , y ′ (1) = 1,
y
b) 2 y′ + =0, y ′ (1) = π .
x
3) Find the general solution of the following system of ordinary differential
equations in x(t), y(t), z(t):
x′ = y z, y ′ = x z, z ′ = t z.
8-14
Recurrence Equations
Recurrence Equations
Recurrence equations are equations for functions depending on a discrete
parameter (an “index”). You can generate such an object with the function rec,
whose arguments are an equation, the function to be determined and, optionally,
a set of initial conditions:
equation := rec(y(n + 2) = y(n + 1) + 2*y(n), y(n)):
solve(equation)
n
{(−1) C1 + 2n C2}
The general solution contains two arbitrary constants (C1 , C2 in this case), which
are suitably adjusted when you specify initial conditions:
solve(rec(y(n + 2) = 2*y(n) + y(n + 1), y(n),
{y(0) = 1}))
n
{2n C4 − (−1) (C4 − 1)}
solve(rec(y(n + 2) = 2*y(n) + y(n + 1), y(n),

{y(0) = 1, y(1) = 1}))
n
(−1) 2 2n
+
3 3
Exercise 8.4: The Fibonacci numbers are defined by the recurrence

Fn = Fn−1 + Fn−2 with the initial values F0 = 0, F1 = 1. Use solve to find an
explicit representation for Fn .
8-15
9
Manipulating Expressions
When evaluating objects, MuPAD® automatically performs a variety of

simplifications. For example, arithmetic operations between integers are executed
or exp(ln(x)) is simplified to x. Other simplifications such as √
sin(x)2 + cos(x)2 = 1, ln(exp(x)) = x, (x2 − 1)/(x − 1) = x + 1, or x2 = x do not
happen automatically.
√ One reason is that many of these rules are not universally
valid: for example, x2 = x is wrong for x = −2. Other simplifications such as
sin(x)2 + cos(x)2 = 1 are valid universally, but there would be a significant loss of
efficiency if MuPAD would always scan expressions for the occurrence of sin and
cos terms.
Moreover, it is not clear in general which of several mathematically equivalent
representations is the most appropriate. For example, it might be reasonable to
replace an expression such as sin(x) by its complex exponential representation
i i
sin(x) = − exp(x i) + exp(−x i).
2 2
In such a situation, you can control the manipulation and simplification of

expressions by explicitly applying appropriate system functions. MuPAD provides
the following functions, which we have partly discussed in Section 2.4:
9 Manipulating Expressions
✞ ☎
collect : collecting coefficients
combine : combining subexpressions
expand : expansion
factor : factorization
normal : normalization of rational expressions
partfrac : partial fraction decomposition
radsimp : simplification of radicals
rectform : Cartesian representation of complex values
rewrite : applying mathematical identities
simplify : universal simplifier
Simplify : universal simplifier
✝ ✆
9-2
Transforming Expressions
If you enter the command collect(expression, unknown), the system regards
the expression as a polynomial in the specified unknown and groups the
coefficients of equal powers:
x^2 + a*x + sqrt(2)*x + b*x^2 + sin(x) + a*sin(x):
collect(%, x)
√
(b + 1) x2 + a + 2 x + (sin(x) + a sin(x))
You can specify several “unknowns,” which may themselves be expressions, as a

list:
collect(%, [x, sin(x)])
√
(b + 1) x2 + a + 2 x + (a + 1) sin(x)
The function combine(expression, option) combines subexpressions using

mathematical identities between functions indicated by option. The implemented
options are arctan, exp, ln, log, sincos, sinhcosh, and gamma.
By default, combine only employs the identities ab ac = ab+c , ac bc = (a b)c , and
(ab )c = abc for powers, where they are valid1 :
f := x^(n + 1)*x^PI/x^2: f = combine(f)
xπ xn+1
= xπ+n−1
x2
f := a^x*3^y/2^x/9^y: f = combine(f)
y
3y ax 1 a x
=
2x 9y 3 2
combine(sqrt(6)*sqrt(7)*sqrt(x))
√
42 x
1 An example where they are not is ((−1)2 )1/2 ̸= −1.
9-3
f := (PI^(1/2))^x: f = combine(f)
√ x x
π = π2
If |xy| < 1, the inverse arctan of the tangent function satisfies the following
identity:
f := arctan(x) + arctan(y):
f = combine(f, arctan) assuming 0 < x*y < 1

x+y
arctan(x) + arctan(y) = − arctan
xy − 1
For the exponential function, we have exp(x) exp(y) = exp(x + y):

combine(exp(x)*exp(y)^2/exp(-z), exp)
ex+2 y+z
Note, however, that the identity exp(x)y = exp(x y) known to hold for real values
of x does not hold throughout the complex plane. Consequently, without
additional assumptions on x, MuPAD® does not combine such terms:
combine(exp(x)^y, exp)
y
(ex )
combine(exp(x)^y, exp) assuming x in R_

ex y
With certain assumptions about x and y , the logarithm satisfies the rules
ln(x) + ln(y) = ln(x y) and x ln(y) = ln(y x ):
combine(ln(x) + ln(2) + 3*ln(3/2), ln)

27 x
ln
4
9-4
The trigonometric functions satisfy a variety of identities that the system employs
to combine products:
combine(sin(x)*cos(y), sincos),
combine(sin(x)^2, sincos)
sin(x − y) sin(x + y) 1 cos(2 x)
+ , −
2 2 2 2
Similar rules are applied to the hyperbolic functions:

combine(sinh(x)*cosh(y), sinhcosh),
combine(sinh(x)^2, sinhcosh)
sinh(x − y) sinh(x + y) cosh(2 x) 1
+ , −
2 2 2 2
The function expand applies the identities used by combine in the reverse
direction: it transforms special function calls with composite arguments to sums
or products of function calls with simpler arguments via “addition theorems:”
expand(x^(y + z)), expand(exp(x + y - z + 4)),
expand(ln(2*PI*x*y))
e 4 ex ey
xy xz , , ln(2) + ln(π) + ln(x y)
ez
expand(sin(x + y)), expand(cosh(x + y))
cos(x) sin(y) + cos(y) sin(x) , cosh(x) cosh(y) + sinh(x) sinh(y)
expand(sqrt(42*x*y))
√ √
42 xy
Here, the system does not perform certain “expansions” such as

ln(x y) = ln(x) + ln(y), since such an identity holds only under additional
assumptions (for example, for positive real x and y ).
The most frequent use of expand is for transforming a product of sums into a sum
of products:
expand((x + y)^2*(x - y)^2)
x4 − 2 x2 y 2 + y 4
9-5
The function expand works recursively for all subexpressions:

expand((x - y)*(x + y)*sin(exp(x + y + z)))
x2 sin(ex ey ez ) − y 2 sin(ex ey ez )
You can supply expressions as additional arguments to expand. These

subexpressions are not expanded:
expand((x - y)*(x + y)*sin(exp(x + y + z)),
x - y, x + y + z)

x sin ex+y+z (x − y) + y sin ex+y+z (x − y)
The function factor factors polynomials and expressions:

factor(x^3 + 3*x^2 + 3*x + 1)
3
(x + 1)
Here the system factors “over the rational numbers:” it looks for polynomial
factors with rational number
√coefficients.
√ In effect, MuPAD does not return the
factorization x2 − 2 = (x − 2) (x + 2):
factor(x^2 - 2)

x2 − 2
To extend the ring of constants over which to factor, you can explicitly adjoin
constants to the field of rational numbers:
factor(x^2 - 2, Adjoin = sqrt(2))
√ √
x− 2 · x+ 2
For sums of rational expressions, factor first computes a common denominator

and then factors both the numerator and the denominator:
f := (x^3 + 3*y^2)/(x^2 - y^2) + 3: f = factor(f)
x3 + 3 y 2 x2 · (x + 3)
+3=
x −y
2 2 (x − y) · (x + y)
MuPAD can factor not only polynomials and rational functions. For more general
expressions, the system internally replaces subexpressions such as symbolic
9-6
function calls by identifiers, factors the corresponding polynomial or rational

function, and re-substitutes the temporary identifiers:
factor((exp(x)^2 - 1)/(cos(x)^2 - sin(x)^2))

e2 x − 1
(cos(x) − sin(x)) · (cos(x) + sin(x))
The function normal computes a “normal form” for rational expressions. Like
factor, it first computes a common denominator for sums of rational expressions,
but it then expands numerator and denominator instead of factoring them:
f := ((x + 6)^2 - 17)/(x - 1)/(x + 1) + 1:
f, factor(f), normal(f)
2 2
(x + 6) − 17 2 · (x + 3) 2 x2 + 12 x + 18
+ 1, ,
(x − 1) (x + 1) (x − 1) · (x + 1) x2 − 1
Nevertheless, normal cancels common factors in numerator and denominator:

f := x^2/(x + y) - y^2/(x + y): f = normal(f)
x2 y2
− =x−y
x+y x+y
Like factor, normal can handle arbitrary expressions:

f := (exp(x)^2-exp(y)^2)/(exp(x)^3 - exp(y)^3):
f = normal(f)
e2 x − e2 y ex + e y
=
e3 x − e3 y e2 x + e2 y + e x e y
The function partfrac decomposes a rational expression into a polynomial part

plus a sum of rational terms in which the degree of the numerator is smaller than
the degree of the corresponding denominator (partial fraction decomposition):
f := x^2/(x^2 - 1): f = partfrac(f, x)
x2 1 1
= − +1
x −1
2 2 (x − 1) 2 (x + 1)
The denominators of the terms are the factors that MuPAD finds when factoring
9-7
the common denominator:

denominator := x^5 + x^4 - 7*x^3 - 11*x^2 - 8*x - 12:
factor(denominator)
2
(x − 3) · x2 + 1 · (x + 2)
partfrac(1/denominator, x)
250 − 250
9x 13
1 1 1
− − +
x2 + 1 25 (x + 2) 25 (x + 2)2 250 (x − 3)
Another function for manipulating expressions is rewrite. It employs identities

to eliminate certain functions completely from an expression and replaces them
by other functions. For example, you can always express sin and cos by tan with
the half argument:
2 tan(x/2) 1 − tan(x/2)2
sin(x) = , cos(x) = .
1 + tan(x/2)2 1 + tan(x/2)2
The trigonometric functions are also related to the complex exponential function:
i i
sin(x) = − exp(i x) + exp(−i x) ,
2 2
1 1
exp(i x) + exp(−i x) .
cos(x) =
2 2
You can express the hyperbolic functions and their inverse functions in terms of
the exponential function and the logarithm:
exp(x) − exp(−x) exp(x) + exp(−x)

sinh(x) = , cosh(x) = ,
2 2
p p
arcsinh(x) = ln(x + x2 + 1) , arccosh(x) = ln(x + x2 − 1) .
A call of the form rewrite(expression, target) employs these identities.
Table 9.1 lists the rules implemented in MuPAD.
rewrite(D(D(u))(x), diff)
∂2
u(x)
∂x2
9-8
✞ ☎
target : function(s) → rewritten
in terms of
andor : logical operators xor, ==>, <=> → and, or, not
arccos : inverse trig. functions → arccos
arccosh : inverse trig. functions, ln → arccosh
arccot : inverse trig. functions → arccot
arccoth : inverse trig. functions, ln → arccoth
arcsin : inverse trig. functions → arcsin
arcsinh : inverse trig. functions, ln → arcsinh
arctan : inverse trig. functions → arctan
arctanh : inverse trig. functions, ln → arctanh
bernoulli : euler → bernoulli
cos : exponential function exp, → cos
trig. and hyperbolic functions
cosh : exponential function exp, → cosh
cot : exponential function exp, → cot
coth : exponential function exp, → coth
diff : differential operator D → diff
D : differentiating function diff → D
exp : powers (^), trig. and hyperbolic → exp, ln
functions and their inverses,
polar angle arg, dawson
erf : dawson → erf
fact : Γ-function gamma, → fact
double factorial fact2,
binomial coefficients binomial,
β -function beta, pochhammer
gamma : factorial fact, → gamma
double factorial fact2,
binomial coefficients binomial,
β -function beta, pochhammer
✝ ✆
Table 9.1a: Targets of rewrite
9-9
✞ ☎
target : function(s) → rewritten
in terms of
harmonic : psi → harmonic
heaviside : sign → heaviside
Im : Re → Im
ln : inverse trig. and inverse hyperbolic → ln
functions, polar angle arg, log
lambertW : wrightOmega → lambertW
max : min, abs → max
min : max, abs → min
piecewise : sign, absolute value abs, → piecewise
step function heaviside,
maximum max, minimum min,
kroneckerDelta
psi : harmonic → psi
Re : Im → Re
sign : step function heaviside, → sign
absolute value abs
sin : exponential function exp, → sin
sincos : exponential function exp, → sin, cos
sinh : exponential function exp, → sinh
sinhcosh : exponential function exp, → sinh, cosh
tan : exponential function exp, → tan
tanh : exponential function exp, → tanh
✝ ✆
Table 9.1b: Targets of rewrite (cont.)
9-10
rewrite(sin(x)/cos(x), exp) = rewrite(tan(x), exp)

e−x i i ex i i
− ex 2 i i − i
2
e−x i
2
=−
+ ex i ex 2 i + 1
2 2
rewrite(arcsinh(x) - arccosh(x), ln)

p p
ln x + x2 + 1 − ln x + x2 − 1
For expressions representing complex numbers, you can easily compute real and
imaginary parts by using Re and Im:
z := 2 + 3*I: Re(z), Im(z)
2, 3
z := sin(2*I) - ln(-1): Re(z), Im(z)
0, sinh(2) − π
When an expression contains symbolic identifiers, MuPAD assumes all such

unknowns to be complex values. Re and Im are returned symbolically:
Re(a*b + I), Im(a*b + I)
ℜ(a b) , ℑ(a b) + 1
In such a case, you can use the function rectform (short for: rectangular form) to
decompose the expression into real and imaginary part. The name of this function
is derived from the fact that it computes the coordinates of the usual rectangular
(Cartesian) coordinate system. MuPAD decomposes the symbols contained in the
expression into their real and imaginary parts and expresses the final result
accordingly:
rectform(a*b + I)
ℜ(a) ℜ(b) − ℑ(a) ℑ(b) + ℑ(a) ℜ(b) i + ℑ(b) ℜ(a) i + i
rectform(exp(x))
cos(ℑ(x)) eℜ(x) + sin(ℑ(x)) eℜ(x) i
9-11
Again, you can extract the real and imaginary parts of the result with Re and Im,
respectively:
Re(%), Im(%)
cos(ℑ(x)) eℜ(x) , sin(ℑ(x)) eℜ(x)
As a basic principle, rectform regards all symbolic identifiers as representatives

of complex numbers. However, you can use assume (Section 9.3) to specify that an
identifier represents only real numbers:
assume(a in R_):
z := rectform(a*b + I)
a ℜ(b) + a ℑ(b) i + i
The results of rectform have a special data type:

domtype(z)
rectform
You can use the function expr to convert such an object to a “normal” expression
of domain type DOM_EXPR:
expr(z)
a ℑ(b) i + a ℜ(b) + i
9-12
Simplifying Expressions
In some cases, a transformation leads to a simpler expression:
f := 2^x*3^x/8^x/9^x: f = combine(f)
x
2x 3x 1
=
8x 9x 12
f := x/(x + y) + y/(x + y): f = normal(f)

x y
+ =1
x+y x+y
To this end, however, you must inspect the expression and decide yourself which
function to use for simplification. There are tools for applying various
simplification algorithms to an expression automatically: the functions simplify
and Simplify. These are universal simplifiers which MuPAD® uses to achieve a
representation of an expression that is as “simple” as possible:
f := 2^x*3^x/8^x/9^x: f = simplify(f)
x
2x 3x 1
=
8x 9x 12
f := (1 + (sin(x)^2 + cos(x)^2)^2)/sin(x):
f = simplify(f)
2
2 2
cos(x) + sin(x) +1 2
=
sin(x) sin(x)
f := x/(x + y) + y/(x + y) - sin(x)^2 - cos(x)^2:

f = simplify(f)
x 2 2 y
− sin(x) − cos(x) + =0
x+y x+y
f := (exp(x) - 1)/(exp(x/2) + 1): f = simplify(f)
ex − 1 x
x = e2 − 1
e2 + 1
9-13
f := sqrt(997) - (997^3)^(1/6): f = simplify(f)

√ 1
997 − 991026973 6 = 0
Note that simplify operates in a purely heuristic way since there is no general
answer what “simple” means. You can control the simplification process by
supplying additional arguments. As in the case of combine, you can request
particular simplifications by means of options. For example, you can tell the
simplifier explicitly to simplify expressions containing square roots:
f := sqrt(4 + 2*sqrt(3)):
f = simplify(f, sqrt)
q
√ √ √
2 3+2= 3+1
The possible options are exp, ln, log, cos, sin, cosh, sinh, sqrt, gamma, unit,
condition, logic, and relation. Internally, simplify then confines itself to
those simplification rules that are valid for the function given as option. The
options logic and relation are for simplifying logical expressions and equations
and inequalities, respectively (see also the corresponding help page: ?simplify).
Instead of simplify(expression, sqrt), you may also use the function radsimp
to simplify numerical expressions containing square roots or other radicals:
f = radsimp(f)
q
√ √ √
2 3+2= 3+1
f := 2^(1/4)*2 + 2^(3/4) - sqrt(8 + 6*2^(1/2)):

f = radsimp(f)
q
1 √ √ 3
22 −4 2 3 2 + 4 + 24 = 0
In many cases, using simplify without options is appropriate. However, such a

call is often very time consuming, since the simplification algorithm is quite
complex. It may be useful to specify additional options to save computing time,
since then simplifications are performed only for special functions.
9-14
The second general simplifier, Simplify (note the capital S), is often slower than
simplify, but much more powerful and allows much finer tuning:
Simplify(1/(x+y) + 1/(x-y)),
Simplify(1/(x+y) + 1/(x-y), Valuation=length)
2x 1 1
, +
x2 − y 2 x − y x + y
f := gamma(n + n!/gamma(n+1)):
f, simplify(f), Simplify(f), Simplify(f, Steps = 200)

n! n! + n Γ (n + 1) n!
Γ n+ , Γ , Γ n+ , Γ (n + 1)
Γ (n + 1) Γ (n + 1) Γ (n + 1)
Here, we have used the option Steps to tell Simplify how many “elementary”
steps it may try before giving up the search for a simpler expression. In the end,
almost all of the steps have led nowhere; we can ask Simplify for a list of steps it
performed and see that only three steps were actually used:
Simplify(f, Steps = 200, OutputType = "Proof")
Input was gamma(n + 1/gamma(n + 1)*n!).
Lemma: n + 1/gamma(n + 1)*n! = n + 1
Input was n + 1/gamma(n + 1)*n!.
Applying the rule proc Simplify::expand(a) ... end(X)\
Strategy: table\
("Default" = 0.8)
to n + 1/gamma(n + 1)*n! gives n + 1/n*n!/gamma(n)
Lemma: 1/n*n!/gamma(n) = 1
Input was 1/n*n!/gamma(n).
Applying the rule X -> combine(X, gamma)(X)
to 1/n*n!/gamma(n) gives 1/gamma(n + 1)*n!
Lemma: n! = gamma(n + 1)
Input was n!.
Applying the rule X -> gamma(op(X, 1) + 1)(X)
to n! gives gamma(n + 1)
End of lemma
substituting gives 1
End of lemma
substituting gives n + 1
End of lemma
substituting gives gamma(n + 1)
END OF PROOF
9-15
As this (admittedly difficult to read) output suggests, Simplify works by following

a rule base. The documentation, accessible at ?Simplify (details) (note the
space and the parentheses!), shows examples with application-specific rule sets.
As we have seen above in the first example, the user can also control Simplify’s
idea of what is “simple.” Exercise 9.4 shows an application.
Exercise 9.1: It is possible to rewrite products of trigonometric functions as

linear combinations of sin and cos terms whose arguments are integral multiples
of the original arguments (Fourier expansion). Find constants a, b, c, d, and e such
that
cos(x)2 + sin(x) cos(x)

= a + b sin(x) + c cos(x) + d sin(2 x) + e cos(2 x)
holds.
Exercise 9.2: Use MuPAD to prove the following identities:
cos(5 x) cos2 (x) 5 sin3 (x)

1) = −5 sin (x) + + ,
sin(2 x) cos2 (x) 2 sin(x) 2 cos2 (x)
sin2 (x) − e2 x sin(x) − ex

2) 2 = ,
sin (x) + 2 sin(x) ex + e2 x sin(x) + ex
sin(2 x) − 5 sin(x) cos(x) 9 cos(x) 3 cos(3 x)

3) 2 =− − ,
sin(x) (1 + tan (x)) 4 4
v s
u r
u q
t √ √
4) 14 + 3 3 + 2 5 − 12 3 − 2 2 = 2 + 3 .
Exercise 9.3: MuPAD computes the following integral for f:

f := sqrt(sin(x) + 1): int(f, x)
p
2 (sin(x) − 1) sin(x) + 1
cos(x)
9-16
Its derivative is not literally identical to the integrand:

diff(%, x)
p
sin(x) − 1 p 2 sin(x) (sin(x) − 1) sin(x) + 1
p + 2 sin(x) + 1 + 2
sin(x) + 1 cos(x)
Simplify this expression.
Exercise 9.4: Using the option Valuation, we may pass a function to Simplify
to determine which expressions are “simple:” the function is called with an
expression as its argument and returns a number, higher numbers for more
complex expressions.
Let us try to write tan(x) − cot(x) without the tangent and cotangent functions.
The first, somewhat naive approach is to use a valuation function that simply
looks for the presence of tan and cot:2
noTangent := x -> if has(x, [hold(tan), hold(cot)])
then 10
else 1 end_if:
Simplify(tan(x) - cot(x), Valuation = noTangent)
2
2 sin(x) − 1
2
sin(x) − 2 sin x2 sin(x)
Now, this expression actually does not contain tan, but is hardly “simple.”
Improve noTangent such that the call above returns a simple expression without
tan and cot. You might want to inform yourself about length first or use
Simplify::defaultValuation instead, which is the function used by Simplify if
nothing is specified.
2 See Chapter 16 for an explanation of “if.”
9-17
Assumptions about Mathematical Properties

MuPAD® performs transformations or simplifications for objects containing
symbolic identifiers only if the corresponding rules apply in the entire complex
plane. However, some familiar rules for computing with real numbers are not
generally valid for complex numbers. For example, the square root and the
logarithm are branches of multi-valued complex functions, and the MuPAD
functions internally make certain assumptions about the branch cuts.
✞ ☎
x
ln(e ) = x for real x
ln(xn ) = n ln(x) for real x > 0
ln(x y) = ln(x) + ln(y) for real x > 0 or real y > 0
√
x2 = |x| for real x
ex/2 = (ex )1/2 for real x
✝ ✆
You can use the function assume to tell the system functions such as expand,
simplify, limit, solve, and int that they may make certain assumptions about
the meaning of certain expressions. We only demonstrate some simple examples
here. You find more information on the corresponding help page: ?assume.
You can use an expression such as an inequality or containment in a set, including
the basic sets of the solver (cf. page 8-7) to tell MuPAD that a symbolic identifier
or expression represents only values corresponding to the mathematical meaning
of the type. For example, the commands
assume(x in R_): assume(y in R_): assume(n in Z_):
restrict x and y to be real numbers and n to be an integer. Now simplify can

apply additional rules:
simplify(ln(exp(x))), simplify(sqrt(x^2))
x, x sign(x)
The command
assume(x > 0):
9-18
restricts x to positive real numbers. After this assumption, one obtains:

simplify(ln(x^n)), simplify(ln(x*y) - ln(x) - ln(y)),
simplify(sqrt(x^2))
n ln(x) , 0, x
Transformations and simplifications with constants are executed without

additional assumptions since their mathematical meaning is known:
expand(ln(2*PI*z)), sqrt((2*PI*z)^2)
√
ln(2) + ln(π) + ln(z) , 2 π z2
The arithmetic operators take into account certain mathematical properties

automatically:
(a*b)^m
m
(a b)
assume(m in Z_): (a*b)^m

am bm
The function is checks whether a MuPAD expression is known to be true:

is(1 in Z_), is(PI + 1 in R_)
TRUE, TRUE
In addition, is takes into account the mathematical properties set by assume:

delete x: is(x in Z_)
UNKNOWN
assume(x in Z_):
is(x in Z_), is(x in R_)
TRUE, TRUE
Here, the Boolean value UNKNOWN expresses the fact that the system cannot decide
whether x represents an integer or not.
9-19
In contrast to is, the function testtype presented in Section 14.1 checks the
technical type of a MuPAD object:
testtype(x, Type::Integer), testtype(x, DOM_IDENT)
FALSE, TRUE
Queries of the following form are also possible:

assume(y > 5): is(y + 1 > 4)
TRUE
To set an assumption only temporarily during a single command, use the

assuming operator:
limit(exp(a*x), x=infinity);
limit(exp(a*x), x=infinity) assuming a < 0


 1 if a = 0



0 if ℜ(a) < 0

 ∞ if 0 < ℜ(a) ∧ 0 < sign(ℜ(a)) + sign(ℑ(a)) i



limx→∞ e ax
if ℜ(a) = 0 ∧ a ̸= 0 ∨ 0 < ℜ(a) ∧ . . .
The function getprop returns a mathematical property of an identifier or an

expression, i.e., a set such that x ∈ getprop(x):
getprop(y), getprop(y^2 + 1)
(5, ∞), (26, ∞)
You can delete the properties of an identifier using unassume or the keyword
delete:
delete y: is(y > 5)
UNKNOWN
9-20
If none of the sub-expressions in an expression has any properties attached to it,

then getprop may return the set of complex numbers:
getprop(y), getprop(y^2 + 1), getprop(abs(y))
C, C, [0, ∞)
getprop(3), getprop(sqrt(2) + 1)
n√ o
{3} , 2+1
Assuming some property deletes all previous assumptions using the same
identifiers:
assume(sin(x) > y):
getprop(y)
(−∞, sin(x))
assume(abs(x) > 1):

getprop(y)
C
To make an assumption in addition to existing assumptions, use assumeAlso

instead of assume, and assumingAlso instead of assuming:
assume(sin(x) > y):
getprop(y)
(−∞, sin(x))
assumeAlso(abs(x) > 1):

getprop(y)
(−∞, sin(x))
9-21
We now illustrate some of the various types of properties with a short example.
The equation (xa )b = xab is not generally valid, as the example x = −1, a = 2, and
b = 1/2 shows. However, it is valid if b is an integer:
assume(b in Z_): (xâ)^b
xa b
unassume(b): (xâ)^b
b
(xa )
The function linalg::isPosDef checks whether a matrix is positive definite. For

a matrix with symbolic entries, it may not be possible to decide this correctly:
A := matrix([[1/a, 1], [1, 1/a]])
!
1
a 1
1
1 a
linalg::isPosDef(A)
Error: cannot check whether matrix component is positive
[linalg::factorCholesky]
With the additional assumption that the parameter a be positive and less than 1,
MuPAD can decide that the matrix is positive definite:
assume(a, Type::Interval(0, 1))
linalg::isPosDef(A)
TRUE
Properties of this type can be specified in the following more intuitive way as well:
assume(0 < a < 1)
The function simplify reacts to properties:

assume(k, Type::Residue(3,4))
sin(k*PI/2)

πk
sin
2
9-22
simplify(%)
−1
The property above can also be specified in any of the following equivalent forms:
assume(k in 4*Z_ + 3)
assume((k - 3)/4 in Z_)
The functions Re, Im, sign, and abs take properties into account:
assume(x > 1):
Re(x*(x - 1)), sign(x*(x - 1)), abs(x*(x - 1))
x (x − 1) , 1, x (x − 1)
Since only a limited number of mathematical properties and derivation rules are
implemented in MuPAD, the system performs some simplifications when
evaluating the properties of a nontrivial expression. Thus the answer of getprop
or is is sometimes not “as close as possible.” For example, if x is a real number,
then x2 − x ≥ −1/4, but getprop yields the following less accurate answer:
assume(x, Type::Real): getprop(x^2 - x)
R
Exercise 9.5: Use MuPAD to show:

(
∞ for a > 0 ,
lim Ei(ax) =
x→∞ 0 for a < 0 .
R xthe tfunction assume to distinguish the cases. The exponential integral

Hint: Use
Ei(x) = −∞ et dt is available as Ei.
9-23
10
You can use MuPAD® ’s random number generators random, frandom and
stats::xxxRandom to perform many experiments.
The call random() generates a random nonnegative 12 digit integer. You obtain a
sequence of 4 such random numbers as follows:
random(), random(), random(), random()
427419669081, 321110693270, 343633073697, 474256143563
If you want to generate random integers in a different range, you can construct a
random number generator generator:= random(m..n). You call this generator
without arguments,1 and it returns integers between m and n. The call random(n)
is equivalent to random(0..n-1). Thus you can simulate 15 rolls of a die as
follows:
die := random(1..6):
dieExperiment := [die() $ i = 1..15]
[5, 3, 6, 3, 2, 2, 2, 4, 4, 3, 3, 2, 1, 4, 4]
We stress that you must specify a loop variable when using the sequence generator
$, since otherwise die() is called only once and a sequence of copies of this value
is generated:
die() $ 15
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6
1 In fact, you can call generator with arbitrary arguments, which are ignored when generating ran-
dom numbers.
10 Chance and Probability
Here is a simulation of 8 coin tosses:

coin := random(2):
coinTosses := [coin() $ i = 1..8]
[0, 0, 0, 1, 1, 1, 0, 0]
subs(coinTosses, [0 = head, 1 = tail])

[head, head, head, tail, tail, tail, head, head]
The following example generates uniformly distributed floating-point numbers

from the interval [0, 1]. It uses the random generator frandom:
randomNumbers := [frandom() $ i = 1..10]
[0.2703581656, 0.8310371787, 0.153156516,
0.9948127808, 0.2662729021, 0.1801642277,
0.452083055, 0.6787819563, 0.3549849261,
0.6818588132]
The library stats comprises functions for statistical analysis. You obtain
information by entering info(stats) or ?stats. For example, the function
1
Pn
stats::mean computes the mean value X = n i=1 xi of a list of numbers
[x1 , . . . , xn ]:
stats::mean(dieExperiment),
stats::mean(coinTosses),
stats::mean(randomNumbers)
16 3
, , 0.4863510522
5 8
The function stats::variance returns the variance
1 X
n
V ar = (xi − X)2 :
n − 1 i=1
10-2
stats::variance(dieExperiment),
stats::variance(coinTosses),
stats::variance(randomNumbers)
61 15
, , 0.08565360412
35 56
√
You can compute the standard deviation V ar with stats::stdev:
stats::stdev(dieExperiment),
stats::stdev(coinTosses),
stats::stdev(randomNumbers)
√ √ √ √
35 61 14 15
, , 0.29266637
35 28
q
n−1
If you specify the option Population, the system returns n V ar instead:
stats::stdev(dieExperiment, Population),
stats::stdev(coinTosses, Population),
stats::stdev(randomNumbers, Population)
√ √ √
3 122 15
, , 0.2776476971
15 8
The data structure Dom::Multiset (see ?Dom::Multiset) provides a simple means

of determining frequencies in sequences. The call Dom::Multiset(a,b, ...)
returns a multiset, which is printed as a set of lists. The first entry of each such list
is one of the arguments; the second entry counts the number of occurrences in the
argument sequence:
Dom::Multiset(a, b, a, c, b, b, a, a, c, d, e, d)
{[a, 4] , [b, 3] , [c, 2] , [d, 2] , [e, 1]}
If you simulate 1000 rolls of a die, you might obtain the following frequencies:
rolls := die() $ i = 1..1000:
Dom::Multiset(rolls)
{[1, 158] , [2, 152] , [3, 164] , [4, 188] , [5, 176] , [6, 162]}
In this case, you would have rolled 158 times a 1, 152 times a 2 etc.
10-3
An example from number theory is the distribution of the greatest common

divisors (gcd) of random pairs of integers. We use the function zip (Section 4.6)
to combine two random lists via the function igcd, which computes the gcd of
integers:
list1 := [random() $ i=1..1000]:
list2 := [random() $ i=1..1000]:
gcdlist := zip(list1, list2, igcd)
[1, 7, 1, 1, 1, 5, 1, 3, 1, 1, 1, 3, 6, 1, 3, 5, ...]
Now, we use Dom::Multiset to count the frequencies of the individual gcds:

frequencies := Dom::Multiset(op(gcdlist))
{[11, 5], [13, 3], [14, 2], ..., [377, 1], [1, 596]}
The result becomes much more readable if we sort it by the first entry of the
sublists. We employ the function sort which takes a function representing a
sorting order as second argument. This function decides which of two elements
x, y shall precede the other. We refer to the corresponding help page: ?sort. In
this case, x, y are lists with two entries, and we want x to appear before y if we
have x[1] < y[1] (i.e., we sort numerically with respect to the first entries):
sortingOrder := (x, y) -> (x[1] < y[1]):
sort([op(frequencies)], sortingOrder)
[[1, 596], [2, 142], [3, 84], ..., [212, 1], [377, 1]]
In this experiment, 596 out of the 1000 chosen random pairs have a gcd of 1 and
hence are coprime. Thus, we found 59.6% as an approximation of the probability
that two randomly chosen integers are coprime. The theoretical value of this
probability is 6/π 2 ≈ 0.6079.. =
b 60.79%.
The stats library provides many stochastic distribution functions. Each such
distribution xxx, say, consists of four functions: a cumulative distribution
function xxxCDF, a probability density function xxxPDF (or a discrete probability
function xxxPF, respectively), a quantile function xxxQuantile, and a random
number generator xxxRandom. For example, the following command creates a list
of random numbers distributed according to the standard normal distribution
with mean 0 and variance 1:
10-4
randomGenerator := stats::normalRandom(0, 1):

data := [randomGenerator() $ i = 1..1000]:
The stats library includes an implementation of the classical χ2 -test. We use it

here to test whether the random data generated above do indeed satisfy a normal
distribution. Pretending that we do not know the mean and the variance of the
data, we compute statistical estimates of these parameters:
m := stats::mean(data)
−0.03440235553
V := stats::variance(data)
0.9962289589
The χ2 -test requires to specify a “cell partitioning” of the real line to compare the
observed frequencies of the data falling into the cells with the expected
frequencies given a hypothesized distribution of the data. The function
stats::equiprobableCells is a convenient utility function to compute a cell
partitioning consisting of cells that are equiprobable with respect to a given
distribution. The following call partitions the real line into 32 cells which are
equiprobable with respect to the normal distribution with the empirical mean and
variance computed above:
cells := stats::equiprobableCells(32,
stats::normalQuantile(m, V))
[[-infinity, -1.89096853], [-1.89096853, -1.553118836],
..., [1.939230531, infinity]]
The χ2 -goodness-of-fit test is implemented by stats::csGOFT. We use it to test

how good the random data fit a normal distribution with mean and variance given
by the empirical values m and V:
stats::csGOFT(data, cells,
CDF = stats::normalCDF(m, V))
[PValue = 0.3862347505, StatValue = 32.64,
MinimalExpectedCellFrequency = 31.25]
The first value returned by stats::csGOFT is the significance level attained by the
data. Since this value is not small, the given data pass the test well.
10-5
Finally, we dote the data by adding 35 zeroes:

data := append(data, 0 $ 35):
We check whether the new data still may be regarded as a normally distributed
sample:
m := stats::mean(data): V := stats::variance(data):
cells := stats::equiprobableCells(32,
stats::normalQuantile(m, V)):
stats::csGOFT(data, cells,
CDF = stats::normalCDF(m, V))
[PValue = 0.000004764116336, StatValue = 78.87826087,
MinimalExpectedCellFrequency = 32.34375]
Now, the attained significance level 0.0010... indicates that the hypothesis of a
normal distribution of the data must be rejected at significance levels as low as
0.001.
See the help page of stats::csGOFT for further details.
Exercise 10.1: Three dice are thrown simultaneously. For each value between 3
and 18, the following table contains the expected frequencies of the total dice
score when rolling the dice 216 times:
score
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 3 6 10 15 21 25 27 27 25 21 15 10 6 3 1
frequency
Simulate 216 rolls and compare the frequencies that you observe with those from
the table.
Exercise 10.2: The Monte-Carlo method for approximating the area of a region
A ⊂ R2 works as follows. First, we choose a (preferably small) rectangle Q
enclosing A. Then we randomly choose n points in Q. If m of these points lie in A,
the following estimate holds for sufficiently large n:
m
area of A ≈ × area of Q.
n
10-6
Let r() be a call to a generator r of uniformly distributed random numbers in the

interval [0, 1]. We can use r to generate uniformly distributed random vectors in
the rectangle Q = [0, a] × [0, b] via [a * r(), b * r()].
a) Consider the right upper quadrant of the unit circle around the origin. Use
Monte-Carlo simulation with Q = [0, 1] × [0, 1] to approximate its area. This
way, one gets stochastic approximations of π .
b) RLet f : x 7→ x sin(x) + cos(x) exp(x). Determine an approximation for

1
0
f (x) dx. For that purpose, find an upper bound M for f on the interval
[0, 1] and apply the simulation to Q = [0, 1] × [0, M ]. Compare your result to
the exact integral.
10-7
11
Graphics
Introduction
Since exploring mathematical objects is probably one of the most important uses
of computer algebra systems, graphics are a rather central part of modern CAS.
The MuPAD® system allows to easily create two- and three-dimensional graphics
and animations with high quality output and advanced interactive manipulation
capabilities.
To aid the user in fine-tuning a plot, an object browser is provided. It allows to
inspect and analyze the tree structure of graphical scenes interactively, giving easy
access to all parts of the plot by a mouse-click. After selecting an object, all plot
attributes such as color, line width, annotations etc. associated with the object
become visible. One may select the attributes with the mouse and change their
values interactively (see page 11-50). Thus, almost any detail of a plot generated
by a MuPAD call can be changed interactively making it possible to fine-tune both
the contents as well as the looks by visual inspection.
The features of the renderer are fully supported by the plot library. It provides a
list of graphical primitives such as points, lines, polygons etc. that one may use to
build up highly complex graphical scenes. The primitives also include graphical
objects that are not at all “primitive,” but come along with advanced algorithms
and much built-in intelligence. Examples are function graphs in 2D and 3D (with
automatic clipping for singular functions), implicit plots in 2D and 3D, vector field
plots, graphical solutions of ordinary differential equations in 2D and 3D etc.
This chapter gives an introduction to the new graphics system. It explains the
basic concepts and ideas and provides many examples.
11 Graphics
Easy Plotting: Graphs of Functions

Probably the most important graphical task in a mathematical context is to
visualize function graphs, i.e., to plot functions. The plot command allows to
create 2D plots of functions with one argument (such as f (x) = sin(x)) or 3D plots
of functions with two arguments (such as f (x, y) = sin(x2 + y 2 )). The calling
syntax is simple: just pass the expression that defines the function and,
optionally, a range for the independent variable(s). To distinguish 3D plots from
2D animations, add #3D to the call.
2D Function Graphs
We consider 2D examples, i.e., plots of univariate functions f (x). Here is one

period of the sine function:
plot(sin(x), x = 0..2*PI)
If several functions are to be plotted in the same graphical scene, just pass a
sequence of function expressions. All functions are plotted over the specified
common range:
11-2
plot(sin(x)/x, x*cos(x), tan(x), x = -4..4)
To get a legend explaining the mapping from color to function, add the option
LegendVisible:
plot(sin(x)/x, x*cos(x), tan(x), x = -4..4, LegendVisible)
11-3
11 Graphics
Functions that do not allow a simple symbolic representation by an expression

can also be defined by a procedure that produces a numerical value f (x) when
called with a numerical value x from the plot range. In the following example we
consider the largest eigenvalue of a symmetric 3 × 3 matrix that contains a
parameter x. We plot this eigenvalue as a function of x:
f := x -> max(numeric::eigenvalues(
matrix([[-x, x, -x ],
[ x, x, x ],
[-x, x, x^2]]))):
plot(f, x = -1..1)
The name x used in the specification of the plotting range provides the name that
labels the horizontal axis.
11-4
Functions can also be defined by piecewise objects:

plot(piecewise([x < 1, 1 - x],
[1 < x and x < 2, 1/2],
[x > 2, 2 - x]),
x = -2..3)
Note that there are gaps in the definition of the function above: no function value
is specified for x = 1 and x = 2. This does not cause any problem, because plot
simply ignores all points that do not produce real numerical values. Thus, in the
following example, the plot is automatically restricted to the regions where the
functions produce real values:
11-5
11 Graphics
plot(sqrt(8 - x^4), ln(x^3 + 2)/(x - 1), x = -2 ..2)
11-6
When several functions are plotted in the same scene, they are drawn in different
colors that are chosen automatically. With the Colors attribute one may specify a
list of RGB colors that plot shall use:
plot(x, x^2, x^3, x^4, x^5, x = 0..1,
Colors = [RGB::Red, RGB::Orange, RGB::Yellow,
RGB::BlueLight, RGB::Blue],
LegendVisible)
11-7
11 Graphics
Animated 2D plots of functions are created by passing function expressions

depending on a variable (x, say) and an animation parameter (a, say) and
specifying a range both for x and a. In this text, animations are represented by a
“film strip:”
plot(cos(a*x), x = 0..2*PI, a = 1..2)
11-8
Once the plot is created, the first frame of the picture appears as a static plot.
After double-clicking on the picture, the graphics tool allows to start the
animation by pushing the “Start” button:
11-9
11 Graphics
An animation consists of separate frames, i.e., individual still images. The default
number of frames is 50. If a different value is desired, just pass the attribute
Frames = n, where n is the number of frames that shall be created:
plot(sin(a*x), sin(x - a), x = 0..PI, a = 0..4*PI,

Frames = 200, Colors = [RGB::Blue, RGB::Red])
Apart from the color specification or the Frames number, there is a large number
of further attributes that may be passed to plot. Each attribute is passed as an
equation AttributeName = AttributeValue. Here, we only present some selected
attributes. Section “Attributes for plotfunc2d and plotfunc3d” of the online plot
documentation provides further tables with more attributes.
✞ ☎
attribute name possible values meaning default
Height 8*unit::cm physical height 80*unit::mm
of the picture
Width 12*unit::cm physical width 120*unit::mm
of the picture
Footer string footer text "" (no footer)
Header string header text "" (no header)
Title string title text "" (no title)
TitlePosition [real value, coordinates of the
real value] lower left corner of
the title
✝ ✆
Table 11.1: Some important attributes for plotting 2D functions
11-10
✞ ☎
GridVisible TRUE, FALSE visibility of “major” FALSE

grid lines
SubgridVisible TRUE, FALSE visibility of “minor” FALSE
grid lines
AdaptiveMesh integer ≥ 0 depth of the adaptive 2
mesh
Axes None, Automatic, axes type Automatic
Boxed, Frame, Origin
AxesVisible TRUE, FALSE visibility TRUE
of all axes
AxesTitles [string, string] titles of the axes ["x","y"]
CoordinateType LinLin, LinLog, linear-linear, LinLin
LogLin, LogLog linear-logarithmic,
log-linear, log-log
Colors list of RGB values line colors first 10 entries of
RGB::ColorList
Frames integer ≥ 0 number of frames of 50
an animation
LegendVisible TRUE, FALSE legend on/off TRUE if plotting more
than one function
LineColorType Dichromatic, Flat, color scheme Flat
Functional,
Monochrome, Rainbow
Mesh integer ≥ 2 number of sample 121
points
Scaling Automatic, scaling mode Unconstrained
Constrained,
Unconstrained
TicksNumber None, Low, Normal, number of labeled Normal
High ticks
ViewingBoxYRange ymin .. ymax restricted viewing Automatic
range in y direction .. Automatic
✝ ✆
We now present some examples for the use of these attributes.
11-11
11 Graphics
First, we will give an example where the number of evaluation points needs
adjustment. The following plot example features the notorious function sin (1/x)
that oscillates wildly near the origin:
plot(sin(1/x), x = -0.5..0.5)
Clearly, the default of 121 sample points used by plot does not suffice to create a
sufficiently resolved plot.
11-12
We increase the number of numerical mesh points via the Mesh attribute.
Additionally, we increase the resolution depth of the adaptive plotting mechanism
from its default value AdaptiveMesh = 2 to AdaptiveMesh = 4:
plot(sin(1/x), x = -0.5..0.5, Mesh = 500,
AdaptiveMesh = 4)
11-13
11 Graphics
The following call specifies a header via Header = "The function sin(x^2)".
The distance between labeled ticks is set to 0.5 along the x axis and to 0.2 along the
y axis via XTicksDistance = 0.5 and YTicksDistance = 0.2, respectively. Four
additional unlabeled ticks between each pair of labeled ticks are set in the x
direction via XTicksBetween = 4. One additional unlabeled tick between each pair
of labeled ticks in the y direction is requested via YTicksBetween = 1. Grid lines
attached to the ticks are “switched on” by GridVisible = TRUE and
SubgridVisible = TRUE:
plot(sin(x^2), x = 0..7,
Header = "The function sin(x^2)",
XTicksDistance = 0.5, YTicksDistance = 0.2,
XTicksBetween = 4, YTicksBetween = 1,
GridVisible = TRUE, SubgridVisible = TRUE)
11-14
When singularities are found in the function, an automatic clipping is called trying
to restrict the vertical viewing range in some way to obtain a “reasonably” scaled
picture. This is a heuristic approach that sometimes needs a helping adaption “by
hand.” In the following example, the automatically chosen range between y ≈ −40
and y ≈ 260 in vertical direction is suitable to represent the 6th order pole at
x = 1, but it does not provide a good resolution of the first order pole at x = −1:
plot(1/(x + 1)/(x - 1)^6, x = -2..2)
There is no good viewing range that is adequate for both poles because they are of
different order. However, some compromise can be found.
11-15
11 Graphics
We override the automatic viewing range suggested by plot and request a specific
viewing range in vertical direction via ViewingBoxYRange:
plot(1/(x + 1)/(x - 1)^6, x = -2..2,
ViewingBoxYRange = -10..10)
11-16
The values of the following function have a lower bound, but no upper bound. We
use the attribute ViewingBoxYRange = Automatic..10 to let plot find a lower
bound for the viewing box by itself whilst requesting a specific value of 10 for the
upper bound:
plot(exp(x)*sin(PI*x) + 1/(x + 1)^2/(x - 1)^4,
x = -2..2, ViewingBoxYRange = Automatic..10)
11-17
11 Graphics
3D Function Graphs
We consider 3D examples, i.e., plots of bi-variate functions f (x, y). As noted

above, to distinguish static 3D and animated 2D plots, the former need the option
#3D. Here is a plot of the function sin(x2 + y 2 ):
plot(sin(x^2 + y^2), x = -2..2, y = -2..2, #3D)
11-18
If several functions are to be plotted in the same graphical scene, just pass a
sequence of function expressions; all functions are plotted over the specified
common range:
plot((x^2 + y^2)/4, sin(x - y)/(x - y),
x = -2..2, y = -2..2, #3D)
11-19
11 Graphics
Functions that do not allow a simple symbolic representation by an expression

can also be defined by a procedure that produces a numerical value f (x, y) when
called with numerical values x, y from the plot range. In the following example we
consider the largest eigenvalue of a symmetric 3 × 3 matrix that contains two
parameters x, y . We plot this eigenvalue as a function of x and y :
f := (x, y) -> max(numeric::eigenvalues(
matrix([[-y, x, -x ],
[ x, y, x ],
[-x, x, y^2]]))):
plot(#3D, f, x = -1..1, y = -1..1)
The names x, y used in the specification of the plotting range provide the labels of
the corresponding axes.
11-20
Functions can also be defined by piecewise objects:

plot(piecewise([x < y, y-x], [x > y, (y-x)^2]),
x = 0..1, y = 0..1, #3D)
Note that there are gaps in the definition of the function above: no function value
is specified for x = y . This does not cause any problem, because plot simply
ignores points that do not produce real numerical values if it finds suitable values
in the neighborhood. Thus, missing points or singularities do not raise an error.
11-21
11 Graphics
If the function is not real-valued in regions of non-zero measure, gaps will be

visible in the output. The following function is real-valued only in the disc
x2 + y 2 ≤ 1:
plot(sqrt(1 - x^2 - y^2), x = 0..1, y = 0..1, #3D)
11-22
When several functions are plotted in the same scene, they are drawn in different
colors that are chosen automatically. With the Colors attribute one may specify a
list of RGB colors that plot shall use:
plot(2 + x^2 + y^2, 1 + x^4 + y^4, x^6 + y^6,
x = -1..1, y = -1..1, #3D,
Colors = [RGB::Red, RGB::Green, RGB::Blue])
11-23
11 Graphics
Animated 3D plots of functions are created by passing function expressions

depending on two variables (x and y , say) and an animation parameter (a, say)
and specifying a range for x, y , and a.
plot(xâ + yâ, x = 0..2, y = 0..2, a = 1..2, #3D)
Once the plot is created, the first frame of the picture appears as a static plot.
After double-clicking on the picture, the graphics tool allows to start the
animation by pushing the “Start” button.
11-24
An animation consists of separate frames. The default number of frames is 50. If a

different value is desired, just pass the attribute Frames = n, where n is the number
of frames that shall be created:
plot(sin(a)*sin(x) + cos(a)*cos(y), x = 0..2*PI,
y = 0..2*PI, a = 0..2*PI, #3D, Frames = 32)
Apart from the color specification or the Frames number, there is a large number
of further attributes that may be passed to plot. Each attribute is passed as an
equation to plot. Here, we only present some selected attributes. Section
“Attributes for plotfunc2d and plotfunc3d” of the online plot documentation
provides further tables with more attributes.
✞ ☎
Height 8*unit::cm physical height of the 80*unit::mm
picture
Width 12*unit::cm physical width of the 120*unit::mm
picture
Footer string footer text "" (no footer)
Header string header text "" (no header)
Title string title text "" (no title)
TitlePosition [real value, coordinates of the
real value] lower left corner of
the title
GridVisible TRUE, FALSE visibility of “major” FALSE
grid lines
✝ ✆
11-25
11 Graphics
✞ ☎
SubgridVisible TRUE, FALSE visibility of “minor” FALSE

grid lines
AdaptiveMesh integer ≥ 0 depth of the adaptive 0
mesh
Axes Automatic, Boxed, axes type Boxed
Frame, Origin
AxesVisible TRUE, FALSE visibility of all axes TRUE
AxesTitles [string, string, titles of the axes ["x","y","z"]
string]
Colors list of RGB colors fill colors
Frames integer ≥ 0 number of frames of 50
the animation
LegendVisible TRUE, FALSE legend on/off TRUE if plotting more
than one function
FillColorType Dichromatic, Flat, color scheme Dichromatic
Functional,
Monochrome, Rainbow
Mesh [integer ≥ 2, integer number of “major” [25, 25]
≥ 2] mesh points
Submesh [integer ≥ 0, integer number of “minor” [0, 0]
≥ 0] mesh points
Scaling Automatic, scaling mode Unconstrained
Constrained,
Unconstrained
TicksNumber None, Low, Normal, number of labeled Normal
High ticks
ViewingBoxZRange zmin .. zmax restricted viewing Automatic
range in z direction .. Automatic
✝ ✆
Let us present some example uses of these attributes. As for 2D plots, we’ll start
with the evaluation density.
11-26
In the following example, the default mesh of 25 × 25 sample points used by plot
does not suffice to create a sufficiently resolved plot:
plot(sin(x^2 + y^2), x = -3..3, y = -3..3, #3D)
11-27
11 Graphics
We increase the number of numerical mesh points via the Submesh attribute:
plot(sin(x^2 + y^2), x = -3..3, y = -3..3,
Submesh = [3, 3], #3D)
11-28
The following call specifies a header via Header = "The function sin(x - y^2)".
Grid lines attached to the ticks are “switched on” by GridVisible and
SubgridVisible:
plot(sin(x - y^2), x = -2*PI..2*PI, y = -2..2, #3D,

Header = "The function sin(x - y^2)",
GridVisible = TRUE, SubgridVisible = TRUE)
11-29
11 Graphics
When singularities are found in the function, an automatic clipping is called

trying to restrict the vertical viewing range in some way to obtain a “reasonably”
scaled picture. This is a heuristic approach that sometimes needs a helping
adaption “by hand.” In the following example, the automatically chosen range
between z ≈ 0 and z ≈ 0.8 in vertical direction is suitable to represent the pole at
x = 1, y = 1, but it does not provide a good resolution of the pole at x = −1, y = 1:
plot(1/((x+1)^2 + (y-1)^2)/((x-1)^2 + (y-1)^2)^5,
x = -2..3, y = -2..3, Submesh = [3, 3], #3D)
There is no good viewing range that is adequate for both poles because they are of
different order.
11-30
We override the automatic viewing range suggested by plot and request a specific
viewing range in the vertical direction via ViewingBoxZRange:
plot(1/((x+1)^2 + (y-1)^2)/((x-1)^2 + (y-1)^2)^5,
x = -2..3, y = -2..3, Submesh = [3, 3],
ViewingBoxZRange = 0..0.1, #3D)
11-31
11 Graphics
The values of the following function have a lower bound but no upper bound. We
use the attribute ViewingBoxZRange = Automatic..20 to let plot find a lower
bound for the viewing box by itself whilst requesting a specific value of 20 for the
upper bound:
plot(1/x^2/y^2 + exp(-x)*sin(PI*y),
x = -2..2, y = -2..2, #3D,
ViewingBoxZRange = Automatic..20)
11-32
Advanced Plotting: Principles and First Examples

In the previous section, we introduced the plot command for plotting functions in
2D and 3D with simple calls in easy syntax. Although there is a large number of
attributes to control the graphical output and there is also a large number of
additional possibilities for plotting point lists etc., there remains a serious
restriction: the attributes are used for all functions simultaneously.
If attributes attr11 etc. are to be applied to functions individually, one needs to
invoke a (slightly) more elaborate calling syntax to generate the plot:
plot(
plot::Function2d(f1, x1 = a1..b1, attr11, attr12, ...),
plot::Function2d(f2, x2 = a2..b2, attr21, attr22, ...),
...
)
In this call, each call of plot::Function2d creates a separate object that

represents the graph of the function passed as the first argument over the plotting
range passed as the second argument. An arbitrary number of plot attributes can
be associated with each function graph. The objects themselves are not displayed
directly. The plot command triggers the evaluation of the functions on some
suitable numerical mesh and calls the renderer to display these numerical data in
the form specified by the given attributes.
In fact, plot called on a plain expression does precisely the same: internally, the
utility function plot::easy generates objects of type plot::Function2d or
plot::Function3d, respectively, and these are rendered.
General Principles
In general, graphical scenes are collections of “graphical primitives.” There are

simple primitives such as points, line segments, polygons, rectangles and boxes,
circles and spheres, histogram plots, pie charts etc. An example of a more
advanced primitive is plot::VectorField2d that represents a collection of arrows
attached to a regular mesh visualizing a vector field over a rectangular region in
R2 . Yet more advanced primitives are function graphs and parametrized curves
that come equipped with some internal intelligence, e.g., knowing how to evaluate
11-33
11 Graphics
themselves numerically on adaptive meshes and how to clip themselves in case of

singularities. As examples for highly advanced primitives in the plot library, we
mention plot::Ode2d, plot::Ode3d, plot::Streamlines2d, and
plot::Implicit2d, plot::Implicit3d. The first automatically solve systems of
ordinary differential equations numerically and display the solutions graphically.
The latter display the solution curves or surfaces of equations f (x, y) = 0 or
f (x, y, z) = 0, respectively, by solving these equations numerically, a typical task
in (real) algebraic geometry.
All these primitives are just “objects” representing some graphical entities. They
are not rendered directly when they are created, but just serve as data structures
encoding the graphical meaning, collecting attributes defining the presentation
style and providing numerical routines to convert the input parameters to some
numerical data that are to be sent to the renderer.
An arbitrary number of such primitives can be collected to form a graphical scene.
Finally, a call to plot passing a sequence of all primitives in the scene invokes the
renderer to draw the plot. The following example shows the graph of the function
f (x) = x · sin(x). At the point (x0 , f (x0 )), a graphical point is inserted and the
tangent to the graph through this point is added:
f := x -> x*sin(x):
x0:= 1.2: dx := 1:
g := plot::Function2d(f(x), x = 0..2*PI):
p := plot::Point2d(x0, f(x0), PointSize = 3.0*unit::mm):
t := plot::Line2d([x0 - dx, f(x0) - f'(x0)*dx],
[x0 + dx, f(x0) + f'(x0)*dx]):
11-34
The picture is drawn by calling plot:

plot(g, t, p)
Each primitive accepts a variety of plot attributes that may be passed as a

sequence of equations AttributeName = AttributeValue to the generating call.
Most prominently, almost every primitive allows to set the color explicitly:
g := plot::Function2d(f(x), x = 0..2*PI,
Color = RGB::Blue):
Alternatively, the generated objects allow to set attributes via slot assignments of
the form object::AttributeName:= AttributeValue as in
p::Color := RGB::Black:
p::PointSize := 4.0*unit::mm:
t::Color := RGB::Red:
t::LineWidth := 1.0*unit::mm:
The help page of each primitive provides a list of all attributes the primitive is
reacting to.
11-35
11 Graphics
Certain attributes, such as axes style, the visibility of grid lines in the background
etc. are associated with the whole scene rather than with the individual primitives.
These attributes may be included in the plot call:
plot(g, t, p, GridVisible = TRUE)
As explained in detail in Section “The Full Picture” on page 11-46, the plot
command automatically embeds the graphical primitives in a coordinate system,
which in turn is embedded in a graphical scene, which is drawn inside a canvas.
The various attributes associated with the general appearance of the whole picture
are associated with these “grouping structures.” A concise list of all such
attributes is provided on the help pages of the corresponding primitives:
plot::Canvas, plot::Scene2d, plot::Scene3d, plot::CoordinateSystem2d, and
plot::CoordinateSystem3d, respectively.
The MuPAD® object browser allows to select each primitive in the plot. After
selection, the attributes of the primitive can be changed interactively in the
property inspector (see page 11-50).
Next, we wish to demonstrate an animation. It is remarkably simple to generate
an animated picture. Going back to our previous example with the tangent to the
function graph, we want to let the point x0 at which the tangent is added move
along the graph of the function. In MuPAD, you do not need to create an
animation frame by frame. Instead, each primitive can be told to animate itself by
11-36
simply defining it with a symbolic animation parameter and adding an animation

range for this parameter. Static and animated objects can be mixed and rendered
together. The static function graph of f (x) used in the previous plot is recycled for
the animation. The graphical point at (x0 , f (x0 )) and the tangent through this
point shall be animated using the coordinate x0 as the animation parameter.
Deleting its value set above, we can use the same definitions as before, now with a
symbolic x0. We just have to add the range specification x0 = 0..2*PI for this
parameter:
delete x0:
dx := 2/sqrt(1 + f'(x0)^2):
p := plot::Point2d(x0, f(x0), x0 = 0..2*PI,
Color = RGB::Black,
PointSize = 2.0*unit::mm):
t := plot::Line2d([x0 - dx, f(x0) - f'(x0)*dx],
[x0 + dx, f(x0) + f'(x0)*dx],
x0 = 0..2*PI, Color = RGB::Red,
LineWidth = 1.0*unit::mm):
plot(g, p, t, GridVisible = TRUE)
Details on animations and further examples are provided starting on page 11-71.
11-37
11 Graphics
We summarize the construction principles for graphics with MuPAD’s plot

library:
✞ ☎
• Graphical scenes are built from graphical primitives. The section
starting on page 11-54 provides a survey of the primitives that are
available in the plot library.
• Primitives generated by the plot library are sym-

bolic objects that are not rendered directly. The call
plot(Primitive1, Primitive2, …) generates the pictures.
• Graphical attributes are specified as equations

AttributeName = Value. Attributes for a graphical primitive
may be passed in the call that generates the primitive. The help
page of each primitive provides a complete list of all attributes the
primitive reacts to.
• Attributes determining the general appearance of the pic-

ture may be given in the plot call. The help pages of
plot::CoordinateSystem2d, plot::CoordinateSystem3d,
plot::Scene2d, plot::Scene3d, and plot::Canvas, respectively,
provide a complete list of all attributes determining the general
appearance.
• Almost all attributes can be changed interactively in the viewer.
• Presently, 2D and 3D plots are strictly separated. Objects of differ-

ent dimension cannot be rendered in the same plot.
• Animations are not created frame by frame but per object (see also
Section 11.9). An object is animated by generating it with a symbolic
animation parameter and providing a range for this parameter in
the generating call. The section starting on page 11-71 provides fur-
ther details on animations.
✝ ✆
Presently, it is not possible to add objects to an existing plot. However, using

animations, it is possible to let primitives appear one after another in the
animated picture.
11-38
Some Examples
Example 1: We wish to visualize the interpolation of a discrete data sample by

cubic splines. First, we define the data sample, consisting of a list of points
[[x1 , y1 ], [x2 , y2 ], . . . ]. Suppose they are equidistant sample points from the graph
of the function f (x) = x · e−x · sin(5 x):
f := x -> x*exp(-x)*sin(5*x):
data := [[i, f(i)] $ i = 0..3 step 1/3]:
We use numeric::cubicSpline to define the cubic spline interpolant through

these data:
S := numeric::cubicSpline(op(data)):
The plot shall consist of the function f (x) that provides the data of the sample
points and of the spline interpolant S(x). The graphs of f (x) and S(x) are
generated via plot::Function2d. The data points are plotted as a
plot::PointList2d:
11-39
11 Graphics
plot(plot::Function2d(f(x), x = 0..3, Color = RGB::Red,

LegendText = expr2text(f(x))),
plot::Function2d(S(x), x = 0..3, Color = RGB::Blue,
LegendText = "spline interpolant"),
plot::PointList2d(data, Color = RGB::Black),
GridVisible = TRUE, SubgridVisible = TRUE,
LegendVisible = TRUE)
11-40
Example 2: A cycloid is the curve that you get when following a point fixed to a
wheel rolling along a straight line. We visualize this construction by an animation
in which we use the x coordinate of the hub as the animation parameter. The
wheel is realized as a circle. There are 3 points fixed to the wheel: a green point on
the rim, a red point inside the wheel and a blue point outside the wheel:
WheelRadius := 1:
r := [1.5*WheelRadius, 1.0*WheelRadius, 0.5*WheelRadius]:
WheelCenter := [x, WheelRadius]:
WheelRim := plot::Circle2d(WheelRadius, WheelCenter,
x = 0..4*PI,
LineColor = RGB::Black):
WheelHub := plot::Point2d(WheelCenter, x = 0..4*PI,
PointColor = RGB::Black):
WheelSpoke := plot::Line2d(WheelCenter,
[WheelCenter[1] + max(r)*sin(x),
WheelCenter[2] + max(r)*cos(x)],
x = 0..4*PI, LineColor = RGB::Black):
color:= [RGB::Red, RGB::Green, RGB::Blue]:
Point[i] := plot::Point2d([WheelCenter[1] + r[i]*sin(x),
WheelCenter[2] + r[i]*cos(x)],
x = 0..4*PI,
PointColor = color[i],
PointSize = 2.0*unit::mm):
Cycloid[i] := plot::Curve2d([y + r[i]*sin(y),
WheelRadius + r[i]*cos(y)],
y = 0..x, x = 0..4*PI,
LineColor = color[i]):
end_for:
11-41
11 Graphics
plot(WheelRim, WheelHub, WheelSpoke, Point[i] $ i = 1..3,

Cycloid[i] $ i = 1..3, Scaling = Constrained,
Width = 120*unit::mm, Height = 35*unit::mm)
11-42
Example 3: We wish to visualize the solution of the ordinary differential

equation (ODE) y ′ (x) = −y(x)3 + cos(x) with the initial condition y(0) = 0. The
solution shall be drawn together with the vector field ⃗v (x, y) = (1, −y 3 + cos(x))
associated with this ODE (along the solution curve, the vectors of this field are
tangents of the curve). We use numeric::odesolve2 to generate the solution as a
function plot. Since the numerical integrator returns the result as a list of one
floating point value, one has to pass the single list entry as Y (x)[1] to
plot::Function2d. The vector field is generated via plot::VectorField2d:
f := (x, y) -> -y^3 + cos(x):

Y := numeric::odesolve2(
numeric::ode2vectorfield({y'(x) = f(x, y),
y(0) = 0}, [y(x)])):
plot(
plot::VectorField2d([1, f(x, y)], x = 0..6, y = -1..1,
Color = RGB::Blue, Mesh = [25, 25]),
plot::Function2d(Y(x)[1], x = 0..6, Color = RGB::Red,
LineWidth = 0.7*unit::mm),
GridVisible = TRUE, SubgridVisible = TRUE, Axes = Frame)
11-43
11 Graphics
Example 4: The radius r of an object with rotational symmetry around the

x-axis is measured at various x positions:
x 0.00 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 0.95 1.00
r(x) 0.60 0.58 0.55 0.51 0.46 0.40 0.30 0.15 0.23 0.24 0.20 0.00
A spline interpolation is used to define a smooth function r(x) from the

measurements:
samplepoints :=
[0.00, 0.60], [0.10, 0.58], [0.20, 0.55], [0.30, 0.51],
[0.40, 0.46], [0.50, 0.40], [0.60, 0.30], [0.70, 0.15],
[0.80, 0.23], [0.90, 0.24], [0.95, 0.20], [1.00, 0.00]:
r := numeric::cubicSpline(samplepoints):
We reconstruct the object as a surface of revolution via plot::XRotate. The

rotation angle is restricted to a range that leaves a gap in the surface. The spline
curve and the sample points are added as a plot::Curve3d and a
plot::PointList3d, respectively, and displayed in this gap:
11-44
plot(
plot::XRotate(r(x), x = 0..1,
AngleRange = 0.6*PI..2.4*PI,
Color = RGB::MuPADGold),
plot::Curve3d([x, 0, r(x)], x = 0..1,
LineWidth = 0.5*unit::mm,
Color = RGB::Black),
plot::PointList3d([[p[1], 0, p[2]] $ p in samplepoints],
PointSize = 2.0*unit::mm,
Color = RGB::Red),
CameraDirection = [70, -70, 40])
11-45
11 Graphics
The Full Picture: Graphical Trees

For a full understanding of the interactive features of the viewer to be discussed in
the next section, we need to know the structure of a MuPAD ® plot as a “graphical
tree.”
The root is the “canvas”; this is the drawing area into which all parts of the plot are
rendered. The type of the canvas object is plot::Canvas. Its physical size may be
specified via the attributes Width and Height.
Inside the canvas, one or more “graphical scenes” can be displayed. All of them
must be of the same dimension, i.e., objects of type plot::Scene2d or
plot::Scene3d, respectively. The following command displays four different 3D
scenes. We set the BorderWidth for all objects of type plot::Scene3d to some
positive value so that the drawing areas of the scenes become visible more clearly:
S1 := plot::Scene3d(plot::Sphere(1, [0, 0, 0],
Color = RGB::Red),
BackgroundStyle = LeftRight):
S2 := plot::Scene3d(plot::Box(-1..1, -1..1, -1..1,
Color = RGB::Green),
BackgroundStyle = TopBottom):
S3 := plot::Scene3d(plot::Cone(1, [0, 0, 0], [0, 0, 1],
Color = RGB::Blue),
BackgroundStyle = Pyramid):
S4 := plot::Scene3d(plot::Cone(1, [0, 0, 1], [0, 0, 0],
Color = RGB::Orange),
BackgroundStyle = Flat,
BackgroundColor = RGB::Gray):
11-46
plot(plot::Canvas(
S1, S2, S3, S4,
Width = 80*unit::mm, Height = 80*unit::mm,
Axes = None, BorderWidth = 0.5*unit::mm,
plot::Scene3d::BorderWidth = 0.5*unit::mm))
See Section “Layout of Canvas and Scenes” of the online plot documentation for
details on how the layout of a canvas containing several scenes is set.
Coordinate systems exist inside a 2D scene or a 3D scene and are of type
plot::CoordinateSystem2d or plot::CoordinateSystem3d, respectively. There
may be one or more coordinate systems in a scene. Inside the coordinate systems,
an arbitrary number of primitives (of the appropriate dimension) can be
displayed. Thus, we always have a canvas, containing one or more scenes, with
each scene containing one or more coordinate systems. The graphical primitives
(or groups of such primitives) are contained in the coordinate systems.
11-47
11 Graphics
Hence, any MuPAD plot has the following general structure:

Canvas
Scene 1
CoordinateSystem 1
Primitive 1
Primitive 2
…
CoordinateSystem 2
Primitive
…
…
Scene 2
CoordinateSystem 3
Primitive
…
…
…
This is the “graphical tree” that is displayed by the “object browser” (see
page 11-50).
Shortcuts: For simple plots containing primitives inside one coordinate system
only that resides in a single scene of the canvas, it would be rather cumbersome to
generate the picture by a command such as
plot(
plot::Canvas(
plot::Scene2d(
plot::CoordinateSystem2d(Primitive1, Primitive2, ...))))
In fact, the command

plot(Primitive1, Primitive2, ...)
suffices: It is a shortcut of the above command. It automatically generates a

coordinate system that contains the primitives, embedded in a scene which is
automatically placed inside a canvas object.
11-48
Thus, this command implicitly creates the graphical tree

Canvas
Scene
CoordinateSystem
Primitive 1
Primitive 2
…
that is displayed in the object browser.
11-49
11 Graphics
Viewer, Browser, and Inspector: Interactive Manipulation

After a plot command is executed in a notebook, the plot will typically appear
below the input region, embedded in the notebook. To “activate” the plot, click on
it with the left mouse button. This leaves the plot embedded in the notebook, but
the notebook menus are replaced by the graphics menus.
Make sure that the item ‘Object Browser’ is enabled under the ‘View’ menu. A
pane titled ‘Object Browser’ is visible containing two sub-windows, which we will
refer to as the ‘object browser’ and the ‘property inspector.’
In the object browser, the graphical tree of the plot as introduced in the preceding
section is visible. It allows to select any node of the graphical tree by a mouse click.
After selecting an object in the object browser, the corresponding part of the plot
is highlighted in some way allowing to identify the selected object visually. The
property inspector then displays the attributes the selected object reacts to. For
example, for an object of type Function2d, the attributes visible in the property
inspector are categorized as ‘Definition,’ ‘Animation,’ ‘Annotation,’ ‘Calculation,’
and ‘Style’ with the latter split into the sub-categories (Style of) ‘Lines,’ (Style of)
‘Points,’ (Style of) ‘Asymptotes.’ Opening one of these categories, one finds the
attributes and their current values that apply to the currently selected object.
11-50
After selection of an attribute with the mouse, its value can be changed:
There is a sophisticated way of setting defaults (see Section 11.7 and Section 11.7
for an explanation) for the attributes via the object browser and the property
inspector. The ‘View’ menu provides an item ‘Hide Defaults.’ Disabling ‘Hide
Defaults,’ the object browser shows entries for defaults:
11-51
11 Graphics
At each node of the graphical tree, default values for the inheritable attributes can
be set via the property inspector. These defaults are valid for all primitives that
exist below this node, unless these defaults are re-defined at some other node
further down in the tree hierarchy.
This mechanism is particularly useful when there are many primitives of the same
kind in the plot. Imagine a picture consisting of 1000 points. If you wish to
change the color of all points to green, it would be quite cumbersome to set
PointColor = RGB::Green in all 1000 points. Instead, you can set
PointColor = RGB::Green in the PointColor defaults entry at some tree node that
contains all the points (e.g., the canvas), either directly in the plot call or via the
object browser/property inspector. Similarly, if there are 1000 points in one scene
and another 1000 points in a second scene, you can change the color of all points
in the first scene by an appropriate default entry in the first scene, whilst the
default entry for the second scene can be set to a different value. See page 11-58
for an example.
11-52
A 3D plot can be rotated and shifted by the mouse. Also zooming in and out is
possible. In fact, these operations are realized by moving the camera around,
closer to, or farther away from the scene, respectively. There is a camera control
that may be switched on and off via the ‘Camera Control’ item of the ‘View’ menu
or the camera icon in the toolbar. It provides the current viewing parameters such
as camera position, focal point and the angle of the camera lens:
The section starting on page 11-112 provides more information on cameras.
11-53
11 Graphics
Primitives
In this section, we give a brief survey of the graphical primitives, grouping
constructs, transformations etc. provided by the plot library.
The following table lists the ‘low-level’ primitives:
✞ ☎
Arc2d, Arc3d circular arc,
Arrow2d, Arrow3d arrow,
Box rectangular box in 3D,
Circle2d, Circle3d circle,
Cone cone/conical frustum in 3D,
Cylinder cylinder in 3D,
Ellipse2d, Ellipse3d ellipse,
Ellipsoid ellipsoid in 3D,
Line2d, Line3d (finite or infinite) line,
Parallelogram2d, Parallelogram3d parallelogram,
Plane infinte plane in 3D,
Point2d, Point3d point,
PointList2d, PointList3d list of points,
Polygon2d, Polygon3d line segments forming a polygon,
Rectangle rectangle in 2D,
Sphere sphere in 3D,
SurfaceSet surface in 3D
(as a collection of triangles),
SurfaceSTL import of 3D stl surfaces,
Text2d, Text3d text object.
✝ ✆
In addition, there are primitives plot::Tetrahedron, plot::Hexahedron,
plot::Octahedron, plot::Dodecahedron, and plot::Icosahedron for Plato’s
regular polyhedra and plot::Waterman for Waterman polyhedra.
The following table lists the ‘high-level’ primitives and ‘special purpose’
primitives:
11-54
Primitives
✞ ☎
Bars2d, Bars3d (statistical) data plot,
Boxplot (statistical) box plot,
Conformal plot of conformal functions in 2D,
Curve2d, Curve3d parameterized curve,
Cylindrical surface in cylindrical coordinates in 3D,
Density density plot in 2D,
Function2d, Function3d function graph,
Hatch hatched region in 2D,
Histogram2d (statistical) histogram plot in 2D,
Implicit2d implicitly defined curves in 2D,
Implicit3d implicitly defined surfaces in 3D,
Inequality visualization of inequalities in 2D,
Iteration visualization of iterations in 2D,
Listplot finite list of points,
Lsys Lindenmayer system in 2D,
Matrixplot visualization of matrices in 3D,
Ode2d, Ode3d graphical solution of an ODE,
Piechart2d, Piechart3d (statistical) pie chart,
Polar curve in polar coordinates in 2D,
Prism prism in 3D,
Pyramid pyramids and their frustrums in 3D,
QQPlot (statistical) quantile-quantile plots,
Raster raster and bitmap plots in 2D,
Rootlocus dependency of rational root on parameter,
Scatterplot (statistical) scatter plot in 2D,
Sequence sequence (given by formula) in 2D,
SparseMatrixplot sparsity pattern of a matrix, 2D,
Spherical surface in spherical coordinates in 3D,
Streamlines2d vector field visualization in 2D,
Sum visualization of symbolic sums in 2D,
Sweep sweep surface spanned by two curves in 3D,
Tube tube plot in 3D,
Turtle turtle plot in 2D,
VectorField2d, VectorField3d vector field plot,
Surface parameterized surface in 3D,
XRotate surface of revolution in 3D,
ZRotate surface of revolution in 3D.
✝ ✆
11-55
11 Graphics
The following table lists the various light sources available to illuminate 3D plots:
✞ ☎
AmbientLight ambient (undirected) light,
DistantLight directed light (sun light),
PointLight (undirected) point light,
SpotLight (directed) spot light.
✝ ✆
The following table lists various grouping constructs:
✞ ☎
Canvas drawing area,
Scene2d container for 2D coordinate systems,
Scene3d container for 3D coordinate systems,
CoordinateSystem2d container for 2D primitives,
CoordinateSystem3d container for 3D primitives,
Group2d group of primitives in 2D,
Group3d group of primitives in 3D.
✝ ✆
Primitives or groups of primitives can be transformed by the following objects:
✞ ☎
Scale2d, Scale3d scaling,
Reflect2d, Reflect3d reflection,
Rotate2d, Rotate3d rotation,
Translate2d, Translate3d translation,
Transform2d, Transform3d general linear transformation.
✝ ✆
Additionally, there are:
✞ ☎
Camera camera in 3D,
ClippingBox clipping box in 3D.
✝ ✆
11-56
Attributes
Attributes
The plot library provides more than 400 attributes for fine-tuning of the
graphical output. Because of this large number, the attributes are grouped into
various categories in the object browser (see page 11-50) and the documentation:
✞ ☎
category meaning
Animation parameters relevant for animations
Annotation footer, header, titles, and legends
Axes axes style and axes titles
Calculation numerical evaluation
Definition parameters that change the object itself
Grid Lines grid lines in the background (rulings)
Layout layout parameters for canvas and scenes
Style parameters that do not change the objects but their
presentation (visibility, color, line width, point size etc.)
Arrows style parameters for arrows
Lines style parameters for line objects
Points style parameters for point objects
Surface style parameters for surface objects in 3D
and filled areas in 2D
Tick Marks axes tick marks: style and labels
✝ ✆
On the help page for each primitive, there is a complete list of all attributes the
primitive reacts to. Clicking on an attribute, you are lead to the help page for this
attribute which provides all the necessary information concerning its semantics
and admissible values. The examples on the help page demonstrate the typical use
of the attribute.
Default Values
Most attributes have a default value that is used if no value is specified explicitly.
As an example, we consider the attribute LinesVisible that is used by several
primitives such as plot::Box, plot::Circle2d, plot::Cone, plot::Curve2d,
plot::Raster etc. Although they all use the same attribute named LinesVisible,
its default value differs among the different primitive types. The specific defaults
11-57
11 Graphics
are accessible by passing the slots plot::Box::LinesVisible,

plot::Circle2d::LinesVisible etc. to plot::getDefault:
plot::getDefault(plot::Box::LinesVisible),
plot::getDefault(plot::Circle2d::LinesVisible),
plot::getDefault(plot::Cone::LinesVisible),
plot::getDefault(plot::Raster::LinesVisible)
TRUE, TRUE, TRUE, FALSE
If any of the default values provided by the MuPAD® system do not seem
appropriate for your applications, change these defaults via plot::setDefault:
plot::setDefault(plot::Box::LinesVisible = FALSE)
TRUE
(The return value is the previously valid default value.) Several defaults can be
changed simultaneously:
plot::setDefault(plot::Box::LinesVisible = FALSE,
plot::Circle2d::LinesVisible = FALSE,
plot::Circle2d::Filled = TRUE)
FALSE, TRUE, FALSE
plot::getDefault(plot::Box::LinesVisible)
FALSE
Inheritance of Attributes
The setting of default values for attributes is quite sophisticated. Assume that you
have two scenes that are to be displayed in one single canvas. Both scenes consist
of 51 graphical points, each:
points1 := plot::Point2d(i/50*PI, sin(i/50*PI)) $ i=0..50:
points2 := plot::Point2d(i/50*PI, cos(i/50*PI)) $ i=0..50:
S1 := plot::Scene2d(points1):
S2 := plot::Scene2d(points2):
11-58
Attributes
plot(S1, S2)
If we wish to color all points in both scenes red, we can set a default for the point
color in the plot command:
plot(S1, S2, PointColor = RGB::Red)
If we wish to color all points in the first scene red and all points in the second
scene blue, we can give each of the points the desired color in the generating call
to plot::Point2d. Alternatively, we can set separate defaults for the point color
inside the scenes:
S1 := plot::Scene2d(points1, PointColor = RGB::Red):
S2 := plot::Scene2d(points2, PointColor = RGB::Blue):
plot(S1, S2)
Here is the general rule for setting defaults inside a graphical tree (see page 11-46):
✞ ☎
When an attribute is specified in a node of the graphical tree, the specified value
serves as the default value for the attribute for all primitives that exist in the
subtree starting from that node.
✝ ✆
The default value can be overwritten by another value at each node further down
in the subtree (e.g., finally, by a specific value in the primitives). In the following
call, the default color ‘red’ is set in the canvas. This value is accepted and used in
11-59
11 Graphics
the first scene. The second scene sets the default color ‘blue’ overriding the default
value ‘red’ set in the canvas. Additionally, there is an extra point with a color
explicitly set to ‘black’. This point ignores the defaults set further up in the tree
hierarchy:
extrapoint := plot::Point2d(1.4, 0.5,
PointSize = 3*unit::mm,
PointColor = RGB::Black):
S1 := plot::Scene2d(points1, extrapoint):
S2 := plot::Scene2d(points2, extrapoint,
PointColor = RGB::Blue):
plot(plot::Canvas(S1, S2, PointColor = RGB::Red))
The following call generates the same result. Note that the plot command
automatically creates a canvas object and passes the attribute
PointColor =RGB::Red to the canvas:
plot(S1, S2, PointColor = RGB::Red)
We note that there are different primitives that react to the same attribute. We
used LinesVisible in the previous section to demonstrate this fact. One of the
rules for inheriting attributes in a graphical tree is:
✞ ☎
If an attribute such as LinesVisible = TRUE is specified in some node of the
graphical tree, all primitives below this node that react to this attribute use the
specified value as the default value.
If a type specific attribute (using the “fully qualified” syntax) such as
plot::Circle2d::LinesVisible = TRUE is specified, the new default value is
valid only for primitives of that specific type.
✝ ✆
In the following example, we consider 100 randomly placed circles with a

rectangle indicating the area into which all circle centers are placed:
rectangle := plot::Rectangle(0..1, 0 ..1):
circles := plot::Circle2d(0.05, [frandom(), frandom()])
$ i = 1..100:
11-60
Attributes
plot(rectangle, circles, Axes = Frame)
We wish to turn the circles into filled circles by setting Filled = TRUE and
LinesVisible = FALSE:
plot(rectangle, circles,
Filled = TRUE, FillPattern = Solid,
LinesVisible = FALSE, Axes = Frame)
11-61
11 Graphics
This is not quite what we wanted: Not only the circles, but also the rectangle
reacts to the attributes Filled, FillPattern, and LinesVisible. The following
command restricts these attributes to the circles:
plot(rectangle, circles,
plot::Circle2d::Filled = TRUE,
plot::Circle2d::FillPattern = Solid,
plot::Circle2d::LinesVisible = FALSE,
Axes = Frame)
Primitives Requesting Special Scene Attributes: “Hints”
The default values for the attributes are chosen in such a way that they produce
reasonable pictures in “typical” plot commands. For example, the default axes
type in 3D scenes is Axes = Boxed, because this is the most appropriate axes type in
the majority of 3D plots:
plot::getDefault(plot::CoordinateSystem3d::Axes)
Boxed
However, there are exceptions. E.g., a plot containing a 3D pie chart should
probably have no axes at all. Since it is not desirable to use Axes = None as the
default setting for all plots, exceptional primitives such as plot::Piechart3d are
11-62
Attributes
given a chance to override the default axes automatically. In a pie chart plot, no
axes are used by default:
plot(plot::Piechart3d([20, 30, 10, 7, 20, 13],
Titles = [1 = "20%", 2 = "30%",
3 = "10%", 4 = "7%",
5 = "20%", 6 = "13%"]))
Note that the attribute Axes that is in charge of switching axes on and off is a
scene attribute and hence cannot be processed by pie chart objects directly.
Hence, a separate mechanism for requesting special scene attributes by primitives
is implemented: so-called “hints.”
A “hint” is an attribute of one of the superordinate nodes in the graphical tree, i.e.,
an attribute of a coordinate system, a scene, or the canvas. The help pages of the
primitives give information on what hints are sent by the primitive. If several
primitives send conflicting hints, the first hint is used.
Hints are implemented internally and cannot be switched off by the user. Note,
however, that the hints concept only concerns default values for attributes. You
can always specify the attribute explicitly if you think that a default value or a hint
is not appropriate.
11-63
11 Graphics
As an example, we explicitly request Axes = Boxed in the following call:

plot(plot::Piechart3d([20, 30, 10, 7, 20, 13],
Titles = [1 = "20%", 2 = "30%",
3 = "10%", 4 = "7%",
5 = "20%", 6 = "13%"]),
Axes = Boxed)
11-64
Attributes
The Help Pages of Attributes
We have a brief look at a typical help page for a plot attribute to explain the
information provided there:
✞ ☎
UMesh, VMesh, USubmesh, VSubmesh – number of sample
points
The attributes UMesh etc. determine the number of sample points used for the
numerical approximation of parameterized plot objects such as curves and
surfaces.
→ Examples
Attribute Type Value
USubmesh, VSubmesh inherited non-negative integer
UMesh, VMesh inherited positive integer
See Also
AdaptiveMesh, Mesh, Submesh, XMesh, YMesh, ZMesh
Objects reacting to UMesh, VMesh, USubmesh, VSubmesh
plot::Surface, plot::Cylindrical, 25 (UMesh, VMesh)
plot::XRotate, plot::Spherical, 0 (USubmesh,
plot::ZRotate VSubmesh)
plot::Tube 60 (UMesh)
11 (VMesh)
0 (USubmesh)
1 (VSubmesh)
…
Detail
• Many plot objects have to be evaluated numerically on a discrete mesh.
…
Example 1 …
✝ ✆
11-65
11 Graphics
In these help pages,
• the table entry “Type” (“inherited”) states that these attributes may not only
be specified in the generating call of graphical primitives. They can also be
specified at higher nodes of a graphical tree to be inherited by the primitives
in the corresponding subtree (see page 11-58).
• the table entry “Value” states the type of the number n that is admissible
when passing the attributes UMesh = n, VMesh = n etc.
• the sections “Object types reacting to UMesh” etc. provide complete

listings of all primitives reacting to the attribute(s) together with the specific
default values.
the “Details” section gives further information on the semantics of the
attribute(s). Finally, there are “Examples” of plot commands using the
described attribute(s).
11-66
Colors
Colors
The most prominent plot attribute, available for almost all primitives, is Color,
setting the ‘primary’ color of an object. MuPAD® ’s plot library knows 3 different
types of primary colors:
• The attribute PointColor refers to the color of points in 2D and 3D (of type
plot::Point2d and plot::Point3d, respectively).
• The attribute LineColor refers to the color of line objects in 2D and 3D. This
includes the color of function graphs in 2D, curves in 2D and 3D, polygon
lines in 2D and 3D etc. Also 3D objects such as function graphs in 3D,
parametrized surfaces etc. react to the attribute LineColor; it defines the
color of the coordinate mesh lines that are displayed on the surface.
• The attribute FillColor refers to the color of closed and filled polygons in
2D and 3D as well as hatched regions in 2D. Further, it sets the surface color
of function graphs in 3D, parametrized surfaces etc. This includes spheres,
cones etc.
The primitives also accept the attribute Color as a shortcut for one of these colors.
Depending on the primitive, either PointColor, LineColor, or FillColor is set
with the Color attribute.
RGB Colors
MuPAD® uses the RGB color model, i.e., colors are specified by lists [r, g, b] of
red, green, and blue values between 0 and 1, or in HTML syntax as a hash mark
followed by a six-digit hexadecimal number, as in #cc0099. Black and white
correspond to [0, 0, 0] (#000000) and [1, 1, 1] (#ffffff), respectively. The
library RGB contains numerous color names with corresponding RGB values:
RGB::Black, RGB::White, RGB::Red, RGB::SkyBlue
[0.0, 0.0, 0.0] , [1.0, 1.0, 1.0] , [1.0, 0.0, 0.0] , [0.0, 0.8, 1.0]
List all color names available in the RGB library via info(RGB). Alternatively, there
is the command RGB::ColorNames() returning a complete list of names. With
11-67
11 Graphics
RGB::ColorNames(Red)
[CadmiumRedDeep, CadmiumRedLight, CardinalRed,
CarmineRed, DarkRed, EnglishRed, IndianRed,
OrangeRed, PermanentRedViolet, Red, VenetianRed,
VioletRed, VioletRedMedium, VioletRedPale]
one searches for all color names that contain ‘Red.’ To actually see the colors
found, use RGB::plotColorPalette:
RGB::plotColorPalette("red")
After exporting the color library via use(RGB), you can use the color names in the
short form Black, White, IndianRed etc. Note, however, that this command will
assign values to a little over 350 identifiers, precluding their use in other meanings.
RGBa color values consist of lists [r, g, b, a] containing a fourth entry: the
“opacity” value a between 0 and 1. (In HTML-like notation, the hexadecimal
specification has eight characters.) For a = 0, a surface patch painted with this
RGBa color is fully transparent (i.e., invisible). For a = 1, the surface patch is
opaque, i.e., it hides plot objects that are behind it. For 0 < a < 1, the surface
patch is semi-transparent, i.e., plot objects behind it shine through.
RGBa color values can be constructed easily via the RGB library. One only has to
append a fourth entry to the [r, g, b] lists provided by the color names. The easiest
11-68
Colors
way to do this is to append the list [a] to the RGB list via the concatenation
operator ‘.’. We create a semi-transparent gray:
RGB::Gray.[0.5]
[0.752907, 0.752907, 0.752907, 0.5]
The following command plots a highly transparent red box, containing a

somewhat less transparent green box with an opaque blue box inside:
plot(plot::Box(-3..3, -3..3, -3..3,
FillColor = RGB::Red.[0.2]),
plot::Box(-2..2, -2..2, -2..2,
FillColor = RGB::Green.[0.3]),
plot::Box(-1..1, -1..1, -1..1,
FillColor = RGB::Blue),
LinesVisible = TRUE, LineColor = RGB::Black,
Scaling = Constrained)
HSV Colors
Besides the RGB model, there are various other popular color formats used in
computer graphics. One is the HSV model (Hue, Saturation, Value). The RGB
library provides the routines RGB::fromHSV and RGB::toHSV to convert HSV
11-69
11 Graphics
colors to RGB colors and vice versa:

hsv := RGB::toHSV(RGB::Orange)
[24.0, 1.0, 1.0]
RGB::fromHSV(hsv) = RGB::Orange
[1.0, 0.4, 0.0] = [1.0, 0.4, 0.0]
With the RGB::fromHSV utility, all colors in a MuPAD plot can be specified easily
as HSV colors. For example, the color ‘violet’ is given by the HSV values
[290, 0.4, 0.6], whereas ‘dark green’ is given by the HSV specification
[120, 1, 0.4] (120 for ‘green,’ 0.4 for ‘dark’). Hence, a semi-transparent violet
sphere intersected by an opaque dark green plane may be specified as follows:
plot(plot::Sphere(1, [0, 0, 0],
Color = RGB::fromHSV([290, 0.4, 0.6, 0.5])),
plot::Surface([x, y, 0.5], x = -1..1, y = -1..1,
Mesh = [2, 2],
Color = RGB::fromHSV([120, 1, 0.4])))
11-70
Animations
Animations
Generating Simple Animations
Each primitive of the plot library knows how many specifications of type “range”
it has to expect.
✞ ☎
Whenever a graphical primitive receives a “surplus” range specification by
an equation such as a = amin..amax, the parameter a is interpreted as an “an-
imation parameter” assuming values from amin to amax.
✝ ✆
What is a “surplus” range? This is a specification that is not necessary for

generating a static object. For example, a static univariate function graph in 2D
such as
plot::Function2d(sin(x), x = 0..2*PI):
expects one plot range for the x coordinate, whereas a static bi-variate function
graph in 3D expects two plot ranges for the x and y coordinate:
plot::Function3d(sin(x^2 + y^2), x = 0..2, y = 0..2):
A static contour plot in 2D expects 2 ranges for the x and y coordinate:

plot::Implicit2d(x^2 + y^2 - 1, x = -2..2, y = -2..2):
A static contour plot in 3D expects 3 ranges for the x, y , and z coordinate:

plot::Implicit3d(x^2 + y^2 + z^2 - 1, x = -2..2,
y = - 2..2, z = - 2..2):
Any additional equation involving a range makes the primitive create an

animation. Since a static 2D function graph expects only one range (for the
independent variable), the following call is interpreted as an instruction to
generate an animated 2D function graph:
plot::Function2d(sin(x - a), x = 0..2*PI, a = 0..2*PI):
Thus, it is very easy indeed to create animated objects: just pass a “surplus” range
equation a = amin..amax to the generating call of the primitive. The name a of the
animation parameter is irrelevant; any symbolic name may be used. All other
11-71
11 Graphics
entries and attributes of the primitive that are symbolic expressions of the
animation parameter will be animated. In the following call, both the function
expression as well as the x range of the function graph depend on the animation
parameter. Also, the ranges defining the width and the height of the rectangle as
well as the end point of the line depend on it:
plot(plot::Function2d(a*sin(x), x = 0..a*PI, a = 0.5..1),
plot::Rectangle(0..a*PI, 0..a, a = 0.5..1,
LineColor = RGB::Black),
plot::Line2d([0, 0], [PI*a, a], a = 0.5 ..1,
LineColor = RGB::Black))
11-72
Animations
Here is an animated arc whose radius and “angle range” depend on the animation
parameter:
plot(plot::Arc2d(1 + a, [0, 0], AngleRange = 0..a*PI,
a = 0..1))
Here, an additional range specification for the attribute AngleRange is used.

However, the attribute is identified by its name as an admissible attribute for the
primitive and thus not assumed to be the specification of an animation parameter.
✞ ☎
Beware! Do make sure that attributes are specified by their correct names.
If an incorrect attribute name is used, it may be mistaken for an animation
parameter!
✝ ✆
In the following examples, we wish to define a static semi-circle, using

plot::Arc2d with AngleRange = 0..PI. However, AngleRange is spelled
incorrectly. A plot is created. It is an animated full circle with the animation
parameter AngelRange!
plot(plot::Arc2d(1, [0, 0], AngelRange = 0..PI))
The animation parameter may be any symbolic parameter (identifier or indexed

identifier) that is different from the symbols used for the mandatory range
11-73
11 Graphics
specifications (such as the names of the independent variables in function

graphs). The parameter must also be different from any of the protected names of
the plot attributes.
✞ ☎
Animations are created object by object. The names of the animation param-
eters in different objects need not coincide.
✝ ✆
In the following example, different names a and b are used for the animation
parameters of the two functions:
plot(plot::Function2d(4*a*x, x = 0..1, a = 0..1),
plot::Function2d(b*x^2, x = 0..1, b = 1..4))
An animation parameter is a global symbolic name. It can be used as a global

variable in procedures defining the graphical object. The following example
features the 3D graph of a bi-variate function that is defined by a procedure using
the globally defined animation parameter. Further, a fill color function mycolor is
defined that changes the color in the course of the animation. It could use the
animation parameter as a global parameter, just like the function f does.
Alternatively, the animation parameter may be declared as an additional input
parameter. Refer to the help page of FillColorFunction to find out how many
input parameters the fill color function expects and which of the input parameters
11-74
Animations
receives the animation parameter. One finds that for Function3d, the fill color
function is called with the coordinates x, y , z of the points on the graph. The next
input parameter (the 4th argument of mycolor) is the animation parameter:
f := (x, y) -> 4 - (x - a)^2 - (y - a)^2:
mycolor := proc(x, y, z, a)
local t;
begin
t := sqrt((x - a)^2 + (y - a)^2):
if t < 0.1 then return(RGB::Red)
elif t < 0.4 then return(RGB::Orange)
elif t < 0.7 then return(RGB::Green)
else return(RGB::Blue)
end_if;
end:
plot(plot::Function3d(f, x = -1..1, y = -1..1, a = -1..1,
FillColorFunction = mycolor))
Playing Animations
When an animated plot is created in a MuPAD® notebook, the first frame of the
animation appears as a static picture below the input region. To start the
11-75
11 Graphics
animation, click on the plot. An icon for stopping and re-starting the animation
will appear (make sure the item ‘Animation Bar’ of the ‘View’ menu is enabled):
One can also use the slider to animate the picture “by hand.”
The Number of Frames and the Time Range
By default, an animation consists of 50 frames. The number of frames can be set

to be any positive number n by specifying the attribute Frames = n. This attribute
can be set in the generating call of the animated primitives, or at some higher
node of the graphical tree. In the latter case, this attribute is inherited by all
primitives that exist below the node. With a = amin..amax, Frames = n, the i-th
frame consists of a snapshot of the primitive with
i−1
a = amin + · (amax − amin ), i = 1, . . . , n.
n−1
Increasing the number of frames does not mean that the animation runs longer;
the renderer does not work with a fixed number of frames per second but
processes all frames within a fixed time interval.
11-76
Animations
In the background, there is a “real time clock” used to synchronize the animation
of different animated objects. An animation has a time range measured by this
clock. The time range is set by the attributes TimeBegin = t0, TimeEnd = t1 or,
equivalently, TimeRange = t0..t1, where t0, t1 are real numerical values
representing physical times in seconds. These attribute can be set in the
generating call of the animated primitives, or at some higher node of the graphical
tree. In the latter case, these attributes are inherited by all primitives that exist
below the node.
The absolute value of t0 is irrelevant if all animated objects share the same time
range. Only the time difference t1 - t0 matters. It is (an approximation of) the
physical time in seconds that the animation will last.
✞ ☎
The parameter range amin..amax in the specification of the animation param-
eter a = amin..amax together with Frames = n defines an equidistant time mesh
in the time interval set by TimeBegin = t0 and TimeEnd = t1. The frame with
a = amin is visible at the time t0, the frame with a = amax is visible at the time
t1.
✝ ✆
✞ ☎
With the default TimeBegin = 0, the value of the attribute TimeEnd gives the
physical time of the animation in seconds. The default value is TimeEnd = 10,
i.e., an animation using the default values will last about 10 seconds. The
number of frames set by Frames = n does not influence the time interval, but
changes the number of frames displayed in this time interval.
✝ ✆
Here is a simple example:

plot(plot::Point2d([a, sin(a)], a = 0..2*PI,
Frames = 50, TimeRange = 0..5))
The point will be animated for about 5 physical seconds in which it moves along
one period of the sine graph. Each frame is displayed for about 0.1 seconds. After
increasing the number of frames by a factor of 2, each frame is displayed for about
0.05 seconds, making the animation somewhat smoother:
plot(plot::Point2d([a, sin(a)], a = 0..2*PI,
Frames = 100, TimeRange = 0..5))
11-77
11 Graphics
Note that the human eye cannot distinguish between different frames if they
change with a rate of more than 25 frames per second. Thus, the number of
frames n set for the animation should satisfy
n < 25 · (t1 − t0 ).
Hence, with the default time range TimeBegin = 0, TimeEnd = 10 (seconds), it does
not make sense to specify Frames = n with n > 250. If a higher frame number is
required to obtain a sufficient resolution of the animated object, one should also
increase the time for the animation by a sufficiently high value of TimeEnd.
What Can Be Animated?
We may regard a graphical primitive as a collection of plot attributes. (This is

actually what they are internally. Indeed, even the function expression sin(x) in
plot::Function2d(sin(x), x = 0..2*PI) is realized as the attribute
Function = sin(x).) So, the question is:
“Which attributes can be animated?”
The answer is: “Almost any attribute can be animated!” Instead of listing the
attributes that allow animation, it is much easier to characterize the attributes
that cannot be animated:
• None of the canvas attributes can be animated. This includes layout

parameters such as the physical size of the picture. See the help page of
plot::Canvas for a complete list of all canvas attributes.
• None of the attributes of 2D scenes and 3D scenes can be animated. This

includes layout parameters, background color and style, automatic camera
positioning in 3D etc. See the help pages of plot::Scene2d and
plot::Scene3d for a complete list of all scene attributes.
Note that there are camera objects of type plot::Camera that can be placed
in a 3D scene. These camera objects can be animated and allow to realize a
“flight” through a 3D scene. See Section 11.16 for details.
• None of the attributes of 2D coordinate systems and 3D coordinate systems

can be animated. This includes viewing boxes, axes, axes ticks, and grid
11-78
Animations
lines (rulings) in the background. See the help pages of

plot::CoordinateSystem2d and plot::CoordinateSystem3d for a
complete list of all attributes for coordinate systems.
Although the ViewingBox attribute of a coordinate system cannot be
animated, the user can still achieve animated visibility effects in 3D by
clipping box objects of type plot::ClippingBox.
• None of the attributes that are declared as “Attribute Type: inherited”

on their help page can be animated. This includes size specifications such as
PointSize, LineWidth etc.
• RGB and RGBa values cannot be animated. However, it is possible to

animate the coloring of lines and surfaces via user defined procedures. See
the help pages of LineColorFunction and FillColorFunction for details.
• The texts of annotations such as Footer, Header, Title, legend entries etc.
cannot be animated. The position of titles, however, can be animated.
There are special text objects plot::Text2d and plot::Text3d that allow to
animate the text as well as their position.
• Fonts cannot be animated.
• Attributes such as DiscontinuitySearch = TRUE or FillPattern = Solid that

can assume only finitely many values from a fixed discrete set cannot be
animated.
Nearly all attributes not falling into one of these categories can be animated. You
will find detailed information on this issue on the corresponding help pages of
primitives and attributes.
Advanced Animations: The Synchronization Model
As already explained on page 11-76, there is a “real time clock” running in the
background that synchronizes the animation of different animated objects.
Each animated object has its own separate “real time life span” set by the
attributes TimeBegin = t0, TimeEnd = t1 or, equivalently, TimeRange = t0..t1. The
values t0, t1 represent seconds measured by the “real time clock.”
11-79
11 Graphics
In most cases, there is no need to bother about specifying the life span. If
TimeBegin and TimeEnd are not specified, the default values TimeBegin = 0 and
TimeEnd = 10 are used, i.e., the animation will last about 10 seconds. These values
only need to be modified
• if a shorter or longer real time period for the animation is desired, or
• if the animation contains several animated objects, where some of the

animated objects are to remain static while others change.
Here is an example for the second situation. The plot consists of 3 jumping points.
For the first 5 seconds, the left point jumps up and down, while the other points
remain at their initial position. Then, all points stay static for 1 second. After a
total of 6 seconds, the middle point starts its animation by jumping up and down,
while the left point remains static in its final position and the right points stays
static in its initial position. After 9 seconds, the right point begins to move as well.
The overall time span for the animation is the hull of the time ranges of all
animated objects, i.e., 15 seconds in this example:
p1 := plot::Point2d(-1, sin(a), a = 0..PI,
Color = RGB::Red,
TimeBegin = 0, TimeEnd = 5):
p2 := plot::Point2d(0, sin(a), a = 0..PI,
Color = RGB::Black,
Color = RGB::Blue,
11-80
Animations
plot(p1, p2, p3, PointSize = 8.0*unit::mm,

YAxisVisible = FALSE)
Here, all points use the default settings VisibleBeforeBegin = TRUE and
VisibleAfterEnd = TRUE which make them visible as static objects outside the
time range of their animation. We set VisibleAfterEnd = FALSE for the middle
point, so that it disappears after the end of its animation. With
VisibleBeforeBegin = FALSE, the right point is not visible until its animation
starts:
p2::VisibleAfterEnd := FALSE:
p3::VisibleBeforeBegin := FALSE:
11-81
11 Graphics
plot(p1, p2, p3, PointSize = 8.0*unit::mm,

We summarize the synchronization model of animations:

✞ ☎
The total real time span of an animated plot is the physical real time given by
the minimum of the TimeBegin values of all animated objects in the plot to the
maximum of the TimeEnd values of all the animated objects.
✝ ✆
• When a plot containing animated objects is created, the real time clock is set
to the minimum of the TimeBegin values of all animated objects in the plot.
The real time clock is started when pushing the ‘play’ button for animations
in the graphical user interface.
• Before the real time reaches the TimeBegin value t0 of an animated object,
this object is static in the state corresponding to the begin of its animation.
Depending on the attribute VisibleBeforeBegin, it may be visible or
invisible before t0.
• During the time from t0 to t1, the object changes from its original to its final
state.
11-82
Animations
• After the real time reaches the TimeEnd value t1, the object stays static in the
state corresponding to the end of its animation. Depending on the value of
the attribute VisibleAfterEnd, it may stay visible or become invisible after
t1.
• The animation of the entire plot ends with the physical time given by the
maximum of the TimeEnd values of all animated objects in the plot.
Frame by Frame Animations
There are some special attributes such as VisibleAfter that are very useful to
build animations from purely static objects:
✞ ☎
With VisibleAfter = t0, an object is invisible from the start of the animation
until time t0. Then it will appear and remain visible for the rest of the anima-
tion.
✝ ✆
✞ ☎
With VisibleBefore = t1, an object is visible from the start of the animation
until time t1. Then it will disappear and remain invisible for the rest of the
animation.
✝ ✆
These attributes should not be combined to define a “visibility range” from t0 to

t1. Use the attribute VisibleFromTo instead:
✞ ☎
With VisibleFromTo = t0..t1, an object is invisible from the start of the an-
imation until time t0. Then it will appear and remain visible until time t1,
when it will disappear and remain invisible for the rest of the animation.
✝ ✆
We continue the example of the previous section in which we defined the

following animated points:
11-83
11 Graphics
p1 := plot::Point2d(-1, sin(a), a = 0..PI,

Color = RGB::Red,
Color = RGB::Black,
Color = RGB::Blue,
p2::VisibleAfterEnd := FALSE:
p3::VisibleBeforeBegin := FALSE:
We add a further point p4 that is not animated. We make it invisible at the start of
the animation via the attribute VisibleFromTo. It is made visible after 7 seconds
to disappear again after 13 seconds:
p4 := plot::Point2d(0.5, 0.5, Color = RGB::Black,
VisibleFromTo = 7..13):
The start of the animation is determined by p1 which bears the attribute

TimeBegin = 0, the end of the animation is determined by p3 which has set
TimeEnd = 15:
plot(p1, p2, p3, p4, PointSize = 8.0*unit::mm,
11-84
Animations
Although a typical MuPAD animation is generated object by object, each animated

object taking care of its own animation, we can also use the attributes
VisibleAfter, VisibleBefore, VisibleFromTo to build up an animation frame by
frame:
✞ ☎
“Frame by frame animations:” Choose a collection of (typically static)
graphical primitives that are to be visible in the i-th frame of the animation.
Set VisibleFromTo = t[i]..t[i+1] for these primitives, where t[i]..t[i+1]
is the real time life span of the i-th frame (in seconds). Finally, plot all frames
in a single plot command.
✝ ✆
Here is an example. We let two points wander along the graphs of the sine and the
cosine function, respectively. Each frame is to consist of a picture of two points.
We use plot::Group2d to define the frame; the group forwards the attribute
VisibleFromTo to all its elements:
t[i] := i/10;
end_for:
x := i/100*PI;
myframe[i] := plot::Group2d(
plot::Point2d([x, sin(x)], Color = RGB::Red),
plot::Point2d([x, cos(x)], Color = RGB::Blue),
VisibleFromTo = t[i]..t[i + 1]);
end_for:
11-85
11 Graphics
plot(myframe[i] $ i = 0..100, PointSize = 7.0*unit::mm)
This “frame by frame” animation certainly needs a little bit more coding effort
than the equivalent object-wise animation, where each of the points is animated.
11-86
Animations
Compare:
delete i:
plot(plot::Point2d([i/100*PI, sin(i/100*PI)],
i = 0..100, Color = RGB::Red),
plot::Point2d([i/100*PI, cos(i/100*PI)],
i = 0..100, Color = RGB::Blue),
Frames = 101, PointSize = 7.0*unit::mm)
There is a special kind of plot where “frame by frame” animations are very useful.
Note that in the present version of the graphics, new plot objects cannot be added
to a scene that is already rendered. With the special “visibility” animations for
static objects, however, one can easily simulate a plot that gradually builds up: fill
the frames of the animation with static objects that are visible for a limited time
only. The visibility can be chosen very flexibly by the user. For example, the static
objects can be made visible only for one frame (VisibleFromTo) which allows to
simulate moving objects.
11-87
11 Graphics
In the following example, we use VisibleAfter to fill up the plot gradually. We

demonstrate the caustics generated by sunlight in a tea√ cup. The rim of the cup,
regarded as a mirror, is given by the function f (x) = − 1 − x2 , x ∈ [−1, 1] (a
semi-circle). Sun rays parallel to the y -axis are reflected by the rim. After
reflection at the point (x, f (x)) of the rim, a ray heads into the direction
(−1, −(f ′ (x) − 1/f ′ (x))/2) if x is positive. It heads into the direction
(1, (f ′ (x) − 1/f ′ (x))/2) if x is negative. Sweeping through the mirror from left to
right, the incoming rays as well as the reflected rays are visualized as lines. In the
animation, they become visible after the time 5 x, where x is the coordinate of the
rim point at which the ray is reflected:
11-88
Animations
f := x -> -sqrt(1 - x^2):

plot(// The static rim:
plot::Function2d(f(x), x = -1..1,
Color = RGB::Black),
// The incoming rays:
plot::Line2d([x, 2], [x, f(x)],
Color = RGB::Orange,
VisibleAfter = 5*x
) $ x in [-1 + i/20 $ i = 1..39],
// The reflected rays leaving to the right:
plot::Line2d([x, f(x)],
[1, f(x)+(1-x)*(f'(x) - 1/f'(x))/2],
VisibleAfter = 5*x
) $ x in [-1 + i/20 $ i = 1..19],
// The reflected rays leaving to the left:
plot::Line2d([x, f(x)],
[-1, f(x) - (x+1)*(f'(x) - 1/f'(x))/2],
VisibleAfter = 5*x
) $ x in [-1 + i/20 $ i = 21..39],
ViewingBox = [-1..1, -1..1])
11-89
11 Graphics
Examples
Example 1: We build R x a 2D animation that displays a function f (x) together with

the integral F (x) = 0 f (y) dy . The area between the graph of f and the x-axis is
displayed as an animated hatch object. The current value of F (x) is displayed by
an animated text:
DIGITS := 2:
// the function, f(x):
f := x -> cos(x^2):
// the anti-derivative, F(x):
F := x -> numeric::int(f(y), y = 0..x):
// the graph of f(x):
g := plot::Function2d(f(x), x = 0..6,
Color = RGB::Blue):
// the graph of F(x):
G := plot::Function2d(F(x), x = 0..6,
Color = RGB::Black):
// a point moving along the graph of F(x):
p := plot::Point2d([a, F(a)], a = 0..6,
Color = RGB::Black):
// hatched region between the origin and
// the moving point p:
h := plot::Hatch(g, 0, 0..a, a = 0..6,
Color = RGB::Red):
// the right border line of the hatched region:
l := plot::Line2d([a, 0], [a, f(a)], a = 0..6,
Color = RGB::Red):
// a dashed vertical line from f(x) to F(x):
L1 := plot::Line2d([a, f(a)], [a, F(a)],
a = 0..6, Color = RGB::Black,
LineStyle = Dashed):
// a dashed horizontal line from the y axis to F(x):
L2 := plot::Line2d([-0.1, F(a)], [a, F(a)],
a = 0..6, Color = RGB::Black,
LineStyle = Dashed):
// the current value of F at the moving point p:
t := plot::Text2d(a -> F(a), [-0.2, F(a)], a = 0..6,
HorizontalAlignment = Right):
11-90
Animations
plot(g, G, p, h, l, L1, L2, t,

YTicksNumber = None, YTicksAt = [-1, 1]):
delete DIGITS:
Example 2: We build two 3D animations. The first one starts with a rectangular
strip that is deformed to an annulus in the x, y plane:
c := a -> 1/2 *(1 - 1/sin(PI/2*a)):
mycolor := (u, v, x, y, z) ->
[(u - 0.8)/0.4, 0, (1.2 - u)/0.4]:
rectangle2annulus := plot::Surface(
[c(a) + (u-c(a))*cos(PI*v), (u-c(a))*sin(PI*v), 0],
u = 0.8..1.2, v = -a..a, a = 1/10^10..1,
FillColorFunction = mycolor, Mesh = [3, 40],
Frames = 40):
11-91
11 Graphics
plot(rectangle2annulus, Axes = None,

CameraDirection = [-11, -3, 3])
The second animation twists the annulus to become a Moebius strip:

annulus2moebius := plot::Surface(
[((u - 1)*cos(a*v*PI/2) + 1)*cos(PI*v),
((u - 1)*cos(a*v*PI/2) + 1)*sin(PI*v),
(u - 1)*sin(a*v*PI/2)],
u = 0.8..1.2, v = -1..1, a = 0..1, Mesh = [3, 40],
FillColorFunction = mycolor, Frames = 20):
11-92
Animations
plot(annulus2moebius, Axes = None,

CameraDirection = [-11, -3, 3])
Note that the final frame of the first animation coincides with the first frame of the
second animation. To join the two separate animations, we can set appropriate
visibility ranges and plot them together. After 5 seconds, the first animation
object vanishes and the second takes over:
rectangle2annulus::VisibleFromTo := 0..5:
annulus2moebius::VisibleFromTo := 5..7:
11-93
11 Graphics
plot(rectangle2annulus, annulus2moebius,
Axes = None, CameraDirection = [-11, -3, 3])
11-94
Groups of Primitives
Groups of Primitives
An arbitrary number of graphical primitives in 2D or 3D can be collected in
groups of type plot::Group2d or plot::Group3d, respectively. This is useful for
handing down attribute values to all elements in a group.
In the following example, we visualize random generators with different
distributions by using them to position random points:
r1 := stats::normalRandom(0, 1):
group1 := plot::Group2d(plot::Point2d(r1(), r1())
$ i = 1..200):
r2 := stats::uniformRandom(-3, 3):
group2 := plot::Group2d(plot::Point2d(r2(), r2())
$ i = 1..500):
plot(group1, group2, Axes = Frame)
We cannot distinguish between the two kinds of points. Due to the grouping, it is
very easy to change their color, size, and style by setting the appropriate attributes
in the groups. Now, the two kinds of points can be distinguished easily:
11-95
11 Graphics
group1::PointColor := RGB::Red:
group1::PointStyle := XCrosses:
group2::PointColor := RGB::Blue:
group2::PointSize := 0.7*unit::mm:
plot(group1, group2, Axes = Frame)
11-96
Transformations
Transformations
Affine linear transformations ⃗x → A · ⃗x + ⃗b with a vector ⃗b and a matrix A can be
applied to graphical objects via transformation objects. There are special
transformations such as translations, scaling, and rotations as well as general
affine linear transformations:
• plot::Translate2d([b1, b2], Primitive1, Primitive2, ...) applies the

translation ⃗x → ⃗x + ⃗b by the vector ⃗b = (b1 , b2 )T to all points of 2D primitives.
• plot::Translate3d([b1, b2, b3], Primitive1, ...) applies the translation

⃗x → ⃗x + ⃗b by the vector b = (b1 , b2 , b3 )T to all points of 3D primitives.
• plot::Reflect2d([x1, y1], [x2, y2], Primitive1, ...) reflects all 2D

primitives about the line through the points [x1, y1] and [x2, y2].
• plot::Reflect3d([x, y, z], [nx, ny, nz], Primitive1, ...) reflects all 3D

primitives about the plane through the point [x, y, z] with the normal [nx,
ny, nz].
• plot::Rotate2d(angle, [c1, c2], Primitive1, ...) rotates all points of

2D primitives counter clockwise by the given angle about the pivot point
(c1 , c2 )T .
• plot::Rotate3d(angle, [c1, c2, c3], [d1, d2, d3], Primitive1, ...)

rotates all points of 3D primitives by the given angle around the rotation
axis specified by the pivot point (c1 , c2 , c3 )T and the direction (d1 , d2 , d3 )T .
• plot::Scale2d([s1, s2], Primitive1, ...) applies the diagonal scaling

matrix diag(s1 , s2 ) to all points of 2D primitives.
• plot::Scale3d([s1, s2, s3], Primitive1, ...) applies the diagonal

scaling matrix diag(s1 , s2 , s3 ) to all points of 3D primitives.
• plot::Transform2d([b1, b2], A, Primitive1, ...) applies the general

affine linear transformation ⃗x → A · ⃗x + ⃗b with a 2 × 2 matrix A and a vector
⃗b = (b1 , b2 )T to all points of 2D primitives.
• plot::Transform3d([b1, b2, b3], A, Primitive1, ...) applies the general

affine linear transformation ⃗x → A · ⃗x + ⃗b with a 3 × 3 matrix A and a vector
⃗b = (b1 , b2 , b3 )T to all points of 3D primitives.
11-97
11 Graphics
The ellipses plot::Ellipse2d provided by the plot library have axes parallel to
the coordinate axes. We use a rotation to create an ellipse with a different
orientation:
center := [1, 2]:
ellipse := plot::Ellipse2d(2, 1, center):
plot(plot::Rotate2d(PI/4, center, ellipse))
Transform objects can be animated. We build a group consisting of the ellipse and
its symmetry axes. An animated rotation is applied to the group:
g := plot::Group2d(ellipse,
plot::Line2d([center[1] + 2, center[2]],
[center[1] - 2, center[2]]),
plot::Line2d([center[1], center[2] + 1],
[center[1], center[2] - 1])):
11-98
Transformations
plot(plot::Rotate2d(a, center, a = 0..2*PI, g))
11-99
11 Graphics
Legends
The annotations of a MuPAD® plot may include a legend. A legend is a small table
that relates the color of an object with some text explaining the object:
f := 3*x*sin(2*x):
g := 4*x^2*cos(x):
h := sin(4*x)/x:
plotfunc2d(f, g, h, x = 0..PI/2):
By default, legends are provided only by plotfunc2d and plotfunc3d. These

routines define the legend texts as the expressions with which the functions are
passed to plotfunc2d or plotfunc3d, respectively.
11-100
Legends
A corresponding plot command using primitives of the plot library does not
generate the legend automatically:
plot(plot::Function2d(f, x = 0..PI/2, Color = RGB::Red),
plot::Function2d(g, x = 0..PI/2, Color = RGB::Green),
plot::Function2d(h, x = 0..PI/2, Color = RGB::Blue))
11-101
11 Graphics
However, legends can be requested explicitly:

plot(plot::Function2d(f, x = 0..PI/2, Color = RGB::Red,
Legend = "Function 1: ".expr2text(f)),
plot::Function2d(g, x = 0..PI/2, Color = RGB::Green,
Legend = "Function 2: ".expr2text(g)),
plot::Function2d(h, x = 0..PI/2, Color = RGB::Blue,
Legend = "Function 3: ".expr2text(h)))
Each graphical primitive accepts the attribute Legend. Passing this attribute to an
object triggers several actions:
• The object attribute LegendText is set to the given string.
• The object attribute LegendEntry is set to TRUE.
• A hint is sent to the scene containing the object advising it to use the scene
attribute LegendVisible = TRUE.
The attributes LegendText and LegendEntry are visible in the “object inspector” of
the interactive viewer (page 11-50) and can be manipulated interactively for each
single primitive after selection in the “object browser.” The attribute
LegendVisible is associated with the scene object accessible via the “object
browser.”
11-102
Legends
At most 20 entries can be displayed in a legend. If more entries are specified in a

plot command, the surplus entries are ignored. Further, the legend may not cover
more than 50% of the height of the drawing area of a scene. Only those legend
entries fitting into this space are displayed; remaining entries are ignored.
If the attribute LegendEntry = TRUE is set for a primitive, its legend entry is
determined as follows:
• If the attribute LegendText is specified, its value is used for the legend text.
• If no LegendText is specified, but the Name attribute is set, the name is used
for the legend text.
• If no Name attribute is specified either, the type of the object such as

Function2d, Curve2d etc. is used for the legend text.
Here are all attributes relevant for legends:

✞ ☎
Legend string sets LegendText to
the given string,
LegendEntry to
TRUE, and
LegendVisible to
TRUE.
LegendEntry TRUE, FALSE add this object to the TRUE for function
legend? graphs, curves, and
surfaces, FALSE
otherwise
LegendText string legend text
LegendVisible TRUE, FALSE legend on/off TRUE for
plotfunc2d/3d
plotting more than
one function, FALSE
otherwise
LegendPlacement Top, Bottom vertical placement Bottom
LegendAlignment Left, Center, Right horizontal alignment Center
LegendFont see page 11-104 font for the legend Sans-Serif 8
text
✝ ✆
Table 11.10: Attributes for the legend
11-103
11 Graphics
Fonts
The plot attributes for specifying fonts are AxesTitleFont, FooterFont,
HeaderFont, LegendFont, TextFont, TicksLabelFont, and TitleFont. Each such
font is specified by a MuPAD® list containing any of the following:
• A string denoting the font family: the available font families depend on the
fonts that are installed on your machine. Typical font families available on
Windows systems are "Times New Roman" (of type "serif"), "Arial" (of
type "sans-serif"), or "Courier New" (of type "monospace").
To find out which fonts are available on your machine, open the menu
‘Format,’ submenu ‘Font’ in your MuPAD notebook. The first column in the
font dialog provides the names of the font families that you may specify.
The most portable way of defining fonts is to use one the three generic
family names "serif", "sans-serif", or "monospace". The system will
automatically choose one of the available font families of the specified type
for you.
• A positive integer specifying the size of the font in points.
• When the parameter Bold is specified, the font is bold.
• When the parameter Italic is specified, the font is italic.
• A color specification.
• An alignment specification: it must be one of the flags Left, Center, or

Right.
11-104
Fonts
In the following example, we specify the font for the canvas header and footer:
plot(plot::Function2d(sin(x), x = 0..2*PI),
Header = "The sine function",
HeaderFont = ["monospace", 12, Bold],
Footer = "The sine function",
FooterFont = ["Times New Roman", 14, Italic])
11-105
11 Graphics
All font parameters are optional; some default values are chosen for entries that
are not specified. For example, if you do not care about the footer font family for
your plot, but you insist on a specific font size, you may specify a 14 pt font as
follows:
plot(plot::Function2d(sin(x), x = 0..2*PI),
Footer = "The sine function", FooterFont = [14])
11-106
Saving and Exporting Pictures
Interactive Saving and Exporting
The MuPAD® kernel uses an xml format to communicate with the renderer.
Usually, a plot command sends a stream of xml data directly to the viewer which
renders the picture.
After clicking on the picture, the notebook provides a menu item ‘File/Export
Graphics…’ that opens a dialog allowing to save the picture in a variety of
graphical formats:
• The image may also be stored in various standard bitmap formats such as
png, jpg etc.
• Graphics can be exported in eps (encapsulated postscript) format. Since eps

does not support transparency, however, graphics making use of
transparency will degrade in quality in this step. This includes most 3D
plots.
• MuPAD’s native format is indicated by the file extension ‘xvz’ for the
compressed and ‘xvc’ for the uncompressed version.
One can use MuPAD to open such files and display and manipulate the plots
contained therein.
• Further, there is jvx export (JavaView).
• MuPAD animations can be saved as animated gif files.
• On Windows® and Macintosh® systems, MuPAD animations can also be

saved as avi files.
• In a Mac OS® system, MuPAD animations can furthermore be saved as

Quicktime® movie files.
11-107
11 Graphics
Batch Mode
MuPAD plots can also be saved in “batch mode” by specifying the attribute
OutputFile = filename in a plot call:
plot(Primitive1, Primitive2, ...,

OutputFile = "mypicture.xvz")
Here, the extension xvz of the file name indicates that MuPAD’s xml data are to be
written in compressed format. Alternatively, the extension xvc may be used to
write the xml data without compression of the file (the resulting ascii file can be
read with any text editor). Files in both formats can be opened by MuPAD to
generate the plot encoded by the xml data.
If the MuPAD environment variable WRITEPATH does not have a value, the
previous call creates the file in the directory where MuPAD is installed. An
absolute pathname can be specified to place the file anywhere else:
OutputFile = "C:\\Documents\\mypicture.xvz")
Alternatively, the environment variable WRITEPATH can be set:

WRITEPATH := "C:\\Documents":
OutputFile = "mypicture.xvz")
Now, the plot data are stored in the file ‘C:\Documents\mypicture.xvz’.

Apart from saving files as xml data, MuPAD pictures can also be saved in a variety
of standard graphical formats such as jpg, eps, svg, bmp etc. In batch mode, the
export is triggered by the OutputFile attribute in the same way as for saving in
xml format. Just use an appropriate extension of the filename indicating the
format. The following commands save the plot in four different files in jpg, eps,
svg, and bmp format, respectively:
plot(Primitive1, ..., OutputFile = "mypicture.jpg"):
plot(Primitive1, ..., OutputFile = "mypicture.eps"):
plot(Primitive1, ..., OutputFile = "mypicture.svg"):
plot(Primitive1, ..., OutputFile = "mypicture.bmp"):
11-108
An animated MuPAD plot can be exported to avi format:

plot(plot::Function2d(exp(a*x), x = 0..1, a = -1..1)
OutputFile = "myanimation.avi")
If no file extension is specified by the file name, the default extension xvc is used,
i.e., uncompressed xml data are written.
If a notebook is saved to a file, its location in the file system is available inside the
notebook as the value of the environment variable NOTEBOOKPATH. If you wish to
save your plot in the same folder as the notebook, you may call
OutputFile = NOTEBOOKPATH."mypicture.xvz")
In addition to OutputFile, there is the attribute OutputOptions to specify

parameters for some of the export formats. The help page of this attribute
provides detailed information.
11-109
11 Graphics
Importing Pictures
MuPAD® does not provide for many tools to import standard graphical vector
formats, yet. Presently, the only supported vector type is the stl format, popular in
stereo lithography, which encodes 3D surfaces. It can be imported via the routine
plot::SurfaceSTL.
In contrast to graphical vector formats, there are many standard bitmap formats
such as bmp, gif, jpg, ppm etc. that can be imported. One can read such a file via
import::readbitmap, thus creating a MuPAD array of RGB color values or an
equivalent three-dimensional hardware float array that can be manipulated at
will. In particular, it can be fed into the routine plot::Raster which creates an
object that can be used in any 2D MuPAD plot. Note, however, that the import of
bitmap data consumes a lot of memory, i.e., only reasonably small bitmaps (up to
a few hundred pixels in each direction) should be processed. Memory
consumption is much smaller with hardware floating point arrays, which is why
import::reasonably uses them by default.
In the following example, we plot the probability density function and the
cumulative density function of the standard normal (“Gaussian”) distribution.
Paying tribute to Carl Friedrich Gauss, we wish to display <<<<<<< .mine his
picture in this plot. Assume that we have his picture as a png bitmap file
“Gauss.png.” We import the file via import::readbitmap that provides us with
the width and height in pixels and the color data: ======= his picture in this
plot. Assume that we have his picture as a png bitmap file “Gauss.png.” We
import the file via import::readbitmap that provides us with the width and
height in pixels and the color data: >>>>>>> .r52548
[width, height, gauss] := import::readbitmap("Gauss.png"):
Note the colon at the end of the above command! Without it, MuPAD will print
the color information on the screen, and formatting such a huge output takes time.
We have to use Scaling = Constrained to preserve the aspect ratio of the image.
Unfortunately, this setting is not appropriate for the function plots. So we use two
different scenes that are positioned via Layout = Relative. See Section ‘Layout of
Canvas and Scenes’ of the online plot documentation for details on how the
layout of a canvas containing several scenes is set.
11-110
Importing Pictures
pdf := stats::normalPDF(0, 1):

cdf := stats::normalCDF(0, 1):
plot(plot::Scene2d(plot::Function2d(pdf(x), x = -4..7),
plot::Function2d(cdf(x), x = -4..7),
Width = 1, Height = 1),
plot::Scene2d(plot::Raster(gauss),
Scaling = Constrained,
Width = 0.3, Height = 0.6,
Bottom = 0.25, Left = 0.6,
BorderWidth = 0.5*unit::mm,
Footer = "C.F. Gauss",
FooterFont = [8]),
Layout = Relative)
11-111
11 Graphics
Cameras in 3D
The MuPAD® 3D graphics model includes an observer at a specific position,
pointing a camera with a lens of a specific opening angle to some specific focal
point. The specific parameters “position,” “angle,” and “focal point” determine the
picture that the camera will take.
When a 3D picture is created,a camera with an appropriate default lens is
positioned automatically. Its focal point is chosen as the center of the graphical
scene. The interactive viewer allows to rotate the scene which, in fact, is
implemented internally as a change of the camera position. Also interactive
zooming in and zooming out is realized by moving the camera closer to or farther
away from the scene.
Apart from interactive camera motions, the perspective of a 3D picture can also be
set in the calls generating the plot. One way is to specify the direction from which
the camera is pointing towards the scene. This is done via the attribute
CameraDirection:
plot(plot::Function3d(sin(x + y^3), x = -1..1, y = -1..1),
CameraDirection = [-25, 20, 30])
11-112
Cameras in 3D

CameraDirection = [10, -40, 10])
In these calls, CameraDirection does not fully specify the position of the camera.
This attribute just requests the camera to be placed at some large distance from
the scene along the ray in the direction given by the attribute. The actual distance
from the scene is determined automatically to let the graphical scene fill the
picture optimally.
For a full specification of the perspective, there are camera objects of type
plot::Camera that allow to specify the position of the camera, its focal point and
the opening angle of its lens:
position := [-5, -10, 5]:
focalpoint := [0, 0, 0]:
angle := PI/12:
camera := plot::Camera(position, focalpoint, angle):
This camera can be passed like any graphical object to the plot command
generating the scene.
11-113
11 Graphics
Once a camera object is specified in a graphical scene, it determines the view. No

“automatic camera” is used any more:
camera)
11-114
Cameras in 3D
Camera objects can be animated:

camera := plot::Camera([3*cos(a), 3*sin(a), 1 + cos(2*a)],
[0, 0, 0], PI/3, a = 0..2*PI,
Frames = 100):
Inserting the animated camera in a graphical scene, we obtain an animated plot

simulating a “flight around the scene:”
camera)
In fact, several cameras can be installed simultaneously in a scene. Per default,

the first camera produces the view rendered. After clicking on another camera in
the object browser of the viewer (page 11-50), the selected camera takes over and
the new view is shown.
11-115
11 Graphics
Next, we have a look at a more appealing example: the so-called “Lorenz

attractor.” The Lorenz ODE is the system
   
x p · (y − x)
d   
y = −x · z + r · x − y 
dt
z x·y−b·z
with fixed parameters p, r, b. As a dynamical system for Y = [x, y, z], we have to
solve the ODE dY /dt = f (t, Y ) with the following vector field:
f := proc(t, Y)
local x, y, z;
begin
[x, y, z] := Y:
[p*(y - x), -x*z + r*x - y, x*y - b*z]
end_proc:
Consider the following parameters and the following initial condition Y0:
p := 10: r := 28: b := 1: Y0 := [1, 1, 1]:
The routine plot::Ode3d serves for generating a graphical 3D solution of a

dynamical system. It solves the ODE numerically and generates graphical data
from the numerical mesh. The plot data are specified by the user via “generators”
(procedures) that map a solution point (t, Y ) to a point (x, y, z) in 3D.
The following generator Gxyz produces a 3D phase plot of the solution. The
generator Gyz projects the solution curve to the (y, z) plane with x = −20; the
generator Gxz projects the solution curve to the (x, z) plane with y = −20; the
generator Gxy projects the solution curve to the (x, y) plane with z = 0:
Gxyz := (t, Y) -> Y:
Gyz := (t, Y) -> [-20, Y[2], Y[3]]:
Gxz := (t, Y) -> [Y[1], -20, Y[3]]:
Gxy := (t, Y) -> [Y[1], Y[2], 0]:
With these generators, we create a 3D plot object consisting of the phase curve
and its projections:
object := plot::Ode3d(f, [$ 1..50 step 1/10], Y0,
[Gxyz, Style = Splines, Color = RGB::Red],
[Gyz, Style = Splines, Color = RGB::LightGray],
[Gxz, Style = Splines, Color = RGB::LightGray],
[Gxy, Style = Splines, Color = RGB::LightGray]):
11-116
Cameras in 3D
We define an animated camera moving around the scene:

camera := plot::Camera(
[-1 + 100*cos(a), 6 + 100*sin(a), 120],
[-1, 6, 25], PI/6, a = 0..2*PI, Frames = 250):
The following plot call takes about half a minute on a 3 GHz computer:
plot(object, camera, Axes = Boxed, TicksNumber = Low)
Next, we wish to fly along the Lorenz attractor. We cannot use plot::Ode3d,
because we need access to the numerical data of the attractor to build a suitable
animated camera object. We use the numerical ODE solver numeric::odesolve2
and compute a list of numerical sample points on the Lorenz attractor. This takes
about twenty seconds on a 3 GHz computer:
Y := numeric::odesolve2(f, 0, Y0, RememberLast):
timemesh := [$ 0..500 step 1/50]:
Y := [Y(t) $ t in timemesh]:
11-117
11 Graphics
Similar to the picture above, we define a box around the attractor with the
projections of the solution curve:
box := [-15, 20, -20, 26, 1, 50]:
Yyz := map(Y, pt -> [box[1], pt[2], pt[3]]):
Yxy := map(Y, pt -> [pt[1], pt[2], box[5]]):
Yxz := map(Y, pt -> [pt[1], box[3], pt[3]]):
We create an animated camera using an animation parameter a that corresponds

to the index of the list of numerical sample points. The following procedure
returns the i-th coordinate (i = 1, 2, 3) of the a-th point in the list of sample points
(see Chapter 17, especially the section starting on page 17-7 for details):
Point := proc(a, i)
begin
if domtype(float(a)) <> DOM_FLOAT then
procname(args());
else Y[round(a)][i];
end_if;
end_proc:
In the a-th frame of the animation, the camera is positioned at the a-th sample
point of the Lorenz attractor, pointing toward the next sample point. Setting
TimeRange = 0..n/10, the camera visits about 10 points per second:
11-118
Cameras in 3D
n := nops(timemesh) - 1:
plot(plot::Scene3d(
plot::Camera([Point(a, i) $ i = 1..3],
[Point(a + 1, i) $ i = 1..3],
PI/4, a = 1..n, Frames = n,
TimeRange = 0..n/10),
plot::Polygon3d(Y, LineColor = RGB::Red,
PointsVisible = TRUE),
plot::Polygon3d(Yxy, LineColor = RGB::DimGray),
plot::Polygon3d(Yxz, LineColor = RGB::DimGray),
plot::Polygon3d(Yyz, LineColor = RGB::DimGray),
plot::Box(box[1]..box[2], box[3]..box[4],
box[5]..box[6], Filled = TRUE,
LineColor = RGB::Black,
FillColor = RGB::Gray.[0.1]),
BackgroundStyle = Flat))
11-119
11 Graphics
Strange Effects in 3D? Accelerated OpenGL® library?

The rendering engine for 3D plots uses the OpenGL® library. OpenGL library is a
widely used graphics standard and (almost) any computer has appropriate drivers
installed in its system.
By default, MuPAD® under Windows® uses a software OpenGL driver provided by
the Windows operating system. Depending on the graphics card of your machine,
you may also have further OpenGL drivers on your system, maybe using hardware
support to accelerate your OpenGL library.
The MuPAD 3D graphics was written and tested using certain standard OpenGL
drivers. The numerous drivers available on the market have different rendering
quality and differ slightly. This may, in rare cases, lead to some unexpected
graphical effects on your machine.
After double clicking on a 3D plot, the ‘Help’ menu contains an entry ‘OpenGL
Info …’ providing the information which OpenGL driver you are currently using.
You also get the information how many light sources and how many clipping
planes this driver supports.
The entry ‘Configure …’ of the ‘View’ menu opens a dialog, which contains a
section ‘User Interface.’ This section contains two check boxes labeled ‘Accelerate
OpenGL’ and ‘Disable OpenGL,’ with the first one selecting between the divers
optimized for the hardware installed (which, as outlined above, may cause
problems due to bad drivers). The second checkbox should only be used in the
extremely unlikely event that 3D graphics do not work at all; on some systems,
opening any OpenGL program freezes the computer. Checking this box disables
MuPAD 3D graphics.
Thus, if you encounter strange graphical effects in 3D, we recommend to use this
configuration dialog to toggle hardware acceleration.
Exercise 11.1: Find alternative display styles for the plots in this chapter.
Especially, modify the example from page 11-43 to use plot::Ode2d and/or
plot::Streamlines2d.
11-120
12
Input and Output
Output of Expressions
MuPAD® does not display all computed results on the screen. Typical examples
are the commands within for loops (Chapter 15) or procedures (Chapter 17): only
the final result (i.e., the result of the last command) is printed and the output of
intermediate results is suppressed. Nevertheless, you can let MuPAD print
intermediate results or change the output format.
Printing Expressions on the Screen
The function print outputs MuPAD objects on the screen:

print("The ", i, "th prime is ", ithprime(i))
end_for
"The ", 4, "th prime is ", 7
"The ", 5, "th prime is ", 11
We recall that ithprime(i) computes the i-th prime. MuPAD encloses the text in
double quotes. Use the option Unquoted to suppress this:
12 Input and Output
print(Unquoted,
"The ", i, "th prime is ", ithprime(i))
end_for
The , 4, th prime is , 7
The , 5, th prime is , 11
Note that the option Unquoted breaks typesetting:

print(x^2); print(Unquoted, x^2)
x2
2
x
Furthermore, you can eliminate the commas from the output by means of the
tools for manipulating strings that are presented in Section 4.11:
print(Unquoted,
"The " . expr2text(i) . "th prime is " .
expr2text(ithprime(i)) . ".")
end_for
The 4th prime is 7.
The 5th prime is 11.
Here, the function expr2text is used to convert the value of i and the prime
returned by ithprime(i) to strings. Then, the concatenation operator . combines
them with the other strings to a single string. Note that converting an expression
to a string breaks typesetting as well as the “pretty print” format explained below:
print(Unquoted, expr2text(x^2))
x^2
Alternatively you can use the function fprint, which writes data to a file or on the
screen. In contrast to print, it does not output its arguments as individual
expressions. Instead, fprint combines them to a single string (if you use the
option Unquoted):
a := one: b := string:
12-2
Output of Expressions
fprint(Unquoted, 0, "This is ", a, " ", b)

This is one string
The second argument 0 tells fprint to direct its output to the screen.
Modifying the Output Format
Usually, MuPAD will format outputs in a way similar to how mathematical

formulas are usually written inRbooks or on a blackboard (“typeset expressions”):
P
integral signs are displayed as , symbolic sums appear as etc. This is the
format used in most “result regions” of this book. There are two other output
formats available. The following text refers to these ASCII-based output only,
which are used if the typesetting is switched off via the corresponding menu of the
notebook interface or when print with the option Plain is used.
Without typesetting, MuPAD usually prints expressions in a two-dimensional
form with simple (ascii) characters:
diff(sin(x)/cos(x), x)
2
sin(x)
------- + 1
2
cos(x)
This format is known as pretty print. It resembles the usual mathematical

notation. Therefore, it is often easier to read than a single line output. However,
MuPAD only uses pretty print for output and it is not a valid input format: in a
graphical user interface you cannot copy some output text with the mouse and
paste it as input somewhere else. (This is possible with typeset formulas, although
not for parts of a larger formula.)
The environment variable PRETTYPRINT controls the output format. The default
value of the variable is TRUE, i.e., the pretty print format is used for the output. If
you set this variable to FALSE, you obtain a one-dimensional output form which
can often also be used as input:
PRETTYPRINT := FALSE: diff(sin(x)/cos(x), x)
1/cos(x)^2*sin(x)^2 + 1
12-3
12 Input and Output
If an output would exceed the line width, the system automatically breaks the
lines:
PRETTYPRINT := TRUE: taylor(sin(x), x = 0, 16)
3 5 7 9 11
x x x x x
x - -- + --- - ---- + ------ - -------- +
6 120 5040 362880 39916800
13 15
x x 17
---------- - ------------- + O(x )
6227020800 1307674368000
You can set the environment variable TEXTWIDTH to the desired line width. Its
default value is 75 (characters), and you can assign any integer between 10 and
231 − 1 to it. For example, if you compute (ln ln x)′′ , then you obtain the following
output:
diff(ln(ln(x)), x, x)
1 1
- -------- - ---------
2 2 2
x ln(x) x ln(x)
If you reduce the value of TEXTWIDTH, the system breaks the output across two
lines:
TEXTWIDTH := 20: diff(ln(ln(x)),x,x)
1
- -------- -
2
x ln(x)
1
---------
2 2
x ln(x)
The default value is restored by deleting TEXTWIDTH:

delete TEXTWIDTH:
You can also control the output by user-defined preferences. This is discussed in
the section starting on page 13-2.
12-4
Reading and Writing Files

You can save the values of identifiers or a complete MuPAD ® session to a file and
read the file later into another MuPAD session.
The Functions write and read
The function write stores the values of identifiers in a file, so that you can reuse
the computed results in another MuPAD session. In the following example, we
save the values of the identifiers a and b to the file ab.mb:
a := 2/3: b := diff(sin(cos(x)), x):
write("ab.mb", a, b)
You pass the file name as a string (Section 4.11) enclosed in double quotes ". The
system then creates a file with this name (without "). If you read this file into
another MuPAD session via the function read, you can access the values of the
identifiers a and b without recomputing them:
reset():
read("ab.mb"): a, b
2
, − cos(cos(x)) sin(x)
3
If you use the function write as in the above example, it creates a file in the
MuPAD binary format. By convention, a file in this format should have the file
name extension “.mb”. You can call the function write with the option Text. This
generates a file in a readable text format:1
a := 2/3: b := exp(x+1):
write(Text, "ab.mu", a, b)
1 Usually the file name extension for MuPAD text files should be “ .mu”. The MuPAD editor allows
editing such files in a comfortable way.
12-5
12 Input and Output
The file ab.mu now contains the following two syntactically correct MuPAD
commands:
a := 2/3:
b := hold(exp)(hold(_plus)(hold(x), 1)):
You can use the function read to read this file:

a := 1: b := 2: read("ab.mu"): a, b
2 x+1
, e
3
The text format files generated by write contain valid MuPAD commands. Of
course, you can use any editor to generate such a text file “by hand” and read it
into a MuPAD session, using the command read or the entry ‘Read Commands …’
from the ‘Notebook’ menu. In fact this is a natural way to proceed when you
develop more complex MuPAD procedures.
Saving a MuPAD® Session
If you call the function write without supplying any identifiers as arguments, the
system writes the values of all identifiers having a value to a file, except for those
defined by the MuPADsystem itself. Thus, it is possible to restore the state of the
current session via read at a later time:
result1 := ...; result2 := ...; ...
write("results.mb")
Reading Data from a Text File
Often you want to use data in MuPAD that are generated by other software (for
example, you might want to read in statistical values for further processing), or
access all files in some directory automatically. This is possible with the help of
the function import::readdata from the library import. This function converts
the contents of a file to a nested MuPAD list. You may regard the file as a “matrix”
with line breaks indicating the beginning of a new row. Note that the rows may
12-6
have different length. You may pass an arbitrary character to import::readdata

as a column separator.
Suppose you have a file numericalData with the following 4 lines:
1 1.2 12
2.34 234
34 345.6
4 44 444
By default, blank characters are assumed as column separators. So you can read
this file into a MuPAD session as follows:
data := import::readdata("numericalData"):
data[1]; data[2]; data[3]; data[4]
[1, 1.2, 12]
[2.34, 234]
[34, 345.6]
[4, 44, 444]
The help page for import::readdata provides further information. Also see
import::csv for another important data exchange format.
12-7
13
Utilities
In this chapter we present some useful functions. Due to space limitations, we do

not explain their complete functionality and refer to the help pages for more
detailed information.
13 Utilities
User-Defined Preferences
You can customize MuPAD® ’s behavior by using preferences. The following
command lists all preferences:
Pref()
Pref::alias : TRUE
Pref::autoExpansionLimit: 1000
Pref::autoPlot : FALSE
Pref::callBack : NIL
Pref::callOnExit : NIL
Pref::dbgAutoDisplay : TRUE
Pref::dbgAutoList : TRUE
Pref::floatFormat : "g"
Pref::ignoreNoDebug : FALSE
Pref::keepOrder : DomainsOnly
Pref::kernel : [5, 0, 0]
Pref::maxMem : 0
Pref::maxTime : 0
Pref::output : NIL
Pref::postInput : NIL
Pref::postOutput : NIL
Pref::report : 0
Pref::trailingZeroes : FALSE
Pref::typeCheck : Interactive
Pref::unloadableModules : FALSE
Pref::userOptions : ""
Pref::verboseRead : 0
Pref::warnDeadProcEnv : FALSE
We refer to the help page ?Pref for a complete description of all preferences. Only
a few options are discussed below.
You can use the report preference to request regular information on MuPAD’s
allocated memory, the memory really used, and the elapsed computing time.
Valid arguments for report are integers between 0 and 9. The default value 0
means that no information is displayed. If you choose the value 9, you
permanently obtain information about MuPAD’s current state. You also get this
information in the status bar of the notebook, but the output of Pref::report will
stay in the output, allowing you to review the development over time.
13-2
Pref::report(9): int(sin(x)^2/x, x = 0..1)

[used=2880k, reserved=3412k, seconds=1]
γ Ci (2) ln (2)
− +
2 2 2
The preference floatFormat controls the output of floating-point numbers. For

example, if you supply the argument "e", floating-point numbers are printed with
mantissa and exponent (e.g., 1.234e-7 = 1.234 · 10−7 ). If you use the argument
"f", MuPAD prints them in fixed point representation:
Pref::floatFormat("e"): float(exp(-50))
1.928749848 · 10−22
Pref::floatFormat("f"): float(exp(-50))
0.0000000000000000000001928749848
You can use preferences to control the screen output in other ways as well. For
example, after calling Pref::output(F), MuPAD passes every result computed by
the kernel to the function F before printing it on the screen. The screen output is
then the result of the function F instead of the result originally computed by the
kernel. In the following example, we use this to compute and output the
normalization of every requested expression. We define a procedure F
(Chapter 17) and pass it to Pref::output:
Pref::output(x -> (x, normal(x))):
1 + x/(x + 1) - 2/x
x 2 −2 x2 + x + 2
− + 1, −
x+1 x x2 + x
The library generate contains functions for converting MuPAD expressions to the
input format of other programming languages (C, Fortran, or TEX). In the
following example, the MuPAD output is converted to a string. You might then
write this string to a text file for further processing with TEX:
Pref::output(generate::TeX): diff(f(x),x)
”\frac{\partial}{\partial x} f\!\left(x\right)”
13-3
13 Utilities
The following command resets the output routine to its original state:
Pref::output(NIL):
Some users want to obtain information on certain characteristics of all

computations, such as computing times. This can be achieved with the functions
Pref::postInput and Pref::postOutput. Both take MuPAD procedures as
arguments, which are then called after each input or output, respectively. In the
following example, we use a procedure that assigns the system time returned by
time() to the global identifier Time. This starts a “timer” before each computation:
Pref::postInput(proc() begin Time := time() end_proc):
We define a procedure myInformation which—among other things—uses this

timer to determine the time taken by the computation. It employs expr2text
(Section 4.11) to convert the numerical time value to a string and concatenates it
with some other strings. Moreover, the procedure uses domtype to find the
domain type of the object and converts it to a string as well. Finally it
concatenates the time information, some blanks " ", and the type information via
_concat. The function length is used to determine the precise number of blanks
so that the domain type appears flushed right on the screen:
myInformation := proc() begin
"domain type: ". expr2text(domtype(args()));
"time: ". expr2text(time() - Time). " msec";
_concat(%1,
" " $ TEXTWIDTH-1-length(%1)-length(%2),
%2)
end_proc:
We pass this procedure as argument to Pref::postOutput:

Pref::postOutput(myInformation):
After each computed result, the system now prints the string generated by the
procedure myInformation on the screen:
factor(x^3 - 1)

(x − 1) · x + x2 + 1
time: 80 msec domain type: Factored
13-4
You can reset a preference to its default value by specifying NIL as argument. For
example, the command Pref::report(NIL) resets the value of Pref::report to
0. Similarly, Pref(NIL) resets all preferences to their default values.
Exercise 13.1: The MuPAD function bytes returns the amount of logical and
physical memory used by the current MuPAD session. Let this information appear
on the screen after each output, using Pref::postOutput.
13-5
13 Utilities
The History Mechanism

Every input to MuPAD® yields a result after evaluation by the system. The
computed objects are stored internally in a history table. Note that the result of
every statement is stored, even if it is not printed on the screen. You can use it
later by means of the function last. The command last(1) returns the previous
result, last(2) the last but one, and so on. Instead of last(i), you may use the
shorter notation %i. Moreover, % is short for %1 or last(1). Thus the input
f := diff(ln(ln(x)), x): int(f, x)
can be passed to the system in the following equivalent form:

diff(ln(ln(x)), x): int(%, x)
This enables you to access intermediate results that have not been assigned to an
identifier. It is remarkable that the use of last may speed up certain interactive
evaluations when compared to the use of identifiers to store intermediate results.
In the following example, we first try to compute a definite integral symbolically.
After recognizing that MuPAD does not compute a symbolic value, we ask for a
floating-point approximation:
f := int(sin(x)*exp(x^3)+x^2*cos(exp(x)), x=0..1)
Z 1
3
x2 cos(ex ) + ex sin(x) dx
0
startingTime := time():
float(f);
(time() - startingTime)*msec
0.5356260737
750 msec
The function time returns the total computing time (in milliseconds) used by the
system since the beginning of the session. Thus the printed difference is the time
for computing the floating-point approximation.
13-6
The History Mechanism
In this example, we can reduce the computing time dramatically by employing

last:
f := int(sin(x)*exp(x^3)+x^2*cos(exp(x)), x = 0..1)
Z 1
3
x2 cos(ex ) + ex sin(x) dx
0
startingTime := time():
float(%2);
(time() - startingTime)*msec
0.5356260737
40 msec
In this case, the reason for the gain in speed is that MuPAD does not re-evaluate
the objects that last(i), %i, or % refer to.1 Thus calls to last form an exception to
the usual complete evaluation at interactive level (Section 5.2):
delete x: sin(x): x := 0: %2
sin(x)
You can enforce complete evaluation by using eval:

delete x: sin(x): x := 0: eval(%2)
0
Please note that the value of last(i) may differ from the i-th but last visible
output if you have suppressed the screen output of some intermediate results by
terminating the corresponding commands with a colon. Also note that the value
of the expression last(i) changes permanently during a computation:
1: last(1) + 1; last(1) + 1
2
1 Note that this gain in speed is only achieved when working interactively, since identifiers are eval-
uated with level 1 within procedures anyway (Section 17.11).
13-7
13 Utilities
The environment variable HISTORY determines the number of results that MuPAD
stores in a session and that can be accessed via last:
HISTORY
20
This default means that MuPAD stores the previous 20 expressions. Of course you
can change this default by assigning a different value to HISTORY. This may be
appropriate when MuPAD has to handle huge objects (such as very large
matrices) that fill up a significant part of the main memory of your computer.
Copies of these objects are stored in the history table, requiring additional storage
space. In this case, you would reduce the memory load by choosing small values in
HISTORY. Note that HISTORY only yields the value of the interactive “history
depth.” Inside a procedure, last only accepts the arguments 1, 2 and 3.
We strongly recommend to use last only interactively. The use of last within
procedures is considered bad programming style and should be avoided.
13-8
Information on MuPAD® Algorithms
Information on MuPAD® Algorithms

Some MuPAD® system functions may provide runtime information. The following
command makes all such procedures produce additional information on the
screen:
setuserinfo(Any, 1):
As an example, we invert the following matrix (Section 4.15) over the ring of
integers modulo 11:
M := Dom::Matrix(Dom::IntegerMod(11)):
A := M([[1, 2, 3], [2, 4, 7], [0, 7, 5]]):
A^(-1)
Info: using Gaussian elimination (LR decomposition)
 
1 mod 11 0 mod 11 6 mod 11
 
 3 mod 11 4 mod 11 8 mod 11 
9 mod 11 1 mod 11 0 mod 11
You obtain more detailed information by increasing the second argument of

setuserinfo (the “information level”):
setuserinfo(Any, 3): A^(-1)

Info: using Gaussian elimination (LR decomposition)
Info: searching for pivot element in column 1
Info: choosing pivot element 2 mod 11 (row 2)
 
1 mod 11 0 mod 11 6 mod 11
 
 3 mod 11 4 mod 11 8 mod 11 
9 mod 11 1 mod 11 0 mod 11
13-9
13 Utilities
If you enter
setuserinfo(Any, 0):
the system stops printing additional information:

A^(-1)
 
1 mod 11 0 mod 11 6 mod 11
 
 3 mod 11 4 mod 11 8 mod 11 
9 mod 11 1 mod 11 0 mod 11
The first argument of setuserinfo may be an arbitrary procedure name or library

name. Then the corresponding procedure(s) provide additional information.
Programmers of the system functions have built output commands into the code
via userinfo. These commands are activated by setuserinfo. You can use this in
your own procedures as well (?userinfo).
13-10
Restarting a MuPAD® Session
Restarting a MuPAD® Session

The command reset() resets a MuPAD® session to its initial state. Afterwards,
all identifiers that you defined previously have no value and all environment
variables are reset to their default values:
a := hello: DIGITS := 100: reset(): a, DIGITS
a, 10
13-11
13 Utilities
Executing Commands of the Operating System

You can use the function system (or the exclamation symbol ! for short) to
execute a command of the operating system. On UNIX ® platforms, the following
command lists the contents of the current directory:
!ls
bin Contributions doc fonts lib mmg
You can neither use the output of such a command for further computation nor
save it to a file.2 system returns the error status of the operating system to the
MuPAD® session. When called with the ! syntax, the output of this value is
suppressed.
2 If this is desired, you can use another command of the operating system to write the output to a
file and read this file into a MuPAD session via import::readdata.
13-12
14
Type Specifiers
The data structure of a MuPAD® object is its domain type, which can be requested
by means of the function domtype. The domain type reflects the structure that the
MuPAD kernel uses internally to manage the objects. The type concept also leads
to a classification of the objects according to their mathematical meaning:
numbers, sets, expressions, series expansions, polynomials, etc.
In this section, we describe how to obtain detailed information about the
mathematical structure of objects. For example, how can you find out efficiently
whether an integer of domain type DOM_INT is positive or even, or whether all
elements of a set are equations?
Such type checks are barely relevant when using MuPAD interactively: you can
control the mathematical meaning of an object by direct inspection. Type checks
are mainly used for implementing mathematical algorithms, i.e., when
programming MuPAD procedures (Chapter 17). For example, a procedure for
differentiating expressions has to decide whether its input is a product, a
composition of functions, a symbolic call of a known function, etc. Each case
requires a different action, such as supplying the product rule, the chain rule, etc.
14 Type Specifiers
The Functions type and testtype

For most MuPAD® objects, the function type returns, like domtype, the domain
type:
type([a, b]), type({a, b}), type(array(1..1))
DOM_LIST, DOM_SET, DOM_ARRAY
For expressions of domain type DOM_EXPR, the function type yields a finer
distinction according to the mathematical meaning of the expression: sums,
products, function calls, etc.:
type(a + b), type(a*b), type(a^b), type(a(b))
”_plus”, ”_mult”, ”_power”, ”function”
type(a = b), type(a < b), type(a <= b)
”_equal”, ”_less”, ”_leequal”
For most of these (with the exception of a(b)), the result returned by type is the
name of the function that generates the expression (internally, a symbolic sum or
product is represented by a call of the system functions _plus or _mult,
respectively). More generally, the result for most symbolic calls of system
functions is the identifier of the function as a string:
type(ln(x)), type(diff(f(x), x)), type(fact(x))
”ln”, ”diff”, ”fact”
You can use both the domain types DOM_INT, DOM_EXPR, etc. and the strings
returned by type as type specifiers. There exists a variety of other type specifiers
in addition to the “standard typing” of MuPAD objects given by type. An example
is Type::Numeric. This type comprises all “numerical” objects (of domain type
DOM_INT, DOM_RAT, DOM_FLOAT, or DOM_COMPLEX).
The call testtype(object, typeSpecifier) checks whether an object complies

with the specified type. The result is either TRUE or FALSE. Several type specifiers
may correspond to an object:
testtype(2/3, DOM_RAT), testtype(2/3, Type::Numeric)
TRUE, TRUE
14-2
The Functions type and testtype
testtype(2 + x, "_plus"), testtype(2 + x, DOM_EXPR)

TRUE, TRUE
testtype(f(x), "function"), testtype(f(x), DOM_EXPR)
TRUE, TRUE
Exercise 14.1: Consider the expression
i5/2 + i2 − i1/2 − 1
f (i) =
i5/2 + i2 + 2 i3/2 + 2 i + i1/2 + 1
How can MuPAD decide whether the set
S := {f(i) $ i = -1000..-2} union {f(i) $ i=0..1000}:
contains only rational numbers? Hint: For a specific integer i, use the function
normal to simplify subexpressions of f(i) containing square roots.
Exercise 14.2: Consider the expressions sin(i π/200) with integer values of i
between 0 and 100. Which of them are simplified by the MuPAD sin function,
which are returned as symbolic values sin(·)?
14-3
14 Type Specifiers
Comfortable Type Checking: the Type Library

The type specifiers presented above are useful only for checking relatively simple
structures. For more advanced type checking, more flexible type specifications are
needed. For example, how can you check without direct inspection whether the
object [1, 2, 3, ...] is a list of positive integers?
For that purpose, the Type library provides further type specifiers and
constructors. You can use them to create your own type specifiers, which are
recognized by testtype:
info(Type)
Library 'Type': type expressions and properties
-- Interface:
Type::AlgebraicConstant, Type::AnyType,
Type::Arithmetical, Type::Boolean,
Type::Complex, Type::Condition,
Type::Constant, Type::ConstantIdents,
Type::Equation, Type::Even,
Type::Function, Type::Imaginary,
Type::IndepOf, Type::Indeterminate,
Type::Integer, Type::Intersection,
Type::Interval, Type::ListOf,
Type::ListProduct, Type::NegInt,
Type::NegRat, Type::Negative,
Type::NonNegInt, Type::NonNegRat,
Type::NonNegative, Type::NonZero,
Type::Numeric, Type::Odd,
Type::PolyExpr, Type::PolyOf,
Type::PosInt, Type::PosRat,
Type::Positive, Type::Predicate,
Type::Prime, Type::Product,
Type::Property, Type::RatExpr,
Type::Rational, Type::Real,
Type::Relation, Type::Residue,
Type::SequenceOf, Type::Series,
Type::Set, Type::SetOf,
Type::Singleton, Type::TableOf,
Type::TableOfEntry, Type::TableOfIndex,
Type::Union, Type::Unknown,
Type::Zero
14-4
Comfortable Type Checking: the Type Library
For example, the type specifier Type::PosInt represents the set of positive
integers n > 0, Type::NonNegInt corresponds to the nonnegative integers n ≥ 0,
Type::Even and Type::Odd represent the even and odd integers, respectively.
These type specifiers are of domain type Type:
domtype(Type::Even)
Type
You can use such type specifiers to query the mathematical structure of MuPAD
objects via testtype. In the following example, we extract all even integers from a
list of integers via select (Section 4.6):
select([i $ i = 1..20], testtype, Type::Even)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
You can use constructors such as Type::ListOf or Type::SetOf to perform type

checking for lists or sets. For example, a list of integers is matched by the type
Type::ListOf(DOM_INT), a set of equations corresponds to the type specifiers
Type::SetOf(Type::Equation()) (or Type::SetOf("_equal")), a set of odd
integers is matched by the type Type::SetOf(Type::Odd):
T := Type::ListOf(DOM_INT):
testtype([-1, 1], T), testtype({-1, 1}, T),
testtype([-1, 1.0], T)
TRUE, FALSE, FALSE
The constructor Type::Union generates type specifiers corresponding to the

union of simpler types. For example, the following type specifier
T := Type::Union(DOM_FLOAT, Type::NegInt, Type::Even):
matches real floating-point numbers as well as negative integers as well as even

integers:
testtype(-0.123, T), testtype(-3, T),
testtype(2, T), testtype(3, T)
TRUE, TRUE, TRUE, FALSE
We describe an application of type checking for the implementation of MuPAD

procedures in Section 17.7.
14-5
14 Type Specifiers
Exercise 14.3: How can you compute the intersection of a set with the set of
positive integers?
Exercise 14.4: Use ?Type::ListOf to consult the help page for this type
constructor. Construct a type specifier corresponding to a list of two elements
such that each element is again a list with three arbitrary elements.
14-6
15
Loops
Loops are important elements of the MuPAD® programming language. The

following example illustrates the simplest form of a for loop:
x := i^2;
print("The square of", i, "is", x)
end_for:
"The square of", 1, "is", 1
The loop variable i automatically runs through the values 1, 2, 3, 4. For each value
of i, all commands between do and end_for are executed. There may be
arbitrarily many commands, separated by semicolons or colons. The system does
not print the results computed in each loop iteration on the screen, even if you
terminate the commands by semicolons. For that reason, we used the print
command to generate an output in the above example.
15 Loops
The following variant counts backwards. We use the tools from Section 4.11 to
make the output look more appealing:
for j from 4 downto 2 do
print(Unquoted,
"The square of ".expr2text(j)." is ".
expr2text(j^2))
end_for:
The square of 4 is 16
You can use the keyword step to increment or decrement the loop variable in
bigger or smaller steps:
for x from 3 to 8 step 2 do print(x, x^2) end_for:
3, 9
5, 25
7, 49
Note that at the end of the iteration with x = 7 the value of x is incremented to 9.
This exceeds the upper bound 8, and the loop terminates. Here is another variant
of the for loop:
for i in [5, 27, y] do print(i, i^2) end_for:
5, 25
27, 729
2
y, y
The loop variable only runs through the values from the list [5, 27, y]. As you can
see, such a list may contain symbolic elements such as the variable y .
15-2
Loops
In a for loop, a loop variable changes according to fixed rules (typically, it is

incremented or decremented). The repeat loop is a more flexible alternative,
where you can arbitrarily modify many variables in each step. In the following
example, we compute the squares of the integers i = 2, 22 , 24 , 28 , . . . until i2 > 100
holds for the first time:
x := 2:
repeat
i := x; x := i^2; print(i, x)
until x > 100 end_repeat:
2, 4
4, 16
16, 256
The system executes the commands between repeat and until repeatedly. The
loop terminates when the condition between until and end_repeat holds true. In
the above example, we have i = 4 and x = 16 at the end of the second step. Hence
the third step is executed, and afterwards we have i = 16, x = 256. Now the
termination condition x > 100 is satisfied and the loop terminates.
Another loop variant is the while loop:
x := 2:
while x <= 100 do
i := x; x := i^2; print(i, x)
end_while:
2, 4
4, 16
16, 256
In a repeat loop, the system checks the termination condition after each loop
iteration. In a while loop, this condition is checked before each iteration. As soon
as the condition evaluates to FALSE, the system terminates the while loop.
15-3
15 Loops
You can use break to abort a loop explicitly. Typically this is done within an if
construction (Chapter 16):
print(i);
if i^2 > 20 then break end_if
end_for:
3
After a call to next, the system skips all commands up to end_for. It returns
immediately to the beginning of the loop and starts the next iteration with the
next value of the loop variable:
x := i;
if i > 3 then next end_if;
y := i;
print(x, y)
end_for:
2, 2
3, 3
For i > 3, only the first assignment x:= i is executed:

x, y
5, 3
15-4
Loops
We recall that every MuPAD command returns an object. For a loop, this is the
return value of the most recently executed command. If you do not terminate the
loop command with a colon as in all of the above examples, then MuPAD displays
this value:
delete x: for i from 1 to 3 do x.i := i^2 end_for
9
You may process this value further. In particular, you can assign it to an identifier
or use it as the return value of a MuPAD procedure (Chapter 17):
factorial := proc(n)
local result;
begin
result := 1;
for i from 2 to n do
result := result * i
end_for
end_proc:
The return value of the above procedure is the return value of the for loop, which
in turn is the value of the last assignment to result.
Internally, loops are system function calls. For example, MuPAD processes a for
loop by evaluating the function _for:
_for(i, first_i, last_i, increment, command):
This is equivalent to
for i from first_i to last_i step increment do
command
end_for:
15-5
16
Branching instructions are an important element of every programming

language. Depending on the value or the meaning of variables, different
commands are executed. The simplest variant in MuPAD® is the if statement:
if isprime(i)
then print(expr2text(i)." is prime")
else print(expr2text(i)." is not prime")
end_if
end_for:
"2 is prime"
"3 is prime"
"4 is not prime"
Here, the primality test isprime(i) returns either TRUE or FALSE. If the value is
TRUE, the system executes the commands between then and else (in this case,
only one print command). If it is FALSE, the commands between else and end_if
are executed. The else branch is optional:
if isprime(i)
then text := expr2text(i)." is prime";
print(text)
end_if
end_for:
"2 is prime"
"3 is prime"
16 Branching: if-then-else and case
Here, the then branch comprises two commands separated by a semicolon (or,
alternatively, a colon). You may nest commands, loops, and branching statements
arbitrarily:
primes := []: evenNumbers := []:
if isprime(i)
then primes := primes.[i]
else if testtype(i,Type::Even)
then evenNumbers := evenNumbers.[i]
end_if
end_if
end_for:
In this example, we inspect the integers between 30 and 50. If we encounter a

prime, then we append it to the list primes. Otherwise, we use testtype to check
whether i is even (see Sections 14.1 and 14.2). In that case, we append i to the list
evenNumbers. Upon termination, the list primes contains all prime numbers
between 30 and 50, whilst evenNumbers contains all even integers in this range:
primes, evenNumbers
[31, 37, 41, 43, 47] , [30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]
You can create more complex conditions for the if statement by using the
Boolean operators and, or, and not (Section 4.10). The following for loop prints
all prime twins [i, i + 2] with i ≤ 100. The alternative condition not (i>3) yields
the additional pair [2, 4]:
if (isprime(i) and isprime(i+2)) or not (i>3)
then print([i,i+2])
end_if
end_for:
[2, 4]
[3, 5]
[5, 7]
...
16-2
Internally, an if statement is just a call of the system function _if:

_if(condition, command1, command2):
is equivalent to
if condition then command1 else command2 end_if:
The return value of an if statement is, as for any MuPAD procedure, the result of
the last executed command:1
x := -2: if x > 0 then x else -x end_if
2
For example, you can use the arrow operator -> (Section 4.12) to implement the
absolute value of numbers as follows:
Abs := y -> (if y > 0 then y else -y end_if):
Abs(-2), Abs(-2/3), Abs(3.5)
2
2, , 3.5
3
As you can see, you can use if commands both at the interactive level and within
procedures. The typical application is in programming MuPAD procedures, where
if statements and loops control the flow of the algorithm. A simple example is the
above function Abs. You find more examples in Chapter 17.
If you have several nested if … else if … constructions, you can abbreviate this by
using the elif statement:
if condition1 then
statements1
elif condition2 then
statements2
elif ...
else
statements
end_if:
1 If no command is executed then the result is null().
16-3
This is equivalent to the following nested if statement:

if condition1 then
statements1
else if condition2 then
statements2
else if ...
else
statements
end_if
end_if
end_if:
A typical application is for type checking within procedures (Chapter 17). The
following version of Abs computes the absolute value if the input is an integer, a
rational number, a real floating-point number, or a complex numbera. Otherwise,
it raises an error:
Abs := proc(y) begin
if (domtype(y) = DOM_INT) or (domtype(y) = DOM_RAT)
or (domtype(y) = DOM_FLOAT) then
if y > 0 then y else -y end_if;
elif (domtype(y) = DOM_COMPLEX) then
sqrt(Re(y)^2 + Im(y)^2);
else "Invalid argument type" end_if:
end_proc:
delete x: Abs(-3), Abs(5.0), Abs(1+2*I), Abs(x)
√
3, 5.0, 5, ”Invalid argument type”
16-4
In our example, we distinguish several cases according to the evaluation of a

single expression. We can also implement this by using a case statement, which is
often easier to read:
case domtype(y)
of DOM_INT do
of DOM_RAT do
of DOM_FLOAT do
if y > 0 then y else -y end_if;
break;
of DOM_COMPLEX do
sqrt(Re(y)^2 + Im(y)^2);
break;
otherwise
"Invalid argument type";
end_case:
The keywords case and end_case indicate the beginning and the end of the
statement, respectively. MuPAD evaluates the expression after case. If the result
matches one of the expressions between of and do, the system executes all
commands from the first matching of on until it encounters either a break or the
keyword end_case.
Warning: Note that, if no break statement used in a branch, the following
branches are entered and executed, too. This is in the same style as the switch
statement in the C programming language. It allows several branches to share the
same code.
If none of the of branches applies and there is an otherwise branch, the code
between otherwise and end_case is executed. The return value of a case
statement is the value of the last executed command. We refer to the
corresponding help page ?case for a more detailed description.
16-5
As for loops and if statements, there is a functional equivalent for a case

statement: the system function _case. Internally, MuPAD converts the above
case statement to the following equivalent form:
_case(domtype(y),
DOM_INT, NIL,
DOM_RAT, NIL,
DOM_FLOAT,
(if y > 0 then y else -y end_if; break),
DOM_COMPLEX, (sqrt(Re(y)^2 + Im(y)^2); break),
"Invalid argument type"):
Exercise 16.1: In if statements or termination conditions of while and repeat

loops, the system evaluates composite conditions with Boolean operators one
after the other. The evaluation routine stops prematurely if it can decide whether
the final result is TRUE or FALSE (“lazy evaluation”). Are there problems with the
following statements? What happens when the conditions are evaluated?
A := x/(x - 1) > 0: x := 1:
(if x <> 1 and A then right else wrong end_if),
(if x = 1 or A then right else wrong end_if)
16-6
17
MuPAD® Procedures
MuPAD® provides the essential constructs of a programming language. The user

can implement complex algorithms comfortably in MuPAD. Indeed, most of
MuPAD’s mathematical intelligence is not implemented in C or C++ within the
kernel, but in the MuPAD programming language at the library level. The
programming features are more extensive than in other languages such as C,
Pascal, or Fortran, since the MuPAD language offers more general and more
flexible constructs.
We have already presented basic structures such as loops (Chapter 15), branching
instructions (Chapter 16), and “simple” functions (page 4-52).
In this chapter, we regard “programming” as writing complex MuPAD procedures.
In principle the user recognizes no differences between “simple functions”
generated via -> (page 4-52) and “more complex procedures” as presented in this
chapter. Procedures, like functions, return values. Only the way of generating
such procedure objects via proc … end_proc is a little more complicated.
Procedures provide additional functionality: there is a distinction between local
and global variables, you can use arbitrarily many commands in a clear and
convenient way etc.
As soon as a procedure is implemented and assigned to an identifier, you may call
it in the form procedureName(arguments) like any other MuPAD function. After
executing the implemented algorithm, it returns an output value.
You can define and use MuPAD procedures within an interactive session, like any
other MuPAD object. Typically, however, you want to use these procedures again
in later sessions, in particular when they implement more complex algorithms.
Then it is useful to write the procedure definition into a text file using your
favorite text editor (such as, e.g., the MuPAD source code editor), and read it into
17 MuPAD® Procedures
a MuPAD session via read (page 12-5) or with the entry ‘Read commands …’ from
the ‘Notebook’ menu. Apart from the evaluation level, the MuPAD kernel
processes the commands in the file exactly in the same way as if they were entered
interactively. MuPAD includes an editor with syntax highlighting for MuPAD
programs.
17-2
Defining Procedures
Defining Procedures
The following function, which compares two numbers and returns their
maximum, is an example of a procedure definition via proc … end_proc:
maximum := proc(a, b) /* comment: maximum of a and b */
begin
if a<b then return(b) else return(a) end_if;
end_proc:
The text enclosed between /* and */ is a comment1 and completely ignored by the
system. This is a useful tool for documenting the source code when you write the
procedure definition in a text file.
The above sample procedure contains an if statement as the only command.
More realistic procedures contain many commands (separated by colons or
semicolons). The command return terminates a procedure and passes its
argument as output value to the system.
A MuPAD® object generated via proc … end_proc is of domain type DOM_PROC:
domtype(maximum)
DOM_PROC
You can decompose and manipulate a procedure like any other MuPAD object. In
particular, you may assign it to an identifier, as above. The syntax of the function
call is the same as for other MuPAD functions:
maximum(3/7, 0.4)
3
7
The statements between begin and end_proc may be arbitrary MuPAD

commands. In particular, you may call system functions or other procedures from
within a procedure. A procedure may even call itself, which is helpful for
implementing recursive algorithms.
1 Alternatively, you can start a comment by //. A comment started with // automatically ends at the
end of the line.
17-3
The favorite example for a recursive algorithm is the computation of the factorial
n! = 1 · 2 · · · · · n of a nonnegative integer, which may be defined by the rule
n! = n · (n − 1)! together with the initial condition 0! = 1. The realization as a
recursive procedure might look as follows:
factorial := proc(n) begin
if n = 0 then
return(1)
else return(n*factorial(n - 1))
end_if
end_proc:
factorial(10)
3628800
The environment variable MAXDEPTH determines the maximal number of nested

procedure calls. Its default value is 500. With this value, the above factorial
function works only for n ≤ 500. For larger values, after MAXDEPTH steps MuPAD
assumes that there is an infinite recursion and aborts with an error message. It is
advisable to avoid deep recursions, to save on memory, increase efficiency and to
avoid these problems.
17-4
The Return Value of a Procedure
The Return Value of a Procedure

When you call a procedure, the system executes its body, i.e., the sequence of
statements between begin and end_proc. Every procedure returns some value,
either explicitly via return or otherwise the value of the last command executed
within the procedure.2 Thus, you can implement the above factorial function
without using return:
if n = 0 then 1 else n*factorial(n - 1) end_if;
end_proc:
The if statement returns either 1 or n (n − 1)! . Since the end of the procedure is
reached directly after the if statement, this is the return value of the call
factorial(n).
As soon as the system encounters a return statement, it terminates the procedure:

if n = 0 then return(1) end_if;
n*factorial(n - 1);
end_proc:
For n = 0, MuPAD® does not execute the last statement (the recursive call of
n * factorial(n - 1)) after returning 1. For n ̸= 0, the most recently computed
value is n * factorial(n - 1), which is then the return value of the call
factorial(n).
2 If there is no command to execute, the return value is NIL.
17-5
A procedure may return an arbitrary MuPAD object, such as an expression, a

sequence, a set, a list, or even a procedure. However, if the returned procedure
uses local variables of the outer procedure, you have to declare the latter with the
option escape. Otherwise, this leads to a MuPAD warning message or to
unwanted effects. The following procedure returns a function that uses the
parameter power of the outer procedure:
generatePowerFunction := proc(power)
option escape;
begin
x -> (x^power)
end_proc:
f := generatePowerFunction(2):
g := generatePowerFunction(5):
f(a), g(b)
a2 , b5
17-6
Returning Symbolic Function Calls
Returning Symbolic Function Calls

Many system functions return “themselves” as symbolic function calls if they
cannot find a simple representation of the requested result:
sin(x), max(a, b), int(exp(x^3), x)
Z
3
sin(x) , max(a, b) , ex dx
You achieve the same behavior in your own procedures when you encapsulate the
procedure name in a hold upon return. The hold (page 5-4) prevents the function
from calling itself recursively and ending up in an infinite recursion. The
following function computes the absolute value for numerical inputs (integers,
rational numbers, real floating-point numbers, and complex numbers). For all
other kinds of inputs, it returns itself symbolically:
Abs := proc(x) begin
if testtype(x, Type::Numeric) then
if domtype(x) = DOM_COMPLEX then
return(sqrt(Re(x)^2 + Im(x)^2))
else if x >= 0 then
return(x)
else return(-x)
end_if
end_if
end_if;
hold(Abs)(x)
end_proc:
Abs(-1), Abs(-2/3), Abs(1.234), Abs(2 + I/3),
Abs(x + 1)
√
2 37
1, , 1.234, , Abs(x + 1)
3 3
17-7
A more elegant way is to use the MuPAD® object procname, which returns the
name of the calling procedure:
Abs := proc(x) begin
if testtype(x, Type::Numeric) then
if domtype(x) = DOM_COMPLEX then
return(sqrt(Re(x)^2 + Im(x)^2))
else if x >= 0 then
return(x)
else return(-x)
end_if
end_if
end_if;
procname(args())
end_proc:
Abs(-1), Abs(-2/3), Abs(1.234), Abs(2 + I/3),
Abs(x + 1)
√
2 37
1, , 1.234, , Abs(x + 1)
3 3
Here, we use the expression args(), which returns the sequence of arguments
passed to the procedure (cf. page 17-21).
17-8
Local and Global Variables

You can use arbitrary identifiers in procedures. They are also called global
variables:
a := b: f := proc() begin a := a^2 + 1 end_proc:
f(); f(); f()
b2 + 1
2
b2 + 1 +1
2 2
b2 + 1 +1 +1
The procedure f modifies the value of a, which has been set outside the
procedure. When the procedure terminates, a has a new value, which is again
changed by further calls to f.
The keyword local declares identifiers as local variables that are only valid
within the procedure:
a := b: f := proc() local a; begin a := 2 end_proc:
f(): a
b
Despite the equal names, the assignment a:= 2 of the local variable does not affect
the value of the global identifier a that has been defined outside the procedure.
You can declare an arbitrary number of local variables by specifying a sequence of
identifiers after local:
f := proc(x, y, z)
local A, B, C;
begin
A:= 1; B:= 2; C:= 3; A*B*C*(x + y + z)
end_proc:
f(A, B, C)
6A + 6B + 6C
17-9
Local variables of a procedure have a special domain type DOM_VAR. They do not
get mixed up with global variables which are identifiers of type DOM_IDENT. Note
that also local variables declared by the same name in the source code of different
functions have no reference to one another. Also, when calling a function several
times, a local variable refers to a different value in each call:
f := proc(x) local a, b;
begin
a := x;
if x > 0 then b := f(x - 1);
else b := 1;
end_if;
print(a, x);
b + a;
end:
f(2)
0, 0
1, 1
2, 2
We recommend to take into account the following rule of thumb:
Using global variables is generally considered bad programming style.

Use local variables whenever possible.
The reason for this principle is that procedures implement mathematical

functions, which should return a unique output value for a given set of input
values. If you use global variables then, depending on their values, the same
procedure call may lead to different results:
a := 1: f := proc(b) begin a := a + 1; a + b end_proc:
f(1), f(1), f(1)
3, 4, 5
Moreover, a procedure call can change the calling environment in a subtle way by
redefining global variables (“side effect”). In more complex programs, this may
lead to unwanted effects that are difficult to debug.
17-10
An important difference between global and local variables is that an uninitialized

global variable is regarded as a symbol, whose value is its own name, while the
value of an uninitialized local variable is NIL. Using a local variable without
initialization leads to a warning message in MuPAD® and should be avoided:
IAmGlobal + 1
IAmGlobal + 1
f := proc()
local IAmLocal;
begin
IAmLocal + 1
end_proc:
f()
Warning: Uninitialized variable 'IAmLocal' used;
during evaluation of 'f'
Error: Illegal operand [_plus];
The reason for the error is that MuPAD cannot add the value NIL of the local
variable to the number 1.
We now present a realistic example of a meaningful procedure. If we use arrays of
domain type DOM_ARRAY to represent matrices, we are faced with the problem that
there is no direct way to perform matrix multiplication with such arrays. 3 The
following procedure solves this problem: you can compute the matrix product
C = A · B with the command C:= MatrixProduct(A, B). We want the procedure to
work for arbitrary dimensions of the matrices A and B , provided the result is
defined mathematically. If A is an m × n matrix, then B may be an n × r matrix,
where m, n, r are arbitrary positive integers. The result is the m × r matrix C with
the entries
Xn
Cij = Aik Bkj , i = 1, . . . , m, j = 1, . . . , r.
k=1
The multiplication procedure below automatically extracts the dimension
parameters m, n, r from the arguments, namely from the 0-th operands of the
input arrays (page 4-44). If B is a q × r matrix with q ̸= n, the multiplication is not
defined mathematically. In this case, the procedure terminates with an error
3 If you use the data type Dom::Matrix() instead, you can directly use the standard operators +, -,
*, ^, / for arithmetic with matrices (cf. page 4-70 ff.).
17-11
message. For that purpose, we employ the function error, which aborts the
calling procedure and writes the string passed as argument on the screen. We
store the result component by component in the local variable C. We initialize this
variable as an array of dimension m × r, so that the result of our procedure is of
the desired data type DOM_ARRAY. We might implement the sum over k in the
computation of Cij as a loop of the form for k from 1 to n do .. Instead, we
use the system function _plus which returns the sum of its arguments. We
generally recommend to use these system functions, if possible, since they work
quite efficiently. The return value of MatrixProduct is the final expression C:
MatrixProduct := /* multiplication C=AB of an m x n */
proc(A, B) /* matrix A by an n x r Matrix B */
local m, n, r, i, j, k, C; /* with arrays A, B of */
begin /* domain type DOM_ARRAY */
m := op(A, [0, 2, 2]);
n := op(A, [0, 3, 2]);
if n <> op(B, [0, 2, 2]) then
error("incompatible matrix dimensions")
end_if;
r := op(B, [0, 3, 2]);
C := array(1..m, 1..r); /* initialization */
for i from 1 to m do
for j from 1 to r do
C[i, j] := _plus(A[i, k]*B[k, j] $ k = 1..n)
end_for
end_for;
C
end_proc:
A general remark about MuPAD programming style: you should always perform
argument checking in procedures meant for interactive use. If you implement a
procedure, you usually know which types of inputs are valid (such as DOM_ARRAY in
the above example). If somebody passes parameters of the wrong type by mistake,
this usually leads to system functions calls with invalid arguments, and your
procedure aborts with an error message originating from a system function. In the
above example, the function op returns the value FAIL when accessing the 0-th
operand of A or B and one of them is not of type DOM_ARRAY. Then this value is
assigned to m, n or r, and the following for loop aborts with an error message,
since FAIL is not allowed as a value for the endpoint of the loop.
17-12
In such a situation, it is often difficult to locate the source of the error. However,
an even worse scenario might happen: if the procedure does not abort, the result
is likely to be wrong! Thus, type checking helps to avoid errors.
In the above example, we might add a type check of the form
if domtype(A) <> DOM_ARRAY or domtype(B) <> DOM_ARRAY
then error("arguments must be of type DOM_ARRAY")
end_if
to the procedure body. Starting on page 17-20, we discuss a simpler type checking
concept.
17-13
Subprocedures
Often tasks occur frequently within a procedure and you want to implement them
again in the form of a procedure. This structures and simplifies the program code.
In many cases, such a procedure is used only from within a single procedure.
Then it is reasonable to define this procedure locally as a subprocedure only in the
scope of the calling procedure. In MuPAD® you can use local variables to
implement subprocedures. If you want to make
g := proc() begin ... end_proc:
a local procedure of
f := proc() begin ... end_proc:
define f as follows:
f := proc()
local g;
begin
g := proc() begin ... end_proc; /* subprocedure */
/* main part of f, which calls g(..): */

...
end_proc:
Now, g is a local procedure of f and you can use it only from within f.
We give an example. You can implement matrix multiplication by means of
suitable column×row multiplications:
 
4 6
 (2, 1) · (2, 1) ·
2 1 4 6  2 3 
 10 15
· =  = .
5 3 2 3  4 6  26 39
(5, 3) · (5, 3) ·
2 3
More generally, if we partition the input matrices by rows ai and columns bj ,

respectively, then
   
a1 a1 · b1 . . . a1 · bn
 ..   .. .. .. 
 .  · (b1 , . . . , bn ) =  . . . ,
am am · b1 . . . am · bn
17-14
Subprocedures
with the inner product X

ai · bj = (ai )r (bj )r .
r
We now write a procedure MatrixMult that expects input arrays A and B of the
form array(1..m, 1..k) and array(1..k, 1..n), and returns the m × n matrix
product A · B . A call of the subprocedure RowTimesColumn with arguments i, j
extracts the i-th row and the j -th column from the input matrices A and B ,
respectively, and computes the inner product of the row and the column. The
subprocedure uses the arrays A, B as well as the locally declared dimension
parameters m, n, and k as “global” variables:
MatrixMult := proc(A, B)
local m, n, k, K, /* local variables */
RowTimesColumn; /* local subprocedure */
begin
/* subprocedure */
RowTimesColumn := proc(i, j)
local row, column, r;
begin
/* ith row of A: */
row := array(1..k, [A[i,r] $ r=1..k]);
/* jth column of B: */
column := array(1..k, [B[r,j] $ r=1..k]);
/* row times column */
_plus(row[r]*column[r] $ r=1..k)
end_proc;
/* main part of the procedure MatrixMult: */

m := op(A, [0, 2, 2]); /* number of rows of A */
k := op(A, [0, 3, 2]); /* number of columns of A */
K := op(B, [0, 2, 2]); /* number of rows of B */
n := op(B, [0, 3, 2]); /* number of columns of B */
if k <> K then
error("# of columns of A <> # of rows of B")
end_if;
/* matrix A*B: */
array(1..m, 1..n,
[[RowTimesColumn(i, j) $ j=1..n] $ i=1..m])
end_proc:
17-15
The following example returns the desired result:

A := array(1..2, 1..2, [[2, 1], [5, 3]]):
B := array(1..2, 1..2, [[4, 6], [2, 3]]):
MatrixMult(A, B)
!
10 15
26 39
17-16
Scope of Variables
Scope of Variables
The MuPAD® programming language implements lexical scoping. This
essentially means that the scope of a procedure’s local variables and parameters
can already be determined when the procedure is defined. We start with a simple
example to explain this concept.
p := proc() begin x end_proc:
x := 3: p(); x := 4: p()
3
4
q := proc() local x; begin x := 5; p(); end_proc:
q()
4
First, a procedure p without arguments is defined. It uses a variable x, which is

not declared as a local variable of p. Thus, the call p() returns the value of the
global variable x, as shown in the two subsequent calls. In the procedure q,
however, the variable x is declared local, and the value 5 is assigned to it. The
global variable x is not visible from within the procedure q, only the local variable
x can be accessed. Nevertheless, the call q() returns the value of the global
variable x, and not the current value of the local variable x within p. We might, for
example, define a subprocedure within q to achieve the latter behavior:
x := 4:
q := proc()
local x, p;
begin
x := 5;
p := proc() begin x; end_proc;
x := 6;
p()
end_proc:
q(), p()
6, 4
17-17
The previously defined global procedure p is not accessed from within q because a
local variable p is declared. The call of the local procedure p from within q now
indeed returns the current value of the local variable x, as shown by the call q().
The last command p(), however, executes the global procedure p defined before,
which still returns the current value 4 of the global variable x.
Here is another example:
p := proc(x) begin 2 * cos(x) + 1; end_proc:
q := proc(y)
local cos;
begin
cos := proc(z) begin z + 1; end_proc;
p(y) * cos(y)
end_proc:
p(PI), q(PI)
−1, −π − 1
The procedure p uses MuPAD’s globally defined cosine function. Within q, we

have defined a local subprocedure cos. Calling q, the internal call cos(y) refers to
the local function cos. Even when called from within q, the procedure p still uses
the MuPAD global cosine function.
When using the option escape, a local variable can be accessed even when it has
escaped the scope of the procedure that it was local to. In the following example,
the “counter” returned by f refers to the local variable x of f. The procedures
counter1, counter2 etc. are not local to f anymore but still use the reference to x
to synchronize subsequent calls of each counter. Note that both counters refer to
different independent instances of x, so that they count independently:
f := proc() local x;
option escape;
begin
x := 1;
// The following procedure
// is the return value of f:
proc() begin x := x + 1 end;
end:
counter1 := f(): counter2 := f():
17-18
Scope of Variables
counter1(), counter1(), counter1();

counter2(), counter2();
counter1(), counter2(), counter1();
2, 3, 4
2, 3
5, 4, 6
17-19
Type Declaration
MuPAD® provides easy-to-use type checking for procedure arguments. For
example, you can restrict the arguments of MatrixProduct, a procedure from the
Section starting on page 17-9, to the domain type DOM_ARRAY as follows:
MatrixProduct := proc(A: DOM_ARRAY, B: DOM_ARRAY)
local m, n, r, i, j, k, C;
begin ...
If you declare the type of the parameters of a procedure in the form used above,
argument: typeSpecifier, a call of the procedure with parameters of an
incompatible type leads to an error message. In the example above, we used the
domain type DOM_ARRAY as a type specifier.
We have discussed MuPAD’s type concept in Chapter 14. The Type library offers
Type::NonNegInt to represent the set of nonnegative integers. If we use it in the
following variant of the factorial function
factorial := proc(n: Type::NonNegInt) begin
if n = 0 then
return(1)
else n*factorial(n - 1)
end_if
end_proc:
then only nonnegative integers are permitted for the argument n:

factorial(4)
24
factorial(4.0)
Error: Wrong type of 1. argument (type 'Type::NonNeg\
Int' expected,
got argument '4.0');
during evaluation of 'factorial'
factorial(-4)
Error: Wrong type of argument 'n' (type 'Type::NonNeg\
Int' expected,
got argument '-4');
during evaluation of 'factorial'
17-20
Procedures with a Variable Number of Arguments
Procedures with a Variable Number of Arguments

The system function max computes the maximum of its arguments. You may call it
with arbitrarily many arguments:
max(1), max(3/7, 9/20), max(-1, 3, 0, 7, 3/2, 7.5)
9
1, , 7.5
20
You can implement this behavior in your own procedures as well. The function
args returns the arguments passed to the calling procedure:
args(0) : the number of arguments,

args(i) : the i-th argument, 1 ≤ i ≤ args(0),
args(i..j) : the sequence of arguments from i to j ,
1 ≤ i ≤ j ≤ args(0),
args() : the sequence args(1), args(2), ... of all
arguments.
The following function simulates the behavior of the system function max:
maximum := proc() local m, i; begin
m := args(1);
for i from 2 to args(0) do
if m < args(i) then m := args(i) end_if
end_for:
m
end_proc:
maximum(1), maximum(3/7, 9/20), maximum(-1, 3, 0, 7, 3/2, 7.5)
9
1, , 7.5
20
Here, we initialize m with the first argument. Then, we test for each of the
remaining arguments whether it is greater than m, and if so, replace m by the
corresponding argument. Thus, m contains the maximum at the end of the loop.
Note that if you call maximum with only one argument (so that args(0) = 1), then
the loop for i from 2 to 1 do ... is not executed at all.
17-21
You may use both formal parameters and accesses via args in a procedure:
f := proc(x, y) begin
if args(0) = 3 then
x^2 + y^3 + args(3)^4
else x^2 + y^3
end_if
end_proc:
f(a, b), f(a, b, c)
a2 + b3 , a2 + b3 + c4
The following example is a trivial function returning itself symbolically for any
number of arguments that are actually passed:
f := proc() begin procname(args()) end_proc:
f(1), f(1, 2), f(1, 2, 3), f(a1, b2, c3, d4)
f (1) , f (1, 2) , f (1, 2, 3) , f (a1, b2, c3, d4)
17-22
Options: the Remember Table

When declaring MuPAD® procedures, you can specify options that affect the
execution of a procedure call. Besides the option escape already mentioned, the
option remember may be of interest to the user. In this section, we take a closer
look at this option and demonstrate its effect with an example. The sequence of
Fibonacci numbers is defined by the recursion
Fn = Fn−1 + Fn−2 , F0 = 0, F1 = 1.
It is easy to translate this into a MuPAD procedure:

F := proc(n: Type::NonNegInt)
begin
if n < 2 then n
else F(n - 1) + F(n - 2) end_if
end_proc:
F(i) $ i = 0..10
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
This way of computing Fn is highly inefficient for larger values of n. To see why,
let us trace the recursive calls of F when computing F4 . You may regard this as a
tree structure: F(4) calls F(3) and F(2), F(3) calls F(2) and F(1) etc.:
F4
F3 F2
F2 F1 F1 F0
F1 F0
One can show that the call F(n) leads to about 1.45.. · (1.618..)n calls of F for large
n. These “costs” grow dramatically fast for increasing values of n:
time(F(10)), time(F(15)), time(F(20)), time(F(25))
80, 910, 10290, 113600
17-23
We recall that the function time returns the time in milliseconds used to evaluate
its argument.
We see that many calls (such as, for example, F(1)) are executed several times.
For evaluating F(4), it is sufficient to execute only the boxed function calls
F(0), ..., F(4) in the above figure and to store these values. All other
computations of F(0), F(1), F(2) are redundant since their results are already
known. This is precisely what MuPAD does when you declare F with the option
remember:
option remember;
begin
if n < 2 then n
else F(n - 1) + F(n - 2) end_if
end_proc:
The system internally creates a remember table for the procedure F, which
initially is empty. At each call to F, MuPAD checks whether there is an entry for
the current argument sequence in this table. If this is the case, the procedure is
not executed at all, and the result is taken from the table. If the current arguments
do not appear in the table, the system executes the procedure body as usual and
returns its result. Then it appends the argument sequence and the return value to
the remember table. This ensures that a procedure is not unnecessarily executed
twice with the same arguments.
In the Fibonacci example, the call F(n) now leads to only n + 1 calls to compute
F(0), ..., F(n). In addition, the system searches the remember table n − 2 times.
However, this happens very quickly. In this example, the benefit in speed from
using option remember is quite dramatic:
time(F(10)), time(F(15)), time(F(20)), time(F(25)),
time(F(500))
0, 10, 0, 10, 390
The real running times are so small that the system cannot measure them exactly.
This explains the (rounded) times of 0 milliseconds for F(10) and F(20).
Using option remember in a procedure is promising whenever a

procedure is called frequently with the same arguments.
17-24
Of course, you can implement this method for computing the Fibonacci numbers
directly by computing Fn iteratively instead of recursively and storing already
computed values in a table:4
local i, F;
begin
F[0] := 0: F[1] := 1:
F[i] := F[i - 1] + F[i - 2]
end_for
end_proc:
time(F(10)), time(F(15)), time(F(20)), time(F(25)),
time(F(500))
10, 0, 10, 0, 400
The function numlib::fibonacci from the number theory library is yet faster for
large arguments, since it uses more elaborate algorithms and direct formulas.
Warning: The remember mechanism recognizes only previously processed
inputs, but does not consider the values of possibly used global variables. When
the values of these global variables change, then the remembered return values
are usually wrong. In particular, this is the case for global environment variables
such as DIGITS:
floatexp := proc(x) option remember;
begin float(exp(x)) end_proc:
DIGITS := 20: floatexp(1);
2.7182818284590452354
DIGITS := 40: floatexp(1); float(exp(1))
2.718281828459045235360287471344923927842
2.718281828459045235360287471352662497757
Here, the system outputs the remembered value of floatexp(1) with higher
precision after switching from 20 to 40 DIGITS. Nevertheless, this is still the value
computed with DIGITS = 20; the output only shows all digits that were used
4 This procedure is not properly implemented: what happens when you call F(0)?
17-25
internally5 in this computation. The last of the three numbers is the true value of
exp(1) computed with 40 digits. It differs from the wrongly remembered value at
the 30-th decimal digit.
You can explicitly add new entries to the remember table of a procedure. In the
following example, f is the function x 7→ sin(x)/x, which has a removable
singularity at x = 0. The limit is f (0) := limx→0 sin(x)/x = 1:
f := proc(x) begin sin(x)/x end_proc: f(0)
Error: Division by zero;
You can easily add the value for x = 0:

f(0) := 1: f(0)
1
The assignment f(0):= 1 creates a remember table for f, so that a later call of
f(0) does not try to evaluate the value of sin(x)/x for x = 0. Now you can use f
without running into danger at x = 0.
Warning: The call:

delete f: f(x) := x^2:
does not generate the function f : x 7→ x2 , but rather creates a remember table for
the identifier f with the entry x^2 only for the symbolic identifier x. Any other call
to f returns a symbolic function call:
f(x), f(y), f(1)
x2 , f (y) , f (1)
5 Internally, MuPAD uses a certain number of additional “guard digits” exceeding the number of
digits requested via DIGITS. However, for the output, the system truncates the internally computed value
to the requested number of digits.
17-26
Input Parameters
Input Parameters
The declared formal arguments of a procedure can be used like additional local
variables:
f := proc(a, b) begin a := 1; a + b end_proc:
a := 2: f(a, 1): a
2
Modifying a within this procedure does not affect the identifier a that is used
outside the procedure. You should be cautious when you access the calling
arguments via args (page 17-21) in a procedure after changing some input
parameter. Assignment to a formal parameter changes the return value of args:
f := proc(a) begin a := 1; a, args(1) end_proc: f(2)
1, 1
In principle, arbitrary MuPAD® objects may be input parameters of a procedure.

Thus you can use sets, lists, expressions, or even procedures and functions:
p := proc(f) begin
[f(1), f(2), f(3)]
end_proc:
p(g)
[g(1) , g(2) , g(3)]
p(proc(x) begin x^2 end_proc)

[1, 4, 9]
p(x -> x^3)

[1, 8, 27]
17-27
In general, user-defined procedures evaluate their arguments (“call by value”):

when you call f(x), the procedure f knows only the value of the identifier x. If you
declare a procedure with the option hold, then the “call by name” scheme is used
instead: the expression or the name of the identifier passed as the actual
argument is seen by the procedure. In this case, you can use context to obtain the
value of the expression:
f := proc(x) option hold;
begin x = context(x) end_proc:
x := 2:
f(x), f(sin(x)), f(sin(PI))
x = 2, sin(x) = sin(2) , sin(π) = 0
17-28
Evaluation Within Procedures
Evaluation Within Procedures

In Chapter 5, we have discussed MuPAD® ’s evaluation strategy: complete
evaluation at interactive level. Thus all identifiers are replaced by their values
recursively until only symbolic identifiers without a value remain (or the
evaluation depth given by the environment variable LEVEL is reached):
delete a, b, c: x := a + b: a := b + 1: b := c:
x
2c + 1
In contrast, within procedures, the system performs evaluation not completely but
only with evaluation depth 1. This is similar to internally replacing each identifier
by level(identifier, 1): every identifier is replaced by its value, but not
recursively. We recall from page 5-1 the distinction between the value of an
identifier (the evaluation at the time of assignment) and its evaluation (the
“current value,” where symbolic identifiers that have been assigned a value in the
meantime are replaced by their values as well). In interactive mode, calling an
object yields its complete evaluation, while in procedures only the object’s value is
returned. This explains the difference between the interactive result above and
the following result:
f := proc() begin
delete a, b, c:
x := a + b: a := b + 1: b := c:
x
end_proc:
f()
a+b
The reason why two different behaviors are implemented is that the strategy of
incomplete evaluation makes the evaluation of procedures faster and increases
the efficiency of MuPAD procedures considerably. For a beginner in
programming MuPAD procedures, this evaluation concept has its pitfalls.
However, after some practice you acquire an appropriate programming style so
that you can work with the restricted evaluation depth without problems.
17-29
Warning: If you do not work interactively with MuPAD, but use an editor to
write your MuPAD commands into a text file which is read into a MuPAD session
via read (page 12-5), these commands are executed within a procedure (namely,
read). Consequently, the evaluation depth is 1.
You can use the system function level (page 5-4) to control the evaluation depth
and to enforce complete evaluation if necessary:
f := proc() begin
delete a, b, c:
x := a + b: a := b + 1: b := c:
level(x)
end_proc:
f()
2c + 1
Warning: level does not evaluate local variables.

Moreover, you cannot use local variables as symbolic identifiers; you must
initialize them before use. The following procedure, in which a symbolic identifier
x is passed to the integration function, is invalid:
f := proc(n) local x; begin int(exp(x^n), x) end_proc:
You can pass the name of the integration variable as additional argument to the
procedure. Thus, the following variants are valid:
f := proc(n, x) begin int(exp(x^n), x) end_proc:
f := proc(n, x) local y; begin
y := x; int(exp(y^n), y) end_proc:
If you need symbolic identifiers for intermediate results, you can generate an
identifier without a value via genident() (page 4-8) and assign it to a local
variable.
17-30
Function Environments
MuPAD® provides a variety of tools for handling built-in mathematical standard
functions such as sin, cos, exp. These tools implement the mathematical
properties of these functions. Typical examples are the float conversion routine,
the differentiation function diff, or the function expand, which you use to
manipulate expressions:
float(sin(1)), diff(sin(x), x, x, x),
expand(sin(x + 1))
0.8414709848, − cos(x) , cos(1) sin(x) + sin(1) cos(x)
In this sense, the mathematical knowledge about the standard functions is

distributed over several system functions: the function float has to know how to
compute numerical approximations of the sine function, diff must know its
derivative, and expand has to know the addition theorems of the trigonometric
functions.
You can invent arbitrary new functions as symbolic names or implement them in
procedures. How can you pass the knowledge about the mathematical meaning
and the rules of manipulation for the new functions to the other system functions?
For example, how can you tell the differentiation routine diff what the derivative
of your newly created function is? If the function is composed of standard
functions known to MuPAD, such as, for example, f : x 7→ x sin(x), then this is no
problem. The call
f := x -> (x*sin(x)): diff(f(x), x)
sin(x) + x cos(x)
immediately yields the desired answer. However, often there are situations where
the newly implemented function cannot be composed from standard objects.
Thus, our goal is to hand the rules of manipulation (floating-point approximation,
differentiation etc.) for symbolic function calls to the MuPAD functions float,
diff etc. This is the actual challenge when you “implement a new mathematical
function in MuPAD:” to distribute the knowledge about the mathematical
meaning of the symbol to MuPAD’s standard tools. Indeed, this is a necessary
task: for example, if you want to differentiate a more complex expression
containing both the new function and some standard functions, then this is only
17-31
possible via the system’s differentiation routine. Thus, the latter has to learn how
to handle the new symbols.
For that purpose, MuPAD provides the domain type DOM_FUNC_ENV (short for:
function environment). Indeed, all built-in mathematical standard functions are
of this type in order to enable float, diff, expand etc. to handle them:
domtype(sin)
DOM_FUNC_ENV
You can call a function environment like any “normal” function or procedure:
sin(1.7)
0.9916648105
A function environment consists of three operands. The first operand is a

procedure that computes the return value of a function call. The second operand
is a procedure for printing a symbolic function call on the screen. The third
operand is a table containing information how the system functions float, diff,
expand, etc. should handle symbolic function calls.
You can look at the procedure for evaluating a function call with the function
expose, just like for normal functions:
expose(sin)
proc(x)
name sin;
local f, y;
option noDebug;
begin
if args(0) = 0 then
error("no arguments given")
else
...
end_proc
To keep the example manageable, we will choose two closely related functions and
act as if they were not implemented in MuPAD yet. Our example functions are the
complete elliptic integral functions of the first and second kind, K(z) and E(z).
Since MuPAD already has a predefined identifier E, we will implement these
functions as ellipE and, for consistency, ellipK. (The more obvious names
17-32
ellipticE and ellipticK are already used by the MuPAD versions of the same
functions.) These functions appear in such different contexts as calculating the
perimeter of an ellipsis, the gravitational or electrostatic potential of a uniform
ring or the probability that a random walk in three dimensions ever goes through
the origin. For this presentation, let us concentrate on the following properties of
the functions E and K :
E(z) − K(z)
E ′ (z) = ,
2z
E(z) − (1 − z)K(z)
K ′ (z) = ,
2 (1 − z)z
π
E(0) = K(0) = , E(1) = 1,
2
1
1 2
8 π 3/2 Γ
K = 2 , K(−1) = √
4
.
2 Γ − 14 4 2π
That is, we are going to implement the derivatives of E and K with the above
relations and make the functions evaluate at special points. Additionally, we will
implement the functions in such a way that they are written as E and K in the
output.
The basic functions are easy to write:
ellipE :=
proc(x) begin
if x = 0 then PI/2
elif x = 1 then 1
else procname(x) end_if
end_proc:
ellipK :=
proc(x) begin
if x = 0 then PI/2
elif x = 1/2 then 8*PI^(3/2)/gamma(-1/4)^2
elif x = -1 then gamma(1/4)^2/4/sqrt(2*PI)
end_proc:
17-33
Since the values of the functions are known only at specific places, we use
procname (page 17-7) to return the symbolic expressions ellipE(x) and
ellipK(x), respectively, for all arguments where the function values are not
known. This yields:
ellipE(0), ellipE(1/2),
ellipK(12/17), ellipK(x^2+1)

π 1 12
, ellipE , ellipK , ellipK x2 + 1
2 2 17
You generate a new function environment by means of funcenv:

output_E := f -> hold(E)(op(f)):
ellipE := funcenv(ellipE, output_E):
output_K := f -> hold(K)(op(f)):
ellipK := funcenv(ellipK, output_K):
These commands convert the procedures ellipE and ellipK to function

environments. The first arguments are the procedures for evaluation. The
(optional) second argument of funcenv is the procedure for screen output. We
want a symbolic expression ellipE(x) displayed as E(x) and likewise ellipK(x)
shall be displayed as K(x). This is achieved by the second argument of funcenv,
which you should interpret as a conversion routine. On input ellipE(x), it
returns the MuPAD object to print on the screen instead of ellipE(x). The
argument f, which represents ellipE(x), is converted to the unevaluated
function call E(x) (note that x = op(f) for f = ellipE(x) and that you need
hold(E) to prevent evaluation of the identifier E). The system outputs this
expression instead of ellipE(x) on the screen:6
ellipE(0), ellipE(1/2),
ellipK(12/17), ellipK(x^2+1)

π 1 12
, E , K , K x2 + 1
2 2 17
The (optional) third argument to funcenv is a table of function attributes. It tells

the system functions float, diff, expand etc. how to handle symbolic calls of the
6 Note that you should avoid returning strings from such procedures. Using strings breaks both
pretty-printing and typesetting of the output.
17-34
form ellipK(x) and ellipE(x). In the example above, we did not provide any
such function attributes. Hence, the system functions do not yet know how to
proceed and, by default, return the expression or themselves symbolically:
float(ellipE(1/3)), expand(ellipE(x + y)),
diff(ellipE(x), x), diff(ellipK(x), x)

1 ∂ ∂
E , E(x + y) , E(x) , K(x)
3 ∂x ∂x
By assigning to the "diff" slot of our function environments, we set the attributes
for the differentiation routine diff:
ellipE::diff :=
proc(f,x)
local z;
begin
z := op(f);
(ellipE(z) - ellipK(z))/(2*z) * diff(z, x)
end_proc:
ellipK::diff :=
proc(f,x)
local z;
begin
z := op(f);
(ellipE(z) - (1-z)*ellipK(z))/
(2*(1-z)*z) * diff(z, x)
end_proc:
These commands tell diff that diff(f, x) with a symbolic function call
f = ellipE(z), where z depends on x, should apply the procedure assigned to
ellipE::diff. The well-known chain rule yields
d dz
E(z) = E ′ (z) .
dx dx
The specified procedure implements this rule, where the inner function in the
expression f = ellipE(z) is given by z = op(f).
17-35
Now MuPAD knows the derivatives of the functions represented by the

identifiers ellipE and ellipK. We have already implemented the screen outputs:
diff(ellipE(z), z), diff(ellipE(y(x)), x);
diff(ellipE(x*sin(x)), x)
E(z) − K(z) (E(y(x)) − K(y(x))) ∂

∂x y(x)
,
2z 2 y(x)
(E(x sin(x)) − K(x sin(x))) (sin(x) + x cos(x))

2 x sin(x)
As far as diff is concerned, the implementation of our two elliptic integrals is now
complete:
diff(ellipE(x), x, x)
E(x)−K(x) E(x)+K(x) (x−1)
2x + 2 x (x−1) E(x) − K(x)
−
2x 2 x2
normal(diff(ellipK(2*x + 3), x, x, x))
- (73 E(2 x + 3) + 86 K(2 x + 3) + 115 x E(2 x + 3) +
2
228 x K(2 x + 3) + 46 x E(2 x + 3) +
2 3
202 x K(2 x + 3) + 60 x K(2 x + 3)) /
6 5 4 3 2
(32 x + 240 x + 744 x + 1220 x + 1116 x +
540 x + 108)
As an application, we now want MuPAD to compute the first terms of the Taylor
expansion of the complete elliptic integral of the first kind around x = 0. We can
use the function taylor since it calls diff internally:
taylor(ellipK(x), x = 0, 6)
π π x 9 π x2 25 π x3 1225 π x4 3969 π x5
+ + + + + + O x6
2 8 128 512 32768 131072
17-36
But there is more: With functions such as the elliptic integrals, which appear in
their own derivatives, the integration routine has a good chance of finding
symbolic integrals once the diff attributes have been implemented:
int(ellipE(x), x)

2 E(x) 2 K(x) 2 E(x) 2 K(x)
− +x +
3 3 3 3
Exercise 17.1: Extend the definitions of ellipE and ellipK by a "float" slot.
Use hypergeom::float and the following equivalences:

π 1 1
E(z) = hypergeom − , , [1], z
2 2 2

π 1 1
K(z) = hypergeom , , [1], z
2 2 2
Also, extend the definitions of the functions such that your new float evaluation is
automatically used when a floating point value is given as input.
Exercise 17.2: Implement an absolute value function Abs as a function

environment. The call Abs(x) should return the absolute value for real numbers x
of domain type DOM_INT, DOM_RAT, or DOM_FLOAT. For all other arguments, the
symbolic output |x| should appear on the screen. The absolute value is
differentiable on R\{0}. Its derivative is
d |y| |y| dy
= .
dx y dx
Set the "diff" attribute accordingly and compute the derivative of Abs(x^3).
Compare your result to the corresponding derivative of the system function abs.
17-37
A Programming Example: Differentiation

In this section, we discuss an example demonstrating the typical mode of
operation of a symbolic MuPAD® procedure. We implement a symbolic
differentiation routine that computes the derivatives of algebraic expressions
composed of additions, multiplications, exponentiations, some mathematical
functions (exp, ln, sin, cos, …), constants, and symbolic identifiers.
This example is only for illustration purposes, since MuPAD already provides such
a function: the diff routine. This function is implemented in the MuPAD kernel
and therefore very fast. A user-defined function that is written in the MuPAD
programming language can hardly achieve the efficiency of diff.
The following algebraic differentiation rules are valid for the class of expressions
that we consider:
df
(1) = 0, if f does not depend on x,
dx
dx
(2) = 1,
dx
d(f + g) df dg
(3) = + (linearity),
dx dx dx
da b da db
(4) = b+a (product rule),
dx dx dx
d ab d b ln(a) d
(5) = e = eb ln(a) (b ln(a))
dx dx dx
db da
= ab ln(a) + ab−1 b ,
dx dx
d dy
(6) F (y(x)) = F ′ (y) (chain rule).
dx dx
Moreover, for some functions F , the derivative is known, and we want to take this
into account in our implementation. For an unknown function F , we return the
symbolic function call of the differentiation routine.
17-38
A Programming Example: Differentiation
The procedure Diff in Table 17.1 implements the above properties in the stated
order. Its calling syntax is Diff(expression, identifier).
Diff := proc(f, x : DOM_IDENT) // (0)

local a, b, F, y; begin
if not has(f, x) then return(0) end_if; // (1)
if f = x then return(1) end_if; // (2)
if type(f) = "_plus" then
return(map(f, Diff, x)) end_if; // (3)
if type(f) = "_mult" then
a := op(f, 1); b := subsop(f, 1 = 1);
return(Diff(a, x)*b + a*Diff(b, x)) // (4)
end_if;
if type(f) = "_power" then
a := op(f, 1); b := op(f, 2);
return(f*ln(a)*Diff(b, x)
+ a^(b - 1)*b*Diff(a, x)) // (5)
end_if;
if op(f, 0) <> FAIL then
F := op(f, 0); y := op(f, 1); // (6)
if F = hold(exp) then
return( exp(y)*Diff(y, x)) end_if; // (6)
if F = hold(ln) then
return( 1/y *Diff(y, x)) end_if; // (6)
if F = hold(sin) then
return( cos(y)*Diff(y, x)) end_if; // (6)
if F = hold(cos) then
return(-sin(y)*Diff(y, x)) end_if; // (6)
/* specify further known functions here */
end_if;
procname(args()) // (7)
end_proc:
Table 17.1: A symbolic differentiation routine
In (0), we implemented an automatic type check of the second argument, which

must be a symbolic identifier of domain type DOM_IDENT.
In (1), the MuPAD function has checks whether the expression f to be
differentiated depends on x.
Linearity of differentiation is implemented in (3) by means of the MuPAD
17-39
function map:
map(f1(x) + f2(x) + f3(x), Diff, x)
Diff(f1(x) , x) + Diff(f2(x) , x) + Diff(f3(x) , x)
In (4), we handle a product expression f = f1 · f2 · . . . : the command a:= op(f,1)

determines the first factor a = f1 , then subsop(f, 1 = 1) replaces this factor by 1,
such that b assumes the value f2 · f3 · . . . . Then, we call Diff(a, x) and Diff(b, x).
If b = f2 · f3 · . . . is itself a product, this leads to another execution of step (4) at
the next recursion level. In this way, (4) handles products of arbitrary length.
Step (5) differentiates powers. For f = ab , the call op(f, 1) returns the base a and
op(f, 2) the exponent b. In particular, this covers all monomial expressions of the
form f = xn for constant n. The recursive calls to Diff for a = x and b = n then
yield Diff(a, x) = 1 and Diff(b, x) = 0, respectively, and the expression returned
in (5) simplifies to the correct result n xn−1 .
If the expression f is a symbolic function call of the form f = F (y), we extract the
“outer” function F in (6) via F:= op(f, 0) (otherwise, F gets the value FAIL). Next,
we handle the case where F is a function with one argument y and extract the
“inner” function by y:= op(f, 1). If F is the name of a function with known
derivative (such as F = exp, ln, sin, cos), then we apply the chain rule. It is easy to
extend this list of functions F with known derivatives. In particular, you can add a
formula for differentiating symbolic expressions of the form int(·, ·). Extensions
to functions F with more than one argument are also possible.
Finally, step (7) returns Diff(f, x) symbolically if no simplifications of the
expression f happen in steps (1) through (6).
Diff’s mode of operation is adopted from the system function diff. Compare the
following results to those returned by diff:
Diff(x*ln(x + 1/x), x)

1 x 1
−1
ln x + − x2
1
x x+ x
Diff(f(x)*sin(x^2), x)

sin x2 Diff(f (x) , x) + 2 x cos x2 f (x)
17-40
Programming Exercises
Programming Exercises
Exercise 17.3: Write a short procedure date that takes three integers month, day,
year as input and prints the date in the usual way. For example, the call
date(5, 3, 1990) should yield the screen output 5/3/1990.
Exercise 17.4: We define the function f : N → N by

(
3 x + 1 for odd x ,
f (x) =
x/2 for even x .
The “(3 x + 1) problem” asks whether for an arbitrary initial value x0 ∈ N, the
sequence recursively defined by xi+1 := f (xi ) contains the value 1. Write a
program that on input x0 returns the smallest index i with xi = 1.
Exercise 17.5: Implement a function Gcd to compute the greatest common

divisor of two positive integers. Of course, you should not use the system
functions gcd and igcd. Hint: the Euclidean Algorithm for computing the gcd is
based on the observation
gcd(a, b) = gcd(a mod b, b) = gcd(b, a mod b)
and the facts gcd(0, b) = gcd(b, 0) = b.
Exercise 17.6: Implement a function Quadrature. For a function f and a

MuPAD® list X of numerical values
x0 < x1 < · · · < xn ,
the call Quadrature(f, X) should compute a numerical approximation of the

integral
Z xn X
n−1
f (x) dx ≈ (xi+1 − xi ) f (xi ).
x0 i=0
17-41
Exercise 17.7: Newton’s method for finding a numerical root of a function

f : R 7→ R employs the iteration xi+1 = F (xi ), where F (x) = x − f (x)/f ′ (x).
Write a procedure Newton. The call Newton(f, x0, n), with an expression f,
should return the first n + 1 elements x0 , . . . , xn of the Newton sequence.
For bonus points, extend the example on page 11-34 to display the sequence just
found.
Exercise 17.8: The Sierpinski triangle is a well-known fractal. We define a

variant of it as follows. The Sierpinski triangle is the set of all points (x, y) ∈ N × N
with the following property: there exists at least one position in the binary
expansions of x and y such that both have a 1-bit at this position. Write a program
Sierpinski that on input xmax, ymax plots the set of all such points with integer
coordinates in the range 1 ≤ x ≤ xmax, 1 ≤ y ≤ ymax. Hint: the function
numlib::g_adic computes the binary expansion of an integer. The graphical
primitive plot::PointList2d can be used to create a plot of the points.
Exercise 17.9: A logical formula is composed of identifiers and the operators

and, or, and not. For example:
formula := (x and y) or
((y or z) and (not x) and y and z)
Such a formula is called satisfiable if it is possible to assign the values TRUE and
FALSE to all identifiers in such a way that the formula can be evaluated to TRUE.
Write a program that checks whether an arbitrary logical formula is satisfiable.
17-42
A
Exercise 2.1: The help page ?diff tells you how to compute higher order
derivatives:
diff(sin(x^2), x, x, x, x, x)

32 x5 cos x2 − 120 x cos x2 + 160 x3 sin x2
You can also use the longer command diff(diff(..., x), x).
Exercise 2.2: The exact representations are:

sqrt(27) - 2*sqrt(3), cos(PI/8)
p√
√ 2+2
3,
2
The numerical approximations are:

DIGITS := 5:
float(sqrt(27) - 2*sqrt(3)), float(cos(PI/8))
1.7321, 0.92388
They are correct to within 5 digits.
Exercise 2.3:
expand((x^2 + y)^5)
x10 + 5 x8 y + 10 x6 y 2 + 10 x4 y 3 + 5 x2 y 4 + y 5
A Solutions to Exercises
Exercise 2.4:
normal((x^2 - 1)/(x + 1))
x−1
Exercise 2.5: You can plot the singular function f (x) = 1/ sin(x) on the interval
[1, 10] without any problems:
plot(1/sin(x), x = 1..10)
Exercise 2.6: MuPAD® immediately returns the claimed limits:

limit(sin(x)/x, x = 0),
limit((1 - cos(x))/x, x = 0),
limit(ln(x), x = 0, Right)
1, 0, −∞
limit(x^sin(x), x = 0),
limit((1 + 1/x)^x, x = infinity),
limit(ln(x)/exp(x), x = infinity)
1, e, 0
A-2
limit(x^ln(x), x = 0, Right),
limit((1 + PI/x)^x, x = infinity),
limit(2/(1 + exp(-1/x)), x = 0, Left)
∞, eπ , 0
The result undefined denotes a non-existing limit:

limit(exp(cot(x)), x = 0)
undefined
Exercise 2.7: You obtain the first result in the desired form by factoring:
sum(k^2 + k + 1 , k = 1..n): % = factor(%)

n3 5n 1
+ n2 + = · n · n2 + 3 n + 5
3 3 3
sum((2*k - 3)/((k + 1)*(k + 2)*(k + 3)),

k = 0..infinity)
1
−
4
sum(k/(k - 1)^2/(k + 1)^2, k = 2..infinity)
5
16
Exercise 2.8:
A := matrix([[1, 2, 3], [4, 5, 6], [7, 8, 0]]):
B := matrix([[1, 1, 0], [0, 0, 1], [0, 1, 0]]):
2*(A + B), A*B
   
4 6 6 1 4 2
   
 8 10 14  ,  4 10 5 
14 18 0 7 7 8
A-3
(A - B)^(-1)
 
− 52 3
2 − 57
 
 5
2 − 32 6
7

− 12 1
2 − 27
Exercise 2.9: a) The function numlib::mersenne returns a list of values for p

yielding the 44 currently known Mersenne primes that have been found on
supercomputers. The actual computation for 1 < p ≤ 1000 can be easily
performed in MuPAD:
select([$ 1..1000], isprime):
select(%, p -> (isprime(2^p - 1)))
After some time you obtain the desired list of values of p:

select(%, p -> (isprime(2^p - 1)))
[2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607]
The corresponding Mersenne primes are:

map(%, p -> (2^p-1))
[3, 7, 31, 127, 8191, 131071, 524287, 2147483647,
2305843009213693951, 618970019642690137449562111,
162259276829213363391578010288127, ... ]
b) Depending on your computer’s speed, you can test only the first 13 or 14 Fermat
numbers in a reasonable amount of time. Note that the 12-th Fermat number
already has 1234 decimal digits.
Fermat := n -> 2^(2^n) + 1: isprime(Fermat(10))
FALSE
The only known Fermat primes are the first five Fermat numbers (including
Fermat(0)). Indeed, if MuPAD tests the first 12 Fermat numbers, then after some
time it returns the following five values:
A-4
select([Fermat(i) $ i = 0..11], isprime)

[3, 5, 17, 257, 65537]
Exercise 4.1: The first operand of a power is the base, the second is the
exponent. The first and second operand of an equation is the left and the
right-hand side, respectively. The operands of a function call are its arguments:
op(a^b, 1), op(a^b, 2)
a, b
op(a = b, 1), op(a = b, 2)
a, b
op(f(a, b), 1), op(f(a, b), 2)
a, b
Exercise 4.2: The list with the two equations is op(set, 1). Its second operand
is the equation y = ..., whose second operand is the right-hand side:
set := solve({x+sin(3)*y = exp(a),
y-sin(3)*y = exp(-a)}, {x,y})
(" sin(3)
#)
ea sin(3) − ea + 1
x= ea
,y = − a
sin(3) − 1 e (sin(3) − 1)
y := op(set, [1, 2, 2])

1
−
ea (sin(3) − 1)
Use assign(op(set)) to perform assignments of both unknowns x and y

simultaneously.
Exercise 4.3: If at least one number in a numerical expression is a floating-point

number, then the result is a floating-point number:
1/3 + 1/3 + 1/3, 1.0/3 + 1/3 + 1/3
1, 1.0
A-5
Exercise 4.4: You obtain the desired floating-point numbers immediately by

applying float:
float(PI^(PI^PI)), float(exp(PI*sqrt(163)/3))
1.340164183 · 1018 , 640320.0
Note that only the first 10 digits of these values are reliable since this is the default
precision. Indeed, for larger values of DIGITS, you find:
DIGITS := 100:
float(PI^(PI^PI)), float(exp(PI*sqrt(163)/3))
1340164183006357435.297449129640131415099374974573499\
237787927516586034092619094068148269472611301142
640320.0000000006048637350490160394717418188185394757\
714857603665918194652218258286942536340815822646
We compute 235 decimal digits of PI to obtain the correct 234-th digit after the
decimal point. After setting DIGITS:= 235, the result is the last shown digit of
float(PI). A more elegant way is to multiply by 10234 . Then the desired digit is
the first digit before the decimal point, and we obtain it by truncating the digits
after the decimal point:
DIGITS := 235: trunc(10^234*PI) - 10*trunc(10^233*PI)
6
Exercise 4.5: a) Internally, MuPAD computes with some additional digits not
shown in the output.
DIGITS := 10: x := 10^50/3.0; floor(x)
3.333333333 · 1049
33333333333333333307484730568084080731669827420160
A-6
b) After increasing DIGITS, MuPAD displays the additional digits. However, not
all of them are correct:
DIGITS := 40: x
3.333333333333333330748473056808408073167 · 1049
Restart the computation with the increased value of DIGITS to obtain the desired
precision:
DIGITS := 40: x := 10^50/3.0
3.333333333333333333333333333333333333333 · 1049
Exercise 4.6: The names caution!-!, x-y, and Jack&Jill are invalid since they
contain the special characters !, -, and &, respectively. Since an identifier’s name
must not start with a number, 2x is not valid either. The names diff and exp are
valid names of identifiers. However, you cannot assign values to them since they
are protected names of MuPAD functions. The name #1 is a valid name of
identifier. However, you cannot assign values to it because, starting with a hash
mark, it cannot be assigned to.
Exercise 4.7: We use the sequence operator $ (page 4-24) to generate the set of
equations and the set of unknowns. Then a call to solve returns a set of simpler
equations:
equations := {(x.i + x.(i+1) = 1) $ i = 1..19,
x20 = PI}:
unknowns := {x.i $ i = 1..20}:
solutions := solve(equations, unknowns)
{[x1 = 1 - PI, x10 = PI, x11 = 1 - PI, x12 = PI,
x13 = 1 - PI, x14 = PI, x15 = 1 - PI, x16 = PI,
x17 = 1 - PI, x18 = PI, x19 = 1 - PI, x2 = PI,
x20 = PI, x3 = 1 - PI, x4 = PI, x5 = 1 - PI,
x6 = PI, x7 = 1 - PI, x8 = PI, x9 = 1 - PI]}
A-7
We use the function assign to assign the computed values to the identifiers:
assign(op(solutions, 1)): x1, x2, x3, x4, x5, x6
1 − π, π, 1 − π, π, 1 − π, π
Exercise 4.8: MuPAD stores the expression a^b - sin(a/b) in the form
sin(a * b^(-1)) * (-1) + a^b. Its expression tree is:
* ^
a b
sin -1
a ^
b -1
Exercise 4.9: We observe that:

op(2/3); op(x/3)
2, 3
1
x,
3
The reason is that 2/3 is of domain type DOM_RAT, whose operands are the
numerator and the denominator. The domain type of the symbolic expression x/3
is DOM_EXPR and its internal representation is x * (1/3). The situation is similar for
1 + 2 * I and x + 2 * I:
op(1 + 2*I); op(x + 2*I)
1, 2
x, 2 i
A-8
The first object is of domain type DOM_COMPLEX. Its operands are the real and the
imaginary part. The operands of the symbolic expression x + 2 * I are the first and
the second term of the sum.
Exercise 4.10: The expression tree of condition = (not a) and (b or c) is:

and
not or
a b c
Thus op(condition, 1) = not a and op(condition, 2) = b or c. We obtain the

atoms a, b, c as follows:
op(condition, [1, 1]), op(condition, [2, 1]),
op(condition, [2, 2])
a, b, c
Exercise 4.11: You can use both the assignment function _assign presented on
page 4-8 and the assignment operator :=.
for i from 1 to 100 do _assign(x.i, i); end:
for i from 1 to 100 do x.i := i; end:
You can also pass a set of assignment equations to the assign function:
assign({x.i = i $ i = 1..100}):
Exercise 4.12: Since a sequence is a valid argument of the sequence operator,

you may achieve the desired result as follows:
(x.i $ i) $ i = 1..10
x1, x2, x2, x3, x3, x3, x4, x4, x4, x4, ...
A-9
Exercise 4.13: We use the addition function _plus and generate its argument
sequence via $:
_plus(((i+j)^(-1) $ j = 1.. i) $ i=1..10)
1464232069
232792560
Exercise 4.14:
L1 := [a, b, c, d]: L2 := [1, 2, 3, 4]:
L1.L2, zip(L1, L2, _mult)
[a, b, c, d, 1, 2, 3, 4] , [a, 2 b, 3 c, 4 d]
Exercise 4.15: The function _mult multiplies its arguments:

map([1, x, 2], _mult, multiplier)
[multiplier, multiplier x, 2 multiplier]
We use map to apply the function sublist -> map(sublist, _mult, 2) to the
sublists in a nested list:
L := [[1, x, 2], [PI], [2/3, 1]]:
map(L, map, _mult, 2)

4
[2, 2 x, 4] , [2 π] , , 2
3
Exercise 4.16: For

X := [x1, x2, x3]: Y := [y1, y2, y3]:
the products are given immediately by

_plus(op(zip(X, Y, _mult)))
x1 y1 + x2 y2 + x3 y3
A-10
The following function f multiplies each element of the list Y by its input
parameter x and returns the resulting list:
f := x -> (map(Y, _mult, x)):
The next command replaces each element of X by the list returned by f:

map(X, f)
[[x1 y1, x1 y2, x1 y3] , [x2 y1, x2 y2, x2 y3] , [x3 y1, x3 y2, x3 y3]]
Exercise 4.17: For each m, we use the sequence generator $ to create a list of all
integers to be checked. Then we extract all primes from the list via
select(·, isprime). The number of primes is just nops of the resulting list. We
compute this value for all m between 0 and 41:
nops(select([(n^2 + n + m) $ n = 1..100], isprime))
$ m = 0..41
1, 32, 0, 14, 0, 29, 0, 31, 0, 13, 0, 48, 0, 18, 0,
11, 0, 59, 0, 25, 0, 14, 0, 28, 0, 28, 0, 16, 0,
34, 0, 35, 0, 11, 0, 24, 0, 36, 0, 17, 0, 86
There is a simple explanation for the zero values for even m > 0. Since
n2 + n = n (n + 1) is always even, n2 + n + m is an even integer greater than 2 and
hence not a prime.
Exercise 4.18: We store the children in a list C and remove the one that was
counted out at the end of each round. We represent the positions 1, 2, . . . , n of n
children by a list with the corresponding integers. Let out ∈ {1, . . . , n} be the
position of the last child that was counted out. After deleting the out-th element,
the next round begins at position out in the shortened list. At the end of the
round, after m words, the child at position out + m - 1 in the current list is counted
out. Since we are counting cyclically, we take this value modulo the number of
remaining children. Note, however, that a mod b produces numbers in the range
0, 1, . . . , b − 1 rather than 1, . . . , b. This is overcome by using ((a - 1) mod b) + 1
instead of a mod b:
m := 8: n := 12: C := [$ 1..n]: out := 1:
A-11
out := ((out + m - 2) mod nops(C)) + 1:

C[out]
8
delete C[out]:
C[out]
4
etc. It is useful to implement the complete counting by a loop (Chapter 15):

m := 8: n := 12: C := [$ 1..n]: out := 1:
repeat
print(C[out]);
delete C[out];
until nops(C) = 0 end_repeat:
8
11
...
Exercise 4.19:
set := {op(list)}: list := [op(set)]:
Note that the two conversions list 7→ set 7→ list in general change the order of the
list elements.
A-12
Exercise 4.20:
A := {a, b, c}: B := {b, c, d}: C := {b, c, e}:
A union B union C, A intersect B intersect C,
A minus (B union C)
{a, b, c, d, e} , {b, c} , {a}
Exercise 4.21: You obtain the union via _union:

M := {{2, 3}, {3, 4}, {3, 7}, {5, 3}, {1, 2, 3, 4}}:
_union(op(M))
{1, 2, 3, 4, 5, 7}
and the intersection via _intersect:

_intersect(op(M))
{3}
Exercise 4.22:
telephoneDirectory := table(Ford = 1815,
Reagan = 4711, Bush = 1234, Clinton = 5678):
An indexed call returns Ford’s number:

telephoneDirectory[Ford]
1815
You can use select to extract all table entries containing the number 5678:
select(telephoneDirectory, has, 5678)
Clinton 5678
Exercise 4.23: The command [op(Table)] returns a list of all assignment

equations. The call map(·, op, i) (i = 1, 2) extracts the left and the right-hand
sides, respectively, of the equations:
T := table(a = 1, b = 2,
1 - sin(x) = "derivative of x + cos(x)" ):
A-13
indices := map([op(T)], op, 1)

[a, b, 1 − sin(x)]
values := map([op(T)], op, 2)

[1, 2, ”derivative of x + cos(x)”]
Exercise 4.24: The following timings (in milliseconds) show that generating a
table is more time consuming:
n := 100000:
time((T := table((i=i) $ i=1..n))),
time((L := [i $ i=1..n]))
422, 165
However, working with tables is notably faster. The following assignments create
an additional table entry and extend the list by one element, respectively:
time((T[n + 1] := New)), time((L := L.[New]))
0, 84
Exercise 4.25: We use the sequence generator $ to create a nested list and pass
it to array:
n := 20:
array(1..n, 1..n,
[[1/(i + j - 1) $ j = 1..n] $ i = 1..n]):
Exercise 4.26:
TRUE and (FALSE or not (FALSE or not FALSE))
FALSE
Exercise 4.27: We use the function zip to generate a list of comparisons. We

pass the system function _less as third argument, which generates inequalities of
the form a < b. Then we extract the sequence of inequalities via op and pass it to
_and:
A-14
L1 := [10*i^2 - i^3 $ i = 1..10]:

L2 := [i^3 + 13*i $ i = 1..10]:
_and(op(zip(L1, L2, _less)))
9 < 14 and 32 < 34 and 63 < 66 and 96 < 116 and
125 < 190 and 144 < 294 and 147 < 434 and
128 < 616 and 81 < 846 and 0 < 1130
Finally, evaluating this expression with bool answers the question:

bool(%)
TRUE
Exercise 4.28: The function sort does not sort the identifiers alphabetically by
their names but according to an internal order (page 4-28). Thus, we convert
them to strings via expr2text before sorting:
sort(map(anames(All), expr2text))
["Ax", "Axiom", "AxiomConstructor", "C_", "Cat",
"Category", ... , "zeta", "zip"]
Exercise 4.29: We compute the reflection of the palindrome

text := "Never odd or even":
by passing the reflected sequence of individual characters to the function _concat,

which converts it to a string again:
n := length(text):
_concat(text[n - i + 1] $ i = 1..n)
”neve ro ddo reveN”
This can also be achieved with the call revert(text).
Exercise 4.30:
f := x -> (x^2): g := x -> (sqrt(x)):
A-15
(f@f@g)(2), (f@@100)(x)
4, x1267650600228229401496703205376
Exercise 4.31: The following function does the job:

f := L -> [L[nops(L) + 1 - i] $ i = 1..nops(L)]
L -> [L[(nops(L) + 1) - i] $ i = 1..nops(L)]
f([a, b, c])
[c, b, a]
However, the simplest solution is to use f:= revert.
Exercise 4.32: You can use the function last (Chapter 13.2) to generate the
Chebyshev polynomials as expressions:
T0 := 1: T1 := x:
T2 := 2*x*% - %2; T3:= 2*x*% - %2; T4:= 2*x*% - %2
2 x2 − 1

2 x 2 x2 − 1 − x

1 − 2 x2 − 2 x x − 2 x 2 x2 − 1
A much more elegant way is to translate the recursive definition into a MuPAD
function that works recursively:
T := (k, x) ->
(if k < 2
then x^k
else 2*x*T(k - 1, x) - T(k - 2, x)
end_if):
Then we obtain:
T(i, 1/3) $ i = 2..5
7 23 17 241
− , − , ,
9 27 81 243
A-16
T(i, 0.33) $ i = 2..5

−0.7822, −0.846252, 0.22367368, 0.9938766288
T(i, x) $ i = 2..5
2 2
2 x - 1, 2 x (2 x - 1) - x,
2 2
1 - 2 x - 2 x (x - 2 x (2 x - 1)), x -
2 2
2 x (2 x - 1) - 2 x (2 x (x - 2 x (2 x - 1)) +
2
2 x - 1)
You can obtain expanded representations of the polynomials by inserting a call to

expand (page 9-3) in the function definition.
The Chebyshev polynomials are already implemented in orthpoly, the library for
orthogonal polynomials. The i-th Chebyshev polynomial is returned by the call
orthpoly::chebyshev1(i, x).
Exercise 4.33: In principle, you can compute the derivatives of f in MuPAD and
substitute x = 0. But it is simpler to approximate the function by a Taylor series
whose leading terms describe the behavior in the neighborhood of x = 0:
taylor(tan(sin(x)) - sin(tan(x)), x = 0)
x7 29 x9 1913 x11
+ + + O x13
30 756 75600
Thus, f (x) = x7 /30 · (1 + O(x2 )), and hence f has a root of order 7 at x = 0.
A-17
Exercise 4.34: The reason for the difference between the results
taylor(diff(1/(1 - x), x), x);
diff(taylor(1/(1 - x), x), x)

1 + 2 x + 3 x2 + 4 x3 + 5 x4 + 6 x5 + O x6

1 + 2 x + 3 x2 + 4 x3 + 5 x4 + O x5
is the truncation determined by the environment variable ORDER with the default
value 6. Both taylor calls compute the corresponding series up to O(x6 ):
taylor(1/(1 - x), x)

1 + x + x2 + x3 + x4 + x5 + O x6
The order term O(x^5) appears when the term O(x^6) is differentiated:
diff(%, x)

1 + 2 x + 3 x2 + 4 x3 + 5 x4 + O x5
Exercise 4.35: An asymptotic expansion yields:

f := sqrt(x + 1) - sqrt(x - 1):
g := series(f, x = infinity)

1 1 7 1
√ + + + O
x 8 x 52 9
128 x 2
11
x2
Thus
1 1 7
f≈√ 1 + + + · · · ,
x 8 x2 128 x4
√
(x) ≈ 1/
and hence f x for all real x ≫ 1. The next better approximation is
1 1
f (x) ≈ √ 1+ .
x 8 x2
A-18
Exercise 4.36: The command ?revert requests the corresponding help page.
f := taylor(sin(x + x^3), x); g := revert(%)
5 x3 59 x5
x+ − + O x7
6 120
5 x3 103 x5
x− + + O x7
6 40
To check this result, we consider the composition of f and g , whose series

expansion is that of the identity function x 7→ x:
g@f

x + O x7
Exercise 4.37: We perform the computation over the standard coefficient ring
(page 4-64), which comprises both rational numbers and floating-point numbers:
n := 16:
H := matrix(n, n, (i, j) -> ((i + j -1)^(-1))):
e := matrix(n, 1, 1): b := H*e:
We first compute the solution of the system of equations H ⃗x = ⃗b with exact

arithmetic over the rational numbers. Then we convert all entries of H and ⃗b to
floating-point numbers and solve the system numerically (and in the unstable and
slow way, using an explicit inverse instead of calling numeric::matlinsolve):
exact = H^(-1)*b, numerical = float(H)^(-1)*float(b)
   
1 0.999999993
   
 1   1.000000164 
   
   
 ...   ... 
exact =   , numerical =  
 1   −11.875 
   
   
 1   4.036132812 
1 0.3975830078
A-19
The errors in the numerical solution originate from rounding errors. To

demonstrate this, we repeat the numerical computation with higher precision:
DIGITS := 20:
numerical = float(H)^(-1)*float(b)
 
1.0000000505004147319
 
 0.99999992752642441474 
 
 
 ... 
numerical =  
 0.99999889731407165527 
 
 
 1.0000003278255462646 
0.9999999580904841423
Exercise 4.38: We look for values where the determinant of the matrix vanishes:
matrix([[1, a, b], [1, 1, c], [1, 1, 1]]):
factor(linalg::det(%))
(c − 1) · (a − 1)
The matrix is invertible unless a = 1 or c = 1.
Exercise 4.39: We first store the matrix data in arrays. These arrays are used
later to generate matrices over different coefficient rings:
a := array(1..3, 1..3, [[ 1, 3, 0],
[-1, 2, 7],
[ 0, 8, 1]]):
b := array(1..3, 1..2, [[7, -1], [2, 3], [0, 1]]):
Now we define the constructor MQ for matrices over the rational numbers and
convert the arrays to corresponding matrices:
MQ := Dom::Matrix(Dom::Rational): A := MQ(a): B := MQ(b):
A-20
The method "transpose" of the constructor computes the transpose of a matrix B

via MQ::transpose(B):
(2*A + B*MQ::transpose(B))^(-1)
 
34
1885
7
1508 − 7540
153
 
 11
3770 − 3016
31 893
15080

− 3770
47 201
3016 − 15080
731
Computing over the residue class ring modulo 7 we find:

Mmod7 := Dom::Matrix(Dom::IntegerMod(7)):
A := Mmod7(a): B := Mmod7(b):
C := (2*A + B*Mmod7::transpose(B)): C^(-1)
 
3 mod 7 0 mod 7 1 mod 7
 
 1 mod 7 3 mod 7 2 mod 7 
4 mod 7 2 mod 7 2 mod 7
We check this by multiplying the inverse by the original matrix, which yields the
identity matrix over the coefficient ring:
%*C
 
1 mod 7 0 mod 7 0 mod 7
 
 0 mod 7 1 mod 7 0 mod 7 
0 mod 7 0 mod 7 1 mod 7
Exercise 4.40: We compute over the coefficient ring of rational numbers:

MQ := Dom::Matrix(Dom::Rational):
We consider 3 × 3 matrices. To define the matrix, we pass a function to the

constructor that maps the indices to the corresponding matrix entries:
A-21
A := MQ(3, 3, (i, j) -> (if i=j then 0 else 1 end_if))

 
0 1 1
 
 1 0 1 
1 1 0
The determinant of A is
linalg::det(A)
2
The eigenvalues are the roots of the characteristic polynomial:

p := linalg::charpoly(A, x)
x3 − 3 x − 2
solve(p, x)
{−1, 2}
Alternatively, the linalg package provides a function for computing eigenvalues:

linalg::eigenvalues(A)
{−1, 2}
Let Id denote the 3 × 3 identity matrix. The eigenspace for the eigenvalue
λ ∈ {−1, 2} is the solution space of the system of linear equations
(A − λ · Id) ⃗x = ⃗0. The solution vectors span the nullspace (the “kernel”) of the
matrix A − λ · Id. The function linalg::nullspace computes a basis for the
kernel of a matrix:
Id := MQ::identity(3):
lambda := -1: linalg::nullspace(A - lambda*Id)
   
−1 −1
   
 1  ,  0 
0 1
There are two linearly independent basis vectors. Hence the eigenspace for the
eigenvalue λ = −1 is two-dimensional. The other eigenvalue is simple:
A-22
lambda := 2: linalg::nullspace(A - lambda*Id)

 
1
 
 1 
1
Alternatively, linalg::eigenvectors computes all eigenspaces simultaneously:

linalg::eigenvectors(A)
       
−1 −1 1
       
−1, 2,  1  ,  0  , 2, 1,  1 
0 1 1
The return value is a nested list. For each eigenvalue λ, it contains a list of the form
[ λ , multiplicity of λ , eigenspace basis ].
Exercise 4.41:
p := poly(x^7 - x^4 + x^3 - 1): q := poly(x^3 - 1):
p - q^2

poly x7 − x6 − x4 + 3 x3 − 2, [x]
The polynomial p is a multiple of q :

p/q

poly x4 + 1, [x]
This is confirmed by a factorization:

factor(p)

poly (x − 1, [x]) · poly x2 + x + 1, [x] · poly x4 + 1, [x]
factor(q)

poly (x − 1, [x]) · poly x2 + x + 1, [x]
A-23
Exercise 4.42: We use the identifier R to abbreviate the lengthy type name
Dom::IntegerMod(3). With alias, MuPAD also uses R as an alias in the output of
the following polynomials.
p := 3: alias(R = Dom::IntegerMod(p)):
We only need to try the possible remainders 0, 1, 2 modulo 3 for the coefficients
a, b, c in a x2 + b x + c. We generate a list of all 18 quadratic polynomials with a ̸= 0
as follows:
[((poly(a*x^2 + b*x + c, [x], R) $ a = 1..p-1)
$ b = 0..p-1) $ c = 0..p-1]:
The command select(·, irreducible) extracts the 6 irreducible polynomials:

select(%, irreducible)
2 2
[poly(x + 1, [x], R), poly(2 x + x + 1, [x], R),
2
poly(2 x + 2 x + 1, [x], R),
2 2
poly(2 x + 2, [x], R), poly(x + x + 2, [x], R),
2
poly(x + 2 x + 2, [x], R)]
Exercise 5.1: The value of x is the identifier a1. The evaluation of x yields the
identifier c1. The value of y is the identifier b2. The evaluation of y yields the
identifier c2. The value of z is the identifier a3. The evaluation of z yields 10.
The evaluation of u1 leads to an infinite recursion, which MuPAD aborts with an
error message. The evaluation of u2 yields the expression v2^2 - 1.
Exercise 6.1: The result of subsop(b + a, 1 = c) is b + c and not c + a, as you might

have expected. The reason is that subsop evaluates its arguments. The system
reorders the sum internally when evaluating it, and thus subsop processes a + b
instead of b + a. Upon return, the result c + b is reordered again.
A-24
Exercise 6.2: The highest derivative occurring in g is the 6-th derivative

diff(f(x), x $ 6). We pass the sequence of replacement equations:
diff(f(x), x $ 6) = f6, diff(f(x), x $ 5) = f5, ...,

diff(f(x), x) = f1, f(x) = f0
to MuPAD’s substitution function. Note that, in accordance with the usual

mathematical notation, diff returns the function itself as the 0-th derivative:
diff(f(x), x $ 0) = diff(f(x)) = f(x).
delete f: g := diff(f(x)/diff(f(x), x), x $ 5):

subs(g, (diff(f(x), x $ 6 - i) = f.(6-i)) $ i = 0..6)
4 2 5 2
60 f2 4 f5 20 f3 120 f0 f2 100 f2 f3
------ - ---- + ------ - ---------- - ---------- -
4 f1 2 6 3
f1 f1 f1 f1
f0 f6 25 f2 f4 10 f0 f2 f5 20 f0 f3 f4
----- + -------- + ----------- + ----------- -
2 2 3 3
f1 f1 f1 f1
2 3 2
90 f0 f2 f3 240 f0 f2 f3 60 f0 f2 f4
------------ + ------------- - ------------
4 5 4
f1 f1 f1
Exercise 7.1: The following commands yield the desired evaluation of the
function:
f := sin(x)/x: x := 1.23: f
0.7662510585
However, x now has a value. The following call diff(f, x) would internally lead
to the command diff(0.7662510584, 1.23), since diff evaluates its arguments.
A-25
You can circumvent this problem by preventing a complete evaluation of the

arguments via level or hold (page 5-4):
g := diff(level(f, 1), hold(x)); g
cos(x) sin(x)
−
x x2
−0.3512303507
Here the evaluation of hold(x) is the identifier x and not its value. Writing
hold(f) instead of level(f, 1) would yield the wrong result
diff(hold(f),hold(x)) = 0, since hold(f) does not contain hold(x). Using
level(f, 1) replaces f by its value sin(x)/x (page 5-4). The next call of g returns
the evaluation of g, namely the value of the derivative at x = 1.23. Alternatively
you can delete the value of x:
delete x: diff(f, x) | x = 1.23
−0.3512303507
Exercise 7.2: The first three derivatives of the numerator and the denominator
vanish at the point x = 0:
Z := x -> (x^3*sin(x)): N := x -> ((1 - cos(x))^2):
Z(0), N(0), Z'(0), N'(0), Z''(0), N''(0),
Z'''(0), N'''(0)
0, 0, 0, 0, 0, 0, 0, 0
For the fourth derivatives, we have:

Z''''(0), N''''(0)
24, 6
Thus the limit is Z ′′′′ (0)/N ′′′′ (0) = 4, according to de l’Hospital’s rule. The
function limit computes the same result:
limit(Z(x)/N(x), x = 0)
4
A-26
Exercise 7.3: The first order partial derivatives of f1 are:

f1 := sin(x1*x2): diff(f1, x1), diff(f1, x2)
x2 cos(x1 x2) , x1 cos(x1 x2)
The second order derivatives are:

diff(f1, x1, x1), diff(f1, x1, x2),
diff(f1, x2, x1), diff(f1, x2, x2)
2
- x2 sin(x1 x2), cos(x1 x2) - x1 x2 sin(x1 x2),
2
cos(x1 x2) - x1 x2 sin(x1 x2), - x1 sin(x1 x2)
The total derivative of f2 with respect to t is:

f2 := x^2*y^2: x := sin(t): y := cos(t): diff(f2, t)
3 3
2 cos(t) sin(t) − 2 cos(t) sin(t)
Exercise 7.4:
int(sin(x)*cos(x), x = 0..PI/2),
int(1/(sqrt(1 - x^2)), x = 0..1),
int(x*arctan(x), x = 0..1),
int(1/x, x = -2..-1)
1 π π 1
, , − , − ln(2)
2 2 4 2
Exercise 7.5:
int(x/(2*a*x - x^2)^(3/2), x)
x
√
a 2 a x − x2
int(sqrt(x^2 - a^2), x)
√ √
x x2 − a2 a2 ln x + x2 − a2
−
2 2
A-27
int(1/(x*sqrt(1 + x^2)), x)
r !
1
− arcsinh
x2
Exercise 7.6: The function intlib::changevar only performs a change of

variables without invoking the integration:
intlib::changevar(hold(int)(sin(x)*sqrt(1 + sin(x)),
x = -PI/2..PI/2), t = sin(x))
Z 1 √
t t+1
√ dt
−1 1 − t2
A further evaluation activates the integration routine:

eval(%): % = float(%)
√
2 2
= 0.9428090416
3
Numerical quadrature returns the same result:

numeric::int(sin(x)*sqrt(1 + sin(x)),
x = -PI/2..PI/2)
0.9428090416
Exercise 8.1: The equation solver returns the general solution:

equations := {a + b + c + d + e = 1,
a + 2*b + 3*c + 4*d + 5*e = 2,
a - 2*b - 3*c - 4*d - 5*e = 2,
a - b - c - d - e = 3}:
solve(equations, {a, b, c, d, e})
{[a = 2, b = z + 2 z1 − 3, c = 2 − 3 z1 − 2 z, d = z, e = z1]}
The free parameters are on the right-hand sides of the solved equations. You can
determine them in MuPAD by extracting the right hand sides and using indets to
find the identifiers contained therein:
A-28
map(%, map, op, 2); indets(%)

{[2, z + 2 z1 − 3, 2 − 3 z1 − 2 z, z, z1]}
{z, z1}
Exercise 8.2: The symbolic solution is:

solution := solve(ode(
{y'(x) = y(x) + 2*z(x), z'(x) = y(x)}, {y(x), z(x)}))

C2 e2 x C1 C1
z(x) = − x , y(x) = x + C2 e2 x
2 e e
with free constants C1, C2. We remove the outer curly braces via op:
solution := op(solution)

C2 e2 x C1 C1
z(x) = − x , y(x) = x + C2 e2 x
2 e e
Now, we set x = 0 and substitute y(0) and z(0), respectively, for the initial
conditions. Then, we solve the resulting linear system of equations for C1 and C2:
solve((solution | x = 0) | [y(0) = 1, z(0) = 1],
{C1, C2})

1 4
C1 = − , C2 =
3 3
Again, we remove the outer curly braces via op and assign the solution values to C1
and C2 by means of assign:
assign(op(%)):
Thus, the value at x = 1 of the symbolic solution for the above initial conditions is:
x := 1: solution

1 2 e2 4 e2 1
z(1) = + , y(1) = −
3e 3 3 3e
A-29
Finally, we apply float:

float(%)
[z(1) = 5.04866388, y(1) = 9.729448318]
Exercise 8.3:
solve(ode(y'(x)/y(x)^2 = 1/x, y(x)))

1
−
C3 + ln(x)
solve(ode({y'(x) - sin(x)*y(x) = 0, y'(1)=1}, y(x)))

ecos(1)
ecos(x) sin(1)
solve(ode({2*y'(x) + y(x)/x = 0, y'(1) = PI}, y(x)))

2π
− √
x
A-30
solve(ode({diff(x(t),t) = y(t)*z(t),
diff(y(t),t) = x(t)*z(t),
diff(z(t),t) = t*z(t)},
{x(t),y(t),z(t)}))
{ --
{ |
{ |
{ |
{ | x(t) =
{ --
/ 1/2 1/2 1/2 \

| 2 C10 (-PI) erf(2 t 1/2 I) |
C11 exp| - ----------------------------------- |
\ 2 /
------------------------------------------------ +
2
/ 1/2 1/2 1/2 \

| 2 C10 (-PI) erf(2 t 1/2 I) |
C12 exp| ----------------------------------- |
\ 2 /
----------------------------------------------,
2
y(t) =
/ 1/2 1/2 1/2 \

| 2 C10 (-PI) erf(2 t 1/2 I) |
C11 exp| - ----------------------------------- |
\ 2 /
------------------------------------------------ -
2
/ 1/2 1/2 1/2 \

| 2 C10 (-PI) erf(2 t 1/2 I) |
C12 exp| ----------------------------------- |
\ 2 /
----------------------------------------------,
2
-- }
| }
/ 2 \ | }
| t | | }
z(t) = C10 exp| -- | | } A-31
\ 2 / -- }
Exercise 8.4: The function solve directly yields the solution of the recurrence:
solve(rec(F(n) = F(n-1) + F(n-2), F(n),
{F(0) = 0, F(1) = 1}))
√ √ n √ 1 √ n 
 5 25 + 12 5 2− 2
5 
−
 5 5 
Exercise 9.1: You obtain the answer immediately from simplify:

simplify(cos(x)^2 + sin(x)*cos(x))
cos(2 x) sin(2 x) 1
+ +
2 2 2
You get the same result by applying combine to rewrite products of trigonometric
functions as sums:
combine(cos(x)^2 + sin(x)*cos(x), sincos)
cos(2 x) sin(2 x) 1
+ +
2 2 2
Exercise 9.2:
expand(cos(5*x)/(sin(2*x)*cos(x)^2))
2 3
cos(x) 5 sin(x)
− 5 sin(x) + 2
2 sin(x) 2 cos(x)
f := (sin(x)^2 - exp(2*x)) /
(sin(x)^2 + 2*sin(x)*exp(x) + exp(2*x)):
normal(expand(f))
ex − sin(x)
−
ex + sin(x)
f := (sin(2*x) - 5*sin(x)*cos(x)) /
(sin(x)*(1 + tan(x)^2)):
A-32
combine(normal(expand(f)), sincos)
3 cos(x)
− 2
tan(x) + 1
f := sqrt(14 + 3*sqrt(3 +
2*sqrt(5 - 12*sqrt(3 - 2*sqrt(2))))):
simplify(f, sqrt)
√
2+3
Exercise 9.3: As a first step, we perform a normalization:

int(sqrt(sin(x) + 1), x): normal(diff(%, x))
2 2 3
3 cos(x) sin(x) + cos(x) + 2 sin(x) − 2 sin(x)
2
p
cos(x) sin(x) + 1
Then we eliminate the cosine terms:

rewrite(%, sin)

2 3 2
2 sin(x) + sin(x) − 2 sin(x) + 3 sin(x) sin(x) − 1 − 1
p
2
sin(x) + 1 sin(x) − 1
The final normalization step achieves the desired simplification:

normal(%)
p
sin(x) + 1
On the other hand, calling Simplify is much easier:

int(sqrt(sin(x) + 1), x): Simplify(diff(%, x))
p
sin(x) + 1
A-33
Exercise 9.4: The problem obviously is that the valuation function does not look
carefully enough at the term to analyze. To remedy this, we use the function
length which returns a general, quickly computed “complexity:”
noTangent := x -> if has(x, [hold(tan), hold(cot)])

then 1000000
else length(x) end_if:
Simplify(tan(x) - cot(x), Valuation = noTangent)
2 cos(2 x)
−
sin(2 x)
Exercise 9.5: The operator assuming (page 9-18) assigns properties to

identifiers. These are taken into account by limit:
limit(Ei(a*x), x = infinity)
lim Ei(a x)
x→∞
limit(Ei(a*x), x = infinity) assuming a > 0

∞
limit(Ei(a*x), x = infinity) assuming a < 0
0
Exercise 10.1: In analogy to the previous gcd example, we obtain the following
experiment:
die := random(1..6):
experiment := [[die(), die(), die()] $ i = 1..216]:
diceScores := map(experiment,
x -> (x[1] + x[2] + x[3])):
frequencies := Dom::Multiset(op(diceScores)):
sortingOrder := (x, y) -> (x[1] < y[1]):
A-34
sort([op(frequencies)], sortingOrder)
[[4, 4], [5, 9], [6, 8], [7, 9], [8, 16], [9, 20],
[10, 27], [11, 31], [12, 32], [13, 20], [14, 13],
[15, 12], [16, 6], [17, 7], [18, 2]]
In this experiment, the score 3 did not occur.
Exercise 10.2: a) The command frandom is a generator for random

floating-point numbers in the interval [0, 1]. The call
n := 1000:
absValues := [sqrt(frandom()^2+frandom()^2) $ i = 1..n]:
returns a list with the absolute values of n random vectors in the rectangle
Q = [0, 1] × [0, 1]. The number of values ≤ 1 is the number of random points in the
right upper quadrant of the unit circle:
m := nops(select(absValues, z -> (z <= 1)))
821
Since m/n approximates the area π/4 of the right upper quadrant of the unit circle,
we obtain the following approximation to π :
float(4*m/n)
3.284
b) First we determine the maximum of f . The following function plot shows that f
is monotonically increasing on the interval [0, 1]:
A-35
f := x -> x*sin(x) + cos(x)*exp(x):

plotfunc2d(f(x), x = 0..1):
Thus f (x) assumes its maximal value at the right end of the interval. Therefore,
M = f (1) is an upper bound for the function:
M := f(1.0)
2.310164925
We use the random number generator defined above to generate random points in
the rectangle [0, 1] × [0, M ]:
n := 1000:
pointlist := [[frandom(), M*frandom()] $ i = 1..n]:
We select those points p = [x, y] for which 0 ≤ y ≤ f (x) holds:

select(pointlist, p -> (p[2] <= f(p[1]))):
m := nops(%)
742
Thus the following is an approximation of the integral:

m/n*M
1.714142374
A-36
The exact value is:

float(int(f(x), x = 0..1))
1.679193292
Exercise 13.1: With the following definition of the postOutput method of Pref,
the system prints an additional status line:
Pref::postOutput(
proc()
begin
"bytes: " .
expr2text(op(bytes(), 1)) . " (logical) / " .
expr2text(op(bytes(), 2)) . " (physical)"
end_proc):
float(sum(1/i!, i = 0..100))
2.718281828
bytes: 836918 (logical) / 1005938 (physical)
Exercise 14.1: We first generate the set S :

f := i -> (i^(5/2)+i^2-i^(1/2)-1) /
(i^(5/2)+i^2+2*i^(3/2)+2*i+i^(1/2)+1):
S := {f(i) $ i=-1000..-2} union {f(i) $ i=0..1000}:
Then we apply domtype to all elements of the set to determine their domain types:
map(S, domtype)
{DOM_RAT, DOM_INT, DOM_EXPR}
You see the explanation for this result by looking at some elements:
f(-2), f(0), f(1), f(2), f(3), f(4)
5 √ √ √
(−2) 2 + 3 − 2i 3 2+3 8 3+8 3
3 5 √ , −1, 0, √ , √ ,
2 (−2) 2 + (−2) 2 + 1 + 2 i 9 2 + 9 16 3 + 16 5
The function normal simplifies the expressions containing square roots:
A-37
map(%, normal)
1 1 3
3, −1, 0, , ,
3 2 5
Now we apply normal to all elements of the set before querying their data type:
map(S, domtype@normal)
{DOM_RAT, DOM_INT}
Thus, all numbers in S are indeed rational (in particular there are two integer
values f(0) = -1 and f(1) = 0). The reason is that f(i) can be simplified to
(i - 1)/(i + 1):
normal(f(i))
i−1
i+1
Exercise 14.2: We apply testtype(·, "sin") to each element of the list:

list := [sin(i*PI/200) $ i = 0..100]:
to find out whether it is returned in the form sin(·). The following split
command (page 4-36) decomposes the list accordingly:
decomposition := split(list, testtype, "sin"):
MuPAD simplified 9 of the 101 calls:
A-38
map(decomposition, nops); decomposition[2]

[92, 9, 0]
-- 1/2 1/2 1/2 1/2 1/2 1/2

| 5 (2 - 2 ) 2 (5 - 5 )
| 0, ---- - 1/4, -------------, ------------------,
-- 4 2 4
1/2 1/2 1/2 1/2

2 5 (2 + 2)
----, ---- + 1/4, -------------,
2 4 2
1/2 1/2 1/2 --

2 (5 + 5) |
------------------, 1 |
4 --
Exercise 14.3: You can use select (page 4-36) to extract those elements that
testtype identifies as positive integers. For example:
set := {-5, 2.3, 2, x, 1/3, 4}:

select(set, testtype, Type::PosInt)
{2, 4}
Note that this selects only those objects that are positive integers, but not those
that might represent positive integers, such as the identifier x in the above
example. This is not possible with testtype. Instead, you can use assume to set
this property and query it via is:
assume(x, Type::PosInt):
select(set, is, Type::PosInt)
{2, 4, x}
A-39
Exercise 14.4: We construct the desired type specifier and employ it as follows:
T := Type::ListOf(Type::ListOf(
Type::AnyType, 3, 3), 2, 2)
Type::ListOf(Type::ListOf(Type::AnyType, 3, 3) , 2, 2)
testtype([[a, b, c], [1, 2, 3]], T),

testtype([[a, b, c], [1, 2]], T)
TRUE, FALSE
Exercise 16.1: Consider the conditions x <> 1 and A and x = 1 or A, respectively.

After entering:
x := 1:
it is not possible to evaluate them due to the singularity in x/(x − 1):

x <> 1 and A
Error: Division by zero [_power]
x = 1 or A
However, this is not a problem within an if statement since the Boolean

evaluation of x <> 1 and x = 1 already tells us that x <> 1 and A evaluates to FALSE
and x = 1 or A to TRUE, respectively:
(if x <> 1 and A then right else wrong end_if),
(if x = 1 or A then right else wrong end_if)
wrong, right
On the other hand, evaluation of the following if statement still produces an

error, since it is necessary to evaluate A in order to determine the truth value of
x = 1 and A:
if x = 1 and A then right else wrong end_if
A-40
Exercise 17.1: With the formulas given, implementation of the "float" slots is
straightforward:
ellipE::float := z -> float(PI/2) *
hypergeom::float([-1/2, 1/2], [1], z):
ellipK::float := z -> float(PI/2) *
hypergeom::float([1/2, 1/2], [1], z):
This is almost sufficient:

ellipE(1/3)

1
E
3
float(%)
1.430315257
However, one thing is missing: we would like to have calls with floating point
arguments evaluated immediately:
ellipE(0.1)
E(0.1)
To this end, we must extend the definitions of ellipE and ellipK:

ellipE :=
proc(x) begin
if domtype(x) = DOM_FLOAT
or domtype(x) = DOM_COMPLEX
and (domtype(Re(x)) = DOM_FLOAT
or domtype(Im(x)) = DOM_FLOAT)
then
return(ellipE::float(x));
end_if;
if x = 0 then PI/2
elif x = 1 then 1
end_proc:
Extend ellipK analogously, then make these new functions into function
environments (the above definition replaced the old one completely) and add the
function slots we used for the original definitions and the new float slots, and you
get:
A-41
ellipE(0.1)
1.530757637
Exercise 17.2: The following procedure evaluates the Abs function:

Abs := proc(x)
begin
if domtype(x) = DOM_INT or domtype(x) = DOM_RAT
or domtype(x) = DOM_FLOAT
then if x >= 0 then x else -x end_if;
else procname(x);
end_if
end_proc:
We convert Abs to a function environment and supply a function producing the

desired screen output:
Abs := funcenv(Abs,
proc(f) begin
"|" . expr2text(op(f)) . "|"
end_proc,
NIL):
Then we set the function attribute for differentiation:

Abs::diff := proc(f,x) begin
f/op(f)*diff(op(f), x)
end_proc:
Now we have the following behavior:

Abs(-23.4), Abs(x), Abs(x^2 + y - z)
23.4, |x|, |x^2 + y - z|
The diff attribute of the system function abs yields a slightly different but
equivalent result:
diff(Abs(x^3), x), diff(abs(x^3), x)
3 |x^3| 2
-------, 3 |x| sign(x)
x
A-42
Exercise 17.3: We use expr2text (page 4-49) to convert the integers passed as
arguments to strings. Then we combine them, together with some slashes, via the
concatenation operator “.”:
date := proc(month, day, year) begin
print(Unquoted, expr2text(month) . "/" .
expr2text(day) . "/" .
expr2text(year))
end_proc:
Exercise 17.4: We present a solution using a while loop. The condition x mod
2 = 0 checks whether x is even:
f := proc(x) local i;
begin
i := 0;
userinfo(2, "term " . expr2text(i) . ": " .
expr2text(x));
while x <> 1 do
if x mod 2 = 0 then x := x/2
else x := 3*x+1 end_if;
i := i + 1;
userinfo(2, "term " . expr2text(i) . ": " .
expr2text(x))
end_while;
i
end_proc:
f(4), f(1234), f(56789), f(123456789)
2, 132, 60, 177
If we set setuserinfo(f, 2) (page 13-9), then the userinfo command outputs all
terms of the sequence until the procedure terminates:
setuserinfo(f, 2): f(4)
Info: term 0: 4
Info: term 1: 2
Info: term 2: 1
A-43
If you do not believe in the 3 x + 1 conjecture, you should insert a stopping

condition for the index i to ensure termination.
Exercise 17.5: A recursive implementation based on the relation

gcd(a, b) = gcd(a mod b, b) leads to an infinite recursion: we have
a mod b ∈ {0, 1, . . . , b − 1}, and hence
(a mod b) mod b = a mod b
in the next step. Thus the function gcd would always call itself recursively with the
same arguments. However, a recursive call of the form gcd (a, b) = gcd(b, a mod b)
make sense. Since a mod b < b, the function calls itself recursively for decreasing
values of the second argument, which finally becomes zero:
Gcd := proc(a, b) begin /* recursive variant */
if b = 0
then a
else Gcd(b, a mod b)
end_if
end_proc:
For large values of a and b, you may need to increase the value of the environment
variable MAXDEPTH if Gcd exhausts the valid recursion depth. The following
iterative variant avoids this problem:
GCD := proc(a, b)
begin
while b <> 0 do
[a, b] := [b, a mod b];
end_while;
a
end_proc:
These implementations yield the same results as the functions igcd and gcd
provided by the system:
a := 123456: b := 102880:
Gcd(a, b), GCD(a, b), igcd(a, b), gcd(a, b)
20576, 20576, 20576, 20576
A-44
Exercise 17.6: In the following implementation, we generate a shortened copy

Y = [x1 , . . . , xn ] of X = [x0 , . . . , xn ] and compute the list of differences
[x1 − x0 , . . . , xn − xn−1 ] via zip and _subtract (_subtract(y,x) = y - x). Then we
multiply each element of this list with the corresponding numerical value in the
list [f (x0 ), f (x1 ), . . . ]. Finally, the function _plus adds all elements of the
resulting list:
[(x1 − x0 ) f (x0 ), . . . , (xn − xn−1 ) f (xn−1 )] :
Quadrature := proc(f, X)
local Y, distances, numericalValues, products;
begin
Y := X; delete Y[1];
distances := zip(Y, X, _subtract);
numericalValues := map(X, float@f);
products := zip(distances, numericalValues, _mult);
_plus(op(products))
end_proc:
In the following example, we use n = 1000 equidistant sample points in the

interval [0, 1]:
f := x -> (x*exp(x)): n := 1000:
Quadrature(f, [i/n $ i = 0..n])
0.9986412288
R1
This is a (crude) numerical approximation of 0
x ex dx (= 1).
A-45
Exercise 17.7: The specification of Newton requires that the first argument f be
an expression and not a MuPAD function. Thus, to compute the derivative, we
first use indets to determine the unknown in f. We substitute a numerical value
for the unknown to evaluate the iteration function F (x) = x − f (x)/f ′ (x) at a
point:
Newton := proc(f, x0, n)
local vars, x, F, sequence, i;
begin
vars := indets(float(f)):
if nops(vars) <> 1
then error(
"the function must contain exactly one unknown"
)
else x := op(vars)
end_if;
F := x - f/diff(f,x); sequence := x0;
x0 := float(subs(F, x = x0));
sequence := sequence, x0
end_for;
return(sequence)
end_proc:
In the following example, Newton

√ computes the first terms of a sequence rapidly
converging to the solution 2:
Newton(x^2 - 2, 1, 6)
1, 1.5, 1.416666667, 1.414215686, 1.414213562,
1.414213562, 1.414213562
A-46
The following procedure uses Newton to plot the approximation procedure:

plotNewton :=
proc(f, x0, n)
local x, xvals, xmin, xmax, i, xi;
begin
xvals := Newton(f, x0, n);
xmin := min(xvals);
xmax := max(xvals);
[xmin, xmax] :=
[xmin - (xmax - xmin)/2, xmax + (xmax - xmin)/2];
x := op(indets(f));
plot(plot::Function2d(f, x=xmin..xmax),
plot::Line2d([xvals[i], f | x=xvals[i]],
[xvals[i+1], 0]) $ i = 1..nops(xvals)-1,
plot::Line2d([xvals[i], 0], [xvals[i], f | x=xvals[i]],
LineStyle = Dashed) $ i = 1..nops(xvals),
plot::Line2d::LineColor = RGB::Red)
end_proc:
plotNewton(x^2 - 2, 1, 3)
A-47
plotNewton(sin(x)+5*sin(x/3), 4, 3)
Exercise 17.8: The call numlib::g_adic(..,2) yields the binary expansion of an

integer as a list of bits:
numlib::g_adic(7, 2), numlib::g_adic(16, 2)
[1, 1, 1] , [0, 0, 0, 0, 1]
Instead of calling numlib::g_adic directly, our solution uses a subprocedure

binary furnished with the option remember. This accelerates the computation
notably since numlib::g_adic is called frequently with the same arguments. The
call isSPoint([x, y]) returns TRUE when the point specified by the list [x, y] is a
Sierpinski point. To check this, the function multiplies the lists with the bits of the
two coordinates. At those positions where both x and y have a 1 bit, multiplication
yields a 1. In all other cases, 0 · 0, 1 · 0, 0 · 1, produce the result 0. If the list of
products contains at least one 1, the point is a Sierpinski point.
A-48
We use select (page 4-28) to extract the Sierpinski points from all points
considered. Finally, we create a plot::PointList2d with these points and call
plot (page 11-1):
Sierpinski := proc(xmax, ymax)

local binary, isSPoint, allPoints, i, j, SPoints;
begin
binary := proc(x) option remember; begin
numlib::g_adic(x, 2)
end_proc;
isSPoint := proc(Point) local x, y; begin
x := binary(Point[1]);
y := binary(Point[2]);
has(zip(x, y, _mult), 1)
end_proc;
allPoints := [([i, j] $ i = 1..xmax) $ j = 1..ymax];
SPoints := select(allPoints, isSPoint);
plot(plot::PointList2d(SPoints, Color = RGB::Black));
end_proc:
For xmax = ymax = 100, say, you obtain a quite appealing picture:
Sierpinski(100, 100)
A-49
Exercise 17.9: We present a recursive solution. Given an expression

formula(x1, x2, ...) with the identifiers x1, x2, ..., we collect the identifiers in
the set x = {x1, x2, ...} by means of indets. Then we substitute TRUE and FALSE,
respectively, for x1 (= op(x, 1)), and call the procedure recursively with the
arguments formula(TRUE, x2, x3, ...) and formula(FALSE, x2, x3, ...),
respectively. In this way, we test all possible combinations of TRUE and FALSE for
the identifiers until the expression can finally be simplified to TRUE or FALSE at the
bottom of the recursion. This value is returned to the calling procedure. If at least
one of the TRUE/FALSE combinations yields TRUE, then the procedure returns TRUE,
indicating that the formula is satisfiable, and otherwise it returns FALSE.
satisfiable := proc(formula) local x;
begin
x := indets(formula);
if x = {} then return(formula) end_if;
return(satisfiable(subs(formula, op(x, 1) = TRUE))
or satisfiable(subs(formula, op(x, 1) = FALSE)))
end_proc:
If the number of identifiers in the input formula is n, then the recursion depth is
at most n and the total number of recursive calls of the procedure is at most 2n .
We apply this procedure in two examples:
F1 := ((x and y) or (y or z)) and (not x) and y and z:
F2 := ((x and y) or (y or z)) and (not y) and (not z):
satisfiable(F1), satisfiable(not F1),
satisfiable(F2), satisfiable(not F2)
TRUE, TRUE, FALSE, TRUE
The call simplify(·, logic) (page 9-13) simplifies logical formulae. Formula F2
can be simplified to false, no matter what the values of x, y , and z are:
simplify(F1, logic), simplify(F2, logic)
¬x ∧ y ∧ z, FALSE
A-50
B
Documentation and References
You can find a list of all documents that are available in your installation by
choosing “Browse Help” from the “Help” menu of any MuPAD® notebook window
and then clicking on “Contents”.
The MuPAD Quick Reference lists all MuPAD data types, functions, and libraries,
and provides a survey of its functionality.
You also find links to various libraries such as, for example, Dom (the library for
pre-installed data types). The corresponding documentation contains a concise
description of all domains provided by Dom. In a MuPAD session, the command
?Dom directly opens this document. Moreover, you can access the description of
individual data structures from this document, such as Dom::Matrix, directly
through the call ?Dom::Matrix. Another example is the documentation for the
linalg package (linear algebra). It can be requested directly via ?linalg.
As an introduction to MuPAD, targeted especially at Windows® users, we

recommend the following books:
[Maj 05] M. Majewski Getting Started with MuPAD. Springer Heidelberg, 2005.
ISBN 3-540-28635-7
[Maj 04] M. Majewski MuPAD Pro Computing Essentials, Second Edition.

Springer Heidelberg, 2004. ISBN 3-540-21943-9
In addition to the MuPAD documentation, we recommend the following books

about computer algebra in general and the underlying algorithms:
[Wes 99] M. Wester (ed.), Computer Algebra Systems. A Practical Guide. Wiley,
1999.
B Documentation and References
[GG 99] J. von zur Gathen and J. Gerhard, Modern Computer Algebra.
Cambridge University Press, 1999.
[Hec 93] A. Heck, Introduction to Maple. Springer, 1993.
[DTS 93] J.H. Davenport, E. Tournier and Y. Siret, Computer Algebra: Systems
and Algorithms for Algebraic Computation. Academic Press, 1993.
[GCL 92] K.O. Geddes, S.R. Czapor and G. Labahn, Algorithms for Computer
Algebra. Kluwer, 1992.
B-2
C
C Graphics Gallery
Graphics Gallery
C-2
Graphics Gallery
C-3
C Graphics Gallery
C-4
Graphics Gallery
C-5
C Graphics Gallery
C-6
Graphics Gallery
C-7
C Graphics Gallery
C-8
Graphics Gallery
C-9
C Graphics Gallery
C-10
Graphics Gallery
C-11
C Graphics Gallery
C-12
Graphics Gallery
C-13
C Graphics Gallery
C-14
Graphics Gallery
C-15
C Graphics Gallery
C-16
Graphics Gallery
C-17
D
Comments on the Graphics

Gallery
On the color pages of this book you find a gallery of pictures demonstrating the
power of the MuPAD® graphics. These pictures are discussed at various locations
in this book and the online plot documentation, respectively. There, further
details including the MuPAD commands for reproducing the pictures can be
found.
Figure 1 shows a plot of several functions. Singularities are highlighted by
“vertical asymptotes.” See page 11-3. Figure 2 shows a function plot together
with a spline interpolation through a set of sample points. See page 11-39.
Figure 3 demonstrates some layout possibilities. See the examples on the help
page of the graphical attribute Layout in the online plot documentation.
Figure 4 demonstrates the construction of cycloids via points fixed to a rolling
wheel. See page 11-41.
Figure 5 and Figure 6 demonstrate hatched areas between functions and within
closed curves, respectively. See the examples on the help page of plot::Hatch.
Figure 7 shows various statistical distribution functions.
Figure 8 shows an imported bitmap inside function plots. See page 11-110.
Figure 9 shows some frames of an animation of the perturbed orbit of a small
planet kicked out of a solar system by a giant planet after a near-collision. The
animation is generated in Section Animations“ / Examples“ of the online plot
” ”
documentation.
Figure 10 visualizes the vector field ⃗v (x, y) = (sin(3 π y), sin(3 π x)).
D Comments on the Graphics Gallery
Figure 11 shows three solution curves of an ODE inside the directional vector
field associated with the ODE. See the examples on the help page of
plot::VectorField2d.
Figure 12 shows several rotated copies of a function graph. See the examples on
the help page of plot::Rotate2d.
Figure 13 shows the Mandelbrot set together with two blow ups of regions of
special interest. See the examples on the help page of plot::Density.
Figure 14 shows a bar plot of statistical data. See the examples on the help page
of plot::Bars2d.
Figure 15 shows the image of a rectangle in the complex plane under the map
z → sin(z 2 ). See the examples on the help page of plot::Conformal.
Figure 16 shows some elliptic curves generated as a contour plot. See the
examples on the help page of plot::Implicit2d.
Figure 17 shows the Feigenbaum diagram of the logistic map. See the examples
on the help page of plot::PointList2d.
p
Figure 18 shows Bessel functions Jν ( x2 + y 2 ) with ν = 0, 4, 8. See the
examples on the help page of plot::Function3d.
Figure 19 shows 3D function plots with coordinate grid lines. See the examples
on the help page of the graphical attribute GridVisible.
Figure 20 shows “Klein’s bottle” (a famous topological object). This surface does
not have an orientation; there is no “inside” and no “outside” of this object. See
the examples on the help page of plot::Surface.
Figure 21 models various snails using plot::Surface (by Maike Kramer-Jka).
Figure 22 demonstrates the re-construction of an object with rotational
symmetry from measurements of its radius at various points. See page 11-44.
Figure 23 shows the solution set of the equation z 2 = sin(z − x2 · y 2 ) in 3D. See
the examples on the help page of plot::Implicit3d.
Figure 24 shows the “Lorenz attractor.” See page 11-116.
D-2
Index
# _and . . . . . . . . . . . . . . . . . . . . . . see and
_assign . . . . . . . . . . . . . . . . . . 4-9, A-9
! . .. . . . . . . . . . . . . . . . . . . . . . . see fact
_concat . . . 4-16, 4-17, 4-30, 4-49, A-15
". .. . . . . . . . . . . . . . . . . . . . . see strings
_concat . . . . . . . . . . . . . . . . . . . . . 4-10
$. .. . . . . . . . . . . . . . . . . . . . . 4-13, 4-18
_divide . . . . . . . . . . . . . 4-13, 4-15, 4-16
'. .. . . . . . . . . . . . . . . . . 2-12, 2-22, 7-2
_equal . . . . . . . . . . . . . . 4-16, 14-2, 14-5
‘ . .. . . . . . . . . . . . . . . . . . . . . . . . . . 4-8
_exprseq . . . . . . . . . . . . . . . . . 4-16, 4-21
*. .. . . . . . . . . . . . . . . . . . . . . . see _mult
_fconcat . . . . . . . . . . . . . . . . . . . . . see @
+. .. . . . . . . . . . . . . . . . . . . . . . see _plus
_fnest . . . . . . . . . . . . . . . . . . . . . see @@
-. .. . . . . . . . see _negate and _subtract
_fnest . . . . . . . . . . . . . . . . . . . . . . . 4-16
--> . . . . . . . . . . . . . . . . . . . . . 4-14, 4-52
_for . . . . . . . . . . . . . . . . . . . . . . . . . 15-5
-> . . . . 2-16, 2-22, 2-25, 2-26, 2-28, 2-29,
_if . . . . . . . . . . . . . . . . . . . . . . . . . . 16-3
4-14, 4-52, 4-65, 5-8, 6-3, 7-2, 8-13,
_index . . . . . . . . . . . . . . . . . . . . . . 4-29
10-4, 16-3, 17-1, 17-6, 17-27, 17-31,
_intersect . . . . . . . . . . . . see intersect
A-4, A-11, A-16, A-19, A-35–A-37,
_leequal . . . . . . . . . . . . . . . . . . . . . . 4-14
A-45
_less . . . . . . . . . . 4-14, 4-16, 14-2, A-14
. . . . . . . . . see _concat and concatenation
_mult . . 4-13, 4-16, 4-21, 4-33, 6-6, 14-2,
.. . . . . . . . . . . see expressions, range (..)
A-10
... . . . . . . . . . . . . . . . . . . . . . . . see hull
_negate . . . . . . . . . . . . . . . . . . . . . 4-13
/ . . . . . . . . . . . . . . . . . . . . . . see _divide
_plus . 4-13, 4-16, 4-17, 4-21, 4-22, 4-33,
/* ... */ . . . . . . . . . . . . . see comments
4-34, 6-6, 14-2, 17-12, A-10
// . . . . . . . . . . . . . . . . . . . see comments
_power 4-13, 4-16, 4-17, 4-21, 4-33, 9-13,
: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-3
14-2
:= . . . . . . . . . . . . . . . . . . . see assignment
_seqgen . . . . . . . . . . . . 4-15, 4-16, 4-24
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-3
_subtract . . . . . . . . . . . 4-13, 4-16, A-45
< . . . . . . . . . . . . . . . . . . . . . . . . see _less
_unequal . . . . . . . . . . . . . . . . . . . . . . 4-13
<= . . . . . . . . . . . . . . . . . . . . see _leequal
_union . . . . . . . . . . . . . . . . . . 4-16, 4-17
<> . . . . . . . . . . . . . . . . . . . . see _unequal
= . . . . . . . . . . . . . . . . . . . . . . . see _equal
> . . . . . . . . . . . . . . . . . . . . . . . . see _less A
>= . . . . . . . . . . . . . . . . . . . . see _leequal
abbreviation . . . . . . . . . . . see assignment
? . . . . . . . . . . . . . . . . . . . . . . . . . see help
abs . . . . . . . . . . . . . 2-10, 4-7, 9-23, A-42
@ . 4-15, 4-52, 4-58, 7-2, A-19, A-38, A-45
addition theorems . . . . . . . . . . . 2-14, 9-5
@@ . . . . . . . . . . . . . . . . . 4-15, 4-52, 4-58
algebraic structures . . . . . . . . . 4-60–4-63
$ . . . . 2-25–2-27, 2-29, 4-17, 4-24, 4-28,
alias . . . . . . . . . . . . . . . . . . . . . . . A-24
4-41, 6-7, 7-2, 10-1–10-4, 14-5,
anames . . . . . . . . . . . . . 4-10, 4-51, A-15
17-23, A-4, A-7, A-9–A-11,
and . . . . . . . . . . . . . . . . 4-16, 4-18, A-14
A-14–A-16, A-24, A-25, A-34–A-38
and . . . 4-14, 4-23, 4-47, 16-2, 17-42, A-9,
% . . . . 2-3, 2-13, 2-18, 2-20, 4-17, 5-7, 8-2,
A-50
8-9, 9-3, 9-12, 9-17, 13-6, A-4, A-15,
animations 11-8, 11-24, 11-36, 11-71–11-94
A-16, A-19, A-24, A-26, A-28–A-30,
examples . . . . . . . . . . . . 11-90–11-94
A-33, A-36
frame by frame ∼ . . . . . . 11-83–11-89
^ . . . . . . . . . . . . . . . . . . . . . . . see _power
Index
join ∼ . . . . . . . . . . . . . . . . . . . 11-93 batch mode . . . . . . . . . . . . 11-108–11-109

number of frames . . . . . . 11-76–11-78 Bitmap . . . . . . . . . . . . . . . . . . . . . 11-107
playing ∼ . . . . . . . . . . . . . . . . . 11-75 bool . . . . . . . . . . . . . . . . . . . . 4-47, A-15
simple ∼ . . . . . . . . . . . . 11-71–11-75 Boolean expressions . . . . . . . . 4-47–4-48
start . . . . . . . . . . . . . . . . . . . . . 11-9 evaluation (bool) . . . . . . . . . . . 4-47
synchronization of ∼ . . . 11-79–11-83 branching (if and case) . . . . . . 16-1–16-6
time range of ∼ . . . . . . . 11-76–11-78 return value . . . . . . . . . . . 16-3, 16-5
annulus . . . . . . . . . . . . . . . . . . . . . . 11-91
approximate solution . . . . . . . . . see float
arccos . . . . . . . . . . . . . . . . . . . . . . . 2-14
C
arccosh . . . . . . . . . . . . . . . . . . . . . . 2-14 C . . . . see C_ and domain, Dom::Complex
arcsin . . . . . . . . . . . . . . . . . . . . . . . 2-14 C/C++ additions to MuPAD . . . . . . . . 1-6
arcsinh . . . . . . . . . . . . . . . . . . . . . . 2-14 C_ . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-7
arctan . . . . . . . . . . . . . . . . . . . . . . . 2-14 cameras in 3D . . . . . . . . . . . 11-112–11-119
arctanh . . . . . . . . . . . . . . . . . . . . . . 2-14 animated . . . . . . . . . . . . . . . . 11-117
arg . . . . . . . . . . . . . . . . . . . . . . . . . 2-10 canvas . . . . . . . . . . . . . . . . . . . . . . . 11-46
args . . . . . . . . . . . . . . 17-8, 17-21, 17-22 case . . . . . . . . . . . . . . . . . . . . . . . . . 16-5
array . . . . . . . . . 4-44, 4-46, 4-66, A-14 case distinction . . . . . . . . . see piecewise
arrays . . . . . . . . . . . . . . . . . . . 4-44–4-46 ceil . . . . . . . . . . . . . . . . . . . . . . . . . 4-7
0-th operand . . . . . . . . . . . . . . 4-45 characteristic polynomial
deleting elements . . . . . . . . . . . 4-45 (linalg::charpoly) . . . 4-75, A-22
dimension . . . . . . . . . . . . . . . . 4-45 Chebyshev polynomials . . . . . . 4-55, A-16
generation of ∼ . . . . . . . . . . . . 4-44 χ2 -test (stats::csGOFT) . . . . . . . . . . 10-5
matrix multiplication . . . . . . . . 17-11 coeff . . . . . . . . . . . . . . . . . . . 4-57, 4-85
arrow operator (->) . . . . . . . . . . . . . 4-52 coin tosses . . . . . . . . . . . . . . . . . . . . 10-2
assign . . . 4-10, 8-3, A-5, A-8, A-9, A-29 collect . . . . . . . . . . . . . . . . . . . . . . 9-3
assignment . . . . . . . . . . . . . . . . 2-11, 4-8 colon . . . . . . . . . . . . . . . . . . . . . . . . 2-3
delete . . . . . . . . . . . . . . . . . . . . 4-9 colors . . . . . . . . . . . . . . . . . . 11-67–11-70
indexed . . . . . . . . . . . . . . . . . . 4-29 finding ∼ by name . . . . . . . . . . 11-67
simultaneous ∼ . . . . . 4-9, 4-28, A-5 HSV ∼ . . . . . . . . . . . . . . 11-69–11-70
to sublist . . . . . . . . . . . . . . . . . 4-29 opacity . . . . . . . . . . . . . . . . . . 11-68
assume . 7-4, 9-18, 9-18, 9-19, 9-22, 9-23 RGB ∼ . . . . . . . . . . . . . . 11-67–11-69
assumeAlso . . . . . . . . . . . . . . . . . . . 9-18 RGBa ∼ . . . . . . . . . . . . . . . . . . 11-68
assuming . . . . . . . . . . . . 9-18, 9-20, A-34 column vectors . . . . . . . . . . . . 2-19, 4-66
assumingAlso . . . . . . . . . . . . . . . . . 9-18 combine . . . . . . . . . . . . . 9-3, 9-13, A-32
assumptions about properties . . . . . . . . comments . . . . . . . . . . . . . . . . . . . . . 17-3
. . . . . . . . . . . . . see assume and is comparisons . . . . . . . . . . . . . . . . . . . 4-14
asymptotic expansion (series) . . . . . 4-58 composition operator . . . . . . . . . . . . see @
atoms . . . . . . . . . . . . . . . . . . . . 4-3, 4-20 composition operator (@) . . . . . . . . . 4-58
attributes . . . . . . . see graphics, attributes computation
exact . . . . see symbolic computations
hybrid . . . . . . . . . . . . . . . . . . . . 1-4
B numerical . . . . . . . . . . . . . . . . . .
backtick . . . . . . . . . . . . . . . . . . . . . . 4-8 . . . . . . see numerical computations
Index-2
Index
symbolic . see symbolic computations partial derivatives . . . . . . . . . . . . 7-2

computer algebra . . . . . . . . . . . . . . . . 1-3 sample procedure . . . . . 17-38–17-40
concatenation (. and _concat) DIGITS . . . 1-5, 2-7, 2-9, 4-7, 4-97, 13-11,
of lists . . . . . . . . . . . . . . . . . . . 4-30 17-25, A-6, A-20
of matrices . . . . . . . . . . . . . . . . . 4-71 discont . . . . . . . . . . . . . . . . . . . . . 2-22
of names . . . . . . . . . . . . . . . . . 4-10 discontinuities (discont) . . . . . . . . . 2-22
of strings . . . . . . . . . . . . . . . . . 4-49 distribution function . . . . . . . . . . . . 10-4
conjugate . . . . . . . . . . . . . . . . 2-10, 4-71 div . . . . . . . . . . . . . . . . . . . . . . 4-6, 4-13
contains . . . . . . . . 4-30, 4-37, 4-38, 4-42 divide . . . . . . . . . . . . . . . . . . . . . . 4-86
context . . . . . . . . . . . . . . . . . . . . . 17-28 Dodecahedron . . . . . . . . . . . . . . . . . 11-54
cycloid . . . . . . . . . . . . . . . . . . . . . . 11-41 domain
Dom::ExpressionField . . . . . . 4-62
Dom::Float . . . . . . . . . . . . . . . 4-60
D Dom::FloatIV . . . . . . . . . . . . . 4-96
D . . . . . . . . . . . . . . . . . . . 4-16, 4-89, 7-2 Dom::ImageSet . . . . . . . . . . . . . 8-9
data type . . . . . . . . . . . . . . . . . . . . . . 1-6 Dom::Integer . . . . . . . . . . . . . 4-60
debugger . . . . . . . . . . . . . . . . . . . . . . 1-6 Dom::IntegerMod . . . . . . 4-60, A-24
decompose . . . . . . . . . . . . . see operands Dom::Interval . . . . . . . . . . . . . 8-11
degree . . . . . . . . . . . . . . . . . . . . . . 4-85 Dom::Matrix . . . . . . . . . . . . . . 4-65
delayed evaluation (hold) . . . . . . . . . . 5-8 Dom::Multiset . . . . . . . 10-3, A-34
delete . . . 2-8, 2-9, 2-28, 3-5, 4-9, 4-10, Dom::Rational . . . . . . . . . . . . 4-60
4-15, 4-27, 4-30, 4-40, 4-41, 4-45, Dom::Real . . . . . . . . . . . . . . . . 4-60
4-46, 4-54, 5-1–5-7, 6-7, 9-19, 9-20, Dom::SquareMatrix . . . . 4-65, 4-69
12-4, 13-7, 15-5, 17-11, 17-26, 17-29, DOM_ARRAY . . . . . . . . . . . . . . . . 4-44
17-30, A-11, A-25, A-26, A-45 DOM_BOOL . . . . . . . . . . . . . . . . . 4-47
denom . . . . . . . . . . . . . . . . . . . . . . . . 4-6 DOM_COMPLEX . . . . . . . . . . . . . . . 4-6
denominator (denom) . . . . . . . . . . . . . 4-6 DOM_EXPR . . . . . . . . . . . . . . . . . . 4-12
derivative . . . . . . . . . . see differentiation DOM_FLOAT . . . . . . . . . . . . . . . . . 4-6
determinant (linalg::det) . . . . . . . . 2-19 DOM_FUNC_ENV . . . . . . . . . . . . . 17-32
diagonal matrices . . . . . . . . . . . . . . 4-67 DOM_IDENT . . . . . . . . . . . . . . . . . 4-8
die . . . . . . . . . . . . . . . . . . . . . . . . . . 10-1 DOM_INT . . . . . . . . . . . . . . . . . . . 4-6
diff . . . 2-3, 2-11, 2-13, 4-25, 4-56, 4-59, DOM_INTERVAL . . . . . . . . . . . . . . 4-15
4-71, 4-80, 4-89, 6-7, 7-2, 9-8, 9-17, DOM_NULL . . . . . . . . . . . . . . . . . 4-99
12-3–12-5, 13-3, 13-6, 14-2, 17-31, DOM_POLY . . . . . . . . . . . . . . . . . 4-81
17-35, 17-36, 17-38, 17-40, A-18, DOM_PROC . . . . . . . . . . . . . . . . . . 17-3
A-25, A-26, A-42 DOM_RAT . . . . . . . . . . . . . . . . . . . 4-6
differential equations (ode) . . . . . . . . 8-12 DOM_SET . . . . . . . . . . . . . . . . . . 4-36
initial and boundary conditions . . 8-12 DOM_STRING . . . . . . . . . . . . . . . 4-49
numerical solutions . . . . . . . . . . . DOM_TABLE . . . . . . . . . . . . . . . . 4-40
. . . . . . . . . . . . . . 8-13, 11-43, 11-117 DOM_VAR . . . . . . . . . . . . . . . . . . 17-10
differential operator (' and D) . . . . . . . . piecewise . . . . . . . . . . . . . . . . 8-10
. . . . . . . . . . . . . . . . 2-12, 4-89, 7-2 rectform . . . . . . . . . . . . . . . . . . 9-12
differentiation (diff) . . . . . . . . . . 7-2–7-3 Series::Puiseux . . . . . . . . . . . 4-56
higher derivatives . . . . . . . . . . . . 7-2
Index-3
Index
solvelib::BasicSet . . . . . . . . . 8-7 numeric::solve . . . . . . . . . . . 8-7

Type . . . . . . . . . . . . . . . 14-5, 17-20 search range . . . . . . . . . . . . . 8-10
domain type . . . . . . . . . . . . . . . . . . . 4-1 parametric ∼ . . . . . . . . . . . . . . 8-10
defining your own ∼ . . . . . . . . . . 4-2 polynomial ∼ . . . . . . . . . . . . . . . 8-2
determining the ∼ . . . . . see domtype rational solutions . . . . . . . . . . . . 8-6
domtype . 4-2, 4-6, 4-8, 4-47, 4-56, 4-61, real solutions . . . . . . . . . . . . . . . 8-6
4-63, 4-99, 5-9, 8-7, 8-9–8-11, 9-12, recurrence ∼ (rec) . . . . . . . . . . . 8-15
13-4, 14-1, 14-2, 14-5, 16-4, 16-5, solving (solve) . . . . . . . . . . 8-1–8-15
17-3, 17-7, 17-8, 17-13, 17-32, A-37, survey of all solvers (?solvers) . . .
A-38, A-42 . . . . . . . . . . . . . . . . . . . . . 8-1, 8-7
escape . . . . . . . . . . . . . . . . . 17-6, 17-18
Euclidean Algorithm . . . . . . . . . . . . 17-41
E eval . . . . . . . . . . 5-7, 5-7, 6-3, 8-11, 13-7
E . . . . . . . . . . . . . . . . . . . . . . . . . 2-7, 2-9 evalAt . . . . . . . . . . . . . . 2-23, 5-13, 6-2
e . . . . . . . . . . . . . . . . . . . . . . . . . . . see E evalp . . . . . . . . . . . . . . . . . . . . . . . 4-88
eigenvalues evaluation . . . . . . . . . . . . . . . . . . 5-1–5-9
numerical . . . . . . . . . . . . . . . . . . complete ∼ . . . . . . . . . . . . . 5-4–5-9
. . . . . . . see numeric::eigenvalues delayed ∼ (hold) . . . . . . . . . . . . 5-8
symbolic . . see linalg::eigenvalues enforcing ∼ (eval) . . . . . . . . 5-7, 6-3
eigenvectors ∼ tree . . . . . . . . . . . . . . . . . . . . 5-4
numerical . . . . . . . . . . . . . . . . . . incomplete . . . . . . . . . . . . . . . . . 5-7
. . . . . . see numeric::eigenvectors invoke . . . . . . . . . . . . . . . . . . . . 2-2
symbolic . see linalg::eigenvectors level (LEVEL) . . . . . . . . . . . . . . . 5-6
elliptic integrals . . . . . . . . . . . 17-32–17-37 maximal depth (MAXLEVEL) . . . . . 5-6
environment variables . . . . . . . . . . . . 2-8 of arrays . . . . . . . . . . . . . . . . . . 5-7
DIGITS . . . . . . . . . . . . . . . . . . . . 2-7 of matrices . . . . . . . . . . . . . . . . . 5-8
HISTORY . . . . . . . . . . . . . . . . . . . 13-8 of polynomials . . . . . . . . . . . . . . 5-8
LEVEL . . . . . . . . . . . . . . . . . . . . 5-6 of tables . . . . . . . . . . . . . . . . . . . 5-8
MAXDEPTH . . . . . . . . . . . . . . . . . . 17-4 up to a particular level (level) . . 5-5
MAXLEVEL . . . . . . . . . . . . . . . . . . 5-6 within procedures . . . . . . . . . . . 5-8
ORDER . . . . . . . . . . . . . . . . . . . 4-56 evaluator . . . . . . . . . . . . . . . . . . . . . . 1-6
PRETTYPRINT . . . . . . . . . . . . . . . 12-3 exact calculations . . . . . . . . . . . . . . . . 2-5
reinitialization (reset()) . 2-8, 13-11 examples
TEXTWIDTH . . . . . . . . . . . . . . . . . 12-4 transfer ∼ to notebook . . . . . . . . 2-4
eps . . . . . . . . . . . . . . . . . . . . . . . . 11-107 exp . . . . . . . . . . . . . . 2-7, 4-71, 4-79, 8-9
equations . . . . . . . . . . . . . . . . . . . . . 4-13 expand . . 2-14, 4-71, 4-80, 5-10, 8-4, 9-5,
assigning solutions (assign) . . . . 8-3 A-17
differential ∼ (ode) . . . . . . . . . . . 8-12 exponential function (exp) . . . . . . . . . 2-7
general ∼ . . . . . . . . . . . . . . . . . . 8-9 for matrices . . . . . . . 4-71, 4-76, 4-79
integer solutions . . . . . . . . . . . . 8-6 exponentiation (^) . . . . . . . . . . see _power
linear ∼ . . . . . . . . . . . . . . . . . . . 8-3 exporting graphics . . . . . . . 11-107–11-109
numerical solutions . . . . . . . . . . 8-7 batch mode . . . . . . . . 11-108–11-109
numeric::realroots . . . . . . . 8-7 interactive . . . . . . . . . . . . . . . 11-107
numeric::fsolve . . . . . . . . . . 8-7
Index-4
Index
expose . . . . .......... 3-3, 3-6, 17-32 fields . . . . . . . . . . . . . . . . . . . . 4-60–4-63

Expr . . . . . . .......... . . . . . . . . 4-84 files
expr . . . . . . . . . . . 4-57,
4-71, 4-84, 9-12 reading ∼ (read) . . . . . . . . . . . . 12-5
expr2text . . . 4-50, 12-2,
13-4, 15-2, 16-1, reading data (import::readdata) .
A-15, A-42 . . . . . . . . . . . . . . . . . . . . . . . . 12-6
expressions . . . . . . . . . . . . . . . 4-12–4-23 writing ∼ (write) . . . . . . . . . . . . 12-5
0-th operand . . . . . . . . . . . . . . . 4-21 float 1-2, 2-7, 2-9, 2-13, 4-7, 4-17, 4-42,
atoms . . . . . . . . . . . . . . . . . . . 4-20 4-46, 4-71, 7-5, 8-2, 8-7, 8-10, 10-2,
Boolean ∼ . . . . . . . . . . . . 4-47–4-48 13-3, 17-25, 17-31, 17-35, A-6, A-19,
evaluation (bool) . . . . . . . . . 4-47 A-28, A-30, A-35–A-37
comparisons . . . . . . . . . . . . . . . 4-14 floating point . see numerical computations
equations . . . . . . . . . . . . . . . . . . 4-13 floating-point arrays . . . . . . . . 4-92–4-93
expression trees . . . . . . . . 4-19–4-20 floating-point intervals . . . . . . . 4-94–4-98
factorial (fact) . . . . . . . . . . . . . . 4-13 floor . . . . . . . . . . . . . . . . . . . . 4-7, A-6
generation via operators . . 4-12–4-19 fonts . . . . . . . . . . . . . . . . . 11-104–11-106
indeterminates (indets) . . . . . . 4-82 for . . . . . . . . . . . . . . . . . 4-25, 15-1, A-9
inequalities . . . . . . . . . . . . . . . . 4-13 formula manipulation . . . . . . . . . . . . . 1-3
manipulation . . . . . . . . . . . 9-1–9-23 Fourier expansion . . . . . . . . . . . . . . . 9-16
operands (op) . . . . . . . . . . 4-21–4-23 frac . . . . . . . . . . . . . . . . . . . . . . . . . 4-7
quotient modulo (div) . . . . . . . . 4-13 frandom . . . . . . . . . . . . . . . . . . . . . 10-2
range (..) . . . . . . . . . . . . . . . . . 4-15 frequencies (Dom::Multiset) . 10-3, A-34
remainder modulo (mod) . . . . . . . 4-13 funcenv . . . . . . . . . . . . . . . . 17-34, A-42
redefinition . . . . . . . . . . . . . . 4-13 function environments . . . . . . 17-31–17-37
sequence generator ($) . . . . . . . 4-24 function attributes . . . . . . . . . . 17-35
simplification . . . . . . . . . . . . . . . . generation . . . . . . . . . . . see funcenv
. see also combine, normal, radsimp, operands . . . . . . . . . . . . . . . . . 17-32
simplify, and Simplify, 9-13–9-17 source code (expose) . . . . . . . . . 3-6
transformation . . . . see also collect, functions . . . . . . . . . . . . . 4-14, 4-52–4-55
combine, factor, normal, partfrac, as procedures . . . . . . . . . . 17-1–17-42
rectform, rewrite, 9-3–9-12 composition . . . . . . . . . . . . . . . see @
constant ∼ . . . . . . . . . . . . . . . . 4-54
converting expressions to ∼ (-->) .
F . . . . . . . . . . . . . . . . . . . . . . . . 4-53
fact . . . . . . . . . . . . 2-18, 4-7, 4-13, 4-16 extrema . . . . . . . . . . . . . . . . . . 2-22
factor . . . 2-15, 4-7, 4-88, 5-11, 9-6, 9-6, functional expressions . . . . . . . 4-54
A-20 generation (-->) . . . . . . . . . . . . 4-52
factorial . . . . . . . . . . . . . . . . . . . see fact generation (->) . . . . . . . . . . . . 4-52
FAIL . . . . . . . . . . . . . . . . 4-71, 4-99, 5-11 identity function (id) . . . . . . . . 4-62
FALSE . . . . . . . . . . . . . . . . . . . . . . . 4-47 iterated composition . . . . . . . . see @@
Fermat numbers . . . . . . . . . . . 2-30, A-4 iterated composition (@@) . . . . . 4-52
Fibonacci numbers . . . . . . . . . . . . . . . kernel ∼ . . . . . . . . . . . . . . . . . . 1-6
. . . . . 3-3, 8-15, 17-23–17-25, A-32 numbers as ∼ . . . . . . . . . . . . . . 4-54
field extension roots . . . . . . . . . . . . . . . . . . . . 2-22
(Dom::AlgebraicExtension) . . 4-62
Index-5
Index
G Layout . . . . . . . . . . . . . . . . 11-110
Legend . . . . . . . . . . 11-102, 11-103
gcd . . . . . . . . . . . . . .
. . . . . . 4-89, A-44
LegendAlignment . . . . . . . . 11-103
general plot principles . . . . . . 11-33–11-38
LegendEntry . . . . . 11-102, 11-103
generate . . . . . . . . . .
. . . . . . . . . . . . 13-3
LegendFont . . . . . . 11-103, 11-104
genident . . . . . . . . . .
. . . . . . 4-11, 17-30
LegendPlacement . . . . . . . . 11-103
geometric series . . . . .
. . . . . . . . . . . 4-56
LegendText . . . . . . 11-102, 11-103
getprop . . . . . . . . . .
. . 9-20, 9-21, 9-23
LegendVisible . . ...........
global variables . . . . .
. . . . . . . . . . . . 17-9
. . . . . . . 11-11, 11-26, 11-102, 11-103
Goldbach conjecture . . . . . . . . . . . . 2-26
LineColor . . . . . . . . . . . . . . 11-67
graphical trees . . . . . .
. . . . . . 11-46–11-49
LineColorFunction . . . . . . . 11-79
graphics . . . . . . . . . .
. . . . . . 11-1–11-120
LineColorType . . . . . . . . . . . 11-11
animations . . . . .. . . . see animations
LinesVisible . . . . . . . 11-57, 11-61
attributes . . . . . .
. . . . . . 11-57–11-66
Mesh . . . . . . . . . 11-11, 11-13, 11-26
AdaptiveMesh . . . 11-11, 11-13, 11-26
Name . . . . . . . . . . . . . . . . . 11-103
Axes . . . . . . .
. 11-11, 11-26, 11-62
PointColor . . . . . . . . . . . . . 11-67
AxesTitleFont . . . . . . . . . . 11-104
Scaling . . . . . . 11-11, 11-26, 11-110
AxesTitles . . . . . . . . 11-11, 11-26
spelling . . . . . . . . . . . . . . . . 11-73
AxesVisible . . . . . . . 11-11, 11-26
SubgridVisible . . . . . . . . . . . .
BorderWidth . . . . . . . . . . . . 11-46
. . . . . . . . . 11-11, 11-14, 11-26, 11-29
CameraDirection . . . . . . . . 11-112
Submesh . . . . . . . . . . . 11-26, 11-28
change ∼ in existing objects . 11-35
TextFont . . . . . . . . . . . . . . 11-104
Color . . . . . . . . . . . . . 11-35, 11-67
TicksLabelFont . . . . . . . . . 11-104
Colors . . . 11-7, 11-11, 11-23, 11-26
TicksNumber . . . . . . . 11-11, 11-26
CoordinateType . . . . . . . . . . 11-11
TimeBegin . . . . . . . . . 11-77, 11-79
default values . . . . . . . 11-57–11-58
TimeEnd . . . . . . . . . . . 11-77, 11-79
FillColor . . . . . . . . . . . . . . 11-67
TimeRange . . . . . . . . . 11-77, 11-79
FillColorFunction . . . . . . . 11-79
Title . . . . . . . . 11-10, 11-25, 11-79
FillColorType . . . . . . . . . . . 11-26
TitleFont . . . . . . . . . . . . . 11-104
Filled . . . . . . . . . . . . . . . . . 11-61
TitlePosition . . . . . . 11-10, 11-25
Footer . 11-10, 11-25, 11-79, 11-105
type specific ∼ . . . . . . . . . . . 11-60
FooterFont . . . . . . 11-104, 11-105
ViewingBoxYRange . . . . 11-11, 11-16
Frames . . . . . . . . . . . . . . . . . . .
ViewingBoxZRange . . . 11-26, 11-32
. . . . 11-10, 11-11, 11-25, 11-26, 11-76
VisibleAfter . . . . . . . . . . . . 11-83
“fully qualified” . . . . . . . . . . 11-60
VisibleAfterEnd . . . . . . . . . 11-81
GridVisible . . . . . . . . . . . . . .
VisibleBefore . . . . . . . . . . . 11-83
. . . . . . . . . 11-11, 11-14, 11-25, 11-29
VisibleBeforeBegin . . . . . . 11-81
Header . . 11-10, 11-14, 11-25, 11-29,
VisibleFromTo . . . . . . . . . . . 11-83
11-79, 11-105
Width . . . . . . . . 11-10, 11-25, 11-46
HeaderFont . . . . . . 11-104, 11-105
XTicksBetween . . . . . . . . . . . 11-14
Height . . . . . . . 11-10, 11-25, 11-46
XTicksDistance . . . . . . . . . . 11-14
help pages for ∼ . . . . . 11-65–11-66
YTicksBetween . . . . . . . . . . . 11-14
hints . . . . . . . . . . . . . 11-62–11-64
YTicksDistance . . . . . . . . . . 11-14
inheritance of ∼ . . . . . 11-58–11-62
Index-6
Index
batch mode . . . . . . . . 11-108–11-109 property inspector . . . . . 11-50–11-53

cameras in 3D . . . . . . . 11-112–11-119 RGB colors . . . . . . . . . . 11-67–11-69
animated . . . . . . . . . . . . . . 11-117 saving and exporting . 11-107–11-109
canvas . . . . . . . . . . . . . . . . . . . 11-46 batch mode . . . . . . 11-108–11-109
caption . . . . . . . . . . . . . . . . . . . . interactive . . . . . . . . . . . . . 11-107
. . . . see graphics, attributes, Footer Sierpinski triangle . . . . . 17-42, A-48
colors . . . . . . . . . . . . . . . . see colors size of image see graphics, attributes,
evaluation mesh . . . . . . see graphics, Height and Width
attributes, Mesh und Submesh title (per object) . . . . . . . . . . . . . .
evaluation mesh, adaptive . . . . . . . . . . . . see graphics, attributes, Title
. . . . . . . . . . see graphics, attributes, title position see graphics, attributes,
AdaptiveMesh TitlePosition
fonts . . . . . . . . . . . . . 11-104–11-106 transformation . . . . . . . . 11-97–11-99
footer . . . . . . . . . . . . . . . . . . . . . transformations . . . . . . . . . . . . 11-56
. . . . see graphics, attributes, Footer graphs of functions (plot) . . . . . . . . . 11-2
general plot principles . . 11-33–11-38 greatest common divisor see gcd and igcd
graphical trees . . . . . . . . 11-46–11-49 Gröbner bases . . . . . . . . . . . . . see library
implicit ∼ . . . . . . . . . . . . . . . 11-49 groups of primitives . . . . . . . . 11-95–11-96
graphs of functions (plot) . 2-16, 11-2
gaps in definition . . . . . 11-5, 11-21
piecewise defined functions . . . .
H
. . . . . . . . . . . . . . . . . . . 11-5, 11-21 hardware float arrays . . . . . . . . 4-92–4-93
singularities . . . . . . . . 11-15, 11-30 has . . . . . . . . . . . 4-32, 9-17, 17-39, A-34
grid lines . . . see graphics, attributes, help . . . . . . . . . . . . . . . . . . . . . . 2-4, B-1
GridVisible and SubgridVisible help . . . . . . . . . . . . . . . . . . . . . 2-4, 3-2
groups of primitives . . . . . . . . . . . Hexahedron . . . . . . . . . . . . . . . . . . 11-54
. . . . . . . . . . . . . 11-56, 11-95–11-96 Hilbert matrix (linalg::hilbert) . . . .
header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-46, 4-46, 4-72, 4-97
. . . . see graphics, attributes, Header inverse ∼ (linalg::invhilbert) .
HSV colors . . . . . . . . . . . 11-69–11-70 . . . . . . . . . . . . . . . . . . . . . . . . 4-98
image size . . see graphics, attributes, hint . . . . . . see graphics, attributes, hints
Height and Width HISTORY . . . . . . . . . . . . . . . . . . . . . . 13-8
importing pictures . . . . 11-110–11-111 history (% and last) . . . . . . . . . 13-6–13-8
legends . . . . . . . . . . . 11-100–11-103 evaluation of last . . . . . . . . . . . 13-7
light sources . . . . . . . . . . . . . . 11-56 hold . . . 5-8, 5-8, 5-9, 6-3, 7-5, 8-7, 8-10,
logarithmic plots . . . . . . . . . . . 11-11 9-17, 12-6, 17-7, 17-28, 17-39, A-26,
object browser . . . . . . . . 11-50–11-53 A-34
OpenGL de l’Hospital . . . . . . . . . . . . . . . . . . . 7-3
drivers . . . . . . . . . . . . . . . . 11-120 hull . . . . . . . . . . . . . . . 4-15, 4-94, 4-96
Plato’s polyhedra . . . . . . . . . . . 11-54 hypertext . . . . . . . . . . . . . . . . . . . . . 2-4
playing animations . . . . . . . . . . 11-75
primitives 11-54–11-56, see also plot
(graphics library)
Index-7
Index
I rounded ∼ (RD_INF, RD_NINF) . . 4-95

info . . . . . . . . . . . . 3-2, 4-74, 11-67, 14-4
I . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9
input and output . . . . . . . . . . . . 12-1–12-7
Icosahedron . . . . . . . . . . . . . . . . . . 11-54
int 2-3, 2-12, 2-13, 4-15, 4-21, 4-53, 4-71,
id . . . . . . . . . . . . . . . . . . . . . . . . . . 4-62
4-89, 7-4, 7-5, 9-16, 13-2, 13-6, 13-7,
identifiers . . . . . . . . . . . . . 2-11, 4-8–4-11
17-7, 17-30, 17-37, A-28, A-33, A-37
assignment . . . . . . . . . . . . 4-8–4-10
integration . . . . . . . . . . . . . . . . . see int
assumptions . . . . see assume and is
change of variable . . . . . . . . . . . .
concatenation . . . . . . . . . . . . . 4-10
. . . . . . . . . . see intlib::changevar
deleting the value . . . . . . . . . . . . 4-9
numerical ∼ . . . . . . . . . . . . . . . . .
dynamical generation . . . . . . . . 4-10
. . . . . . . . see numerical integration
evaluation . . . . . . . . . . . . . . . . . . 5-1
intermediate result . . . . . . . . . . . . . . 2-3
generation via strings . . . . . . . . . 4-11
interpolation . . . . . . . . . . . . . . . . . . 11-39
greek letters . . . . . . . . . . . . . . . . 4-8
intersect . . . . . . . . . . . . . . . . 4-16, A-13
list (anames) . . . . . . . . . . . . . . . 4-10
intersect . . . . . . . . . . . 4-37, 4-39, 4-96
special characters . . . . . . . . . . . . 4-8
interval arithmetic . . . . . . . . . . 4-94–4-98
sub- and superscripted ∼ . . . . . . 4-8
union, intersect . . . . . . . . . . . 4-96
values . . . . . . . . . . . . . . . . . . . . . 5-1
convert to intervals (interval) . 4-96
with arbitrary characters . . . . . . . 4-8
façade domain (Dom::FloatIV) . 4-96
write protection
generate intervals (..., hull) . . . .
removing ∼ (unprotect) . . . . 4-10
. . . . . . . . . . . . . . . . . . . 4-15, 4-94
setting ∼ (protect) . . . . . . . 4-10
intlib::changevar . . . . . . . . . 7-6, A-28
if . 4-48, 4-52, 5-8, 15-4, 16-1, 16-3, 16-6,
IntMod . . . . . . . . . . . . . . . . . . . . . . 4-83
17-3–17-5, 17-7, 17-8, 17-12,
irreducible . . . . . . . . . . . . . 4-90, A-24
17-20–17-24, 17-32, 17-33, 17-39,
is . . . . . . . . . . . . . . . . . . . . . . . 8-9, 9-19
A-16, A-40, A-42, A-44, A-46, A-50
isprime 2-6, 2-24, 2-26, 2-27, 4-7, 4-48,
ifactor . . . . . . . . . 2-6, 2-24, 2-28, 4-7
16-1, 16-2, A-4, A-11
igcd . . . . . . . . . . . . . . 10-4, 17-41, A-44
iszero . . . . 4-62, 4-62, 4-68, 4-69, 4-71
IgnoreSpecialCases . . . . . . . . . . . . . 2-17
iteration operator . . . . . . . . . . . . . see @@
Im . . . . . . . . . . . . . . . . . . . . . . . 2-10, 4-6
iteration operator (@@) . . . . . . . 4-52, 4-58
imaginary part . . . . . . . . . . . . . . . . see Im
ithprime . . . . . . . . . . . . . 2-24, 12-1, 12-2
imaginary unit . . . . . . . . . . . . . . . . . . 2-9
import::readbitmap . . . . . . . . . . . 11-110
import::readdata . . . . . . . . . 12-7, 13-12 J
importing pictures . . . . . . . . 11-110–11-111
JavaView . . . . . . . . . . . . . . . . . . . 11-107
in . . . . . . . . . . . . . . . . . . . . . . . 4-98, 8-9
jpg . . . . . . . . . . . . . . . . . . . . . . . . 11-107
indeterminates . . . . . . . . . . see identifiers
indeterminates (indets) . . . . . . . . . 4-82
indets . . . . . . . . . 4-82, 8-6, A-28, A-46 K
indexed access . . . . . . . . . . . . . . . . . 4-29
inequalities . . . . . . . . . . . . . . . . . . . . 4-13 kernel . . . . . . . . . . . . . . . . . . . . . . . . 1-6
solving ∼ . . . . . . . . . . . . . . . . . . 8-11 extending the ∼ . . . . . . . . . . . . . 1-6
infinity . . . . 2-7, 2-22, 2-23, 4-58, 5-10,
kernel function . . . . . . . . . . . . . . . . . 1-6
5-11, A-18
Index-8
Index
L lists . . . . . . . . . . . . . . . . . . . . . 4-28–4-35
applying a function (map) . . . . . . 4-31
Landau symbol (O) . . . . . . . . . 4-56, A-18
combining ∼ (zip) . . . . . . . . . . 4-33
last . . . . . . . . . . . . . . . . . . . . . . . . see %
empty list . . . . . . . . . . . . . . . . . 4-28
last
selecting according to properties
evaluation of ∼ . . . . . . . . . . . . . . 13-7
(select) . . . . . . . . . . . . . . . . . 4-32
last . . . . . . . . . . . . . . . . 5-7, 13-6, A-16
splitting according to properties
Laurent series . . . . . . . . . . . . . . . . . 4-58
(split) . . . . . . . . . . . . . . . . . . 4-32
legends . . . . . . . . . . . . . . . 11-100–11-103
ln . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-7
length . . . . . . . . . . . . . 4-51, A-15, A-34
local . . . . . . . . . . . . . . . . . . . . . . . . 17-9
LEVEL . . . . . . . . . . . . . . . . . . . . . . . . 5-6
local variables (local) . . . . . . . 17-9–17-13
level . . . . . . . . . . . . . . 5-5, 17-30, A-26
formal parameters . . . . . . . . . . 17-27
library . . . . . . . . . . . . . . . . . . . . . 3-1–3-6
uninitialized ∼ . . . . . . . . . . . . . 17-11
exporting a ∼ (use) . . . . . . . . . . 3-4
log . . . . . . . . . . . . . . . . . . . . . . . . . 4-97
for color names (RGB) . . . . . . . . 11-67
logarithm (ln, log) . . . . . . . . . . 2-7, 4-97
for data structures (Dom) . . . . . . 4-60
logical formula . . . . . . . . . . . . . . . . 17-42
for external formats (generate) . . 13-3
long arrow operator (-->) . . . . . . . . . 4-52
for Gröbner bases (groebner) . . 4-90
loops . . . . . . . . . . . . . . . . . . . . . 15-1–15-5
for input (import) . . . . . . . . . . . 12-6
aborting ∼ (break) . . . . . . . . . . . 15-4
for linear algebra (linalg) . . . . 4-74
for . . . . . . . . . . . . . . . . . . . . . . 15-1
for number theory (numlib) . . . . .
repeat . . . . . . . . . . . . . . . . . . . . 15-3
. . . . . . . . . . . . . . . . . . . . 2-29, 3-2
return value . . . . . . . . . . . . . . . . 15-5
for numerical algorithms (numeric)
skipping commands (next) . . . . . 15-4
. . . . . . . . . . . . . . . . . . . . 3-4, 4-74
while . . . . . . . . . . . . . . . . . . . . 15-3
for orthogonal polynomials
Lorenz attractor . . . . . . . . . . . . . . . 11-116
(orthpoly) . . . . . . . . . . . . . . . A-17
for statistics (stats) . . . . . . . . . 10-2
for strings (stringlib) . . . . . . . 4-50 M
for type specifiers (Type) . . . . . . . .
manipulating expressions . . . . . . 9-1–9-23
. . . . . . . . . . . . . . 14-4, 17-20, A-40
map . . . 2-20, 4-17, 4-31, 4-34, 4-38, 4-42,
information on a ∼ (? and info) . 3-2
4-46, 4-71, 5-7, 8-4, 8-9, 8-11,
standard ∼ . . . . . . . . . . . . . . . . . 3-6
17-40, A-4, A-10, A-13, A-15, A-28,
limit . 2-7, 2-16, 2-22, 2-23, 4-100, A-34
A-34, A-37, A-38, A-45
one-sided . . . . . . . . . . . . . . . . . 2-22
mapcoeffs . . . . . . . . . . . . . . . . . . . . 4-87
limit computation (limit) . . . . . . . . 2-16
maps . . . . . . . . . . . . . . . . . . see functions
linalg (library for linear algebra)
mathematical objects . . . . . . . . . . . . . . 1-3
∼::charpoly . . . . . . . . . 4-75, A-22
matrices . . . . . . . . . . . . . . . . . 4-64–4-80
∼::det . . . . . . . . . . . . . . 2-19, A-20
characteristic polynomial
∼::eigenvalues . . 4-75, 4-77, A-22
(linalg::charpoly) . . . 4-75, A-22
∼::eigenvectors . . . . . . . . . . A-23
computing with ∼ . . . . . . 4-70–4-72
∼::invhilbert . . . . . . . . . . . . 4-98
default coefficient ring
∼::isPosDef . . . . . . . . . . . . . . 9-22
(Dom::ExpressionField) . . . . . 4-68
linear algebra (linalg) . . . . . . . . . . . 4-74
determinant (linalg::det) . . . . 2-19
linefeed . . . . . . . . . . . . . . . . . . . . . . . 2-2
diagonal ∼ . . . . . . . . . . . . . . . . 4-67
Index-9
Index
eigenvalues mod . . . . 4-6, 4-13, 4-18, 4-60, 4-61, 4-83,

numerical . . . . . . . . . . . . . . . . 17-41, A-11, A-44
. . . . . . . see numeric::eigenvalues redefine ∼ . . . . . . . . . . . . . . . . . 4-13
symbolic . . . . . . . . . . . . . . . . . modp . . . . . . . . . . . . . . . . . . . . . . . . . 4-13
. . . . . . . . see linalg::eigenvalues mods . . . . . . . . . . . . . . . . . . . . . . . . . 4-13
eigenvectors modular exponentiation (powermod) . . 4-61
numerical . . . . . . . . . . . . . . . . module . . . . . . . . . . . . . . . . . . . . . . . 1-6
. . . . . . see numeric::eigenvectors Moebius strip . . . . . . . . . . . . . . . . . 11-92
symbolic . . . . . . . . . . . . . . . . . Monte-Carlo simulation . . . . . . . . . . 10-6
. . . . . . . see linalg::eigenvectors multcoeffs . . . . . . . . . . . . . . . . . . . 4-87
exponential function (exp) 4-71, 4-79 multiset . . . . . . . . . . . . . . . . . . . . . 10-3
exponential function
(numeric::expMatrix) . . . . . . . 4-76
functional calculus
N
(numeric::fMatrix) . . . . . . . . 4-76 Newton iteration . . . . . . . . . . 17-42, A-46
Hilbert matrix (linalg::hilbert) numeric::fsolve . . . . . . . . . . . . 3-4
. . . . . . . . . . . . . . . 4-46, 4-72, 4-97 nextprime . . . . . . . . . . . . . . . . 2-24–2-26
identity ∼ . . . . . . . . . . . . . . . . 4-68 NIL . . . . . . . . 4-99, 13-2, 13-4, 17-5, A-42
indexed access . . . . . . . . . . . . . 4-67 nops . . 2-25–2-27, 2-29, 4-3, 4-21, 4-22,
initialization . . . . . . . . . . 4-64–4-69 4-36, A-11, A-12, A-35, A-36, A-46
inverse . . . . . . . . . . . . . . 2-19, 4-70 norm . . . . . . . . . . . . . . . . . . . . . . . . 4-72
inverse Hilbert matrix normal . 2-14, 2-20, 4-63, 4-69, 9-7, 9-13,
(linalg::invhilbert) . . . . . . . 4-98 13-3, A-33, A-37, A-38
library for linear algebra (linalg) . normal distribution (stats::normalCDF)
. . . . . . . . . . . . . . . . . . . . . . . . 4-74 . . . . . . . . . . . . . . . . . . . . . . . . 10-5
library for numerical algorithms not . . 2-26, 4-14, 4-23, 4-47, 16-2, 17-42,
(numeric) . . . . . . . . . . . . . . . . 4-74 A-9, A-50
methods . . . . . . . . . . . . . 4-72–4-73 notebook . . . . . . . . . . . . . . . . . . 1-5, 12-3
ring of square ∼ . . . . . . . . . . . . 4-69 nterms . . . . . . . . . . . . . . . . . . . . . . 4-89
sparse ∼ . . . . . . . . . . . . . 4-77–4-78 nthcoeff . . . . . . . . . . . . . . . . . . . . . 4-89
submatrices . . . . . . . . . . . . . . . 4-67 nthterm . . . . . . . . . . . . . . . . . . . . . 4-89
Toeplitz ∼ . . . . . . . . . . . . . . . . 4-78 null . . . . . . . . . . . . . . . . . . . . . . . . . 16-3
matrix . . . . 2-19, 4-64, 4-69, 4-77, 4-78, null objects . . . . . . . . . . . . . . 4-99–4-100
9-22, A-19, A-20 null() . . . . . . . . . . . . . . . . . 4-26, 4-99
max . . . . . . . . . . . . . . . . 4-27, 17-7, 17-21 number theory (numlib) . . . . . . . 2-29, 3-2
MaxDegree . . . . . . . . . . . . . . . . . . . . . 8-5 numbers . . . . . . . . . . . . . . . . . . . 4-6–4-7
MAXDEPTH . . . . . . . . . . . . . . . . . 17-4, A-44 absolute value . . . . . . . . . . . see abs
MAXLEVEL . . . . . . . . . . . . . . . . . . . . . . 5-6 basic arithmetic . . . . . . . . . . . . . 4-7
mean value (stats::mean) . . . . . . . . 10-2 complex ∼ . . . 2-9, see also domains,
memory management . . . . . . . . . . . . 1-6 DOM_COMPLEX
Mersenne primes . . . . . . . . . . . 2-30, A-4 complex conjugation . see conjugate
min . . . . . . . . . . . . . . . . . . . . . . . . . 4-27 computing with ∼ . . . . . . . . 2-5–2-6
minus . . . . . . . . . . . . . . . . . . . . . . . 4-37 decimal expansion
(numlib::decimal) . . . . . . . . . . 3-2
Index-10
Index
denominator . . . . . . . . . . . see denom ∼::expMatrix . . . . . . . . . . . . . 4-76

domain types . . . . . . . . . . . . . . . 4-6 ∼::fMatrix . . . . . . . . . . . . . . . 4-76
even integers (Type::Even) . . . . . 14-5 ∼::fsolve . . . . . . . . . . . . . . 3-4, 8-7
factorial . . . . . . . . . . . . . . . . see fact ∼::int . . . . . . . . . . . 5-8, 7-5, A-28
floating point approximation . . . . . ∼::inverse . . . . . . . . . . . . . . . 4-76
. . . . . . . . . . . . . . . . . . . . see float ∼::odesolve . . . . . . . . . . . . . . . 8-13
fractional part . . . . . . . . . . . see frac ∼::quadrature . . . . . . . . . . . . . 3-4
greatest common divisor . . . . see igcd ∼::realroots . . . . . . 3-4, 8-7, 8-10
i-th prime (ithprime) . . . . . . . . 2-24 ∼::singularvalues . . . . . . . . . 4-76
imaginary part . . . . . . . . . . . . see Im ∼::singularvectors . . . . . . . . 4-76
integers . . . . . . see domains, DOM_INT ∼::solve . . . . . . . . . . . . . . . . . 8-7
integral part . . . . . . . . . . . . see trunc numerical computations . . . . . . . . . . . .
i-th prime . . . . . . . . . . see ithprime . . . . . . . . . 1-2, 2-7, 2-8, 3-4, 4-74
modular exponentiation (powermod) precision . . . . . . . . . . . . . see DIGITS
. . . . . . . . . . . . . . . . . . . . . . . . 4-61 numerical integration . . . . 3-4, 7-5, A-28
next prime . . . . . . . . . see nextprime numerical integration (numeric::int and
numerator . . . . . . . . . . . . . see numer numeric::quadrature) . . . . . 17-41
odd integers (Type::Odd) . . . . . . 14-5 numlib (library for number theory)
operands . . . . . . . . . . . . . . . . . . 4-6 ∼::decimal . . . . . . . . . . . . . . . . 3-2
output format of floating-point ∼::fibonacci . . . . . . . . . . . . . 17-25
numbers (Pref::floatFormat) . 13-3 ∼::primedivisors . . . . . . . . . 2-29
primality test . . . . . . . . . see isprime ∼::proveprime . . . . . . . . . . . . 2-24
prime factorization . . . . . see ifactor
quotient modulo (div) . . . . . . . . 4-6
random ∼ . . see random and frandom
O
rational ∼ . . . . see domains, DOM_RAT O . . . . . . . . . . . . . . . . . . . . . . 4-56, A-18
real and imaginary part see rectform object browser . . . . . . . . . . . . 11-50–11-53
real part . . . . . . . . . . . . . . . . . see Re object-oriented . . . . . . . . . . . . . . . . . 1-6
remainder modulo . . . . . . . . see mod Octahedron . . . . . . . . . . . . . . . . . . . 11-54
rounding . . . . . . . . . . . . . . . . . . . ode . . . . . . . . . . . . . . . . . . . . 8-12, A-29
. . . . . see ceil, floor, round, trunc op . . 4-3, 4-4–4-6, 4-21–4-23, 4-26, 4-29,
sign . . . . . . . . . . . . . . . . . . . see sign 4-36, 4-41, 4-45, 4-57, 4-84, 4-86,
simplification of radicals (radsimp) 4-87, 4-98, 6-3–6-6, 8-3, 8-9, 10-4,
. . . . . . . . . . . . . . . . . . . 2-15, 9-14 17-12, 17-35, 17-39, A-5, A-8–A-10,
square root . . . . . . . . . . . . . see sqrt A-12–A-15, A-29, A-34, A-42, A-45,
type specifier . . . . . . . . . . . . . . . 14-5 A-46, A-50
numer . . . . . . . . . . . . . . . . . . . . . . . . 4-6 OpenGL . . . . . . . . . . . . . . . . . . . . 11-120
numerator (numer) . . . . . . . . . . . . . . . 4-6 drivers . . . . . . . . . . . . . . . . . . 11-120
numeric (numerics library) operands . . . . . . . . . . . . . . . 4-3–4-5, 6-1
∼::det . . . . . . . . . . . . . . . . . . 4-76 0-th operand . . . . . . . . . . . 4-21, 6-6
∼::eigenvalues . . . . . . . . . . . . . accessing ∼ . . . . . . . . . . . . . . see op
. . . . . . . . . . . 3-5, 4-76, 11-4, 11-20 number of ∼ . . . . . . . . . . . . see nops
∼::eigenvectors . . . . . . . . . . 4-76 of series expansions . . . . . . . . . 4-57
operators . . . . . . . . . . . . . . . . 4-12–4-19
Index-11
Index
priorities . . . . . . . . . . . . . . . . . 4-18 ∼::Conformal . . . . . . . . . . . . . 11-55

option escape . . . . . . . . . . . 17-6, 17-18 ∼::CoordinateSystem2d . . . . . . .
option remember . . . . . 2-8, 17-23–17-26 . . . . . . . . . . . . . . . . . . 11-47, 11-56
or . . . . 4-14, 4-47, 16-2, 17-42, A-9, A-50 ∼::CoordinateSystem3d . . . . . . .
ORDER . . . . . . . . . . . . . . . . . . . . . . . 4-56 . . . . . . . . . . . . . . . . . . 11-47, 11-56
orthpoly::chebyshev1 . . . . . . . . . . A-17 ∼::Curve2d . . . . . . . . . . . . . . . 11-55
OS command (system) . . . . . . . . . . . 13-12 ∼::Curve3d . . . . . . . . . . . . . . . 11-55
output ∼::Cylinder . . . . . . . . . . . . . . 11-54
manipulation (Pref::output) . . . 13-3 ∼::Cylindrical . . . . . . . . . . . 11-55
of floating-point numbers ∼::Density . . . . . . . . . . . . . . . 11-55
(Pref::floatFormat) . . . . . . . 13-3 ∼::DistantLight . . . . . . . . . . 11-56
order of terms . . . . . . . . . . . . . . 2-11 ∼::Dodecahedron . . . . . . . . . . 11-54
suppressing ∼ . . . . . . . . . . . . . . 2-3 ∼::Ellipse2d . . . . . . . . . . . . . 11-54
output and input . . . . . . . . . . . . 12-1–12-7 ∼::Ellipse3d . . . . . . . . . . . . . 11-54
pretty print . . . . . . . . . . . . . . . . 12-3 ∼::Ellipsoid . . . . . . . . . . . . . 11-54
overload . . . . . . . . . . . . . . . . . . . . . . 1-6 ∼::Function2d . . . . . . . . . . . . 11-55
∼::Function3d . . . . . . . . . . . . 11-55
∼::getDefault . . . . . . . . . . . . 11-58
P ∼::Group2d . . . . . . . . . . . . . . . 11-56
parser . . . . . . . . . . . . . . . . . . . . . . . . 1-6 ∼::Group3d . . . . . . . . . . . . . . . 11-56
partfrac . . . . . . . . . . . . . . . . . . 2-15, 9-7 ∼::Hatch . . . . . . . . . . . . . . . . 11-55
partial fraction decomposition ∼::Hexahedron . . . . . . . . . . . . 11-54
(partfrac) . . . . . . . . . . . . . . . . 9-7 ∼::Histogram2d . . . . . . . . . . . 11-55
Pascal . . . . . . . . . . . . . . . . . . . . . . . . . 1-5 ∼::Icosahedron . . . . . . . . . . . 11-54
PI . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9 ∼::Implicit2d . . . . . . . . . . . . 11-55
π . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9 ∼::Implicit3d . . . . . . . . . . . . 11-55
piecewise . . . . . . . 2-17, 8-10, 11-5, 11-21 ∼::Inequality . . . . . . . . . . . . 11-55
Plato’s polyhedra . . . . . . . . . . . . . . . 11-54 ∼::Iteration . . . . . . . . . . . . . 11-55
plot (graphics library) ∼::Line2d . . . . . . . . . . . . . . . . 11-54
∼::AmbientLight . . . . . . . . . . 11-56 ∼::Line3d . . . . . . . . . . . . . . . . 11-54
∼::Arc2d . . . . . . . . . . . . . . . . 11-54 ∼::Listplot . . . . . . . . . . . . . . 11-55
∼::Arc3d . . . . . . . . . . . . . . . . 11-54 ∼::Lsys . . . . . . . . . . . . . . . . . 11-55
∼::Arrow2d . . . . . . . . . . . . . . . 11-54 ∼::Matrixplot . . . . . . . . . . . . 11-55
∼::Arrow3d . . . . . . . . . . . . . . . 11-54 ∼::Octahedron . . . . . . . . . . . . 11-54
∼::Bars2d . . . . . . . . . . . . . . . . 11-55 ∼::Ode2d . . . . . . . . . . . . . . . . 11-55
∼::Bars3d . . . . . . . . . . . . . . . . 11-55 ∼::Ode3d . . . . . . . . . . 11-55, 11-116
∼::Box . . . . . . . . . . . . . . . . . . 11-54 ∼::Parallelogram2d . . . . . . . . 11-54
∼::Boxplot . . . . . . . . . . . . . . . 11-55 ∼::Parallelogram3d . . . . . . . . 11-54
∼::Camera . . . . . . . . . . 11-56, 11-113 ∼::Piechart2d . . . . . . . . . . . . 11-55
∼::Canvas . . . . . . . . . . . 11-46, 11-56 ∼::Piechart3d . . . . . . . 11-55, 11-62
∼::Circle2d . . . . . . . . . . . . . . 11-54 ∼::Plane . . . . . . . . . . . . . . . . 11-54
∼::Circle3d . . . . . . . . . . . . . . 11-54 ∼::Point2d . . . . . . . . . . . . . . . 11-54
∼::ClippingBox . . . . . . . . . . . 11-56 ∼::Point3d . . . . . . . . . . . . . . . 11-54
∼::Cone . . . . . . . . . . . . . . . . . 11-54
Index-12
Index
∼::PointLight . . . . . . . . . . . . 11-56 ∼::VectorField3d . . . . . . . . . 11-55

∼::PointList2d . . . . . . . . . . . 11-54 ∼::Waterman . . . . . . . . . . . . . . 11-54
∼::PointList3d . . . . . . . . . . . 11-54 ∼::XRotate . . . . . . . . . . . . . . . 11-55
∼::Polar . . . . . . . . . . . . . . . . 11-55 ∼::ZRotate . . . . . . . . . . . . . . . 11-55
∼::Polygon2d . . . . . . . . . . . . . 11-54 plot . . . . . . . . . . 2-16, 2-23, 11-2, 11-33
∼::Polygon3d . . . . . . . . . . . . . 11-54 plotfunc2d . . . . . . . . . 2-16, 11-100, A-35
∼::Prism . . . . . . . . . . . . . . . . 11-55 png . . . . . . . . . . . . . . . . . . . . . . . . 11-107
∼::Pyramid . . . . . . . . . . . . . . . 11-55 poly . . . . . . . . . . 4-81, 4-82–4-89, A-24
∼::QQPlot . . . . . . . . . . . . . . . . 11-55 poly2list . . . . . . . . . . . . . . . . . . . . 4-83
∼::Raster . . . . . . . . . . 11-55, 11-110 polynomials . . . . . . . . . . . . . . 4-81–4-90
∼::Rectangle . . . . . . . . . . . . . 11-54 accessing terms (nthterm) . . . . 4-89
∼::Reflect2d . . . . . . . . . . . . . 11-56 applying a function to coefficients
∼::Reflect3d . . . . . . . . . . . . . 11-56 (mapcoeffs) . . . . . . . . . . . . . . 4-87
∼::Rootlocus . . . . . . . . . . . . . 11-55 arithmetic . . . . . . . . . . . . . . . . 4-85
∼::Rotate2d . . . . . . . . . 11-56, 11-97 Chebyshev ∼ . . . . . . . . . . 4-55, A-16
∼::Rotate3d . . . . . . . . . 11-56, 11-97 coefficients
∼::Scale2d . . . . . . . . . . 11-56, 11-97 coeff . . . . . . . . . . . . . . . . . . 4-85
∼::Scale3d . . . . . . . . . . 11-56, 11-97 nthcoeff . . . . . . . . . . . . . . . 4-89
∼::Scatterplot . . . . . . . . . . . 11-55 computing with ∼ . . . . . . 4-85–4-90
∼::Scene2d . . . . . . . . . . 11-46, 11-56 conversion of a polynomial
∼::Scene3d . . . . . . . . . . 11-46, 11-56 to a list (poly2list) . . . . . . . 4-83
∼::Sequence . . . . . . . . . . . . . . 11-55 to an expression (expr) . . . . . 4-84
∼::setDefault . . . . . . . . . . . . 11-58 default ring (Expr) . . . . . . . . . . 4-84
∼::SparseMatrixplot . . . . . . . 11-55 definition (poly) . . . . . . . 4-81–4-84
∼::Sphere . . . . . . . . . . . . . . . . 11-54 degree (degree) . . . . . . . . . . . . 4-85
∼::Spherical . . . . . . . . . . . . . 11-55 division with remainder (divide) .
∼::SpotLight . . . . . . . . . . . . . 11-56 . . . . . . . . . . . . . . . . . . . . . . . . 4-86
∼::Streamlines2d . . . . . . . . . 11-55 evaluation (evalp) . . . . . . . . . . 4-88
∼::Sum . . . . . . . . . . . . . . . . . . 11-55 factorization (factor) . . . . . . . . 4-88
∼::Surface . . . . . . . . . . . . . . . 11-55 Gröbner bases (groebner) . . . . . 4-90
∼::SurfaceSet . . . . . . . . . . . . 11-54 greatest common divisor (gcd) . 4-89
∼::SurfaceSTL . . . . . . 11-54, 11-110 irreducibility test (irreducible) . .
∼::Sweep . . . . . . . . . . . . . . . . 11-55 . . . . . . . . . . . . . . . . . . . . . . . . 4-90
∼::Tetrahedron . . . . . . . . . . . 11-54 library for orthogonal ∼ (orthpoly)
∼::Text2d . . . . . . . . . . . 11-54, 11-79 . . . . . . . . . . . . . . . . . . . . . . . . A-17
∼::Text3d . . . . . . . . . . . 11-54, 11-79 multiplication by a scalar factor
∼::Transform2d . . . . . . 11-56, 11-97 (multcoeffs) . . . . . . . . . . . . . . 4-87
∼::Transform3d . . . . . . 11-56, 11-97 number of terms (nterms) . . . . . 4-89
∼::Translate2d . . . . . . 11-56, 11-97 operands . . . . . . . . . . . . . . . . . 4-84
∼::Translate3d . . . . . . 11-56, 11-97 Postscript . . . . . . . . . . . . . . . . . . . 11-107
∼::Tube . . . . . . . . . . . . . . . . . 11-55 powermod . . . . . . . . . . . . . . . . . . . . . . 4-61
∼::Turtle . . . . . . . . . . . . . . . . 11-55 Pref (library for user preferences) . . . .
∼::VectorField2d . . . . . . . . . 11-55 . . . . . . . . . . . . . . . . . . . . 13-2–13-5
Index-13
Index
∼::floatFormat . . . . . . . . . . . . 13-3 property inspector . . . . . . . . . 11-50–11-53

∼::output . . . . . . . . . . . . . . . . . 13-3 protect . . . . . . . . . . . . . . . . . . . . . 4-10
∼::postInput . . . . . . . . . . . . . . 13-4 Puiseux series . . . . . . . . . . . . . . . . . 4-58
∼::postOutput . . . . . . . . . . . . . 13-4
∼::report . . . . . . . . . . . . . . . . . 13-2
resetting preferences . . . . . . . . . 13-4
Q
PRETTYPRINT . . . . . . . . . . . . . . . . . . . 12-3 Q . . . see Q_ and domain, Dom::Rational
primitives . . . . . . . . . . . . . . . 11-54–11-56 Q_ . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-7
print 2-26, 2-29, 4-26, 4-48–4-50, 4-99, quadrature . . . . see numerical integration
12-1, 15-1–15-4, 16-1, 17-27, A-12 quantile function . . . . . . . . . . . . . . . 10-4
probability . . . . . . . . . . . . . . . 10-1–10-7 quotient modulo (div) . . . . . . . . 4-6, 4-13
probability density function . . . . . . . 10-4
procedures . . . . . . . . . . . . . . . 17-1–17-42
call . . . . . . . . . . . . . . . . . . . . . . 17-3
R
by name . . . . . . . . . . . . . . . . 17-28 R . . . . . . . see R_ and domain, Dom::Real
by value . . . . . . . . . . . . . . . . 17-28 R_ . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-7
comments (/* */) . . . . . . . . . . . 17-3 R_ . . . . . . . . . . . . . . . . . . . . . . 9-18, 9-19
definition . . . . . . . . . . . . . 17-3–17-4 radical simplification (radsimp) . . . . 9-14
evaluation level . . . . . . . 17-29–17-30 radsimp . . . . . . . . . . . . . . . . . 2-15, 9-14
global variables . . . . . . . . . . . . . 17-9 random . . . . . . . . . . . . . 10-1, 10-4, A-34
input parameters . . . . . . 17-27–17-28 random number generators (random,
local variables (local) . . . 17-9–17-13 frandom, stats::normalRandom)
formal parameters . . . . . . . . 17-27 . . . . . . . . . . . . . . . . . . . . 10-1–10-7
without a value . . . . . . . . . . . 17-30 random numbers
MatrixProduct . . . . . . . . . . . . 17-12 normally distributed
option escape . . . . . . . 17-6, 17-18 (stats::normalRandom) . . . . . . 10-4
option remember . . 2-8, 17-23–17-26 other distributions . . . . . . . . . . 10-4
procname . . . . . . . . . . . . . . . . . . 17-8 uniformly distributed (frandom) 10-2
recursion depth (MAXDEPTH) . . . . . . uniformly distributed (random) . . 10-1
. . . . . . . . . . . . . . . . . . . 17-4, A-44 range . . . . . . . see expressions, range (..)
return value (return) . . . . . 17-5–17-6 RD_INF . . . . . . . . . . . . . . . . . . . . . . 4-95
scoping . . . . . . . . . . . . . 17-17–17-19 RD_NINF . . . . . . . . . . . . . . . . . . . . . 4-95
subprocedures . . . . . . . . 17-14–17-16 Re . . . . . . . . . . . . . . . . . . 2-10, 4-6, 9-23
symbolic differentiation 17-38–17-40 read . . . . . . . . . . . . . . . . . . . 12-5, 17-30
symbolic return values . . . . 17-7–17-8 reading data (import::readdata) . . . . 12-6
trivial function . . . . . . . . . . . . . 17-22 Real . . . . . . . . . . . . . . . . . . . . . . . . . 8-6
type declaration . . . . . . . . . . . . 17-20 real part . . . . . . . . . . . . . . . . . . . . see Re
variable number of arguments rec . . . . . . . . . . . . . . . . . . . . . 8-15, A-32
(args) . . . . . . . . . . . . . 17-21–17-22 rectform . . . . . . . . . . . . . . . . . 2-10, 9-11
procname . . . . . . 17-8, 17-22, 17-33, A-42 recurrence equations (rec) . . . . . . . . . 8-15
product . . . . . . . . . . . . . . . . . . . . . . 2-18 remainder modulo (mod) . . . . . . 4-6, 4-13
prog::exprtree . . . . . . . . . . . . . . . 4-20 redefinition . . . . . . . . . . . . . . . . 4-13
properties . . . . . . . . . . . . . . . . . . . . 9-18 option remember . . . . . . . . . 17-23–17-26
repeat . . . . . . . . . . . . . . . . . . . . . . A-12
Index-14
Index
reset . . . . . . . . . . . . . . . . . . 4-99, 13-11 series expansions . . . . . . . . . . . . . . . . .

residue class ring . . . . . . . . . . . . . . . . . . . . . . . . 4-56–4-59, see also series
. . . . . see domain, Dom::IntegerMod asymptotic expansion (series) . . .
restarting a session (reset()) . . 2-8, 13-11 . . . . . . . . . . . . . . . . . . . 2-23, 4-58
<Return> . . . . . . . . . . . . . . . . . . . . . . 2-2 conversion to a sum (expr) . . . . 4-57
return . . 17-5, 17-8, 17-10, 17-20, 17-39, Laurent series (series) . . . . . . 4-58
A-50 of inverse functions (revert) . . 4-59
revert . . . . . . . . . 4-59, A-15, A-16, A-19 operands . . . . . . . . . . . . . . . . . 4-57
rewrite point of expansion . . . . . . . . . . 4-57
targets . . . . . . . . . . . . . . . . . . . 9-10 Puiseux series (series) . . . . . . . 4-58
rewrite . . . . . . . . . . . . . . . . . . . . . . 9-8 Taylor series (taylor) . . . . . . . . 4-56
RGB::ColorNames . . . . . . . . . . . . . . 11-68 truncation (O) . . . . . . . . . . . . . . 4-56
RGB::plotColorPalette . . . . . . . . . 11-68 order (ORDER) . . . . . . . . . . . . 4-56
rings . . . . . . . . . . . . . . . . . . . . 4-60–4-63 session
RootOf . . . . . . . . . . . . . . . . . . . . . . . 8-2 restart (reset()) . . . . . . . 2-8, 13-11
roots . . . . . . . . . . . . . . . . . . . . . . . . 2-22 saving a ∼ (write) . . . . . . . . . . . 12-6
round . . . . . . . . . . . . . . . . . . . . . . . . 4-7 sets . . . . . . . . . . . . . . . . . . . . . 4-36–4-39
rounding errors . . . . . . . . . . . . . . . . . 1-2 applying a function (map) . . . . . 4-38
row vectors . . . . . . . . . . . . . . . . . . . 4-66 basic sets (solvelib::BasicSet) . 8-7
runtime information about algorithms difference (minus) . . . . . . . . . . 4-37
(userinfo and setuserinfo) . . 13-9 elements (op) . . . . . . . . . . . . . . 4-36
empty set ({}, ∅) . . . . . . . . . . . . 4-36
exchanging elements . . . . . . . . 4-37
S image set (Dom::ImageSet) . . . . . 8-9
saving graphics . . . . . . . . . 11-107–11-109 intersection (intersect) . . . . . . 4-37
batch mode . . . . . . . . 11-108–11-109 intervals (Dom::Interval) . . . . . 8-11
interactive . . . . . . . . . . . . . . . 11-107 number of elements (nops) . . . . 4-36
scoping . . . . . . . . . . . . . . . . . 17-17–17-19 order of the elements . . . . . . . . 4-36
screen output (print) . . . . . . . . . . . . 12-1 removing elements . . . . . . . . . . 4-37
manipulation (Pref::output) . . . 13-3 selecting according to properties
select . . . . 2-25–2-27, 2-29, 4-32, 4-38, (select) . . . . . . . . . . . . . . . . . 4-38
4-42, 14-5, A-4, A-11, A-24, A-35, set-valued functions . . . . . . . . . 4-37
A-36 splitting according to properties
semicolon . . . . . . . . . . . . . . . . . . . . . 2-3 (split) . . . . . . . . . . . . . . . . . . 4-38
sequence . . . . . . . . . . . . . . . . . . . . . . 4-13 union (union) . . . . . . . . . . . . . 4-37
sequence generator ($) . . . . . . . 2-25, 4-24 setuserinfo . . . . . . . . . . . . . . . . . . . 13-9
in . . . . . . . . . . . . . . . . . . . . . . 4-25 Sierpinski triangle . . . . . . . . . 17-42, A-48
sequence generator ($) . . . . . . . . . . . . 4-13 sign . . . . . . . . . . . . . . . . . . . . . 4-7, 9-23
sequences . . . . . . . . . . . . . . . . 4-24–4-27 simplification . . . . . . . . . . . . . . . . . . 6-2
deleting elements (delete) . . . . 4-27 automatic ∼ . . . . . . . . . . . 5-10–5-12
indexed access . . . . . . . . . . . . . 4-26 of expressions (simplify) . 9-13–9-17
of integers . . . . . . . . . . . . . . . . 4-24 of radicals (radsimp) . . . . 2-15, 9-14
series . . . . . . . . . . . . . 2-23, 4-58, A-18
Index-15
Index
Simplify . . . 2-15, 4-79, 9-13, 9-15, 9-17, ∼::normalQuantile . . . . . . . . . . 10-5

A-33, A-34 ∼::normalRandom . . . . . . . . . . 10-4
simplify . . . 2-15, 9-13, 9-22, A-32, A-50 ∼::stdev . . . . . . . . . . . . . . . . 10-3
sine integral (Si) . . . . . . . . . . . . . . . . 7-4 ∼::variance . . . . . . . . . . . . . . 10-2
solution strings . . . . . . . . . . . . . . . . . . 4-49–4-51
approximate . . . . . . . . . . . see float converting expressions to ∼
solve . . . 2-3, 2-17, 2-18, 2-22, 4-5, 4-11, (expr2text) . . . . . . . . . 4-50, 13-4
5-11, 6-5, 8-1, 8-4–8-7, 8-9, 8-10, extracting symbols . . . . . . . . . . 4-49
8-12, 8-13, 8-15, A-7, A-28, A-29, length (length) . . . . . . . . . . . . . 4-51
A-32 library (stringlib) . . . . . . . . . 4-50
solving equations . . . . . . . . . see equations screen output (print) . . . . . . . . 4-49
sort . . . . . . . . . . . 4-31, 10-4, A-15, A-34 substrings . . . . . . . . . . . . . . . . 4-49
user-defined order . . . . . . . . . . 10-4 subprocedures . . . . . . . . . . . . 17-14–17-16
source code (expose) . . . . . . . . . . 3-3, 3-6 subs . 4-72, 4-99, 6-1, 6-3–6-6, 8-3, 8-11,
source code debugger . . . . . . . . . . . . . 1-6 10-2, A-25, A-26, A-29, A-33
sparse matrices . . . . . . . . . . . . 4-77–4-78 subsex . . . . . . . . . . . . . . . . . . . . . . . 6-4
split . . . . . . . . . 4-32, 4-38, 4-42, A-38 subsop . . . . . 4-29, 6-5, 6-7, 17-39, A-24
sqrt . . . . . . . . . . . . . . . . . . . . . . 2-6, 4-7 substitution . . . . . . . . . . . . . . . . . 6-1–6-7
square root (sqrt) . . . . . . . . . . . . 2-6, 4-7 enforced evaluation (eval) . . . . . 6-3
standard deviation (stats::stdev) . . 10-3 in sums and products (subsex) . . 6-4
statistics . . . . . . . . . . . . . . . . . 10-1–10-7 multiple ∼s . . . . . . . . . . . . . . . . 6-4
χ2 -test (stats::csGOFT) . . . . . . . 10-5 of operands (subsop) . . . . . . . . . 6-5
equiprobable cells of subexpressions (subs) . . . . . . . 6-1
(stats::equiprobableCells) . 10-5 of system functions . . . . . . . . . . . 6-3
frequencies (Dom::Multiset) . . . . simultaneous ∼ . . . . . . . . . . . . . 6-5
. . . . . . . . . . . . . . . . . . . 10-3, A-34 sum . . . . . . . . . . . . . . . . . . . . . . . . . . 2-18
library for ∼ (stats) . . . . . . . . . 10-2 Symbol . . . . . . . . . . . . . . . . . . . . . . . 4-8
mean value (stats::mean) . . . . 10-2 symbolic computations . . . . . . . 1-3, 2-11
normal distribution symbolic manipulation . . . . . . . . . . . . . 1-3
(stats::normalCDF) . . . . . . . . 10-5 system . . . . . . . . . . . . . . . . . . . . . . 13-12
quantile (stats::normalQuantile)
. . . . . . . . . . . . . . . . . . . . . . . . 10-5
random numbers (frandom, random,
T
stats::normalRandom) . . . . . . . table 4-30, 4-40, 4-41, 4-42, 4-46, A-13,
. . . . . . . . . . . . . . . 10-1, 10-2, 10-4 A-14
standard deviation (stats::stdev) tables . . . . . . . . . . . . . . . . . . . 4-40–4-43
. . . . . . . . . . . . . . . . . . . . . . . . 10-3 accessing elements . . . . . . . . . . . 4-41
variance (stats::variance) . . . 10-2 applying a function (map) . . . . . 4-42
stats (library for statistics) deleting entries (delete) . . . . . . . 4-41
∼::csGOFT . . . . . . . . . . . . . . . . . 10-5 explicit generation . . . . . . . see table
∼::equiprobableCells . . . . . . . 10-5 implicit generation . . . . . . . . . . 4-40
∼::mean . . . . . . . . . . . . . . . . . 10-2 operands . . . . . . . . . . . . . . . . . . 4-41
∼::normalCDF . . . . . . . . . . . . . . 10-5 querying indices (contains) . . . 4-42
Index-16
Index
selecting according to properties unknowns . . . . . . . . . . . . . . see identifiers

(select) . . . . . . . . . . . . . . . . . 4-42 unprotect . . . . . . . . . . . . . . . . . . . . 4-10
splitting according to properties use . . . . . . . . . . . . . . . . . . . . . 3-4, 11-68
(split) . . . . . . . . . . . . . . . . . . 4-42
tan . . . . . . . . . . . . . . . . . . . . . 9-17, A-34
tangent . . . . . . . . . . . . . . . . . . . . . . 11-34
V
taylor . . . 4-56, 4-57, 4-58, 12-4, 17-36, variance (stats::variance) . . . . . . . 10-2
A-17–A-19 VectorFormat . . . . . . . . . . . . . . . . . . 8-3
testtype . . . . 9-20, 14-2, 14-5, 16-2, 17-7, vectors . . . . . . . . . . . . . . . . . . 4-64–4-80
17-8, A-38, A-40 column ∼ . . . . . . . . . . . . . 2-19, 4-66
Tetrahedron . . . . . . . . . . . . . . . . . . 11-54 indexed access . . . . . . . . . . . . . 4-67
TEXTWIDTH . . . . . . . . . . . . . . . . . . . . . 12-4 initialization . . . . . . . . . . . . . . 4-66
time . 4-43, 13-4, 13-6, 17-23–17-25, A-14 row ∼ . . . . . . . . . . . . . . . . . . . 4-66
transformations . . . . . . . . . . . 11-97–11-99
transforming expressions . . . . . . 9-3–9-12
TRUE . . . . . . . . . . . . . . . . . . . . . . . . 4-47
W
trunc . . . . . . . . . . . . . . . . . . . . 4-7, A-6 Waterman polyhedra . . . . . . . . . . . . 11-54
Type (library for type checking) worksheet . . . . . . . . . . . . . . . . . . . . . . 1-5
∼::AnyType . . . . . . . . . . . . . . . A-40 write . . . . . . . . . . . . . . . . . . . 12-5, 12-6
∼::Even . . . . . . . . . . . . . . . . . 14-5 write protection
∼::Interval . . . . . . . . . . . . . . 9-22 removing ∼ (unprotect) . . . . . . 4-10
∼::ListOf . . . . . . . . . . . . . . . . A-40 setting ∼ (protect) . . . . . . . . . 4-10
∼::NegInt . . . . . . . . . . . . . . . . . 14-5
∼::NonNegInt . . . . . . . . . . . . . 17-20
∼::Numeric . . . . . . . 14-2, 17-7, 17-8 Z
∼::Odd . . . . . . . . . . . . . . . . . . . 14-5 Z . . . . see Z_ and domain, Dom::Integer
∼::PosInt . . . . . . . . . . . . . . . . . 14-5 Z_ . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-7
∼::Positive . . . . . . . . . . . . . . 9-18 Z_ . . . . . . . . . . . . . . . . . . 9-18, 9-19, 9-22
∼::Real . . . . . . . . . . . . . . . . . 9-23 zip . . 2-28, 4-33, 4-34, 4-72, 4-98, 10-4,
∼::Residue . . . . . . . . . . . . . . . 9-22 A-10, A-14, A-45
type . . . . . . . . . . . . . . . . . . . . . . . . . 14-2 Zn . . . . . . see domain, Dom::IntegerMod
types of MuPAD objects . . . . . . 14-1–14-6
domain type (domtype) . . . . . . . . 4-2
library (Type) . . . . 14-4, 17-20, A-40
type checking (testtype) . . . . . . 14-2
type query (type) . . . . . . . . . . . . 14-2
typeset expressions . . . . . . . . . . . . . . 12-3
U
unassume . . . ..... . . . . . . . . . . . . . 9-20
undefined . . ..... . . . . . . . . 4-100, 5-11
union . . . . . 4-37, 4-39, 4-96, A-13, A-37
UNKNOWN . . . ..... . . . . 4-32, 4-38, 4-47
Index-17

Mupad Tutorial

Uploaded by

Copyright:

Available Formats

Mupad Tutorial

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Mupad Tutorial

Uploaded by

Copyright:

Available Formats

Symbolic Math Toolbox™ 5

[email protected] Product enhancement suggestions

The MathWorks, Inc.

First Steps in MuPAD®

The MuPAD® Libraries

Definition of Polynomials . . . . . . . . . . . . . . . . . . . . . . 4-81

Evaluation and Simplification

Substitution: subs, subsex, and subsop

Differentiation and Integration

Solving Equations: solve

Recurrence Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8-15

Chance and Probability

Input and Output

Branching: if-then-else and case

Documentation and References

Comments on the Graphics Gallery

To explain the notion of computer algebra, we compare algebraic and numerical

1. “Symbolic” emphasizes that in many cases the ultimate goal of mathematical

2. “Algebraic” means that computations are carried out exactly, according to

Sometimes “symbolic manipulation” or “formula manipulation” are used as

or symbolic solutions of equations. For example, we consider the equation

The symbolic computation of an exact solution usually requires more computing

depend functionally on p. This information can be used, for example, to examine

Characteristics of Computer Algebra Systems

guage constructs for object oriented programming.

• There are MuPAD language constructs for object oriented programming.

• There is a highly interactive MuPAD source code debugger.

• Programs written in C or C++ can be added to the kernel by the MuPAD

– The memory management is responsible for the efficient storage of MuPAD

First Steps in MuPAD®

In the previous example, a set of two equations is assigned to the identifier

Explanations and Help

Computing with Numbers

The symbol ^ represents exponentiation. MuPAD can compute big numbers

Besides the basic arithmetic functions, MuPAD provides a variety of functions

A simple example is the factorial n! = 1 · 2 · · · n of a nonnegative integer, which

Using ifactor, you can obtain the prime factorization:

As another example for exact computation, let us determine the limit

We use the function limit and the symbol infinity:

We will encounter more exact computations later in this tutorial.

Besides exact computations, MuPAD can also perform numerical approximations.

Please note that none of the two following calls

results in an approximate computation of sin(2), since, technically, sin(2) is an

You have to use the function float to compute floating-point approximations of

Most arithmetic functions,such as the square root, the trigonometric functions,

If desired, you can obtain numerical approximations of these constants by

A symbolic expression may contain undetermined quantities (identifiers). The

Using the assignment operator :=, we have assigned the expression to an

are equivalent ways of obtaining the derivative as expressions. The call

The next command determines an indefinite integral and returns an expression

Nevertheless, this object has mathematical properties. The differentiator

Definite integrals may also be returned symbolically by int:

The corresponding mathematical object is a real number, and the output is an

As already noted, the symbol % is an abbreviation for the previously computed

Generally speaking, one of the main tasks of a computer algebra system is to

Moreover, normal automatically cancels common factors in the numerator and

Conversely, partfrac (short for “partial fraction”) decomposes a rational

You may control the simplification by supplying simplify or Simplify with

Here, we have generated an equation, which is a genuine MuPAD object.

In Chapter 17, we discuss MuPAD programming features and describe how to