Rosetta Translations


1.1  Introduction

The following is a collection of synonyms for various operations in
the computer algebra systems [FriCAS], [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 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).




1.2  System availability




System
License
Status
Web Location

Aldor
BSD
available
http://www.aldor.org

FriCAS
open source
avalilable
http://fricas.sf.net

Derive
commercial
defunct
http://www.mathware.com

DoCon
open source
available
http://www.haskell.org/docon

GAP
GPL
Rosetta
http://www.gap-system.org/

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://maxima.sourceforge.net/

Maple
commercial
available
http://www.maplesoft.com

Mathematica
commercial
available
http://www.wolfram.com

MuPAD
commercial
defunct, available as Matlab toolkit
http://www.mupad.de

Octave
GPL
Rosetta
http://www.octave.org

Pari
GPL
Rosetta
http://www.parigp-home.de

Reduce
BSD
available
http://www.zib.de/Symbolik/reduce

Scilab
Scilab
available
http://www-rocq.inria.fr/scilab

Sumit
 
available
http://www-sop.inria.fr/cafe/soft-f.html

Yacas
GPL
available
http://yacas.sourceforge.net
 




System
Type
Interpreted or Compiled

FriCAS
General Purpose
both

Derive
General Purpose
 

DoCon
General Purpose
Compiled 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
 
 


1.3  Programming and Miscellaneous




 
Unix/Microsoft user initialization file

FriCAS
~/fricas.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
~/.mupad/userinit.mu
      \mupad\bin\userinit.mu

Octave
 
 

Pari
 
 

Reduce
~/.reducerc
reduce.rc

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Describe keyword
Find keywords containing pattern

FriCAS
 
)what operations pattern

Derive
 
 

DoCon
 
 

GAP
?keyword
??keyword

Gmp
 
 

Macsyma
describe("keyword")$
apropos("pattern");

Magnus
 
 

Maxima
describe("keyword")$
apropos("pattern");

Maple
?keyword
?pattern 1

Mathematica
?keyword
?pattern

MuPAD
?keyword
?pattern

Octave
help -i keyword
 

Pari
 
 

Reduce
 
 

Scilab
 
 

Sumit
 
 

Yacas
 
 





 
 
 
 
Prev.
Case
Variables

 
Comment
 
Line continuation
expr.
sensitive
assumed
        

FriCAS
-- comment
 
input _<CR>input
%
Yes
real

Derive
"comment"
 
input ~<CR>input
 
No
real

DoCon
 
 
 
 
 
 

GAP
# comment
 
input\<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 / or // comment
 
input<CR>input;
%
Yes
complex

Octave
##
 
 
 
Yes
 

Pari
 
 
 
 
 
 

Reduce
% comment
 
input<CR>input;
ws
No
complex

Scilab
 
 
 
 
 
 

Sumit
 
 
 
 
 
 

Yacas
 
 
 
 
 
 



 
Load a file
Time a command
Quit

FriCAS
)read "file" )quiet
)set messages time on
)quit

Derive
[Transfer Load Derive]
 
[Quit]

DoCon
 
 
 

GAP
Read("file");
time; (also see 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
 
 
 



 
Display
Suppress
 

 
output
output
Substitution: f(x, y) ® f(z, w)

FriCAS
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]);2

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
 
 
 



 
Set
List
Matrix

FriCAS
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]]3

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]
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
 
 
 



 
Equation
List element
Matrix element
Length of a list

FriCAS
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
 
 
 
 



 
Prepend/append an element to a list
Append two lists

FriCAS
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] . l
append(l, e)
l1 . l2

Octave
 
 
 

Pari
 
 
 

Reduce
e . l
append(l, e)
append(l1, l2)

Scilab
 
 
 

Sumit
 
 
 

Yacas
 
 
 



 
Matrix column dimension
Convert a list into a column vector

FriCAS
ncols(m)
transpose(matrix([l]))

Derive
DIMENSION(m SUB 1)
[l]`

DoCon
 
 

GAP
Length(mat[1])
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)
linalg::transpose(matrix([l])) 

Octave
 
 

Pari
 
 

Reduce
load_ package(linalg)$
matrix v(length(l), 1)$

 
column_dim(m)
for i:=1:length(l) do

 
 
    v(i, 1):= part(l, i)

Scilab
 
 

Sumit
 
 

Yacas
 
 





 
Convert a column vector into a list

FriCAS
parts(v)

Derive
v` SUB 1

