Symbolic Math Toolbox Release Notes

R2016a

New Features, Bug Fixes, Compatibility Considerations

Live Scripts: Edit symbolic code and visualize results in MATLAB Live Editor, and convert MuPAD notebooks to MATLAB live scripts

The MATLAB® `convertMuPADNotebook` function converts the code from MuPAD® notebooks (file extension `.mn`) to MATLAB live script files (file extension `.mlx`). The function also flags the code lines and formatting that cannot be directly translated from the MuPAD language to the MATLAB language. For information on live scripts, see Create Live Scripts.

Plotting: Create 2-D, 3-D, contour, surface, and mesh plots with MATLAB `fplot`, `fplot3`, `fcontour`, `fsurf`, and `fmesh` functions

New MATLAB functions to plot mathematical expressions. These functions supersede the existing `ez` family of plotting functions, such as `ezplot`. The `ez` functions remain available.

Because the new functions fully integrate with MATLAB graphics, you can use standard MATLAB graphics options as inputs to these functions.

Simscape Component Generation: Create custom components directly from symbolic math equations for use in dynamic simulation

Use `symReadSSCParameters` and `symReadSSCVariables` to load the names, values, and units of the parameters and variables of a Simscape™ component to MATLAB. Names, values, and units appear in the MATLAB workspace as cell arrays.

When you are ready to import the result of symbolic computations to a Simscape component, use `symWriteSSC`. This function lets you create a new component using an existing component as a template and adding new equations.

MATLAB `cell2sym` and `sym2cell` simplify conversions between symbolic and cell arrays

The MATLAB `cell2sym` function converts cell arrays to symbolic arrays. The MATLAB `sym2cell` function converts symbolic arrays to cell arrays.

MATLAB `nchoosek` accepts a vector as its first argument

`C = nchoosek(v,k)` returns a matrix containing all possible combinations of the elements of vector `v` taken `k` at a time.

MATLAB `sym` creates multidimensional arrays

`sym(a,[n1 ... nM])` creates the symbolic array with dimension `n1`-by-`...`-by-`nM`. You can create symbolic arrays of any dimension using this syntax. For details, see `sym`.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
Character strings inputs to `sym` and `vpa` are restricted to numbers and valid variable names.WarnsWhen creating symbolic expressions, first create symbolic variables, and then use operations on them. For example, use:
• `syms x; x + 1`

`sym('x + 1')`

• `exp(sym(pi))`

`sym('exp(pi)')`

• `syms f(var1,...varN)`

`f(var1,...varN) = sym('f(var1,...varN)')`

• `vpa((1 + sqrt(sym(5)))/2)`

`vpa('(1 + sqrt(5))/2')`

Support of strings that are not valid variable names and do not define a number will be removed in a future release. To create symbolic expressions, first create symbolic variables, and then use operations on them.
Comparing symbolic and non-symbolic objects by using `isequal`Returns `0` instead of `1`.Wrap the non-symbolic object with `sym`. For example, instead of `a=1;isequal(a,1)`, use `isequal(a,sym(1))`.Symbolic objects are not considered equal to non-symbolic objects.
Character strings as inputs to `solve`WarnsWhen specifying equations and variables, use symbolic equations and variables instead of character strings. For example, replace ```solve('2*r = 1', 'r')``` with `syms r; solve(2*r == 1, r)`.Do not specify equations and variables as character strings. Instead of string inputs, create symbolic variables using `syms`, and then pass them as input arguments separated by commas, or as a vector of input arguments.
`findsym`Warns`symvar`Replace all instances of `findsym` with `symvar`.
`mfun`WarnsAppropriate special function. For example, replace `mfun('P',1,2,3,4)` with `jacobiP(1,2,3,4)`.Replace all instances of `mfun` with the appropriate function call. See Special Functions for the list of available special functions.
`mfunlist`WarnsSee Special Functions.See Special Functions for the list of available special functions.
`sym(A,set)` and `sym(A,'clear')` where `A` is a symbolic object in the workspace.Errors`assume(A,set)` and `assume(A,'clear')`Instead of `sym`, use `assume` to set and clear assumptions on variables in the workspace.
Values `All` and `None` of `IgnoreAnalyticConstraints`Errors`true` and `false`Replace all instances of `'IgnoreAnalyticConstraints','All'` with `'IgnoreAnalyticConstraints',true`. Replace all instances of `'IgnoreAnalyticConstraints','None'` with `'IgnoreAnalyticConstraints',false`.
`poly2sym(c, 'var')` does not accept a character string `'var'` anymore.Errors`syms var; poly2sym(c, var)` or ```poly2sym(c, sym('var'))```Replace all instances of `poly2sym(c, 'var')` with ```syms var; poly2sym(c, var)``` or `poly2sym(c, sym('var'))`

R2015b

New Features, Bug Fixes, Compatibility Considerations

Fourier and Laplace transforms and their inverses for a wider variety of input expressions, including hyperbolic functions

More patterns are available for the transformation functions `fourier`, `laplace`, `ztrans` and their inverses, allowing these functions to support a wider variety of input expressions.

MATLAB `series` function for computing Puiseux series expansion

The MATLAB `series` function approximates a symbolic expression or function with a Puiseux series expansion.

MATLAB `hermiteForm` and `smithForm` functions for computing Hermite and Smith normal forms of matrices​

The MATLAB `smithForm` and `hermiteForm` functions compute the Smith and Hermite normal forms of a matrix, respectively. Elements of a matrix must be integers or polynomials. Both functions also can return corresponding transformation matrices.

The MuPAD `linalg::smithForm` and `linalg::hermiteForm` functions provide more functionality:

`Sparse` argument for `matlabFunction`, `odeFunction`, and `daeFunction` for using sparse instead of dense matrices in generated MATLAB functions

`matlabFunction`, `odeFunction`, and `daeFunction` accept the name-value pair argument, `'Sparse',true` that triggers the generated MATLAB functions to represent symbolic matrices by sparse numeric matrices in the generated code.

MATLAB `has` function for searching subexpressions in a symbolic expression​

The MATLAB `has` function checks if an expression contains specified subexpressions.

MATLAB `root` function for representing roots of polynomials

The MATLAB `root` function represents roots of polynomials. Symbolically solving a high degree polynomial for its roots can be complex or mathematically impossible. In this case, Symbolic Math Toolbox™ uses the `root` function to represent the roots of the polynomial.

New Symbolic Math Toolbox examples

The following new examples demonstrate the functionality of Symbolic Math Toolbox:

The following examples are updated and renamed:

• Integration. To run this example, enter `IntExample` in the MATLAB Command Window.

• Differentiation. To run this example, enter `DiffExample` in the MATLAB Command Window.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
Character strings inputs to `sym` and `vpa` are restricted to numbers and valid variable names.Still runsWhen creating symbolic expressions, first create symbolic variables, and then use operations on them. For example, use:
• `syms x; x + 1`

`sym('x + 1')`

• `exp(sym(pi))`

`sym('exp(pi)')`

• `syms f(var1,...varN)`

`f(var1,...varN) = sym('f(var1,...varN)')`

• `vpa((1 + sqrt(sym(5)))/2)`

`vpa('(1 + sqrt(5))/2')`

Support of strings that are not valid variable names and do not define a number will be removed in a future release. To create symbolic expressions, first create symbolic variables, and then use operations on them.
Character strings as inputs to `solve`WarnsWhen specifying equations and variables, use symbolic equations and variables instead of character strings. For example, replace ```solve('2*r = 1', 'r')``` with `syms r; solve(2*r == 1, r)`.Do not specify equations and variables as character strings. Instead of string inputs, create symbolic variables using `syms`, and then pass them as input arguments separated by commas, or as a vector of input arguments.
`findsym`Warns`symvar`Replace all instances of `findsym` with `symvar`.
Values `All` and `None` of `IgnoreAnalyticConstraints`Warns`true` and `false`Replace all instances of `'IgnoreAnalyticConstraints','All'` with `'IgnoreAnalyticConstraints',true`. Replace all instances of `'IgnoreAnalyticConstraints','None'` with `'IgnoreAnalyticConstraints',false`.
`mfun`WarnsAppropriate special function. For example, replace `mfun('P',1,2,3,4)` with `jacobiP(1,2,3,4)`.Replace all instances of `mfun` with the appropriate function call. See Special Functions for the list of available special functions.
`mfunlist`WarnsSee Special Functions.See Special Functions for the list of available special functions.
`poly2sym(c, 'var')` will not accept a character string `'var'` in a future release.Warns`syms var; poly2sym(c, var)` or ```poly2sym(c, sym('var'))```Replace all instances of `poly2sym(c, 'var')` with ```syms var; poly2sym(c, var)``` or `poly2sym(c, sym('var'))`
`setVar(nb, 'MuPADvar')`ErrorsThree-argument version `setVar(nb, 'MuPADvar', MATLABexpr)`Replace all instances of `setVar(nb,'MuPADvar')` with ```setVar(nb, 'MuPADvar', MATLABexpr)```.

R2015a

New Features, Bug Fixes, Compatibility Considerations

MATLAB `functionalDerivative` function for finding derivatives of functionals

The MATLAB `functionalDerivative` function finds the derivative of a symbolic expression with respect to functions.

MATLAB `odeFunction` for converting systems of algebraic expressions to MATLAB functions suitable for `ode45` and other ODE solvers

The MATLAB `odeFunction` converts a system of symbolic algebraic expressions to MATLAB function handle suitable for `ode45`, `ode15s`, and other ODE solvers.

MATLAB `partfrac` function for computing partial fraction decomposition

The MATLAB `partfrac` function finds the partial fraction decomposition of a rational expression. This function accepts the name-value pair argument `'FactorMode',mode` that lets you choose a factorization mode used to factor the denominator. Here, `mode` is one of the following strings: `'real'`, `'complex'`, `'full'`, or `'rational'`. By default, `partfrac` performs factorization over the rational numbers.

MATLAB `sympref` function for specifying preferences for symbolic functions `fourier`, `ifourier`, and `heaviside`

The MATLAB `sympref` function specifies preferences for symbolic functions `fourier`, `ifourier`, and `heaviside`. `sympref` specifies values of parameters in `fourier` and `ifourier`, and the return value of `heaviside` at `0`.

`Optimize` argument for controlling code optimization in generated MATLAB functions returned by `matlabFunction`, `odeFunction`, and `daeFunction`

`matlabFunction`, `odeFunction`, and `daeFunction` accept the name-value pair argument, `'Optimize',false` that disables code optimization when you write the resulting code to a file.

MuPAD `isolate` function for rearranging an equation so that the variable or expression appears on the left side

The MuPAD `isolate` function rearranges an equation so that the variable or expression appears on the left side of the equation. If `isolate` cannot isolate the variable or expression, it moves all terms containing the variable or expression to the left side.

`FactorMode` argument offering different modes of factorization returned by MATLAB `factor` function

The MATLAB `factor` function now accepts the name-value pair argument `'FactorMode',mode` that lets you choose a factorization mode. Here, `mode` is one of the following strings: `'real'`, `'complex'`, `'full'`, or `'rational'`. By default, `factor` performs factorization over the rational numbers.

Reverse accumulation option for `cumsum` and `cumprod` functions

The `'reverse'` option for the MATLAB `cumsum` and `cumprod` functions reverses the direction of cumulation, working from end to 1 in the active dimension. This option allows quick directional calculations without requiring a flip or reflection of the input array.

MATLAB functions `chol`, `lu`, `qr`, and `rank` now return certain outputs as type double

The MATLAB functions `chol`, `lu`, `qr`, and `rank` now return certain outputs as type `double` instead of symbolic objects.

Compatibility Considerations

