Calculer avec des symboles

I.Expressions algébriques
1.Transformations d'expressions algébriques
Les expressions algébriques (et en particulier les polynômes et les fractions rationnelles) sont manipulées par  un grand nombre de fonctions de Maple. Leur affichage peut parfois surprendre (et en particulier l'ordre que retient Maple pour les monômes). Pour cette raison, une des premières fonctions à connaître est celle qui permettra un affichage "plus classique"
?sort
FUNCTION: sort - sort a list of values or a polynomial
CALLING SEQUENCE: (for polynomials)
   sort(A)   
   sort(A, V)  
PARAMETERS:
   A - an algebraic expression
   V - (optional) variables
SYNOPSIS:   
- In Maple, polynomials are not automatically stored in sorted order.  They are stored in the order they were first created and printed in the order they are  stored.  The sort function can be used to sort polynomials.  But please note  that sorting polynomials is a destructive operation: the input polynomial will be sorted "in-place". 
- If V is given it specifies the variable ordering to be used when sorting polynomials.  It can be a list or set of names (for the multivariate case). All polynomials in the expression A are sorted into decreasing order in V.  If V is not specified, the indets appearing in A will be used. 
- An additional 3rd argument, either the string plex or tdeg can be given to fine the ordering for the multivariate case.  If tdeg is specified (default) then polynomials in V are sorted in total degree with ties broken by lexicographical order.  If plex is specified, polynomials in V are sorted in pure lexicographical order.
Ensuite on peut développer, factoriser, simplifier, combiner des expressions algébriques à l'aide des fonctions 
suivantes.
?expand
FUNCTION: expand - expand an expression
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 als 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 particular sub-expressions in expr (expr_1, expr_2, ..., expr_n) from being expanded.
?factor
FUNCTION: factor - factor a multivariate polynomial 
CALLING SEQUENCES:
   factor(a); or factor(a,K);
PARAMETERS:
   a - an expression
   K - an algebraic extension
SYNOPSIS:   
- The function factor computes the factorization of a multivariate polynomial with integer, rational or algebraic number coefficients.
- If the input is a rational function, then a is first ``normalized'' (see normal) and the numerator and denominator of the resulting expression are then factored.  This provides a ``fully-factored form'' which can be used to simplify in the same way the normal function is used.  However, it is more expensive to compute than normal
- If the input a is a list, set, equation, range, series, relation, or function, then factor is applied recursively to the components of a.   
- The call factor(a,K) factors a over the algebraic number field defined by K. K must be a single RootOf or a list or set of RootOf's or a single radical or a list or set of radicals.
- If the 2nd argument K is not given, the polynomial is factored over the rationals.  Note that any integer content (see first example below) is not factored.
Pour factoriser un polynôme en utilisant des radicaux (et en particulier des nombres complexes) vous devez spécifier les radicaux à utiliser:
• factor(x^4+1);
                                   4
                                  x  + 1

• factor(x^4+1,sqrt(2));
                     2    1/2          2    1/2
                   (x  + 2    x + 1) (x  - 2    x + 1)

• factor(x^4+1,I);
                              2        2
                            (x  - I) (x  + I)

Un certain nombre de simplifications élémentaires sont faites automatiquement, mais pour des simplifications plus élaborées vous devrez mettre en oeuvre la fonction simplify.
?simplify
FUNCTION: simplify - apply simplification rules to an expression
CALLING SEQUENCE:
   simplify(expr)
   simplify(expr, n1, n2, ...)
PARAMETERS:
   expr       - any expression
   n1, n2,... - (optional) names or sets or lists
SYNOPSIS:   
- The simplify function is used to apply simplification rules to an expression.  If only one argument is present, then simplify will search the expression for  function calls, square roots, radicals, and powers.  Next it will invoke the  appropriate simplification procedures, which include: exp, ln, sqrt, trig (for trig  functions), radical (occurrence of fractional powers), power (occurrence of powers, exp, ln). Further information on particular simplification procedures is available for
  the subtopics simplify[<name>] where <name> is one of:  power, radical, RootOf, sqrt, trig .
- In the case of two or more arguments where the additional arguments are  names, simplify will only invoke the simplification procedures specified by  the additional arguments.
Nous verrons plus loin que la fonction simplify a également d'autres utilités. Pour mettre un peu d'ordre dans les expressions algébriques, on utilise la fonction collect qui regroupe ensemble des monômes correspondnat aux mêmes puissances des variables indiquées.
?collect
FUNCTION: collect - collect coefficients of like powers
CALLING SEQUENCE:
   collect(a, x)
   collect(a, x, form)   
PARAMETERS:
   a    - an expression
   x    - an indeterminate, or a list or set of indeterminates
   form - (optional) name  
SYNOPSIS:   
- The collect function views a as a polynomial in x and collects all the coefficients with the same power of x .   
- The second argument x can be a single indeterminate (univariate case) or a  list or set of indeterminates x_1, x_2, ..., x_n (multivariate case) .  The  indeterminates can be names or unevaluated function calls but not sums or  products.   
- Two forms for the result are available.  The form is specified by the thirdirdgument.  It may be the name recursive (the default) or the name distributed.      
- The recursive form is obtained by first collecting the coefficients in x_1,  then for each coefficient in x_1, collecting the coefficients in x_2 and so  on.  The distributed form is the form obtained by collecting the coefficients  of x_1^e1 * x_2^e2 * ... * x_n^eN together.
• collect(y (sin(x) + 1) + sin(x), sin(x));
                          y(sin(x) + 1) + sin(x)
Dans le même ordre d'idée, la fonction combine fait pour la plupart des fonctions les opérations inverses de la fonction expand.
?combine
FUNCTION: combine - combine terms into a single term   
CALLING SEQUENCE:
   combine(f)
   combine(f, n)   
PARAMETERS:
   f - any expression
   n - a name   
SYNOPSIS:   
- The combine function applies transformations which combine terms in sums,  products, and powers into a single term.  This function is applied recursively to the components of lists, sets, and relations; that is, f and n may  be lists/sets of expressions and names, respectively.  .  
- For many functions, the transformations applied by combine are the inverse of  the transformations that are applied by expand.  
- Subexpressions involving Int, Sum, and Limit are combined into one expression  where possible using linearity; that is, c1*f(a,range) + c2*f(b,range) ==>  f(c1*a+c2*b,range).
• combine(sin(x)^3,trig);
                       - 1/4 sin(3 x) + 3/4 sin(x)

Enfin les fonctions suivantes permettent d'extraire des composantes des expressions algébriques, coefficients, numérateurs ou dénominateurs.
?coeff, lcoeff, tcoeff
FUNCTION: coeff - extract a coefficient of a polynomial   
CALLING SEQUENCE:
   coeff(p,x)
   coeff(p,x,n)
   coeff(p,x^n)   
PARAMETERS:
   p - a polynomial in x
   x - the variable (an expression)
   n - (optional) an integer  

SYNOPSIS:   
- The coeff function extracts the coefficient of x^n in the polynomial p.  Note that the input expression p must be collected in x.  Use the function  collect(p,x) prior to calling coeff, if necessary.   
- If the third argument is omitted, it is determined by looking at the second  argument.  Thus coeff(p,x^n) is equivalent to coeff(p,x,n) for n <> 0.   
- The related functions lcoeff, tcoeff extract the leading coeffi-  cient, trailing coefficient of p in x respectively.
?coeffs
FUNCTION: coeffs - extract all coefficients of a multivariate polynomial   
CALLING SEQUENCE:
   coeffs(p, x, 't');   
PARAMETERS:
   p - multivariate polynomial
   x - (optional) indeterminate or list/set of indetermina
testes - (optional) name   
SYNOPSIS:   
- The coeffs function returns an expression sequence of all the coefficients of  the polynomial p with respect the indeterminate(s) x.   - If x is not specified, coeffs computes the coefficients with respect to all
  the indeterminates of p (see the indets function).  If a third argument t is  specified (call by name), it is assigned an expression sequence of the terms  of p.  There is a one to one correspondence between the coefficients and the  terms of p.  
- Note that p must be collected with respect to the appropriate indeterminates.
?numer, denom
FUNCTION: numer - numerator of an expression
FUNCTION: denom - denominator of an expression
CALLING SEQUENCE:
PARAMETERS:
   e - any algebraic expression
SYNOPSIS:   
- The procedures numer and denom are typically called after first using the  normal function.  The procedure normal is used to put an expression in ``normal form'' which is the form numerator/denominator where both the numerator  and denominator are polynomials.  In this case, numer simply picks off the nummerator of e and denom picks off the denominator of e.  Note that if e is in  normal form, the numerator and denominator will have integer coefficients.
- If e is not in normal form (e contains a subexpression which has one or more  terms which are quotients of expressions), it is first converted into a normal form.  A common denominator is found so that e can be expressed in the  form numerator/denominator.

Pour décomposer en éléments simples, il faut un peu plus se creuser la tête. Pour Maple, il s'agit en fait d'une conversion
?convert[parfrac]
 FUNCTION: convert/parfrac - convert to partial fraction form
CALLING SEQUENCE:
   convert(f, parfrac, x)
  PARAMETERS:
   f        - rational function
   x        - main variable name
  SYNOPSIS:   
- Convert to parfrac performs a partial fraction decomposition of the rational  function f in the variable x.
Etudiez les exemples ci dessous et soyez sûr de bien les comprendre. Les fonctions que nous venons d'étudier sont celles que l'on utilise tous les jours dans le calcul algébrique
•exp:=expand((1+sin(x))^10);
                                 2             3             4
 exp := 1 + 10 sin(x) + 45 sin(x)  + 120 sin(x)  + 210 sin(x)
             5             6             7            8            9
 + 252 sin(x)  + 210 sin(x)  + 120 sin(x)  + 45 sin(x)  + 10 sin(x)
         10
 + sin(x)
•coeff(exp,sin(x)^5);
                                   252
•coeffs(exp);
              1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1

•factor(exp);
                                          10
                              (sin(x) + 1)
•collect(y (sin(x) + 1) + sin(x), sin(x));
                          y(sin(x) + 1) + sin(x)
•convert(1/(x^4-1),parfrac,x);
                        1           1            1
                    --------- - --------- - ----------
                    4 (x - 1)   4 (x + 1)       2
                                            2 (x  + 1)
2.Calculs modulo un nombre premier
Un certain nombre des fonctions ci dessus peuvent s'effectuer d'une manière spécifique modulo un nombre premier c'est à dire dans l'anneau des polynômes à coefficients dans Z/pZ. Pour cela il suffit d'utiliser une forme inerte de la fonction (c'est à dire une fonction qui ne sera pas évoluée dans un premier temps) qui se distingue de la fonction active par le fait qu'elle commence par une majuscule, et de faire suivre par un  mod p.
factor(x^4+1) mod 3;
                                   4
                                  x  + 1
