Rosetta Stone
   
   
   
The following is a collection of synonyms for various operations in
the computer algebra systems Axiom, Derive, GAP, DoCon,
Macsyma, Magnus, Maxima, Maple, Mathematica, MuPAD, Octave,
Pari, Reduce, Scilab, Sumit and Yacas.  This collection does not
attempt to be comprehensive, but hopefully it will be useful in giving
an indication of how to translate between the syntaxes used by the
different systems in many common situations.  Note that a blank entry
means either (a) that there may be an exact translation of a
particular operation for the indicated system, but we don't know what
it is or (b) there is no exact translation but it may still be
possible to work around this lack with a related functionality.
While commercial systems are not provided on this CD the intent of the
Rosetta effort is to make it possible for experienced Computer Algebra
users to experiment with other systems. Thus the commands for
commercial systems are included to allow users of those systems to
translate.
Some of these systems are special purpose and do not support a lot of
the functionality of the more general purpose systems. Where they do
support an interpreter the commands are provided.
Originally written by Michael Wester.
Modified for Rosetta by Timothy Daly, Alexander Hulpke (GAP).
System availability
 
  | System | License | Status (2002) | URL | 
 
  | Aldor | Non-free | available | http://www.aldor.org | 
 
 | Axiom | ModifiedBSD | available | http://axiom.axiom-developer.org | 
 
 | Derive | commercial | available | http://www.mathware.com | 
 
  | DoCon | open source | available | http://www.haskell.org/docon | 
 
  | GAP | GPL | Rosetta | http://www.gap-system.org/~gap | 
 
  | Macsyma | commercial | dead | unavailable | 
 
  | Magnus | GPL | Rosetta | http://sourceforge.net/projects/magnus | 
 
  | Maxima | GPL | Rosetta | http://www.ma.utexas.edu/maxima.html | 
 
  | Maple | commercial | available | http://www.maplesoft.com | 
 
  | Mathematica | commercial | available | http://www.wolfram.com | 
 
  | MuPAD | commercial | available | http://www.mupad.de | 
 
  | Octave | GPL | Rosetta | http://www.octave.org | 
 
  | Pari | GPL | Rosetta | http://www.parigp-home.de | 
 
  | Reduce | commercial | available | http://www.zib.de/Symbolik/reduce | 
 
  | Scilab | Scilab | available | http://www-rocq.inria.fr/scilab | 
 
  | Sumit |  | available | http://www-sop.inria.fr/cafe/soft-f.html | 
 
  | Yacas | GPL | available | http://yacas.sourceforge.net | 
 | System | Type | Interpreted or Compiled | 
 
  | Axiom | General Purpose | both | 
 
  | Derive | General Purpose |  | 
 
  | DoCon | General Purpose | Interpreted in Haskell | 
 
  | GAP | Group Theory |  | 
 
  | Macsyma | General Purpose |  | 
 
  | Magnus | Infinite Group Theory |  | 
 
  | Maxima | General Purpose |  | 
 
  | Maple | General Purpose |  | 
 
  | Mathematica | General Purpose |  | 
 
  | MuPAD | General Purpose |  | 
 
  | Octave | Numerical Computing |  | 
 
  | Pari | Number Theory |  | 
 
  | Reduce | General Purpose |  | 
 
  | Scilab | General Purpose |  | 
 
  | Sumit | Functional Equations |  | 
 
  | Yacas | General Purpose |  | 
 
  |  | 
Programming and Miscellaneous
 
  | System | Unix/Microsoft user initialization file |  | 
 
  | Axiom | .axiom.input |  | 
 
  | GAP | .gaprc | GAP.RC | 
 
  | DoCon |  |  | 
 
  | Derive |  | derive.ini | 
 
  | Macsyma | macsyma-init.macsyma | mac-init.mac | 
 
  | Magnus |  |  | 
 
  | Maxima | macsyma-init.macsyma | mac-init.mac | 
 
  | Maple | .mapleinit | maplev5.ini | 
 
  | Mathematica | init.m | init.m | 
 
  | MuPAD | .mupadinit | \mupad\bin\userinit.mu | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | .reducerc | reduce.rc | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
 
  | System | Describe keyword | Find keywords containing pattern | 
 
  | Axiom |  | )what operations pattern | 
 
  | Derive |  |  | 
 
  | DoCon |  |  | 
 
  | GAP | ?keyword | ??keyword | 
 
  | Macsyma | describe("keyword")\$ | apropos("pattern"); | 
 
  | Magnus |  |  | 
 
  | Maxima | describe("keyword")\$ | apropos("pattern"); | 
 
  | Maple | ?keyword | ?pattern\,\fnm | 
 
  | Mathematica | ?keyword | ?*pattern* | 
 
  | MuPAD | ?keyword | ?*pattern* | 
 
  | Octave | help -i keyword |  | 
 
  | Pari |  |  | 
 
  | Reduce |  |  | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