DoCon
 

GAP
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
 



 
True
False
And
Or
Not
Equal
Not equal
        

FriCAS
true
false
and
or
not
=
~=

Derive
TRUE
FALSE
AND
OR
NOT
=
/=

DoCon
 
 
 
 
 
 
 

GAP
true
false4
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
 
 
 
 
 
 
 



 
If+then+else statements
Strings (concatenated)

FriCAS
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"

 
    end_if
 

Octave
 
 

Pari
 
 

Reduce
if  then  else if  then  else _
"xy" or  mkid(x, y)

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Simple loop and Block
Generate the list [1, 2, ..., n]

FriCAS
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] 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];

 
    end_for;
 

Octave
 
 

Pari
 
 

Reduce
for i:=1:n do <<x; y>>;
for i:=1:n collect f(i);

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Complex loop iterating on a list

FriCAS
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,

 
  l = Rest[l], Print[l[[1]]] ]

MuPAD
for x in [2, 3, 5] do if x^2 < 10 then print(x) end_if

 
  end_for:

Octave
 

Pari
 

Reduce
for each x in {2, 3, 5} do if x^2 < 10 then write(x)$

Scilab
 

Sumit
 

Yacas
 



 
Assignment
Function definition
Clear vars and funs

FriCAS
y:= f(x)
f(x, y) == x*y
      )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;
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)
(x, y) -> x*y
delete y, f

 
 
f:= proc(x, y)
 

 
 
    begin x*y end_proc
 

Octave
 
 
 

Pari
 
 
 

Reduce
y:= f(x);
procedure f(x, y); x*y;
clear y, f;

Scilab
 
 
 

Sumit
 
 
 

Yacas
 
 
 



 
Function definition with a local variable

FriCAS
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
 



 
Return unevaluated symbol
Define a function from an expression

FriCAS
e:= x*y;  'e
function(e, f, x, y)

Derive
e:= x*y  'e
f(x, y):== e

DoCon
 
 

GAP
No unevaluated symbols6
 

Gmp
 
 

Macsyma
e: x*y$  'e;
define(f(x, y), e);

Magnus
 
 

Maxima
e: x*y$  'e;
define(f(x, y), e);

Maple
e:= x*y:  'e';
f:= unapply(e, x, y);

Mathematica
e = x*y;  HoldForm[e]
f[x, y ] = e

MuPAD
e:= x*y:  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
 
 





 
Fun. of an indefinite number of args
Apply ``+'' to sum a list

FriCAS
 
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() begin [args()]
_plus(op([1, 2]))

 
      end_ proc;
 

Octave
 
 

Pari
 
 

Reduce
 
xapply(+, {1, 2}) 5

Scilab
 
 

Sumit
 
 

Yacas
 
 





 
Apply a fun. to a
 

 
list of its args
Map an anonymous function onto a list

FriCAS
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], x -> x + y)

Octave
 
 

Pari
 
 

Reduce
xapply(f, l) 6
for each x in {1, 2} collect x + y

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Pattern matching: f(3 y) + f(z y) ® 3 f(y) + f(z y)

