Using MuPAD^{®}, you can operate on the following types of numbers:
Integer numbers
Rational numbers
Floating-point numbers
Complex numbers
By default, MuPAD assumes that all variables are complex numbers.
When computing with integers and rational numbers, MuPAD returns integer results
2 + 2
or rational results:
(1 + (5/2*3))/(1/7 + 7/9)^2
If MuPAD cannot find a representation of an expression in an integer or rational form, it returns a symbolic expression:
56^(1/2)
You can perform exact computations that include the constants
=exp(1)=2.718...
and π=3.1415...
:
2*(exp(2)/PI)
For more information on the mathematical constants implemented in MuPAD, see Constants.
By default, MuPAD performs all computations in an exact
form. To obtain a floating-point approximation to an expression, use
the float
command.
For example:
float(sqrt(56))
The accuracy of the approximation depends on the value of the
global variable DIGITS
. The variable DIGITS
can assume any
integer value between 1 and 2^{29} +
1. For example:
DIGITS:=20: float(sqrt(56))
The default value of the variable DIGITS
is 10. To restore
the default value, enter:
delete DIGITS
When MuPAD performs arithmetic operations on numbers involving at least one floating-point number, it automatically switches to approximate numeric computations:
(1.0 + (5/2*3))/(1/7 + 7/9)^2
If an expression includes exact values such as or sin(2) and floating-point numbers, MuPAD approximates only numbers:
1.0/3*exp(1)*sin(2)
To approximate an expression with exact values, use the float
command:
float(1.0/3*exp(1)*sin(2))
or use floating-point numbers as arguments:
1.0/3*exp(1.0)*sin(2.0)
You also can approximate the constants π and :
DIGITS:=30: float(PI); float(E); delete DIGITS
In the input regions MuPAD recognizes an uppercase I as the imaginary unit . In the output regions, MuPAD uses a lowercase i to display the imaginary unit:
sqrt(-1), I^2
Both real and imaginary parts of a complex number can contain integers, rationals, and floating-point numbers:
(1 + 0.2*I)*(1/2 + I)*(0.1 + I/2)^3
If you use exact expressions, for example, , MuPAD does not always return the result in Cartesian coordinates:
1/(sqrt(2) + I)
To split the result into its real and imaginary parts, use the rectform
command:
rectform(1/(sqrt(2) + I))
The functions Re
and Im
return real and imaginary parts of
a complex number:
Re(1/(2^(1/2) + I))
Im(1/(2^(1/2) + I))
The function conjugate
returns
the complex conjugate:
conjugate(1/(2^(1/2) + I))
The function abs
and arg
return an absolute
value and a polar angle of a complex number:
abs(1/(2^(1/2) + I)); arg(1/(2^(1/2) + I))
To compute the derivative of a mathematical expression, use
the diff
command.
For example:
f := 4*x + 6*x^2 + 4*x^3 + x^4: diff(f, x)
You also can compute a partial derivative of a multivariable expression:
f := y^2 + 4*x + 6*x^2 + 4*x^3 + x^4: diff(f, y)
To find higher order derivatives, use a nested call of the diff
command
diff(diff(diff(sin(x), x), x), x)
or, more efficiently:
diff(sin(x), x, x, x)
You can use the sequence operator $
to compute second
or higher order derivatives:
diff(sin(x), x $ 3)
diff(f, x1, x2, ...)
is equivalent to diff(...diff(diff(f,
x1), x2)...)
. The system first differentiates f
with
respect to x1
, and then differentiates the result
with respect to x2
, and so on. For example
diff(diff((x^2*y^2 + 4*x^2*y + 6*x*y^2), y), x)
is equivalent to
diff(x^2*y^2 + 4*x^2*y + 6*x*y^2, y, x)
Note: To improve performance, MuPAD assumes that all mixed derivatives commute. For example, . |
This assumption suffices for most of engineering and scientific problems.
For further computations, delete f
:
delete f:
MuPAD provides two differentiation functions, diff
and D
. The diff
function serves
for differentiating mathematical expressions, such as sin(x)
, cos(2y)
, exp(x^2)
, x^2
+ 1
, f(y)
, and so on.
To differentiate a standard function, such as sin
, exp
, heaviside
, or a custom
function, such as f:= x -> x^2 + 1
, use the
differential operator D
:
D(sin), D(exp), D(heaviside)
f := x -> x^2 + 1: D(f)
'
is
a shortcut for the differential operator D
:
sin', sin'(x), f'
The command D(f)(x)
assumes that f
is
a univariate function, and represents the derivative of f
at
the point x
. For example, the derivative of the
sine function at the point x^{2} is:
D(sin)(x^2)
Note that in this example you differentiate the sin
function, not the
function f := x -> sin(x^2)
. Differentiating f
returns
this result:
f := x -> sin(x^2): D(f)
For details about using the operator D
for computing second-
and higher-order derivatives of functions, see Differentiating Functions.
To compute integrals use the int
command. For example, you can compute
indefinite integrals:
int((cos(x))^3, x)
The int
command
returns results without an integration constant.
To find a definite integral, pass the upper and lower limits
of the integration interval to the int
function:
int((cos(x))^3, x = 0..PI/4)
You can use infinity as a limit when computing a definite integral:
int(sin(x)/x, x = -infinity..infinity)
If MuPAD cannot evaluate an expression in a closed form, it returns the expression. For example:
int(sin(x^2)^2, x = -1..1)
You can approximate the value of an integral numerically using
the float
command.
For example:
float(int(sin(x^2)^2,(x = -1..1)))
You also can use the numeric::int
command
to evaluate an integral numerically. For example:
numeric::int(sin(x^2)^2, x = -1..1)
To create a matrix in MuPAD, use the matrix
command:
A := matrix([[1, 2], [3, 4], [5, 6]]); B := matrix([[1, 2, 3], [4, 5, 6]])
You also can create vectors using the matrix
command:
V := matrix([1, 2, 3])
You can explicitly declare the matrix dimensions:
C := matrix(3, 3, [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]); W := matrix(1, 3, [1, 2, 3])
If you declare matrix dimensions and enter rows or columns shorter than the declared dimensions, MuPAD pads the matrix with zero elements:
F := matrix(3, 3, [[1, -1, 0], [2, -2]])
If you declare matrix dimensions and enter rows or columns longer than the declared dimensions, MuPAD returns the following error message:
matrix(3, 2, [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]])
Error: The number of columns does not match. [(Dom::Matrix(Dom::ExpressionField()))::mkSparse]
You also can create a diagonal matrix:
G := matrix(4, 4, [1, 2, 3, 4], Diagonal)
To add, subtract, multiply and divide matrices, use standard arithmetic operators. For example, to multiply two matrices, enter:
A := matrix([[1, 2], [3, 4], [5, 6]]); B := matrix([[1, 2, 3], [4, 5, 6]]); A*B
If you add number x
to a matrix A
, MuPAD adds x
times
an identity matrix to A
. For example:
C := matrix(3, 3, [[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]); C + 10
You can compute the determinant and the inverse of a square matrix:
G := matrix([[1, 2, 0], [2, 1, 2], [0, 2, 1]]); det(G); 1/G
The MuPAD linalg
library contains the
functions for handling linear algebraic operations. Using this library,
you can perform a wide variety of computations on matrices and vectors.
For example, to find the eigenvalues of the square matrices G, F,
and (A*B), use the linalg::eigenvalue command:
linalg::eigenvalues(G); linalg::eigenvalues(F); linalg::eigenvalues(A*B)
To see all the functions available in this library, enter info(linalg)
in
an input region. You can obtain detailed information about a specific
function by entering ?functionname
. For example,
to open the help page on the eigenvalue function, enter ?linalg::eigenvalues
.
To solve a simple algebraic equation with one variable, use
the solve
command:
solve(x^5 + 3*x^4 - 23*x^3 - 51*x^2 + 94*x + 120 = 0, x)
You can solve an equation with symbolic parameters:
solve(a*x^2 + b*x + c = 0, x)
If you want to get the solution for particular values of the
parameters, use the assuming
command.
For example, you can solve the following equation assuming that a
is
positive:
solve(a*x^2 + b*x + c = 0, x) assuming a > 0
For more information, see Using Assumptions.
You can solve a system of equations:
solve([x^2 + x*y + y^2 = 1, x^2 - y^2 = 0], [x, y])
or you can solve a system of equations containing symbolic parameters:
solve([x^2 + y^2 = a, x^2 - y^2 = b], [x, y])
You can solve different types of ordinary differential equations:
o := ode(x^2*diff(y(x), x, x) + 2*x*diff(y(x), x) + x, y(x)): solve(o)
Also, you can solve inequalities:
solve(x^4 >= 5, x)
If you want to get the result over the field of real numbers
only, assume
that
x is a real number:
assume(x in R_); solve(x^4 >= 5, x)
You can pick the solutions that are positive:
solve(x^4 >= 5, x) assuming x > 0
There are several ways to present a polynomial expression. The
standard polynomial form is a sum of monomials. To get this form of
a polynomial expression, use the expand
command:
expand((x - 1)*(x + 1)*(x^2 + x + 1)* (x^2 + 1)*(x^2 - x + 1)*(x^4 - x^2 + 1))
You can factor this expression using the factor
command:
factor(x^12 - 1)
For multivariable expressions, you can specify a variable and collect the terms with the same powers in this variable:
collect((x - a)^4 + a*x^3 + b^2*x + b*x + 10*a^4 + (b + a*x)^2, x)
For rational expressions, you can use the partfrac
command to present the expression
as a sum of fractions (partial fraction decomposition). For example:
partfrac((7*x^2 + 7*x + 6)/(x^3 + 2*x^2 + 2*x + 1))
MuPAD also provides two general simplification functions: simplify
and Simplify
.
The simplify
function
is faster and it can handle most of the elementary expressions:
simplify((x - 1)*(x + 1)*(x^2 + x + 1)*(x^2 + 1)* (x^2 - x + 1)*(x^4 - x^2 + 1))
The Simplify
function
searches for simpler results deeper than the simplify
function. The more extensive
search makes this function slower than simplify
. The Simplify
function allows
you to extend the simplification rule set with your own rules and
serves better for transforming more complex expressions. For the elementary
expressions it gives the same result as simplify:
Simplify((x - 1)*(x + 1)*(x^2 + x + 1)*(x^2 + 1)* (x^2 - x + 1)*(x^4 - x^2 + 1))
For the following expression the two simplification functions give different forms of the same mathematical expression:
f := exp(wrightOmega(-ln(3/5)))*exp(ln(5) - ln(3)): simplify(f); Simplify(f)
Note that there is no universal simplification strategy, because
the meaning of the simplest representation of a symbolic expression
cannot be defined clearly. Different problems require different forms
of the same mathematical expression. You can use the general simplification
functions simplify
and Simplify
to
check if they give a simpler form of the expression you use.
You also can transform and simplify trigonometric expressions.
The functions for manipulating trigonometric expressions are the same
as for polynomial expressions. For example, to expand a trigonometric
expression, use the expand
command:
expand(sin(5*x))
To factor the trigonometric expression, use the factor
command:
factor(cos(x)^4 + 4*cos(x)^3*sin(x) + 6*cos(x)^2*sin(x)^2 + 4*cos(x)*sin(x)^3 + sin(x)^4)
You can use the general simplification functions on trigonometric expressions:
simplify(cos(x)^2 + sin(x)^2)
simplify(cos(x)^4 + sin(x)^4 + sin(x)*cos(x))
Simplify(cos(x)^4 + sin(x)^4 + sin(x)*cos(x))
By default, all variables in MuPAD represent complex numbers. When solving equations or simplifying expressions, the software considers all possible cases for complex numbers. If you are solving an equation or simplifying an expression, this default assumption leads to the exact and complete set of results including complex solutions:
solve(x^(5/2) = 1, x)
To obtain real solutions only, pass the assumption to MuPAD using
the assuming
command:
solve(x^(5/2) = 1, x) assuming x in R_
You can make various assumptions on the values that a variable represents. For example, you can solve an equation assuming that the variable x represents only positive values:
solve(x^4 - 1 = 0, x) assuming x > 0
You can make multiple assumptions:
solve(x^4 - a = 0, x) assuming a = 16 and x in R_
You can use assumptions when integrating mathematical expressions.
For example, without an assumption on the variable x
,
the following integral depends on the sign of the expression x^{2} -
1:
int(1/abs(x^2 - 1), x)
If you know that x > 1, you can pass the assumption to the integral:
int(1/abs(x^2 - 1), x) assuming x > 1
Using assumptions along with the simplification functions narrows down the possible values that variables represent and can provide much shorter results than the simplification functions alone. For example:
simplify(sqrt(x^2 + 2*x + 1) + sqrt(x^2 - 2*x + 1) + sqrt(x^2 + 4*x + 4) + sqrt(x^2 - 4*x + 4))
versus
simplify(sqrt(x^2 + 2*x + 1) + sqrt(x^2 - 2*x + 1) + sqrt(x^2 + 4*x + 4) + sqrt(x^2 - 4*x + 4)) assuming x > 2
You can pass assumptions to the following functions: expand
, simplify
, limit
, solve
, and int
. The Simplify
function
does not allow assumptions on variables.