The functions `chol`, `lu`, and `qr` now return the permutation information as matrices or vectors of double-precision values. The `rank` function returns the rank of a matrix as a double-precision value. In previous releases, these output arguments were returned as symbolic objects. For details, see the Output Arguments section on the respective reference pages.

MATLAB functions `assume`, `assumeAlso`, `assumptions`, `sym`, and `syms` have changes to assumptions mechanism

• `syms` creates a vector or a matrix of symbolic variables where each element of the vector or matrix belongs to `set` using the syntax `sym(A,dim,set)`. For example, `A = sym('A',[3 3],'rational')` creates the 3-by-3 matrix `A` where MATLAB assumes all elements of `A` are `rational`.

• `assume` clears assumptions on a variable `var` using the syntax `assume(var,'clear')`. If `var` is an expression, `assume` clears all assumptions on all variables in `var`.

• `assume` and `assumeAlso` set the assumption that a variable is positive using the option `'positive'`. For example, assume `x` is positive using `assume(x,'positive')`.

Compatibility Considerations

• `syms` does not create variables with the following names: `clear`, `integer`, `positive`, `rational`, and `real`. For example, in previous releases ```syms integer``` created the symbolic variable `integer`. To use these variable names now, use `sym`. For example, to create the symbolic variable `integer`, use `integer = sym('integer')`.

• The syntax `sym(x,set)` for `x` that already exists in the MATLAB workspace will be removed in a future release. Use `assume(x,set)` instead.

• The syntax `sym(x,'clear')` will be removed in a future release. Use `assume(x,'clear')` instead.

MATLAB function `combine` combines additional expressions

The MATLAB `combine` can combine expressions containing the function `int` using the target `int`, and expressions containing a sum of sine or cosine functions using the target `sincos`.

New and updated Symbolic Math Toolbox examples

The following new examples demonstrate the functionality of Symbolic Math Toolbox.

The Differentiation example is updated and renamed. To run this example, enter `DiffExample` in the MATLAB Command Window.

Compatibility Considerations

To run the Differentiation example in previous releases, enter`symdiffdemo` in the MATLAB Command Window.

MATLAB `solve` function uses default `MaxDegree` value of `2`

The MATLAB `solve` function uses a default `MaxDegree` value of `2`. In previous releases, the default value of `MaxDegree` was `3`.

Compatibility Considerations

In previous releases, `solve` automatically returned explicit solutions for equations of degree `3`. To obtain the same results as in previous releases, set `MaxDegree` to `3`. For example, `solve(a*x^3 + b*x^2 + c*x + 1,'MaxDegree',3)`.

MuPAD functions `taylor` and `mtaylor` error when they cannot find a Taylor series

The MuPAD functions `taylor` and `mtaylor` throw an error when they cannot find a Taylor series.

Compatibility Considerations

In previous releases, `taylor` and `mtaylor` issued a warning and returned unresolved symbolic `taylor` and `mtaylor` calls in such cases.

MuPAD orthogonal polynomial functions return polynomial expressions

The MuPAD orthogonal polynomial functions return polynomial expressions when the polynomials are evaluated with identifiers. This applies to all functions in the MuPAD `orthpoly` library.

Compatibility Considerations

In previous releases, the MuPAD orthogonal polynomial functions returned objects of type `DOM_POLY` when the polynomials were evaluated with identifiers.

MATLAB function `sym` treats `i` in string input as a variable

The MATLAB function `sym` treats `i` in string input as a variable. For example, `sym('1 + i')` returns the symbolic expression `i+1`.

Compatibility Considerations

• In previous releases, `sym` treated `i` in string input as an imaginary number. Now, it is treated as a variable `i`. For example, `sym('1 + i')^2` returns the symbolic expression `(i + 1)^2`. To obtain the same results as in previous releases, specify the imaginary number `i` as `1i`. For example, `sym('1 + 1i')^2` returns `2i`.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
`findsym`Still runs`symvar`Replace all instances of `findsym` with `symvar`.
Values `All` and `None` of `IgnoreAnalyticConstraints`Still runs`true` and `false`Replace all instances of `'IgnoreAnalyticConstraints','All'` with `'IgnoreAnalyticConstraints',true`. Replace all instances of `'IgnoreAnalyticConstraints','None'` with `'IgnoreAnalyticConstraints',false`.
`mfun`WarnsAppropriate special function. For example, replace `mfun('P',1,2,3,4)` with `jacobiP(1,2,3,4)`.Replace all instances of `mfun` with the appropriate function call. See Special Functions for the list of available special functions.
`mfunlist`WarnsSee Special Functions.See Special Functions for the list of available special functions.
`setVar(nb, 'MuPADvar')`WarnsThree-argument version `setVar(nb, 'MuPADvar', MATLABexpr)`Replace all instances of `setVar(nb,'MuPADvar')` with ```setVar(nb, 'MuPADvar', MATLABexpr)```
Character strings as inputs to `solve`WarnsWhen specifying equations and variables, use symbolic equations and variables instead of character strings. For example, replace ```solve('2*r = 1, r')``` with `syms r; solve(2*r == 1, r)`.Do not specify equations and variables as character strings. Instead of string inputs, create symbolic variables using `syms`, and then pass them as input arguments separated by commas, or as a vector of input arguments.
`poly2sym(c, 'var')` will not accept a character string `'var'` in a future release.Warns`syms var; poly2sym(c, var)` or ```poly2sym(c, sym('var'))```Replace all instances of `poly2sym(c, 'var')` with ```syms var; poly2sym(c, var)``` or `poly2sym(c, sym('var'))`
`simple`Errors`simplify`Replace all instances of `simple(S)` with `simplify``(S)`. There is no replacement for `[r,how] = simple(S)`.
In previous releases, `in(x, type)` in some cases returned logical `1` if `x` belonged to `type` and `0` otherwise. Returns a symbolic expression of the form `in(x, type)``isAlways`To obtain the same results as in previous releases, wrap such expressions in `isAlways`. For example, use `isAlways(in(sym(5), 'integer'))`.
In previous releases, the symbolic relational operators in some cases evaluated equations involving only symbolic numbers and returned logical `1` or `0`. Returns a symbolic equation or inequality`isAlways`To obtain the same results as in previous releases, wrap equations in `isAlways`. For example, use `isAlways(A < B)`.

R2014b

New Features, Bug Fixes, Compatibility Considerations

MATLAB `solve` function returning parameters and conditions in solutions

The MATLAB symbolic `solve` function returns the parameters in a solution and the conditions under which a solution is valid when the `ReturnConditions` option is specified as `true`.

Compatibility Considerations

• Do not specify equations and variables as character strings. Instead of string inputs, declare symbolic variables using `syms`, and then pass them as input arguments separated by commas, or as a vector of input arguments. For example, replace

`solve('2*r = 1, r')`

with

```syms r solve(2*r == 1, r)```

In a future release, string input arguments will be interpreted as option names to support shortcuts, such as `ignorea` for `IgnoreAnalyticConstraints`.

• `solve` warns when it calls the numerical solver and returns a numerical output.

• `solve` does not warn if provably no solution exists.

• When the list of equations is empty, `solve` throws an error instead of a warning.

Functions for analyzing and reducing systems of differential algebraic equations (DAEs), such as `isLowIndexDAE` and `reduceDAEIndex`

• Identify subsets (blocks) of equations that can be used to define subsets of variables.

• Identify high-index differential algebraic equations.

• Reduce high-index differential algebraic equations to systems of differential index `1` or `0`.

MATLAB `pade` function for computing Padé approximation

The MATLAB symbolic `pade` function calculates Padé approximations.

`funm` function for computing matrix functions

The MATLAB symbolic `funm` function and the MuPAD `funm` function represent a general matrix function. A matrix function is a scalar function that maps one matrix to another, for example, function `f` in ```B = f(A)``` maps matrix `A` to matrix `B`.

MATLAB `kummerU` function for computing confluent hypergeometric (Kummer U) function

The MATLAB symbolic `kummerU` function computes the value of the confluent hypergeometric function. This function is also known as the Kummer U function.

MATLAB `polylog` function for computing polylogarithms

The MATLAB symbolic `polylog` function computes polylogarithms.

MATLAB `signIm` function for computing signs of imaginary parts of complex numbers

The MATLAB symbolic `signIm` function returns a sign of the imaginary part of a complex number. For all complex numbers with a nonzero imaginary part, ```singIm(z) = sign(imag(z))```. For real numbers, ```signIm(z) = -sign(z)```.

MATLAB `in` function for representing conditions on symbolic inputs

The MATLAB symbolic `in` function represents the condition that the input is of the specified type. The allowed types are `integer`, `real` and `rational`. The `in` function is used in the input and output of other functions such as `solve` to represent conditions on symbolic variables. If the input is a number of the specified type, the `in` function returns logical `1` (`true`), and if it is not of the specified type, the `in` function returns logical `0` (`false`).

MATLAB `divisors` function for finding divisors of integers and polynomials

The MATLAB symbolic `divisors` function computes divisors of integers and polynomials.

MATLAB functions `nnz` and `nonzeros` for finding nonzero elements in a symbolic array

The MATLAB symbolic `nnz` function computes the number of nonzero elements in a symbolic vector, matrix, or multidimensional array.

The MATLAB symbolic `nonzeros` function returns a column vector containing all nonzero elements of a symbolic vector, matrix, or multidimensional array.

MATLAB `pochhammer` function to calculate Pochhammer symbol

The MATLAB symbolic `pochhammer` function calculates the Pochhammer symbol.

MATLAB `kroneckerDelta` function for computing the Kronecker delta function

The MATLAB symbolic `kroneckerDelta` function calculates the Kronecker delta function.

MATLAB `dirac` function with two input arguments for computing derivatives of the Dirac delta function

The MATLAB symbolic `dirac` function with one input argument represents the Dirac delta function. `dirac` with two input arguments, `dirac(n,x)` represents the `n`th derivative of the Dirac delta function at `x`.

MATLAB `isAlways` function warns when returning false for undecidable inputs

The MATLAB symbolic `isAlways` function issues a warning when it returns logical `0` (`false`) for an undecidable input.

Compatibility Considerations

• In previous releases, `isAlways` did not issue a warning before returning logical `0` (`false`) for an undecidable input. To go back to this behavior, suppress the warning by specifying the `Unknown` option as `false`, as in `isAlways(cond,'Unknown','false')`.

MuPAD `generate::fortran` function can use Fortran 90 as the target compiler

The MuPAD `generate::fortran` function can use Fortran 90 as the target compiler, in addition to Fortran 77.

MATLAB `mod` function for computing modulus after division

The MATLAB symbolic `mod` function finds the modulus after division as follows: ```mod(a,b) = a - b*floor(a/b)```.

Compatibility Considerations

The MATLAB symbolic `mod` function uses the same definition as the MuPAD `modp` function. Also, by default, the MuPAD `mod` operator and its functional form `_mod` are equivalent to the MuPAD `modp` function.

In previous releases, the MuPAD `modp` and `mods` functions computed the modulus after division according to these definitions:

• If `a` and `b` are integers, then `modp(a,b)` is an integer `r`, such that `a = qb + r`, `0 <= r < |b|`, and `q = a div b`.

If `b` is an integer and `a` is a rational number, `a = u/v`, such that `v` and `b` are coprime integers, then `modp(a,b) = modp(u*w,b)`. Here, `w` is an inverse of `v mod b`, that is, `v*w``1 (mod b)`.

• If `a` and `b` are integers, then `mods(a,b)` is an integer `r`, such that `a = qb + r` and ```-|b|/2 < r <= |b|/2```.

If `b` is an integer and `a` is a rational number, `a = u/v`, such that `v` and `b` are coprime integers, then `mods(a,b) = mods(u*w,b)`. Here, `w` is an inverse of `v mod b`, that is, `v*w``1 (mod b)`.