L'expression a été évaluée, mais le polynôme n'a pas été factorisée car il est irréductible sur les entiers. C'est  après sa tentative de factorisation sur les entiers que Maple l'a réduit modulo 3.

Factor(x^4+1);
                                      4
                              Factor(x  + 1)
La fonction Factor (contrairement à la fonction factor) est inerte. Elle ne fait rien (à moins qu'elle ne soit suivie d'un  mod … ).

Factor(x^4+1) mod 3;
                         2              2
                       (x  + 2 x + 2) (x  + x + 2)
3.Racines communes, racines multiples
Deux fonctions de Maple vous seront particulièrement utiles pour le calcul algébrique et la manipulation des équations polynomiales, ce sont celles qui calculent le résultant de deux polynômes et le discriminant d'un polynôme. Rappelons que le dsicriminant de deux polynômes en la variable x est une expression polynomiale en les coefficients des deux polynômes qui est nulle si et seulement si les deux polynômes ont une racine commune en x. Quant au discriminant d'un polynôme en x, c'est une expression polynomiale en les coefficients du polynôme qui est nulle si et seulement si ce polynôme a une racine multiple en x.
?resultant
FUNCTION: resultant - compute the resultant of two polynomials  
CALLING SEQUENCE:
   resultant(a, b, x)   
PARAMETERS:
   a,b - polynomials in x
   x   - a name   
SYNOPSIS:   
- The function resultant computes the resultant of the two polynomials a and b
  with respect to the indeterminate x.
?discrim
FUNCTION: discrim - discriminant of a polynomial   
CALLING SEQUENCE:
   discrim(p, x)  
PARAMETERS:
   p - polynomial in x
   x - independent variable   
SYNOPSIS:   
- If d=degree(p,x) and a=lcoeff(p,x) then the discriminant is   
         (-1)^(d*(d 1)/2)*resultant(p,diff(p,x),x)/a
II.Substitutions, affectations
1.Substitutions
La substitution est un opération essentielle du calcul formel. La manière la plus simple de procéder est d'utiliser la fonction subs:
?subs
FUNCTION: subs - substitute subexpressions into an expression   
CALLING SEQUENCE:
   subs(s_1,s_2,...,s_n,expr)   
PARAMETERS:
   s_1,... - equations or sets or lists of equations
   expr    - any exp
