roseta.htm

Dernière mise à jour le 4 juin 2003 à 4h 17, par Michel Lavaud

Pour télécharger le document La pierre de Rosette des logiciels de calcul formel (1621Kb), cliquez ici.

Bien qu'aucun système commercial ne soit fourni sur les CD Rosetta, l'intention de l'effort Rosetta est de permettre aux utilisateurs expérimentés de systèmes de calcul formel d'expérimenter avec les autres systèmes. C'est pourquoi les commandes des systèmes commerciaux sont incluses pour permettre aux utilisateurs de ces systèmes de traduire dans les autres systèmes.

Les tables ne couvrent pas la gamme complète des fonctionnalités et sont orientées vers les systèmes interactifs généralistes. Quelques-uns de ces systèmes sont spécialisés dans un domaine précis et ne fournissent que peu de fonctionnalités des systèmes plus généralistes. Pour ceux qui disposent d'un interpréteur, les commandes sont fournies. Certains systèmes sont essentiellement des outils de développement plutôt que des interpréteurs et ils ne sont pas représentés dans certaines tables.

Ce document a été écrit à l'origine par Michael Wester. Il a été modifié pour Rosetta par Timothy Daly, Alexander Hulpke (GAP), Hans Schoenemann (Singular), Serge Mechveliani (DoCon), Ayal Pinkus (Yacas) et Michel Lavaud (index et traduction française).

1.2 Disponibilité des systèmes

System	License	Status	Web Location
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
Sum^it		pending	http://www-sop.inria.fr/- cafe/Manuel.Bronstein
Yacas	GPL	Rosetta	http://yacas.sourceforge.net

System	Type	Interpreted, Compiled, Library
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
Sum^it	ODE and Diff. eqns	library
Yacas	General Purpose	interpreted, compiled and library

1.3 Programmation et divers

System	License	Status	Web Location
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

	Unix/Microsoft user initialization file
Axiom	~/axiom.input
CoCoA	~/init.coc
	~/userinit.coc
Derive		derive.ini
DoCon	~/.ghci	(interactive system init.)
GAP	~/.gaprc	GAP.RC
Giac
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	\mupad\bin\userinit.mu
Octave
Pari	~/.gprc
Reduce	~/.reducerc	reduce.rc
Singular	~/.singularrc	~/.singularrc
Yacas	~/.yacasrc	None

	Describe keyword	Find keywords containing pattern
Axiom		)what operations pattern
CoCoA	H.Command("");	Man("keyword");
Derive
DoCon
GAP	?keyword	??keyword
Giac
GiNaC
Macsyma	describe("keyword")$	apropos("pattern");
Magnus
Maple	?keyword	?pattern ¹
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	?keyword	no pattern searching

	Comment	Line continuation
Axiom	-- comment	input _<CR>input
CoCoA	-- comment	input<CR>input;
Derive	"comment"	input ~<CR>input
DoCon
GAP	# comment	input\<CR>input
Macsyma	/* comment */	input<CR>input;
Magnus
Maple	# comment	input<CR>input;
Mathcad	Text Region
Mathematica	(* comment *)	input<CR>input
Maxima	/* comment */	input<CR>input;
MuPAD	# comment #	input<CR>input;
Octave	##
Pari
Reduce	% comment	input<CR>input;
Singular	// comment	input<CR>input;
Yacas	/* comment */ or	input\<CR>input;
	//comment <CR>

	Previous	Case	Variables
	expression	sensitive	assumed
Axiom	%	Yes	real
CoCoA	It	Yes
Derive		No	real
DoCon
GAP	last	Yes	no assumption
Macsyma	%	No	real
Magnus
Maple	%	Yes	complex
Mathcad
Mathematica	%	Yes	complex
Maxima	%	No	real
MuPAD	%	Yes	complex
Octave		Yes
Pari
Reduce	ws	No	complex
Singular	_	Yes	none
Yacas	%	Yes	real

	Load a file	Time a command
Axiom	)read "file" )quiet	)set messages time on
CoCoA	<< 'MySession'	Time T := F();
Derive	[Transfer Load Derive]
DoCon
GAP	Read("file");	time; (also see `Runtime();`)
Macsyma	load("file")$	showtime: all$
Magnus
Maple	read("file"):	readlib(showtime): on;
Mathcad	File: Open Document
Mathematica	<< file	Timing[command]
Maxima	load("file")$	showtime: all$
MuPAD	read("file"):	time(command);
Octave	load file	tic(); cmd ; toc()
Pari
Reduce	in "file"$	on time;
Singular	< "file";	timer=1;
Yacas	Load("file");	Time(command);

	Quit