FriCAS
f:= operator('f);

 
( rule f((n | integer?(n))  x) == nf(x) )( _

 
    f(3y) + f(zy))

Derive
 

DoCon
 

GAP
 

Gmp
 

Macsyma
matchdeclare(n, integerp, x, true)$

 
defrule(fnx, f(nx), nf(x))$

 
apply1(f(3y) + f(zy), fnx);

Magnus
 

Maxima
matchdeclare(n, integerp, x, true)$

 
defrule(fnx, f(nx), nf(x))$

 
apply1(f(3y) + f(zy), fnx);

Maple
map(proc(q) local m;

 
      if match(q = f(n*y), y, m) and

 
          type(rhs(op(m)), integer) then

 
        subs(m, n * f(y)) else q fi

 
    end,

 
    f(3y) + f(zy));

Mathematica
f[3*y] + f[z*y] /. f[n_Integer  x_ ] -> nf[x]

MuPAD
 

Octave
 

Pari
 

Reduce
operator f;

 
f(3y) + f(zy)

 
    where {f(~n  ~x) => nf(x) when fixp(n)};

Scilab
 

Sumit
 

Yacas
 



 
Define a new infix operator and then use it

FriCAS
 

Derive
 

DoCon
 

GAP
One can overload existing infix operators for ones own purposes

Gmp
 

Macsyma
infix("~")$   "~"(x, y):= sqrt(x^2 + y^2)$        3 ~ 4;

Magnus
 

Maxima
infix("~")$   "~"(x, y):= sqrt(x^2 + y^2)$        3 ~ 4;

Maple
`&~`:= (x, y) -> sqrt(x^2 + y^2):   3 &~ 4;
        

Mathematica
x_ \[Tilde] y_:= Sqrt[x^2 + y^2];           3 \[Tilde] 4

MuPAD
tilde:= proc(x, y) begin sqrt(x^2 + y^2) end_ proc:

 
  operator("~", tilde, Binary, 100):

 
  3 ~ 4;

Octave
 

Pari
 

Reduce
infix |$   procedure |(x, y); sqrt(x^2 + y^2)$    3 | 4;

Scilab
 

Sumit
 

Yacas
 



 
Main expression
 
 

 
operator
11 th st nd rd operand
List of expression operands

FriCAS7
 
kernels(e) . 1
kernels(e)

Derive
 
 
various8

DoCon
 
 
 

GAP
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)

 
 
 
    collect part(e, i)

Scilab
 
 
 

Sumit
 
 
 

Yacas
 
 
 





 
Print text and results

FriCAS
output(concat(["sin(", string(0), ") = ",

 
  string(sin(0))]));

Derive
"sin(0)" = sin(0)

DoCon
 

GAP
Print("There is no sin, but factors(10)= ",Factors(10),
"\n")

Gmp
 

Macsyma
print("sin(", 0, ") =", sin(0))$

Magnus
 

Maxima
print("sin(", 0, ") =", sin(0))$

Maple
printf("sin(%a) = %a\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
 



 
Generate FORTRAN
Generate TeX/LATEX

FriCAS
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;   e;   off fort; or 
load_ package(tri)$

 
load_ package(gentran)$ gentran e;
on TeX; e; off TeX;

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Import two space separated columns of integers from file

FriCAS
 

Derive
[Transfer Load daTa] (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
data := import::readdata("file")

Octave
 

Pari
 

Reduce
 

Scilab
 

Sumit
 

Yacas
 



 
Export two space separated columns of integers to file

FriCAS
)set output algebra "file"   (creates file.spout)

 
for i in 1..n repeat output( _

 
  concat([string(xy(i, 1)), " ", string(xy(i, 2))]) )

 
)set output algebra console

Derive
xy [Transfer Print Expressions File]  (creates file.prt)

DoCon
 

GAP
PrintTo("file");for i in [1..n] do

 
  AppendTo("file",xy[i][1]," ",xy[i][2],"\n");od;

Gmp
 

Macsyma
writefile("file")$   for i:1 thru n do

 
  print(xy[i, 1], xy[i, 2])$   closefile()$

Magnus
 

Maxima
writefile("file")$   for i:1 thru n do

 
  print(xy[i, 1], xy[i, 2])$   closefile()$

Maple
writedata("file", xy);

Mathematica
outfile = OpenWrite["file"];

 
Do[WriteString[outfile,

 
  xy[[i, 1]], " ", xy[[i, 2]], "\n"], {i, 1, n}]

 
Close[outfile];

MuPAD
fprint(Unquoted, Text, "file",

 
  (xy[i, 1], " ", xy[i, 2], "\n") $ i = 1..n):

Octave
 

Pari
 

Reduce
out "file";   for i:=1:n do

 
  write(xy(i, 1), " ", xy(i, 2));   shut "file";

Scilab
 

Sumit
 

Sumit
 

Yacas
 







1.4  Mathematics and Graphics


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


 
e
p
i
+Â¥
2
21/3

FriCAS
%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)8
 

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
 
 
 
 
 
 





 
Euler's constant
Natural log
Arctangent
n!

FriCAS
 
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
 
 
 
 



 
Legendre polynomial
Chebyshev poly. of the 11 th st nd rd kind

