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