Axiom	)quit
CoCoA	Quit; or Ciao;
Derive	[Quit]
DoCon
GAP	quit;
Macsyma	quit();
Magnus
Maple	quit
Mathcad	File: Exit
Mathematica	Quit[]
Maxima	quit();
MuPAD	quit
Octave	quit or exit
Pari
Reduce	quit;
Singular	quit;
Yacas	quit or Exit();

	Display	Suppress
	output	output	Substitution: f(x, y) f(z, w)
Axiom	input	input;	subst(f(x, y), [x = z, y = w])
CoCoA	input;		Subst(F,[z,w]);
Derive	input	var:= input	[Manage Substitute]
DoCon
GAP	input;	input;;	Value(f,[x,y],[z,w]);²
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	input;	not supported	f(x,y) /: {x<-z,y<-w};

	Set	List	Matrix
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
GAP	Set([1,2])	[1, 2]	[[1,2], [3,4]]³
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): export(linalg):
			matrix:= ExpressionField(normal)):
			matrix([[1, 2], [3, 4]])
Octave
Pari
Reduce	{1, 2}	{1, 2}	mat((1, 2), (3, 4))
Singular
Yacas	{1,2}	{1,2}	{{1,2}, {3,4}}

	Equation	List element	Matrix element	Length of a list
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
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	x==0	L[2]	M[2][3]	Length(L)

	Prepend/append an element to a list
Axiom	cons(e, l)	concat(l, e)
CoCoA	Concat([E1],L1)	Append(L, E)
Derive	APPEND([e], l)	APPEND(l, [e])
DoCon
GAP	Concatenation([e],l)	Add(l,e)
Macsyma	cons(e, l)	endcons(e, l)
Magnus
Maple	[e, op(l)]	[op(l), e]
Mathcad
Mathematica	Prepend[l, e]	Append[l, e]
Maxima	cons(e, l)	endcons(e, l)
MuPAD	[e, op(l)]	append(l, e)
Octave
Pari
Reduce	e . l	append(l, e)
Singular	insert(l,e,1)	insert(l, e, size(l)+1)
Yacas	e:L	Append(L,e)

	Append two lists
Axiom	append(l1, l2)
CoCoA	Concat(L1, L2)
Derive	APPEND(l1, l2)
DoCon
GAP	Append(l1, l2)
Macsyma	append(l1, l2)
Magnus
Maple	[op(l1), op(l2)]
Mathcad
Mathematica	Join[l1, l2]
Maxima	append(l1, l2)
MuPAD	l1 . l2
Octave
Pari
Reduce	append(l1, l2)
Singular	l1+l2
Yacas	Concat({a,b},{c,d})

	Matrix column dimension	Convert a list into a column vector
Axiom	ncols(m)	transpose(matrix([l]))
CoCoA	Len(ColumnVectors(M))	Transposed(Mat(Vector([l])))
Derive	DIMENSION(m SUB 1)	[l]`
DoCon
GAP	Length(mat[1])	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])) ⁴
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)
Singular	ncols(m)	vector v;
		for(int i=1;i<=size(l);i++)
		{ v[i]=l[i]; }
Yacas		Transpose({L})

	Convert a column vector into a list
Axiom	[v(i, 1) for i in 1..nrows(v)]
CoCoA	V:=ColumnVectors(M);
	List(V[1]);
Derive	v` SUB 1
DoCon
GAP	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	Transpose(%)[1]

	True	False	And	Or	Not	Equal	Not equal
Axiom	true	false	and	or	not	=	~=
CoCoA	TRUE	FALSE	AND	OR	NOT	=	<>
Derive	TRUE	FALSE	AND	OR	NOT	=	/=
DoCon
GAP	true	false⁵	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	True	False	And	Or	Not	=	!=

	If+then+else statements
Axiom	if _ then _ else if _ then _ else _
CoCoA	If _ Then _ Elsif _ Then _ Else _ End
Derive	IF(_, _, IF(_, _, _))
DoCon
GAP	if _ then _ elif _ then _ else _ fi
Macsyma	if _ then _ else if _ then _ else _
Magnus
Maple	if _ then _ elif _ then _ else _ fi
Mathcad
Mathematica	If[_, _, If[_, _, _]]
Maxima	if _ then _ else if _ then _ else _
MuPAD	if _ then _ elif _ then _ else _
	end_if
