\documentclass{book}
\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}
%
\def\chaptername{}
%
\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{\Aldor}{{\sf Aldor}}
\newcommand{\Axiom}{{\sf Axiom}}
\newcommand{\CLN}{{\sf CLN}}
\newcommand{\CoCoA}{{\sf CoCoA}}
\newcommand{\Derive}{{\sf Derive}}
\newcommand{\DoCon}{{\sf DoCon}}
\newcommand{\GAP}{{\sf GAP}}
\newcommand{\GCL}{{\sf GCL}}
\newcommand{\Giac}{{\sf Giac}}
\newcommand{\GiNaC}{{\sf GiNaC}}
\newcommand{\Gmp}{{\sf Gmp}}
\newcommand{\GnuPlot}{{\sf GnuPlot}}
\newcommand{\Haskell}{{\sf Haskell}}
\newcommand{\Macsyma}{{\sf Macsyma}}
\newcommand{\Magnus}{{\sf Magnus}}
\newcommand{\Maxima}{{\sf Maxima}}
\newcommand{\Maple}{{\sf Maple}}
\newcommand{\Mathcad}{{\sf Mathcad}}
\newcommand{\Mathematica}{{\sf Mathematica}}
\newcommand{\Mpfr}{{\sf Mpfr}}
\newcommand{\MuPAD}{{\sf MuPAD}}
\newcommand{\Ntl}{{\sf Ntl}}
\newcommand{\Octave}{{\sf Octave}}
\newcommand{\Pari}{{\sf Pari}}
\newcommand{\Readline}{{\sf Readline}}
\newcommand{\Reduce}{{\sf Reduce}}
\newcommand{\Singular}{{\sf Singular}}
\newcommand{\Sumit}{{\sf Sum\^{}it}}
\newcommand{\TeXmacs}{{\sf TeXmacs}}
\newcommand{\Yacas}{{\sf Yacas}}

\chapter{Rosetta Translations}

\section{Introduction}

The following is a collection of synonyms for various operations in
the computer algebra systems \Aldor, \Axiom, \CoCoA, \Derive, \DoCon,
\GAP, \Giac, \GiNaC, \Gmp, \Macsyma, \Magnus, \Maple, \Mathcad,
\Mathematica, \Maxima, \MuPAD, \Octave, \Pari, \Reduce, \Sumit,
\Singular\ 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.

The tables do not cover the full range of functionality and are
slanted in favor of general purpose, interactive systems. 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. Some systems are
primarily development tools rather than interpreters and are not
represented in some tables.

Originally written by Michael Wester.
Modified for Rosetta by Timothy Daly, Alexander Hulpke (GAP),
Hans Schoenemann (Singular) and Serge Mechveliani (DoCon).

\section{System availability}

\begin{tabular}{l|lll}
System & \rm{License} & \rm{Status} & \rm{Web Location} \\
\hline
\Aldor       & BSD         & available  & http://www.aldor.org               \\
\Axiom       & open source & pending    & http://home.earthlink.net/\~{}jgg964/axiom.html \\
\CLN         & GPL         & Rosetta    & ftp://ftp.ilog.fr/pub/Users/haible/gnu \\
\CoCoA       & unknown     & Rosetta    & http://cocoa.dima.unige.it         \\
\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     \\
\Giac        & GPL         & Rosetta    & http://www-fourier.ujf-grenoble.fr/\~{}parisse/giac\_us.html \\
\GiNaC       & GPL         & Rosetta    & http://www.ginac.de/Download.html  \\
\Gmp         & GPL         & Rosetta    & http://www.swox.com/gmp            \\
\Macsyma     & commercial  & dead       & unavailable                        \\
\Magnus      & GPL         & Rosetta    & http://zebra.sci.ccny.cuny.edu/web \\
\Maxima      & GPL         & Rosetta    & http://www.ma.utexas.edu/maxima.html\\
\Maple       & commercial  & available  & http://www.maplesoft.com           \\
\Mathcad     & commercial  & available  & http://www.mathcad.com             \\
\Mathematica & commercial  & available  & http://www.wolfram.com             \\
\Mpfr        & GPL         & Rosetta    & http://www.loria.fr/equipes/polka  \\
\MuPAD       & commercial  & available  & http://www.mupad.de                \\
\Ntl         & GPL         & Rosetta    & http://shoup.net/ntl               \\
\Octave      & GPL         & Rosetta    & http://www.octave.org              \\
\Pari        & GPL         & Rosetta    & http://www.parigp-home.de          \\
\Reduce      & commercial  & available  & http://www.zib.de/Symbolik/reduce  \\
\Singular    & Singular    & Rosetta    & http://www.singular.uni-kl.de      \\
\Sumit       &             & pending    & http://www-sop.inria.fr/cafe/Manuel.Bronstein \\
\Yacas       & GPL         & Rosetta    & http://yacas.sourceforge.net       \\
\end{tabular} \\[10pt]
\\
\\
\begin{tabular}{l|ll}
System & \rm{Type} & \rm{Interpreted, Compiled, Library}\\
\hline
\Aldor       & library development      & compiler and library               \\
\Axiom       & General Purpose          & interp and compiled                \\
\CLN         & arb. prec. arithmetic    & library                            \\
\CoCoA       & Commutative Algebra      &                                    \\
\Derive      & General Purpose          &                                    \\
\DoCon       & General Purpose          & interpreted                        \\
\GAP         & Group Theory             & interpreted                        \\
\Giac        & C++ algebra library      & library                            \\
\GiNaC       & C++ algebra library      & library                            \\
\Gmp         & arb. prec. arithmetic    & library                            \\
\Macsyma     & General Purpose          &                                    \\
\Magnus      & Infinite Group Theory    &                                    \\
\Maxima      & General Purpose          &                                    \\
\Maple       & General Purpose          &                                    \\
\Mathcad     & General Purpose          &                                    \\
\Mathematica & General Purpose          &                                    \\
\Mpfr        & arb. prec. arithmetic    & library                            \\
\MuPAD       & General Purpose          &                                    \\
\Ntl         & Number Theory library    & library                            \\
\Octave      & Numerical Computing      &                                    \\
\Pari        & Number Theory            &                                    \\
\Reduce      & General Purpose          &                                    \\
\Singular    & Polynomial Computations  &                                    \\
\Sumit       & ODE and Diff. eqns       & library                            \\
\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|lll}
System & \rm{License} & \rm{Status} & \rm{Web Location} \\
\hline
\GCL         & GPL         & Rosetta    & http://www.gnu.org/software/gcl    \\
\GnuPlot     & GPL         & Rosetta    & http://www.gnuplot.org             \\
\Haskell     & GPL         & Rosetta    & http://www.haskell.org             \\
\Readline    & GPL         & Rosetta    & http://prep.ai.mit.edu/pub/gnu/readline \\
\TeXmacs     & GPL         & Rosetta    & http://www.texmacs.org             \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \m{2}{\rm Unix/Microsoft user initialization file} \\
\hline
\Axiom       & \~{}/axiom.input          &                                   \\
\CoCoA       & \~{}/init.coc             &                                   \\
             & \~{}/userinit.coc         &                                   \\
\Derive      &                           & derive.ini                        \\
\DoCon       & \~/.ghci                  & (interactive system init.)        \\
\GAP         & \~{}/.gaprc               & GAP.RC                            \\
\Giac        & \~{}/.xcasrc              &                                   \\
\GiNaC       &                           &                                   \\
\Macsyma     & \~{}/macsyma-init.macsyma & mac-init.mac                      \\
\Magnus      &                           &                                   \\
\Maple       & \~{}/.mapleinit           & maplev5.ini                       \\
\Mathcad     &                           &                                   \\
\Mathematica & \~{}/init.m               & init.m                            \\
\Maxima      & \~{}/macsyma-init.macsyma & mac-init.mac                      \\
\MuPAD       & \~{}/.mupadinit           &
	$\backslash$mupad$\backslash$bin$\backslash$userinit.mu              \\