FriCAS
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
 
 



 
Fibonacci number
Elliptic integral of the 11 th st nd rd kind

FriCAS
fibonacci(n)
ellipticE(sin(phi), k)

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
 
 



 
G(x)
y(x)
Cosine integral
Bessel fun. (11 th st nd rd)

FriCAS
Gamma(x)
psi(x)
Ci(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)
Ci(x)
besselJ(n, x)

Octave
 
 
 
 

Pari
 
 
 
 

Reduce
Gamma(x)
Psi(x)
Ci(x)
BesselJ(n, x)

Scilab
 
 
 
 

Sumit
 
 
 
 

Yacas
 
 
 
 



 
Hypergeometric fun. 2F1(a, b; c; x)
Dirac delta
      Unit step fun.

FriCAS
hypergeometricF([a, b], [c], x)
 
 

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]
<< Calculus`DiracDelta`

MuPAD
hypergeom([a,b], [c], x)
dirac(x)
heaviside(x)

Octave
 
 
 

Pari
 
 
 

Reduce
hypergeometric({a, b}, {c}, x)
 
 

Scilab
 
 
 

Sumit
 
 
 

Yacas
 
 
 



 
Define |x| via a piecewise function

FriCAS
 

Derive
a(x):= -xCHI(-inf, x, 0) + xCHI(0, x, inf)

DoCon
 

GAP
 

Gmp
 

Macsyma
a(x):= -xunit_ step(-x) + xunit_ step(x)$

Magnus
 

Maxima
a(x):= -xunit_ step(-x) + xunit_ step(x)$

Maple
a:= x -> piecewise(x < 0, -x, x):

Mathematica
<< Calculus`DiracDelta`

 
a[x_]:= -x*UnitStep[-x] + x*UnitStep[x]

MuPAD
a:= x -> piecewise([x<0, -x], [x>=0, x])

 
    end_ proc:

Octave
 

Pari
 

Reduce
 

Scilab
 

Sumit
 

Yacas
 



 
Assume x is real
Remove that assumption

FriCAS
 
 

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::Real):
delete x:

Octave
 
 

Pari
 
 

Reduce
 
 

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Assume 0 < x £ 1
Remove that assumption

FriCAS
 
 

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 8
 

MuPAD
assume(0 < x <= 1):
delete x:

Octave
 
 

Pari
 
 

Reduce
 
 

Scilab
 
 

Sumit
 
 

Yacas
 
 





 
Basic simplification of an expression e

FriCAS
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
 



 
Use an unknown function
Numerically evaluate an expr.

FriCAS
f:= operator('f);   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;   f(x)
on rounded;   exp(1);

 
 
off rounded;

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
n modm
Solve e º 0 modm for x

FriCAS
rem(n, m)
solve(e = 0 :: PrimeField(m), x)

Derive
MOD(n, m)
SOLVE_ MOD(e = 0, x, m)

DoCon
 
 

GAP
n mod m
solve using finite fields

Gmp
 
 

Macsyma
mod(n, m)
modulus: m$   solve(e = 0, x)

Magnus
 
 

Maxima
mod(n, m)
modulus: m$   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, [x], IntMod(m))=0, x)

Octave
 
 

Pari
 
 

Reduce
on modular;
load_ package(modsr)$   on modular;

 
setmod m$   n
setmod m$   m_solve(e = 0, x)

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Put over common denominator
Expand into separate fractions

FriCAS
a/b + c/d
(ad + bc)/(b*d) :: _

 
 
  MPOLY([a], FRAC POLY INT)

Derive
FACTOR(a/b + c/d, Trivial)
EXPAND((ad + bc)/(b*d))

DoCon
 
 

GAP
a/b+c/d
 

Gmp
 
 

Macsyma
xthru(a/b + c/d)
expand((ad + bc)/(b*d))

Magnus
 
 

Maxima
xthru(a/b + c/d)
expand((ad + bc)/(b*d))

Maple
normal(a/b + c/d)
expand((ad + bc)/(b*d))

Mathematica
Together[a/b + c/d]
Apart[(ad + bc)/(b*d)]

MuPAD
normal(a/b + c/d)
expand((ad + bc)/(b*d))

Octave
 
 

Pari
 
 