Octave
Pari
Reduce	if _ then _ else if _ then _ else _
Singular	if (_) { _ } else { _ }
Yacas	If(_,_,_)

	Strings (concatenated)
Axiom	concat(["x", "y"])
CoCoA	Concat("x","y")
Derive	"xy"
DoCon
GAP	Concatenation("x","y")
Macsyma	concat("x", "y")
Magnus
Maple	"x" . "y"
Mathcad
Mathematica	"x" <> "y"
Maxima	concat("x", "y")
MuPAD	"x" . "y"

Octave
Pari
Reduce	"xy" or mkid(x, y)
Singular	"x"+"y"
Yacas	ConcatStrings("x","y");

	Simple loop and Block
Axiom	for i in 1..n repeat ( x; y )
CoCoA	For I:=1 To N Do _ End;
Derive	VECTOR([x, y], i, 1, n)
DoCon
GAP	for i in [1..n] do _ od;
Macsyma	for i:1 thru n do (x, y);
Magnus
Maple	for i from 1 to n do x; y od;
Mathcad
Mathematica	Do[x; y, {i, 1, n}]
Maxima	for i:1 thru n do (x, y);
MuPAD	for i from 1 to n do x; y
	end_for;
Octave
Pari
Reduce	for i:=1:n do <<x; y>>;
Singular	for(int i=n;i>0;i--) { x;y; }
Yacas	For(i:=1,i<n,i++)[x;y;];

	Generate the list [1, 2, . . . , n]
Axiom	[f(i) for i in 1..n]
CoCoA	List(1..10)
Derive	VECTOR(f(i), i, 1, n)
DoCon
GAP	[1..n] or [1,2..n]
Macsyma	makelist(f(i), i, 1, n);
Magnus
Maple	[f(i) $ i = 1..n];
Mathcad
Mathematica	Table[f[i], {i, 1, n}]
Maxima	makelist(f(i), i, 1, n);
MuPAD	[f(i) $ i = 1..n];

Octave
Pari
Reduce	for i:=1:n collect f(i);
Singular	list l; for(int i=n;i>0;i--)
Yacas	1 .. n;

	Complex loop iterating on a list
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
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,
	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
	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))
	{ if(l[1]^2<10) { l[1];}}
Yacas	ForEach(x,{2,3,5})If(x^2<10,Echo(x));

	Assignment	Function definition
Axiom	y:= f(x)	f(x, y) == x*y
CoCoA	Y:= F(x);	F(X,Y):=X*Y;
Derive	y:= f(x)	f(x, y):= x*y
DoCon
GAP	y:= f(x);	f:=function(x, y) return x*y; end;
Macsyma	y: f(x);	f(x, y):= x*y;
Magnus
Maple	y:= f(x);	f:= proc(x, y) x*y end;
Mathcad
Mathematica	y = f[x]	f[x_, y_ ]:= x*y
Maxima	y: f(x);	f(x, y):= x*y;
MuPAD	y:= f(x);	f:= proc(x, y)
		begin x*y end_ proc;
Octave
Pari
Reduce	y:= f(x);	procedure f(x, y); x*y;
Singular	y=f(x);	proc f(x,y)
Yacas	y:=f(x);	f(x,y):x*y;

	Clear vars and funs
Axiom	`)clear properties y f`
CoCoA	Delete Y;
Derive	y:= f:=
DoCon
GAP	no symbolic variables
Macsyma	remvalue(y)$
	remfunction(f)$
Magnus
	remfunction(f)$
Maple	y:= 'y': f:= 'f':
Mathcad
Mathematica	Clear[y, f]
Maxima	remvalue(y)$
MuPAD	y:= NIL: f:= NIL:

Octave
Pari
Reduce	clear y, f;
Singular	kill y,f;
Yacas	Clear(var); Retract(f,nrargs);

	Function definition with a local variable
Axiom	f(x) == (local n; n:= 2; n*x)
CoCoA	Define F(X) N:=2; Return N*; End;
Derive
DoCon
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	f(x):=[Local(n);n:=2;n*x;];

	Return unevaluated symbol	Define a function from an expression