Only if the pattern is not a keyword and then the matches are simplistic.
  | System | Comment | Line Cont. | Prev. Expr. | Case sensitive | Variables assumed | 
  | Axiom | -- comment | input _CR input | % | Yes | real | 
 
  | Derive | "comment" | input CRinput |  | No | real | 
 
  | DoCon |  |  |  |  |  | 
 
  | GAP | # comment | input\CRinput | last | Yes | no assumption | 
 
  | Macsyma | /* comment */ | input CR input; | % | No | real | 
 
  | Magnus |  |  |  |  |  | 
 
  | Maxima | /* comment */ | input CR input; | % | No | real | 
 
  | Maple | # comment | input CR input; | % | Yes | complex | 
 
  | Mathematica | (* comment *) | input CR input | % | Yes | complex | 
 
  | MuPAD | # comment # | input CR input; | % | Yes | complex | 
 
  | Octave | ## |  |  | Yes |  | 
 
  | Pari |  |  |  |  |  | 
 
  | Reduce | % comment | input CR input; | ws | No | complex | 
 
  | Scilab |  |  |  |  |  | 
 
  | Sumit |  |  |  |  |  | 
 
  | Yacas |  |  |  |  |  | 
 
  |  | 
  | System | Load a file | Time a command | Quit | 
  | Axiom | )read "file" )quiet | )set messages time on | )quit | 
 
  | Derive | [Transfer Load Derive] |  | [Quit] | 
 
  | DoCon |  |  |  | 
 
  | GAP | Read("file"); | time; \h{(also see {\tt Runtime();})} | quit; | 
 
  | Macsyma | load("file")\$ | showtime: all\$ | quit(); | 
 
  | Magnus |  |  |  | 
 
  | Maxima | load("file")\$ | showtime: all\$ | quit(); | 
 
  | Maple | read("file"): | readlib(showtime): on; | quit | 
 
  | Mathematica | << file | Timing[command] | Quit[] | 
 
  | MuPAD | read("file"): | time(command); | quit | 
 
  | Octave | load file | tic(); cmd ; toc() | quit \OR\ exit | 
 
  | Pari |  |  |  | 
 
  | Reduce | in "file"\$ | on time; | quit; | 
 
  | Scilab |  |  | quit | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Display} | \h{Suppress} |  | 
  |  | \h{output} | \h{output} | \h{Substitution: $f(x, y) \rightarrow f(z, w)$} | 
 
  | Axiom | input | input; | subst(f(x, y), [x = z, y = w]) | 
 
  | Derive | input | var:= input | [Manage Substitute] | 
 
  | DoCon |  |  |  | 
 
  | GAP | input; | input;; | Value(f,[x,y],[z,w]);\fnm | 
 
  | Macsyma | input; | input\$ | subst([x = z, y = w], f(x, y)); | 
 
  | Magnus |  |  |  | 
 
  | Maxima | input; | input\$ | subst([x = z, y = w], f(x, y)); | 
 
  | Maple | input; | input: | subs(\{x = z, y = w\}, f(x, y)); | 
 
  | Mathematica | input | input; | f[x, y] /. \{x -> z, y -> w\} | 
 
  | MuPAD | input; | input: | subs(f(x, y), [x = z, y = w]); | 
 
  | Octave | input | input; |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | input; | input\$ | sub(\{x = z, y = w\}, f(x, y)); | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Set} | \h{List} | \h{Matrix} | 
  | Axiom | set [1, 2] | [1, 2] | matrix([[1, 2],[3, 4]]) | 
 
  | Derive | \{1, 2\} | [1, 2] | [[1,2], [3,4]] | 
 
  | DoCon |  |  |  | 
 
  | GAP | Set([1,2]) | [1, 2] | [[1,2], [3,4]]\fnm | 
 
  | Macsyma | [1, 2] | [1, 2] | matrix([1, 2], [3, 4]) | 
 
  | Magnus |  |  |  | 
 
  | Maxima | [1, 2] | [1, 2] | matrix([1, 2], [3, 4]) | 
 
  | Maple | \{1, 2\} | [1, 2] | matrix([[1, 2], [3, 4]]) | 
 
  | Mathematica | \{1, 2\} | \{1, 2\} | \{\{1, 2\}, \{3, 4\}\} | 
 
  | MuPAD | \{1, 2\} | [1, 2] | export(Dom): \q export(linalg): | 
 
  |  |  |  | matrix:= ExpressionField(normal)): | 
 
  |  |  |  | matrix([[1, 2], [3, 4]]) | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | \{1, 2\} | \{1, 2\} | mat((1, 2), (3, 4)) | 
 
  | Scilab |  | list(1,2) | A=[1,2;3,4] | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Equation} | \h{List element} | \h{Matrix element} | \h{Length of a list} | 
  | Axiom | x = 0 | l . 2 | m(2, 3) | \#l | 
 
  | Derive | x = 0 | l SUB 2 | m SUB 2 SUB 3 | DIMENSION(l) | 
 
  | DoCon |  |  |  |  | 
 
  | GAP | x=0 | l[2] | m[2][3] | Length(l) | 
 
  | Macsyma | x = 0 | l[2] | m[2, 3] | length(l) | 
 
  | Magnus |  |  |  |  | 
 
  | Maxima | x = 0 | l[2] | m[2, 3] | length(l) | 
 
  | Maple | x = 0 | l[2] | m[2, 3] | nops(l) | 
 
  | Mathematica | x == 0 | l[[2]] | m[[2, 3]] | Length[l] | 
 
  | MuPAD | x = 0 | l[2] | m[2, 3] | nops(l) | 
 
  | Octave |  |  |  |  | 
 
  | Pari |  |  |  |  | 
 
  | Reduce | x = 0 | part(l, 2) | m(2, 3) | length(l) | 
 
  | Scilab |  | l(2) |  |  | 
 
  | Sumit |  |  |  |  | 
 
  | Yacas |  |  |  |  | 
 
  |  | 
  | \m{2}{\rm Prepend/append an element to a list} | \h{Append two lists} | 
  | Axiom | cons(e, l) | concat(l, e) | append(l1, l2) | 
 
  | Derive | APPEND([e], l) | APPEND(l, [e]) | APPEND(l1, l2) | 
 
  | DoCon |  |  |  | 
 
  | GAP | Concatenation([e],l) | Add(l,e) | Append(l1, l2) | 
 
  | Macsyma | cons(e, l) | endcons(e, l) | append(l1, l2) | 
 
  | Magnus |  |  |  | 
 
  | Maxima | cons(e, l) | endcons(e, l) | append(l1, l2) | 
 
  | Maple | [e, op(l)] | [op(l), e] | [op(l1), op(l2)] | 
 
  | Mathematica | Prepend[l, e] | Append[l, e] | Join[l1, l2] | 
 
  | MuPAD | [e, op(l)] | append(l, e) | l1 . l2 | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | e . l | append(l, {e}) | append(l1, l2) | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Matrix column dimension} | \h{Convert a list into a column vector} | 
  | Axiom | ncols(m) | transpose(matrix([l])) | 
 
  | Derive | DIMENSION(m SUB 1) | [l]\`{} | 
 
  | DoCon |  |  | 
 
  | GAP | Length(mat[1]) | \h{objects are identical} | 
 
  | Macsyma | mat\_\,ncols(m) | transpose(matrix(l)) | 
 
  | Magnus |  |  | 
 
  | Maxima | mat\_\,ncols(m) | transpose(matrix(l)) | 
 
  | Maple | linalg[coldim](m) | linalg[transpose](matrix([l])) | 
 
  | Mathematica | Dimensions[m][[2]] | Transpose[\{l\}] | 
 
  | MuPAD | linalg::ncols(m) | transpose(matrix([l]))\,\fnm | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | load\_\,package(linalg)\$ | matrix v(length(l), 1)\$ | 
 
  |  | column\_dim(m) | for i:=1:length(l) do | 
 
  |  |  | \q\q v(i, 1):= part(l, i) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
See the definition of matrix above.
  | \h{Convert a column vector into a list} | 
  | Axiom | [v(i, 1) for i in 1..nrows(v)] | 
 
  | Derive | v\`{} SUB 1 | 
 
  | DoCon |  | 
 
  | GAP | \h{objects are identical} | 
 
  | Macsyma | part(transpose(v), 1) | 
 
  | Magnus |  | 
 
  | Maxima | part(transpose(v), 1) | 
 
  | Maple | op(convert(linalg[transpose](v), listlist)) | 
 
  | Mathematica | Flatten[v] | 
 
  | MuPAD | [op(v)] | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | load\_\,package(linalg)\$ | 
 
  |  | for i:=1:row\_\,dim(v) collect(v(i, 1)) | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{True} | \h{False} | \h{And} | \h{Or} | \h{Not} | \h{Equal} | \h{Not equal} | 
  | Axiom | true | false | and | or | not | = | = | 
 
  | Derive | TRUE | FALSE | AND | OR | NOT | = | /= | 
 
  | DoCon |  |  |  |  |  |  |  | 
 
  | GAP | true | false\fnm | and | or | not | = | <> | 
 
  | Macsyma | true | false | and | or | not | = | \# | 
 
  | Magnus |  |  |  |  |  |  |  | 
 
  | Maxima | true | false | and | or | not | = | \# | 
 
  | Maple | true | false | and | or | not | = | <> | 
 
  | Mathematica | True | False | \ | \ |  | || | ! | == | != | 
 
  | MuPAD | true | false | and | or | not | = | <> | 
 
  | Octave |  |  |  |  |  |  |  | 
 
  | Pari |  |  |  |  |  |  |  | 
 
  | Reduce | t | nil | and | or | not | = | neq | 
 
  | Scilab | \%t | \%f |  |  |  |  |  | 
 
  | Sumit |  |  |  |  |  |  |  | 
 
  | Yacas |  |  |  |  |  |  |  | 
 
  |  | 
  | \h{If+then+else statements} | \h{Strings (concatenated)} | 
  | Axiom | if \_ then \_ else if \_ then \_ else \_ | concat(["x", "y"]) | 
 
  | Derive | IF(\_, \_, IF(\_, \_, \_)) | "xy" | 
 
  | DoCon |  |  | 
 
  | GAP | if \_ then \_ elif \_ then \_ else \_ fi | Concatenation("x","y") | 
 
  | Macsyma | if \_ then \_ else if \_ then \_ else \_ | concat("x", "y") | 
 
  | Magnus |  |  | 
 
  | Maxima | if \_ then \_ else if \_ then \_ else \_ | concat("x", "y") | 
 
  | Maple | if \_ then \_ elif \_ then \_ else \_ fi | "x" . "y" | 
 
  | Mathematica | If[\_, \_, If[\_, \_, \_]] | "x" <> "y" | 
 
  | MuPAD | if \_ then \_ elif \_ then \_ else \_ | "x" . "y" | 
 
  |  | \q\q end\_if |  | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | if \_ then \_ else if \_ then \_ else \_ | "xy" \OR\ mkid(x, y) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Simple loop and Block} | \h{Generate the list $[1, 2, \ldots, n]$} | 
  | Axiom | for i in 1..n repeat ( x; y ) | [f(i) for i in 1..n] | 
 
  | Derive | VECTOR([x, y], i, 1, n) | VECTOR(f(i), i, 1, n) | 
 
  | DoCon |  |  | 
 
  | GAP | for i in [1..n] do \_ od; | [1..n] {\rm or} [1,2..n] | 
 
  | Macsyma | for i:1 thru n do (x, y); | makelist(f(i), i, 1, n); | 
 
  | Magnus |  |  | 
 
  | Maxima | for i:1 thru n do (x, y); | makelist(f(i), i, 1, n); | 
 
  | Maple | for i from 1 to n do x; y od; | [f(i) \$ i = 1..n]; | 
 
  | Mathematica | Do[x; y, \{i, 1, n\}] | Table[f[i], \{i, 1, n\}] | 
 
  | MuPAD | for i from 1 to n do x; y | [f(i) \$ i = 1..n]; | 
 
  |  | \q\q end\_for; |  | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | for i:=1:n do <>; | for i:=1:n collect f(i); | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  | \end{tabular} | 
 
  | [10pt]
\begin{tabular}{l|l} | \h{Complex loop iterating on a list} | 
 
  | Axiom | for x in [2, 3, 5] while x**2 < 10 repeat output(x) | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP | for x in [2, 3, 5] do while x\^{}2<10 do Print(x);od;od; | 
 
  | Macsyma | for x in [2, 3, 5] while x\^{}2 < 10 do print(x)\$ | 
 
  | Magnus |  | 
 
  | Maxima | for x in [2, 3, 5] while x\^{}2 < 10 do print(x)\$ | 
 
  | Maple | for x in [2, 3, 5] while x\^{}2 < 10 do print(x) od: | 
 
  | Mathematica | For[l = \{2, 3, 5\}, l != \{\} \ | \ | l[[1]]\^{}2 < 10, | 
 
  |  | \q l = Rest[l], Print[l[[1]]] ] | 
 
  | MuPAD | for x in [2, 3, 5] do if x\^{}2 < 10 then print(x) end\_if | 
 
  |  | \q end\_for: | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | for each x in \{2, 3, 5\} do if x\^{}2 < 10 then write(x)\$ | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{\small Assignment} | \h{Function definition} | \h{Clear vars and funs} | 
  | Axiom | y:= f(x) | f(x, y) == x*y | {\small\tt )clear properties y f} | 
 
  | Derive | y:= f(x) | f(x, y):= x*y | y:=  f:= | 
 
  | DoCon |  |  |  | 
 
  | GAP | y:= f(x); | f:=function(x, y) return x*y; end; | \h{There are
no symbolic variables} | 
 
  | Macsyma | y: f(x); | f(x, y):= x*y; | remvalue(y)\$ | 
 
  |  |  |  | remfunction(f)\$ | 
 
  | Magnus |  |  |  | 
 
  | Maxima | y: f(x); | f(x, y):= x*y; | remvalue(y)\$ | 
 
  |  |  |  | remfunction(f)\$ | 
 
  | Maple | y:= f(x); | f:= proc(x, y) x*y end; | y:= 'y':  f:= 'f': | 
 
  | Mathematica | y = f[x] | f[x\_, y\_\,]:= x*y | Clear[y, f] | 
 
  | MuPAD | y:= f(x); | f:= proc(x, y) | y:= NIL:  f:= NIL: | 
 
  |  |  | \q\q begin x*y end\_\,proc; |  | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | y:= f(x); | procedure f(x, y); x*y; | clear y, f; | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Function definition with a local variable} | 
  | Axiom | f(x) == (local n; n:= 2; n*x) | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP | f:=function(x) local n; n:=2;return n*x; end; | 
 
  | Macsyma | f(x):= block([n], n: 2, n*x); | 
 
  | Magnus |  | 
 
  | Maxima | f(x):= block([n], n: 2, n*x); | 
 
  | Maple | f:= proc(x) local n; n:= 2; n*x end; | 
 
  | Mathematica | f[x\_\,]:= Module[\{n\}, n = 2; n*x] | 
 
  | MuPAD | f:= proc(x) local n; begin n:= 2; n*x end\_\,proc; | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | procedure f(x); begin scalar n; n:= 2; return(n*x) end; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Return unevaluated symbol} | \h{Define a function from an expression} | 
  | Axiom | e:= x*y;\q 'e | function(e, f, x, y) | 
 
  | Derive | e:= x*y\q 'e | f(x, y):== e | 
 
  | DoCon |  |  | 
 
  | GAP | \h{No unevaluated symbols}\fnm |  | 
 
  | Macsyma | e: x*y\$\q 'e; | define(f(x, y), e); | 
 
  | Magnus |  |  | 
 
  | Maxima | e: x*y\$\q 'e; | define(f(x, y), e); | 
 
  | Maple | e:= x*y:\q 'e'; | f:= unapply(e, x, y); | 
 
  | Mathematica | e = x*y;\q HoldForm[e] | f[x\_, y\_\,] = e | 
 
  | MuPAD | e:= x*y:\q hold(e); | f:= hold(func)(e, x, y); | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | e:= x*y\$ | for all x, y let f(x, y):= e; | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
Variables can be assigned to generators of a suitable free
object, for example x:=X(Rationals,"x"); or 
f:=FreeGroup(2);x:=f.1;}.
  | \h{Fun.\ of an indefinite number of args} | \h{Apply ``+'' to sum a list} | 
  | Axiom |  | reduce(+, [1, 2]) | 
 
  | Derive | LST l:= l |  | 
 
  | DoCon |  |  | 
 
  | GAP | lst:=function(args) \_ end; | Sum([1,2]) | 
 
  | Macsyma | lst([l]):= l; | apply("+", [1, 2]) | 
 
  | Magnus |  |  | 
 
  | Maxima | lst([l]):= l; | apply("+", [1, 2]) | 
 
  | Maple | lst:=proc() [args[1..nargs]] end; | convert([1, 2], \`{}+\`{}) | 
 
  | Mathematica | lst[l\_\,\_\,\_\,]:= \{l\} | Apply[Plus, \{1, 2\}] | 
 
  | MuPAD | lst:= proc(l) begin [args()] | \_\,plus(op([1, 2])) | 
 
  |  | \q\q\q end\_\,proc; |  | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce |  | xapply(+, \{1, 2\})\,\fnm | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
procedure xapply(f, lst); lisp(f . cdr(lst))
  | \h{Apply a fun.\ to a} |  | 
  |  | \h{list of its args} | \h{Map an anonymous function onto a list} | 
 
  | Axiom | reduce(f, l) | map(x +-> x + y, [1, 2]) | 
 
  | Derive |  | x:= [1, 2] | 
 
  |  |  | VECTOR(x SUB i + y, i, 1, DIMENSION(x)) | 
 
  | DoCon |  |  | 
 
  | GAP | List(l,f) | List([1,2],x->x+y) | 
 
  | Macsyma | apply(f, l) | map(lambda([x], x + y), [1, 2]) | 
 
  | Magnus |  |  | 
 
  | Maxima | apply(f, l) | map(lambda([x], x + y), [1, 2]) | 
 
  | Maple | f(op(l)) | map(x -> x + y, [1, 2]) | 
 
  | Mathematica | Apply[f, l] | Map[\# + y \ | , \{1, 2\}] | 
 
  | MuPAD | f(op(l)) | map([1, 2], func(x + y, x)) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | xapply(f, l)\,\fnm | for each x in \{1, 2\} collect x + y | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Pattern matching: $f(3 y) + f(z y) \rightarrow 3 f(y) + f(z y)$} | 
  | Axiom | f:= operator('f); | 
 
  |  | ( rule f((n | integer?(n)) * x) == n*f(x) )( \_ | 
 
  |  | \q\q f(3*y) + f(z*y)) | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | matchdeclare(n, integerp, x, true)\$ | 
 
  |  | defrule(fnx, f(n*x), n*f(x))\$ | 
 
  |  | apply1(f(3*y) + f(z*y), fnx); | 
 
  | Magnus |  | 
 
  | Maxima | matchdeclare(n, integerp, x, true)\$ | 
 
  |  | defrule(fnx, f(n*x), n*f(x))\$ | 
 
  |  | apply1(f(3*y) + f(z*y), fnx); | 
 
  | Maple | map(proc(q) local m; | 
 
  |  | \q\q\q if match(q = f(n*y), y, 'm') and | 
 
  |  | \q\q\q\q\q type(rhs(op(m)), integer) then | 
 
  |  | \q\q\q\q subs(m, n * f(y)) else q fi | 
 
  |  | \q\q end, | 
 
  |  | \q\q f(3*y) + f(z*y)); | 
 
  | Mathematica | f[3*y] + f[z*y] /. f[n\_Integer * x\_\,] -> n*f[x] | 
 
  | MuPAD | d:= domain("match"): \q d::FREEVARIABLE:= TRUE: | 
 
  |  | n:= new(d, "n", func(testtype(m, DOM\_INT), m)): | 
 
  |  | x:= new(d, "x", TRUE): | 
 
  |  | map(f(3*y) + f(z*y), | 
 
  |  | \q\q proc(q) local m; begin m:= match(q, f(n*x)); | 
 
  |  | \q\q\q if m = FAIL then q | 
 
  |  | \q\q\q else subs(hold("n" * f("x")), m) end\_if | 
 
  |  | \q\q end\_\,proc); | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | operator f; | 
 
  |  | f(3*y) + f(z*y) | 
 
  |  | \q\q where \{f(n * x) => n*f(x) when fixp(n)\}; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Define a new infix operator and then use it} | 
  | Axiom |  | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP | \h{One can overload existing infix operators for ones own purposes} | 
 
  | Macsyma | infix("")\$ \q ""(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
	3  4; | 
 
  | Magnus |  | 
 
  | Maxima | infix("")\$ \q ""(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
	3  4; | 
 
  | Maple | \`{}\ | \`{}:= (x, y) -> sqrt(x\^{}2 + y\^{}2): \q 3 \ | 4; | 
 
  | Mathematica | x\_ $\backslash$[Tilde] y\_:= Sqrt[x\^{}2 + y\^{}2]; \q
	3 $\backslash$[Tilde] 4 | 
 
  | MuPAD | tilde:= proc(x, y) begin sqrt(x\^{}2 + y\^{}2) end\_\,proc: | 
 
  |  | \q 3 \ | tilde 4; | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | infix |\$ \q procedure |(x, y); sqrt(x\^{}2 + y\^{}2)\$ \q
	3 | 4; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Main expression} |  |  | 
  |  | \h{operator} | \h{\nth{1} operand} | \h{List of expression operands} | 
 
  | Axiom\fnm |  | kernels(e) . 1 | kernels(e) | 
 
  | Derive |  |  | {\em various}\fnm | 
 
  | DoCon |  |  |  | 
 
  | GAP | \m{3}{\rm There are no formal unevaluated expressions} | 
 
  | Macsyma | part(e, 0) | part(e, 1) | args(e) | 
 
  | Magnus |  |  |  | 
 
  | Maxima | part(e, 0) | part(e, 1) | args(e) | 
 
  | Maple | op(0, e) | op(1, e) | [op(e)] | 
 
  | Mathematica | Head[e] | e[[1]] | ReplacePart[e, List, 0] | 
 
  | MuPAD | op(e, 0) | op(e, 1) | [op(e)] | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | part(e, 0) | part(e, 1) | for i:=1:arglength(e) | 
 
  |  |  |  | \q\q collect part(e, i) | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
The following commands work only on expressions that consist of a
single level (e.g., $x + y + z$ but not $a/b + c/d$).
TERMS, FACTORS, NUMERATOR, LHS, etc.
  | \h{Print text and results} | 
  | Axiom | output(concat(["sin(", string(0), ") = ", | 
 
  |  | \q string(sin(0))])); | 
 
  | Derive | "sin(0)" = sin(0) | 
 
  | DoCon |  | 
 
  | GAP | Print("There is no sin, but factors(10)= ",Factors(10),
"$\backslash$n") | 
 
  | Macsyma | print("sin(", 0, ") =", sin(0))\$ | 
 
  | Magnus |  | 
 
  | Maxima | print("sin(", 0, ") =", sin(0))\$ | 
 
  | Maple | printf("sin(\%a) = \%a$\backslash$n", 0, sin(0)): | 
 
  | Mathematica | Print[StringForm["sin(\`{}\`{}) = \`{}\`{}", 0, Sin[0]]]; | 
 
  | MuPAD | print(Unquoted, "sin(".0.")" = sin(0)): | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | write("sin(", 0, ") = ", sin(0))\$ | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Generate FORTRAN} | \h{Generate \TeX/\LaTeX} | 
  | Axiom | outputAsFortran(e) | outputAsTex(e) | 
 
  | Derive | [Transfer Save Fortran] |  | 
 
  | DoCon |  |  | 
 
  | GAP |  | Print(LaTeX(e)); | 
 
  | Macsyma | fortran(e)\$ \OR gentran(eval(e))\$ | tex(e); | 
 
  | Magnus |  |  | 
 
  | Maxima | fortran(e)\$ \OR gentran(eval(e))\$ | tex(e); | 
 
  | Maple | fortran([e]); | latex(e); | 
 
  | Mathematica | FortranForm[e] | TexForm[e] | 
 
  | MuPAD | generate::fortran(e); | generate::TeX(e); | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | on fort; \q e; \q off fort; \OR | load\_\,package(tri)\$ | 
 
  |  | load\_\,package(gentran)\$ gentran e; | on TeX; e; off TeX; | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Import two space separated columns of integers from {\tt file}} | 
  | Axiom |  | 
 
  | Derive | [Transfer Load daTa] ({\rm from} file.dat) | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ | 
 
  | Magnus |  | 
 
  | Maxima | xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ | 
 
  | Maple | xy:= readdata("file", integer, 2): | 
 
  | Mathematica | xy = ReadList["file", Number, RecordLists -> True] | 
 
  | MuPAD |  | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce |  | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Export two space separated columns of integers to {\tt file}\fnm} | 
  | Axiom | )set output algebra "file" \q ({\rm creates} file.spout) | 
 
  |  | for i in 1..n repeat output( \_ | 
 
  |  | \q concat([string(xy(i, 1)), " ", string(xy(i, 2))]) ) | 
 
  |  | )set output algebra console | 
 
  | Derive | xy  [Transfer Print Expressions File]\q({\rm creates} file.prt) | 
 
  | DoCon |  | 
 
  | GAP | PrintTo("file");for i in [1..n] do | 
 
  |  | \q AppendTo("file",xy[i][1]," ",xy[i][2],"$\backslash$n");od; | 
 
  | Macsyma | writefile("file")\$ \q for i:1 thru n do | 
 
  |  | \q print(xy[i, 1], xy[i, 2])\$ \q closefile()\$ | 
 
  | Magnus |  | 
 
  | Maxima | writefile("file")\$ \q for i:1 thru n do | 
 
  |  | \q print(xy[i, 1], xy[i, 2])\$ \q closefile()\$ | 
 
  | Maple | writedata("file", xy); | 
 
  | Mathematica | outfile = OpenWrite["file"]; | 
 
  |  | Do[WriteString[outfile, | 
 
  |  | \q xy[[i, 1]], " ", xy[[i, 2]], "$\backslash$n"], \{i, 1, n\}] | 
 
  |  | Close[outfile]; | 
 
  | MuPAD | fprint(Unquoted, Text, "file", | 
 
  |  | \q ("$\backslash$n", xy[i, 1], xy[i, 2]) \$ i = 1..n): | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | out "file"; \q for i:=1:n do | 
 
  |  | \q write(xy(i, 1), " ", xy(i, 2)); \q shut "file"; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
Some editing of file will be necessary for all systems but
Maple and Mathematica.
Mathematics and Graphics
Since GAP aims at discrete mathematics, it does not provide much of
the calculus functionality listed in the following section.
  | $e$ | $\pi$ | $i$ | $+\infty$ | $\sqrt{2}$ | $2^{1/3}$ | 
  | Axiom | \%e | \%pi | \%i | \%plusInfinity | sqrt(2) | 2**(1/3) | 
 
  | Derive | \#e | pi | \#i | inf | SQRT(2) | 2\^{}(1/3) | 
 
  | DoCon |  |  |  |  |  |  | 
 
  | GAP |  |  | E(4) | infinity | ER(2)\fnm |  | 
 
  | Macsyma | \%e | \%pi | \%i | inf | sqrt(2) | 2\^{}(1/3) | 
 
  | Magnus |  |  |  |  |  |  | 
 
  | Maxima | \%e | \%pi | \%i | inf | sqrt(2) | 2\^{}(1/3) | 
 
  | Maple | exp(1) | Pi | I | infinity | sqrt(2) | 2\^{}(1/3) | 
 
  | Mathematica | E | Pi | I | Infinity | Sqrt[2] | 2\^{}(1/3) | 
 
  | MuPAD | E | PI | I | infinity | sqrt(2) | 2\^{}(1/3) | 
 
  | Octave |  |  |  |  |  |  | 
 
  | Pari |  |  |  |  |  |  | 
 
  | Reduce | e | pi | i | infinity | sqrt(2) | 2\^{}(1/3) | 
 
  | Scilab |  |  |  |  |  |  | 
 
  | Sumit |  |  |  |  |  |  | 
 
  | Yacas |  |  |  |  |  |  | 
 
  |  | 
ER represents special cyclotomic numbers and is not a
root function.}
  | \h{Euler's constant} | \h{Natural log} | \h{Arctangent} | $n!$ | 
  | Axiom |  | log(x) | atan(x) | factorial(n) | 
 
  | Derive | euler\_\,gamma | LOG(x) | ATAN(x) | n! | 
 
  | DoCon |  |  |  |  | 
 
  | GAP |  | LogInt(x,base) |  | Factorial(n) | 
 
  | Macsyma | \%gamma | log(x) | atan(x) | n! | 
 
  | Magnus |  |  |  |  | 
 
  | Maxima | \%gamma | log(x) | atan(x) | n! | 
 
  | Maple | gamma | log(x) | arctan(x) | n! | 
 
  | Mathematica | EulerGamma | Log[x] | ArcTan[x] | n! | 
 
  | MuPAD | EULER | ln(x) | atan(x) | n! | 
 
  | Octave |  |  |  |  | 
 
  | Pari |  |  |  |  | 
 
  | Reduce | Euler\_\,Gamma | log(x) | atan(x) | factorial(n) | 
 
  | Scilab |  |  |  |  | 
 
  | Sumit |  |  |  |  | 
 
  | Yacas |  |  |  |  | 
 
  |  | 
  | \h{Legendre polynomial} | \h{Chebyshev poly.\ of the \nth{1} kind} | 
  | Axiom | legendreP(n, x) | chebyshevT(n, x) | 
 
  | Derive | LEGENDRE\_\,P(n, x) | CHEBYCHEV\_\,T(n, x) | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | legendre\_\,p(n, x) | chebyshev\_\,t(n, x) | 
 
  | Magnus |  |  | 
 
  | Maxima | legendre\_\,p(n, x) | chebyshev\_\,t(n, x) | 
 
  | Maple | orthopoly[P](n, x) | orthopoly[T](n, x) | 
 
  | Mathematica | LegendreP[n, x] | ChebyshevT[n, x] | 
 
  | MuPAD | orthpoly::legendre(n, x) | orthpoly::chebyshev1(n, x) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | LegendreP(n, x) | ChebyshevT(n, x) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Fibonacci number} | \h{Elliptic integral of the \nth{1} kind} | 
  | Axiom | fibonacci(n) |  | 
 
  | Derive | FIBONACCI(n) | ELLIPTIC\_\,E(phi, k\^{}2) | 
 
  | DoCon |  |  | 
 
  | GAP | Fibonacci(n) |  | 
 
  | Macsyma | fib(n) | elliptic\_\,e(phi, k\^{}2) | 
 
  | Magnus |  |  | 
 
  | Maxima | fib(n) | elliptic\_\,e(phi, k\^{}2) | 
 
  | Maple | combinat[fibonacci](n) | EllipticE(sin(phi), k) | 
 
  | Mathematica | Fibonacci[n] | EllipticE[phi, k\^{}2] | 
 
  | MuPAD | numlib::fibonacci(n) |  | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce |  | EllipticE(phi, k\^{}2) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | $\Gamma(x)$ | $\psi(x)$ | \h{Cosine integral} | \h{Bessel fun.\ (\nth{1})} | 
  | Axiom | Gamma(x) | psi(x) | real(Ei(\%i*x)) | besselJ(n, x) | 
 
  | Derive | GAMMA(x) | PSI(x) | CI(x) | BESSEL\_\,J(n, x) | 
 
  | DoCon |  |  |  |  | 
 
  | GAP |  |  |  |  | 
 
  | Macsyma | gamma(x) | psi[0](x) | cos\_\,int(x) | bessel\_j[n](x) | 
 
  | Magnus |  |  |  |  | 
 
  | Maxima | gamma(x) | psi[0](x) | cos\_\,int(x) | bessel\_j[n](x) | 
 
  | Maple | GAMMA(x) | Psi(x) | Ci(x) | BesselJ(n, x) | 
 
  | Mathematica | Gamma[x] | PolyGamma[x] | CosIntegral[x] | BesselJ[n, x] | 
 
  | MuPAD | gamma(x) | psi(x) |  | besselJ(n, x) | 
 
  | Octave |  |  |  |  | 
 
  | Pari |  |  |  |  | 
 
  | Reduce | Gamma(x) | Psi(x) | Ci(x) | BesselJ(n, x) | 
 
  | Scilab |  |  |  |  | 
 
  | Sumit |  |  |  |  | 
 
  | Yacas |  |  |  |  | 
 
  |  | 
  | \h{Hypergeometric fun.\ ${}_2F_1(a, b; c; x)$} | \h{Dirac delta} | \h{Unit step fun.} | 
  | Axiom |  |  |  | 
 
  | Derive | GAUSS(a, b, c, x) |  | STEP(x) | 
 
  | DoCon |  |  |  | 
 
  | GAP |  |  |  | 
 
  | Macsyma | hgfred([a, b], [c], x) | delta(x) | unit\_\,step(x) | 
 
  | Magnus |  |  |  | 
 
  | Maxima | hgfred([a, b], [c], x) | delta(x) | unit\_\,step(x) | 
 
  | Maple | hypergeom([a, b], [c], x) | Dirac(x) | Heaviside(x) | 
 
  | Mathematica | HypergeometricPFQ[\{a,b\},\{c\},x] | \m{2}{<< Calculus\`{}DiracDelta\`{}} | 
 
  | MuPAD |  | dirac(x) | heaviside(x) | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | hypergeometric(\{a, b\}, \{c\}, x) |  |  | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Define $|x|$ via a piecewise function} | 
  | Axiom |  | 
 
  | Derive | a(x):= -x*CHI(-inf, x, 0) + x*CHI(0, x, inf) | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$ | 
 
  | Magnus |  | 
 
  | Maxima | a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$ | 
 
  | Maple | a:= x -> piecewise(x < 0, -x, x): | 
 
  | Mathematica | << Calculus\`{}DiracDelta\`{} | 
 
  |  | a[x\_]:= -x*UnitStep[-x] + x*UnitStep[x] | 
 
  | MuPAD | a:= proc(x) begin -x*heaviside(-x) + x*heaviside(x) | 
 
  |  | \q\q end\_\,proc: | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce |  | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Assume $x$ is real} | \h{Remove that assumption} | 
  | Axiom |  |  | 
 
  | Derive | x :epsilon Real | x:= | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | declare(x, real)\$ | remove(x, real)\$ | 
 
  | Magnus |  |  | 
 
  | Maxima | declare(x, real)\$ | remove(x, real)\$ | 
 
  | Maple | assume(x, real); | x:= 'x': | 
 
  | Mathematica | x/: Im[x] = 0; | Clear[x] | 
 
  | MuPAD | assume(x, Type::RealNum): | unassume(x, Type::RealNum): | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce |  |  | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Assume $0 < x \le 1$} | \h{Remove that assumption} | 
  | Axiom |  |  | 
 
  | Derive | x :epsilon (0, 1] | x:= | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | assume(x > 0, x <= 1)\$ | forget(x > 0, x <= 1)\$ | 
 
  | Magnus |  |  | 
 
  | Maxima | assume(x > 0, x <= 1)\$ | forget(x > 0, x <= 1)\$ | 
 
  | Maple | assume(x > 0); | x:= 'x': | 
 
  |  | additionally(x <= 1); |  | 
 
  | Mathematica | Assumptions -> 0 < x <= 1\,\fnm |  | 
 
  | MuPAD | assume(x > 0):  assume(x <= 1): | unassume(x): | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce |  |  | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
Note: This is an option for {\tt Integrate}.}
  | \h{Basic simplification of an expression $e$} | 
  | Axiom | simplify(e) \OR\ normalize(e) \OR\ complexNormalize(e) | 
 
  | Derive | e | 
 
  | DoCon |  | 
 
  | GAP | e | 
 
  | Macsyma | ratsimp(e) \OR\ radcan(e) | 
 
  | Magnus |  | 
 
  | Maxima | ratsimp(e) \OR\ radcan(e) | 
 
  | Maple | simplify(e) | 
 
  | Mathematica | Simplify[e] \OR\ FullSimplify[e] | 
 
  | MuPAD | simplify(e) \OR\ normal(e) | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | e | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Use an unknown function} | \h{Numerically evaluate an expr.} | 
  | Axiom | f:= operator('f); \q f(x) | exp(1) :: Complex Float | 
 
  | Derive | f(x):= | Precision:= Approximate | 
 
  |  | f(x) | APPROX(EXP(1)) | 
 
  |  |  | Precision:= Exact | 
 
  | DoCon |  |  | 
 
  | GAP |  | EvalF(123/456) | 
 
  | Macsyma | f(x) | sfloat(exp(1)); | 
 
  | Magnus |  |  | 
 
  | Maxima | f(x) | sfloat(exp(1)); | 
 
  | Maple | f(x) | evalf(exp(1)); | 
 
  | Mathematica | f[x] | N[Exp[1]] | 
 
  | MuPAD | f(x) | float(exp(1)); | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | operator f; \q f(x) | on rounded; \q exp(1); | 
 
  |  |  | off rounded; | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | $ n \bmod m$ | \h{Solve $e \equiv 0 \bmod m$ for $x$} | 
  | Axiom | rem(n, m) | solve(e = 0 :: PrimeField(m), x) | 
 
  | Derive | MOD(n, m) | SOLVE\_\,MOD(e = 0, x, m) | 
 
  | DoCon |  |  | 
 
  | GAP | n mod m | \h{solve using finite fields} | 
 
  | Macsyma | mod(n, m) | modulus: m\$ \q solve(e = 0, x) | 
 
  | Magnus |  |  | 
 
  | Maxima | mod(n, m) | modulus: m\$ \q solve(e = 0, x) | 
 
  | Maple | n mod m | msolve(e = 0, m) | 
 
  | Mathematica | Mod[n, m] | Solve[\{e == 0, Modulus == m\}, x] | 
 
  | MuPAD | n mod m | solve(poly(e = 0, [x], IntMod(m)), x) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | on modular; | load\_\,package(modsr)\$ \q on modular; | 
 
  |  | setmod m\$ \q n | setmod m\$ \q m\_solve(e = 0, x) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Put over common denominator} | \h{Expand into separate fractions} | 
  | Axiom | a/b + c/d | (a*d + b*c)/(b*d) :: \_ | 
 
  |  |  | \q MPOLY([a], FRAC POLY INT) | 
 
  | Derive | FACTOR(a/b + c/d, Trivial) | EXPAND((a*d + b*c)/(b*d)) | 
 
  | DoCon |  |  | 
 
  | GAP | a/b+c/d |  | 
 
  | Macsyma | xthru(a/b + c/d) | expand((a*d + b*c)/(b*d)) | 
 
  | Magnus |  |  | 
 
  | Maxima | xthru(a/b + c/d) | expand((a*d + b*c)/(b*d)) | 
 
  | Maple | normal(a/b + c/d) | expand((a*d + b*c)/(b*d)) | 
 
  | Mathematica | Together[a/b + c/d] | Apart[(a*d + b*c)/(b*d)] | 
 
  | MuPAD | normal(a/b + c/d) | expand((a*d + b*c)/(b*d)) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | a/b + c/d | on div;  (a*d + b*c)/(b*d) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Manipulate the root of a polynomial} | 
  | Axiom | a:= rootOf(x**2 - 2); \q a**2 | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP | x:=X(Rationals,"x"); | 
 
  |  | \q a:=RootOfDefiningPolynomial(AlgebraicExtension(Rationals,x\^{}2-2));
a\^{}2 | 
 
  | Macsyma | algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2); | 
 
  | Magnus |  | 
 
  | Maxima | algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2); | 
 
  | Maple | a:= RootOf(x\^{}2 - 2): \q simplify(a\^{}2); | 
 
  | Mathematica | a = Root[\#\^{}2 - 2 \ | , 2] \q a\^{}2 | 
 
  | MuPAD |  | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | load\_\,package(arnum)\$ \q defpoly(a\^{}2 - 2); \q a\^{}2; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Noncommutative multiplication} | \h{Solve a pair of equations} | 
  | Axiom |  | solve([eqn1, eqn2], [x, y]) | 
 
  | Derive | x :epsilon Nonscalar | SOLVE([eqn1, eqn2], [x, y]) | 
 
  |  | y :epsilon Nonscalar |  | 
 
  |  | x . y |  | 
 
  | DoCon |  |  | 
 
  | GAP | * |  | 
 
  | Macsyma | x . y | solve([eqn1, eqn2], [x, y]) | 
 
  | Magnus |  |  | 
 
  | Maxima | x . y | solve([eqn1, eqn2], [x, y]) | 
 
  | Maple | x \ | * y | solve(\{eqn1, eqn2\}, \{x, y\}) | 
 
  | Mathematica | x ** y | Solve[\{eqn1, eqn2\}, \{x, y\}] | 
 
  | MuPAD |  | solve(\{eqn1, eqn2\}, \{x, y\}) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | operator x, y; | solve(\{eqn1, eqn2\}, \{x, y\}) | 
 
  |  | noncom x, y; |  | 
 
  |  | x() * y() |  | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \m{2}{\rm Decrease/increase angles in trigonometric functions} | 
  | Axiom | \m{2}{simplify(normalize(sin(2*x)))} | 
 
  | Derive | Trigonometry:= Expand | Trigonometry:= Collect | 
 
  |  | sin(2*x) | 2*sin(x)*cos(x) | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | trigexpand(sin(2*x)) | trigreduce(2*sin(x)*cos(x)) | 
 
  | Magnus |  |  | 
 
  | Maxima | trigexpand(sin(2*x)) | trigreduce(2*sin(x)*cos(x)) | 
 
  | Maple | expand(sin(2*x)) | combine(2*sin(x)*cos(x)) | 
 
  | Mathematica | TrigExpand[Sin[2*x]] | TrigReduce[2*Sin[x]*Cos[x]] | 
 
  | MuPAD | expand(sin(2*x)) | combine(2*sin(x)*cos(x), sincos) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | load\_\,package(assist)\$ | 
 
  |  | trigexpand(sin(2*x)) | trigreduce(2*sin(x)*cos(x)) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Gr\"obner basis} | 
  | Axiom | groebner([p1, p2, ...]) | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | grobner([p1, p2, ...]) | 
 
  | Magnus |  | 
 
  | Maxima | grobner([p1, p2, ...]) | 
 
  | Maple | Groebner[gbasis]([p1, p2, ...], plex(x1, x2, ...)) | 
 
  | Mathematica | GroebnerBasis[\{p1, p2, ...\}, \{x1, x2, ...\}] | 
 
  | MuPAD | groebner::gbasis([p1, p2, ...]) | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | load\_\,package(groebner)\$ \q groebner(\{p1, p2, ...\}) | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Factorization of $e$ over $i = \sqrt{-1}$} | 
  | Axiom | factor(e, [rootOf(i**2 + 1)]) | 
 
  | Derive | FACTOR(e, Complex) | 
 
  | DoCon |  | 
 
  | GAP | Factors(GaussianIntegers,e) | 
 
  | Macsyma | gfactor(e); \OR\ factor(e, i\^{}2 + 1); | 
 
  | Magnus |  | 
 
  | Maxima | gfactor(e); \OR\ factor(e, i\^{}2 + 1); | 
 
  | Maple | factor(e, I); | 
 
  | Mathematica | Factor[e, Extension -> I] | 
 
  | MuPAD | QI:= Dom::AlgebraicExtension(Dom::Rational, i\^{}2 + 1); | 
 
  |  | QI::name:= "QI": \q Factor(poly(e, QI)); | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | on complex, factor; \q e; \q off complex, factor; | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Real part} | \h{Convert a complex expr.\ to rectangular form} | 
  | Axiom | real(f(z)) | complexForm(f(z)) | 
 
  | Derive | RE(f(z)) | f(z) | 
 
  | DoCon |  |  | 
 
  | GAP | (f(z)+GaloisCyc(f(z),-1))/2 |  | 
 
  | Macsyma | realpart(f(z)) | rectform(f(z)) | 
 
  | Magnus |  |  | 
 
  | Maxima | realpart(f(z)) | rectform(f(z)) | 
 
  | Maple | Re(f(z)) | evalc(f(z)) | 
 
  | Mathematica | Re[f[z]] | ComplexExpand[f[z]] | 
 
  | MuPAD | Re(f(z)) | rectform(f(z)) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | repart(f(z)) | repart(f(z)) + i*impart(f(z)) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Matrix addition} | \h{Matrix multiplication} | \h{Matrix transpose} | 
  | Axiom | A + B | A * B | transpose(A) | 
 
  | Derive | A + B | A . B | A\`{} | 
 
  | DoCon |  |  |  | 
 
  | GAP | A + B | A * B | TransposedMat(A) | 
 
  | Macsyma | A + B | A . B | transpose(A) | 
 
  | Magnus |  |  |  | 
 
  | Maxima | A + B | A . B | transpose(A) | 
 
  | Maple | evalm(A + B) | evalm(A \ | * B) | linalg[transpose](A) | 
 
  | Mathematica | A + B | A . B | Transpose[A] | 
 
  | MuPAD | A + B | A * B | transpose(A) | 
 
  | Octave |  |  |  | 
 
  | Pari |  |  |  | 
 
  | Reduce | A + B | A * B | tp(A) | 
 
  | Scilab |  |  |  | 
 
  | Sumit |  |  |  | 
 
  | Yacas |  |  |  | 
 
  |  | 
  | \h{Solve the matrix equation $A x = b$} | 
  | Axiom | solve(A, transpose(b)) . 1 . particular :: Matrix \_\_\_ | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP | SolutionMat(TransposedMat(A),b) | 
 
  | Macsyma | xx: genvector('x, mat\_nrows(b))\$ | 
 
  |  | x: part(matlinsolve(A . xx = b, xx), 1, 2) | 
 
  | Magnus |  | 
 
  | Maxima | xx: genvector('x, mat\_nrows(b))\$ | 
 
  |  | x: part(matlinsolve(A . xx = b, xx), 1, 2) | 
 
  | Maple | x:= linalg[linsolve](A, b) | 
 
  | Mathematica | x = LinearSolve[A, b] | 
 
  | MuPAD |  | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce |  | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Sum: $\sum_{i = 1}^n f(i)$} | \h{Product: $\prod_{i = 1}^n f(i)$} | 
  | Axiom | sum(f(i), i = 1..n) | product(f(i), i = 1..n) | 
 
  | Derive | SUM(f(i), i, 1, n) | PRODUCT(f(i), i, 1, n) | 
 
  | DoCon |  |  | 
 
  | GAP | Sum([1..n],f) | Product([1..n],f) | 
 
  | Macsyma | closedform( | closedform( | 
 
  |  | \q sum(f(i), i, 1, n)) | \q product(f(i), i, 1, n)) | 
 
  | Magnus |  |  | 
 
  | Maxima | closedform( | closedform( | 
 
  |  | \q sum(f(i), i, 1, n)) | \q product(f(i), i, 1, n)) | 
 
  | Maple | sum(f(i), i = 1..n) | product(f(i), i = 1..n) | 
 
  | Mathematica | Sum[f[i], \{i, 1, n\}] | Product[f[i], \{i, 1, n\}] | 
 
  | MuPAD | sum(f(i), i = 1..n) | product(f(i), i = 1..n) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | sum(f(i), i, 1, n) | prod(f(i), i, 1, n) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Limit: $\lim_{x \rightarrow 0-} f(x)$} | \h{Taylor/Laurent/etc.\ series} | 
  | Axiom | limit(f(x), x = 0, "left") | series(f(x), x = 0, 3) | 
 
  | Derive | LIM(f(x), x, 0, -1) | TAYLOR(f(x), x, 0, 3) | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | limit(f(x), x, 0, minus) | taylor(f(x), x, 0, 3) | 
 
  | Magnus |  |  | 
 
  | Maxima | limit(f(x), x, 0, minus) | taylor(f(x), x, 0, 3) | 
 
  | Maple | limit(f(x), x = 0, left) | series(f(x), x = 0, 4) | 
 
  | Mathematica | Limit[f[x], x->0, Direction->1] | Series[f[x],\{x, 0, 3\}] | 
 
  | MuPAD | limit(f(x), x = 0, Left) | series(f(x), x = 0, 4) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | limit!-(f(x), x, 0) | taylor(f(x), x, 0, 3) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Differentiate: $\frac{d^3 f(x, y)}{dx \, dy^2}$} | \h{Integrate: $\int_0^1 f(x) \, dx$} | 
  | Axiom | D(f(x, y), [x, y], [1, 2]) | integrate(f(x), x = 0..1) | 
 
  | Derive | DIF(DIF(f(x, y), x), y, 2) | INT(f(x), x, 0, 1) | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | diff(f(x, y), x, 1, y, 2) | integrate(f(x), x, 0, 1) | 
 
  | Magnus |  |  | 
 
  | Maxima | diff(f(x, y), x, 1, y, 2) | integrate(f(x), x, 0, 1) | 
 
  | Maple | diff(f(x, y), x, y\$2) | int(f(x), x = 0..1) | 
 
  | Mathematica | D[f[x, y], x, \{y, 2\}] | Integrate[f[x], \{x, 0, 1\}] | 
 
  | MuPAD | diff(f(x, y), x, y\$2) | int(f(x), x = 0..1) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | df(f(x, y), x, y, 2) | int(f(x), x, 0, 1) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Laplace transform} | \h{Inverse Laplace transform} | 
  | Axiom | laplace(e, t, s) | inverseLaplace(e, s, t) | 
 
  | Derive | LAPLACE(e, t, s) |  | 
 
  | DoCon |  |  | 
 
  | GAP |  |  | 
 
  | Macsyma | laplace(e, t, s) | ilt(e, s, t) | 
 
  | Magnus |  |  | 
 
  | Maxima | laplace(e, t, s) | ilt(e, s, t) | 
 
  | Maple | inttrans[laplace](e,t,s) | inttrans[invlaplace](e,s,t) | 
 
  | Mathematica | \m{2}{\q << Calculus\`{}LaplaceTransform\`{}} | 
 
  |  | LaplaceTransform[e, t, s] | {\st InverseLaplaceTransform[e,s,t]} | 
 
  | MuPAD | transform::laplace(e,t,s) | transform::ilaplace(e, s, t) | 
 
  | Octave |  |  | 
 
  | Pari |  |  | 
 
  | Reduce | \m{2}{\q load\_\,package(laplace)\$ \q load\_\,package(defint)\$} | 
 
  |  | laplace(e, t, s) | invlap(e, t, s) | 
 
  | Scilab |  |  | 
 
  | Sumit |  |  | 
 
  | Yacas |  |  | 
 
  |  | 
  | \h{Solve an ODE (with the initial condition $y'(0) = 1$)} | 
  | Axiom | solve(eqn, y, x) | 
 
  | Derive | APPLY\_\,IC(RHS(ODE(eqn, x, y, y\_)), [x, 0], [y, 1]) | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) | 
 
  | Magnus |  | 
 
  | Maxima | ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) | 
 
  | Maple | dsolve(\{eqn, D(y)(0) = 1\}, y(x)) | 
 
  | Mathematica | DSolve[\{eqn, y'[0] == 1\}, y[x], x] | 
 
  | MuPAD | solve(ode(\{eqn, D(y)(0) = 1\}, y(x))) | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | odesolve(eqn, y(x), x) | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{Define the differential operator $L = D_x + I$ and apply it to $\sin x$} | 
  | Axiom | DD : LODO(Expression Integer, e +-> D(e, x)) := D(); | 
 
  |  | L:= DD + 1; \q L(sin(x)) | 
 
  | Derive |  | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x)); | 
 
  | Magnus |  | 
 
  | Maxima | load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x)); | 
 
  | Maple | id:= x -> x: \q L:= (D + id): \q L(sin)(x); | 
 
  | Mathematica | L = D[\#, x]\ | + Identity; \q Through[L[Sin[x]]] | 
 
  | MuPAD | L:= (D + id): \q L(sin)(x); | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce |  | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
  | \h{2D plot of two separate curves overlayed} | 
  | Axiom | draw(x, x = 0..1); \q draw(acsch(x), x = 0..1); | 
 
  | Derive | [Plot Overlay] | 
 
  | DoCon |  | 
 
  | GAP |  | 
 
  | Macsyma | plot(x, x, 0, 1)\$ \q plot(acsch(x), x, 0, 1)\$ | 
 
  | Magnus |  | 
 
  | Maxima | plot(x, x, 0, 1)\$ \q plot(acsch(x), x, 0, 1)\$ | 
 
  | Maple | plot(\{x, arccsch(x)\}, x = 0..1): | 
 
  | Mathematica | Plot[\{x, ArcCsch[x]\}, \{x, 0, 1\}]; | 
 
  | MuPAD | plotfunc(x, acsch(x), x = 0..1): | 
 
  | Octave |  | 
 
  | Pari |  | 
 
  | Reduce | load\_\,package(gnuplot)\$ \q plot(y = x, x = (0 .. 1))\$ | 
 
  |  | plot(y = acsch(x), x = (0 .. 1))\$ | 
 
  | Scilab |  | 
 
  | Sumit |  | 
 
  | Yacas |  | 
 
  |  | 
 
  
  | System | Simple 3D plotting | 
 
  |  | 
  | Axiom | draw(abs(x*y), x = 0..1, y = 0..1); | 
 
  |  | 
  | Derive | [Plot Overlay] | 
 
  |  | 
  | DoCon |  | 
 
  |  | 
  | GAP |  | 
 
  |  | 
  | Macsyma | plot3d(abs(x*y), x, 0, 1, y, 0, 1)\$ | 
 
  |  | 
  | Magnus |  | 
 
  |  | 
  | Maxima | plot3d(abs(x*y), x, 0, 1, y, 0, 1)\$ | 
 
  |  | 
  | Maple | plot3d(abs(x*y), x = 0..1, y = 0..1): | 
 
  |  | 
  | Mathematica | Plot3D[Abs[x*y], \{x, 0, 1\}, \{y, 0, 1\}]; | 
 
  |  | 
  | MuPAD | plotfunc(abs(x*y), x = 0..1, y = 0..1): | 
 
  |  | 
  | Octave |  | 
 
  |  | 
  | Pari |  | 
 
  |  | 
  | Reduce | load\_\,package(gnuplot)\$ | 
 
  |  | 
  |  | plot(z = abs(x*y), x = (0 .. 1), y = (0 .. 1))\$ | 
 
  |  | 
  | Scilab |  | 
 
  |  | 
  | Sumit |  | 
 
  |  | 
  | Yacas |  | 
 
  |  |