\Octave      &                           &                                   \\
\Pari        & \~{}/.gprc                &                                   \\
\Reduce      & \~{}/.reducerc            & reduce.rc                         \\
\Singular    & \~{}/.singularrc          & \~{}/.singularrc                  \\
\Yacas       &                           &                                   \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Describe {\em keyword}} & \h{Find keywords containing {\em pattern}} \\
\hline
\Axiom       &                       & )what operations pattern              \\
\CoCoA       & H.Command("");        & Man("keyword");                       \\
\Derive      &                       &                                       \\
\DoCon       &                       &                                       \\
\GAP         & ?keyword              & ??keyword                             \\
\Giac        & ?keyword              &                                       \\
\GiNaC       &                       &                                       \\
\Macsyma     & describe("keyword")\$ & apropos("pattern");                   \\
\Magnus      &                       &                                       \\
\Maple       & ?keyword              & ?pattern\,\fnm                        \\
\Mathcad     & [F1]                  & [Shift][F1]                           \\
\Mathematica & ?keyword              & ?*pattern*                            \\
\Maxima      & describe("keyword")\$ & apropos("pattern");                   \\
\MuPAD       & ?keyword              & ?*pattern*                            \\
\Octave      & help -i keyword       &                                       \\
\Pari        &                       &                                       \\
\Reduce      &                       &                                       \\
\Singular    & ?keyword;             & ?*pattern*;                           \\
\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         \\
\CoCoA       & -- comment    & input<CR>input;     & It & Yes &              \\
\Derive      & "comment"     & input \~{}<CR>input &    & No  & real         \\
\DoCon       &               &                     &    &     &              \\
\Giac     & /* comment */ & input<CR>input;     & ans() & Yes  & real         \\
\GAP         & \# comment    & input$\backslash$<CR>input&last&Yes&no assumption\\
\Macsyma     & /* comment */ & input<CR>input;     & \% & No  & real         \\
\Magnus      &               &                     &    &     &              \\
\Maple       & \# comment    & input<CR>input;     & \% & Yes & complex      \\
\Mathcad     & Text Region   &                     &    &     &              \\
\Mathematica & (* comment *) & input<CR>input      & \% & Yes & complex      \\
\Maxima      & /* comment */ & input<CR>input;     & \% & No  & real         \\
\MuPAD       & \# comment \# & input<CR>input;     & \% & Yes & complex      \\
\Octave      & \#\#          &                     &    & Yes &              \\
\Pari        &               &                     &    &     &              \\
\Reduce      & \% comment    & input<CR>input;     & ws & No  & complex      \\
\Singular    & // comment    & input<CR>input;     & \_ & Yes  & none        \\
\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       \\
\CoCoA       & << 'MySession'         & Time T := F();   & Quit; \OR\ Ciao;  \\
\Derive      & [Transfer Load Derive] &                        & [Quit]      \\
\DoCon       &                        &                        &             \\
\Giac        & read("file"):          & always on & Ctrl-D/[Quit]        \\
\GAP         & Read("file");          & time; \h{(also see {\tt Runtime();})}&quit;\\
\Macsyma     & load("file")\$         & showtime: all\$        & quit();     \\
\Magnus      &                        &                        &             \\
\Maple       & read("file"):          & readlib(showtime): on; & quit        \\
\Mathcad     & File: Open Document    &                        & File: Exit  \\
\Mathematica & << file                & Timing[command]        & Quit[]      \\
\Maxima      & load("file")\$         & showtime: all\$        & quit();     \\
\MuPAD       & read("file"):          & time(command);         & quit        \\
\Octave      & load file              & tic(); cmd ; toc()     & quit \OR\ exit\\
\Pari        &                        &                        &             \\
\Reduce      & in "file"\$            & on time;               & quit;       \\
\Singular    & < "file";              & timer=1;               & quit;       \\
\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])         \\
\CoCoA       & input; &             & Subst(F,[z,w]);                        \\
\Derive      & input  & var:= input & [Manage Substitute]                    \\
\DoCon       &        &             &                                        \\
\Giac       & input & nodisp(input) & subst(f(x, y), [x, y],[z, w]);         \\
\GAP         & input; & input;;     & Value(f,[x,y],[z,w]);\fnm              \\
\Macsyma     & input; & input\$     & subst([x = z, y = w], f(x, y));        \\
\Magnus      &        &             &                                        \\
\Maple       & input; & input:      & subs(\{x = z, y = w\}, f(x, y));       \\
\Mathcad     &        &             &                                        \\
\Mathematica & input  & input;      & f[x, y] /. \{x -> z, y -> w\}          \\
\Maxima      & input; & input\$     & subst([x = z, y = w], f(x, y));        \\
\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));        \\
\Singular    & input; & default     & substitute(f,x,z,y,w)                  \\
\Yacas       &        &             &                                        \\
\end{tabular} \\[10pt]

\footnotetext{Only if $f$ is a rational function involving the variables $x$ and $y$.}

\begin{tabular}{l|lll}
& \h{Set} & \h{List} & \h{Matrix} \\
\hline
\Axiom       & set [1, 2] & [1, 2]   & matrix([[1, 2],[3, 4]])            \\
\CoCoA       & Set([1,2]) & [1, 2]   & Mat[[1,2],[3,4]];                  \\
\Derive      & \{1, 2\}   & [1, 2]   & [[1,2], [3,4]]                     \\
\DoCon       &            &          &                                    \\
\Giac        & set[1,2]   & [1, 2]   & [[1,2], [3,4]]                 \\
\GAP         & Set([1,2]) & [1, 2]   & [[1,2], [3,4]]\fnm                 \\
\Macsyma     & [1, 2]     & [1, 2]   & matrix([1, 2], [3, 4])             \\
\Magnus      &            &          &                                    \\
\Maple       & \{1, 2\}   & [1, 2]   & matrix([[1, 2], [3, 4]])           \\
\Mathcad     &            &          & Math: Matrices                     \\
\Mathematica & \{1, 2\}   & \{1, 2\} & \{\{1, 2\}, \{3, 4\}\}             \\
\Maxima      & [1, 2]     & [1, 2]   & matrix([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))                \\
\Singular    &            &          &                                    \\
\Yacas       &            &          &                                    \\
\end{tabular} \\[10pt]

\footnotetext{There are special compressed matrices over finite fields}