Axiom	e:= x*y; 'e	function(e, f, x, y)
CoCoA
Derive	e:= x*y 'e	f(x, y):== e
DoCon
GAP	No unevaluated symbols⁶
Macsyma	e: x*y$ 'e;	define(f(x, y), e);
Magnus
Maple	e:= x*y: 'e';	f:= unapply(e, x, y);
Mathcad
Mathematica	e = x*y; HoldForm[e]	f[x_, y_ ] = e
Maxima	e: x*y$ 'e;	define(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;
Singular	string e="x*y";	proc f(x,y)
		{ execute("return("+e+");");}
Yacas	[e:=x*y;Hold(e);];	f(x):=Eval(e);

	Fun. of an indefinite number of args	Apply "+" to sum a list
Axiom		reduce(+, [1, 2])
CoCoA		Sum([1,2]);
Derive	LST l:= l
DoCon
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]))
	end_ proc;
Octave
Pari
Reduce		xapply(+, {1, 2}) ⁷
Singular	proc f(list #) { _ }
Yacas	f(L,...):=L;	UnFlatten({1,2},"+",0);

	Apply a fun. to a
	list of its args	Map an anonymous function onto a list
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
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	MapSingle("-",{1,2});	Apply({{x},x+y},{{1,2}});

	Pattern matching: f(3y) + f(zy) 3f(y) + f(zy)
Axiom	f:= operator('f);
	( rule f((n \| integer?(n)) * x) == n*f(x) )( _
	f(3y) + f(zy))
CoCoA
Derive
DoCon
GAP
Macsyma	matchdeclare(n, integerp, x, true)$
	defrule(fnx, f(nx), nf(x))$
	apply1(f(3y) + f(zy), fnx);
Magnus
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));
Mathcad
Mathematica	f[3y] + f[zy] /. f[n_Integer * x_ ] -> n*f[x]
Maxima	matchdeclare(n, integerp, x, true)$
	defrule(fnx, f(nx), nf(x))$
	apply1(f(3y) + f(zy), fnx);
MuPAD	d:= domain("match"): d::FREEVARIABLE:= TRUE:
	n:= new(d, "n", func(testtype(m, DOM_INT), m)):
	x:= new(d, "x", TRUE):
	map(f(3y) + f(zy),
	proc(q) local m; begin m:= match(q, f(n*x));
	if m = FAIL then q
	else subs(hold("n" * f("x")), m) end_if
	end_ proc);
Octave
Pari
Reduce	operator f;
	f(3y) + f(zy)
	where {f(~n * ~x) => n*f(x) when fixp(n)};
Singular
Yacas	f(3y)+f(zy) /: {f(n_IsInteger_x) <- nf(x)};

	Define a new infix operator and then use it
Axiom
CoCoA
Derive
DoCon
GAP	One can overload existing infix operators for ones own purposes
Macsyma	infix("~")$ "~"(x, y):= sqrt(x^2 + y^2)$ 3 ~ 4;
Magnus
Maple	`&~`:= (x, y) -> sqrt(x^2 + y^2): 3 &~ 4;
Mathcad
Mathematica	x_ \[Tilde] y_:= Sqrt[x^2 + y^2]; 3 \[Tilde] 4
Maxima	infix("~")$ "~"(x, y):= sqrt(x^2 + y^2)$ 3 ~ 4;
MuPAD	tilde:= proc(x, y) begin sqrt(x^2 + y^2) end_ proc:
	3 &tilde 4;
Octave
Pari
Reduce	infix \|$ procedure \|(x, y); sqrt(x^2 + y^2)$ 3 \| 4;
Singular
Yacas	Infix("~",10); x ~ y := Sqrt(x^2+y^2);

	Main expression
	operator	1^st operand	List of expression operands
Axiom⁸		kernels(e) . 1	kernels(e)
CoCoA
Derive			various⁹
DoCon
GAP	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)
			collect part(e, i)
Singular
Yacas	Type(e);

	Print text and results
Axiom	output(concat(["sin(", string(0), ") = ",
	string(sin(0))]));