ssion   
SYNOPSIS:   
- The function subs returns an expression resulting from applying the substitutions specified by the first arguments to the last argument expr.   
- The substitutions are performed sequentially starting with s1.  
The substitutions within a set or list are performed simultaneously.   
- Every occurrence of the left hand side of a substitution equation that appears in expr is replaced by the right hand side of the equation.   
- The action of substitution is not followed by evaluation.  In cases where full evaluation is desired, it is necessary to use the eval function to force an evaluation.  For example, subs( y=ln(x), exp(y) ), as shown below.
Il faut distinguer soigneusement les substitutions successives (séparées par des virgules) des substitutions simultanées (regroupées par des accolades):
• subs(x=y,y=x,sin(x)+y^4);
                                         4
                               sin(x) + x

La variable x a d'abord été remplacée par y, puis dans l'expression ainsi obtenue, la variable y a été remplacée par x. Par contre, si on met des accolades on obtient un échange des variables.
• subs({x=y,y=x},sin(x)+y^4);
                                         4
                               sin(y) + x

La substitution a plusieurs utilités. D'une part remplacer des variables par des valeurs symboliques:
• subs({x=3,y=1-a},(x+y)*(x-y)^2);
                                            2
                             (4 - a) (2 + a)
En particulier, les substitutions permettent d'évaluer des expressions pour des valeurs numériques des paramètres
• subs(x=1,sin(x)/(x+1));
                                1/2 sin(1)

Les substitutions ne se contentent pas de porter sur des variables. Elles peuvent porter également sur des expressions algébriques
• subs({cos(x)=(1-t^2)/(1+t^2),sin(x)=2*t/(1+t^2)},
sin(x)+cos(x));
                                            2
                                 t     1 - t
                            2 ------ + ------
                                   2        2
                              1 + t    1 + t

Mais la fonction simplify peut aussi permettre des substitutions beaucoup plus complexes. C'est ainsi que dans le calcul ci dessous, nous remplaçons x+y et x*y par s et p en réexprimant complêtement l'expression à l'aide de ces nouvelles variables.
• simplify(x^7+y^7,{s=x+y,p=x*y},[x,y,s,p]);
                      7        5       2  3        3
                     s  - 7 p s  + 14 p  s  - 7 s p
?simplify[siderels]
FUNCTION: simplify/siderels - simplify with respect to side relations   
CALLING SEQUENCE:
   simplify(expr, eqns)
   simplify(expr, eqns, vars)   
PARAMETERS:
   expr - an expression
   eqns - a set or list of equations (an expression e is understood as the
          equation e=0)
   vars - (optional) a set or list of variables   
SYNOPSIS:   
- Simplification of expr with respect to the side relations eqns is performed.
  The result is an expression which is mathematically equivalent to expr but
  which is in ``normal form'' with respect to the specified side relations.   
- If vars is not specified then it is determined using indets.  There are two
  reasons for pre-specifying vars: 
  (i) perhaps some indeterminates are meant to be considered as parameters
  rather than variables;   
  (ii) the precise form of simplification to be performed can be controlled by
  specifying vars as a list (see below).

