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.
Domains and Programming

Domains

We have loosely tossed about the term “domain”. We shall now look at this in a bit (but not much) more detail. Domains are fundamental to the way in which MuPAD works, and we need to have a basic understanding of them in order to use MuPAD effectively.

A domain in MuPAD is either an algebraic structure (such as finite field or permutation group) or a data type (such as Matrix, Polynomial or Fraction), for which overloaded operators or functions defined on that domain always return results in the domain (or the result FAIL if no result exists).

To give some examples, suppose we investigate matrices over the integers modulo 29. Since 29 is prime, these integers form a Galois field, and so the matrices should respond to all standard arithmetic operations.

First the definition:

```>> M29:=Dom::Matrix(Dom::IntegerMod(29));
Dom::Matrix(Dom::IntegerMod(29))
```

We have two domains being used here: Dom::Matrix, which creates a matrix domain, and Dom::IntegerMod(29), which creates the field of integers modulo 29.

```>> A:=M29([[100,200,-30],[47,-97,130],[13,33,-1001]]);
+-                                 -+
|  13 mod 29, 26 mod 29, 28 mod 29  |
|                                   |
|  18 mod 29, 19 mod 29, 14 mod 29  |
|                                   |
|  13 mod 29,  4 mod 29, 14 mod 29  |
+-                                 -+
```
Notice that the result returned by MuPAD is automatically normalized so that the matrix elements are in the required field. If we enter values which can't be normalized (say, decimal fractions), MuPAD will return an error message.
```>> 1/A;
+-                                 -+
|   3 mod 29,  8 mod 29, 15 mod 29  |
|                                   |
|  28 mod 29,  9 mod 29, 22 mod 29  |
|                                   |
|  12 mod 29, 19 mod 29, 13 mod 29  |
+-                                 -+
```
Here the inverse operator returns a suitable result. Let's check this.
```>> %*A;
+-                              -+
|  1 mod 29, 0 mod 29, 0 mod 29  |
|                                |
|  0 mod 29, 1 mod 29, 0 mod 29  |
|                                |
|  0 mod 29, 0 mod 29, 1 mod 29  |
+-                              -+
```
This is the identity for our particular matrix ring. Now we can try a few other matrix operations.
```>> linalg::det(A);
12 mod 29
>> linalg::gaussElim(A);
+-                                 -+
|  13 mod 29, 26 mod 29, 28 mod 29  |
|                                   |
|   0 mod 29, 12 mod 29,  2 mod 29  |
|                                   |
|   0 mod 29,  0 mod 29,  9 mod 29  |
+-                                 -+
>> linalg::gaussJordan(A);
+-                              -+
|  1 mod 29, 0 mod 29, 0 mod 29  |
|                                |
|  0 mod 29, 1 mod 29, 0 mod 29  |
|                                |
|  0 mod 29, 0 mod 29, 1 mod 29  |
+-                              -+
>> A^10;
+-                                 -+
|  22 mod 29, 10 mod 29,  3 mod 29  |
|                                   |
|   3 mod 29, 21 mod 29, 16 mod 29  |
|                                   |
|   4 mod 29, 18 mod 29,  5 mod 29  |
+-                                 -+
>> exp(A);
FAIL
```
The matrix exponential exp(X) is defined as 1 + X + (X^2)/2 + (X^3)/6 + (X^4)/24 + . . . + (X^n)/n! + . . . As you might expect, this is not defined for matrices over our field. For another example, consider polynomials over the integers modulo 2. The definition is similar to the matrix definition above.
```>> PK:=Dom::Polynomial(Dom::IntegerMod(2));
Dom::Polynomial(Dom::IntegerMod(2))
```
Now we'll create a polynomial in this domain.
```>> p1:=PK(x^17+1);
17
x   + 1
```
For good measure, we'll create a second polynomial which looks the same, but is not in our domain.
```>> p2:=x^17+1;
17
x   + 1
```
Even though they look the same on the screen, MuPAD knows all about them; the type command will tell us.
```>> type(p1);
Dom::Polynomial(Dom::IntegerMod(2))
>> type(p2);
"_plus"
```
(The result of this last command is that p2 is an object formed by adding things together.)
```>> Factor(p1);
3    4    5    8            2    4    6    7    8
1 (x + 1) (x  + x  + x  + x  + 1) (x + x  + x  + x  + x  + x  + 1)
>> Factor(p2);
2        3    4    5    6    7    8    9    10    11    12    13
(x + 1) (x  - x - x  + x  - x  + x  - x  + x  - x  + x   - x   + x   - x
14    15    16
+ x   - x   + x   + 1)
```
The domains package is part of MuPAD which is very much in a state of constant revision and enhancement. For example, at present, it is not possible to perform polynomial division in a polynomial domain.

______________________