CoCoA	PrintLn "Does Sin exist?";
Derive	"sin(0)" = sin(0)
DoCon
GAP	Print("There is no sin, but factors(10)= ",Factors(10), "\n")
Macsyma	print("sin(", 0, ") =", sin(0))$
Magnus
Maple	printf("sin(%a) = %a\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	Echo("sin(0) = ",Sin(0));

	Generate FORTRAN	Generate TeX/LaTeX
Axiom	outputAsFortran(e)	outputAsTex(e)
CoCoA		Latex(e);
Derive	[Transfer Save Fortran]
DoCon
GAP		Print(LaTeX(e));
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; e; off fort; or	load_ package(tri)$
	load_ package(gentran)$ gentran e;	on TeX; e; off TeX;
Singular		LIB "latex.lib";
		texobj(e);
Yacas		TeXForm(e);

	Import two space separated columns of integers from `file`
Axiom
CoCoA
Derive	[Transfer Load daTa] (from file.dat)
DoCon
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

	Export two space separated columns of integers to `file`¹⁰
Axiom	)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)
CoCoA
DoCon
GAP	PrintTo("file");for i in [1..n] do
	AppendTo("file",xy[i][1]," ",xy[i][2],"\n");od;
Macsyma	writefile("file")$ for i:1 thru n do
	print(xy[i, 1], xy[i, 2])$ closefile()$
Magnus
Maple	writedata("file", xy);
Mathcad
Mathematica	outfile = OpenWrite["file"];
	Do[WriteString[outfile,
	xy[[i, 1]], " ", xy[[i, 2]], "\n"], {i, 1, n}]
	Close[outfile];
Maxima	writefile("file")$ for i:1 thru n do
	print(xy[i, 1], xy[i, 2])$ closefile()$
MuPAD	fprint(Unquoted, Text, "file",
	("\n", xy[i, 1], xy[i, 2]) $ i = 1..n):
Octave
Pari
Reduce	out "file"; for i:=1:n do
	write(xy(i, 1), " ", xy(i, 2)); 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	ToFile("file")For(i:=1,i<=Length(xy),i++)Echo(xy[i][1],"",xy[i][2]);

1.4 Mathématiques et graphisme

	e		i	+		2^1/3
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)¹¹
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

	Euler's constant	Natural log	Arctangent	n!
Axiom		log(x)	atan(x)	factorial(n)
CoCoA
Derive	euler_ gamma	LOG(x)	ATAN(x)	n!
DoCon
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

	Legendre polynomial	Chebyshev polynomial of the 1^st kind
Axiom	legendreP(n, x)	chebyshevT(n, x)
CoCoA
Derive	LEGENDRE_ P(n, x)	CHEBYCHEV_ T(n, x)
DoCon
GAP
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

	Fibonacci number	Elliptic integral of the 1^st kind
Axiom	fibonacci(n)
CoCoA
Derive	FIBONACCI(n)	ELLIPTIC_ E(phi, k^2)
DoCon
GAP	Fibonacci(n)
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

	(x)	(x)	Cosine integral	Bessel fun. (1^st)
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
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	Gamma(n/2) or
	GammaNum(x)

	Hypergeometric fun. ₂F₁(a, b; c; x)	Dirac delta	Unit step fun.
Axiom
CoCoA
Derive	GAUSS(a, b, c, x)		STEP(x)
DoCon
GAP
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]	<< 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

	Define \|x\| via a piecewise function
Axiom
CoCoA
Derive	a(x):= -xCHI(-inf, x, 0) + xCHI(0, x, inf)
DoCon
GAP
Macsyma	a(x):= -xunit_ step(-x) + xunit_ step(x)$
Magnus
Maple	a:= x -> piecewise(x < 0, -x, x):
Mathcad
Mathematica	<< Calculus`DiracDelta`
	a[x_]:= -xUnitStep[-x] + xUnitStep[x]
Maxima	a(x):= -xunit_ step(-x) + xunit_ step(x)$
MuPAD	a:= proc(x) begin -xheaviside(-x) + xheaviside(x)
	end_ proc:
Octave
Pari
Reduce
Singular
Yacas

	Assume x is real	Remove that assumption
Axiom
CoCoA
Derive	x :epsilon Real	x:=
DoCon
GAP
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

	Assume 0 < x 1	Remove that assumption
Axiom
CoCoA
Derive	x :epsilon (0, 1]	x:=
DoCon
GAP
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 ¹²
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

	Basic simplification of an expression e
Axiom	simplify(e) or normalize(e) or complexNormalize(e)
CoCoA
Derive	e
DoCon
GAP	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

	Use an unknown function	Numerically evaluate an expr.
