[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Axiom-mail] Re: Axiom, Rosetta and Quantian
|
From: |
root |
|
Subject: |
[Axiom-mail] Re: Axiom, Rosetta and Quantian |
|
Date: |
Fri, 12 Mar 2004 13:50:23 -0500 |
Dirk,
Great, I'm downloading the 0.4.9.5 iso now.
Yeah, Axiom is large. I've tried to package multiple math systems on a
single CD and eventually ran out of space. The Rosetta CD normally
contains about 10 systems (which vary depending on the conference).
But I'd like to find a way that all of the math package maintainers could
(a) have a coordinated outlet for their work and
(b) cooperate with each other to make the various systems compatible.
The Rosetta CD was originally intended to cover the first item but it
requires more work than one person can do and the cooperation of the
various maintainers.
The second item I've discussed many times in many places. The only
(current) result I've got is an attempt to develop a Computer Algebra
Test Suite (CATS). Many systems have ad-hoc test suites and the
expertise to develop tests in any area is quite limited. The idea is
to merge tests from the various systems (similar to the NIST work) so
we get expanded coverage by exploiting common work. CATS is intended
to be the Rosetta-like effort for common testing. I have a CATS
Gnu-arch branch available with the current effort but it is not yet
far along (it just started in August).
Cooperation has not been a big priority for commercial systems which
have tended to dominate the math scene. There is a very limited pool
of people who are "computational mathematicians" and their efforts
have been spread widely and thinly so far.
I think that we might give some thought to constructing a "scientific
workbench" kind of distribution from the kitchen sink version. Michel
Lavaud did a really nice front-end for his version of Rosetta that
made it possible to start individual packages from a list.
Re: Rosetta doc
The Rosetta document I maintain has "synonyms" for commands from
Axiom, Derive, GAP, Gmp, DoCon, Macsyma, Magnus, Maxima, Maple,
Mathematcia, MuPAD, Octave, Pari, Reduce, Scilab, Sumit, and Yacas.
Some of them are commercial but the idea is to allow someone
experienced in one system to gain a quick overview of a second
system. It's a fairly short document and I've appended it.
Re: Tony Rossini. Do you have an email address?
Tim
===================================================================
On Fri, Mar 12, 2004 at 12:53:00PM -0500, root wrote:
> Dirk,
>
> I've just tripped across your Quantian site.
> (http://dirk.eddelbuettel.com/quantian.html)
>
> I see that you have a CD tailored to numerical and quantitative analysis.
> I'd like to work with you on two fronts.
>
> FIrst, I'm the lead developer of Axiom, a large, free and open source
> computer algebra system. I'd like to work with you to add it to the
> Quantian CD if you feel it might be useful to your target audience.
Sure, I just checked and see that it is already packaged for Debian, and
even maintained by Camm, who is one of the number crunching whiz kids around
Debian.
But it also a huuuge package. If you look at the detailed package lists on
my Quantian sites, you see that there are few packages as large as that. I
cannot currently fit axiom on the cdrom edition of Quantian as those 700mb
(compressed) are taken up. That said, I should definitiely add it to the
next 'kitchen sink' release (of isos > 700mb that can be booted from hd by
lilo and friends, and will morph into bootable dvds, one day).
That said, there is also at least some interest into reverse-engineering
what Morphix does in terms of a core and several modules. There is enough
interest from different, non-overlapping user groups with non-overlapping
interests to warrant this. Unfortunately, I doubt i'll have time to look
into this.
> Second, I distribute a Rosetta CD at conferences I attend. I have dozens
> of free and open source algebra packages that I've collected and I
> select a subset of them, based on the nature of the conference, to
> create a CD. Perhaps some of them are of interest to you. In particular,
> I have a file called "Rosetta" that has tables which tell you how to
> write a command in a dozen different systems (e.g how to make a matrix
> in Axiom, Mathematica, Maple, etc).
Absolutely, that would be useful. Mind you, Debian cares less about
Mathematica and Maple as we can't distribute them. But to the extent that
users may have learned the ropes on those system, such cheat sheets are very
useful. From the Octave and R projects, I know that people work on and off
on these w.r.t. Matlab and S-Plus compatibility.
> Michel Lavaud distributes a similar Rosetta CD for Windows.
Tony Rossini at U of Washington has (had?) something with a stats / latex
focus that is (was?) sponsored by ASA (stats folks), if memory serves.
> Let me know if you have any interest.
Sure do, let's talk some more.
Thanks, Dirk
==========================================================================
\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{}
%
address@hidden
address@hidden@address@hidden
address@hidden@address@hidden
address@hidden@address@hidden@oddfoot}
address@hidden@address@hidden
address@hidden@address@hidden
address@hidden@address@hidden@oddfoot}
address@hidden
%
\def\sysdetails{\parbox{\textwidth}{%
Based on material originally published in {\sl Computer Algebra Systems: A
Practical Guide\/} edited by Michael J.\ Wester, John Wiley \& Sons,
Chichester, United Kingdom, ISBN 0-471-98353-5, xvi+436 pages, 1999.}}
%
\pagestyle{plain}
\begin{document}
%
% \nth{n} produces 1^{st}, 2^{nd}, 3^{rd}, 4^{th}, etc.
%
\def\nth#1{$#1^{\rm \ifcase#1 th\or st\or nd\or rd\else th\fi}$}
%
% Abbreviations
%
\newcommand{\Axiom}{{\sf Axiom}}
\newcommand{\Derive}{{\sf Derive}}
\newcommand{\DoCon}{{\sf DoCon}}
\newcommand{\GAP}{{\sf GAP}}
\newcommand{\Gmp}{{\sf Gmp}}
\newcommand{\Macsyma}{{\sf Macsyma}}
\newcommand{\Magnus}{{\sf Magnus}}
\newcommand{\Maxima}{{\sf Maxima}}
\newcommand{\Maple}{{\sf Maple}}
\newcommand{\Mathematica}{{\sf Mathematica}}
\newcommand{\MuPAD}{{\sf MuPAD}}
\newcommand{\Octave}{{\sf Octave}}
\newcommand{\Pari}{{\sf Pari}}
\newcommand{\Reduce}{{\sf Reduce}}
\newcommand{\Scilab}{{\sf Scilab}}
\newcommand{\Sumit}{{\sf Sumit}}
\newcommand{\Yacas}{{\sf Yacas}}
\chapter{Rosetta Translations}
\section{Introduction}
The following is a collection of synonyms for various operations in
the computer algebra systems \Axiom, \Derive, \GAP, \Gmp, \DoCon,
\Macsyma, \Magnus, \Maxima, \Maple, \Mathematica, \MuPAD, \Octave,
\Pari, \Reduce, \Scilab, \Sumit\ and \Yacas. This collection does not
attempt to be comprehensive, but hopefully it will be useful in giving
an indication of how to translate between the syntaxes used by the
different systems in many common situations. Note that a blank entry
means either (a) that there may be an exact translation of a
particular operation for the indicated system, but we don't know what
it is or (b) there is no exact translation but it may still be
possible to work around this lack with a related functionality.
While commercial systems are not provided on this CD the intent of the
Rosetta effort is to make it possible for experienced Computer Algebra
users to experiment with other systems. Thus the commands for
commercial systems are included to allow users of those systems to
translate.
Some of these systems are special purpose and do not support a lot of
the functionality of the more general purpose systems. Where they do
support an interpreter the commands are provided.
Originally written by Michael Wester.
Modified for Rosetta by Timothy Daly, Alexander Hulpke (GAP).
\section{System availability}
\begin{tabular}{l|lll}
System & \rm{License} & \rm{Status (May 2002)} & \rm{Web Location} \\
\hline
\Axiom & BSD & available & http://www.aldor.org \\
\Axiom & open source & pending &
http://home.earthlink.net/~jgg964/axiom.html \\
\Derive & commercial & available & http://www.mathware.com \\
\DoCon & open source & available & http://www.haskell.org/docon \\
\GAP & GPL & Rosetta & http://www.gap-system.org/~gap \\
\Gmp & GPL & Rosetta & http://www.swox.com/gmp \\
\Macsyma & commercial & dead & 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 \\
\Mathematica & commercial & available & http://www.wolfram.com \\
\MuPAD & commercial & available & http://www.mupad.de \\
\Octave & GPL & Rosetta & http://www.octave.org \\
\Pari & GPL & Rosetta & http://www.parigp-home.de \\
\Reduce & commercial & available & http://www.zib.de/Symbolik/reduce \\
\Scilab & Scilab & available & http://www-rocq.inria.fr/scilab \\
\Sumit & & available &
http://www-sop.inria.fr/cafe/soft-f.html \\
\Yacas & GPL & available & http://yacas.sourceforge.net \\
\end{tabular} \\[10pt]
\\
\begin{tabular}{l|ll}
System & \rm{Type} & \rm{Interpreted or Compiled}\\
\hline
\Axiom & General Purpose & both \\
\Derive & General Purpose & \\
\DoCon & General Purpose & Interpreted in Haskell \\
\GAP & Group Theory & \\
\Gmp & arb. prec. arithmetic & \\
\Macsyma & General Purpose & \\
\Magnus & Infinite Group Theory & \\
\Maxima & General Purpose & \\
\Maple & General Purpose & \\
\Mathematica & General Purpose & \\
\MuPAD & General Purpose & \\
\Octave & Numerical Computing & \\
\Pari & Number Theory & \\
\Reduce & General Purpose & \\
\Scilab & General Purpose & \\
\Sumit & Functional Equations & \\
\Yacas & General Purpose & \\
\end{tabular} \\[10pt]
\section{Programming and Miscellaneous}
\begingroup
\newcommand{\OR}{{\em or }}
\newcommand{\fnm}{\footnotemark}
\newcommand{\h}[1]{{\rm #1}}
\newcommand{\m}[2]{\multicolumn{#1}{l}{#2}}
\newcommand{\q}{\quad}
\newcommand{\st}{\small\tt}
\parindent=0pt
\hfuzz=1pt
\begin{tt}
\begin{tabular}{l|ll}
& \m{2}{\rm Unix/Microsoft user initialization file} \\
\hline
\Axiom & \~{}/axiom.input & \\
\GAP & \~{}/.gaprc & GAP.RC \\
\Gmp & & \\
\DoCon & & \\
\Derive & & derive.ini \\
\Macsyma & \~{}/macsyma-init.macsyma & mac-init.mac \\
\Magnus & & \\
\Maxima & \~{}/macsyma-init.macsyma & mac-init.mac \\
\Maple & \~{}/.mapleinit & maplev5.ini \\
\Mathematica & \~{}/init.m & init.m \\
\MuPAD & \~{}/.mupadinit &
$\backslash$mupad$\backslash$bin$\backslash$userinit.mu \\
\Octave & & \\
\Pari & & \\
\Reduce & \~{}/.reducerc & reduce.rc \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Describe {\em keyword}} & \h{Find keywords containing {\em pattern}} \\
\hline
\Axiom & & )what operations pattern \\
\Derive & & \\
\DoCon & & \\
\GAP & ?keyword & ??keyword\\
\Gmp & & \\
\Macsyma & describe("keyword")\$ & apropos("pattern"); \\
\Magnus & & \\
\Maxima & describe("keyword")\$ & apropos("pattern"); \\
\Maple & ?keyword & ?pattern\,\fnm \\
\Mathematica & ?keyword & ?*pattern* \\
\MuPAD & ?keyword & ?*pattern* \\
\Octave & help -i keyword & \\
\Pari & & \\
\Reduce & & \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\footnotetext{Only if the pattern is not a keyword and then the matches are
simplistic.}
\begin{tabular}{l|address@hidden }llll}
& & & \h{Prev.} & \h{Case} & \h{Variables} \\
& \h{Comment} & \h{Line continuation} & \h{expr.} & \h{sensitive} & \h{assumed}
\\
\hline
\Axiom & -- comment & input \_<CR>input & \% & Yes & real \\
\Derive & "comment" & input \~{}<CR>input & & No & real \\
\DoCon & & & & & \\
\GAP & \# comment & input$\backslash$<CR>input&last&Yes&no
assumption\\
\Gmp & & & & & \\
\Macsyma & /* comment */ & input<CR>input; & \% & No & real \\
\Magnus & & & & & \\
\Maxima & /* comment */ & input<CR>input; & \% & No & real \\
\Maple & \# comment & input<CR>input; & \% & Yes & complex \\
\Mathematica & (* comment *) & input<CR>input & \% & Yes & complex \\
\MuPAD & \# comment \# & input<CR>input; & \% & Yes & complex \\
\Octave & \#\# & & & Yes & \\
\Pari & & & & & \\
\Reduce & \% comment & input<CR>input; & ws & No & complex \\
\Scilab & & & & & \\
\Sumit & & & & & \\
\Yacas & & & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Load a file} & \h{Time a command} & \h{Quit} \\
\hline
\Axiom & )read "file" )quiet & )set messages time on & )quit \\
\Derive & [Transfer Load Derive] & & [Quit] \\
\DoCon & & & \\
\GAP & Read("file"); & time; \h{(also see {\tt
Runtime();})}&quit;\\
\Gmp & & & \\
\Macsyma & load("file")\$ & showtime: all\$ & quit(); \\
\Magnus & & & \\
\Maxima & load("file")\$ & showtime: all\$ & quit(); \\
\Maple & read("file"): & readlib(showtime): on; & quit \\
\Mathematica & << file & Timing[command] & Quit[] \\
\MuPAD & read("file"): & time(command); & quit \\
\Octave & load file & tic(); cmd ; toc() & quit \OR\
exit\\
\Pari & & & \\
\Reduce & in "file"\$ & on time; & quit; \\
\Scilab & & & quit \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Display} & \h{Suppress} & \\
& \h{output} & \h{output} & \h{Substitution: $f(x, y) \rightarrow f(z, w)$} \\
\hline
\Axiom & input & input; & subst(f(x, y), [x = z, y = w]) \\
\Derive & input & var:= input & [Manage Substitute] \\
\DoCon & & & \\
\GAP & input; & input;; & Value(f,[x,y],[z,w]);\fnm \\
\Gmp & & & \\
\Macsyma & input; & input\$ & subst([x = z, y = w], f(x, y)); \\
\Magnus & & & \\
\Maxima & input; & input\$ & subst([x = z, y = w], f(x, y)); \\
\Maple & input; & input: & subs(\{x = z, y = w\}, f(x, y)); \\
\Mathematica & input & input; & f[x, y] /. \{x -> z, y -> w\} \\
\MuPAD & input; & input: & subs(f(x, y), [x = z, y = w]); \\
\Octave & input & input; & \\
\Pari & & & \\
\Reduce & input; & input\$ & sub(\{x = z, y = w\}, f(x, y)); \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Set} & \h{List} & \h{Matrix} \\
\hline
\Axiom & set [1, 2] & [1, 2] & matrix([[1, 2],[3, 4]]) \\
\Derive & \{1, 2\} & [1, 2] & [[1,2], [3,4]] \\
\DoCon & & & \\
\GAP & Set([1,2]) & [1, 2] & [[1,2], [3,4]]\fnm \\
\Gmp & & & \\
\Macsyma & [1, 2] & [1, 2] & matrix([1, 2], [3, 4]) \\
\Magnus & & & \\
\Maxima & [1, 2] & [1, 2] & matrix([1, 2], [3, 4]) \\
\Maple & \{1, 2\} & [1, 2] & matrix([[1, 2], [3, 4]]) \\
\Mathematica & \{1, 2\} & \{1, 2\} & \{\{1, 2\}, \{3, 4\}\} \\
\MuPAD & \{1, 2\} & [1, 2] & export(Dom): \q export(linalg): \\
& & & matrix:= ExpressionField(normal)): \\
& & & matrix([[1, 2], [3, 4]]) \\
\Octave & & & \\
\Pari & & & \\
\Reduce & \{1, 2\} & \{1, 2\} & mat((1, 2), (3, 4)) \\
\Scilab & & list(1,2) & A=[1,2;3,4]\\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|llll}
& \h{Equation} & \h{List element} & \h{Matrix element} & \h{Length of a list} \\
\hline
\Axiom & x = 0 & l . 2 & m(2, 3) & \#l \\
\Derive & x = 0 & l SUB 2 & m SUB 2 SUB 3 & DIMENSION(l) \\
\DoCon & & & & \\
\GAP & x=0 & l[2] & m[2][3] & Length(l) \\
\Gmp & & & & \\
\Macsyma & x = 0 & l[2] & m[2, 3] & length(l) \\
\Magnus & & & & \\
\Maxima & x = 0 & l[2] & m[2, 3] & length(l) \\
\Maple & x = 0 & l[2] & m[2, 3] & nops(l) \\
\Mathematica & x == 0 & l[[2]] & m[[2, 3]] & Length[l] \\
\MuPAD & x = 0 & l[2] & m[2, 3] & nops(l) \\
\Octave & & & & \\
\Pari & & & & \\
\Reduce & x = 0 & part(l, 2) & m(2, 3) & length(l) \\
\Scilab & & l(2) & & \\
\Sumit & & & & \\
\Yacas & & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \m{2}{\rm Prepend/append an element to a list} & \h{Append two lists} \\
\hline
\Axiom & cons(e, l) & concat(l, e) & append(l1, l2) \\
\Derive & APPEND([e], l) & APPEND(l, [e]) & APPEND(l1, l2) \\
\DoCon & & & \\
\GAP & Concatenation([e],l) & Add(l,e) & Append(l1, l2) \\
\Gmp & & & \\
\Macsyma & cons(e, l) & endcons(e, l) & append(l1, l2) \\
\Magnus & & & \\
\Maxima & cons(e, l) & endcons(e, l) & append(l1, l2) \\
\Maple & [e, op(l)] & [op(l), e] & [op(l1), op(l2)] \\
\Mathematica & Prepend[l, e] & Append[l, e] & Join[l1, l2] \\
\MuPAD & [e, op(l)] & append(l, e) & l1 . l2 \\
\Octave & & & \\
\Pari & & & \\
\Reduce & e . l & append(l, {e}) & append(l1, l2) \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Matrix column dimension} & \h{Convert a list into a column vector} \\
\hline
\Axiom & ncols(m) & transpose(matrix([l])) \\
\Derive & DIMENSION(m SUB 1) & [l]\`{} \\
\DoCon & & \\
\GAP & Length(mat[1]) & \h{objects are identical} \\
\Gmp & & \\
\Macsyma & mat\_\,ncols(m) & transpose(matrix(l)) \\
\Magnus & & \\
\Maxima & mat\_\,ncols(m) & transpose(matrix(l)) \\
\Maple & linalg[coldim](m) & linalg[transpose](matrix([l])) \\
\Mathematica & Dimensions[m][[2]] & Transpose[\{l\}] \\
\MuPAD & linalg::ncols(m) & transpose(matrix([l]))\,\fnm \\
\Octave & & \\
\Pari & & \\
\Reduce & load\_\,package(linalg)\$ & matrix v(length(l), 1)\$ \\
& column\_dim(m) & for i:=1:length(l) do \\
& & \q\q v(i, 1):= part(l, i) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\footnotetext{See the definition of {\tt matrix} above.}
\begin{tabular}{l|l}
& \h{Convert a column vector into a list} \\
\hline
\Axiom & [v(i, 1) for i in 1..nrows(v)] \\
\Derive & v\`{} SUB 1 \\
\DoCon & \\
\GAP & \h{objects are identical} \\
\Gmp & \\
\Macsyma & part(transpose(v), 1) \\
\Magnus & \\
\Maxima & part(transpose(v), 1) \\
\Maple & op(convert(linalg[transpose](v), listlist)) \\
\Mathematica & Flatten[v] \\
\MuPAD & [op(v)] \\
\Octave & \\
\Pari & \\
\Reduce & load\_\,package(linalg)\$ \\
& for i:=1:row\_\,dim(v) collect(v(i, 1)) \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lllllll}
& \h{True} & \h{False} & \h{And} & \h{Or} & \h{Not} & \h{Equal} & \h{Not equal}
\\
\hline
\Axiom & true & false & and & or & not & = & \~{}= \\
\Derive & TRUE & FALSE & AND & OR & NOT & = & /= \\
\DoCon & & & & & & & \\
\GAP & true & false\fnm & and & or & not & = & <> \\
\Gmp & & & & & & & \\
\Macsyma & true & false & and & or & not & = & \# \\
\Magnus & & & & & & & \\
\Maxima & true & false & and & or & not & = & \# \\
\Maple & true & false & and & or & not & = & <> \\
\Mathematica & True & False & \&\& & || & ! & == & != \\
\MuPAD & true & false & and & or & not & = & <> \\
\Octave & & & & & & & \\
\Pari & & & & & & & \\
\Reduce & t & nil & and & or & not & = & neq \\
\Scilab & \%t & \%f & & & & & \\
\Sumit & & & & & & & \\
\Yacas & & & & & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{If+then+else statements} & \h{Strings (concatenated)} \\
\hline
\Axiom & if \_ then \_ else if \_ then \_ else \_ & concat(["x", "y"]) \\
\Derive & IF(\_, \_, IF(\_, \_, \_)) & "xy" \\
\DoCon & & \\
\GAP & if \_ then \_ elif \_ then \_ else \_ fi &
Concatenation("x","y")\\
\Gmp & & \\
\Macsyma & if \_ then \_ else if \_ then \_ else \_ & concat("x", "y") \\
\Magnus & & \\
\Maxima & if \_ then \_ else if \_ then \_ else \_ & concat("x", "y") \\
\Maple & if \_ then \_ elif \_ then \_ else \_ fi & "x" . "y" \\
\Mathematica & If[\_, \_, If[\_, \_, \_]] & "x" <> "y" \\
\MuPAD & if \_ then \_ elif \_ then \_ else \_ & "x" . "y" \\
& \q\q end\_if & \\
\Octave & & \\
\Pari & & \\
\Reduce & if \_ then \_ else if \_ then \_ else \_ & "xy" \OR\ mkid(x, y)\\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Simple loop and Block} & \h{Generate the list $[1, 2, \ldots, n]$} \\
\hline
\Axiom & for i in 1..n repeat ( x; y ) & [f(i) for i in 1..n] \\
\Derive & VECTOR([x, y], i, 1, n) & VECTOR(f(i), i, 1, n) \\
\DoCon & & \\
\GAP & for i in [1..n] do \_ od; & [1..n] {\rm or} [1,2..n]\\
\Gmp & & \\
\Macsyma & for i:1 thru n do (x, y); & makelist(f(i), i, 1, n); \\
\Magnus & & \\
\Maxima & for i:1 thru n do (x, y); & makelist(f(i), i, 1, n); \\
\Maple & for i from 1 to n do x; y od; & [f(i) \$ i = 1..n]; \\
\Mathematica & Do[x; y, \{i, 1, n\}] & Table[f[i], \{i, 1, n\}] \\
\MuPAD & for i from 1 to n do x; y & [f(i) \$ i = 1..n]; \\
& \q\q end\_for; & \\
\Octave & & \\
\Pari & & \\
\Reduce & for i:=1:n do <<x; y>>; & for i:=1:n collect f(i); \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Complex loop iterating on a list} \\
\hline
\Axiom & for x in [2, 3, 5] while x**2 < 10 repeat output(x) \\
\Derive & \\
\DoCon & \\
\GAP & for x in [2, 3, 5] do while x\^{}2<10 do Print(x);od;od; \\
\Gmp & \\
\Macsyma & for x in [2, 3, 5] while x\^{}2 < 10 do print(x)\$ \\
\Magnus & \\
\Maxima & for x in [2, 3, 5] while x\^{}2 < 10 do print(x)\$ \\
\Maple & for x in [2, 3, 5] while x\^{}2 < 10 do print(x) od: \\
\Mathematica & For[l = \{2, 3, 5\}, l != \{\} \&\& l[[1]]\^{}2 < 10, \\
& \q l = Rest[l], Print[l[[1]]] ] \\
\MuPAD & for x in [2, 3, 5] do if x\^{}2 < 10 then print(x) end\_if \\
& \q end\_for: \\
\Octave & \\
\Pari & \\
\Reduce & for each x in \{2, 3, 5\} do if x\^{}2 < 10 then write(x)\$ \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{\small Assignment} & \h{Function definition} & \h{Clear vars and funs} \\
\hline
\Axiom & y:= f(x) & f(x, y) == x*y &
{\small\tt )clear properties y f} \\
\Derive & y:= f(x) & f(x, y):= x*y & y:= f:= \\
\DoCon & & & \\
\GAP & y:= f(x); & f:=function(x, y) return x*y; end; & \h{There are
no symbolic variables}\\
\Gmp & & & \\
\Macsyma & y: f(x); & f(x, y):= x*y; & remvalue(y)\$ \\
& & & remfunction(f)\$ \\
\Magnus & & & \\
\Maxima & y: f(x); & f(x, y):= x*y; & remvalue(y)\$ \\
& & & remfunction(f)\$ \\
\Maple & y:= f(x); & f:= proc(x, y) x*y end; & y:= 'y': f:= 'f': \\
\Mathematica & y = f[x] & f[x\_, y\_\,]:= x*y & Clear[y, f] \\
\MuPAD & y:= f(x); & f:= proc(x, y) & y:= NIL: f:= NIL: \\
& & \q\q begin x*y end\_\,proc; & \\
\Octave & & & \\
\Pari & & & \\
\Reduce & y:= f(x); & procedure f(x, y); x*y; & clear y, f; \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Function definition with a local variable} \\
\hline
\Axiom & f(x) == (local n; n:= 2; n*x) \\
\Derive & \\
\DoCon & \\
\GAP & f:=function(x) local n; n:=2;return n*x; end; \\
\Gmp & \\
\Macsyma & f(x):= block([n], n: 2, n*x); \\
\Magnus & \\
\Maxima & f(x):= block([n], n: 2, n*x); \\
\Maple & f:= proc(x) local n; n:= 2; n*x end; \\
\Mathematica & f[x\_\,]:= Module[\{n\}, n = 2; n*x] \\
\MuPAD & f:= proc(x) local n; begin n:= 2; n*x end\_\,proc; \\
\Octave & \\
\Pari & \\
\Reduce & procedure f(x); begin scalar n; n:= 2; return(n*x) end; \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Return unevaluated symbol} & \h{Define a function from an expression} \\
\hline
\Axiom & e:= x*y;\q 'e & function(e, f, x, y) \\
\Derive & e:= x*y\q 'e & f(x, y):== e \\
\DoCon & & \\
\GAP & \h{No unevaluated symbols}\fnm&\\
\Gmp & & \\
\Macsyma & e: x*y\$\q 'e; & define(f(x, y), e); \\
\Magnus & & \\
\Maxima & e: x*y\$\q 'e; & define(f(x, y), e); \\
\Maple & e:= x*y:\q 'e'; & f:= unapply(e, x, y); \\
\Mathematica & e = x*y;\q HoldForm[e] & f[x\_, y\_\,] = e \\
\MuPAD & e:= x*y:\q hold(e); & f:= hold(func)(e, x, y); \\
\Octave & & \\
\Pari & & \\
\Reduce & e:= x*y\$ & for all x, y let f(x, y):= e; \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\footnotetext{Variables can be assigned to generators of a suitable free
object, for example {\tt x:=X(Rationals,"x");} or {\tt
f:=FreeGroup(2);x:=f.1;}.}
\addtocounter{footnote}{-1}%
\begin{tabular}{l|ll}
& \h{Fun.\ of an indefinite number of args} & \h{Apply ``+'' to sum a list} \\
\hline
\Axiom & & reduce(+, [1, 2]) \\
\Derive & LST l:= l & \\
\DoCon & & \\
\GAP & lst:=function(args) \_ end; & Sum([1,2])\\
\Gmp & & \\
\Macsyma & lst([l]):= l; & apply("+", [1, 2]) \\
\Magnus & & \\
\Maxima & lst([l]):= l; & apply("+", [1, 2]) \\
\Maple & lst:=proc() [args[1..nargs]] end; & convert([1, 2], \`{}+\`{}) \\
\Mathematica & lst[l\_\,\_\,\_\,]:= \{l\} & Apply[Plus, \{1, 2\}] \\
\MuPAD & lst:= proc(l) begin [args()] & \_\,plus(op([1, 2])) \\
& \q\q\q end\_\,proc; & \\
\Octave & & \\
\Pari & & \\
\Reduce & & xapply(+, \{1, 2\})\,\fnm \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\footnotetext{\tt procedure xapply(f, lst); lisp(f . cdr(lst))\$}
\addtocounter{footnote}{-1}%
\begin{tabular}{l|ll}
& \h{Apply a fun.\ to a} & \\
& \h{list of its args} & \h{Map an anonymous function onto a list} \\
\hline
\Axiom & reduce(f, l) & map(x +-> x + y, [1, 2]) \\
\Derive & & x:= [1, 2] \\
& & VECTOR(x SUB i + y, i, 1, DIMENSION(x)) \\
\DoCon & & \\
\GAP & List(l,f) & List([1,2],x->x+y) \\
\Gmp & & \\
\Macsyma & apply(f, l) & map(lambda([x], x + y), [1, 2]) \\
\Magnus & & \\
\Maxima & apply(f, l) & map(lambda([x], x + y), [1, 2]) \\
\Maple & f(op(l)) & map(x -> x + y, [1, 2]) \\
\Mathematica & Apply[f, l] & Map[\# + y \&, \{1, 2\}] \\
\MuPAD & f(op(l)) & map([1, 2], func(x + y, x)) \\
\Octave & & \\
\Pari & & \\
\Reduce & xapply(f, l)\,\fnm & for each x in \{1, 2\} collect x + y \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Pattern matching: $f(3 y) + f(z y) \rightarrow 3 f(y) + f(z y)$} \\
\hline
\Axiom & f:= operator('f); \\
& ( rule f((n | integer?(n)) * x) == n*f(x) )( \_ \\
& \q\q f(3*y) + f(z*y)) \\
\Derive & \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & matchdeclare(n, integerp, x, true)\$ \\
& defrule(fnx, f(n*x), n*f(x))\$ \\
& apply1(f(3*y) + f(z*y), fnx); \\
\Magnus & \\
\Maxima & matchdeclare(n, integerp, x, true)\$ \\
& defrule(fnx, f(n*x), n*f(x))\$ \\
& apply1(f(3*y) + f(z*y), fnx); \\
\Maple & map(proc(q) local m; \\
& \q\q\q if match(q = f(n*y), y, 'm') and \\
& \q\q\q\q\q type(rhs(op(m)), integer) then \\
& \q\q\q\q subs(m, n * f(y)) else q fi \\
& \q\q end, \\
& \q\q f(3*y) + f(z*y)); \\
\Mathematica & f[3*y] + f[z*y] /. f[n\_Integer * x\_\,] -> n*f[x] \\
\MuPAD & d:= domain("match"): \q d::FREEVARIABLE:= TRUE: \\
& n:= new(d, "n", func(testtype(m, DOM\_INT), m)): \\
& x:= new(d, "x", TRUE): \\
& map(f(3*y) + f(z*y), \\
& \q\q proc(q) local m; begin m:= match(q, f(n*x)); \\
& \q\q\q if m = FAIL then q \\
& \q\q\q else subs(hold("n" * f("x")), m) end\_if \\
& \q\q end\_\,proc); \\
\Octave & \\
\Pari & \\
\Reduce & operator f; \\
& f(3*y) + f(z*y) \\
& \q\q where \{f(\~{}n * \~{}x) => n*f(x) when fixp(n)\}; \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Define a new infix operator and then use it} \\
\hline
\Axiom & \\
\Derive & \\
\DoCon & \\
\GAP &\h{One can overload existing infix operators for ones own purposes}\\
\Gmp & \\
\Macsyma & infix("\~{}")\$ \q "\~{}"(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
3 \~{} 4; \\
\Magnus & \\
\Maxima & infix("\~{}")\$ \q "\~{}"(x, y):= sqrt(x\^{}2 + y\^{}2)\$ \q
3 \~{} 4; \\
\Maple & \`{}\&\~{}\`{}:= (x, y) -> sqrt(x\^{}2 + y\^{}2): \q 3 \&\~{} 4;
\\
\Mathematica & x\_ $\backslash$[Tilde] y\_:= Sqrt[x\^{}2 + y\^{}2]; \q
3 $\backslash$[Tilde] 4 \\
\MuPAD & tilde:= proc(x, y) begin sqrt(x\^{}2 + y\^{}2) end\_\,proc: \\
& \q 3 \&tilde 4; \\
\Octave & \\
\Pari & \\
\Reduce & infix |\$ \q procedure |(x, y); sqrt(x\^{}2 + y\^{}2)\$ \q
3 | 4; \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Main expression} & & \\
& \h{operator} & \h{\nth{1} operand} & \h{List of expression operands} \\
\hline
\Axiom\fnm & & kernels(e) . 1 & kernels(e) \\
\Derive & & & {\em various}\fnm \\
\DoCon & & & \\
\GAP &\m{3}{\rm There are no formal unevaluated expressions}\\
\Gmp & & & \\
\Macsyma & part(e, 0) & part(e, 1) & args(e) \\
\Magnus & & & \\
\Maxima & part(e, 0) & part(e, 1) & args(e) \\
\Maple & op(0, e) & op(1, e) & [op(e)] \\
\Mathematica & Head[e] & e[[1]] & ReplacePart[e, List, 0] \\
\MuPAD & op(e, 0) & op(e, 1) & [op(e)] \\
\Octave & & & \\
\Pari & & & \\
\Reduce & part(e, 0) & part(e, 1) & for i:=1:arglength(e) \\
& & & \q\q collect part(e, i) \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\addtocounter{footnote}{-1}%
\footnotetext{The following commands work only on expressions that consist of a
single level (e.g., $x + y + z$ but not $a/b + c/d$).}
\addtocounter{footnote}{-1}%
\footnotetext{{\tt TERMS}, {\tt FACTORS}, {\tt NUMERATOR}, {\tt LHS}, etc.}
\begin{tabular}{l|l}
& \h{Print text and results} \\
\hline
\Axiom & output(concat(["sin(", string(0), ") = ", \\
& \q string(sin(0))])); \\
\Derive & "sin(0)" = sin(0) \\
\DoCon & \\
\GAP & Print("There is no sin, but factors(10)= ",Factors(10),
"$\backslash$n")\\
\Gmp & \\
\Macsyma & print("sin(", 0, ") =", sin(0))\$ \\
\Magnus & \\
\Maxima & print("sin(", 0, ") =", sin(0))\$ \\
\Maple & printf("sin(\%a) = \%a$\backslash$n", 0, sin(0)): \\
\Mathematica & Print[StringForm["sin(\`{}\`{}) = \`{}\`{}", 0, Sin[0]]]; \\
\MuPAD & print(Unquoted, "sin(".0.")" = sin(0)): \\
\Octave & \\
\Pari & \\
\Reduce & write("sin(", 0, ") = ", sin(0))\$ \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Generate FORTRAN} & \h{Generate \TeX/\LaTeX} \\
\hline
\Axiom & outputAsFortran(e) & outputAsTex(e) \\
\Derive & [Transfer Save Fortran] & \\
\DoCon & & \\
\GAP &&Print(LaTeX(e));\\
\Gmp & & \\
\Macsyma & fortran(e)\$ \OR gentran(eval(e))\$ & tex(e); \\
\Magnus & & \\
\Maxima & fortran(e)\$ \OR gentran(eval(e))\$ & tex(e); \\
\Maple & fortran([e]); & latex(e); \\
\Mathematica & FortranForm[e] & TexForm[e] \\
\MuPAD & generate::fortran(e); & generate::TeX(e); \\
\Octave & & \\
\Pari & & \\
\Reduce & on fort; \q e; \q off fort; \OR & load\_\,package(tri)\$ \\
& load\_\,package(gentran)\$ gentran e; & on TeX; e; off TeX; \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Import two space separated columns of integers from {\tt file}} \\
\hline
\Axiom & \\
\Derive & [Transfer Load daTa] ({\rm from} file.dat) \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ \\
\Magnus & \\
\Maxima & xy: read\_num\_data\_to\_matrix("file", nrows, 2)\$ \\
\Maple & xy:= readdata("file", integer, 2): \\
\Mathematica & xy = ReadList["file", Number, RecordLists -> True] \\
\MuPAD & \\
\Octave & \\
\Pari & \\
\Reduce & \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Export two space separated columns of integers to {\tt file}\fnm} \\
\hline
\Axiom & )set output algebra "file" \q ({\rm creates} file.spout) \\
& for i in 1..n repeat output( \_ \\
& \q concat([string(xy(i, 1)), " ", string(xy(i, 2))]) ) \\
& )set output algebra console \\
\Derive & xy [Transfer Print Expressions File]\q({\rm creates} file.prt)\\
\DoCon & \\
\GAP & PrintTo("file");for i in [1..n] do\\
&\q AppendTo("file",xy[i][1]," ",xy[i][2],"$\backslash$n");od;\\
\Gmp & \\
\Macsyma & writefile("file")\$ \q for i:1 thru n do \\
& \q print(xy[i, 1], xy[i, 2])\$ \q closefile()\$ \\
\Magnus & \\
\Maxima & writefile("file")\$ \q for i:1 thru n do \\
& \q print(xy[i, 1], xy[i, 2])\$ \q closefile()\$ \\
\Maple & writedata("file", xy); \\
\Mathematica & outfile = OpenWrite["file"]; \\
& Do[WriteString[outfile, \\
& \q xy[[i, 1]], " ", xy[[i, 2]], "$\backslash$n"], \{i, 1, n\}] \\
& Close[outfile]; \\
\MuPAD & fprint(Unquoted, Text, "file", \\
& \q ("$\backslash$n", xy[i, 1], xy[i, 2]) \$ i = 1..n): \\
\Octave & \\
\Pari & \\
\Reduce & out "file"; \q for i:=1:n do \\
& \q write(xy(i, 1), " ", xy(i, 2)); \q shut "file"; \\
\Scilab & \\
\Sumit & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\footnotetext{Some editing of {\tt file} will be necessary for all systems but
\Maple\ and \Mathematica.}
\section{Mathematics and Graphics}
{\rm Since {\GAP} aims at discrete mathematics, it does not provide much of
the calculus functionality listed in the following section.}
\begin{tabular}{l|llllll}
& $e$ & $\pi$ & $i$ & $+\infty$ & $\sqrt{2}$ & $2^{1/3}$ \\
\hline
\Axiom & \%e & \%pi & \%i & \%plusInfinity & sqrt(2) & 2**(1/3) \\
\Derive & \#e & pi & \#i & inf & SQRT(2) & 2\^{}(1/3) \\
\DoCon & & & & & & \\
\GAP & & & E(4) & infinity & ER(2)\fnm &\\
\Gmp & & & & & & \\
\Macsyma & \%e & \%pi & \%i & inf & sqrt(2) & 2\^{}(1/3) \\
\Magnus & & & & & & \\
\Maxima & \%e & \%pi & \%i & inf & sqrt(2) & 2\^{}(1/3) \\
\Maple & exp(1) & Pi & I & infinity & sqrt(2) & 2\^{}(1/3) \\
\Mathematica & E & Pi & I & Infinity & Sqrt[2] & 2\^{}(1/3) \\
\MuPAD & E & PI & I & infinity & sqrt(2) & 2\^{}(1/3) \\
\Octave & & & & & & \\
\Pari & & & & & & \\
\Reduce & e & pi & i & infinity & sqrt(2) & 2\^{}(1/3) \\
\Scilab & & & & & & \\
\Sumit & & & & & & \\
\Yacas & & & & & & \\
\end{tabular} \\[10pt]
\footnotetext{{\tt ER} represents special cyclotomic numbers and is not a
root function.}
\addtocounter{footnote}{-1}%
\begin{tabular}{l|llll}
& \h{Euler's constant} & \h{Natural log} & \h{Arctangent} & $n!$ \\
\hline
\Axiom & & log(x) & atan(x) & factorial(n) \\
\Derive & euler\_\,gamma & LOG(x) & ATAN(x) & n! \\
\DoCon & & & & \\
\GAP & & LogInt(x,base) && Factorial(n) \\
\Gmp & & & & \\
\Macsyma & \%gamma & log(x) & atan(x) & n! \\
\Magnus & & & & \\
\Maxima & \%gamma & log(x) & atan(x) & n! \\
\Maple & gamma & log(x) & arctan(x) & n! \\
\Mathematica & EulerGamma & Log[x] & ArcTan[x] & n! \\
\MuPAD & EULER & ln(x) & atan(x) & n! \\
\Octave & & & & \\
\Pari & & & & \\
\Reduce & Euler\_\,Gamma & log(x) & atan(x) & factorial(n) \\
\Scilab & & & & \\
\Sumit & & & & \\
\Yacas & & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Legendre polynomial} & \h{Chebyshev poly.\ of the \nth{1} kind} \\
\hline
\Axiom & legendreP(n, x) & chebyshevT(n, x) \\
\Derive & LEGENDRE\_\,P(n, x) & CHEBYCHEV\_\,T(n, x) \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & legendre\_\,p(n, x) & chebyshev\_\,t(n, x) \\
\Magnus & & \\
\Maxima & legendre\_\,p(n, x) & chebyshev\_\,t(n, x) \\
\Maple & orthopoly[P](n, x) & orthopoly[T](n, x) \\
\Mathematica & LegendreP[n, x] & ChebyshevT[n, x] \\
\MuPAD & orthpoly::legendre(n, x) & orthpoly::chebyshev1(n, x) \\
\Octave & & \\
\Pari & & \\
\Reduce & LegendreP(n, x) & ChebyshevT(n, x) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Fibonacci number} & \h{Elliptic integral of the \nth{1} kind} \\
\hline
\Axiom & fibonacci(n) & \\
\Derive & FIBONACCI(n) & ELLIPTIC\_\,E(phi, k\^{}2) \\
\DoCon & & \\
\GAP & Fibonacci(n) & \\
\Gmp & & \\
\Macsyma & fib(n) & elliptic\_\,e(phi, k\^{}2) \\
\Magnus & & \\
\Maxima & fib(n) & elliptic\_\,e(phi, k\^{}2) \\
\Maple & combinat[fibonacci](n) & EllipticE(sin(phi), k) \\
\Mathematica & Fibonacci[n] & EllipticE[phi, k\^{}2] \\
\MuPAD & numlib::fibonacci(n) & \\
\Octave & & \\
\Pari & & \\
\Reduce & & EllipticE(phi, k\^{}2) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|llll}
& $\Gamma(x)$ & $\psi(x)$ & \h{Cosine integral} & \h{Bessel fun.\ (\nth{1})} \\
\hline
\Axiom & Gamma(x) & psi(x) & real(Ei(\%i*x)) & besselJ(n, x) \\
\Derive & GAMMA(x) & PSI(x) & CI(x) & BESSEL\_\,J(n, x) \\
\DoCon & & & & \\
\GAP & & & & \\
\Gmp & & & & \\
\Macsyma & gamma(x) & psi[0](x) & cos\_\,int(x) & bessel\_j[n](x) \\
\Magnus & & & & \\
\Maxima & gamma(x) & psi[0](x) & cos\_\,int(x) & bessel\_j[n](x) \\
\Maple & GAMMA(x) & Psi(x) & Ci(x) & BesselJ(n, x) \\
\Mathematica & Gamma[x] & PolyGamma[x] & CosIntegral[x] & BesselJ[n, x] \\
\MuPAD & gamma(x) & psi(x) & & besselJ(n, x) \\
\Octave & & & & \\
\Pari & & & & \\
\Reduce & Gamma(x) & Psi(x) & Ci(x) & BesselJ(n, x) \\
\Scilab & & & & \\
\Sumit & & & & \\
\Yacas & & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Hypergeometric fun.\ ${}_2F_1(a, b; c; x)$} & \h{Dirac delta} &
\h{Unit step fun.} \\
\hline
\Axiom & & & \\
\Derive & GAUSS(a, b, c, x) & & STEP(x) \\
\DoCon & & & \\
\GAP & & & \\
\Gmp & & & \\
\Macsyma & hgfred([a, b], [c], x) & delta(x) & unit\_\,step(x)
\\
\Magnus & & & \\
\Maxima & hgfred([a, b], [c], x) & delta(x) & unit\_\,step(x)
\\
\Maple & hypergeom([a, b], [c], x) & Dirac(x) & Heaviside(x) \\
\Mathematica & HypergeometricPFQ[\{a,b\},\{c\},x] &
\m{2}{<< Calculus\`{}DiracDelta\`{}} \\
\MuPAD & & dirac(x) & heaviside(x) \\
\Octave & & & \\
\Pari & & & \\
\Reduce & hypergeometric(\{a, b\}, \{c\}, x) & & \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Define $|x|$ via a piecewise function} \\
\hline
\Axiom & \\
\Derive & a(x):= -x*CHI(-inf, x, 0) + x*CHI(0, x, inf) \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$ \\
\Magnus & \\
\Maxima & a(x):= -x*unit\_\,step(-x) + x*unit\_\,step(x)\$ \\
\Maple & a:= x -> piecewise(x < 0, -x, x): \\
\Mathematica & << Calculus\`{}DiracDelta\`{} \\
& a[x\_]:= -x*UnitStep[-x] + x*UnitStep[x] \\
\MuPAD & a:= proc(x) begin -x*heaviside(-x) + x*heaviside(x) \\
& \q\q end\_\,proc: \\
\Octave & \\
\Pari & \\
\Reduce & \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Assume $x$ is real} & \h{Remove that assumption} \\
\hline
\Axiom & & \\
\Derive & x :epsilon Real & x:= \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & declare(x, real)\$ & remove(x, real)\$ \\
\Magnus & & \\
\Maxima & declare(x, real)\$ & remove(x, real)\$ \\
\Maple & assume(x, real); & x:= 'x': \\
\Mathematica & x/: Im[x] = 0; & Clear[x] \\
\MuPAD & assume(x, Type::RealNum): & unassume(x, Type::RealNum): \\
\Octave & & \\
\Pari & & \\
\Reduce & & \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Assume $0 < x \le 1$} & \h{Remove that assumption} \\
\hline
\Axiom & & \\
\Derive & x :epsilon (0, 1] & x:= \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & assume(x > 0, x <= 1)\$ & forget(x > 0, x <= 1)\$ \\
\Magnus & & \\
\Maxima & assume(x > 0, x <= 1)\$ & forget(x > 0, x <= 1)\$ \\
\Maple & assume(x > 0); & x:= 'x': \\
& additionally(x <= 1); & \\
\Mathematica & Assumptions -> 0 < x <= 1\,\fnm & \\
\MuPAD & assume(x > 0): assume(x <= 1): & unassume(x): \\
\Octave & & \\
\Pari & & \\
\Reduce & & \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\footnotetext{This is an option for {\tt Integrate}.}
\begin{tabular}{l|l}
& \h{Basic simplification of an expression $e$} \\
\hline
\Axiom & simplify(e) \OR\ normalize(e) \OR\ complexNormalize(e) \\
\Derive & e \\
\DoCon & \\
\GAP & e \\
\Gmp & \\
\Macsyma & ratsimp(e) \OR\ radcan(e) \\
\Magnus & \\
\Maxima & ratsimp(e) \OR\ radcan(e) \\
\Maple & simplify(e) \\
\Mathematica & Simplify[e] \OR\ FullSimplify[e] \\
\MuPAD & simplify(e) \OR\ normal(e) \\
\Octave & \\
\Pari & \\
\Reduce & e \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Use an unknown function} & \h{Numerically evaluate an expr.} \\
\hline
\Axiom & f:= operator('f); \q f(x) & exp(1) :: Complex Float \\
\Derive & f(x):= & Precision:= Approximate \\
& f(x) & APPROX(EXP(1)) \\
& & Precision:= Exact \\
\DoCon & & \\
\GAP & & EvalF(123/456)\\
\Gmp & & \\
\Macsyma & f(x) & sfloat(exp(1)); \\
\Magnus & & \\
\Maxima & f(x) & sfloat(exp(1)); \\
\Maple & f(x) & evalf(exp(1)); \\
\Mathematica & f[x] & N[Exp[1]] \\
\MuPAD & f(x) & float(exp(1)); \\
\Octave & & \\
\Pari & & \\
\Reduce & operator f; \q f(x) & on rounded; \q exp(1); \\
& & off rounded; \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& $ n \bmod m$ & \h{Solve $e \equiv 0 \bmod m$ for $x$} \\
\hline
\Axiom & rem(n, m) & solve(e = 0 :: PrimeField(m), x) \\
\Derive & MOD(n, m) & SOLVE\_\,MOD(e = 0, x, m) \\
\DoCon & & \\
\GAP & n mod m & \h{solve using finite fields}\\
\Gmp & & \\
\Macsyma & mod(n, m) & modulus: m\$ \q solve(e = 0, x) \\
\Magnus & & \\
\Maxima & mod(n, m) & modulus: m\$ \q solve(e = 0, x) \\
\Maple & n mod m & msolve(e = 0, m) \\
\Mathematica & Mod[n, m] & Solve[\{e == 0, Modulus == m\}, x] \\
\MuPAD & n mod m & solve(poly(e = 0, [x], IntMod(m)), x) \\
\Octave & & \\
\Pari & & \\
\Reduce & on modular; & load\_\,package(modsr)\$ \q on modular; \\
& setmod m\$ \q n & setmod m\$ \q m\_solve(e = 0, x) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Put over common denominator} & \h{Expand into separate fractions} \\
\hline
\Axiom & a/b + c/d & (a*d + b*c)/(b*d) :: \_ \\
& & \q MPOLY([a], FRAC POLY INT) \\
\Derive & FACTOR(a/b + c/d, Trivial) & EXPAND((a*d + b*c)/(b*d)) \\
\DoCon & & \\
\GAP & a/b+c/d &\\
\Gmp & & \\
\Macsyma & xthru(a/b + c/d) & expand((a*d + b*c)/(b*d)) \\
\Magnus & & \\
\Maxima & xthru(a/b + c/d) & expand((a*d + b*c)/(b*d)) \\
\Maple & normal(a/b + c/d) & expand((a*d + b*c)/(b*d)) \\
\Mathematica & Together[a/b + c/d] & Apart[(a*d + b*c)/(b*d)] \\
\MuPAD & normal(a/b + c/d) & expand((a*d + b*c)/(b*d)) \\
\Octave & & \\
\Pari & & \\
\Reduce & a/b + c/d & on div; (a*d + b*c)/(b*d) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Manipulate the root of a polynomial} \\
\hline
\Axiom & a:= rootOf(x**2 - 2); \q a**2 \\
\Derive & \\
\DoCon & \\
\GAP & x:=X(Rationals,"x");\\
&\q a:=RootOfDefiningPolynomial(AlgebraicExtension(Rationals,x\^{}2-2));
a\^{}2\\
\Gmp & \\
\Macsyma & algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2); \\
\Magnus & \\
\Maxima & algebraic:true\$ \q tellrat(a\^{}2 - 2)\$ \q rat(a\^{}2); \\
\Maple & a:= RootOf(x\^{}2 - 2): \q simplify(a\^{}2); \\
\Mathematica & a = Root[\#\^{}2 - 2 \&, 2] \q a\^{}2 \\
\MuPAD & \\
\Octave & \\
\Pari & \\
\Reduce & load\_\,package(arnum)\$ \q defpoly(a\^{}2 - 2); \q a\^{}2; \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Noncommutative multiplication} & \h{Solve a pair of equations} \\
\hline
\Axiom & & solve([eqn1, eqn2], [x, y]) \\
\Derive & x :epsilon Nonscalar & SOLVE([eqn1, eqn2], [x, y]) \\
& y :epsilon Nonscalar & \\
& x . y & \\
\DoCon & & \\
\GAP &*&\\
\Gmp & & \\
\Macsyma & x . y & solve([eqn1, eqn2], [x, y]) \\
\Magnus & & \\
\Maxima & x . y & solve([eqn1, eqn2], [x, y]) \\
\Maple & x \&* y & solve(\{eqn1, eqn2\}, \{x, y\}) \\
\Mathematica & x ** y & Solve[\{eqn1, eqn2\}, \{x, y\}] \\
\MuPAD & & solve(\{eqn1, eqn2\}, \{x, y\}) \\
\Octave & & \\
\Pari & & \\
\Reduce & operator x, y; & solve(\{eqn1, eqn2\}, \{x, y\}) \\
& noncom x, y; & \\
& x() * y() & \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \m{2}{\rm Decrease/increase angles in trigonometric functions} \\
\hline
\Axiom & \m{2}{simplify(normalize(sin(2*x)))} \\
\Derive & Trigonometry:= Expand & Trigonometry:= Collect \\
& sin(2*x) & 2*sin(x)*cos(x) \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & trigexpand(sin(2*x)) & trigreduce(2*sin(x)*cos(x)) \\
\Magnus & & \\
\Maxima & trigexpand(sin(2*x)) & trigreduce(2*sin(x)*cos(x)) \\
\Maple & expand(sin(2*x)) & combine(2*sin(x)*cos(x)) \\
\Mathematica & TrigExpand[Sin[2*x]] & TrigReduce[2*Sin[x]*Cos[x]] \\
\MuPAD & expand(sin(2*x)) & combine(2*sin(x)*cos(x), sincos)
\\
\Octave & & \\
\Pari & & \\
\Reduce & load\_\,package(assist)\$ \\
& trigexpand(sin(2*x)) & trigreduce(2*sin(x)*cos(x)) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Gr\"obner basis} \\
\hline
\Axiom & groebner([p1, p2, ...]) \\
\Derive & \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & grobner([p1, p2, ...]) \\
\Magnus & \\
\Maxima & grobner([p1, p2, ...]) \\
\Maple & Groebner[gbasis]([p1, p2, ...], plex(x1, x2, ...)) \\
\Mathematica & GroebnerBasis[\{p1, p2, ...\}, \{x1, x2, ...\}] \\
\MuPAD & groebner::gbasis([p1, p2, ...]) \\
\Octave & \\
\Pari & \\
\Reduce & load\_\,package(groebner)\$ \q groebner(\{p1, p2, ...\}) \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Factorization of $e$ over $i = \sqrt{-1}$} \\
\hline
\Axiom & factor(e, [rootOf(i**2 + 1)]) \\
\Derive & FACTOR(e, Complex) \\
\DoCon & \\
\GAP & Factors(GaussianIntegers,e)\\
\Gmp & \\
\Macsyma & gfactor(e); \OR\ factor(e, i\^{}2 + 1); \\
\Magnus & \\
\Maxima & gfactor(e); \OR\ factor(e, i\^{}2 + 1); \\
\Maple & factor(e, I); \\
\Mathematica & Factor[e, Extension -> I] \\
\MuPAD & QI:= Dom::AlgebraicExtension(Dom::Rational, i\^{}2 + 1); \\
& QI::name:= "QI": \q Factor(poly(e, QI)); \\
\Octave & \\
\Pari & \\
\Reduce & on complex, factor; \q e; \q off complex, factor; \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Real part} & \h{Convert a complex expr.\ to rectangular form} \\
\hline
\Axiom & real(f(z)) & complexForm(f(z)) \\
\Derive & RE(f(z)) & f(z) \\
\DoCon & & \\
\GAP & (f(z)+GaloisCyc(f(z),-1))/2&\\
\Gmp & & \\
\Macsyma & realpart(f(z)) & rectform(f(z)) \\
\Magnus & & \\
\Maxima & realpart(f(z)) & rectform(f(z)) \\
\Maple & Re(f(z)) & evalc(f(z)) \\
\Mathematica & Re[f[z]] & ComplexExpand[f[z]] \\
\MuPAD & Re(f(z)) & rectform(f(z)) \\
\Octave & & \\
\Pari & & \\
\Reduce & repart(f(z)) & repart(f(z)) + i*impart(f(z)) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|lll}
& \h{Matrix addition} & \h{Matrix multiplication} & \h{Matrix transpose} \\
\hline
\Axiom & A + B & A * B & transpose(A) \\
\Derive & A + B & A . B & A\`{} \\
\DoCon & & & \\
\GAP & A + B & A * B & TransposedMat(A)\\
\Gmp & & & \\
\Macsyma & A + B & A . B & transpose(A) \\
\Magnus & & & \\
\Maxima & A + B & A . B & transpose(A) \\
\Maple & evalm(A + B) & evalm(A \&* B) & linalg[transpose](A) \\
\Mathematica & A + B & A . B & Transpose[A] \\
\MuPAD & A + B & A * B & transpose(A) \\
\Octave & & & \\
\Pari & & & \\
\Reduce & A + B & A * B & tp(A) \\
\Scilab & & & \\
\Sumit & & & \\
\Yacas & & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Solve the matrix equation $A x = b$} \\
\hline
\Axiom & solve(A, transpose(b)) . 1 . particular :: Matrix \_\_\_ \\
\Derive & \\
\DoCon & \\
\GAP & SolutionMat(TransposedMat(A),b)\\
\Gmp & \\
\Macsyma & xx: genvector('x, mat\_nrows(b))\$ \\
& x: part(matlinsolve(A . xx = b, xx), 1, 2) \\
\Magnus & \\
\Maxima & xx: genvector('x, mat\_nrows(b))\$ \\
& x: part(matlinsolve(A . xx = b, xx), 1, 2) \\
\Maple & x:= linalg[linsolve](A, b) \\
\Mathematica & x = LinearSolve[A, b] \\
\MuPAD & \\
\Octave & \\
\Pari & \\
\Reduce & \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Sum: $\sum_{i = 1}^n f(i)$} & \h{Product: $\prod_{i = 1}^n f(i)$} \\
\hline
\Axiom & sum(f(i), i = 1..n) & product(f(i), i = 1..n) \\
\Derive & SUM(f(i), i, 1, n) & PRODUCT(f(i), i, 1, n) \\
\DoCon & & \\
\GAP & Sum([1..n],f) & Product([1..n],f)\\
\Gmp & & \\
\Macsyma & closedform( & closedform( \\
& \q sum(f(i), i, 1, n)) & \q product(f(i), i, 1, n)) \\
\Magnus & & \\
\Maxima & closedform( & closedform( \\
& \q sum(f(i), i, 1, n)) & \q product(f(i), i, 1, n)) \\
\Maple & sum(f(i), i = 1..n) & product(f(i), i = 1..n) \\
\Mathematica & Sum[f[i], \{i, 1, n\}] & Product[f[i], \{i, 1, n\}] \\
\MuPAD & sum(f(i), i = 1..n) & product(f(i), i = 1..n) \\
\Octave & & \\
\Pari & & \\
\Reduce & sum(f(i), i, 1, n) & prod(f(i), i, 1, n) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Limit: $\lim_{x \rightarrow 0-} f(x)$} & \h{Taylor/Laurent/etc.\ series} \\
\hline
\Axiom & limit(f(x), x = 0, "left") & series(f(x), x = 0, 3) \\
\Derive & LIM(f(x), x, 0, -1) & TAYLOR(f(x), x, 0, 3) \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & limit(f(x), x, 0, minus) & taylor(f(x), x, 0, 3) \\
\Magnus & & \\
\Maxima & limit(f(x), x, 0, minus) & taylor(f(x), x, 0, 3) \\
\Maple & limit(f(x), x = 0, left) & series(f(x), x = 0, 4) \\
\Mathematica & Limit[f[x], x->0, Direction->1] & Series[f[x],\{x, 0, 3\}] \\
\MuPAD & limit(f(x), x = 0, Left) & series(f(x), x = 0, 4) \\
\Octave & & \\
\Pari & & \\
\Reduce & limit!-(f(x), x, 0) & taylor(f(x), x, 0, 3) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Differentiate: $\frac{d^3 f(x, y)}{dx \, dy^2}$} &
\h{Integrate: $\int_0^1 f(x) \, dx$} \\
\hline
\Axiom & D(f(x, y), [x, y], [1, 2]) & integrate(f(x), x = 0..1) \\
\Derive & DIF(DIF(f(x, y), x), y, 2) & INT(f(x), x, 0, 1) \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & diff(f(x, y), x, 1, y, 2) & integrate(f(x), x, 0, 1) \\
\Magnus & & \\
\Maxima & diff(f(x, y), x, 1, y, 2) & integrate(f(x), x, 0, 1) \\
\Maple & diff(f(x, y), x, y\$2) & int(f(x), x = 0..1) \\
\Mathematica & D[f[x, y], x, \{y, 2\}] & Integrate[f[x], \{x, 0, 1\}] \\
\MuPAD & diff(f(x, y), x, y\$2) & int(f(x), x = 0..1) \\
\Octave & & \\
\Pari & & \\
\Reduce & df(f(x, y), x, y, 2) & int(f(x), x, 0, 1) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|ll}
& \h{Laplace transform} & \h{Inverse Laplace transform} \\
\hline
\Axiom & laplace(e, t, s) & inverseLaplace(e, s, t) \\
\Derive & LAPLACE(e, t, s) & \\
\DoCon & & \\
\GAP & & \\
\Gmp & & \\
\Macsyma & laplace(e, t, s) & ilt(e, s, t) \\
\Magnus & & \\
\Maxima & laplace(e, t, s) & ilt(e, s, t) \\
\Maple & inttrans[laplace](e,t,s) & inttrans[invlaplace](e,s,t) \\
\Mathematica & \m{2}{\q << Calculus\`{}LaplaceTransform\`{}} \\
& LaplaceTransform[e, t, s] & {\st InverseLaplaceTransform[e,s,t]}
\\
\MuPAD & transform::laplace(e,t,s) & transform::ilaplace(e, s, t) \\
\Octave & & \\
\Pari & & \\
\Reduce & \m{2}{\q load\_\,package(laplace)\$ \q load\_\,package(defint)\$}
\\
& laplace(e, t, s) & invlap(e, t, s) \\
\Scilab & & \\
\Sumit & & \\
\Yacas & & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Solve an ODE (with the initial condition $y'(0) = 1$)} \\
\hline
\Axiom & solve(eqn, y, x) \\
\Derive & APPLY\_\,IC(RHS(ODE(eqn, x, y, y\_)), [x, 0], [y, 1]) \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) \\
\Magnus & \\
\Maxima & ode\_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1) \\
\Maple & dsolve(\{eqn, D(y)(0) = 1\}, y(x)) \\
\Mathematica & DSolve[\{eqn, y'[0] == 1\}, y[x], x] \\
\MuPAD & solve(ode(\{eqn, D(y)(0) = 1\}, y(x))) \\
\Octave & \\
\Pari & \\
\Reduce & odesolve(eqn, y(x), x) \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Define the differential operator $L = D_x + I$ and apply it to $\sin x$} \\
\hline
\Axiom & DD : LODO(Expression Integer, e +-> D(e, x)) := D(); \\
& L:= DD + 1; \q L(sin(x)) \\
\Derive & \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x)); \\
\Magnus & \\
\Maxima & load(opalg)\$ \q L: (diffop(x) - 1)\$ \q L(sin(x)); \\
\Maple & id:= x -> x: \q L:= (D + id): \q L(sin)(x); \\
\Mathematica & L = D[\#, x]\& + Identity; \q Through[L[Sin[x]]] \\
\MuPAD & L:= (D + id): \q L(sin)(x); \\
\Octave & \\
\Pari & \\
\Reduce & \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{2D plot of two separate curves overlayed} \\
\hline
\Axiom & draw(x, x = 0..1); \q draw(acsch(x), x = 0..1); \\
\Derive & [Plot Overlay] \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & plot(x, x, 0, 1)\$ \q plot(acsch(x), x, 0, 1)\$ \\
\Magnus & \\
\Maxima & plot(x, x, 0, 1)\$ \q plot(acsch(x), x, 0, 1)\$ \\
\Maple & plot(\{x, arccsch(x)\}, x = 0..1): \\
\Mathematica & Plot[\{x, ArcCsch[x]\}, \{x, 0, 1\}]; \\
\MuPAD & plotfunc(x, acsch(x), x = 0..1): \\
\Octave & \\
\Pari & \\
\Reduce & load\_\,package(gnuplot)\$ \q plot(y = x, x = (0 .. 1))\$ \\
& plot(y = acsch(x), x = (0 .. 1))\$ \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
\begin{tabular}{l|l}
& \h{Simple 3D plotting} \\
\hline
\Axiom & draw(abs(x*y), x = 0..1, y = 0..1); \\
\Derive & [Plot Overlay] \\
\DoCon & \\
\GAP & \\
\Gmp & \\
\Macsyma & plot3d(abs(x*y), x, 0, 1, y, 0, 1)\$ \\
\Magnus & \\
\Maxima & plot3d(abs(x*y), x, 0, 1, y, 0, 1)\$ \\
\Maple & plot3d(abs(x*y), x = 0..1, y = 0..1): \\
\Mathematica & Plot3D[Abs[x*y], \{x, 0, 1\}, \{y, 0, 1\}]; \\
\MuPAD & plotfunc(abs(x*y), x = 0..1, y = 0..1): \\
\Octave & \\
\Pari & \\
\Reduce & load\_\,package(gnuplot)\$ \\
& plot(z = abs(x*y), x = (0 .. 1), y = (0 .. 1))\$ \\
\Scilab & \\
\Sumit & \\
\Yacas & \\
\end{tabular} \\[10pt]
%\begin{tabular}{l|l}
%& \h{} \\
%\hline
%\Axiom & \\
%\Derive & \\
%\DoCon & \\
%\GAP & \\
%\Gmp & \\
%\Macsyma & \\
%\Magnus & \\
%\Maxima & \\
%\Maple & \\
%\Mathematica & \\
%\MuPAD & \\
%\Octave & \\
%\Pari & \\
%\Reduce & \\
%\Scilab & \\
%\Sumit & \\
%\Yacas & \\
%\end{tabular} \\[10pt]
\end{tt}
\endgroup
\end{document}
- [Axiom-mail] (no subject), root, 2004/03/12
- [Axiom-mail] Re: Axiom, Rosetta and Quantian, Dirk Eddelbuettel, 2004/03/13
- [Axiom-mail] Re: Axiom, Rosetta and Quantian,
root <=
- [Axiom-mail] Re: Axiom, Rosetta and Quantian, Dirk Eddelbuettel, 2004/03/13
- [Axiom-mail] Re: Axiom, Rosetta and Quantian, A.J. Rossini, 2004/03/13
- [Axiom-mail] Re: Axiom, Rosetta and Quantian, root, 2004/03/12
- [Axiom-mail] Re: Axiom, Rosetta and Quantian, A.J. Rossini, 2004/03/12