# MuPAD

in
MuPAD deserves the full support of the Linux community, and if you use mathematics in any way, then MuPAD should find a home on your system.
Series and Polynomials

The default order of a power series is 6. This can be changed either by changing the value of ORDER (analogous to DIGITS above), or by including the order in the series command. This last inclusion is optional.

```>> tx:=series(tan(x),x,12);
3      5       7       9         11
x    2 x    17 x    62 x    1382 x        12
x + -- + ---- + ----- + ----- + -------- + O(x  )
3     15     315    2835     155925
>> cx:=series(cos(x),x,12);
2    4    6      8        10
x    x    x      x        x          12
1 - -- + -- - --- + ----- - ------- + O(x  )
2    24   720   40320   3628800
>> tx*cx;
3    5      7       9        11
x    x      x       x        x           12
x - -- + --- - ---- + ------ - -------- + O(x  )
6    120   5040   362880   39916800
```

This certainly looks like the series for sin(x), but let's see if MuPAD recognizes it as such.

```>> sx:=series(sin(x),x,12):
>> is(tx*cx=sx);
TRUE
>> type(tx*cx);
Puiseux
```
This means that the result of the series product is recognized by MuPAD as an object of type “Puiseux”; that is, a series possibly containing fractional powers.

MuPAD can also deal with polynomials.

```>> p1:=x^8-3*x^5+11*x^4-x^2+17;
4    2      5    8
11 x  - x  - 3 x  + x  + 17
>> p2:=x^3-23*x^2-4*x+11;
3             2
x  - 4 x - 23 x  + 11
>> divide(p1,p2);
2        3       4    5
285641 x + 12337 x  + 533 x  + 23 x  + x  + 6613228,
2
23310861 x + 153111100 x  - 72745491
```

The result of the last command consists of two terms: the quotient, and the remainder. MuPAD also has commands for extracting coefficients from polynomials, evaluating polynomials using Horner's algorithm, and lots more.

Linear Algebra

We shall first create a matrix domain:

```>> M:=Dom::Matrix();
Dom::Matrix(Dom::ExpressionField(id, iszero))
```

The result returned here indicates that MuPAD expects that the elements of matrices will be members of a field for which no normalization is performed (the function id just returns elements as given), and for which 0 is recognized as the zero value.

Now we shall make all the commands in the library linalg available to us:

```>> export(linalg);
```

Now we shall create a few matrices and play with them. First, a matrix with given elements.

```>> A:=M([[1,2,3],[-1,3,-2],[4,-5,2]]);
+-            -+
|   1,  2,  3  |
|              |
|  -1,  3, -2  |
|              |
|   4, -5,  2  |
+-            -+
```
We have entered the matrix elements as a list of lists (a list, in MuPAD, is delimited by square brackets).

Next, a matrix with elements randomly chosen to be between -9 and 9. We do this by applying the function returned by random to each of the elements.

```>> B:=M(3,3,func(random(-9..9)(),i,j));
+-           -+
|  -7, -5, 8  |
|             |
|   3, -1, 7  |
|             |
|   3, -5, 6  |
+-           -+
```

Clearly this approach can be used to generate any matrix whose elements are functions of their row and column values. There is a randomMatrix command in the linalg library, but it requires the elements to be members of a coefficient ring. For our purposes, it is as easy to roll our own.

```>> A*B;
+-              -+
|   8,  -22, 40  |
|                |
|   10,  12,  1  |
|                |
|  -37, -25,  9  |
+-              -+
>> det(A);
-37
>> 1/A;
+-                     -+
|  4/37,  19/37, 13/37  |
|                       |
|  6/37,  10/37,  1/37  |
|                       |
|  7/37, -13/37, -5/37  |
+-                     -+
```
As we have seen above, MuPAD supports operator overloading, which means that since A is a matrix, 1/A is interpreted as the inverse of A.
```>> A^10;
+-                                 -+
|   19897010, -20429930,  22281963  |
|                                   |
|  -42711893,  43857348, -47862790  |
|                                   |
|   64993856, -66730117,  72852811  |
+-                                 -+
>> b:=M(3,1,[7,9,-21]);
+-     -+
|   7   |
|       |
|   9   |
|       |
|  -21  |
+-     -+
```
Here the first two (optional) values give the number of rows and columns of the matrix, the matrix elements are then given in a single list. If the list isn't long enough, the remaining values will default to zero.
```>> linearSolve(A,b);
+-    -+
|  -2  |
|      |
|   3  |
|      |
|   1  |
+-    -+
>> AM:=A.b;
+-                 -+
|   1,  2,  3,  7   |
|                   |
|  -1,  3, -2,  9   |
|                   |
|   4, -5,  2, -21  |
+-                 -+
```
The . operator is concatenation. Again, this is an overloaded operator, as it will work for other data types as well.
```>> gaussJordan(AM);
+-             -+
|  1, 0, 0, -2  |
|               |
|  0, 1, 0,  3  |
|               |
|  0, 0, 1,  1  |
+-             -+
```
The linalg library is very full-featured, and contains plenty of commands for operating on matrices and vectors: row and column operations; matrix factorization and decomposition; commands for dealing with matrix polynomials and eigensystems; and so on.

______________________

## Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

### Sellout

Mupad has been bought out by mathworks and all code is now under matlab (junk) licence.
any and all open source work is now dead.

### Thankyou for a well written a

Thankyou for a well written article. TeXmacs acts as an excellent interface to mupad. I assume that the TeXmacs screen display generated by TeX. The graphics is generated by javaview. The combination of TeXmacs and javaview greatly enhance the mupad experience.

Webcast
How to Build an Optimal Hadoop Cluster to Store and Maintain Unlimited Amounts of Data Using Microservers

Realizing the promise of Apache® Hadoop® requires the effective deployment of compute, memory, storage and networking to achieve optimal results. With its flexibility and multitude of options, it is easy to over or under provision the server infrastructure, resulting in poor performance and high TCO. Join us for an in depth, technical discussion with industry experts from leading Hadoop and server companies who will provide insights into the key considerations for designing and deploying an optimal Hadoop cluster.

Learn More

Sponsored by AMD

White Paper
Red Hat White Paper: Using an Open Source Framework to Catch the Bad Guy

Built-in forensics, incident response, and security with Red Hat Enterprise Linux 6

Every security policy provides guidance and requirements for ensuring adequate protection of information and data, as well as high-level technical and administrative security requirements for a system in a given environment. Traditionally, providing security for a system focuses on the confidentiality of the information on it. However, protecting the data integrity and system and data availability is just as important. For example, when processing United States intelligence information, there are three attributes that require protection: confidentiality, integrity, and availability.

Learn more about catching the bad guy in this free white paper.

Sponsored by DLT Solutions