Correction des colles Maple n°1&2

Les solutions proposées sont loin d'être les seules. Vous avez vu par exemple sept méthodes pour calculer 7!, et il en existe d'autres. Et puis, les solutions proposées ne sont pas forcément les meilleures : n'hésitez pas à faire part de vos idées.
Exercice 1
La partie entière d'un réel  x est le plus grand entier inférieur à x
> E:=proc(x)
> local n;
> n:=0;
> while n<x do n:=n+1 od: n-1;
> end:
> 
> E(32.32),E(1.7),E(101.23);

                              32, 1, 101

Exercice 2
La valeur absolue d'un réel x vaut x si x est positif, -x sinon
> ab:=proc(x)
> if x>=0 then x else -x fi;
> end:
> ab(32),ab(-32);

                                32, 32

Exercice 3
La moyenne, c'est la somme des opérandes divisée par le nombre d'opérandes
> moy:=proc(l)
> local s,k;
> s:=0;
> for k from 1 to nops(l) do s:=s+l[k] od: s/nops(l);
> end:
> moy([12,15,14,12,12,18,20]);

                                103/7

Pour remédier à ce probléme, on peut utiliser evalf qui donne par défaut un résultat arrondi à 10 chiffres significatifs
> moy:=proc(l)
> local s,k;
> s:=0;
> for k from 1 to nops(l) do s:=s+l[k] od:evalf(s/nops(l));
> end:
> moy([12,15,14,12,12,18,20]);


                             14.71428571

Exercice 4
1)

> bn:=proc(n)
> local a,b,k;
> a:=1+1/n;
> b:=1;
> for k to n do b:=a**b od:
> b
> end:
> 
> bn(5);

                      /     /            1/5  4/5 \\
                      |     |     (6/25 6    5   )||
                      |     \(6/5)                /|
                      \(6/5)                       /
                 (6/5)

> simplify(");

                        %1  (-%1)      %1  (-%1)
                      (6   5     )  (-6   5     )
                     6             5

                           1/5  4/5            1/5  4/5
                    (6/25 6    5   )  (- 6/25 6    5   )
             %1 := 6                 5

Bof...donc, comme d'habitude, on utilise evalf.
> bn:=proc(n)
> local a,b,k;
> a:=1+1/n;
> b:=1;
> for k to n do b:=a**b od:
> evalf(b)
> end:
> 
2) " ...le plus petit entier tel que..." nous fait penser à une boucle while
> m:=1:
> while bn(m)>1.001 do m:=m+1 od:
> m;

                                 1002

Votre premier calcul où maple semble ramer autant que vous.

Exercice 5
1) La ruse est d'introduire deux variables en plus de l'indice : t pour le terme et s pour la somme
> S:=proc(n)
> local s,t,k:
> s:=1: t:=1:
> for k to n do t:=t/k: s:=s+t # il faut bien sûr définir t avant s #
>                              # s utilise donc le nouveau t #
> od:
> s
> end:
> S(32);

                 28610550901763172837819811744646057
                 -----------------------------------
                 10525233477347741206688720486400000

> evalf(");

                             2.718281828

> "-exp(1);# par curiosité #

                         2.718281828 - exp(1)

> evalf(");

                                  0

fichtre...aurait-on trouvé une valeur décimale  exacte de e ?!!?
> evalf(S(32)-exp(1),100);

-.118650052509939203560449589182655889193883710482409450552898929

      -36
    10

Ouf....Nous pouvons passer au 2) avec bien sûr une boucle while comme dans l'exercice précédent.
> seuil:=proc(s)
> local n:
> n:=0:
> while evalf(exp(1)-S(n),1000)>10^(-s) do n:=n+1 od: #pourquoi n'a-t-on pas#                                                                                                                                   # besoin de valeur absolue ? #
> n
> end:
> seuil(36);

                                  32

Exercice 6
Rien de très difficile mathématiquement parlant, mais cela nous permet de découvrir la fonction elif, contraction de else if qui permet d'accéder à une sous-boucle if.
> sol:=proc(a,b,c)
> local d,x1,x2:
> d:=b**2-4*a*c:
> if d>0 then  x1:=(-b-sqrt(d))/(2*a): x2:=(-b+sqrt(d))/(2*a):
> elif d=0 then  x1:=-b/(2*a): x2:=x1 :
> else  x1:=(-b-I*sqrt(-d))/(2*a): x2:=(-b+I*sqrt(-d))/(2*a) :
> fi;
> if d<>0 then print(`Les solutions sont `.x1. `et ` .x2):
> else print (`La solution est `.x1):
> fi;
> end:
> sol(1,-3,2);

                       Les solutions sont 1et 2

> sol(1,2,1);

                          La solution est -1

> sol(1,2,3);

                                      1/2               1/2
         Les solutions sont .(-1 - I 2   ).et .(-1 + I 2   )

Il y a bien sûr plus court
> solv:=proc(a,b,c)
> solve(a*x**2+b*x+c=0,x);
> end:
> solv(1,2,3);

                               1/2          1/2
                       -1 + I 2   , -1 - I 2

mais c'est moins constructif.

Exercice 7
Voici un exercice plus abstrait, mais qui permet de travailler sur les listes et imbrique une boucle if dans une boucle for. Le principe est de passer en revue les couples de termes successifs de la suite. Si au moins l'un d'entre eux n'est pas "dans le bon ordre", alors la suite des éléments de la liste n'est pas croissante.
> test:=proc(l)
> local i,T:
> T:= croissante: #la suite est a priori croissante#
> for i from 1 to nops(l)-1 do
>         if l[i]>l[i+1] then T:= `pas croissante` fi: #on peut avoir if sans                                                                                                                                                                                                    else#
> od:
> T
> end:
> test([1,2,3,4,5,6]);

                              croissante

> test([2,3,4,1]);

                            pas croissante

Exercice 8
Pour mémoire, p parmi n = p parmi n-1 + p-1 parmi n-1. Voici un autre exemple simple de procédure récursive. N'oubliez pas que si p>n, alors p parmi n vaut 0.
> c:=proc(n,p)
> if p=0 then 1
> elif p>n then 0
> else c(n-1,p)+c(n-1,p-1)
> fi
> end:
> c(32,3);
> c(3,32);

                                 4960




                                  0

> branche:=proc(f)
>  local a,b:
>  a:=limit(f(x)/x,x=infinity):
>  if type(a,`..`)=true then lprint(`pas d'asymptote`);
>  elif type(a,infinity)=true then lprint(`pas d'asymptote`);
>  elif a=0 then lprint(`direction asymptotique horizontale`);
>  else b:=limit(f(x)-a*x,x=infinity):
>  if type(b,`..`)=true then printf(`direction asymptotique d'equation y=%f x`,a);
>  elif type(b,infinity)=true then printf(`branche parabolique dans la direction y=%f x`,a);
>  else printf(`asymptote d'equation y=%f x+%f`,a,b);
>  fi;
>  fi;
>  end:
> 
> branche(x->2*x+cos(x));
direction asymptotique d'equation y=2 x