\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          \\
\CoCoA       &        & L[2]       & L[2,3]        & Len(L)       \\
\Derive      & x = 0  & l SUB 2    & m SUB 2 SUB 3 & DIMENSION(l) \\
\DoCon       &        &            &               &              \\
\Giac        & x = 0  & l[2]       & m[2, 3]       & size(l)    \\
\GAP         & x = 0  & l[2]       & m[2][3]       & Length(l)    \\
\Macsyma     & x = 0  & l[2]       & m[2, 3]       & length(l)    \\
\Magnus      &        &            &               &              \\
\Maple       & x = 0  & l[2]       & m[2, 3]       & nops(l)      \\
\Mathcad     &        & l[2        & M[2,3         &              \\
\Mathematica & x == 0 & l[[2]]     & m[[2, 3]]     & Length[l]    \\
\Maxima      & 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)    \\
\Singular    & x == 0 & l[2]       & m[2, 3]       & size(l)      \\
\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)   \\
\CoCoA       & Concat([E1],L1)      & Append(L, E)   & Concat(L1, L2)   \\
\Derive      & APPEND([e], l)       & APPEND(l, [e]) & APPEND(l1, l2)   \\
\DoCon       &                      &                &                  \\
\Giac        & prepend(l,e)         & append(l,e)    & concat(l1,l2)    \\
\GAP         & Concatenation([e],l) & Add(l,e)       & Append(l1, l2)   \\
\Macsyma     & cons(e, l)           & endcons(e, l)  & append(l1, l2)   \\
\Magnus      &                      &                &                  \\
\Maple       & [e, op(l)]           & [op(l), e]     & [op(l1), op(l2)] \\
\Mathcad     &                      &                &                  \\
\Mathematica & Prepend[l, e]        & Append[l, e]   & Join[l1, l2]     \\
\Maxima      & cons(e, l)           & endcons(e, l)  & append(l1, l2)   \\
\MuPAD       & [e, op(l)]           & append(l, e)   & l1 . l2          \\
\Octave      &                      &                &                  \\
\Pari        &                      &                &                  \\
\Reduce      & e . l                & append(l, {e}) & append(l1, l2)   \\
\Singular    & insert(l,e,1)        & insert(l, e, size(l)+1) & l1+l2   \\
\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]))         \\
\CoCoA       & Len(ColumnVectors(M))     & Transposed(Mat(Vector([l])))   \\
\Derive      & DIMENSION(m SUB 1)        & [l]\`{}                        \\
\DoCon       &                           &                                \\
\Giac        & size(mat[0])              & tran([l])      \\
\GAP         & Length(mat[1])            & \h{objects are identical}      \\
\Macsyma     & mat\_\,ncols(m)           & transpose(matrix(l))           \\
\Magnus      &                           &                                \\
\Maple       & linalg[coldim](m)         & linalg[transpose](matrix([l])) \\
\Mathcad     &                           &                                \\
\Mathematica & Dimensions[m][[2]]        & Transpose[\{l\}]               \\
\Maxima      & mat\_\,ncols(m)           & transpose(matrix(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)      \\
\Singular    & ncols(m)                  & vector v;                      \\
             &                           & for(int i=1;i<=size(l);i++)    \\
             &                           & \{ v[i]=l[i]; \}               \\
\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)]              \\
\CoCoA       & V:=ColumnVectors(M);                        \\
             & List(V[1]);                                 \\
\Derive      & v\`{} SUB 1                                 \\
\DoCon       &                                             \\
\Giac        & tran(v)[0]                                  \\
\GAP         & \h{objects are identical}                   \\
\Macsyma     & part(transpose(v), 1)                       \\
\Magnus      &                                             \\
\Maple       & op(convert(linalg[transpose](v), listlist)) \\
\Mathcad     &                                             \\
\Mathematica & Flatten[v]                                  \\
\Maxima      & part(transpose(v), 1)                       \\
\MuPAD       & [op(v)]                                     \\
\Octave      &                                             \\
\Pari        &                                             \\
\Reduce      & load\_\,package(linalg)\$                   \\
             & for i:=1:row\_\,dim(v) collect(v(i, 1))     \\
\Singular    & list l;                                     \\
             & for(int i; i<=size(v);i++) \{ l[i]=v[i]; \} \\
\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 & =  & \~{}= \\
\CoCoA       & TRUE & FALSE & AND  & OR & NOT & =  & <>    \\
\Derive      & TRUE & FALSE & AND  & OR & NOT & =  & /=    \\
\DoCon       &      &       &      &    &     &    &       \\
\Giac        & 1    & 0     & \&\& & || & !   & == & !=    \\
\GAP         & true & false\fnm & and  & or & not & = & <> \\
\Macsyma     & true & false & and  & or & not & =  & \#    \\
\Magnus      &      &       &      &    &     &    &       \\
\Maple       & true & false & and  & or & not & =  & <>    \\
\Mathcad     &      &       &      &    &     &    &       \\
\Mathematica & True & False & \&\& & || & !   & == & !=    \\
\Maxima      & true & false & and  & or & not & =  & \#    \\
\MuPAD       & true & false & and  & or & not & =  & <>    \\
\Octave      &      &       &      &    &     &    &       \\
\Pari        &      &       &      &    &     &    &       \\
\Reduce      & t    & nil   & and  & or & not & =  & neq   \\
\Singular    & 1    & 0     & and  & or & not & == & <>    \\
\Yacas       &      &       &      &    &     &    &       \\
\end{tabular} \\[10pt]

\footnotetext{Some commands may also return {\tt fail} to indicate failure.}

\begin{tabular}{l|ll}
& \h{If+then+else statements} & \h{Strings (concatenated)} \\
\hline
\Axiom       & if \_ then \_ else if \_ then \_ else \_ & concat(["x", "y"])\\
\CoCoA       & If \_ Then \_ Elsif \_ Then \_ Else \_ End & Concat("x","y")   \\
\Derive      & IF(\_, \_, IF(\_, \_, \_))               & "xy"              \\
\DoCon       &                                          &                   \\
\Giac        & if (\_)\{ ; \} else \{ ; \}              & "x"+"y"           \\
\GAP         & if \_ then \_ elif \_ then \_ else \_ fi & Concatenation("x","y")\\
\Macsyma     & if \_ then \_ else if \_ then \_ else \_ & concat("x", "y")  \\
\Magnus      &                                          &                   \\
\Maple       & if \_ then \_ elif \_ then \_ else \_ fi & "x" . "y"         \\
\Mathcad     &                                          &                   \\
\Mathematica & If[\_, \_, If[\_, \_, \_]]               & "x" <> "y"        \\
\Maxima      & if \_ then \_ else if \_ then \_ else \_ & concat("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)\\
\Singular    & if (\_) \{ \_ \} else \{ \_ \}           & "x"+"y"            \\
\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]    \\
\CoCoA       & For I:=1 To N Do \_ End;            & List(1..10)             \\
\Derive      & VECTOR([x, y], i, 1, n)             & VECTOR(f(i), i, 1, n)   \\
\DoCon       &                                     &                         \\
\Giac        & for (;;)\{ \}                       & makelist(f,1,10) \\
\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      &                                     &                         \\
\Maple       & for i from 1 to n do x; y od;       & [f(i) \$ i = 1..n];     \\
\Mathcad     &                                     &                         \\
\Mathematica & Do[x; y, \{i, 1, n\}]               & Table[f[i], \{i, 1, n\}]\\
\Maxima      & for i:1 thru n do (x, y);           & makelist(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);\\
\Singular    & for(int i=n;i>0;i--) \{ x;y; \}     & list l; for(int i=n;i>0;i--)\\
\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)         \\
\CoCoA       & For X In [2, 3, 5] Do While X\^{}2 < 10 Do PrintLn(X) End; End;\\
\Derive      &                                                             \\
\DoCon       &                                                             \\
\Giac        & l:=[2,3,5]; for (j:=0;(j<size(l)) \&\& (l[j]\^{}2<10);j++)\{ print(l[j]); \} \\
\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      &                                                             \\
\Maple       & for x in [2, 3, 5] while x\^{}2 < 10 do print(x) od:        \\
\Mathcad     &                                                             \\
\Mathematica & For[l = \{2, 3, 5\}, l != \{\} \&\& l[[1]]\^{}2 < 10,       \\
             & \q l = Rest[l], Print[l[[1]]] ]                             \\
\Maxima      & for x in [2, 3, 5] while x\^{}2 < 10 do print(x)\$          \\
\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)\$ \\
\Singular    & for(l=list(2,3,5);size(l>0;l=delete(l,1))                   \\
             & \q \{ if(l[1]\^2<10) \{ l[1];\}\}                           \\
\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}                                   \\
\CoCoA       & Y:= F(x); & F(X,Y):=X*Y;                & Delete Y;          \\
\Derive      & y:= f(x)  & f(x, y):= x*y               & y:=  f:=           \\
\DoCon       &           &                             &                    \\
\Giac        & y:= f(x)  & f(x,y):= x*y                & purge(y)           \\
\GAP         & y:= f(x); & f:=function(x, y) return x*y; end; & \h{no symbolic variables}\\
\Macsyma     & y: f(x);  & f(x, y):= x*y;              & remvalue(y)\$      \\
             &           &                             & remfunction(f)\$   \\
\Magnus      &           &                             &                    \\
             &           &                             & remfunction(f)\$   \\
\Maple       & y:= f(x); & f:= proc(x, y) x*y end;     & y:= 'y':  f:= 'f': \\
\Mathcad     &           &                             &                    \\
\Mathematica & y = f[x]  & f[x\_, y\_\,]:= x*y         & Clear[y, f]        \\
\Maxima      & y: f(x);  & f(x, y):= x*y;              & remvalue(y)\$      \\
\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;        \\
\Singular    & y=f(x);   & proc f(x,y)                 & kill y,f;          \\
\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)                           \\
\CoCoA       & Define F(X) N:=2; Return N*; End;                       \\
\Derive      &                                                         \\
\DoCon       &                                                         \\
\Giac        & f(x):=\{ local n; n:=2; return(n*x); \}                 \\
\GAP         & f:=function(x) local n; n:=2;return n*x; end;           \\
\Macsyma     & f(x):= block([n], n: 2, n*x);                           \\
\Magnus      &                                                         \\
\Maple       & f:= proc(x) local n; n:= 2; n*x end;                    \\
\Mathcad     &                                                         \\
\Mathematica & f[x\_\,]:= Module[\{n\}, n = 2; n*x]                    \\
\Maxima      & f(x):= block([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; \\
\Singular    & proc f(int x) \{ int n=2; return(n*x); \}               \\
\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)          \\
\CoCoA       &                        &                               \\
\Derive      & e:= x*y\q 'e           & f(x, y):== e                  \\
\DoCon       &                        &                               \\
\Giac        & e:=x*y\q quote(e)      & f:=program([x,y],[0,0],e)   \\
\GAP         & \h{No unevaluated symbols}\fnm&                        \\
\Macsyma     & e: x*y\$\q 'e;         & define(f(x, y), e);           \\
\Magnus      &                        &                               \\
\Maple       & e:= x*y:\q 'e';        & f:= unapply(e, x, y);         \\
\Mathcad     &                        &                               \\
\Mathematica & e = x*y;\q HoldForm[e] & f[x\_, y\_\,] = e             \\
\Maxima      & e: x*y\$\q 'e;         & define(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; \\
\Singular    & string e="x*y";        & proc f(x,y)                   \\
             &                        & \{ execute("return("+e+");");\}\\
\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;}.}
%% tpdhere \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])         \\
\CoCoA       &                                   & Sum([1,2]);               \\
\Derive      & LST l:= l                         &                           \\
\DoCon       &                                   &                           \\
\Giac        & lst():= \{ print(args); \}        & '+'([1,2])                \\
\GAP         & lst:=function(args) \_ end;       & Sum([1,2])                \\
\Macsyma     & lst([l]):= l;                     & apply("+", [1, 2])        \\
\Magnus      &                                   &                           \\
\Maple       & lst:=proc() [args[1..nargs]] end; & convert([1, 2], \`{}+\`{})\\
\Mathcad     &                                   &                           \\
\Mathematica & lst[l\_\,\_\,\_\,]:= \{l\}        & Apply[Plus, \{1, 2\}]     \\
\Maxima      & lst([l]):= l;                     & apply("+", [1, 2])        \\
\MuPAD       & lst:= proc(l) begin [args()]      & \_\,plus(op([1, 2]))      \\
             & \q\q\q end\_\,proc;               &                           \\
\Octave      &                                   &                           \\
\Pari        &                                   &                           \\
\Reduce      &                                   & xapply(+, \{1, 2\})\,\fnm \\
\Singular    & proc f(list \#) \{ \_ \}          &                           \\
\Yacas       &                                   &                           \\
\end{tabular} \\[10pt]

\footnotetext{\tt procedure xapply(f, lst); lisp(f . cdr(lst))\$}
%% tpdhere \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])               \\
\CoCoA       & Call(Function("F"),l)& L:=[];                                 \\
             &                      & Foreach I In [1,2] Do \\
             &                      &  Append(L,Call(Function("F"),I); End;  \\
\Derive      &                      & x:= [1, 2]                             \\
             &                      & VECTOR(x SUB i + y, i, 1, DIMENSION(x))\\
\DoCon       &                      &                                        \\
\Giac        & map(f,l)             & NA (C++) \\
\GAP         & List(l,f)            & List([1,2],x->x+y)                     \\
\Macsyma     & apply(f, l)          & map(lambda([x], x + y), [1, 2])        \\
\Magnus      &                      &                                        \\
\Maple       & f(op(l))             & map(x -> x + y, [1, 2])                \\
\Mathcad     &                      &                                        \\
\Mathematica & Apply[f, l]          & Map[\# + y \&, \{1, 2\}]               \\
\Maxima      & apply(f, l)          & map(lambda([x], x + y), [1, 2])        \\
\MuPAD       & f(op(l))             & map([1, 2], func(x + y, x))            \\
\Octave      &                      &                                        \\
\Pari        &                      &                                        \\
\Reduce      & xapply(f, l)\,       & for each x in \{1, 2\} collect x + y   \\
\Singular    &                      &                                        \\
\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))                                   \\
\CoCoA       &                                                         \\
\Derive      &                                                         \\
\DoCon       &                                                         \\
\Giac        & NA/C++ \\
\GAP         &                                                         \\
\Macsyma     & matchdeclare(n, integerp, x, true)\$                    \\
             & defrule(fnx, f(n*x), n*f(x))\$                          \\
             & apply1(f(3*y) + f(z*y), fnx);                           \\
\Magnus      &                                                         \\
\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));                                  \\
\Mathcad     &                                                         \\
\Mathematica & f[3*y] + f[z*y] /. f[n\_Integer * x\_\,] -> n*f[x]      \\
\Maxima      & matchdeclare(n, integerp, x, true)\$                    \\
             & defrule(fnx, f(n*x), n*f(x))\$                          \\
             & apply1(f(3*y) + f(z*y), fnx);                           \\
\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)\}; \\
\Singular    &                                                         \\
\Yacas       &                                                         \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Define a new infix operator and then use it} \\
\hline
\Axiom       &                                                               \\
\CoCoA       &                                                               \\
\Derive      &                                                               \\
\DoCon       &                                                               \\
\GAP     &\h{One can overload existing infix operators for ones own purposes}\\
\Giac    & C++ (loadable module) \\
\Macsyma     & infix("\~{}")\$ \q "\~{}"(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
	3 \~{} 4;                                                            \\
\Magnus      &                                                               \\
\Maple       & \`{}\&\~{}\`{}:= (x, y) -> sqrt(x\^{}2 + y\^{}2): \q 3 \&\~{} 4;
	                                                                     \\
\Mathcad     &                                                               \\
\Mathematica & x\_ $\backslash$[Tilde] y\_:= Sqrt[x\^{}2 + y\^{}2]; \q
	3 $\backslash$[Tilde] 4                                              \\
\Maxima      & infix("\~{}")\$ \q "\~{}"(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
	3 \~{} 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;                                                               \\
\Singular    &                                                               \\
\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)              \\
\CoCoA       &            &                &                         \\
\Derive      &            &                & {\em various}\fnm       \\
\DoCon       &            &                &                         \\
\Giac        & sommet(e)  & feuille(e)[0]  & feuille(e)              \\
\GAP         &\m{3}{\rm There are no formal unevaluated expressions} \\
\Macsyma     & part(e, 0) & part(e, 1)     & args(e)                 \\
\Magnus      &            &                &                         \\
\Maple       & op(0, e)   & op(1, e)       & [op(e)]                 \\
\Mathcad     &            &                &                         \\
\Mathematica & Head[e]    & e[[1]]         & ReplacePart[e, List, 0] \\
\Maxima      & part(e, 0) & part(e, 1)     & args(e)                 \\
\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) \\
\Singular    &            &                &                         \\
\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))]));                                     \\
\CoCoA       & PrintLn "Does Sin exist?";                                \\
\Derive      & "sin(0)" = sin(0)                                         \\
\DoCon       &                                                           \\
\Giac        & print("sin",0,") =",sin(0))                               \\
\GAP         & Print("There is no sin, but factors(10)= ",Factors(10),
"$\backslash$n")                                                         \\
\Macsyma     & print("sin(", 0, ") =", sin(0))\$                         \\
\Magnus      &                                                           \\
\Maple       & printf("sin(\%a) = \%a$\backslash$n", 0, sin(0)):         \\
\Mathcad     &                                                           \\
\Mathematica & Print[StringForm["sin(\`{}\`{}) = \`{}\`{}", 0, Sin[0]]]; \\
\Maxima      & print("sin(", 0, ") =", sin(0))\$                         \\
\MuPAD       & print(Unquoted, "sin(".0.")" = sin(0)):                   \\
\Octave      &                                                           \\
\Pari        &                                                           \\
\Reduce      & write("sin(", 0, ") = ", sin(0))\$                        \\
\Singular    & "sin(",0,") =", sin(0);                                   \\
\Yacas       &                                                           \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Generate FORTRAN} & \h{Generate \TeX/\LaTeX} \\
\hline
\Axiom       & outputAsFortran(e)                    & outputAsTex(e)      \\
\CoCoA       &                                       & Latex(e);           \\
\Derive      & [Transfer Save Fortran]               &                     \\
\DoCon       &                                       &                     \\
\GAP         &                                       & Print(LaTeX(e));    \\
\Giac        &                                       & C++ gen2tex         \\
\Macsyma     & fortran(e)\$ \OR gentran(eval(e))\$   & tex(e);             \\
\Magnus      &                                       &                     \\
\Maple       & fortran([e]);                         & latex(e);           \\
\Mathcad     &                                       &                     \\
\Mathematica & FortranForm[e]                        & TexForm[e]          \\
\Maxima      & fortran(e)\$ \OR gentran(eval(e))\$   & tex(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; \\
\Singular    &                                       & LIB "latex.lib";    \\
             &                                       & texobj(e);          \\
\Yacas       &                                       &                     \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Import two space separated columns of integers from {\tt file}} \\
\hline
\Axiom       &                                                     \\
\CoCoA       &                                                     \\
\Derive      & [Transfer Load daTa] ({\rm from} file.dat)          \\
\DoCon       &                                                     \\
\Giac        & NA (C++)                                            \\
\GAP         &                                                     \\
\Macsyma     & xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ \\
\Magnus      &                                                     \\
\Maple       & xy:= readdata("file", integer, 2):                  \\
\Mathcad     &                                                     \\
\Mathematica & xy = ReadList["file", Number, RecordLists -> True]  \\
\Maxima      & xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ \\
\MuPAD       &                                                     \\
\Octave      &                                                     \\
\Pari        &                                                     \\
\Reduce      &                                                     \\
\Singular    &                                                     \\
\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)\\
\CoCoA       &                                                               \\
\DoCon       &                                                               \\
\Giac        & NA (C++) \\
\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      &                                                               \\
\Maple       & writedata("file", xy);                                        \\
\Mathcad     &                                                               \\
\Mathematica & outfile = OpenWrite["file"];                                  \\
             & Do[WriteString[outfile,                                       \\
             & \q xy[[i, 1]], " ", xy[[i, 2]], "$\backslash$n"], \{i, 1, n\}]\\
             & Close[outfile];                                               \\
\Maxima      & writefile("file")\$ \q for i:1 thru n do                      \\
             & \q print(xy[i, 1], xy[i, 2])\$ \q closefile()\$               \\
\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";            \\
\Singular    & link l=":w file";(open(l);                                    \\
             & for(int i=1;i<=n;i++) \{ write(l,xy[i,1]," ",xy[i,2]); \}     \\
	     & close(l);                                                     \\
\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)   \\
\CoCoA       &        &      &     &                & Isqrt(2)&            \\
\Derive      & \#e    & pi   & \#i & inf            & SQRT(2) & 2\^{}(1/3) \\
\DoCon       &        &      &     &                &         &            \\
\GAP         &        &      & E(4) & infinity & ER(2)\fnm &               \\
\Giac        & e      & pi   & i   & +infinity      & sqrt(2) & 2\^{}(1/3) \\
\Macsyma     & \%e    & \%pi & \%i & inf            & sqrt(2) & 2\^{}(1/3) \\
\Magnus      &        &      &     &                &         &            \\
\Maple       & exp(1) & Pi   & I   & infinity       & sqrt(2) & 2\^{}(1/3) \\
\Mathcad     &        &      &     &                &         &            \\
\Mathematica & E      & Pi   & I   & Infinity       & Sqrt[2] & 2\^{}(1/3) \\
\Maxima      & \%e    & \%pi & \%i & inf            & 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) \\
\Singular    &        &      &     &                &         &            \\
\Yacas       &        &      &     &                &         &            \\
\end{tabular} \\[10pt]
\footnotetext{{\tt ER} represents special cyclotomic numbers and is not a
root function.}
%% tpdhere \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) \\
\CoCoA       &                &        &           &              \\
\Derive      & euler\_\,gamma & LOG(x) & ATAN(x)   & n!           \\
\DoCon       &                &        &           &              \\
\Giac        & -psi(1)        & log(x) & atan(x)   & factorial(n) \\
\GAP         &                & LogInt(x,base) && Factorial(n)    \\
\Macsyma     & \%gamma        & log(x) & atan(x)   & n!           \\
\Magnus      &                &        &           &              \\
\Maple       & gamma          & log(x) & arctan(x) & n!           \\
\Mathcad     &                &        &           &              \\
\Mathematica & EulerGamma     & Log[x] & ArcTan[x] & n!           \\
\Maxima      & \%gamma        & log(x) & atan(x)   & n!           \\
\MuPAD       & EULER          & ln(x)  & atan(x)   & n!           \\
\Octave      &                &        &           &              \\
\Pari        &                &        &           &              \\
\Reduce      & Euler\_\,Gamma & log(x) & atan(x)   & factorial(n) \\
\Singular    &                &        &           &              \\
\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)           \\
\CoCoA       &                          &                            \\
\Derive      & LEGENDRE\_\,P(n, x)      & CHEBYCHEV\_\,T(n, x)       \\
\DoCon       &                          &                            \\
\GAP         &                          &                            \\
\Giac        & legendre(n)              & tchebyshev1(n)             \\
\Macsyma     & legendre\_\,p(n, x)      & chebyshev\_\,t(n, x)       \\
\Magnus      &                          &                            \\
\Maple       & orthopoly[P](n, x)       & orthopoly[T](n, x)         \\
\Mathcad     &                          &                            \\
\Mathematica & LegendreP[n, x]          & ChebyshevT[n, x]           \\
\Maxima      & legendre\_\,p(n, x)      & chebyshev\_\,t(n, x)       \\
\MuPAD       & orthpoly::legendre(n, x) & orthpoly::chebyshev1(n, x) \\
\Octave      &                          &                            \\
\Pari        &                          &                            \\
\Reduce      & LegendreP(n, x)          & ChebyshevT(n, x)           \\
\Singular    &                          &                            \\
\Yacas       &                          &                            \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Fibonacci number} & \h{Elliptic integral of the \nth{1} kind} \\
\hline
\Axiom       & fibonacci(n)           &                            \\
\CoCoA       &                        &                            \\
\Derive      & FIBONACCI(n)           & ELLIPTIC\_\,E(phi, k\^{}2) \\
\DoCon       &                        &                            \\
\GAP         & Fibonacci(n)           &                            \\
\Giac        &                        &                            \\
\Macsyma     & fib(n)                 & elliptic\_\,e(phi, k\^{}2) \\
\Magnus      &                        &                            \\
\Maple       & combinat[fibonacci](n) & EllipticE(sin(phi), k)     \\
\Mathcad     &                        &                            \\
\Mathematica & Fibonacci[n]           & EllipticE[phi, k\^{}2]     \\
\Maxima      & fib(n)                 & elliptic\_\,e(phi, k\^{}2) \\
\MuPAD       & numlib::fibonacci(n)   &                            \\
\Octave      &                        &                            \\
\Pari        &                        &                            \\
\Reduce      &                        & EllipticE(phi, k\^{}2)     \\
\Singular    & LIB "general.lib";     &                            \\
             & fibonacci(n);          &                            \\
\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)     \\
\CoCoA       &          &              &                 &                   \\
\Derive      & GAMMA(x) & PSI(x)       & CI(x)           & BESSEL\_\,J(n, x) \\
\DoCon       &          &              &                 &                   \\
\GAP         &          &              &                 &                   \\
\Giac        & gamma(x) & psi(x)       &                 &                   \\
\Macsyma     & gamma(x) & psi[0](x)    & cos\_\,int(x)   & bessel\_j[n](x)   \\
\Magnus      &          &              &                 &                   \\
\Maple       & GAMMA(x) & Psi(x)       & Ci(x)           & BesselJ(n, x)     \\
\Mathcad     &          &              &                 &                   \\
\Mathematica & Gamma[x] & PolyGamma[x] & CosIntegral[x]  & BesselJ[n, x]     \\
\Maxima      & gamma(x) & psi[0](x)    & cos\_\,int(x)   & bessel\_j[n](x)   \\
\MuPAD       & gamma(x) & psi(x)       &                 & besselJ(n, x)     \\
\Octave      &          &              &                 &                   \\
\Pari        &          &              &                 &                   \\
\Reduce      & Gamma(x) & Psi(x)       & Ci(x)           & BesselJ(n, x)     \\
\Singular    &          &              &                 &                   \\
\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       &                                    &          &               \\
\CoCoA       &                                    &          &               \\
\Derive      & GAUSS(a, b, c, x)                  &          & STEP(x)       \\
\DoCon       &                                    &          &               \\
\GAP         &                                    &          &               \\
\Giac        &                                    &          &               \\
\Macsyma     & hgfred([a, b], [c], x)             & delta(x) & unit\_\,step(x)
	                                                                     \\
\Magnus      &                                    &          &               \\
\Maple       & hypergeom([a, b], [c], x)          & Dirac(x) & Heaviside(x)  \\
\Mathcad     &                                    &          &               \\
\Mathematica & HypergeometricPFQ[\{a,b\},\{c\},x] &
	\m{2}{<< Calculus\`{}DiracDelta\`{}}                                 \\
\Maxima      & hgfred([a, b], [c], x)             & delta(x) & unit\_\,step(x)
	                                                                     \\
\MuPAD       &                                    & dirac(x) & heaviside(x)  \\
\Octave      &                                    &          &               \\
\Pari        &                                    &          &               \\
\Reduce      & hypergeometric(\{a, b\}, \{c\}, x) &          &               \\
\Singular    &                                    &          &               \\
\Yacas       &                                    &          &               \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Define $|x|$ via a piecewise function} \\
\hline
\Axiom       &                                                     \\
\CoCoA       &                                                     \\
\Derive      & a(x):= -x*CHI(-inf, x, 0) + x*CHI(0, x, inf)        \\
\DoCon       &                                                     \\
\GAP         &                                                     \\
\Giac        & \\
\Macsyma     & a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$    \\
\Magnus      &                                                     \\
\Maple       & a:= x -> piecewise(x < 0, -x, x):                   \\
\Mathcad     &                                                     \\
\Mathematica & << Calculus\`{}DiracDelta\`{}                       \\
             & a[x\_]:= -x*UnitStep[-x] + x*UnitStep[x]            \\
\Maxima      & a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$    \\
\MuPAD       & a:= proc(x) begin -x*heaviside(-x) + x*heaviside(x) \\
             & \q\q end\_\,proc:                                   \\
\Octave      &                                                     \\
\Pari        &                                                     \\
\Reduce      &                                                     \\
\Singular    &                                                     \\
\Yacas       &                                                     \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Assume $x$ is real} & \h{Remove that assumption} \\
\hline
\Axiom       &                           &                             \\
\CoCoA       &                           &                             \\
\Derive      & x :epsilon Real           & x:=                         \\
\DoCon       &                           &                             \\
\GAP         &                           &                             \\
\Giac        & assume(x,real)            & purge(x)                    \\
\Macsyma     & declare(x, real)\$        & remove(x, real)\$           \\
\Magnus      &                           &                             \\
\Maple       & assume(x, real);          & x:= 'x':                    \\
\Mathcad     &                           &                             \\
\Mathematica & x/: Im[x] = 0;            & Clear[x]                    \\
\Maxima      & declare(x, real)\$        & remove(x, real)\$           \\
\MuPAD       & assume(x, Type::RealNum): & unassume(x, Type::RealNum): \\
\Octave      &                           &                             \\
\Pari        &                           &                             \\
\Reduce      &                           &                             \\
\Singular    &                           &                             \\
\Yacas       &                           &                             \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Assume $0 < x \le 1$} & \h{Remove that assumption} \\
\hline
\Axiom       &                                 &                         \\
\CoCoA       &                                 &                         \\
\Derive      & x :epsilon (0, 1]               & x:=                     \\
\DoCon       &                                 &                         \\
\GAP         &                                 &                         \\
\Giac        & assume(x>0 \&\& x<=1)             & purge(x)                \\
\Macsyma     & assume(x > 0, x <= 1)\$         & forget(x > 0, x <= 1)\$ \\
\Magnus      &                                 &                         \\
\Maple       & assume(x > 0);                  & x:= 'x':                \\
             & additionally(x <= 1);           &                         \\
\Mathcad     &                                 &                         \\
\Mathematica & Assumptions -> 0 < x <= 1\,\fnm &                         \\
\Maxima      & assume(x > 0, x <= 1)\$         & forget(x > 0, x <= 1)\$ \\
\MuPAD       & assume(x > 0):  assume(x <= 1): & unassume(x):            \\
\Octave      &                                 &                         \\
\Pari        &                                 &                         \\
\Reduce      &                                 &                         \\
\Singular    &                                 &                         \\
\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) \\
\CoCoA       &                                                        \\
\Derive      & e                                                      \\
\DoCon       &                                                        \\
\GAP         & e                                                      \\
\Giac        & simplify(e) \\
\Macsyma     & ratsimp(e) \OR\ radcan(e)                              \\
\Magnus      &                                                        \\
\Maple       & simplify(e)                                            \\
\Mathcad     &                                                        \\
\Mathematica & Simplify[e] \OR\ FullSimplify[e]                       \\
\Maxima      & ratsimp(e) \OR\ radcan(e)                              \\
\MuPAD       & simplify(e) \OR\ normal(e)                             \\
\Octave      &                                                        \\
\Pari        &                                                        \\
\Reduce      & e                                                      \\
\Singular    &                                                        \\
\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 \\
\CoCoA       &                           &                         \\
\Derive      & f(x):=                    & Precision:= Approximate \\
             & f(x)                      & APPROX(EXP(1))          \\
             &                           & Precision:= Exact       \\
\DoCon       &                           &                         \\
\Giac        & f(x)                      & evalf(exp(1))           \\
\GAP         &                           & EvalF(123/456)          \\
\Macsyma     & f(x)                      & sfloat(exp(1));         \\
\Magnus      &                           &                         \\
\Maple       & f(x)                      & evalf(exp(1));          \\
\Mathcad     &                           &                         \\
\Mathematica & f[x]                      & N[Exp[1]]               \\
\Maxima      & f(x)                      & sfloat(exp(1));         \\
\MuPAD       & f(x)                      & float(exp(1));          \\
\Octave      &                           &                         \\
\Pari        &                           &                         \\
\Reduce      & operator f; \q f(x)       & on rounded; \q exp(1);  \\
             &                           & off rounded;            \\
\Singular    &                           &                         \\
\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)        \\
\CoCoA       &                 &                                         \\
\Derive      & MOD(n, m)       & SOLVE\_\,MOD(e = 0, x, m)               \\
\DoCon       &                 &                                         \\
\GAP         & n mod m         & \h{solve using finite fields}           \\
\Giac        & n \% m          & \\
\Macsyma     & mod(n, m)       & modulus: m\$ \q solve(e = 0, x)         \\
\Magnus      &                 &                                         \\
\Maple       & n mod m         & msolve(e = 0, m)                        \\
\Mathcad     &                 &                                         \\
\Mathematica & Mod[n, m]       & Solve[\{e == 0, Modulus == m\}, x]      \\
\Maxima      & mod(n, m)       & modulus: m\$ \q solve(e = 0, 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)        \\
\Singular    & n mod m         &                                         \\
\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) \\
\CoCoA       &                            &                              \\
\Derive      & FACTOR(a/b + c/d, Trivial) & EXPAND((a*d + b*c)/(b*d))    \\
\DoCon       &                            &                              \\
\GAP         & a/b+c/d                    &                              \\
\Giac        & normal(a/b + c/d)          &                              \\
\Macsyma     & xthru(a/b + c/d)           & expand((a*d + b*c)/(b*d))    \\
\Magnus      &                            &                              \\
\Maple       & normal(a/b + c/d)          & expand((a*d + b*c)/(b*d))    \\
\Mathcad     &                            &                              \\
\Mathematica & Together[a/b + c/d]        & Apart[(a*d + b*c)/(b*d)]     \\
\Maxima      & xthru(a/b + c/d)           & expand((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)   \\
\Singular    & a/b + c/d                  &  (a*d + b*c)/(b*d)           \\
\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                               \\
\CoCoA       &                                                             \\
\Derive      &                                                             \\
\DoCon       &                                                             \\
\GAP         & x:=X(Rationals,"x");                                        \\
&\q a:=RootOfDefiningPolynomial(AlgebraicExtension(Rationals,x\^{}2-2));
a\^{}2                                                                     \\
\Giac        & x:=rootof([1,0],[1,0,-2]) \\
\Macsyma     & algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2);   \\
\Magnus      &                                                             \\
\Maple       & a:= RootOf(x\^{}2 - 2): \q simplify(a\^{}2);                \\
\Mathcad     &                                                             \\
\Mathematica & a = Root[\#\^{}2 - 2 \&, 2] \q a\^{}2                       \\
\Maxima      & algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2);   \\
\MuPAD       &                                                             \\
\Octave      &                                                             \\
\Pari        &                                                             \\
\Reduce      & load\_\,package(arnum)\$ \q defpoly(a\^{}2 - 2); \q a\^{}2; \\
\Singular    &                                                             \\
\Yacas       &                                                             \\
\end{tabular} \\[10pt]

\begin{tabular}{l|ll}
& \h{Noncommutative multiplication} & \h{Solve a pair of equations} \\
\hline
\Axiom       &                      & solve([eqn1, eqn2], [x, y])     \\
\CoCoA       &                      &                                 \\
\Derive      & x :epsilon Nonscalar & SOLVE([eqn1, eqn2], [x, y])     \\
             & y :epsilon Nonscalar &                                 \\
             & x . y                &                                 \\
\DoCon       &                      &                                 \\
\Giac        & NA                   & solve([eqn1, eqn2], [x, y])     \\
\GAP         & *                    &                                 \\
\Macsyma     & x . y                & solve([eqn1, eqn2], [x, y])     \\
\Magnus      &                      &                                 \\
\Maple       & x \&* y              & solve(\{eqn1, eqn2\}, \{x, y\}) \\
\Mathcad     &                      &                                 \\
\Mathematica & x ** y               & Solve[\{eqn1, eqn2\}, \{x, y\}] \\
\Maxima      & 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()            &                                 \\
\Singular    &                      & LIB "solve.lib";                \\
             &                      & solve(ideal(eqn1,eqn2));        \\
\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)))}                        \\
\CoCoA       &                               &                             \\
\Derive      & Trigonometry:= Expand         & Trigonometry:= Collect      \\
             & sin(2*x)                      & 2*sin(x)*cos(x)             \\
\DoCon       &                               &                             \\
\GAP         &                               &                             \\
\Giac        & texpand(sin(2*x))             & tlin(2*sin(x)*cos(x))       \\
\Macsyma     & trigexpand(sin(2*x))          & trigreduce(2*sin(x)*cos(x)) \\
\Magnus      &                               &                             \\
\Maple       & expand(sin(2*x))              & combine(2*sin(x)*cos(x))    \\
\Mathcad     &                               &                             \\
\Mathematica & TrigExpand[Sin[2*x]]          & TrigReduce[2*Sin[x]*Cos[x]] \\
\Maxima      & 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)) \\
\Singular    &                               &                             \\
\Yacas       &                               &                             \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Gr\"obner basis} \\
\hline
\Axiom       & groebner([p1, p2, ...])                                  \\
\CoCoA       & GBasis(Ideal(p1, p2, ...));                              \\
\Derive      &                                                          \\
\DoCon       &                                                          \\
\GAP         &                                                          \\
\Giac        & gbasis([p1,p2,...],[x,y,...])\\
\Macsyma     & grobner([p1, p2, ...])                                   \\
\Magnus      &                                                          \\
\Maple       & Groebner[gbasis]([p1, p2, ...], plex(x1, x2, ...))       \\
\Mathcad     &                                                          \\
\Mathematica & GroebnerBasis[\{p1, p2, ...\}, \{x1, x2, ...\}]          \\
\Maxima      & grobner([p1, p2, ...])                                   \\
\MuPAD       & groebner::gbasis([p1, p2, ...])                          \\
\Octave      &                                                          \\
\Pari        &                                                          \\
\Reduce      & load\_\,package(groebner)\$ \q groebner(\{p1, p2, ...\}) \\
\Singular    & groebner(ideal(p1,p2 ...))                               \\
\Yacas       &                                                          \\
\end{tabular} \\[10pt]

\begin{tabular}{l|l}
& \h{Factorization of $e$ over $i = \sqrt{-1}$} \\
\hline
\Axiom       & factor(e, [rootOf(i**2 + 1)])                            \\
\CoCoA       &                                                          \\
\Derive      & FACTOR(e, Complex)                                       \\
\DoCon       &                                                          \\
\GAP         & Factors(GaussianIntegers,e)                              \\
\Giac        & factor(e) in complex mode \\
\Macsyma     & gfactor(e); \OR\ factor(e, i\^{}2 + 1);                  \\
\Magnus      &                                                          \\
\Maple       & factor(e, I);                                            \\
\Mathcad     &                                                          \\
\Mathematica & Factor[e, Extension -> I]                                \\
\Maxima      & gfactor(e); \OR\ factor(e, i\^{}2 + 1);                  \\
\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;        \\
\Singular    & ring C=(0,i),x,dp;minpoly=i2+1;factorize(e);             \\
\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))             \\
\CoCoA       &                &                               \\
\Derive      & RE(f(z))       & f(z)                          \\
\DoCon       &                &                               \\
\GAP         & (f(z)+GaloisCyc(f(z),-1))/2&                   \\
\Giac        & re(f(z))       & re(f(z))+i*im(f(z))           \\
\Macsyma     & realpart(f(z)) & rectform(f(z))                \\
\Magnus      &                &                               \\
\Maple       & Re(f(z))       & evalc(f(z))                   \\
\Mathcad     &                &                               \\
\Mathematica & Re[f[z]]       & ComplexExpand[f[z]]           \\
\Maxima      & realpart(f(z)) & rectform(f(z))                \\
\MuPAD       & Re(f(z))       & rectform(f(z))                \\
\Octave      &                &                               \\
\Pari        &                &                               \\
\Reduce      & repart(f(z))   & repart(f(z)) + i*impart(f(z)) \\
\Singular    & repart(f(z))   * repart(f(z)) + i*impart(f(z)) \\
\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)         \\
\CoCoA       & A + B;       & A * B;         & Transposed(A);       \\
\Derive      & A + B        & A . B          & A\`{}                \\
\DoCon       &              &                &                      \\
\GAP         & A + B        & A * B          & TransposedMat(A)     \\
\Giac        & A + B        & A * B          & tran(A) \\
\Macsyma     & A + B        & A . B          & transpose(A)         \\
\Magnus      &              &                &                      \\
\Maple       & evalm(A + B) & evalm(A \&* B) & linalg[transpose](A) \\
\Mathcad     &              &                &                      \\
\Mathematica & A + B        & A . B          & Transpose[A]         \\
\Maxima      & A + B        & A . B          & transpose(A)         \\
\MuPAD       & A + B        & A * B          & transpose(A)         \\
\Octave      &              &                &                      \\
\Pari        &              &                &                      \\
\Reduce      & A + B        & A * B          & tp(A)                \\
\Singular    & A + B        & A * B          & transpose(A)         \\
\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 \_\_\_ \\
\CoCoA       &                                                          \\
\Derive      &                                                          \\
\DoCon       &                                                          \\
\GAP         & SolutionMat(TransposedMat(A),b)                          \\
\Giac        & NA rref(tran(concat(tran(A),[b]))) or inv(A)*b \\
\Macsyma     & xx: genvector('x, mat\_nrows(b))\$                       \\
             & x: part(matlinsolve(A . xx = b, xx), 1, 2)               \\
\Magnus      &                                                          \\
\Maple       & x:= linalg[linsolve](A, b)                               \\
\Mathcad     &                                                          \\
\Mathematica & x = LinearSolve[A, b]                                    \\
\Maxima      & xx: genvector('x, mat\_nrows(b))\$                       \\
             & x: part(matlinsolve(A . xx = b, xx), 1, 2)               \\
\MuPAD       &                                                          \\
\Octave      &                                                          \\
\Pari        &                                                          \\
\Reduce      &                                                          \\
\Singular    &                                                          \\
\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)    \\
\CoCoA       & L:=[];                 & L:=[];                     \\
             & Foreach I In 1..N Do   & Foreach I in 1..N Do       \\
             &  Append(L,F(I));       &  Append(L,F(I));           \\
             & End;                   & End;                       \\
             & Sum(L);                & Product(L);                \\
\Derive      & SUM(f(i), i, 1, n)     & PRODUCT(f(i), i, 1, n)     \\
\DoCon       &                        &                            \\
\GAP         & Sum([1..n],f)          & Product([1..n],f)          \\
\Giac        & sum(1/j,j,1..n)      & NA \\
\Macsyma     & closedform(            & closedform(                \\
             & \q sum(f(i), i, 1, n)) & \q product(f(i), i, 1, n)) \\
\Magnus      &                        &                            \\
\Maple       & sum(f(i), i = 1..n)    & product(f(i), i = 1..n)    \\
\Mathcad     &                        &                            \\
\Mathematica & Sum[f[i], \{i, 1, n\}] & Product[f[i], \{i, 1, n\}] \\
\Maxima      & closedform(            & closedform(                \\
             & \q sum(f(i), i, 1, n)) & \q 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)        \\
\Singular    &                        &                            \\
\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)   \\
\CoCoA       &                                 &                          \\
\Derive      & LIM(f(x), x, 0, -1)             & TAYLOR(f(x), x, 0, 3)    \\
\DoCon       &                                 &                          \\
\GAP         &                                 &                          \\
\Giac        & limit(f(x),x=0,-1)              & series(f(x),x=0,3)       \\
\Macsyma     & limit(f(x), x, 0, minus)        & taylor(f(x), x, 0, 3)    \\
\Magnus      &                                 &                          \\
\Maple       & limit(f(x), x = 0, left)        & series(f(x), x = 0, 4)   \\
\Mathcad     &                                 &                          \\
\Mathematica & Limit[f[x], x->0, Direction->1] & Series[f[x],\{x, 0, 3\}] \\
\Maxima      & limit(f(x), x, 0, minus)        & taylor(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)    \\
\Singular    &                                 &                          \\
\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)    \\
\CoCoA       &                            &                              \\
\Derive      & DIF(DIF(f(x, y), x), y, 2) & INT(f(x), x, 0, 1)           \\
\DoCon       &                            &                              \\
\GAP         &                            &                              \\
\Giac        & diff(f(x,y),[x,y],[1,2])   & integrate(f(x),x,0,1)        \\
\Macsyma     & diff(f(x, y), x, 1, y, 2)  & integrate(f(x), x, 0, 1)     \\
\Magnus      &                            &                              \\
\Maple       & diff(f(x, y), x, y\$2)     & int(f(x), x = 0..1)          \\
\Mathcad     &                            &                              \\
\Mathematica & D[f[x, y], x, \{y, 2\}]    & Integrate[f[x], \{x, 0, 1\}] \\
\Maxima      & diff(f(x, y), x, 1, 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)           \\
\Singular    & diff(diff(diff(f,x),y),y)  &                              \\
\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)        \\
\CoCoA       &                           &                                \\
\Derive      & LAPLACE(e, t, s)          &                                \\
\DoCon       &                           &                                \\
\GAP         &                           &                                \\
\Giac        & laplace(e,t,s)            & ilaplace(e,s,t)                \\
\Macsyma     & laplace(e, t, s)          & ilt(e, s, t)                   \\
\Magnus      &                           &                                \\
\Maple       & inttrans[laplace](e,t,s)  & inttrans[invlaplace](e,s,t)    \\
\Mathcad     &                           &                                \\
\Mathematica & \m{2}{\q << Calculus\`{}LaplaceTransform\`{}}              \\
             & LaplaceTransform[e, t, s] & {\st InverseLaplaceTransform[e,s,t]}
	                                                                  \\
\Maxima      & laplace(e, t, s)          & ilt(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)                \\
\Singular    &                           &                                \\
\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)                                      \\
\CoCoA       &                                                       \\
\Derive      & APPLY\_\,IC(RHS(ODE(eqn, x, y, y\_)), [x, 0], [y, 1]) \\
\DoCon       &                                                       \\
\GAP         &                                                       \\
\Giac        & desolve([y'+y=sin(x),y'(0)=1],x,y)                    \\
\Macsyma     & ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) \\
\Magnus      &                                                       \\
\Maple       & dsolve(\{eqn, D(y)(0) = 1\}, y(x))                    \\
\Mathcad     &                                                       \\
\Mathematica & DSolve[\{eqn, y'[0] == 1\}, y[x], x]                  \\
\Maxima      & ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) \\
\MuPAD       & solve(ode(\{eqn, D(y)(0) = 1\}, y(x)))                \\
\Octave      &                                                       \\
\Pari        &                                                       \\
\Reduce      & odesolve(eqn, y(x), x)                                \\
\Singular    &                                                       \\
\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))                             \\
\CoCoA       &                                                      \\
\Derive      &                                                      \\
\DoCon       &                                                      \\
\GAP         &                                                      \\
\Giac        & NA \\
\Macsyma     & load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x));  \\
\Magnus      &                                                      \\
\Maple       & id:= x -> x: \q L:= (D + id): \q L(sin)(x);          \\
\Mathcad     &                                                      \\
\Mathematica & L = D[\#, x]\& + Identity; \q Through[L[Sin[x]]]     \\
\Maxima      & load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x));  \\
\MuPAD       & L:= (D + id): \q L(sin)(x);                          \\
\Octave      &                                                      \\
\Pari        &                                                      \\
\Reduce      &                                                      \\
\Singular    &                                                      \\
\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);           \\
\CoCoA       &                                                           \\
\Derive      & [Plot Overlay]                                            \\
\DoCon       &                                                           \\
\GAP         &                                                           \\
\Giac        & plotfunc(x,x); plotfunc(sin(x),x);                        \\
\Macsyma     & plot(x, x, 0, 1)\$ \q plot(acsch(x), x, 0, 1)\$           \\
\Magnus      &                                                           \\
\Maple       & plot(\{x, arccsch(x)\}, x = 0..1):                        \\
\Mathcad     &                                                           \\
\Mathematica & Plot[\{x, ArcCsch[x]\}, \{x, 0, 1\}];                     \\
\Maxima      & plot(x, x, 0, 1)\$ \q plot(acsch(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))\$                        \\
\Singular    & LIB "surf.lib";\\
             & plot(((x+3)\^3+2*(x+3)\^2-y\^2)*(x\^3-y\^2)*((x-3)\^3-2*(x-3)\^2-y\^2));\fnm \\
\Yacas       &                                                           \\
\end{tabular} \\[10pt]
\footnotetext{\Singular can only plot polynomial objects}

\begin{tabular}{l|l}
& \h{Simple 3D plotting} \\
\hline
\Axiom       & draw(abs(x*y), x = 0..1, y = 0..1);              \\
\CoCoA       &                                                  \\
\Derive      & [Plot Overlay]                                   \\
\DoCon       &                                                  \\
\GAP         &                                                  \\
\Giac        & plotfunc(abs(x*y),[x,y],[0,1],[0,1])             \\
\Macsyma     & plot3d(abs(x*y), x, 0, 1, y, 0, 1)\$             \\
\Magnus      &                                                  \\
\Maple       & plot3d(abs(x*y), x = 0..1, y = 0..1):            \\
\Mathcad     &                                                  \\
\Mathematica & Plot3D[Abs[x*y], \{x, 0, 1\}, \{y, 0, 1\}];      \\
\Maxima      & 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))\$ \\
\Singular    & LIB "surf.lib"; plot(z\^2-x\^2*y);\fnm           \\
\Yacas       &                                                  \\
\end{tabular} \\[10pt]
\footnotetext{\Singular can only plot polynomial objects}

%\begin{tabular}{l|l}
%& \h{} \\
%\hline
%\Aldor       & \\
%\Axiom       & \\
%\CoCoA       & \\
%\Derive      & \\
%\DoCon       & \\
%\GAP         & \\
%\Giac        & \\
%\GiNaC       & \\
%\Gmp         & \\
%\Macsyma     & \\
%\Magnus      & \\
%\Maple       & \\
%\Mathcad     & \\
%\Mathematica & \\
%\Maxima      & \\
%\Mpfr        & \\
%\MuPAD       & \\
%\Ntl         & \\
%\Octave      & \\
%\Pari        & \\
%\Reduce      & \\
%\Singular    & \\
%\Sumit       & \\
%\Yacas       & \\
%\end{tabular} \\[10pt]

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