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.

______________________

## Comment viewing options

### 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.

White Paper
Fabric-Based Computing Enables Optimized Hyperscale Data Centers

Today’s modular x86 servers are compute-centric, designed as a least common denominator to support a wide range of IT workloads. Those generic, virtualized IT workloads have much different resource optimization requirements than hyperscale and cloud applications. They have resulted in a “one size fits all” enterprise IT architecture that is not optimized for a specific set of IT workloads, and especially not emerging hyperscale workloads, such as web applications, big data, and object storage. In this report, you will learn how shifting the focus from traditional compute-centric IT architectures to an innovative disaggregated fabric-based architecture can optimize and scale your data center.