Now, MuPAD uses the same definitions for an integer or rational `a`. As in previous releases, `b` must be an integer.

• `modp(a,b) = a - b*floor(a/b)`

• `mods(a,b) = a - b*round(a/b)`

In MuPAD, to get the same results as in previous releases, use the MuPAD `numlib::lincongruence` function to find a modular inverse, and then use the MuPAD modulo operator or functions, for example:

```w := numlib::lincongruence(3, 1, 5)[1]: 22*w mod 5; modp(22*w, 5); mods(22*w, 5); _mod(22*w, 5)```

In MATLAB, to get the same results as in previous releases, use the `gcd` function with three output arguments to find a modular inverse, and then use the `mod` function as follows. For example, for ```mod(a,b) = mod(u/v,b)``` use these commands:

```[~, A, ~] = gcd(sym(v), b); mod(A*u, b)```

MATLAB `gcd` and `lcm` functions accept vectors and matrices

The MATLAB symbolic `gcd` and `lcm` functions accept vectors and matrices as input arguments. If `A` is a vector or a matrix, then `gcd(A)` and `lcm(A)` find the greatest common divisor and least common multiple of all elements of `A`. If `A` and `B` are vectors or matrices of the same size, then `gcd(A,B)` and `lcm(A,B)` find the greatest common divisor and least common multiple of the pairs of elements of `A` and `B`.

MATLAB `rem` function accepts vectors and matrices

The MATLAB symbolic `rem` function accepts vectors and matrices as input arguments. Also, the new MuPAD `rem` function lets you compute a remainder after division in a MuPAD notebook.

Compatibility Considerations

In previous release, `rem` accepted polynomials as its input arguments. For example, ```sym x; R = rem(x^2 + 2, x)``` returned `2`. To perform polynomial division in this and later releases, use the `quorem` function, for example, `sym x; [~, R] = quorem(x^2 + 2, x)`.

MATLAB `factor` function only accepts scalar inputs and returns vector of factors of input

The MATLAB symbolic `factor` function only accepts scalar inputs. The `factor` function returns a symbolic vector of irreducible factors of the input.

Compatibility Considerations

The `factor` function does not accept nonscalar inputs. The output is a symbolic vector and is not of type factored.

MuPAD Notebook app supports left and right double square brackets

