login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit

Edit detail for Rosetta revision 1 of 1

1
Editor: page
Time: 2007/09/11 17:12:28 GMT-7
Note:

changed:
-
\documentclass{article}
\normalsize\baselineskip=12pt
\parskip=0pt
\parindent=10pt
\tolerance=5000
\pretolerance=5000
\frenchspacing
\hangindent=10pt
\skip\footins=18pt
\global\textwidth 31pc \global\textheight 47pc
\headsep 12pt
\oddsidemargin 0pt
\evensidemargin 0pt
%
\renewcommand{\textfraction}{.1}
\renewcommand{\floatpagefraction}{.75}
%
\catcode`@=11
\def\ps@plain{\let\@mkboth\@gobbletwo%
     \let\@oddhead\@empty\def\@oddfoot{\sysdetails}
     \let\@evenhead\@empty\let\@evenfoot\@oddfoot}
\def\ps@empty{\let\@mkboth\@gobbletwo%
     \let\@oddhead\@empty\def\@oddfoot{\sysdetails}
     \let\@evenhead\@empty\let\@evenfoot\@oddfoot}
\catcode`@=12
%
\def\sysdetails{\parbox{\textwidth}{%
Based on material originally published in {\sl Computer Algebra Systems: A
Practical Guide\/} edited by Michael J.\ Wester, John Wiley \& Sons,
Chichester, United Kingdom, ISBN 0-471-98353-5, xvi+436 pages, 1999.}}
%
\pagestyle{plain}

\begin{document}
%
% \nth{n} produces 1^{st}, 2^{nd}, 3^{rd}, 4^{th}, etc.
%
\def\nth#1{$#1^{\rm \ifcase#1 th\or st\or nd\or rd\else th\fi}$}
%
% Abbreviations
%
\newcommand{\Axiom}{{\sf Axiom}}
\newcommand{\Derive}{{\sf Derive}}
\newcommand{\DoCon}{{\sf DoCon}}
\newcommand{\GAP}{{\sf GAP}}
\newcommand{\Gmp}{{\sf Gmp}}
\newcommand{\Macsyma}{{\sf Macsyma}}
\newcommand{\Magnus}{{\sf Magnus}}
\newcommand{\Maxima}{{\sf Maxima}}
\newcommand{\Maple}{{\sf Maple}}
\newcommand{\Mathematica}{{\sf Mathematica}}
\newcommand{\MuPAD}{{\sf MuPAD}}
\newcommand{\Octave}{{\sf Octave}}
\newcommand{\Pari}{{\sf Pari}}
\newcommand{\Reduce}{{\sf Reduce}}
\newcommand{\Scilab}{{\sf Scilab}}
\newcommand{\Sumit}{{\sf Sumit}}
\newcommand{\Yacas}{{\sf Yacas}}

\section{Introduction}

The following is a collection of synonyms for various operations in
the computer algebra systems \Axiom, \Derive, \GAP, \Gmp, \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).

\section{System availability}

\begin{tabular}{l|lll}
System & \rm{License} & \rm{Status (May 2002)} & \rm{Web Location} \\
\hline
\Axiom       & BSD         & available  & http://www.aldor.org \\
\Axiom       & open source & pending    & http://wiki.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 \\
\Gmp         & GPL         & Rosetta    & http://www.swox.com/gmp \\
\Macsyma     & commercial  & dead       & See Maxima \\
\Magnus      & GPL         & Rosetta    & http://zebra.sci.ccny.cuny.edu/web \\
\Maxima      & GPL         & Rosetta    & http://maxima.sourceforge.net \\
\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-e.html \\
\Yacas       & GPL         & available  & http://yacas.sourceforge.net \\
\end{tabular} \\[10pt]
\\
\begin{tabular}{l|ll}
System & \rm{Type} & \rm{Interpreted or Compiled}\\
\hline
\Axiom       & General Purpose          & both \\
\Derive      & General Purpose          & \\
\DoCon       & General Purpose          & Interpreted in Haskell \\
\GAP         & Group Theory             & \\
\Gmp         & arb. prec. arithmetic    & \\
\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          & \\
\end{tabular} \\[10pt]

\section{Programming and Miscellaneous}