Reduce
a/b + c/d
on div; (ad + bc)/(b*d)

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Manipulate the root of a polynomial

FriCAS
a:= rootOf(x^2 - 2);   a^2

Derive
 

DoCon
 

GAP
x:=X(Rationals,"x");

 
  a:=RootOfDefiningPolynomial(AlgebraicExtension(Rationals,x^2-2));
a^2

Gmp
 

Macsyma
algebraic:true$   tellrat(a^2 - 2)$   rat(a^2);

Magnus
 

Maxima
algebraic:true$   tellrat(a^2 - 2)$   rat(a^2);

Maple
a:= RootOf(x^2 - 2):   simplify(a^2);

Mathematica
a = Root[#^2 - 2 &, 2]   a^2

MuPAD
F := Dom::AlgebraicExtension(Dom::Rational, a^2-2):

 
F(a)^2

Octave
 

Pari
 

Reduce
load_ package(arnum)$   defpoly(a^2 - 2);   a^2;

Scilab
 

Sumit
 

Yacas
 



 
Noncommutative multiplication
Solve a pair of equations

FriCAS
In noncommutaive domains usual * is noncommutative
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
 
 



 
Decrease/increase angles in trigonometric functions

FriCAS
simplify(normalize(sin(2*x)))

Derive
Trigonometry:= Expand
Trigonometry:= Collect

 
sin(2*x)
2sin(x)cos(x)

DoCon
 
 

GAP
 
 

Gmp
 
 

Macsyma
trigexpand(sin(2*x))
trigreduce(2sin(x)cos(x))

Magnus
 
 

Maxima
trigexpand(sin(2*x))
trigreduce(2sin(x)cos(x))

Maple
expand(sin(2*x))
combine(2sin(x)cos(x))

Mathematica
TrigExpand[Sin[2*x]]
TrigReduce[2*Sin[x]*Cos[x]]

MuPAD
expand(sin(2*x))
combine(2sin(x)cos(x), sincos)
        

Octave
 
 

Pari
 
 

Reduce
load_ package(assist)$

 
trigexpand(sin(2*x))
trigreduce(2sin(x)cos(x))

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Gröbner basis

FriCAS
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)$   groebner({p1, p2, ...})

Scilab
 

Sumit
 

Yacas
 



 
Factorization of e over i = -1

FriCAS
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":   Factor(poly(e, QI));

Octave
 

Pari
 

Reduce
on complex, factor;   e;   off complex, factor;

Scilab
 

Sumit
 

Yacas
 



 
Real part
Convert a complex expr. to rectangular form

FriCAS
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
 
 



 
Matrix addition
Matrix multiplication
Matrix transpose

FriCAS
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
linalg::transpose(A)

Octave
 
 
 

Pari
 
 
 

Reduce
A + B
A * B
tp(A)

Scilab
 
 
 

Sumit
 
 
 

Yacas
 
 
 



 
Solve the matrix equation A x = b

FriCAS
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
matlinsolve(A, b)

Octave
 

Pari
 

Reduce
 

Scilab
 

Sumit
 

Yacas
 



 
Sum: åi = 1n f(i)
Product: Õi = 1n f(i)

FriCAS
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(

 
  sum(f(i), i, 1, n))
  product(f(i), i, 1, n))

Magnus
 
 