Les équations précisent les relations entre les variables, la liste des variables (entre crochets car c'est une liste) précise l'ordre de priorité des variables: les premières sont celles qui doivent être éliminées en priorité, les dernières celles qui doivent être conservées en priorité. Dans cette élimination, le mot de variable doit être compris au sens large. Ce peut être également un appel de fonction non évalué. C'est ainsi que pour simplifier une expression trigonométrique en tenant compte de la relation bien connue comme ci dessous, les variables seront cos(x) et sin(x).
•eqn:={sin(x)^2+cos(x)^2=1}:
e:=sin(x)^3-11*sin(x)^2*cos(x)+3*cos(x)^3-sin(x)*cos(x)+2:
simplify(e, eqn);
              3            2
        sin(x)  - 14 sin(x)  cos(x) - sin(x) cos(x) + 2 + 3 cos(x)
Maple a éliminé le maximum de cosinus (qui se trouve avant sinus dans l'ordre alphabétique). Si vous voulez éliminer le maximum de sinus, il vous faut donner la liste de priorité.
•simplify(e,eqn,[sin(x),cos(x)]);
            3                                    2
   14 cos(x)  - sin(x) cos(x) + 2 - sin(x) cos(x)  + sin(x) - 11 cos(x)

Remarquez que cette substitution à l'aide de simplify est beaucoup plus performante que les bêtes substitutions
subs(cos(x)^2=1-sin(x)^2,e);
             3            2                  3
       sin(x)  - 11 sin(x)  cos(x) + 3 cos(x)  - sin(x) cos(x) + 2
subs(cos(x)=sqrt(1-sin(x)^2),e);
              3            2            2 1/2                2 3/2
        sin(x)  - 11 sin(x)  (1 - sin(x) )    + 3 (1 - sin(x) )
                                 2 1/2
             - sin(x) (1 - sin(x) )    + 2
cette dernière substitution ayant en outre l'inconvénient d'être mathématiquement incorrecte pour un x général.
2.Affectation immédiate, affectation différée
En Maple, l'affectation ressemble à ce qu'elle est dans des langages de programmation comme Pascal ou C. Son symbole est le même qu'en Pascal, :=.
?:=
SYNOPSIS:   
- <lhs> := <rhs>;   
- The assignment operator := assigns the to <lhs> the value of <rhs>.  The left  hand side of the assignment operator must evaluate to a name, or a subscript, or a function call.   
- First, the left hand side is evaluated to a name (see the evaln function),  second the right hand side is evaluated as an expression, then the assignment is performed.  The value of the assignment statement is the right hand side.

Il faut bien comprendre la signification de tout ceci. D'une part le terme de droite est évalué complêtement (c'est à dire que l'expression qui sera assignée au terme de gauche est la valeur du terme de droite au moment où l'affectation est réalisée), d'autre part le terme de gauche (qui peut être un nom, un nom indicé ou un appel de fonction) n'est pas évalué et on lui affecte la valeur du terme de droite. Il s'agit d'une affectation immédiate, ou encore d'une affectation par valeur (analogue au passage de paramètre par valeur). Un exemple:
• x:=2; y:=x+1; x:=100; y;
                                  x := 2
                                  y := 3
                                 x := 100
                                    3
Si par contre on souhaite indiquer que à tout moment l'expression y doit valoir x+1, il faut empêcher l'évaluation du terme de droite. Pour cela, il suffit de le mettre entre apostrophes. On réalise ainsi une affectation différée (tout se passe comme si l'affectation de x+1 à y n'était réalisée qu'au moment où la variable y est uilisée (et à ce moment x vaut 100 et  non plus 3).
• x:=2; y:='x+1';  x:=100; y;
                                  x := 2
                                y := x + 1
                                 x := 100
                                   101
Exemple: comparez les effets de l'affectation immédiate (à la Pascal)
x:=3; x:=x+1; x;

et de l'affectation différée
x:=3;x:='x+1'; x;

Vous pouvez également affecter les valeurs d'une fonction:
• f(1):=1; f(1)+2;
                                f(1) := 1
                                    3
• f(x):=0; f(x); f(t);
                                f(x) := 0
                                    0
                                   f(t)
Attention à ce dernier exemple. On a défini le fait que f(x) devait valoir 0. Mais t n'est pas x, et f(t) reste donc non évalué. On peut même faire des choses baroques du type
• sin(1):=2: sin(1)+2;
                                    4
et Maple ne proteste même pas. Comme quoi l'affectation de valeurs d'une fonction est à manier avec précaution. On en verra l'utilité principale avec la définition de fonctions en liaison avec l'option remember.
3. Suppression d'une affectation
Pour supprimer une affectation de la variable x, il suffit de lui affecter la variable x elle même non évaluée, c'est à dire mise entre apostrophes.
x:='x';
On peut aussi utiliser la fonction unassign qui est particulièrement commode si l'on veut supprimer d'un seul coup plusieurs affectations.
?unassign
FUNCTION: unassign - unassign names
CALLING SEQUENCE:
   unassign(name1, name2, ...)
PARAMETERS:
   name1, name2, ... - names
SYNOPSIS:   
- This procedure unassigns all the unevaluated names given as input.  The value
  returned by unassign is NULL.  
- This function should be defined by the command readlib(unassign) before it is
  used.   
Cette fonction doit être préalablement chargée depuis la librairie par un  readlib(unassign).
III. Sommation, dérivation, integration
1. Sommes et produits
Maple dispose de deux fonctions qui servent à la fois à calculer des sommes ou des produits ou à construire des types sommes ou produits. Ce sont les fonctions sum et product (et leurs formes inertes Sum et Product que Maple n'essaye pas d'évaluer)

FUNCTION: sum - definite and indefinite summation
FUNCTION: Sum - inert form of summation
CALLING SEQUENCES:
   sum('f', 'k');  sum('f', 'k'=m..n);  sum('f', 'k'=alpha);
   Sum('f', 'k');  Sum('f', 'k'=m..n);  Sum('f', 'k'=alpha);
PARAMETERS:
   f     - an expression
   k     - a name, the summation index
   m, n  - integers or arbitrary expressions
   alpha - a RootOf expression
SYNOPSIS:   
- The call sum('f', 'k') computes the indefinite sum of f(k) with respect to k. Thus it computes a formula g such that g(k+1)-g(k)=f(k) for all k.
- The call sum('f', 'k'=m..n) computes the definite sum of f(k) over the given  range m..n, so it computes f(m) + f(m+1) + ... + f(n).  The definite sum is  equivalent to g(n+1)-g(m) where g is the indefinite sum.  For example,  sum(n, n) = sum('k', k=0..n-1) = (n^2-n)/2.
- If m = n+1 then the value returned is 0.  If m > n+1 then the value returned  is -sum('f', 'k'=n+1..m-1).
- The call sum('f', 'k'=alpha) computes the definite sum of f(k) summed over  the roots of a polynomial alpha where alpha must be a RootOf.
- Note: It is recommended (and often necessary) that both f and k be enclosed in single quotes to prevent premature evaluation.  (For example, k may have a  previous value.)  Thus the common format is sum('f', 'k'=m..n) .  
- For definite sums, if n-m is a small integer, the sum is computed directly.  Otherwise it is computed via indefinite summation and taking limits, and/or  using various hypergeometric summation identities.
- If Maple cannot find a closed form for the summation, the function call  itself is returned.  (The prettyprinter displays the sum function using a  stylized summation sign.)
- The capitalized function name Sum is the inert sum function, which simply  returns unevaluated.  The prettyprinter understands Sum to be equivalent to  sum for printing purposes.

Une remarque est nécessaire à ce propos. Supposons que Maple rencontre l'évaluation d'une expression du type  sum(expr,i=m..n). Il va alors procéder de la manière suivante: évaluer expr, puis i  puis  m  et n  et enfin évaluer la somme. Plusieurs difficultés peuvent alors surgir:
	-  expr  peut n'être pas évaluable au sens de Maple lorsque i  est un symbole; c'est ainsi que si on veut calculer la somme des éléments d'une liste, l'évaluation de l'expression  sum(l[i],i=1..nops(l)) va bloquer au niveau de l'évaluation de l[i] alors que i   est encore un symbole
	- au contraire i   peut s'évaluer en un objet qui n'est pas un symbole (en particulier si l'on a déjà affecté à  i   une valeur au cours des calculs précédents) et qui ne peut donc pas servir d'indice de sommation.
	La solution à ces deux types de problème est de toujours inclure aussi bien l'expression à sommer que le nom de l'indice de sommation entre apostrophes; en effet l'évaluation d'une expression entre apostrophes consiste simplement à enlever un niveau d'apostrophes. Cela empêchera Maple d'essayer d'évaluer  expr   de manière prématurée alors que i   est encore un symbole et cela garantirua d'autre part que c'est bien le symbole i   qui est utilisé comme indice de sommation, et non une quelconque valeur résiduelle de ce symbole. C'est ainsi que la somme des éléments d'une liste est obtenue par sum('l[i]','i'=1..nops(l)).
	En dehors de ces contraintes, le fonction sum fait aussi bien de la sommation indéfinie (trouver une "primitive discrète"), que de la sommation définie sur un ensemble fini ou infini.

Exemples:
• sum(k^n,n);
                                     n
                                    k
                                  -----
                                  k - 1
• sum(i^3,i=2..n);
                         4              3              2
              1/4 (n + 1)  - 1/2 (n + 1)  + 1/4 (n + 1)  - 1
• sum(x^i,i=0..4);
                                    2    3    4
                           1 + x + x  + x  + x
• sum(1/n^4,n=1..infinity);
                                        4
                                 1/90 Pi
La fonction inerte Sum est une structure qui représente une somme que Maple ne tentera pas de calculer, soit que l'on sache a priori qu'elle n'est pas calculable et que l'on ne veuille pas que Maple perde du temps à essayer successivement ses divers algorithmes, soit que l'on veuille en retarder le calcul pour des raisons diverses.
	L'analogue multiplicatif est la fonction product qui utilise exactement la même syntaxe.
2. Derivation
La dérivation étant purement algorithmique ne présente aucune difficulté pour Maple. La fonction que vous utiliserez le plus souvent est la fonction diff qui est un opérateur de dérivée partielle par rapport à une ou plusieurs variables
?diff
FUNCTION: diff or Diff -   partial differentiation
CALLING SEQUENCE:
   diff(a, x1, x2, ..., xn)
   Diff(a, x1, x2, ..., xn)  
PARAMETERS:
   a       - an algebraic expression
   x1, ... - names  
SYNOPSIS:   
- diff computes the partial derivative of a with respect to x1, x2, ..., xn,  respectively. 
- Note that where n is greater than 1, the call to diff is the same as diff  called recursively. I.e. diff(f(x), x, y); is equivalent to the call  diff(diff (f(x), x), y);
- The sequence operator $ is useful for forming higher-order derivatives.  E.g., diff(f(x),x$4); is equivalent to diff(f(x),x,x,x,x); and  diff(g(x,y),x$2,y$3); is equivalent to diff(g(x,y),x,x,y,y,y); 
- If the derivative cannot be expressed (e.g. if the expression is an undefined  function), the diff function call itself is returned.  (The prettyprinter  displays the diff function in a two-dimensional d/dx format.) 
- The capitalized function name Diff is the inert diff function, which simply  returns unevaluated.  The prettyprinter understands Diff to be equivalent to  diff for printing purposes.
• diff(BesselJ(2,x),x);
                                       BesselJ(2, x)
                     BesselJ(1, x) - 2 -------------
                                             x
• Diff(BesselJ(2,x),x);
                              d
                            ---- BesselJ(2, x)
                             dx
• diff(1/(x^2+1),x$2);
                                2
                               x           2
                         8 --------- - ---------
                             2     3     2     2
                           (x  + 1)    (x  + 1)
Bien entendu, Maple peut également traiter les dérivées de façon purement symbolique (très utilie pour faire des changements de fonctions inconnues dans des équations différentielles)
• diff(g(x)*exp(x),x$2);
         /   2      \
         |  d       |            /  d      \
         |----- g(x)| exp(x) + 2 |---- g(x)| exp(x) + g(x) exp(x)
         |   2      |            \ dx      /
         \ dx       /
Vous pouvez également dériver à l'aide de formes différentielles à l'aide de la fonction D
?D
FUNCTION: D - Differential operator
CALLING SEQUENCE:
   D(f)   
   D[i](f)     
PARAMETERS:
   f - expression which can be applied as a function
   i - positive integer or expression or sequence of such  
SYNOPSIS:   
- Let f be a function of one argument.  The call D(f) computes the derivative  of the function f.  The derivative is a function of one argument such that  D(f)(x) = diff(f(x), x).  That is, D(f) = unapply(diff(f(x), x), x).  Thus D  is a mapping from unary functions to unary functions.   
- Let f be a function of n arguments.  The call D[i](f) computes the partial  derivative of f with respect to its i-th argument.  More generally, D[i,j](f)  is equivalent to D[i](D[j](f)), and D[](f) = f.  Thus D[i] is a mapping from  n-ary functions to n-ary functions.   
- The argument f must be an algebraic expression which can be treated as a  function.  It may contain constants, known function names (e.g. exp, sin),  unknown function names (e.g. f, g), arrow operators (e.g. x -> x^2), and the  arithmetic and functional operators.  For example, f+g, f*g, and f@g are  valid since (f+g)(x) = f(x)+g(x), (f*g)(x) = f(x)*g(x) and (f@g)(x) = f(g(x))  where f@g denotes functional composition.  
- The usual rules for differentiation hold.  In addition, it is assumed that  partial derivatives commute.  Hence D(f+g) = D(f) + D(g),  D(f*g) = D(g*f) = D(f)*g + D(g)*f, D(f@g) = D(f)@g * D(g) etc.
• D(sin);
                                   cos

• D(tan);
                                        2
                                 1 + tan

• D(sin@cos);
                                    (2)
                               - cos    sin

Comprenez vous ce dernier résultat? L'opérateur @ est l'opérateur de composition des fonctions. Quant à la puissance entre parenthèses, elle désigne une puissance au sens de cette composition des fonctions, c'est à dire  cos@cos (que Maple note encore  cos@@2).

3. Intégrales indéfinies (ou primitives)
Maple est capable de calculer des primitives de fonctions usuelles lorsque celles-ci peuvent s'exprimer avec des fonctions usuelles. Au dire de ses auteurs, Maple a implémenté l'algorithme de Risch qui est un algorithme complet au sens où, pour les fonctions ne dépendant pas d'un paramètre
* soit il existe une primitive pouvant s'exprimer avec des fonctions usuelles et Maple la trouve
* soit il n'existe pas de primitive pouvant s'exprimer avec des fonctions usuelles.
le sens à donner à fonctions usuelles est assez large puisque Maple y inclut les fonctions classiques comme le logarithme intégral, le sinus intégrale, la fonction d'erreur, et ainsi de suite.
• int(1/(x^3+1),x);
                         2                 1/2                       1/2
 1/3 ln(x + 1) - 1/6 ln(x  - x + 1) + 1/3 3    arctan(1/3 (2 x - 1) 3   )
• int(sin(x)/x^2,x);
                               sin(x)
                             - ------ + Ci(x)
                                  x
• int(E^(-x^2),x);
                                   1/2
                             1/2 Pi    erf(x)
Pour les intégrales dépendant d'un paramètre, Maple fait de son mieux, mais il faut parfois le guider pour lui indiquer dans quel domaine se trouve le paramètre
• int(1/(1+a*cos(x)),x);
                                       1/2
                              (- 1 + a)    tan(1/2 x)
                      arctanh(-----------------------)
                                            1/2
                                     (1 + a)
                    2 --------------------------------
                                  1/2          1/2
                           (1 + a)    (- 1 + a)
Ce n'est probablement pas la réponse que vous auriez trouvée "à la main" car vous auriez implicitement supposé que |a|<1, contrairement à Maple. Par contre
• int(1/(1+a^2+cos(x)),x);
                                   a tan(1/2 x)
                            arctan(------------)
                                          2 1/2
                                    (2 + a )
                          2 --------------------
                                        2 1/2
                                a (2 + a )
4. Intégrales définies
Maple est capable de calculer un certain nombre d'intégrales définies (c'est à dire entre deux bornes fixées). Il y parvient à coup sûr lorsque l'algorithme de Risch lui permet de trouver une primitive de la fonction sur l'intervalle en question. Par contre, dans le cas contraire, il peut échouer à calculer certaines intégrales "calculables" par des méthodes classiques.
FUNCTION: int or Int 
-   definite and indefinite integration   
CALLING SEQUENCES:   
	int(f,x);  int(f,x=a..b);  int(f,x=a..b,continuous);   
	Int(f,x);  Int(f,x=a..b);  Int(f,x=a..b,continuous);
PARAMETERS:   f          
- an algebraic expression or a procedure, the integrand   x          
- a name   a,b        
- interval on which integral is taken   continuous 
- (optional) indication that f is continuous
SYNOPSIS:   
- The function int computes the indefinite or definite integral of f with  respect to the variable x. The name integrate is a synonym for int.
- Indefinite integration is performed if the second argument x is a name.  Note  that no constant of integration appears in the result.  Definite integration  is performed if the second argument is of the form x=a..b where a and b are  the end points of the interval of integration.  
- If Maple cannot find a closed form for the integral, the function call itself  is returned.  (The prettyprinter displays the int function using a stylized  integral sign.)  
- The capitalized function name Int is the inert int function, which simply  returns unevaluated.  The prettyprinter understands Int to be equivalent to  int for printing purposes.  
- In the case of a definite integral which returns unevaluated, numerical  integration may be invoked by applying evalf to the unevaluated integral.  To  invoke numerical integration without first invoking symbolic integration, use  the inert function Int as in: evalf( Int(f,x=a..b) ).  
- For symbolic definite integration, iscont is invoked to ensure the integrand  is continuous before taking limits at the endpoints.  This check can be disabled by calling int with the third option continuous (a global name).
• int(1/(x^3+1),x=0..infinity);
                                       1/2
                               2/9 Pi 3
• int(1/(x^3+a),x=0..1);
                                                                 1/2
                  1/3            2/3    1/3       1/2           3
      2 ln(- 1 - a   ) - ln(1 + a    - a   ) + 2 3    arctan(----------)
                                                                1/3
                                                             2 a    - 1
  1/6 ------------------------------------------------------------------
                                      2/3
                                     a
(que pensez vous de la validité de ce dernier résultat, doit-on l'accepter les yeux fermés?).
• int(sin(x)^4/x^4,x=0..infinity);
                                  1/3 Pi
Le mot continuous permet de passer outre à certains tests (et donc d'obtenir n'importe quoi)
• int(1/x^2,x=-1..1), int(1/x^2,x=-1..1,continuous); 
                               1
                               /
                              |    1
                              |  ---- dx, -2
                              |    2
                             /    x
                             -1

La fonction Int est inerte. Sa première utilité est de calculer numériquement des intégrales en conjonction avec evalf. En effet, si vous faites evalf(int(…)), Maple cherchera d'abord à calculer l'intégrale, puis en cherchera une approximation numérique; si vous faites evalf(Int(…)), la réponse sera beaucoup plus rapide puisque Maple utilisera directement une méthode d'intégration numérique pour trouver une valeur approchée de l'intégrale. Cette fonction inerte sert également, en conjonction avec le package student à faire des changements de variables ou des intégrations par parties dans des intégrales.
• evalf(Int(BesselJ(2,x),x=0..1));
                               .03962923860

• evalf(Int(exp(-x^2),x=0..infinity));
                               .8862269255
IV. Resoudre des équations
1. Solutions symboliques
Maple sait résoudre symboliquement un grand nombre d'équations ou de systèmes d'équations. La fonction essentielle à connaître est la fonction solve
?solve
FUNCTION: solve 
	- solve equations
CALLING SEQUENCE:   
	- solve(eqns, vars)  
PARAMETERS:   
	eqns : an equation or set of equations   
	vars (optional): an unknown or set of unknowns  
SYNOPSIS:   
- The most common application of solve is to solve a single equation, or to  solve a system of equations in some unknowns.  A solution to a single equation eqns solved for the unknown vars is returned as an expression.  To solve  a system of equations eqns for unknowns vars, the system is specified as a  set of equations and a set of unknowns.  The solution is returned as a set of  equations.
- Multiple solutions are returned as an expression sequence.  Wherever an equation is expected, if an expression expr is specified then the equation  expr = 0 is understood.  If vars is not specified, indets(eqns,name) is used  in place of vars.   
- When solve is unable to find any solutions, the expression NULL is returned.  This may mean that there are no solutions or that solve was unable to find  the solutions.   
- To assign the solutions to the variables, use the command assign.
• solve(x^3-3*x+2,x);
                                 -2, 1, 1

• solve(x^3-4*x+3,x);
                                  1/2                1/2
                 1, - 1/2 + 1/2 13   , - 1/2 - 1/2 13

• solve(tan(x)=1,x);
                                  1/4 Pi

• solve(sinh(x)=2,x);
                                arcsinh(2)
• solve({2*x+3*y-z=1,4*x+y-z=a,x-z=b},{x,y,z});
         {z = - 5/4 b + 3/8 a - 1/8, y = - 1/4 b - 1/8 a + 3/8,

             x = - 1/4 b + 3/8 a - 1/8}

Un certain nombre de points sont à remarquer sur les exemples précédents. D'une part quand il y a plusieurs solutions, celles ci sont retournées dans une séquence (c'est à dire une suite d'expressions séparées par des virgules). D'autre part  Maple peut résoudre des équations comportant des fonctions transcendantes mais avec des risques évidents liés à l'inversion de ces fonctions (Maple n'a donné qu'une seule solution de l'équation tan(x)=1). Enfin le résultat n'est pas fourni de la même façon suivant qu'il y a une ou plusieurs inconnues:
	- dans le cas d'une seule inconnue, le résultat est fourni sous sa forme brute
	- dans le cas de plusieurs inconnues, le résultat est fourni sous la formes d'égalités entre les variables et les solutions; dans ce cas, on peut transformer les égalités en affectations à l'aide de la fonction assign.
• solve({2*x+3*y=a,x+y=a^2},{x,y});
                                2             2
                      {y = - 2 a  + a, x = 3 a  - a}

• assign(");
• x+y;
                                     2
                                    a
Enfin, dans les systèmes d'équations algébriques, Maple fait systématiquement emploi d'extension de corps introduites par la fonction RootOf.
FUNCTION: RootOf - a representation for roots of equations
CALLING SEQUENCE:
   RootOf(expr)
   RootOf(expr, x)
PARAMETERS:
   expr - an algebraic expression or equation
   x    - a variable name  
SYNOPSIS:   
- The function RootOf is a place holder for representing all the roots of an  equation in one variable.
- If x is not specified, then expr must be either a univariate expression or an  expression in _Z.  In this case, the RootOf represents the roots of expr with  respect to its single variable or _Z, respectively.  If the first argument is  not an equation, then the equation expr = 0 is assumed.   
- The RootOf function checks the validity of its arguments, and solves it for  polynomials of degree one.  The RootOf is expressed in a single
-argument  canonical form, obtained by making the argument primitive and expressing the  RootOf in terms of the global variable _Z. 
- If expr is an irreducible polynomial over a field F then alpha = RootOf(expr)  represents an algebraic extension field K over F of degree degree(expr, x)  where elements of K are represented as polynomials in alpha.  Maple automatically generates RootOf's to express the solutions to polynomial  equations and systems of equations, eigenvalues, and rational function  integrals. 
• solve({x^2+y^2=1,4*x+3*y=1},{x,y});
                              2
             {y = RootOf(25 _Z  - 6 _Z - 15),

                                       2
                 x = - 3/4 RootOf(25 _Z  - 6 _Z - 15) + 1/4}

Une fonction complémentaire de la fonction RootOf est la fonction allvalues qui retourne des résultats numériques (exacts ou approchés) à partir d'expressions contenant des RootOf.
FUNCTION: allvalues - evaluate all possible values of expressions involving
                      RootOf's
CALLING SEQUENCE:
   allvalues(expr)
   allvalues(expr, 'd')
PARAMETERS:
   expr - any expression or table, list, or set of expressions
   'd'  - the character 'd'
SYNOPSIS:   
- The most common application of allvalues is to evaluate expressions returned  from solve involving RootOf's.
- Typically, a RootOf represents more than one value. Thus, expressions involving RootOf's will generally evaluate to more than one value or expression. The procedure allvalues will return all such values (or expressions) generated by the combinations of different values of the RootOf's, in an expresion sequence.
- The procedure allvalues will attempt to evaluate expressions exactly using  solve.  The roots of nth degree polynomial equations where n <= 4 can be  obtained exactly. Where roots cannot be obtained exactly, allvalues will use  fsolve to obtain a numerical solution.  In this case, no symbolic constants  can be used in the particular RootOf argument.
- The optional second parameter 'd' is used to specify that RootOf's of the  same equation represent the same value and they should not be evaluated  independently of one another.
- Nested RootOf's are supported by allvalues.
• solve({x^2+y^2=1,4*x+3*y=1},{x,y});
                                     2
              {x = - 3/4 RootOf(25 _Z  - 6 _Z - 15) + 1/4,

                                  2
                  y = RootOf(25 _Z  - 6 _Z - 15)}
• allvalues(");
                              1/2                   1/2
            {y = 3/25 + 8/25 6   , x = 4/25 - 6/25 6   },

                                  1/2                   1/2
                {y = 3/25 - 8/25 6   , x = 4/25 - 6/25 6   },

                                  1/2                   1/2
                {y = 3/25 + 8/25 6   , x = 4/25 + 6/25 6   },

                                  1/2                   1/2
                {y = 3/25 - 8/25 6   , x = 4/25 + 6/25 6   }
Le résultat obtenu n'est pas raisonnable (quatre points d'intersection pour un cercle et une droite). C'est parce que Maple a considéré que les deux RootOf étaient indépendants, alors qu'ils représentent en fait la même valeur. Le deuxième paramètre optionnel 'd' va résoudre ce problème et indiquer à Maple que les deux représentent la même valeur:
• allvalues("",'d');
                               1/2                   1/2
             {y = 3/25 + 8/25 6   , x = 4/25 - 6/25 6   },

                                   1/2                   1/2
                 {y = 3/25 - 8/25 6   , x = 4/25 + 6/25 6   }

Bien entendu n'attendez pas de miracle de la fonction solve. Seules les solutions qui sont calculables de manière algorithmique sont trouvées par Maple. Des  solutions "évidentes" peuvent ainsi ne pas être trouvées.
• solve(sin(x)=3*x/Pi,x);
                                    0
alors que "bien entendu" π/6 est aussi solution.
2. Solutions numériques
Lorsque des solutions formelles ne peuvents pas être trouvées, Maple peut tenter de déterminer des solutions numériques approchées. La fonction à utiliser dans ce cas est la fonction fsolve.

?fsolve
FUNCTION: fsolve - solve using floating-point arithmetic
CALLING SEQUENCE:
   fsolve( <eqns>, <vars>, <options> );
PARAMETERS:
   <eqns>    - an equation or set of equations
   <vars>    - (optional) an unknown or set of unknowns
   <options> - (optional) parameters controlling solutions
SYNOPSIS:   
- The conventions for passing equations and variables, and returning the  answers, are the same for fsolve as for solve.
- For a general equation, fsolve attempts to compute a single real root.  However for polynomials it will compute all real (non-complex) roots, although  exceptionally ill-conditioned polynomials may cause fsolve to miss some  roots.   
- To compute all roots of a polynomial over the field of complex numbers, use  the complex option.
- The options available are:
	- complex
		-Find one root (or all roots, for polynomials) over the complex  floating-point numbers.
	- fulldigits
		-This option prevents fsolve from decreasing Digits for intermediate calculations at high settings of Digits.  With this option fsolve may  escape ill-conditioning problems, but the routine slows down.
	- maxsols=n
		-Find only the n least roots.  This option is only meaningful for  polynomials, where more than one root is computed.
	- <interval>
		- a..b or x = a..b or {x=a..b, y=c..d, ...}.  Search  for roots in the given interval only.  The ranges are open intervals, i.e.  the endpoints are not included in the range. Note that an fsolve computation may fail to find a root even though one  exists, in which case specifying appropriate range information may result in  a successful computation.
• fsolve({x^2+y^2=1,4*x+3*y=1},{x,y});
                   {x = -.4278775383, y = .9038367177}
•  f := sin(x+y) - exp(x)*y = 0:
   g := x^2 - y = 2:
   fsolve({f,g},{x,y},{x=-1..1,y=-2..0});
                      {y = -1.552838698, x = -.6687012050}
• fsolve(x^5-x+2,x,complex);
    	   -1.267168305,  - .2609638804 + 1.177226153 I,

         - .2609638804 - 1.177226153 I, .8945480327 - .5341485462 I,

        .8945480327 + .5341485462 I

3. Equations différentielles
Maple est capable de résoudre formellement un certain nombre d'équations différentielles classiques d'ordre 1 ou 2 à l'aide de la fonction dsolve
?dsolve
FUNCTION: dsolve - solve ordinary differential equations
CALLING SEQUENCE:
   dsolve(deqns, vars)
   dsolve(deqns, vars, option)
PARAMETERS:
   deqns  - ordinary differential equation in vars, or set of equations and/or
            initial conditions
   vars   - variable or set of variables to be solved for
   option - one of: explicit, laplace, series, numeric
SYNOPSIS:   
- dsolve is able to find closed-form solutions to many differential equations.  The solution is returned either as an equation in y(x) and x (or whatever  variables were specified) or in parametric form [x=f(_T),y(x)=g(_T)] where _T  is the parameter.  Any arbitrary constants are represented as _C1, _C2, ...,  _Cn.   
- The explicit option forces the solution to be returned explicitly in terms of  the dependent variable, if possible.
- The laplace option causes dsolve to solve using Laplace transforms.  One  advantage to using this option is that differential equations may contain the  Dirac or Heaviside functions. These functions are not recognized by the rest  of dsolve.
- The series option causes dsolve to solve using a series method.  The order of  the solution can be specified by setting Order.
- The initial conditions must be specified at x=0 if the laplace or series  option is being used.  Otherwise, the conditions may be initial or boundary  conditions specified at any points.  Derivatives in conditions are specified  by applying D to the function name, e.g. the second derivative of y at 0 is  given as D(D(y))(0) or (D@@2)(y)(0). 
 • dsolve(diff(y(x),x$2)+y(x)=x^2*cos(x),y(x));
                 2                      3
     y(x) = 1/4 x  cos(x) + 1/6 sin(x) x  - 1/4 cos(x) - 1/4 sin(x) x

          + _C1 sin(x) + _C2 cos(x)
• dsolve({diff(x(t),t)=x(t)+y(t)+cos(t),diff(y(t),t)=-x(t)+y(t)+sin(t)},{x(t),y(t)});
                           2                          3
  {x(t) = 1/5 sin(t) cos(t)  - 2/5 cos(t) + 2/5 cos(t)  + 2/5 sin(t)

        - 1/10 cos(t) sin(2 t) - 1/5 cos(t) cos(2 t) + _C1 exp(t) sin(t)

        + _C2 exp(t) cos(t),

      y(t) = 1/10 sin(t) sin(2 t) + 1/5 sin(t) cos(2 t) - 3/5 cos(t)

                       3                    2
           + 1/5 cos(t)  - 2/5 sin(t) cos(t)  - _C2 exp(t) sin(t)

           + _C1 exp(t) cos(t)                                      }
• dsolve({diff(y(t),t$2)+sin(y(t))=0},y(t));
                  y(t)
                   /
                  |               2
             t =  |    ---------------------- dy2 - _C2,
                  |                       1/2
                 /     (8 cos(y2) + 4 _C1)
                 0

                      y(t)
                       /
                      |                 2
                 t =  |    - ---------------------- dy1 - _C2
                      |                         1/2
                     /       (8 cos(y1) + 4 _C1)
                     0

La fonction dsolve utilisée avec l'option numeric renvoie (si les conditions initiales sont précisées) une fonction qui fournira en chaque point une évaluation numérique de la solution
?dsolve[numeric]
- If the numeric option is specified then the differential equations must be  specified with initial-value conditions.  In this case, a procedure is  returned as the result of the dsolve function.  If this procedure is assigned  to the name F, for example, then invoking F(t) for a numeric value of the  independent variable t invokes a numerical method to solve the differential  equation (or system of equations), yielding the numerical solution at t.  The  numerical solution is returned as an expression sequence consisting of the  value of t, followed by the values of the dependent variables at the point t.
•f:=dsolve({diff(y(t),t$2)+sin(y(t))=0,y(0)=Pi/2,D(y)(0)=0},y(t),numeric);
f := proc(t) `dsolve/numeric/result2`(t,2359752,[2]) end
• f(1);
                        1.0000000000, 1.074911685
4. Suites récurrentes
L'usage de la fonction rsolve pour résoudre les récurrences est tout à fait similaire à celui de la fonction dsolve pour les équations différentielles.
?rsolve
FUNCTION: rsolve - recurrence equation solver
CALLING SEQUENCE:
   rsolve(eqns, fcn)
   rsolve(eqns, fcn, ztrans)
PARAMETERS:
   eqns   - a single equation or a set of equations
   fcn    - function to solve for
   ztrans - (optional) solve using Z-transforms
SYNOPSIS:   
- The function rsolve attempts to solve the recurrence relation specified in  eqns, returning an expression for the general term of the function.
- The first argument should be a single recurrence relation or a set of  recurrence relations and boundary conditions.  Any expressions in eqns which  are not equations will be understood to be equal to zero.
- The second argument fcn indicates what rsolve should solve for.  This expression should be either an unevaluated function call (or calls) of the form  f(n), indicating that rsolve should return a general solution for f(n), or  simply a function f, in which case the arguments to f are deduced from the  variables that occur in the calls to f in eqns.
- First order linear difference equations are handled; in addition, certain  classes of first order nonlinear difference equations are recognized.
- The ztrans option causes rsolve to solve the difference equations using  Z-Transforms.
• rsolve({x(n+1)=2*x(n)-x(n-1)},x(n));
                         x(0) + (- x(0) + x(1)) n
• rsolve(x(n+1)=2*x(n)+n,x(n));
                                     n    n
                          - n - 1 + 2  + 2  x(0)
• rsolve({x(n+1)=n*x(n)-1},x(n));
                      // n - 1                  \    \
                      || -----                  |    |
                      ||  \              1      |    |
     {x(n) = GAMMA(n) ||   )    - --------------| - 1|, x(0) = x(0)}
                      ||  /       GAMMA(_n2 + 1)|    |
                      || -----                  |    |
                      \\_n2 = 1                 /    /

V.Exercices
Exercice 1
On sait que isu(k=1;n; k^p)  est de la forme Pp(n), où Pp est un polynôme de degré p+1. Construire une liste des Pp sous forme factorisée pour p allant de 0 à 10. On trouvera par exemple  P0(n)=n, P1(n)=n(n+1)/2. Mots Maple à utiliser : map, list, sum, factor.
Exercice 2
Résoudre l'équation différentielle  yy"-y'2= 1 de manière explicite (attention: la première réponse fournie par Maple n'est pas forcément la bonne).
Exercice 3
Etudier l'évolution d'un oscillateur double dont le schéma est le suivant les deux masses étant relachées sans vitesse initale avec des décalages initiaux x1,0 et x2,0 par rapport à leurs positions de repos (axe orienté vers la droite).

Exercice  4

Etudier l'évolution du double pendule pesant dans le champ de pesanteur, les deux masses étant relachées sans vitesse initiale avec des angles initiaux q1,0 et q2,0.

Exercice 5
La formule de Taylor Lagrange à l'ordre 2 garantit que
f(x)=f(0)+x f'(0)+x^2 f''(xq(x))/2
pour un certain q(x)Œ[0,1]. Trouver un développement limité de la fonction q en 0 à l'ordre 2.
Mots Maple à utiliser: series, solve.
Exercice 6
Trouver un développement asymptotique de la suite définie par xn+1 = sin(xn). Mots Maple à utiliser: rsolve, asympt.
Exercice 7
Evaluer la somme de k=1 à 10^6 de 1/x log(x). Utiliser la fonction eulermac  que l'on chargera par un rreadlib(eulermac).
Exercice 8
Chercher les valeurs de a  pour lesquelles le polynôme X5 +5a X3+a2X+1 a 5 racines réelles par les différentes méthodes suivantes
	a) poser T=X/√|a| 
	b) introduire la suite de polynômes P0(X), P1(X)=P'(X)  et Pi+2(X)=Pi(X) mod Pi+1(X) et n(x) le nombre de changement de signes dans la suite (P0(x),P1(x),P2(x),…); alors le nombre de racines de P est égal à n(+∞)-n(-∞)   (méthode de Sturm)
	c) introduire la forme quadratique isu(i,j;;si+j-2 xixj) = isu(i;;(x1+aix2+as(2;i) x3+…)2)   où les ai sont les racines complexes de P et sk = as(k;1) + as(k;2) + …  ; tester si cette forme quadratique est définie positive.