Calculer sur des nombres
I. Calculer sur des entiers
Remarquons que contrairement aux langages de programmation classique, les entiers sont dans Maple de "longueur infinie" : ils ne sont pas limités en taille (ou plutôt la limite est telle que vous ne pourrez jamais l'atteindre pratiquement.
1.Fonctions utilisées
En dehors des opérations évidentes sur les entiers (+,-,*,^) on utilisera les fonctions suivantes de Maple 
Calcul de la factorielle:
?factorial
CALLING SEQUENCE:
   expr ! or factorial (expr)
SYNOPSIS:   
- The factorial operator ``!'' and the function factorial both produce the pro-
  duct of the numbers from 1 to the given argument (if it is a non-negative
  integer)

Décomposition en produits de nombres premiers:
?ifactor;
CALLING SEQUENCE:
   ifactor(n)
   ifactor(n, method)   
PARAMETERS:
   n      - integer or a rational
   method - (optional) name of base method for factoring  
SYNOPSIS:   
- ifactor returns the complete integer factorization of n.

Tester si un nombre est premier:
?isprime;
CALLING SEQUENCE:
   isprime(n, iter)
PARAMETERS:
   n    - integer
   iter - (optional) positive integer (default 5) 
SYNOPSIS:   
- The function isprime is a probabilistic primality testing routine.  
- It returns false if n is shown to be composite within iter tests and returns
  true otherwise.  If isprime returns true, n is ``very probably'' prime

Trouver le n-ième nombre premier:
?ithprime
CALLING SEQUENCE:
   ithprime(i)
PARAMETERS:
   i - positive integer
SYNOPSIS:   
- The function ithprime returns the i'th prime number, where the first prime
  number is 2.

Calculer le PCGD et le PPCM de deux entiers
?igcd;
?ilcm;
CALLING SEQUENCE:
   igcd(x_1,x_2,...);
   ilcm(x_1,x_2,...);
PARAMETERS:
   x_1,x_2,... - any integers
SYNOPSIS:   
- The function igcd computes the greatest common divisor of an arbitrary number
  of integers.  The function ilcm computes the least common multiple of an
  arbitrary number of integers.

2.Exemples d'utilisation
• 2^100;
                     1267650600228229401496703205376
• ifactor(");
                                     100
                                  (2)
• 100!;
933262154439441526816992388562667004907159682643816214685929638952175999\
932299156089414639761565182862536979208272237582511852109168640000000000\
00000000000000
• ifactor(");
    97    48    24    16     9     7     5     5     4     3     3     2
 (2)   (3)   (5)   (7)   (11)  (13)  (17)  (19)  (23)  (29)  (31)  (37)

         2     2     2
     (41)  (43)  (47)  (53) (59) (61) (67) (71) (73) (79) (83) (89) (97)
• ithprime(300);
                                   1987
• isprime(");
                                   true
• ifactor(2^(2^5)+1);
                             (641) (6700417)
II. Calculer sur des rationnels
Les nombres rationnels sont représentés dans Maple comme quotient de deux entiers premiers entre eux, Maple se chargeant au besoin de faire les simplifications nécessaires.
• 1/3 + 2/7;
                                    13
                                   ----
                                    21
Les nombres rationnels sont automatiquement présentés sous forme irréductible
• 2/8;
                                   1/4
et les opérations sur les rationnels sont effectuées automatiquement
• 1/3+1/3+1/3;
                                    1

• 1/10!+3/(2^5+1);
                                  3628811
                                 --------
                                 39916800
III. Calculer sur des nombres algébriques
Maple permet également de travailler sur des symboles algébriques comme la racine carrée d'un nombre entier ou rationnel (et même sur une racine symbolique d'un polynôme irréductible à coefficients entiers ou rationnels, voir pour cela la signification de la fonction RootOf).
La racine carrée utilise la fonction sqrt , mais son résultat est automatiquement converti sous forme de puissance fractionnaire.
?sqrt;
FUNCTION: sqrt - square root
CALLING SEQUENCE:
   sqrt(x)     
PARAMETERS:
   x - any algebraic expression
SYNOPSIS:   
- The function sqrt forms the square root of its argument x.  It returns the
  square root of integers and polynomials which are perfect squares.  It is
  mapped onto products.

 	Les symboles algébriques élémentaires se représentent par des puissances fractionnaires ( 3^(1/5)  pour la racine 5-ième de 3.
	Les calculs sur les nombres algébriques ne sont pas faits automatiquement et en particulier les produits et les puissances (pour la raison évidente qu'il n'est pas clair que le développement d'un produit ou d'une puissance conduise réellement à une expression plus simple). Pour forcer une développement on dispose de la fonction expand:
?expand
CALLING SEQUENCE:
   expand(expr, expr_1, expr_2, . . ., expr_n)
PARAMETERS:
   expr                        - any algebraic expression
   expr_1, expr_2, ..., expr_n - (optional) expressions
SYNOPSIS:   
- The primary application of expand is to distribute products over sums.  This
  is done for all polynomials.  For quotients of polynomials, only sums in the
  numerator are expanded --- products and powers are left alone.
- expand also knows how to expand most of the mathematical functions including
  sin, cos, tan, sinh, cosh, tanh, det, erf, exp, factorial, GAMMA, ln, max,
  min, Psi, binomial, sum, product, int, limit, bernoulli, euler, BesselJ,
  BesselY, BesselI, BesselK, etc.
- The optional arguments expr_1, expr_2, ..., expr_n are used to prevent par-
  ticular sub-expressions in expr (expr_1, expr_2, ..., expr_n) from being
  expanded. 

• expand((sqrt(3)-1)^6);
                                         1/2
                              208 - 120 3

• expand((2^(1/5)-1)^5);
                        4/5       3/5       2/5      1/5
                 1 - 5 2    + 10 2    - 10 2    + 5 2
IV. Calculer sur des réels
Un réel Maple peut aussi bien être une expression symbolique que son approximation en virgule flottante.
1.Fonctions classiques 
Maple dispose de toute une gamme de fonctions classiques. La plupart de ces fonctions sont en général non évaluées et leur résultat reste sous forme symbolique (comme sin(1)), sauf quand leur résultat possède une simplification naturelle (comme sin(0), sin(Pi), abs(-sqrt(3))), où lorsque le pazramètre qui leur est passé est déjà une approximation en virgule flottante (comme  sin(1.5)). Dans ce dernier cas, Maple retourne une approximation en virgule flottante du résultat.
    abs       - absolute value of real or complex argument
    bernoulli - Bernoulli numbers and polynomials
    BesselI   - modified Bessel function of the first kind I(v,x)
    BesselJ   - Bessel function of the first kind J(v,x)
    BesselK   - modified Bessel function of the second kind K(v,x)
    BesselY   - Bessel function of the second kind Y(v,x)
    Beta      - Beta function:  Beta(x,y) = GAMMA(x)*GAMMA(y)/GAMMA(x+y)
     binomial  - binomial coefficients:  binomial(n,r) = n!/(r!*(n-r)!)
    Ci        - cosine integral = gamma + ln(x) + int( (cos(t) 1)/t, t=0..x)
    dilog     - dilogarithm integral = int( ln(t)/(1-t), t=1..x )
    Ei        - exponential integral = int( exp(t)/t, t= -infinity..x )
    erf       - error function = 2/sqrt(Pi) * int( exp(-t^2), t=0..x )
    erfc      - complementary error function = 1-erf(x)
     exp       - the exponential function:  exp(x) = sum(x^i/i!,i=0..infinity)
    factorial - the factorial function factorial(n) = n!
   GAMMA     - the gamma function
                     GAMMA(z) = int( exp(-t)*t^(z-1), t=0..infinity )
                  and the incomplete Gamma function
                     GAMMA(a,x) = int( exp(-t)*t^(a-1), t=x..infinity )
    ln        - natural logarithm (logarithm with base E = 2.71828...)
    lnGAMMA   - ln of the gamma function
    log       - initially assigned the name ln. Typically, the user assigns to
                  this a function that computes logarithms to some other base.
    log10     - log to the base 10
    Psi       - polygamma function  Psi(x) = diff( ln(GAMMA(x)), x )  and
                   its derivatives  Psi(n,x) = diff(Psi(x),x$n)
    signum    - sign of a complex argument signum(z) = z/abs(z)
    Si        - sine integral = int( sin(t)/t, t=0..x )
    W         - the function satisfying  W(x) * exp(W(x)) = x
    Zeta      - Riemann zeta function  Zeta(s) = sum(1/i^s,i=1..infinity)
                  and its derivatives  Zeta(n,s) = diff(Zeta(s),s$n)  and with
                  three arguments  Zeta(n,s,q) = diff(Zeta(0,s,q),s$n)  where
                  Zeta(0,s,q) = sum(1/(i+q)^s,i=1..infinity)   
- The trigonometric and hyperbolic functions:
       sin, cos, tan, sec, csc, cot, sinh, cosh, tanh, sech, csch, coth  
- The inverse trigonometric and inverse hyperbolic functions:
       arcsin, arccos, arctan, arcsec, arccsc, arccot, arctan,
       arcsinh, arccosh, arctanh, arcsech, arccsch, arccoth

2.Evaluation des réels en virgule flottante
Il est essentiel de distinguer dans tout logiciel de calcul formel, l'objet mathématique nombre réel (par exemple sin(1)) de ses approximations en virgule flottante qui ressemblent aux types real ou float des langages de programmation classiques (comme 0.8414709848…). 
	Les approximations de nombres réels en virgule flottante s'écrivent de manière classique (voir aussi en cas de besoin la signification de la fonction Float). Comme pour les nombres entiers et contrairement à d'autres langages de programmation, leur taille n'est pas limitée aussi bien en ce qui concerne le nombre de chiffres avant la virgule que celui après la virgule (ce dernier ayant une valeur par défauts contenu dans la variable Maple Digits dont on peut modifier la valeur). Pour ces approximations on dispose d'une fonction d'évaluation en virgule flottante à une précision arbitraire.
?evalf;
FUNCTION: evalf - evaluate using floating-point arithmetic
CALLING SEQUENCE:
   evalf(expr, n)
PARAMETERS:
   expr - any expression
   n    - (optional) integer specifying number of digits
SYNOPSIS:   
- evalf evaluates to floating-point numbers expressions (or subexpressions)
  involving constants such as Pi, E, gamma, and functions such as exp, ln, sin,
  arctan, cosh, GAMMA, erf. 
- The accuracy of the result is determined by the value of the global variable
  Digits. By default the results will be computed using 10-digit floating-point
  arithmetic, since the initial value of Digits is 10. A user can change the
  value of Digits to any positive integer.
- If a second parameter, n, is present the result will be computed using
  n-digit floating-point arithmetic.

Remarquez le rôle important de la variable globale Digits qui fixe la précision des calculs en virgule flottante
Digits        number of digits carried in floats (default is 10)
• evalf(sin(1));
                               .8414709848
• evalf(sin(1),35);
                   .84147098480789650665250232163029900
• evalf(Pi,35);
                   3.1415926535897932384626433832795029
• evalf(2/7,15);
                             .285714285714286
3.Evaluations exactes et évaluations en virgules flottantes
Comparer les calculs suivants
• sin(1);
                                  sin(1)
• sin(1.0);
                               .8414709848
• evalf(sin(1))-sin(1.0);
                                    0
• sin(Pi);
                                    0
• sin(evalf(Pi));
                                           -9
                            -.4102068570*10
• GAMMA(0.5)-evalf(sqrt(Pi));
                                    0
VI.Calculer sur des complexes
Un nombre complexe s'écrit sous la forme   a + b*I. Les calculs sur les nombres complexes s'effectuent de manière classique
?I;
complex number such that I^2 = 1.  The name I is an alias to the radical (-1)^(1/2).
Les calculs de somme se font automatiquement. Suivant la version de Maple que vous utilisez, les calculs de produit et de puissances peuvent être faits automatiquement (version V release 2) ou demander l'appel de la fonction d'évaluation complexe evalc.
• (2+3*I)*(4+5*I);
                           (2 + 3 I) (4 + 5 I)
?evalc;
FUNCTION: evalc - evaluate in the complex number field   
CALLING SEQUENCE:
   evalc(expr)  
PARAMETERS:
   expr - any expression   
SYNOPSIS:   
- This function is for evaluating and simplifying complex numbers.  evalc attempts to split an expression into its real and imaginary components.
- When possible, the result of evalc will be in the canonical form
  expr_1 + expr_2 * I involving the symbol I, which is an alias for sqrt(-1).
- When evalc encounters an unevaluated function call (e.g.  f(1+I) where f is not defined) then it will attempt to
  put the arguments in the above canonical form.
- evalc(Re(expr)) and evalc(Im(expr)) return the real and imaginary parts of an expression.
- To find the complex conjugate of an expression use evalc(conjugate(expr)).
- A complex number may be represented to evalc as polar(r,theta) where r is the modulus and theta is the argument of the number.
• evalc(");
                                - 7 + 22 I

Les fonctions rencontrées dans le domaine réel sont également définies dans le domaine complexe (pour certaines fonctions "multivaluées", une détermination principale est utilisée). Leur évaluation demande dans toutes les versions l'emploi de la fonction evalc pour des raisons évidentes: quelle est l'expression la plus simple entre les deux lignes qui suivent , cos(2+3i) ou  cos(2) cosh(3) - i sin(2) sinh(3) ?
• evalc(cos(2+3*I));
                    cos(2) cosh(3) - sin(2) sinh(3) I
• evalf(");
                       - 4.189625692 - 9.109227896 I
• arcsin(2);
                                arcsin(2)
• evalc(");
                                          1/2
                         1/2 Pi + ln(2 + 3   ) I
• evalf(");
                       1.570796327 + 1.316957897 I

VII. Exercices
Exercice 1
	Le nombre exp(π √163/3) est-il un entier?
Exercice 2
	Montrer que √(286+2√19549) = √113 + √173