Maxima
closedform(
closedform(

 
  sum(f(i), i, 1, n))
  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
 
 



 
Limit: limx ® 0- f(x)
Taylor/Laurent/etc. series

FriCAS
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
 
 



 
Differentiate: d3 f(x, y)/dx   dy2
      Integrate: ò01 f(x)   dx

FriCAS
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
 
 



 
Laplace transform
Inverse Laplace transform

FriCAS
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
  << Calculus`LaplaceTransform`

 
LaplaceTransform[e, t, s]
InverseLaplaceTransform[e,s,t]
        

MuPAD
transform::laplace(e,t,s)
transform::invlaplace(e, s, t)

Octave
 
 

Pari
 
 

Reduce
  load package(laplace)$   load package(defint)$
        

 
laplace(e, t, s)
invlap(e, t, s)

Scilab
 
 

Sumit
 
 

Yacas
 
 



 
Solve an ODE (with the initial condition y'(0) = 1)

FriCAS
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, y'(0) = 1}, y(x)))

Octave
 

Pari
 

Reduce
odesolve(eqn, y(x), x)

Scilab
 

Sumit
 

Yacas
 



 
Define the differential operator L = Dx + I and apply it to sinx

FriCAS
DD : LODO(Expression Integer, e +-> D(e, x)) := D();

 
L:= DD + 1;   L(sin(x))

Derive
 

DoCon
 

GAP
 

Gmp
 

Macsyma
load(opalg)$   L: (diffop(x) - 1)$   L(sin(x));

Magnus
 

Maxima
load(opalg)$   L: (diffop(x) - 1)$   L(sin(x));

Maple
id:= x -> x:   L:= (D + id):   L(sin)(x);

Mathematica
L = D[#, x]& + Identity;   Through[L[Sin[x]]]

MuPAD
L:= (D + id):   L(sin)(x);

Octave
 

Pari
 

Reduce
 

Scilab
 

Sumit
 

Yacas
 



 
2D plot of two separate curves overlayed

FriCAS
draw(x, x = 0..1);   draw(acsch(x), x = 0..1);

Derive
[Plot Overlay]

DoCon
 

GAP
 

Gmp
 

Macsyma
plot(x, x, 0, 1)$   plot(acsch(x), x, 0, 1)$

Magnus
 

Maxima
plot(x, x, 0, 1)$   plot(acsch(x), x, 0, 1)$

Maple
plot({x, arccsch(x)}, x = 0..1):

Mathematica
Plot[{x, ArcCsch[x]}, {x, 0, 1}];

MuPAD
plotfunc2d(x, arcsech(x), x = 0..1):

Octave
 

Pari
 

Reduce
load_ package(gnuplot)$   plot(y = x, x = (0 .. 1))$

 
plot(y = acsch(x), x = (0 .. 1))$

Scilab
 

Sumit
 

Yacas
 



 
Simple 3D plotting

FriCAS
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
plotfunc3d(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
 







1
Only if the pattern is not a keyword and then the matches are
simplistic.
6
Variables can be assigned to generators of a suitable free
object, for example x:=X(Rationals,"x"); or f:=FreeGroup(2);x:=f.1;.
6
procedure xapply(f, lst); lisp(f . cdr(lst))$
6
TERMS, FACTORS, NUMERATOR, LHS, etc.
7
The following commands work only on expressions that consist of a
single level (e.g., x + y + z but not a/b + c/d).
7
Some editing of file will be necessary for all systems but
Maple and Mathematica.
8
ER represents special cyclotomic numbers and is not a
root function.
8
This is an option for Integrate.






This document was translated from LATEX by
HEVEA.



Remarks concerning GAP --Christian Sievers,  Tue, 23 May 2006 11:39:26 -0500 reply
While the given GAP command does generate the list [1, 2, ..., n], the other examples seem to generate the list
[f(1), f(2), ..., f(n)].  This can be done with:
  List([1..n],f);


I'm not sure what Apply a fun. to a list of its args is supposed to mean, but my answer to that request is:
  CallFuncList(f,l);


A groebner basis can be computed with:
  GroebnerBasis([p1,p2,...],MonomialLexOrdering());


macsyma dead??? --unknown,  Sat, 17 Jun 2006 12:42:22 -0500 reply
Hi
I think it is still alive somehow,
see for example:
http://maxima.sourceforge.net

Bye
Other systems? --znmeb,  Sat, 17 Jun 2006 19:38:19 -0500 reply
Have we ruled out "special purpose" CAS packages, such as Ginac and Singular?

Re: Have we ruled out "special purpose" CAS packages? --Bill Page,  Mon, 19 Jun 2006 11:02:02 -0500 reply
Not at all. Please feel free to add missing information.

Dirac delta and piecewise --konstantin,  Sun, 17 Sep 2006 13:33:02 -0500 reply
Dirak delta and piecewise was implemented as built-in in Mathematica: use DiracDelta?[x]? and Piecewise[{{-x,x<0},{x,x>0}}]?

Pamphlet/LaTeX version of this page --Cliff Yapp,  Sun, 17 Sep 2006 22:06:37 -0500 reply
(Note that the pamphlet form of this document can be found here: Rosetta