\begingroup
\newcommand{\OR}{{\em or }}
\newcommand{\fnm}{\footnotemark}
\newcommand{\h}[1]{{\rm #1}}
\newcommand{\m}[2]{\multicolumn{#1}{l}{#2}}
\newcommand{\q}{\quad}
\newcommand{\st}{\small\tt}
\parindent=0pt
\hfuzz=1pt
\begin{tt}

\begin{tabular}{l|ll}
& \m{2}{\rm Unix/Microsoft user initialization file} \\
\hline
\Axiom       & \~{}/axiom.input          & \\
\GAP         & \~{}/.gaprc               & GAP.RC \\
\Gmp         &                           & \\
\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           &
	$\backslash$mupad$\backslash$bin$\backslash$userinit.mu \\
\Octave      &                           & \\
\Pari        &                           & \\
\Reduce      & \~{}/.reducerc            & reduce.rc    \\
\Scilab      &                           & \\
\Sumit       &                           & \\
\Yacas       &                           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Describe {\em keyword}} & \h{Find keywords containing {\em pattern}} \\
\hline
\Axiom       &                       & )what operations pattern \\
\Derive      &                       & \\
\DoCon       &                       & \\
\GAP         & ?keyword              & ??keyword\\
\Gmp         &                       & \\
\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       &                       & \\
\end{tabular} \\[10pt]

\footnotetext{Only if the pattern is not a keyword and then the matches are
simplistic.}

\begin{tabular}{l|l@{ }llll}
& & & \h{Prev.} & \h{Case} & \h{Variables} \\
& \h{Comment} & \h{Line continuation} & \h{expr.} & \h{sensitive} & \h{assumed}
	\\
\hline
\Axiom       & -- comment    & input \_<CR>input   & \% & Yes & real    \\
\Derive      & "comment"     & input \~{}<CR>input &    & No  & real    \\
\DoCon       &               &                     &    &     & \\
\GAP         & \# comment    & input$\backslash$<CR>input&last&Yes&no assumption\\
\Gmp         &               &                     &    &     & \\
\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       &               &                     &    &     & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Load a file} & \h{Time a command} & \h{Quit} \\
\hline
\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;\\
\Gmp         &                        &                        & \\
\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       &                        &                        & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Display} & \h{Suppress} & \\
& \h{output} & \h{output} & \h{Substitution: $f(x, y) \rightarrow f(z, w)$} \\
\hline
\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         \\
\Gmp         &        &             & \\
\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       &        &             & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Set} & \h{List} & \h{Matrix} \\
\hline
\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                 \\
\Gmp         &            &           & \\
\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       &            &           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|llll}
& \h{Equation} & \h{List element} & \h{Matrix element} & \h{Length of a list} \\
\hline
\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)    \\
\Gmp         &        &            &               & \\
\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       &        &            &               & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \m{2}{\rm Prepend/append an element to a list} & \h{Append two lists} \\
\hline
\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)   \\
\Gmp         &                &                & \\
\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       &                &                & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Matrix column dimension} & \h{Convert a list into a column vector} \\
\hline
\Axiom       & ncols(m)                  & transpose(matrix([l]))         \\
\Derive      & DIMENSION(m SUB 1)        & [l]\`{}                        \\
\DoCon       &                           & \\
\GAP         & Length(mat[1])            & \h{objects are identical}      \\
\Gmp         &                           & \\
\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       &                           & \\
\end{tabular} \\[10pt]

\footnotetext{See the definition of {\tt matrix} above.}

\begin{tabular}{l|l}
& \h{Convert a column vector into a list} \\
\hline
\Axiom       & [v(i, 1) for i in 1..nrows(v)]              \\
\Derive      & v\`{} SUB 1                                 \\
\DoCon       & \\
\GAP         & \h{objects are identical}                   \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lllllll}
& \h{True} & \h{False} & \h{And} & \h{Or} & \h{Not} & \h{Equal} & \h{Not equal}
	\\
\hline
\Axiom       & true & false & and  & or & not & =  & \~{}= \\
\Derive      & TRUE & FALSE & AND  & OR & NOT & =  & /=    \\
\DoCon       &      &       &      &    &     &    & \\
\GAP         & true & false\fnm & and  & or & not & = & <>     \\
\Gmp         &      &       &      &    &     &    & \\
\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       &      &       &      &    &     &    & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{If+then+else statements} & \h{Strings (concatenated)} \\
\hline
\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")\\
\Gmp         &                                          & \\
\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       &                                          & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Simple loop and Block} & \h{Generate the list $[1, 2, \ldots, n]$} \\
\hline
\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]\\
\Gmp         &                                     & \\
\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 @<<x; y>>;             & for i:=1:n collect f(i); \\
\Scilab      &                                     & \\
\Sumit       &                                     & \\
\Yacas       &                                     & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Complex loop iterating on a list} \\
\hline
\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; \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{\small Assignment} & \h{Function definition} & \h{Clear vars and funs} \\
\hline
\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}\\
\Gmp         &           &                             & \\
\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       &           &                             & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Function definition with a local variable} \\
\hline
\Axiom       & f(x) == (local n; n:= 2; n*x)                           \\
\Derive      & \\
\DoCon       & \\
\GAP         & f:=function(x) local n; n:=2;return n*x; end;           \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Return unevaluated symbol} & \h{Define a function from an expression} \\
\hline
\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&\\
\Gmp         &                        & \\
\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       &                        & \\
\end{tabular} \\[10pt]
\footnotetext{Variables can be assigned to generators of a suitable free
object, for example {\tt x:=X(Rationals,"x");} or {\tt
f:=FreeGroup(2);x:=f.1;}.}
\addtocounter{footnote}{-1}%

\begin{tabular}{l|ll}
& \h{Fun.\ of an indefinite number of args} & \h{Apply ``+'' to sum a list} \\
\hline
\Axiom       &                                   & reduce(+, [1, 2])          \\
\Derive      & LST l:= l                         & \\
\DoCon       &                                   & \\
\GAP         & lst:=function(args) \_ end;       & Sum([1,2])\\
\Gmp         &                                   & \\
\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       &                                   & \\
\end{tabular} \\[10pt]

\footnotetext{\tt procedure xapply(f, lst); lisp(f . cdr(lst))\$}
\addtocounter{footnote}{-1}%

\begin{tabular}{l|ll}
& \h{Apply a fun.\ to a} & \\
& \h{list of its args} & \h{Map an anonymous function onto a list} \\
\hline
\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) \\
\Gmp         &                    & \\
\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       &                    & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Pattern matching: $f(3 y) + f(z y) \rightarrow 3 f(y) + f(z y)$} \\
\hline
\Axiom       & f:= operator('f);                                  \\
             & ( rule f((n | integer?(n)) * x) == n*f(x) )( \_    \\
             & \q\q f(3*y) + f(z*y))                              \\
\Derive      & \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Define a new infix operator and then use it} \\
\hline
\Axiom       & \\
\Derive      & \\
\DoCon       & \\
\GAP     &\h{One can overload existing infix operators for ones own purposes}\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Main expression} & & \\
& \h{operator} & \h{\nth{1} operand} & \h{List of expression operands} \\
\hline
\Axiom\fnm   &            & kernels(e) . 1 & kernels(e)              \\
\Derive      &            &                & {\em various}\fnm       \\
\DoCon       &            &                & \\
\GAP         &\m{3}{\rm There are no formal unevaluated expressions}\\
\Gmp         &            &                & \\
\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       &            &                & \\
\end{tabular} \\[10pt]

\addtocounter{footnote}{-1}%
\footnotetext{The following commands work only on expressions that consist of a
single level (e.g., $x + y + z$ but not $a/b + c/d$).}
\addtocounter{footnote}{-1}%
\footnotetext{{\tt TERMS}, {\tt FACTORS}, {\tt NUMERATOR}, {\tt LHS}, etc.}

\begin{tabular}{l|l}
& \h{Print text and results} \\
\hline
\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")\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Generate FORTRAN} & \h{Generate \TeX/\LaTeX} \\
\hline
\Axiom       & outputAsFortran(e)                    & outputAsTex(e)      \\
\Derive      & [Transfer Save Fortran]               & \\
\DoCon       &                                       & \\
\GAP         &&Print(LaTeX(e));\\
\Gmp         &                                       & \\
\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       &                                       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Import two space separated columns of integers from {\tt file}} \\
\hline
\Axiom       & \\
\Derive      & [Transfer Load daTa] ({\rm from} file.dat)          \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Export two space separated columns of integers to {\tt file}\fnm} \\
\hline
\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;\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\footnotetext{Some editing of {\tt file} will be necessary for all systems but
\Maple\ and \Mathematica.}

\section{Mathematics and Graphics}

{\rm Since {\GAP} aims at discrete mathematics, it does not provide much of
the calculus functionality listed in the following section.}

\begin{tabular}{l|llllll}
& $e$ & $\pi$ & $i$ & $+\infty$ & $\sqrt{2}$ & $2^{1/3}$ \\
\hline
\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 &\\
\Gmp         &        &      &     &                &         & \\
\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       &        &      &     &                &         & \\
\end{tabular} \\[10pt]
\footnotetext{{\tt ER} represents special cyclotomic numbers and is not a
root function.}
\addtocounter{footnote}{-1}%

\begin{tabular}{l|llll}
& \h{Euler's constant} & \h{Natural log} & \h{Arctangent} & $n!$ \\
\hline
\Axiom       &                & log(x) & atan(x)   & factorial(n) \\
\Derive      & euler\_\,gamma & LOG(x) & ATAN(x)   & n!           \\
\DoCon       &                &        &           & \\
\GAP         &                & LogInt(x,base) && Factorial(n) \\
\Gmp         &                &        &           & \\
\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       &                &        &           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Legendre polynomial} & \h{Chebyshev poly.\ of the \nth{1} kind} \\
\hline
\Axiom       & legendreP(n, x)          & chebyshevT(n, x)           \\
\Derive      & LEGENDRE\_\,P(n, x)      & CHEBYCHEV\_\,T(n, x)       \\
\DoCon       &                          & \\
\GAP         &                          & \\
\Gmp         &                          & \\
\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       &                          & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Fibonacci number} & \h{Elliptic integral of the \nth{1} kind} \\
\hline
\Axiom       & fibonacci(n)           & \\
\Derive      & FIBONACCI(n)           & ELLIPTIC\_\,E(phi, k\^{}2) \\
\DoCon       &                        & \\
\GAP         & Fibonacci(n)           & \\
\Gmp         &                        & \\
\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       &                        & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|llll}
& $\Gamma(x)$ & $\psi(x)$ & \h{Cosine integral} & \h{Bessel fun.\ (\nth{1})} \\
\hline
\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         &          &              &                 & \\
\Gmp         &          &              &                 & \\
\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       &          &              &                 & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Hypergeometric fun.\ ${}_2F_1(a, b; c; x)$} & \h{Dirac delta} &
	\h{Unit step fun.} \\
\hline
\Axiom       &                                    &          & \\
\Derive      & GAUSS(a, b, c, x)                  &          & STEP(x)      \\
\DoCon       &                                    &          & \\
\GAP         &                                    &          & \\
\Gmp         &                                    &          & \\
\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       &                                    &          & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Define $|x|$ via a piecewise function} \\
\hline
\Axiom       & \\
\Derive      & a(x):= -x*CHI(-inf, x, 0) + x*CHI(0, x, inf)        \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Assume $x$ is real} & \h{Remove that assumption} \\
\hline
\Axiom       & & \\
\Derive      & x :epsilon Real           & x:=                         \\
\DoCon       &                           & \\
\GAP         &                           & \\
\Gmp         &                           & \\
\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       &                           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Assume $0 < x \le 1$} & \h{Remove that assumption} \\
\hline
\Axiom       & & \\
\Derive      & x :epsilon (0, 1]               & x:=                     \\
\DoCon       &                                 & \\
\GAP         &                                 & \\
\Gmp         &                                 & \\
\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       &                                 & \\
\end{tabular} \\[10pt]

\footnotetext{This is an option for {\tt Integrate}.}

\begin{tabular}{l|l}
& \h{Basic simplification of an expression $e$} \\
\hline
\Axiom       & simplify(e) \OR\ normalize(e) \OR\ complexNormalize(e) \\
\Derive      & e                                                      \\
\DoCon       & \\
\GAP         & e \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Use an unknown function} & \h{Numerically evaluate an expr.} \\
\hline
\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)\\
\Gmp         &                           & \\
\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       &                           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& $ n \bmod m$ & \h{Solve $e \equiv 0 \bmod m$ for $x$} \\
\hline
\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}\\
\Gmp         &                 & \\
\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       &                 & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Put over common denominator} & \h{Expand into separate fractions} \\
\hline
\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                    &\\
\Gmp         &                            & \\
\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       &                            & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Manipulate the root of a polynomial} \\
\hline
\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\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Noncommutative multiplication} & \h{Solve a pair of equations} \\
\hline
\Axiom       &                      & solve([eqn1, eqn2], [x, y])     \\
\Derive      & x :epsilon Nonscalar & SOLVE([eqn1, eqn2], [x, y])     \\
             & y :epsilon Nonscalar & \\
             & x . y                & \\
\DoCon       &                      & \\
\GAP         &*&\\
\Gmp         &                      & \\
\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       &                      & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \m{2}{\rm Decrease/increase angles in trigonometric functions} \\
\hline
\Axiom       & \m{2}{simplify(normalize(sin(2*x)))} \\
\Derive      & Trigonometry:= Expand         & Trigonometry:= Collect      \\
             & sin(2*x)                      & 2*sin(x)*cos(x)             \\
\DoCon       &                               & \\
\GAP         &                               & \\
\Gmp         &                               & \\
\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       &                               & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Gr\"obner basis} \\
\hline
\Axiom       & groebner([p1, p2, ...])                                  \\
\Derive      & \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Factorization of $e$ over $i = \sqrt{-1}$} \\
\hline
\Axiom       & factor(e, [rootOf(i**2 + 1)]) \\
\Derive      & FACTOR(e, Complex) \\
\DoCon       & \\
\GAP         & Factors(GaussianIntegers,e)\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Real part} & \h{Convert a complex expr.\ to rectangular form} \\
\hline
\Axiom       & real(f(z))     & complexForm(f(z))             \\
\Derive      & RE(f(z))       & f(z)                          \\
\DoCon       &                & \\
\GAP         & (f(z)+GaloisCyc(f(z),-1))/2&\\
\Gmp         &                & \\
\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       &                & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|lll}
& \h{Matrix addition} & \h{Matrix multiplication} & \h{Matrix transpose} \\
\hline
\Axiom       & A + B        & A * B          & transpose(A)         \\
\Derive      & A + B        & A . B          & A\`{}                \\
\DoCon       &              &                & \\
\GAP         & A + B        & A * B          & TransposedMat(A)\\
\Gmp         &              &                & \\
\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       &              &                & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Solve the matrix equation $A x = b$} \\
\hline
\Axiom       & solve(A, transpose(b)) . 1 . particular :: Matrix \_\_\_ \\
\Derive      & \\
\DoCon       & \\
\GAP         & SolutionMat(TransposedMat(A),b)\\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Sum: $\sum_{i = 1}^n f(i)$} & \h{Product: $\prod_{i = 1}^n f(i)$} \\
\hline
\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)\\
\Gmp         &                        & \\
\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       &                        & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Limit: $\lim_{x \rightarrow 0-} f(x)$} & \h{Taylor/Laurent/etc.\ series} \\
\hline
\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         &                                 & \\
\Gmp         &                                 & \\
\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       &                                 & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Differentiate: $\frac{d^3 f(x, y)}{dx \, dy^2}$} &
	\h{Integrate: $\int_0^1 f(x) \, dx$} \\
\hline
\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         &                            & \\
\Gmp         &                            & \\
\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       &                            & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Laplace transform} & \h{Inverse Laplace transform} \\
\hline
\Axiom       & laplace(e, t, s)          & inverseLaplace(e, s, t)        \\
\Derive      & LAPLACE(e, t, s)          & \\
\DoCon       &                           & \\
\GAP         &                           & \\
\Gmp         &                           & \\
\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       &                           & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Solve an ODE (with the initial condition $y'(0) = 1$)} \\
\hline
\Axiom       & solve(eqn, y, x)                                      \\
\Derive      & APPLY\_\,IC(RHS(ODE(eqn, x, y, y\_)), [x, 0], [y, 1]) \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Define the differential operator $L = D_x + I$ and apply it to $\sin x$} \\
\hline
\Axiom       & DD : LODO(Expression Integer, e +-> D(e, x)) := D(); \\
             & L:= DD + 1; \q L(sin(x))                             \\
\Derive      & \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{2D plot of two separate curves overlayed} \\
\hline
\Axiom       & draw(x, x = 0..1); \q draw(acsch(x), x = 0..1);           \\
\Derive      & [Plot Overlay]                                            \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Simple 3D plotting} \\
\hline
\Axiom       & draw(abs(x*y), x = 0..1, y = 0..1);              \\
\Derive      & [Plot Overlay]                                   \\
\DoCon       & \\
\GAP         & \\
\Gmp         & \\
\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       & \\
\end{tabular} \\[10pt]

%\begin{tabular}{l|l}
%& \h{} \\
%\hline
%\Axiom       & \\
%\Derive      & \\
%\DoCon       & \\
%\GAP         & \\
%\Gmp         & \\
%\Macsyma     & \\
%\Magnus      & \\
%\Maxima      & \\
%\Maple       & \\
%\Mathematica & \\
%\MuPAD       & \\
%\Octave      & \\
%\Pari        & \\
%\Reduce      & \\
%\Scilab      & \\
%\Sumit       & \\
%\Yacas       & \\
%\end{tabular} \\[10pt]

\end{tt}
\endgroup
\end{document}

Download: pdf dvi ps src tex log