Axiom est un logiciel libre de calcul formel.
Instruction |
Résultat |
Type |
| cos 1.5 cos(1.5) |
0.07074 | Float |
| (4/6)::Float | 0.6667 | Float |
| %::Fraction Integer | 2/3 | Fraction Integer |
| round(2.85) | 3.0 | Float |
| truncate(2.85) | 2.0 | Float |
| fractionPart(2.85) | 0.85 | Float |
| abs(-2) | 2 | PositiveInteger |
| sign(-2) | -1 | Integer |
| sign(0) | 0 | NonNegativeInteger |
Instruction |
Description |
| round(x) | |
| truncate(x) | |
| fractionPart(x) | |
| abs(x) | |
| sign(x) | |
| positive?(x) | |
| negative?(x) | |
| zero?(x) | |
| one?(x) | |
| odd?(x) | Impaire? |
| even?(x) | Paire? |
| prime?(x) | Premier? |
| gcd(x,y) | |
| lcm(x,y) | |
| max(x,y) | |
| min(x,y) | |
| factorial(x) | Factoriel |
| factor(x) | Facteurs premiers |
| divide(x,y) | Quotient et Reste |
Symbole |
Decription |
and |
Et |
or \/ |
Ou |
not |
Négation |
quo |
Quotient |
rem |
Reste |
<= |
plus petit ou égal |
>= |
plus grand ou égal |
Macro |
Description |
%i |
i |
%e |
E |
%pi |
PI |
%infinity |
Infini |
%plusInfinity |
Infini positif |
%minusInfinity |
Infini négatif |
Instruction |
Résultat |
Type |
(2/3 + %i) |
2/3 + %i |
Complex Fraction Integer |
real(3+2*%i) |
3 |
PositiveInteger |
imag(3+2*%i) |
2 |
PositiveInteger |
conjugate(3+2*%i) |
3 - 2*%i |
Complex Integer |
factor(2+4*%i) |
-%i*(1+%i)^2*(1+2%i) |
Factored Complex Integer |
%minusInfinity |
Infini négatif |
Instruction |
Résultat |
Type |
p := x*y+1; eval(p,x=2) |
2*y+1 |
Polynomial Integer |
eval(p,[x=2,y=2]) |
5 |
Polynomial Integer |
Instruction |
Résultat |
Type |
x : PrimeField 7 x:=11 |
4 |
PrimeField 7 |
y : IntegerMod 8 y:=3 |
3 |
IntegerMod 8 |
%pi :: Float |
3.1415 |
Float |
11 :: PrimeField 7 |
4 |
PrimeField 7 |
p : Polynomial PrimeField 7 p:=(11*x^2+3*x+1) |
4*x^2+3*x+1 |
Polynomial PrimeField 7 |
(2/3)::Float |
0.6666 |
Float |
(2/3)$Float |
0.6666 |
Float |
(2/3)@Float |
0.6666 |
Float |
5::String |
"5" |
String |
X::T conversion explicite de X en type T si possible.
X$T évaluer X avec les opérateurs disponibles pour le type T.
X@T évaluer X en choisissant les opérateurs de sorte que le résultat soit de type T.
, Tuple
; N'affiche pas le résultat (seulement le type).
% Retourne le dernier résultat.
%%(-5) Retourne le 5ième dernier résultat.
%%(17) Retourne le résultat du point n°17.
_ Permet de continuer l'instruction sur la ligne suivante.
-- Début de commentaire sur une ligne.
++ Début de commentaire sur une ligne.
Instruction |
Résultat |
Type ou description |
list(4) |
[4] |
List PositiveInteger |
[2,5,7] |
[2,5,7] |
List PositiveInteger |
append([1,2],[5,6]) |
[1,2,5,6] |
Recopie [1,2] en insérant en tête de [5,6] |
cons(7,[1,2]) |
[7,1,2] |
Recopie [7] en insérant en tête de [1,2] |
first([2,5,7]) |
2 |
|
first([2,5,7],2) |
[2,5] |
|
rest([2,5,7]) |
[5,7] |
Retourne un pointeur sur [5,7] |
rest([2,5,7],2) |
[7] |
Retourne un pointeur sur [7] |
empty?([2,5]) |
false |
Boolean |
member?(5,[2,5,7]) |
true |
Boolean |
reverse([2,5,-1,7]) |
[7,-1,5,2] |
List Integer |
sort([2,5,-1,7]) |
[-1,2,5,7] |
List Integer |
removeDuplicates([1,2,1,1]) |
[2,1] |
List PositiveInteger |
#[1,2,1,1] |
4 |
PositiveInteger |
u:=[2,5]; concat!(u,[7]); u |
[2,5,7] |
|
setrest!(u,v) |
Modifie la liste u en faisant pointer le reste sur v |
|
u:=[1,5,7,9]; |
||
u.3 |
7 |
|
u(3) |
7 |
|
first rest rest u |
7 |
|
elt(u,3) |
7 |
|
last(u) |
9 |
|
u.last |
9 |
|
#u |
4 |
Cela boucle s'il y a des boucles |
v := [i for i in u] |
recopie u dans v |
|
v:=copy(u) |
recopie u dans v |
|
[i for i in 1..9 | even?(i)] |
[2,4,6,8] |
|
u:=[1..3,7..9] |
[1..3,5..9] |
|
expand(u) |
[1,2,3,7,8,9] |
|
u:=[1..] |
[1..] |
|
expand(u) |
[1,2,3,4,5,...] |
|
generate(nextPrime,2) |
[2,3,5,7,11,...] |
InfiniteTuple Integer |
generate(nextPrime,2)_ $Stream Integer |
[2,3,5,7,11,...] |
Stream Integer |
[generate(nextPrime,2)] |
[2,3,5,7,11,...] |
Stream Integer |
[i for i in 1.. | prime?(i)] |
[2,3,5,7,11,...] |
Stream PositiveInteger |
Instruction |
Résultat |
Type ou description |
f : List Integer -> List Integer |
void |
|
f([2,3]) |
[3,5] |
List Integer |
[generate(f,[1,1])] |
[[1,1],[1,2],[2,3],[3,5],...] |
Stream List Integer |
u := [i.1 for i in [generate(f,[1,1])]] |
[1,1,2,3,...] |
Stream Integer |
u.50 |
12586269025 |
PositiveInteger |
Instruction |
Résultat |
Type ou description |
oneDimensionalArray([1,2,3]) |
[1,2,3] |
OneDimensionalArray PositiveInteger |
V : ARRAY1 Integer |
||
V:=new(5,7) |
[7,7,7,7,7] |
OneDimensionalArray Integer |
map(i +-> i+1, V) |
[8,8,8,8,8] |
OneDimensionalArray Integer |
map!(i +-> i+1, V); V |
[8,8,8,8,8] |
OneDimensionalArray Integer |
U:ARRAY1 Integer U:=[5,6,7] swap!(U,2,3); U |
[5,7,6] |
OneDimensionalArray Integer |
copyInto!(V,U,2) |
[8,5,6,7,8] |
OneDimensionalArray Integer |
vector([1,2,3]) |
[1,2,3] |
Vector PositiveInteger |
"Hello" |
"Hello" |
String |
bits(8,true) |
"11111111" |
Bits |
f : FARRAY INT : new(4,1) |
[1,1,1,1] |
FlexibleArray Integer |
Instruction |
Description |
| )clear all | Reset |
| )read input fred.input | Lit, compile et éxecute le fichier fred.input |
Un block est une succession d'instruction entre parenthèse séparées par des points virgules. Exemple :
(a:=1; b:=2; [a,b])
Ce block retourne [1,2]. Les blocks s'emboitent. Et plusieurs écritures sont possibles. Par exemple :
L:= (a:=1; b:=2; [a,b])
Dans un fichier texte cela pourra s'écrire autrement :
L:=
a:=1;
b:=2;
[a,b]
l'indentation est importante, l'expression a:=1 en dessous, doit être après la parenthèse (. Et la parenthèse fermante doit être après le début de "sqr" et avant le début de "a:=1". Et les assertions a:=1;b:=2;c:=a+b;c doivent débuter paraillement.
sqrt(1.0 +
a:=1
b:=2
c:=a+b
c
)
L'opérateur : sert à définir le type d'une variable. Par exemple
x : Fraction Integer
définie x comme une fraction d'entier. Pour les fonctions, la méthode est la même sauf que les arguments de la fonction sont placés entre parenthèses et le type de retour est placé après le symbole `` ->''. Par exemples :
f : ()->Integer
g : (Integer) -> List Integer
h : (Integer, PositiveInteger) -> Integerf() ==1
g(a) == [a,a+a,a*a]
h(x,a) == x^a
Lorsque la fonction n'a qu'un argument, l'appel peut se faire sans parenthèse. Exemple "g 5" ou "g(5)"
Exemple d'instruction pour sortire du corps de la fonction avec un résultat : return a +b+1
Exemple d'instruction if-then-else :
h :=2.0
if h >3.1 then
1.0
else
z:=sin(h)
max(z,0.5)
Le "else" doit être décalé du "if". Le teste doit être une expression booléenne (utiliser la conversion @Boolean si nécessaire).
Exemple de boucle :
i := 1
repeat
if i > 4 then break
output(i)
i := i + 1
Ctrl C permet d'interompre l'execution d'une boucle sans fin.
Instruction |
Description |
| return x | sort de la fonction avec le résultat x |
| break | sort de la boucle |
| iterate | passe à l'itération suivante de la boucle |
| output(x) | affiche x |
| repeat | Boucle |
while b repeat |
Boucle while |
while b and c repeat while b while c repeat |
Boucle while |
| for i in [1,2,7] repeat | Boucle for |
for i in 5..1 by -1 repeat |
Boucle for,by |
for i in 1.. | odd(i) repeat for i in 1.. while odd(i) repeat |
boucle for, tel que boucle for, tant que |
Axiom |
Résultat |
Mupad |
Résultat |
| integrate(cos(a*x),x) | sin(a*y)/a | int(cos(a*x),x) | sin(a*y)/a |
| digits(4) | Calcul les nombres sur 4 chiffres. | DIGITS:=4 | Calcul les nombres flotants sur 4 chiffres. |
| solve(x^2-x-1, 0.0001) | [x= - 0.618,x= 1.618] | numeric::solve(x^2-x-1,x=1) | [x= 1.618] |
| radix(1000,36) | RS | int2text(1000,36) | "RS" |
| draw(sin(x)*cos(y), x=-5..5,y=-5..5) | plotfunc3d(sin(x)*cos(y),x=-5..5,y=-5..5) | ||
p(0) == 1 |
x^4 - 3*x^2 + 1 |
||
| coefficient(p(100),x,4) | 270725 | coeff(p(100),x,n) | |
| D(p(4)) | 4*x^3 - 6*x | D(p(4)) | |
| [x^2 for x in 1..4] | [1,4,9,16] | [x^2 $ x = 1..4] | [1,4,9,16] |
| a==[x^2 for x in 1..] | [1,4,9,16,25,36,49,64,81,100,...] |
||
| a(7) | 49 | a[4] | 16 |
| a==series(exp(x),x=0) | a:=series(exp(x),x=0) | ||
| coefficient(a,3) | 1/6 | coefficient(a,3) coefficient(a,x,3) |
1/6 |
| a==matrix [ [x,0], [1,y] ] | |||
| inverse(a) a^(-1) |
Instruction |
Résultat |
Type ou descrition |
| S:=[x^3+y+1=0, y^2=4] | Système d'équatio de type "List Equation Polynomial Integer" | |
| solve(S,1/100) | [[y=2,x=369/256],[y=-2,x=1]] | Résoudre S avec 2 chiffres de précision. Et en utilisant l'arithmétique des nombres rationnels comme approximation. |
| radicalSolve(S) | Résoud S avec les solutions exprimées en radicaux. | |
Instruction |
Résultat |
Type ou description |
| M := [ [x,0],[0,2*x] ]::Matrix(POLY(FRAC(INT))) | Matrix Polynomial Fraction Integer |
|
| x:=52 | 52 |
PositiveInteger |
| x | 52 |
PositiveInteger |
| 'x | x |
Variable x |
| p := r^2 + 2/3 | r^2 + 2/3 |
Polynomial Fraction Integer |
| p::Fraction Polynomial Integer | (3r^2+2)/3 |
Fraction Polynomial Integer |
| [u,v] | [u,v] |
List OrderedVariableList [u,v] |
| x:=factor(12) | 2^2*3 |
Factored Integer |
| x:=x+2 | 2*7 |
Factored Integer |
| x::Integer | 14 |
Integer |
| r:=10/21 | 10/21 |
Fraction Integer |
| map(factor,r) | 2*5/(3*7) |
Fraction Factored Integer |
| 12@SingleInteger | SingleInteger Un entier qui tient sur 32 bits. |
|
| 37/22::Float | 1.6818181818 |
Float |
| decimal(37/22) | __ 1.681 |
DecimalExpansion |
| a:=rootOf(a^3+a+1,a) | a |
Expression Integer |
| (a+1)^10 | a^2 + 200*a + 136 |
Expression Integer |
| 1/(1-a) | 1/(1-a) | Expression Integer |
| ratDenom(%) | (a^2+a+2)/3 | Expression Integer |
Instruction |
Description |
| )display all | Affiche tout ce que l'utilisateur a définie dans l'espace de travail ainsi que les macros. |
Instruction |
Résultat |
Type ou description |
| bits(8,true) | "11111111" |
Bits |
m:=matrix[[1,1,1],[x,y,x],[y,x,y]] |
Polynomial Fraction Integer |
|
| m(3,3) | y |
Polynomial Integer |
| factor determinant m | Factored Polynomial Integer |
|
| fac(n) == if n < 3 then n else n * fac(n - 1) fac 5 |
120 |
|
| fa(n) == (a := 1; for i in 2..n repeat a := a*i; a) fa 5 |
120 |
|
| f(n) == reduce(*,list(2..n)) f 5 |
120 |
|
| t: (Float -> Float, Float) -> Float t(f,x) == f(x)*x t(sin,2) |
||
R:= rule(sqrt(a)*sqrt(b)==sqrt(a,b)) |
||
| p: UP(x,INT) p:=x+1 |
UnivariatePolynomial(x,Integer) |
|
| m: MPOLY([x,y],INT) m:= x+y |
MultivariatePolynomial([x,y],Integer) |
|
| m :: DMP([y,x],INT) | ordre lexicographique des monomes |
|
| m:: HDMP([y,x],INT) | ||
| limit(g,x=0) | ||
| series(sin(a*x),x=0) | UnivariatePuiseuxSeries(Expression Integer,x,0) |
|
| exp(%) | UnivariatePuiseuxSeries(Expression Integer,x,0) |
|
| f:=taylor(exp(x)) | UnivariateTaylorSeries(Expression Integer,x,0) |
|
| eval(f,1.0) | Stream Expression Float |
|
| D(f,x) | Dérivé selon x. | |
| D(f,4) | 4ième dérivé selon x. | |
| D(f,[x,y,x]) | dérivé partielle en x puis y puis x | |
| F:=operator 'F |
F |
BasicOperator |
| G:=operator 'G | G | BasicOperator |
| F(G(x),F(x,y)) | Expression Integer | |
| eval(%,'G, x+->sin(x)) | F(sin(x),F(x,y)) | Expression Integer |
| integrate(cos(a*x),x) | sin(a*x)/a | Union(Expression Integer,...) |
| complexIntegrate(1/(x^2+1)) | Expression Complex Integer |
Instruction |
Résultat |
Type ou description |
| f:=operator 'f | f |
BasicOperator |
| e:= D(f(x),x) + f(x) = 1 | Equation Expression Integer | |
| solve(e,f,x) | Union(Record(particular: Expression Integer,basis: List Expression Integer),...) | |
| solve(e,f,x).basis | List Expression Integer | |
| e1:=D(F(t),t) = F(t)+1 e2:=D(G(t),t) = G(t)-F(t) |
||
| serieSolve([e1,e2],[F,G],t=0,[F(0)=1,G(0)=0]) | List UnivariateTaylorSeries(Expression Integer,t,0) | |
| solve([x=y*x+1,y*y=1],1/100) | ||
| complexSolve([x=y*x+1,y*y=1],1/100) | ||
| radicalSolve ([x=y*x+1,y*y=1],[x,y]) |
Instruction |
Type ou description |
| )clear all | |
| )clear value x | |
| )clear properties x | |
| )read fich.input | Lit et éxecute le fichier fich.input |
| )what operations integrate | Affiche les opérations ayant "integrate" dans leur nom |
| )undo n | revient à la ligne n. |
| )undo -n | revient n ligne en arrière. |
| )undo n before | revient à la ligne n, avant son éxecution. |
Instruction |
Type ou description |
| draw(sin(x),x=0..10) | |
| draw(log(x),x=0..10, coordonates==polar) | |
| List (List (Matrix (Polynomial (Complex (Fraction (Integer)))))) | Domain |
| factor(2 :: Complex(Integer)) | Factored Complex Integer |
| (x,y):Integer |
x: Integer; y:Integer |
Abréviation |
Domain ou Domain Constructor |
| COMPLEX | Complex |
| DFLOAT | DoubleFloat |
| EXPR | Expression |
| FLOAT | Float |
| FRAC | Fraction |
| INT | Integer |
| MATRIX | Matrix |
| NNI | NonNegativeInteger |
| PI | PositiveInteger |
| POLY | Polynomial |
| STRING | String |
| UP | UnivariatePolynomial |
Instruction |
Type ou description |
| )abbreviation query Integer | Affiche l'abréviation de Integer |
| )abb q Integer | Affiche l'abréviation de Integer |
| )abb q INT | Affiche le terme ayant comme abréviation INT |
| )what packages INT | Affiche les packages qui ont INT dans leur nom ou dans leur abréviation. |
Déclaration de type ou de mode pour une variable ou plusieurs variables à la fois :
x : INT
y : POLY(?)
(x,y) : FRAC(?)
Instruction |
Résultat |
Type ou description |
| r : Record(a:String, b:Integer) := ["toto",5] | [a = "toto", b = 5] |
Record(a: String, b: Integer) |
| u := divide(5,2) | [quotient= 2,remainder= 1] |
Record(quotient: Integer,remainder: Integer) |
| u.quotient u(quotient) u('quotient) |
2 2 2 |
|
| u.remainder | 1 |
|
| u.quotient := 10 | 10 |
|
| u | [quotient=10,remainder=1] |
Record(quotient: Integer,remainder: Integer) |
| s:= 'quotient | quotient |
Variable quotient. |
| u.s | 10 |
|
| r:=["yo",9] | [a="yo",b=9] |
Record(a: String, b: Integer) |
Instruction |
Résultat |
Type ou description |
| f(x) : Void == output x*x::String | Void |
|
| f(5) | "25" |
Void |
| g(x : Union(Integer,String,Float)) : Void == output x case Integer => "Integer branch" x case String => "String branch" "Float branch" |
||
| g(5) | "Integer branch" |
Void |
| g("toto") | "String branch" |
Void |
| g(1.5) | "Float branch" |
Void |
| x : Union(Integer,String,Float) := 5 | ||
| x | 5 |
Union(Integer,...) |
| typeOf x | Union(Integer,String,Float) |
Domain |
| exquo(6,2) | 3 | Union(Integer,...) |
| exquo(5,2) | "failed" | Union(failed,...) |
| typeOf exquo(5,2) | typeOf exquo(5,2) | Domain |
| y : Union(i:Integer,s:String) := 5 | ||
| y case i | true | |
| y case s | false | |
| y.i | 5 | PositiveInteger |
| y | 5 | Union(i:Integer,...) |
| z : Any := 5 | 5 | PositiveInteger |
| typeOf z | Any | Domain |
| m : SquareMatrix(2,POLY COMPLEX FRAC INT) m:=matrix [ [x*%i,y^2+1],[3*%i*y - x,1-x*y] ] |
||
| m1 := m :: SquareMatrix(2, FRAC POLY COMPLEX INT) | ||
| m2 := m :: POLY(?) | ||
| x:Integer:=5 | ||
| y:=[x] | [5] | List Integer |
| y:=[x pretend PI]] | [5] | List PositiveInteger |
| (2/3) $Float | utilise / de Float | |
| (2/3) @Float | Utilise un / qui produit un Float | |
| h := matrix [ [8,6],[-4,9] ] | ||
| map(inv $Fraction(Integer),h) | ||
| map(inv,h) |
Instruction |
Type ou description |
| )what operation Complex | Affiche les opérations qui ont Complex dans leur nom. |
| )what domain matrix | Affiche les domains qui ont matrix dans leur nom. |
| )what package gauss | Affiche les packages qui ont gauss dans leur nom. |
| )show Any | Affiche les opérations qui proviennent du domaine Any |
| )display operation complex | Affiche les opérations qui ont Complex dans leur nom. |
| )abb q COMRING | Affiche le terme ayant comme abréviation COMRING |
| )history )write dom | Sauvegarde toutes les saisies qui ont été faite dans dom.input. |
| )set output fortran on | |
| )set output fortran fich | écrit sur fich.sfort |
| )set output algebra on | |
| )set output tex on | |
| )set streams calculate n | Les suites infinies n'affichent que les n premier termes. |
a:=1 |
2 |
| (x,y):=(y,x) | permute les valeurs de x et de y |
| x+->x*x+1 | AnonymousFunction |
| (x,y)->x*y+2*x | AnonymousFunction |
| macro u == sin | |
| macro u == (x=x+1; y=y*y) | |
| macro u(x) == (y=sin(x);cos(x)) | |
| f(x: Integer): Integer == x+1 | FunctionCalled f |
| g : Integer->Integer g(x)==x+1 |
FunctionCalled g |
| h(x) == x+1 | FunctionCalled h |
| sin x ==1 | |
| sin(2) | 1 |
| sin(2)$Float | 0.9092974268 |
Instruction |
Résultat |
Type ou description |
| f(0) == 1 f(n | n > 0) == n * f(n - 1) f(n) == error "factoriel d'un negatif " |
||
| )display value f | Definition: f 0 == 1 f (n | 0 < n) == n f(n - 1) f n == error(factoriel d'un negatif ) |
|
| p:=x^2*y+z+1 function(p,f,x) function(p,g,x,y) function(p,h,[x,y,z]) |
||
| s(x,y)==(free a; a:=x*y+1; [a,a]) | free a; signifie que a est une variable globale | |
| h == (x: INT,y: INT): FRAC INT +-> x/y | ||
# The x is analyzed and its default type is
Variable(x).
# The 2 is analyzed and its default type is
PositiveInteger.
# The 3 is analyzed and its default type is
PositiveInteger.
# Because the arguments to ``/'' are integers, Axiom
gives the expression 2/3 a default target type of
Fraction(Integer).
# Axiom looks in PositiveInteger for ``/''.
It is not found.
# Axiom looks in Fraction(Integer) for ``/''.
It is found for arguments of type Integer.
# The 2 and 3 are converted to objects of type
Integer (this is trivial) and ``/'' is applied,
creating an object of type Fraction(Integer).
# No ``+'' for arguments of types Variable(x) and
Fraction(Integer) are found in either domain.
# Axiom resolves
resolve
(see ugTypesResolve )
the types and gets Polynomial (Fraction (Integer)).
# The x and the 2/3 are converted to objects of this
type and + is applied, yielding the answer, an object of type
Polynomial (Fraction (Integer)).