Axiom	f:= operator('f); f(x)	exp(1) :: Complex Float
CoCoA
Derive	f(x):=	Precision:= Approximate
	f(x)	APPROX(EXP(1))
		Precision:= Exact
DoCon
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; f(x)	on rounded; exp(1);
		off rounded;
Singular
Yacas

	n mod m	Solve e 0 mod m for x
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	solve using finite fields
Macsyma	mod(n, m)	modulus: m$ 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$ solve(e = 0, x)
MuPAD	n mod m	solve(poly(e = 0, [x], IntMod(m)), x)
Octave
Pari
Reduce	on modular;	load_ package(modsr)$ on modular;
	setmod m$ n	setmod m$ m_solve(e = 0, x)
Singular	n mod m
Yacas

	Put over common denominator	Expand into separate fractions
Axiom	a/b + c/d	(ad + bc)/(b*d) :: _
		MPOLY([a], FRAC POLY INT)
CoCoA
Derive	FACTOR(a/b + c/d, Trivial)	EXPAND((ad + bc)/(b*d))
DoCon
GAP	a/b+c/d
Macsyma	xthru(a/b + c/d)	expand((ad + bc)/(b*d))
Magnus
Maple	normal(a/b + c/d)	expand((ad + bc)/(b*d))
Mathcad
Mathematica	Together[a/b + c/d]	Apart[(ad + bc)/(b*d)]
Maxima	xthru(a/b + c/d)	expand((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)
Singular	a/b + c/d	(ad + bc)/(b*d)
Yacas

	Manipulate the root of a polynomial
Axiom	a:= rootOf(x2 - 2); a2
CoCoA
Derive
DoCon
GAP	x:=X(Rationals,"x");
	a:=RootOfDefiningPolynomial
	(AlgebraicExtension(Rationals,x^2-2));
a^2
Macsyma	algebraic:true$ tellrat(a^2 - 2)$ rat(a^2);
Magnus
Maple	a:= RootOf(x^2 - 2): simplify(a^2);
Mathcad
Mathematica	a = Root[#^2 - 2 &, 2] a^2
Maxima	algebraic:true$ tellrat(a^2 - 2)$ rat(a^2);
MuPAD
Octave
Pari
Reduce	load_ package(arnum)$ defpoly(a^2 - 2); a^2;
Singular
Yacas

	Noncommutative multiplication	Solve a pair of equations
Axiom		solve([eqn1, eqn2], [x, y])
CoCoA
Derive	x :epsilon Nonscalar	SOLVE([eqn1, eqn2], [x, y])
	y :epsilon Nonscalar
	x . y
DoCon
GAP	*
Macsyma	x . y	solve([eqn1, eqn2], [x, y])
Magnus
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

	Decrease/increase angles in trigonometric functions
Axiom	simplify(normalize(sin(2*x)))
CoCoA
Derive	Trigonometry:= Expand	Trigonometry:= Collect
	sin(2*x)	2sin(x)cos(x)
DoCon
GAP
Macsyma	trigexpand(sin(2*x))	trigreduce(2sin(x)cos(x))
Magnus
Maple	expand(sin(2*x))	combine(2sin(x)cos(x))
Mathcad
Mathematica	TrigExpand[Sin[2*x]]	TrigReduce[2Sin[x]Cos[x]]
Maxima	trigexpand(sin(2*x))	trigreduce(2sin(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))
Singular
Yacas

	Gröbner basis
Axiom	groebner([p1, p2, ...])
CoCoA	GBasis(Ideal(p1, p2, ...));
Derive
DoCon
GAP
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)$ groebner({p1, p2, ...})
Singular	groebner(ideal(p1,p2 ...))
Yacas

	Factorization of e over i =
Axiom	factor(e, [rootOf(i**2 + 1)])
CoCoA
Derive	FACTOR(e, Complex)
DoCon
GAP	Factors(GaussianIntegers,e)
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": Factor(poly(e, QI));
Octave
Pari
Reduce	on complex, factor; e; off complex, factor;
Singular	ring C=(0,i),x,dp;minpoly=i2+1;factorize(e);
Yacas

	Real part
Axiom	real(f(z))
CoCoA
Derive	RE(f(z))
DoCon
GAP	(f(z)+GaloisCyc(f(z),-1))/2
Macsyma	realpart(f(z))
Magnus
Maple	Re(f(z))
Mathcad
Mathematica	Re[f[z]]
Maxima	realpart(f(z))
MuPAD	Re(f(z))
Octave
Pari
Reduce	repart(f(z))
Singular	repart(f(z))
Yacas

	Convert a complex expr. to rectangular form
Axiom	complexForm(f(z))
CoCoA
Derive	f(z)
DoCon
GAP
Macsyma	rectform(f(z))
Magnus
Maple	evalc(f(z))
Mathcad
Mathematica	ComplexExpand[f[z]]
Maxima	rectform(f(z))
MuPAD	rectform(f(z))
Octave
Pari
Reduce	repart(f(z)) + i*impart(f(z))
Singular	repart(f(z)) * repart(f(z)) + i*impart(f(z))
Yacas

	Matrix addition	Matrix multiplication	Matrix transpose
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)
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

	Solve the matrix equation Ax = b
Axiom	solve(A, transpose(b)) . 1 . particular :: Matrix ___
CoCoA
Derive
DoCon
GAP	SolutionMat(TransposedMat(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

	Sum: _i=1ⁿf(i)	Product: _i=1ⁿf(i)
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)
Macsyma	closedform(	closedform(
	sum(f(i), i, 1, n))	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(
	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)
Singular
Yacas

	Limit: lim _x0-f(x)	Taylor/Laurent/etc. series
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
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

	Differentiate:	Integrate: ₀¹f(x) dx
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
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

	Laplace transform	Inverse Laplace transform
Axiom	laplace(e, t, s)	inverseLaplace(e, s, t)
CoCoA
Derive	LAPLACE(e, t, s)
DoCon
GAP
Macsyma	laplace(e, t, s)	ilt(e, s, t)
Magnus
Maple	inttrans[laplace](e,t,s)	inttrans[invlaplace](e,s,t)
Mathcad
Mathematica	<< Calculus`LaplaceTransform`
	LaplaceTransform[e, t, s]	`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	load_ package(laplace)$ load_ package(defint)$
	laplace(e, t, s)	invlap(e, t, s)
Singular
Yacas

	Solve an ODE (with the initial condition y'(0) = 1)
Axiom	solve(eqn, y, x)
CoCoA
Derive	APPLY_ IC(RHS(ODE(eqn, x, y, y_)), [x, 0], [y, 1])
DoCon
GAP
Macsyma	ode_ibc(ode(eqn, y(x), x), x = 0, diff(y(x), x) = 1)
Magnus
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

	Define the differential operator L = D_x + I and apply it to sin x
Axiom	DD : LODO(Expression Integer, e +-> D(e, x)) := D();
	L:= DD + 1; L(sin(x))
CoCoA
Derive
DoCon
GAP
Macsyma	load(opalg)$ L: (diffop(x) - 1)$ L(sin(x));
Magnus
Maple	id:= x -> x: L:= (D + id): L(sin)(x);
Mathcad
Mathematica	L = D[#, x]& + Identity; Through[L[Sin[x]]]
Maxima	load(opalg)$ L: (diffop(x) - 1)$ L(sin(x));
MuPAD	L:= (D + id): L(sin)(x);
Octave
Pari
Reduce
Singular
Yacas

	2D plot of two separate curves overlayed
Axiom	draw(x, x = 0..1); draw(acsch(x), x = 0..1);
CoCoA
Derive	[Plot Overlay]
DoCon
GAP
Macsyma	plot(x, x, 0, 1)$ 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)$ plot(acsch(x), x, 0, 1)$
MuPAD	plotfunc(x, acsch(x), x = 0..1):
Octave
Pari
Reduce	load_ package(gnuplot)$ 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));¹³
Yacas

	Simple 3D plotting
Axiom	draw(abs(x*y), x = 0..1, y = 0..1);
CoCoA
Derive	[Plot Overlay]
DoCon
GAP
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);¹⁴
Yacas

La pierre de Rosette des logiciels de calcul formel

Tim Daly, Michael Wester, Alexander Hulpke, Hans Schoenemann, Serge Mechveliani, Ayal Pinkus et Michel Lavaud

1 Traductions de Rosetta

1.1 Introduction

1.2 Disponibilité des systèmes

1.3 Programmation et divers

`1.4` `Mathématiques et graphisme`

La pierre de Rosette des logiciels de calcul formel

Tim Daly, Michael Wester, Alexander Hulpke, Hans Schoenemann, Serge Mechveliani, Ayal Pinkus et Michel Lavaud

1 Traductions de Rosetta

1.1 Introduction

1.2 Disponibilité des systèmes

1.3 Programmation et divers

1.4 Mathématiques et graphisme

`1.4` `Mathématiques et graphisme`