The MuPAD `Symbol::LeftDoubleBracket` and `Symbol::RightDoubleBracket` functions insert left and right double square brackets. These symbols are also called white square brackets.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
`mfun`Still runsAppropriate special function. For example, replace `mfun('P',1,2,3,4)` with `jacobiP(1,2,3,4)`.Replace all instances of `mfun` with the appropriate function call. See Special Functions for the list of available special functions.
`mfunlist`Still runsSee Special Functions.See Special Functions for the list of available special functions.
`setVar(nb, 'MuPADvar')`WarnsThree-argument version `setVar(nb, 'MuPADvar', MATLABexpr)`Replace all instances of `setVar(nb, 'MuPADvar')` with ```setVar(nb, 'MuPADvar', MATLABexpr)```
`simple`Warns`simplify`Replace all instances of `simple(S)` with `simplify``(S)`. There is no replacement for `[r,how] = simple(S)`.
`emlBlock`Errors`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.

R2014a

New Features, Bug Fixes, Compatibility Considerations

MATLAB functions for computing special integrals, gamma functions, dilogarithm function, and number-theoretic functions

The following special functions are available:

• The MATLAB symbolic `sinhint` and `coshint` function compute the hyperbolic sine and cosine integral functions, respectively.

• The MATLAB symbolic `ssinint` function computes the shifted sine integral function.

• The MATLAB symbolic `dawson` function computes the Dawson integral.

• The MATLAB symbolic `fresnelc` and `fresnels` functions return the Fresnel cosine and sine integral functions respectively.

• The MATLAB symbolic `logint` function computes the logarithmic integral function. This function is also called the integral logarithm.

• The MATLAB symbolic `gammaln` function computes the logarithmic gamma function.

• The MATLAB symbolic `igamma` function computes the incomplete gamma function.

• The MATLAB symbolic `dilog` function computes the dilogarithm function.

• The MATLAB symbolic `bernoulli` function computes the Bernoulli numbers and polynomials.

• The MATLAB symbolic `euler` function computes the Euler numbers and polynomials.

• The MATLAB symbolic `harmonic` function computes the harmonic function. For positive integer arguments, the harmonic function produces harmonic numbers.

• The MATLAB symbolic `catalan` function represents the Catalan constant. To approximate the Catalan constant with the current precision set by `digits`, use `vpa(catalan)`.

• The MATLAB symbolic `eulergamma` function represents the Euler-Mascheroni constant. To approximate the Euler-Mascheroni constant with the current precision set by `digits`, use `vpa(eulergamma)`.

MATLAB function `qr` for computing symbolic QR factorization

The MATLAB symbolic `qr` function computes the QR factorization of a matrix. The result can be used to solve matrix equations.

MATLAB function `combine` for combining symbolic expressions with multiple calls to the same function

The MATLAB symbolic `combine` function applies rewriting rules to the input expression to combine multiple calls to a function, and returns the rewritten expression. The analytic constraints on applying rewriting rules can be optionally relaxed when the function is called.

MATLAB functions `max` and `min` for finding the largest and smallest elements of a symbolic array

The MATLAB symbolic `max` and `min` functions return the largest and the smallest element of a symbolic vector or matrix, all elements of which are convertible to floating-point numbers. For a symbolic matrix, these functions find the largest and smallest elements of each row or column.

`vpasolve` can use random starting points when searching for solutions

The MATLAB numeric solver `vpasolve` now uses random starting points when searching for solutions if you specify `random`. This enables the solver to find different solutions for nonpolynomial equations in subsequent calls.

Support for Unicode characters in MuPAD that includes using Asian language characters in strings and text

The toolbox provides support for Unicode® characters in MuPAD (including messages to print or display), variable names, file names, and external file content.

Compatibility Considerations

In previous releases, the MuPAD `strmatch` function used `[^[]` to match any characters excluding `[`. For example, the command `strmatch("a[b", "[^[]", All)` returned ```{"a", "b"}```.

Now, use `[^\\[]` to match any characters excluding `[`. Thus, rewrite the example as follows: ```strmatch("a[b", "[^\\[]", All)```.

`strmatch` requires the same change for the closing parenthesis `]`.

Support for specifying encoding in MuPAD file operations

The MuPAD functions for file operations, such as `finput`, `fopen`, `fprint`, `read`, `write` and more, accept the option `Encoding`. This option lets you specify the following values for encoding.

 `Big5` `ISO-8859-1` `windows-932` `EUC-JP` `ISO-8859-2` `windows-936` `GBK` `ISO-8859-3` `windows-949` `KSC_5601` `ISO-8859-4` `windows-950` `Macintosh` `ISO-8859-9` `windows-1250` `Shift_JIS` `ISO-8859-13` `windows-1251` `US-ASCII` `ISO-8859-15` `windows-1252` `UTF-8` `windows-1253` `windows-1254` `windows-1257`

Choice of right- or left-handed spherical coordinate system for the MuPAD vector analysis functions

The MuPAD vector analysis functions `curl`, `divergence`, `gradient`, `laplacian`, and `linalg::ogCoordTab` let you choose between right- and left-handed spherical coordinate systems. By default, these functions use the right-handed coordinate system with `[radial, polar, azimuthal]` coordinates. To switch to `[radial, azimuthal, polar]` coordinates, specify `Spherical[LeftHanded]`.

Compatibility Considerations

In previous releases, the MuPAD vector analysis functions used the left-handed spherical coordinate system. To get the same results as in previous releases, use `'Spherical[LeftHanded]'`. To use the right-handed spherical coordinate system and suppress the warning, use `'Spherical[RightHanded]'`.

MATLAB special functions and functions for computing integral and Z-transforms accept several nonscalar arguments

The following MATLAB symbolic functions now accept more than one nonscalar argument:

MATLAB function `erfc` accepts two arguments

The MATLAB symbolic `erfc` function with one input argument represents the complementary error function. `erfc` with two input arguments represents the iterated integrals of the complementary error function, `erfc(k,x) = int(erfc(k - 1, y), y, x, inf)`.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
MuPAD `linalg::curl`Still runs`curl`Replace all instances of `linalg::curl` with `curl`.
MuPAD `linalg::det`Still runs`det`Replace all instances of `linalg::det` with `det`.
MuPAD `linalg::divergence`Still runs`divergence`Replace all instances of `linalg::divergence` with `divergence`.
MuPAD `linalg::grad`Still runs`gradient`Replace all instances of `linalg::grad` with `gradient`.
MuPAD `linalg::gradient`Still runs`gradient`Replace all instances of `linalg::gradient` with `gradient`.
MuPAD `linalg::hessian`Still runs`hessian`Replace all instances of `linalg::hessian` with `hessian`.
MuPAD `linalg::jacobian`Still runs`jacobian`Replace all instances of `linalg::jacobian` with `jacobian`.
MuPAD `linalg::laplacian`Still runs`laplacian`Replace all instances of `linalg::laplacian` with `laplacian`.
MuPAD `linalg::potential`Still runs`potential`Replace all instances of `linalg::potential` with `potential`.
MuPAD `linalg::vectorPotential`Still runs`vectorPotential`Replace all instances of `linalg::vectorPotential` with `vectorPotential`.
`simple`Warns`simplify`Replace all instances of `simple(S)` with `simplify``(S)`. There is no replacement for `[r, how] = simple(S)`.
`emlBlock`Errors`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.

R2013b

New Features, Bug Fixes, Compatibility Considerations

MATLAB `evaluateMuPADNotebook` and `allMuPADNotebooks` functions to evaluate MuPAD notebooks and return list of open notebooks

The MATLAB symbolic `evaluateMuPADNotebook` function lets you evaluate a MuPAD notebook from MATLAB without leaving the MATLAB Command Window or MATLAB Editor. You also can interrupt an evaluation of a MuPAD notebook from MATLAB.

The MATLAB symbolic `allMuPADNotebooks` function identifies all currently open notebooks and returns a vector of handles to them. You can use this vector to evaluate all or some of the notebooks or close them. If you already created a MuPAD notebook without a handle or if you lost the handle to a notebook, `allMuPADNotebooks` helps you create a new handle without saving the notebook.

`bernstein` function for approximating functions using Bernstein polynomials, and `bernsteinMatrix` function for computing Bezier curves

The MATLAB symbolic `bernstein` function and the MuPAD `bernstein` function approximate symbolic expressions and functions by Bernstein polynomials. The MATLAB symbolic `bernsteinMatrix` function and the MuPAD `bernsteinMatrix` function serve for constructing Bezier curves.

MATLAB `cumsum` and `cumprod` functions for computing cumulative sums and products

The MATLAB symbolic `cumsum` and `cumprod` functions return cumulative sums and products of elements of symbolic vectors and matrices.

MATLAB `isfinite`, `isinf`, and `isnan` functions for testing for finite, infinite, and `NaN` elements in symbolic arrays

The MATLAB symbolic `isfinite`, `isinf`, and `isnan` functions test whether the elements of a symbolic array are finite, infinite, or `NaN`s.

`ExclusiveConditions` option that makes MuPAD `piecewise` function equivalent to an `if-elif-end_if` statement

The new `ExclusiveConditions` option of the MuPAD piecewise function fixes the order of branches in a piecewise expression. Thus, `piecewise` with `ExclusiveConditions` is almost equivalent to an `if-elif-end_if` statement, except that `piecewise` takes into account assumptions on identifiers. For example, if the condition in the first branch returns `TRUE`, then `piecewise` returns the expression from the first branch. If a true condition appears in any further branch, then `piecewise` returns the expression from that branch and removes all subsequent branches.

MATLAB `mupadNotebookTitle` function to find the window title of the MuPAD notebook

The MATLAB symbolic `mupadNotebookTitle` function returns a cell array containing the window title of the MuPAD notebook. This function lets you find the title of a particular notebook as well as all currently open notebooks.

MATLAB `close` function to close MuPAD notebooks from MATLAB

The MATLAB symbolic `close` function lets you close MuPAD notebooks without leaving the MATLAB Command Window. This function also accepts the `'force'` flag suppressing the dialog box that prompts you to save changes.

`diff` supports mixed derivatives

The MATLAB symbolic `diff` function lets you compute mixed derivatives in one function call. For example, `diff(S,x,y)` differentiates the expression `S` with respect to the variables `x`, and then differentiates the result with respect to the variable `y`.

`coeffs` function extracts coefficients of multivariate polynomials

The MATLAB symbolic `coeffs` function returns coefficients of multivariate polynomials. You can specify polynomial variables as a vector of these variables. If you do not specify the polynomial variables, then `coeffs` regards all symbolic variables found in the polynomial expression as polynomial variables.

`linspace`, `logspace`, and `compan` functions for symbolic objects

The MATLAB `linspace` and `logspace` functions, which generate linearly and logarithmically spaced vectors, and the `compan` function, which finds the companion matrix, now accept symbolic numbers, variables, expressions, and functions.

Indexing uses lists, vectors, and matrices of indices

The MuPAD `_index` function and its equivalent `[]` now accept lists, vectors, and matrices as indices.

MuPAD lets you set assumptions on matrices

The MuPAD `assume`, `assumeAlso`, `assuming`, and `assumingAlso` functions let you set assumptions on matrices.

`int`, `symprod`, and `symsum` let you specify lower and upper bounds as vectors

The MATLAB symbolic `int`, `symprod`, and `symsum` functions accept integration, summation, and product intervals specified by row and column vectors. For example, `int(expr,var,[a,b])`, ```int(expr,var,[a b])```, and `int(expr,var,[a;b])` are equivalent to `int(expr,var,a,b)`.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
`simple`Still runs`simplify`Replace all instances of `simple(S)` with `simplify``(S)`. There is no replacement for `[r, how] = simple(S)`.
`emlBlock`Warns`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.
`diff` and `int` methods for inputs of the `char` typeErrors`sym`Use the `sym` method instead.
MuPAD factoring functions `numlib::mpqs`, `numlib::pollard`, and `numlib::ecm`Errors`ifactor`Replace all instances of `numlib::mpqs`, `numlib::pollard`, and `numlib::ecm` with `ifactor`.
MuPAD `Dom::SparseMatrixF2` domainErrors`Dom::Matrix(Dom::IntegerMod(2))`Replace all instances of `Dom::SparseMatrixF2` with `Dom::Matrix`(`Dom::IntegerMod``(2)`).
MuPAD `userinfo`Errors`print`Use `print` instead of `userinfo`.
MuPAD `setuserinfo`Errors`prog::trace` or `debug` Try using `prog::trace` or `debug` instead of `setuserinfo`.

R2013a

New Features, Bug Fixes, Compatibility Considerations

Linear algebra functions for computing matrix factorizations (`lu`, `chol`), pseudoinverse, orthogonal basis, and adjoint

• `lu` computes the LU factorization of a matrix. Permutation information can be returned as a matrix or as a row vector.

• `chol` computes the Cholesky factorization of a matrix. The result can be returned as an upper or lower triangular matrix. Permutation information can be returned as a matrix or as a row vector.

• `pinv` computes the Moore-Penrose pseudoinverse of a matrix.

• `orth` computes an orthonormal basis for the range of a symbolic matrix.

• `adjoint` computes the adjoint of a symbolic square matrix.

Verification of solutions of systems of equations and arbitrary symbolic function substitution in `subs` function

The MATLAB symbolic `subs` function lets you:

• Verify solutions of systems of equations by substituting the solutions returned by `solve` back into the systems

• Substitute elements of a symbolic expression with arbitrary symbolic functions

Compatibility Considerations

`subs(s,old,new,0)` will not accept `0` in a future release. Replace all instances of `subs(s,old,new,0)` with `subs(s,old,new)`. The `subs` function does not switch `old` and `new` anymore.

`subs` does not return double-precision floating-point results anymore. Instead, it consistently returns symbolic results. To convert such results to double-precision numbers, use `double`.

Simplification for more types of trigonometric and hyperbolic expressions and expressions with nested roots

The MATLAB symbolic `simplify` function and the MuPAD `simplify` function achieve better simplification of trigonometric expressions and expressions with nested roots.

The MATLAB symbolic `simplify` function accepts the new `Criterion` option. This option lets you discourage `simplify` from returning results containing complex numbers.

The MuPAD `simplify` function accepts two new options:

• `Steps` specifies the number of internal simplification steps.

• `Seconds` limits the time allowed for the internal simplification process.

Compatibility Considerations

The default number of simplification steps used by the MATLAB symbolic `simplify` function and the MuPAD `simplify` function changed from `100` to `1`.

The `FinalValuation` option used in MuPAD `Simplify` function calls is renamed. The new name is `Criterion`.

Special functions for computing polar angle, `atan2` function, imaginary error function, and exponential and elliptic integrals

The following new MATLAB symbolic functions compute elliptic integrals:

`toeplitz` function for creating Toeplitz matrices

The new MATLAB symbolic `toeplitz` function generates a symbolic Toeplitz matrix from two vectors that specify its first column and first row. This function can also generate a symmetric Toeplitz matrix from one vector.

The MuPAD `linalg::toeplitz` function now generates a Toeplitz matrix from two vectors that specify its first column and first row. (In MuPAD, vectors are created as 1-by-n or n-by-1 matrices.) `linalg::toeplitz` accepts the new syntaxes along with the existing syntaxes.

`sqrtm` function for computing square roots of matrices

The MATLAB symbolic `sqrtm` function computes the square root of a symbolic matrix.

`sign` function for computing signs of numbers

The MATLAB symbolic `sign` function returns signs of symbolic real and complex values. The sign of a complex value `z` is defined as `z/abs(z)`.

`Real` option of the `linalg::orthog` function for avoiding complex conjugates

The MuPAD `linalg::orthog` function accepts the new `Real` option. This option lets you avoid using a complex scalar product in the orthogonalization process.

`Real` option of the `linalg::factorCholesky` function for avoiding complex conjugates

The MuPAD `linalg::factorCholesky` function accepts the new `Real` option. When you use this option, `linalg::factorCholesky` assumes that the input matrix is real and symmetric, and does not apply complex conjugation in the course of the algorithm.

Compatibility Considerations

`linalg::factorCholesky` can now compute the Cholesky factorization of a complex Hermitian positive definite matrix. In previous releases, `linalg::factorCholesky` required the input matrix to be symmetric even when working with complex entries. To get the same results as in previous releases for symmetric matrices, use the `Real` option.

New arguments of the `svd` function for computing the "economy size" singular value decomposition

`svd` accepts the new arguments `0` and `'econ'` that let you compute the "economy size" singular value decomposition of a matrix.

`isequaln` function for testing equality of symbolic objects

The MATLAB `isequaln` function tests symbolic objects for equality, treating `NaN` values as equal.

Control over the order in which `solve` and `vpasolve` functions return solutions

The MATLAB symbolic `solve` and `vpasolve` functions now let you control the order in which they return solutions. To ensure the order of the returned solutions, explicitly specify the independent (input) variables. For example, the syntax `[b,a] = solve(eqns,b,a)` guarantees the order of the returned solutions, while the syntax ```[b,a] = solve(eqns)``` does not.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
`simple`Still runs`simplify`Replace all instances of `simple(S)` with `simplify``(S)`. There is no replacement for `[r, how] = simple(S)`.
`emlBlock`Warns`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.
MuPAD factoring functions `numlib::mpqs`, `numlib::pollard`, and `numlib::ecm`Warns`ifactor`Replace all instances of `numlib::mpqs`, `numlib::pollard`, and `numlib::ecm` with `ifactor`.
MuPAD `Dom::SparseMatrixF2` domainWarns`Dom::Matrix(Dom::IntegerMod(2))`Replace all instances of `Dom::SparseMatrixF2` with `Dom::Matrix`(`Dom::IntegerMod``(2)`).
MuPAD `userinfo`Warns`print`Use `print` instead of `userinfo`.
MuPAD `setuserinfo`Warns`prog::trace` or `debug` Try using `prog::trace` or `debug` instead of `setuserinfo`.
`poly`Errors`charpoly`Replace all instances of `poly` with `charpoly`.
`sqrt` target of the MuPAD `simplify` functionErrorsMuPAD `radsimp` or `simplifyRadical`Replace all instances of `simplify` function calls involving the `sqrt` target with `radsimp` or `simplifyRadical`. Alternatively, replace these calls with `simplify` function calls without targets.
`cos`, `sin`, `exp`, and `ln` targets of the MuPAD `simplify` function ErrorsMuPAD `simplify` without targets Replace all instances of `simplify` function calls involving these targets with `simplify` function calls without targets. This can lead to a better simplification for some expressions.
MuPAD `transform::fourier`ErrorsMuPAD `fourier`Replace all instances of `transform::fourier` with `fourier`.
MuPAD `transform::invfourier`ErrorsMuPAD `ifourier`Replace all instances of `transform::invfourier` with `ifourier`.
MuPAD `transform::laplace`ErrorsMuPAD `laplace`Replace all instances of `transform::laplace` with `laplace`.
MuPAD `transform::invlaplace`ErrorsMuPAD `ilaplace`Replace all instances of `transform::invlaplace` with `ilaplace`.
MuPAD `transform::ztrans`ErrorsMuPAD `ztrans`Replace all instances of `transform::ztrans` with `ztrans`.
MuPAD `transform::invztrans`ErrorsMuPAD `iztrans`Replace all instances of `transform::invztrans` with `iztrans`.
MuPAD `transform::fourier::addpattern`ErrorsMuPAD `fourier::addpattern`Replace all instances of `transform::fourier::addpattern` with `fourier::addpattern`.
MuPAD `transform::invfourier::addpattern`ErrorsMuPAD `ifourier::addpattern`Replace all instances of `transform::invfourier::addpattern` with `ifourier::addpattern`.
MuPAD `transform::laplace::addpattern`ErrorsMuPAD `laplace::addpattern`Replace all instances of `transform::laplace::addpattern` with `laplace::addpattern`.
MuPAD `transform::invlaplace::addpattern`ErrorsMuPAD `ilaplace::addpattern`Replace all instances of `transform::invlaplace::addpattern` with `ilaplace::addpattern`.
MuPAD `transform::ztrans::addpattern`ErrorsMuPAD `ztrans::addpattern`Replace all instances of `transform::ztrans::addpattern` with `ztrans::addpattern`.
MuPAD `transform::invztrans::addpattern`ErrorsMuPAD `iztrans::addpattern`Replace all instances of `transform::invztrans::addpattern` with `iztrans::addpattern`.
MuPAD `prog::calledFrom`Errors`context(hold(procname))`Replace all instances of `prog::calledFrom()` with `context`(`hold``(procname)`).
MuPAD `prog::calltree`Errors`prog::trace`Use `prog::trace` instead of `prog::calltree`.
MuPAD `prog::error`Errors`getlasterror`Use `getlasterror` instead of `prog::error`.
MuPAD `prog::memuse`Errors`prog::trace(Mem)`or `bytes()` Use `prog::trace``(Mem)` or `bytes``()` instead of `prog::memuse`.
MuPAD `prog::testfunc`Errors`print(Unquoted, "...")` Use `print````(Unquoted, "...")``` instead of `prog::testfunc`.
MuPAD `prog::testmethod`Errors`prog::test(..., Method = myTestMethod)`Use `prog::test````(..., Method = myTestMethod)``` instead of `prog::testmethod`.
MuPAD `prog::testnum`ErrorsNothingNo replacement
Dynamic modules for MuPAD, including the `module`, `external`, and `Pref::unloadableModules` functions and all functions of the `module` libraryErrorsNothingNo replacement

R2012b

New Features, Bug Fixes, Compatibility Considerations

MATLAB symbolic matrix analysis functions for characteristic (`charpoly`) and minimal (`minpoly`) polynomials and for norm (`norm`) and condition (`cond`) number

`charpoly` computes the characteristic polynomial of a matrix.

`minpoly` computes the minimal polynomial of a matrix.

`norm` computes the 2-norm (default), 1-norm, Frobenius norm, and infinity norm of a symbolic matrix. It also computes the P-norm, Frobenius norm, infinity norm, and negative infinity norm of a symbolic vector.

`cond` computes the corresponding condition numbers of a matrix.

`poles` function for determining the poles of an expression

The MATLAB `poles` function determines the poles of a symbolic expression or function. The `poles` function is also implemented in MuPAD.

`vpasolve` function for solving equations and systems using variable precision arithmetic

The MATLAB `vpasolve` function solves equations and systems of equations numerically.

Functions for converting linear systems of equations to matrix form AX=B (`equationsToMatrix`) and solving matrix equations (`linsolve`)

The MATLAB `equationsToMatrix` function converts a linear system of equations to the matrix form ```AX = B```. The function returns the coefficient matrix `A` and the vector `B` that contains the right sides of the equations.

The MATLAB `linsolve` function solves linear systems of equations represented in the matrix form ```AX = B```. The function also returns the reciprocal of the condition number of the square coefficient matrix `A`. If `A` is rectangular, `linsolve` returns the rank of `A`.

MATLAB symbolic functions for describing pulses: `rectangularPulse` and `triangularPulse`

`rectangularPulse` and `triangularPulse` compute the rectangular and triangular pulse functions, respectively.

In MuPAD, the new `rectangularPulse` and `triangularPulse` functions are equivalent to `rectpulse` and `tripulse`, respectively.

MuPAD functions for computing integral and Z-transforms

These new MuPAD functions compute integral and Z-transforms:

MuPAD `Pref::fourierParameters` function for specifying Fourier parameters

The MuPAD `Pref::fourierParameters` function lets you specify parameters for Fourier and inverse Fourier transforms.

MuPAD does not save custom patterns permanently. The new patterns are available in the current MuPAD session only.

`noFlatten` option of the MuPAD `proc` function for preventing sequence flattening

The MuPAD `proc` function accepts the new `noFlatten` option. This option prevents flattening of sequences passed as arguments of the procedure.

`testtype` uses `testtypeDom` slot for overloading by the second argument

If in the call `testtype(object, T)` the argument `T` is a domain, then the method `testtypeDom` of `T` is called with the arguments `object, T`. If `T` is not a domain, then the method `testtypeDom` of `T::dom` is called with the arguments `object, T`.

Compatibility Considerations

In previous releases, `testtype` used the `testtype` slot for overloading by the second argument.

New upper limit on the number of digits in `double`

By default, the working precision for `double` is now limited to at most by 664 digits. You can explicitly specify a larger precision using `digits`.

Compatibility Considerations

Some results returned by `double` can differ from previous releases. For example, in previous releases `double` approximated the expression

`x = sym('400!*((exp(2000)+1)/(exp(2000) - 1) - 1)')`

by 3.2997. Now it approximates this expression by 0.

To get the same result as in previous releases, increase the precision of computations:

```digits(1000) double(x)```
```ans = 3.2997```

New definition for `real` and `imag`

Starting in R2012a, `real` and `imag` are no longer defined via `conj`. They use the MuPAD `Re` and `Im` functions instead.

Compatibility Considerations

In R2011b and earlier, `real` and `imag` are defined via the `conj` function:

```syms z real(z) imag(z)```
```ans = z/2 + conj(z)/2 ans = - (z*i)/2 + (conj(z)*i)/2```

Therefore, `real` and `imag` can return results in a different form. Results returned by `real` and `imag` now are mathematically equivalent to the results returned in previous releases.

Functionality being removed or changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
Old syntax of `taylor`ErrorsNew calling syntaxUpdate all instances of `taylor` function calls using the new syntax.
`char(A,d)`Errors`char(A)`Replace all instances of `char(A,d)` with `char``(A)`.
`poly`Warns`charpoly`Replace all instances of `poly` with `charpoly`.
`emlBlock`Warns`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.
`openmuphlp`ErrorsNothingNo replacement
MuPAD Help BrowserNot availableDocumentation CenterMuPAD documentation is now available in Documentation Center.
MuPAD EditorNot availableMATLAB EditorOpen and edit MuPAD program files (`.mu` files) in the MATLAB Editor. The MATLAB Editor supports syntax highlighting and smart indenting for these files.
`psi(k0:k1,X)`Errors`psi(k,X)`, where `k` is a scalar specifying the `k`th derivative of `psi` at the elements of `X`.Replace all instances of `psi(k0:k1,X)` with `psi``(k,X)`, where `k` is a scalar. To modify your code, loop through the values `k0:k1`. For example:
```for k = k0:k1 Y(:,k) = psi(k,X); end ```
In a future release, `size(Y)` will be `size(X)`. Modify any code that depends on `size(Y)`.
`diff` and `int` methods for inputs of the `char` typeErrors`sym`Use the `sym` method instead.
`sqrt` target of the MuPAD `simplify` functionErrorsMuPAD `radsimp` or `simplifyRadical`Replace all instances of `simplify` function calls involving the `sqrt` target with `radsimp` or `simplifyRadical`. Alternatively, replace these calls with `simplify` function calls without targets.
`cos`, `sin`, `exp`, and `ln` targets of the MuPAD `simplify` function ErrorsMuPAD `simplify` without targets Replace all instances of `simplify` function calls involving these targets with `simplify` function calls without targets. This can lead to a better simplification for some expressions.
MuPAD `transform::fourier`WarnsMuPAD `fourier`Replace all instances of `transform::fourier` with `fourier`.
MuPAD `transform::invfourier`WarnsMuPAD `ifourier`Replace all instances of `transform::invfourier` with `ifourier`.
MuPAD `transform::laplace`WarnsMuPAD `laplace`Replace all instances of `transform::laplace` with `laplace`.
MuPAD `transform::invlaplace`WarnsMuPAD `ilaplace`Replace all instances of `transform::invlaplace` with `ilaplace`.
MuPAD `transform::ztrans`WarnsMuPAD `ztrans`Replace all instances of `transform::ztrans` with `ztrans`.
MuPAD `transform::invztrans`WarnsMuPAD `iztrans`Replace all instances of `transform::invztrans` with `iztrans`.
MuPAD `transform::fourier::addpattern`WarnsMuPAD `fourier::addpattern`Replace all instances of `transform::fourier::addpattern` with `fourier::addpattern`.
MuPAD `transform::invfourier::addpattern`WarnsMuPAD `ifourier::addpattern`Replace all instances of `transform::invfourier::addpattern` with `ifourier::addpattern`.
MuPAD `transform::laplace::addpattern`WarnsMuPAD `laplace::addpattern`Replace all instances of `transform::laplace::addpattern` with `laplace::addpattern`.
MuPAD `transform::invlaplace::addpattern`WarnsMuPAD `ilaplace::addpattern`Replace all instances of `transform::invlaplace::addpattern` with `ilaplace::addpattern`.
MuPAD `transform::ztrans::addpattern`WarnsMuPAD `ztrans::addpattern`Replace all instances of `transform::ztrans::addpattern` with `ztrans::addpattern`.
MuPAD `transform::invztrans::addpattern`WarnsMuPAD `iztrans::addpattern`Replace all instances of `transform::invztrans::addpattern` with `iztrans::addpattern`.
MuPAD `prog::calledFrom`Warns`context(hold(procname))`Replace all instances of `prog::calledFrom()` with `context`(`hold``(procname)`).
MuPAD `prog::calltree`Warns`prog::trace`Use `prog::trace` instead of `prog::calltree`.
MuPAD `prog::error`Warns`getlasterror`Use `getlasterror` instead of `prog::error`.
MuPAD `prog::memuse`Warns`prog::trace(Mem)`or `bytes()` Use `prog::trace``(Mem)` or `bytes``()` instead of `prog::memuse`.
MuPAD `prog::testfunc`Warns`print(Unquoted, "...")` Use `print````(Unquoted, "...")``` instead of `prog::testfunc`.
MuPAD `prog::testmethod`Warns`prog::test(..., Method = myTestMethod)`Use `prog::test````(..., Method = myTestMethod)``` instead of `prog::testmethod`.
MuPAD `prog::testnum`WarnsNothingNo replacement
Dynamic modules for MuPAD, including the `module`, `external`, and `Pref::unloadableModules` functions and all functions of the `module` libraryWarnsNothingNo replacement

R2012a

New Features, Bug Fixes, Compatibility Considerations

New Special Functions

The following special functions are available:

New Vector Analysis Functions

The following vector analysis functions are available:

Computations with Symbolic Functions

The toolbox lets you create symbolic functions. For details, see Creating Symbolic Functions.

`dsolve`, `ezplot`, the new `odeToVectorField` function, and other Symbolic Math Toolbox functions now support computations with symbolic functions.

The toolbox also provides the following functions to support common operations on symbolic functions:

Assumptions on Variables

You can set assumptions on symbolic variables by using these functions:

New Relational Operators Create Equations, Inequalities, and Relations

Use these relational operators to create symbolic equations, inequalities, and relations:

• `==` and its functional form `eq` create a symbolic equation. You can solve these equations using `solve` or `dsolve`, plot them using `ezplot`, set assumptions using `assume` or `assumeAlso`, or use them in logical expressions.

• `~=` and its functional form `ne` create a symbolic inequality. You can use inequalities in assumptions and logical expressions.

• `>`, `>=`, `<`, `<=`, and their functional forms `ge`, `gt`, `le`, and `lt` create symbolic relations. You can use relations in assumptions and logical expressions.

Compatibility Considerations

In previous releases, `eq` evaluated equations and returned logical 1 or 0. Now it returns unevaluated equations letting you create equations that you can pass to `solve`, `assume`, and other functions. To obtain the same results as in previous releases, wrap equations in `logical` or `isAlways`. For example, use `logical(A == B)`.

New Logical Operators Create Logical Expressions

Use these logical operations let you create logical expressions with symbolic subexpressions:

• `&` or its functional form `and` defines the logical conjunction (the logical AND) for symbolic expressions.

• `|` or its functional form `or` defines the logical disjunction (the logical OR) for symbolic expressions.

• `~` or its functional form `not` defines the logical negation (the logical NOT) for symbolic expressions.

• `xor` defines the logical exclusive disjunction (the logical XOR) for symbolic expressions.

If logical expressions are elements of a symbolic array, you can use these new functions to test the logical expressions:

• `all` tests whether all equations and inequalities represented as elements of a symbolic array are valid.

• `any` tests whether at least one of equations and inequalities represented as elements of a symbolic array is valid.

New Functions Test Validity of Symbolic Equations, Inequalities, and Relations

Use these functions to test symbolic equations, inequalities, and relations, including logical statements:

• `isAlways` checks whether an equation, inequality, or relation holds for all values of its variables.

• `logical` checks the validity of an equation, inequality, or relation. This function does not simplify or mathematically transform expressions that form an equation, inequality, or relation. It also typically ignores assumptions on variables.

New Functions Manipulate Symbolic Expressions

These functions provide more flexible options for manipulating symbolic expressions:

• The `rewrite` function rewrites expressions in terms of target functions. It returns a mathematically equivalent form of an expression using the specified target functions. For example, it can rewrite trigonometric expressions using the exponential function.

• `children` returns child subexpressions, or terms, of a symbolic expression.

New odeToVectorField Function Converts Higher-Order Differential Equations to Systems of First-Order Differential Equations

`odeToVectorField` converts second- and higher-order differential equations to systems of first-order differential equations. It returns a symbolic vector representing the resulting system of first-order differential equations. With `matlabFunction` you can generate a MATLAB function from this vector, and then use it as an input for the MATLAB numerical solvers `ode23` and `ode45`.

In MuPAD, the new `numeric::odeToVectorField` function is equivalent to `numeric::ode2vectorfield`.

New Calling Syntax for the taylor Function

The `taylor` function that computes the Taylor series expansions has a new syntax and set of options.

Compatibility Considerations

The new syntax is not valid before Version 5.8. The old syntax is still supported, but will be removed in a future release. To update existing code that relies on the old syntax, make the following changes to the `taylor` function calls:

• Specify the truncation order using the name-value pair argument `Order`.

• Specify the expansion point using the name-value pair argument `ExpansionPoint`.

Alternatively, specify the expansion point as a third input argument. In this case, you must also specify the independent variable or the vector of variables as the second input argument.

For details and examples, see `taylor`.

New MuPAD Functions Compute Rectangular and Triangular Pulse Functions

The MuPAD `rectpulse` and `tripulse` functions compute the rectangular and triangular pulse functions, respectively.

MuPAD det, linalg::det, inverse, linsolve, and linalg::matlinsolve Functions Accept the New Normal Option

The MuPAD `det`, `linalg::det`, `inverse`, `linsolve`, and `linalg::matlinsolve` functions accept the new `Normal` option that guarantees normalization of the returned results. The `_invert` methods of the MuPAD `Dom::Matrix(R)` and `Dom::DenseMatrix(R)` domains also accept `Normal`.

MuPAD linalg::matlinsolve Function Accepts the New ShowAssumptions Option

The MuPAD `linalg::matlinsolve` function accepts the new `ShowAssumptions` option. This option lets you see internal assumptions on symbolic parameters that `linalg::matlinsolve` makes while solving a system of equations.

Enhanced MuPAD `pdivide` function now performs pseudo-division of multivariate polynomials.

Improved MuPAD `prog::remember` function, which lets you use the remember mechanism in procedures streamlines such processes as debugging, profiling, and argument checking.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
Old syntax of `taylor`WarnsNew syntaxUpdate all instances of `taylor` function calls using the new syntax.
Default number of simplification steps in `simplify` has changed from 50 to 100.Uses the new default setting`simplify(S,'Steps',50)`To terminate algebraic simplification after 50 steps, call `simplify` with the name-value pair argument `'Steps', 50`.
`char(A,d)`Warns`char(A)`Replace all instances of `char(A,d)` with `char(A)`.
`emlBlock`Warns`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.
`psi(k0:k1,X)`Warns`psi(k,X)` where `k` is a scalar specifying the `k`th derivative of `psi` at the elements of `X`.Replace all instances of `psi(k0:k1,X)` with `psi(k,X)`, where `k` is a scalar. To modify your code, loop through the values `k0:k1`. For example:
```for k = k0:k1 Y(:,k) = psi(k,X); end ```
In the future, `size(Y)` will be `size(X)`. Modify any code that depends on `size(Y)`.
`sqrt` target of the MuPAD `simplify` functionWarnsMuPAD `radsimp` or `simplifyRadical`Replace all instances of `simplify` function calls involving the `sqrt` target with `radsimp` or `simplifyRadical`. Alternatively, replace these calls with `simplify` function calls without targets.
`cos`, `sin`, `exp`, and `ln` targets of the MuPAD `simplify` function WarnsMuPAD `simplify` without targets Replace all instances of `simplify` function calls involving these targets with `simplify` function calls without targets. This can lead to a better simplification for some expressions.
MuPAD `frame` functionErrorsNothingNo replacement

R2011b

New Features, Bug Fixes, Compatibility Considerations

MATLAB Editor Now Supports MuPAD Program Files

You can open and edit MuPAD program files (`.mu` files) in the MATLAB Editor. MATLAB Editor supports syntax highlighting and smart indenting for these files.

dsolve, expand, int, simple, simplify, and solve Accept More Options

`dsolve` now accepts the `IgnoreAnalyticConstraints` and `MaxDegree` options.

`expand` now accepts the `ArithmeticOnly` and `IgnoreAnalyticConstraints` options.

`int` now accepts the `IgnoreAnalyticConstraints`, `IgnoreSpecialCases`, and `PrincipalValue` options.

`simple` now accepts the `IgnoreAnalyticConstraints` option.

`simplify` now accepts the `IgnoreAnalyticConstraints`, `Seconds`, and `Steps` options.

`solve` now accepts the `IgnoreAnalyticConstraints`, `IgnoreProperties`, `MaxDegree`, `PrincipalValue`, and `Real` options.

`read` simplifies using your own MuPAD procedures in MATLAB. See Before Calling a Procedure for details.

New symprod Function Computes Products of Series

`symprod` computes definite and indefinite products of symbolic series.

New hessian Function Computes Hessian Matrices

`hessian` computes the Hessian matrix of a scalar function.

`gradient` computes the vector gradient of a scalar function in Cartesian coordinates. In MuPAD, the new `linalg::gradient` function is equivalent to `linalg::grad`.

New erfc Function Computes the Complementary Error Function

`erfc` computes the complementary error function.

New psi Function Computes the Digamma and Polygamma Functions

`psi` computes the digamma and polygamma functions.

New wrightOmega Function Computes the Wright omega Function

`wrightOmega` computes the Wright omega function.

New simplifyFraction Function Simplifies Expressions

`simplifyFraction` returns a simplified form of a fraction where both numerator and denominator are polynomials and their greatest common divisor is 1. In MuPAD, the new `simplifyFraction` function is equivalent to `normal`.

The new MuPAD `simplifyRadical` function is equivalent to the MuPAD `radsimp` function.

pretty Function Now Uses Abbreviations in Long Output Expressions for Better Readability

`pretty` uses abbreviations when presenting symbolic results in the MATLAB Command Window. This new format of presenting symbolic results enhances readability of long output expressions.

MuPAD normal Function Accepts the New Expand Option

The MuPAD `normal` function accepts the new `Expand` option that determines whether numerators and denominators of fractions are expanded.

Compatibility Considerations

In previous releases, `normal` returned a fraction with the expanded numerator and denominator by default. Now the default setting is that `normal` can return factored expressions in numerators and denominators. In explicit calls to `normal`, you can use the `Expand` option to get the same behavior as in previous releases.

If a function calls `normal` internally, then that function can return its results in a different form. These new results are mathematically equivalent to the results that you get in previous releases. Many MuPAD library functions can call `normal`.

All functions of the MuPAD `groebner` library now can accept and return polynomials with arbitrary arithmetical expressions.

MuPAD groebner::gbasis Function Accepts the New Factor and IgnoreSpecialCases Options

With the `Factor` option, `groebner::gbasis` returns a set of lists, such that:

• Each list is the Groebner basis of an ideal.

• The union of these ideals is a superset of the ideal given as input, and a subset of the radical of that ideal.

With the `IgnoreSpecialCases` option, `groebner::gbasis` handles all coefficients in all intermediate results as nonzero unless these coefficients are equal to 0 for all parameter values.

New MuPAD Functions for Computing Logarithms

The new MuPAD `log2` and `log10` functions compute logarithms to the bases 2 and 10, respectively. Also, in MuPAD `log(x)` is now an alias for `ln(x)`.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use It?Use This InsteadCompatibility Considerations
`emlBlock`Warns`matlabFunctionBlock`Replace all instances of `emlBlock` with `matlabFunctionBlock`.
`Real` and `IgnoreProperties` options in MuPAD `ode::solve`Warns`IgnoreSpecialCases` or `IgnoreAnalyticConstraints`Try using `IgnoreSpecialCases` or `IgnoreAnalyticConstraints` instead.

R2011a

New Features, Bug Fixes, Compatibility Considerations

Expression Wrapping of Math Output in the MuPAD Notebook Interface

The new default format of presenting results enhances readability by wrapping long output expressions, including long numbers, fractions and matrices.

Symbolic Solver Handles More Non-Algebraic Equations

The enhanced `rationalize` function in MuPAD helps the symbolic solver to handle more systems of non-algebraic equations. In particular, this improvement enables the toolbox to solve more systems of trigonometric equations.

Improved Performance in the Ordinary Differential Equation Solver

The ordinary differential equation solver demonstrates better performance.

Improved Performance for Polynomial Arithmetic Operations

The MuPAD functions `gcdex`, `partfrac`, `polylib::resultant`, and `solvelib::pdioe` now demonstrate better performance.

New MuPAD polylib::subresultant Function Computes Subresultants of Polynomials

`polylib::subresultant` computes subresultants of two polynomials or polynomial expressions.

MuPAD partfrac Function Accepts the New List Option

With the new `List` option, `partfrac` returns a list consisting of the numerators and denominators of the partial fraction decomposition.

New MuPAD inverf and inverfc Functions Compute the Inverses of Error Functions

The `inverf` function computes the inverse of the error function.

The `inverfc` function computes the inverse of the complementary error function.

New MuPAD numlib::checkPrimalityCertificate Function Tests Primality Certificates

`numlib::checkPrimalityCertificate` tests primality certificates returned by `numlib::proveprime`. For information about proving primality of numbers, see "Proving Primality" in the MuPAD documentation.

New Demos

There are three new demos that show how to solve equations and compute derivatives and integrals:

To run the new demos, enter `symeqndemo`, `symdiffdemo`, or `symintdemo` in the MATLAB Command Window.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use This Functionality?Use This InsteadCompatibility Considerations
MuPAD `matchlib::analyze`ErrorsMuPAD `prog::exprtree`To visualize expressions, use` prog::exprtree`.
MuPAD `prog::testcall`ErrorsNothingNo replacement
MuPAD `prog::testerrors`ErrorsNothingNo replacement
Old syntax of MuPAD `prog::getOptions`ErrorsThe new syntaxUpdate all instances of `prog::getOptions` calls using the new syntax.
Old syntax of MuPAD `prog::trace`ErrorsThe new syntaxUpdate all instances of `prog::trace` calls using the new syntax.

R2010b

New Features, Bug Fixes, Compatibility Considerations

sym Function Creates Matrices of Symbolic Variables

The `sym` function now provides a shortcut for creating vectors and matrices of symbolic variables.

generate::Simscape Function Generates Simscape Equations from MuPAD Expressions

The new MuPAD function `generate::Simscape` converts MuPAD expressions to Simscape equations.

MuPAD Code Generation Functions Accept the New NoWarning Option

MuPAD functions `generate::C`, `generate::fortran`, `generate::MATLAB`, and `generate::Simscape` accept the new `NoWarning` option. The option suppresses all warnings issued by these functions.

MuPAD Notebook Highlights Matched and Unmatched Delimiters

MuPAD Notebook now can notify you about matched and unmatched delimiters such as parentheses, brackets, and braces.

Improved Performance When Solving Linear Systems in a Matrix Form

MuPAD `linalg::matlinsolve` function, which solves linear systems of equations in a matrix form, demonstrates better performance.

MuPAD Solver for Ordinary Differential Equations Handles More Equation Types

Enhanced MuPAD solver handles more first-order nonlinear and third-order linear ordinary differential equations. The solver demonstrates improved performance.

New Syntax for the MuPAD prog::getOptions Function

The `prog::getOptions` function that collects and verifies options within a procedure has the new syntax.

Compatibility Considerations

The new syntax is not valid in MuPAD versions earlier than 5.5. The old syntax is supported in MuPAD 5.5, but will be removed in a future release.

New Syntax for the MuPAD prog::trace Function

The `prog::trace` function used for debugging has the new syntax. The function observes entering and exiting the MuPAD functions.

Compatibility Considerations

The new syntax is not valid in MuPAD versions earlier than 5.5. The old syntax is not supported in MuPAD 5.5.

Improved Interface for Arithmetical Operations on Polynomials

Improved interface for arithmetical operations between polynomials and arithmetical expressions. In previous releases, to perform an arithmetical operation on a polynomial and an arithmetical expression, you must explicitly convert that expression to a polynomials of the corresponding type. Now, when you operate on a polynomial and an arithmetical expression, MuPAD internally converts the arithmetical expression to a polynomial and performs the calculation.

MuPAD igcd Function Now Accepts Complex Numbers as Arguments

The MuPAD `igcd` function, which computes the greatest common divisor of integers, now accepts complex numbers. Both real and imaginary parts of accepted complex numbers must be integers or arithmetic expressions that represent integers.

Enhanced Solver For Factorable Polynomial Systems

The MuPAD `solve` function performs better on factorable polynomial systems.

MuPAD Now Evaluates Large Sums with Subtractions Faster

MuPAD performs evaluations of large sums that contain subtractions faster than in previous releases.

Compatibility Considerations

In MuPAD, the difference operator (–) no longer invokes the `_subtract` function. Instead, it invokes the `_plus` and `_negate` functions. For example, `a - b` is equivalent to ```_plus(a, _negate(b))```.

MuPAD freeIndets Function Accepts the New All Option

The `freeIndets` function accepts the new `All` option. With this option, `freeIndets` does not exclude the 0th operand from the list of free identifiers.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use This Functionality?Use This InsteadCompatibility Considerations
`diff` and `int` methods for inputs of the `char` typeWarns`sym`Use the `sym` method instead.
MuPAD `matchlib::analyze`WarnsMuPAD `prog::exprtree`To visualize expressions, use` prog::exprtree`.
MuPAD `prog::testcall`WarnsNoneNo replacement
MuPAD `prog::testerrors`WarnsNoneNo replacement
The following options in MuPAD `prog::trace`:
• `All`

• `Backup`

• `Force`

• `Name`

• `Proc`

• `Plain`

• `Width`

ErrorsNoneNo replacement. These options are not supported in the current release.
Global properties in MuPADErrorsAssumptions on each variableMake assumptions on each variable instead.

R2010a

New Features, Bug Fixes, Compatibility Considerations

The `mupad` command that opens a MuPAD notebook now supports references to particular places inside a notebook. You can create a link target inside a notebook and refer to it when opening a notebook.

simscapeEquation Function Generates Simscape Equations from Symbolic Expressions

The new `simscapeEquation` command represents symbolic expressions in the form of Simscape equations. For more information, see Generating Simscape Equations in the Symbolic Math Toolbox documentation.

New Calling Syntax for the sort Function

The `sort` function that sorts the element of symbolic arrays and polynomials has the new syntax and set of options.

Compatibility Considerations

In previous releases, the `sort` function flattened symbolic matrices to vectors before sorting the elements. Now the `sort` function sorts the elements of each column or each row of a symbolic matrix. If you want to obtain the same results as in the previous release, flatten the symbolic matrix before sorting it: `sort(A(:))`.

Changes in the symengine Function

The toolbox no longer supports the ability to choose an alternative symbolic engine.

64-Bit GUI Support for Macintosh

MuPAD now supports 64-bit graphical user interfaces (such as notebooks and Editor and Debugger windows) for a 64-bit Macintosh operating system.

Adjusting MuPAD documents for printing is easier with the new Print Preview dialog. You can view one or several pages, zoom in and out, switch between page orientations, adjust the page settings without closing the dialog, and print the page or save it to PDF format

Specifying the default settings for graphical user interfaces, such as notebooks and Editor and Debugger windows, has become easier with the improved configuration dialog box.

MuPAD Support for Basic Arithmetic Operations for Lists

Basic arithmetic operations now work for lists.

Improved Performance When Operating on Matrices with Symbolic Elements

MuPAD demonstrates better performance when handling some linear algebra operations on matrices containing symbolic elements.

Enhanced MuPAD `divide` function computes the quotient and remainder for division of multivariate polynomials.

Improved Performance for Operations on Polynomials

Improved performance for conversions involving polynomials. Improved performance for operations on polynomials including evaluation, multiplication, and division.

Compatibility Considerations

If the coefficients of a polynomial contain the variables of the polynomial itself, the form of results returned by the MuPAD `poly` function can differ from previous releases. In previous releases, the `poly` function converted such coefficients to monomials. Now the `poly` function can return the coefficients of the original expression as coefficients in the resulting polynomial. To get the same behavior as in previous releases, use`expr` to convert an original polynomial into an expression, and then call the `poly` function. For example, the following call exercises the old behavior: ```poly(expr(p), [y, x])```.

MuPAD coeff Function Accepts the New All Option

The `coeff` function accepts the new`All` option. With this option, `coeff` returns all coefficients of a polynomial including those equal to 0.

MuPAD expand Function Accepts the New ArithmeticOnly Option

The `expand` function accepts the new `ArithmeticOnly` option. The option allows you to expand a sum without expanding trigonometric expressions and special functions in its terms. Technically, the option omits overloading the `expand` function for each term of the original expression.

MuPAD expand Function Now Expands Powers of Products

The `expand` function now expands powers of products such as (xy)n for positive x and y. When called with the `IgnoreAnalyticConstraints` option , the function expands the power of products for arbitrary terms.

New Calling Syntax for MuPAD rationalize Function

The `rationalize` function that transforms an arbitrary expression into a rational expression has the new syntax and set of options.

Compatibility Considerations

The new syntax is not valid in MuPAD versions earlier than 5.4. The old syntax is supported in MuPAD 5.4, but will be removed in a future release.

Enhanced MuPAD simplify and Simplify Functions

Enhanced simplification functions, `simplify` and `Simplify`, demonstrate better results for expressions involving trigonometric and hyperbolic functions, square roots, and sums over roots of unity.

MuPAD subs Function Accepts the New EvalChanges Option

The `subs` function now accepts the new `EvalChanges` option. By default, `subs` does not evaluate an expression after making substitutions. With this option, `subs` evaluates all subexpressions that contain substitutions.

MuPAD Solver for Ordinary Differential Equations Handles More Equation Types

Enhanced MuPAD solver handles more second-order linear and first-order nonlinear ordinary differential equations. The solver demonstrates improved performance.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use This Functionality?Use This InsteadCompatibility Considerations
MuPAD Domain `Dom::Ideal`Errors`groebner`Represent ideals as lists, and use functions of the `groebner` package instead.
MuPAD `student` libraryErrors`plot::Integral` and `linalg`Use `plot::Integral` and the `linalg` package instead.
MuPAD `relation` option in `simplify`ErrorsNoneNo replacement
Global property WarnsAssumptions on each variableMake assumptions on each variable instead.
`digits` and `vpa` do not let you set the number of digits to 1.ErrorsErrorsIt is no longer possible to set the number of digits to 1 when using the `digits` and `vpa` functions. The Symbolic Math Toolbox software version number 4.9 and lower allowed you to set the number of digits to 1.

R2009b

New Features, Bug Fixes, Compatibility Considerations

Support for Windows x64 and 64-Bit Macintosh

The toolbox now supports 64-bit Windows® and Macintosh operating systems. If you work in the MuPAD Notebook Interface on a 64-bit Macintosh operating system, MuPAD runs a 64-bit engine with 32-bit graphical user interfaces, such as notebooks and Editor and Debugger windows.

sym and syms Use Reserved Words as Variable Names

`sym` and `syms` commands now treat reserved MuPAD words, except `pi`, as variable names.

Compatibility Considerations

In previous releases, the reserved words returned MuPAD values. If your code uses the reserved words as MuPAD commands, modify your code and use the `evalin` command with the reserved word as a name. For example, use `evalin(symengine,'beta')`.

Toolbox Now Displays Floating-Point Results with Their Original Precision

The toolbox now displays the floating-point results with the original precision with which the toolbox returned them.

Compatibility Considerations

In previous releases, the toolbox displayed floating-point results with the current precision. You must update the existing code that relies on the output precision for displaying floating-point numbers. Use `digits` to set the precision you need before computing such results. The toolbox displays the results with the same number of digits it used to compute the results. The toolbox also can increase the specified precision of calculations by several digits.

In previous releases, `sym(A, 'f')` represented numbers in the form `(2^e + N*2^(e - 52))` or ```-(2^e + N*2^(e - 52)) ```, with integers for `N` and `e`, and `N ≥ 0`. Now `sym(A, 'f')` displays results in the rational form that actually represents the double-precision floating-point numbers.

New MuPAD Preference Pref::outputDigits Controls Floating-Point Outputs

New preference `Pref::outputDigits` controls the precision MuPAD uses to display floating-point results.

Solver for Ordinary Differential Equations Handles More Equation Types

Enhanced solvers handle more equation types of second-order homogeneous linear ordinary differential equations. The solver demonstrates improved performance.

MuPAD limit Function Supports Limits for Incomplete Gamma Function and Exponential Integral Function

Enhanced limit function now can compute limits for incomplete Gamma function and exponential integral function.

Enhanced Simplification Routines for MuPAD Special Functions

Enhanced simplification routines for MuPAD `hypergeom`, `mejerG`, and `bessel` special functions.

Enhanced MuPAD combine Function for Logarithms

Enhanced `combine` function demonstrates better performance for logarithms.

MuPAD normal Function Accepts New Options

The `normal` command now accepts the options `NoGcd`, `ToCancel`, `Rationalize`, `Recursive`, and `Iterations`. The options control costly operations, such as recognizing greatest common divisors and algebraic dependencies.

Functionality Being Removed or Changed

FunctionalityWhat Happens When You Use This Functionality?Use This InsteadCompatibility Considerations
MuPAD `Domain Dom::Ideal`Warns`groebner`Represent ideals as lists, and use functions of the `groebner` package instead.
MuPAD `student` libraryWarns`plot::Integral` and `linalg`Use `plot::Integral` and the `linalg` package instead.
`d` in `char````(A, d)```WarnsNoneNo replacement
MuPAD `relation` option in `simplify`WarnsNoneNo replacement

R2009a

New Features, Bug Fixes, Compatibility Considerations

dsolve Accepts the New Option IgnoreAnalyticConstraints

The `dsolve` command now accepts the option `IgnoreAnalyticConstraints`. The option controls the level of mathematical rigor that the solver uses on the analytical constraints on the solution. By default, the solver ignores all analytical constraints.

Compatibility Considerations

The results of the `dsolve` command can differ from those returned in the previous release. If you want to obtain the same solutions as in the previous release, set the value of the option `IgnoreAnalyticConstraints` to `none`.

emlBlock Function Generates Embedded MATLAB Function Blocks from Symbolic Objects

The new `emlBlock` command converts symbolic expressions to Embedded MATLAB® Function Blocks. You can use these blocks in any Simulink® installation, even those without a Symbolic Math Toolbox license. For more information, see Generating Embedded MATLAB Blocks in the Symbolic Math Toolbox documentation.

matlabFunction Improves Control over Input and Output Parameters

`matlabFunction` now accepts multiple expressions and cell arrays of symbolic arrays as input parameters. The function now allows you to specify the names of the output parameters.

Compatibility Considerations

In previous releases, the default name of an output variable was RESULT. Now the default names of the output variables coincide with the names you use to call `matlabFunction`. You must update existing code that relies on the default output name `RESULT`. You can change your code using any of these methods:

• Define the name of an output variable as `RESULT`.

• Change the name of an input variable to `RESULT`.

• Throughout your code change the variable name from `RESULT` to the input name.

Enhancements to Object-Oriented Programming Capabilities

The Symbolic Math Toolbox product uses some object-oriented programming features to implement symbolic objects. Major enhancements to object-oriented programming capabilities enable easier development and maintenance of large applications and data structures. For a full description of object-oriented features, see the MATLAB Object-Oriented Programming documentation.

Compatibility Considerations

It is no longer possible to add methods to `@sym` by creating a `@sym` directory containing custom methods.

For an empty `x`, `sym(x)` returns a symbolic object of the same size as `x`. In previous releases, `sym(x)` returned a symbolic object of size 0-by-0 for an empty `x`.

generate::MATLAB Function Converts MuPAD Expressions to MATLAB Code

The new `generate::MATLAB` command converts MuPAD expressions, equations, and matrices to MATLAB formatted strings.

MuPAD IgnoreAnalyticConstraints Option Specifies That Core Functions Apply Common Algebraic Assumptions to Simplify Results

The new `IgnoreAnalyticConstraints` option allows the use of a set of simplified mathematical rules when solving equations, simplifying expressions, or integrating. For example, this option applies practical, but not generally correct rules for combining logarithms: $\mathrm{ln}\left(a\right)+\mathrm{ln}\left(b\right)=\mathrm{ln}\left(a\cdot b\right)$

The new default format of presenting results enhances readability of long output expressions by using abbreviations.

MuPAD Solver for Ordinary Differential Equations Handles More Equation Types

The solver now can handle more than 200 additional types of second-order ordinary differential equations. The solver demonstrates improved performance.

MuPAD limit Function Now Can Compute Limits for Piecewise Functions

The enhanced `limit` function computes limits of piecewise functions including bidirectional and one-sided limits.

New and Improved MuPAD Special Functions

MuPAD includes the following new special functions:

• `laguerreL` represents Laguerre's L function.

• `erfc(x,n)` returns iterated integrals of the complementary error function.

• `meijerG` represents the Meijer G function.

The `hypergeom` special function demonstrates better performance.

New Calling Syntax for Test Report Function prog::tcov

The `prog::tcov` function that inspects the data collected during the code execution has the new syntax and set of options.

Compatibility Considerations

The new syntax is not valid in MuPAD versions earlier than 5.2. MuPAD 5.2 does not support the earlier syntax.

New Demos

To see new demos that use MuPAD Notebook Interface, type `mupadDemo` at the MATLAB command line or click MuPAD Notebooks Demo.

Bug Fixes

Bug Fixes

R2007b+

New Features, Bug Fixes, Compatibility Considerations

The default Symbolic Math Toolbox engine is now the MuPAD engine. For more information, see the MuPAD in Symbolic Math Toolbox chapter in the Symbolic Math Toolbox User's Guide.

Compatibility Considerations

The new engine causes many computed results to differ from those returned by previous versions of Symbolic Math Toolbox software.

General Differences

• Many computations return in a permuted order (such as `a + b` instead of `b + a`).

• Some computations return in a different, mathematically equivalent form (such as `(cos(x))^2` instead of ```1 - (sin(x))^2```).

• `diff(dirac(t))` returns `dirac(t,1)` instead of `dirac(1,t)`.

• `sym(x,'f')` no longer produces strings of the form `hex digits*2^n`. Instead the strings have the form `(2^e+N*2^(e-52))`, where `N` and `e` are integers.

• For toolbox calculations, some symbols can only be used as symbolic variables, and not in strings: `E`, `I`, `D`, `O`, `beta`, `zeta`, `theta`, `psi`, `gamma`, `Ci`, `Si`, and `Ei`. This is because those symbols represent MuPAD reserved words, and are interpreted as the MuPAD word if you pass them as strings. The words `Ci`, `Si`, `Ei` represent special mathematical functions: the cosine integral, sine integral, and exponential integral respectively.

• Error and warning message IDs may have changed.

• Performance of numerical integration is slower than in previous versions.

• Subexpressions, calculated by the `subexpr` function, may be different than in previous versions.

• The `pretty` function no longer uses partial subexpressions (with syntax `%n`).

Calculus

• `Int` no longer evaluates some integrals, including many involving Bessel functions.

• `symsum(sin(k*pi)/k,0,n)` no longer evaluates to `pi`.

Linear Algebra

• The output of `colspace` may differ from previous versions, but it is mathematically equivalent.

• The `eig` function may return eigenvalues in a different order than previous versions. Expressions returned by `eig` may be larger than in previous versions.

• The `jordan` function may return diagonal subblocks in a different order than previous versions.

• `svd` may return singular values in a different order than previous versions.

Simplification

• The `coeffs` function may return multivariable terms in a different order than in previous versions.

• The `expand` function may return some trig and exponential expressions differently than in previous versions.

• The `simplify` function involving radicals and powers make fewer assumptions on unknown symbols than in previous versions.

• The `subexpr` function may choose a different subexpression to be the common subexpression than in previous versions.

• Subexpressions no longer have partial subexpressions (previous syntax `%n`).

• The `solve` function returns solutions with higher multiplicity only when solving a single polynomial.

• `acot(-x) = -acot(x)` instead of ```pi - acot(x)``` as in previous versions.

• `acoth(-x) = -acoth(x)` instead of ```2*acoth(0) - acoth(x)``` as in previous versions.

• The `simple` function has several differences:

• The `'how'` value `combine(trig)` has been replaced with `combine(sincos)`, `combine(sinhcosh)`, and `combine(ln)`.

• The `'how'` values involving `convert` have been replaced with `rewrite`.

• A new `'how'` value of `mlsimplify(100)` indicates the MuPAD function `Simplify(...,Steps=100)` simplified the expression.

• Simplifications such as `(sin(x)^2)^(1/2)` to `sin(x)` are no longer performed, since the MuPAD language is careful not to make assumptions about the sign of `sin(x)`.

Conversion

• Arithmetic involving the `vpa` function uses the current number of digits of precision. Variable precision arithmetic may have different rounding behaviors, and answers may differ in trailing digits (trailing zeros are now suppressed).

• The `char` function returns strings using MuPAD syntax instead of Maple™ syntax.

• Testing equality does not compare strings as in previous versions; the symbolic engine equality test is used.

• Saving and loading symbolic expressions is compatible with previous versions, except when the symbolic contents use syntax or functions that differ between Maple or MuPAD engines. For example, suppose you save the symbolic object `sym('transform::fourier(f,x,w)')`, which has MuPAD syntax. You get a MATLAB error if you try to open the object while using a Maple engine.

• LaTeX output from the `latex` function may look different than before.

• C and Fortran code generated with the `ccode` and `fortran` functions may be different than before. In particular, generated files have intermediate expressions as "optimized" code. For more information, see the Generating C or Fortran Code section of the User's Guide.

• `pretty` output may look different than before.

Equation Solving

• `solve` returns solutions with higher multiplicity only when solving a single polynomial.

• `solve` may return a different number of solutions than before.

• Some calls to `dsolve` that used to return results involving `lambertw` now return no solution.

• `dsolve` can now use the variable `C`.

• Some `dsolve` results are more complete (more cases are returned).

• Some `dsolve` results are less complete (not all previous answers are found).

• `finverse` may be able to find inverses for different classes of functions than before.

• When `finverse` fails to find an explicit inverse, it produces different output than before.

Transforms

• Fourier and inverse Fourier transforms return the MuPAD form `transform::fourier` when they cannot be evaluated. For example,

```h = sin(x)/exp(x^2); FF = fourier(h) FF = transform::fourier(sin(x)/exp(x^2), x, -w)```

The reason for this behavior is the MuPAD definition of Fourier transform and inverse Fourier transform differ from their Symbolic Math Toolbox counterparts by the sign in the exponent:

Fourier transform$F\left(w\right)=\underset{-\infty }{\overset{\infty }{\int }}f\left(x\right){e}^{-iwx}dx$$F\left(w\right)=\underset{-\infty }{\overset{\infty }{\int }}f\left(x\right){e}^{iwx}dx$
Inverse Fourier transform$f\left(x\right)=\frac{1}{2\pi }\underset{-\infty }{\overset{\infty }{\int }}F\left(w\right){e}^{iwx}dw$$f\left(x\right)=\frac{1}{2\pi }\underset{-\infty }{\overset{\infty }{\int }}F\left(w\right){e}^{-iwx}dw$

• Several Fourier transforms can no longer be calculated, especially those involving Bessel functions.

• `ztrans` and `iztrans` may return more complicated expressions than before.

Special Mathematical Functions

• The three-parameter Riemann Zeta function is no longer supported.

• heaviside(0) = 0.5; in previous versions it was undefined.

maple

• The `maple`, `mhelp`, and `procread` functions error, unless a Maple engine is installed and selected with `symengine`.

New MuPAD Language and Libraries Supplant Extended Symbolic Math Toolbox Software

The functionality of the MuPAD language, together with the included libraries, goes far beyond that of the previous Symbolic Math Toolbox software. However, it is not identical to that of the previous Extended Symbolic Math Toolbox™ software. The differences between these software packages are beyond the scope of these release notes.

You can access the MuPAD language in several ways:

A MuPAD notebook is an interface for performing symbolic math computations with embedded math notation, graphics, animations, and text. It also enables you to share, document, and publish your calculations and graphics. For example, the MuPAD help viewer is essentially a special MuPAD notebook. For more information, see the Calculating in a MuPAD Notebook section of the User's Guide.

New Functionality for Communication Between MATLAB Workspace and MuPAD

FunctionUse
`doc``(symengine,...)`Access the MuPAD Help browser.
`evalin``(symengine,...)`Use MuPAD functionality in the MATLAB workspace.
`feval``(symengine,...)`Use MuPAD functionality in the MATLAB workspace.
`getVar`Copy expressions residing in a MuPAD notebook into the MATLAB workspace.
`mupad`Launch a MuPAD notebook .
`mupadwelcome`Access MuPAD GUIs .
`reset``(symengine,...)`Clear the MuPAD engine for the MATLAB workspace.
`setVar`Copy expressions residing in the MATLAB workspace into a MuPAD notebook.
`symvar`Produce a list of symbolic objects in an expression.

New symengine Command for Choosing a Maple Engine

If you own a compatible version of a Maple software, you can choose to have Symbolic Math Toolbox software use the Maple engine instead of a MuPAD engine. You might want to do this if you have existing Maple programs. Choose the engine by entering `symengine` at the MATLAB command line; this brings up a GUI for making your choice.

New matlabFunction Generates MATLAB Functions

The new `matlabFunction` generates MATLAB functions from symbolic expressions. `matlabFunction` writes the generated code to a file or creates a function handle. You can use the generated function handles and files in any MATLAB installation, even those without a Symbolic Math Toolbox license. For more information, see Generating MATLAB Functions in the User's Guide.

Bug Fixes

Bug Fixes

R2007a

New Features, Bug Fixes

Maple10 Access Added for Linux 64–bit Processors and Intel Macintosh Platforms

MATLAB now supports Maple Version 10 on 32-bit Windows, 32- and 64-bit Linux® platforms, and the Intel® and PowerPC® Macintosh platforms.

R2006b

New Features, Bug Fixes, Compatibility Considerations

Change in call to code generation package using the maple function

Calling a function in code generation package using Maple software now requires you to explicitly include the package name. For example,

`maple('codegen[fortran](x^2-4)'); `
The generated code output using these methods is unaffected by this change.

Compatibility Considerations

In previous versions, functions in the code generation package of Maple software were made automatically available using the Maple `with` command, and did not require the package name. For example

`maple('fortran(x^2-4)');`
This sometimes caused a conflict when assigning to Maple variables having the same name as a function in the code generation package.