Lycée E.Mimard, Saint-Etienne

M+ Cours d’Informatique Sup-Spé

Maple : Initiation et Exemples

Une "lemniscate de Bernouilli" (symbole de l’infini) et deux belles "Cardioïdes"(la petite est dite "développée" de la grande). En Maple.

1

00

-0,5

20,5

1

0,5

-1

00 1 1,5

 

y 0

x

0 2

à Clément-Marie, à mes chers parents et famille,aux élèves et à tous ceux (celles et ceux) qui m’ont aidé ici.M. Henri Chambon, 19 rue Saint-Joseph, Saint-Etienne.

année 2012

1

Introduction avec Le nombre π

Le nombre Pi est sûrement le nombre le plus important des mathématiques, mis à part lenombre 1. On le retrouve dans tout ce qui concerne les cercles, sphères, ellipses et ... mouve-ments périodiques associés aux fonctions trigonométriques. Euclide, Archimède, Appolonius,Viète... se sont attaqués à son développement décimal. Ils cherchaient une éventuelle pério-dicité... préoccupation abandonnée en 1768 lorsque Lambert montra son irrationalité.

Dessins : 1er en Maple 2ème : Médiatrices 3ème : Lien longueur-aire

> evalf(Pi,101); # Avec Maple: 101 chiffres pour 100 décimales!

3.141592653589793238462643383279502884197169399375105820974944592307816406286\

2089986280348253421170680

Impressionnant !

Un petit texte peut aider à savoir quelques décimales :

Que j’aime à faire connaître un nombre utile aux sages ! # Jadis pour retenir:

3 1 4 1 5 9 2 6 5 3 5 Que=3 j=1 aime=4...

Immortel Archimède, artiste ingénieur, (les décimales)

8 9 7 9

Qui de ton jugement peut priser la valeur ?

3 2 3 8 4 6 2 6

Pour moi ton problème eut de pareils avantages. # ( Et encore:

4 3 3 8 3 2 7 9 Tirez circonférence au diamètre etcetera

5 0 2 8 8 )

2

Liste d’opérateurs, fonctions, mots-clés. Autre classement en Note 1

Opérations : +, -,*, /, ^, $, @ Concaténation: ||

Opérateurs booléens (et constantes) : =, <, >, <>, <=, >=, evalb, or, and, not,

true, false

Réels/Complexes : evalf, Digits, Pi, I, abs, max, min, floor, evalc, conjugate,

Re, Im, argument

Manipulations d’expressions : eval, lhs, rhs, % , convert, combine, map, map2,

nops, op, algsubs, subs, remove, select

Types de données : float, integer, numeric, polynom, {}, [], seq, array, type,

whattype

Arithmétique : iquo, irem, mod, ifactor

Algèbre : factor, expand, simplify, normal, coeff, coeffs, collect, sort,

binomial, rem, quo, denom, numer, parfrac, product, sum, mul, add

Analyse : infinity, limit, asympt, series, taylor, diff, D, int

Hypothèses : assume, about, is, additionally

Résolution d’équations : solve, fsolve, allvalues, RootOf, dsolve, numeric

Fonctions mathématiques : sqrt, exp, ln, log, cos, sin, tan, arccos, arcsin,

arctan, cosh, sinh, tanh, arccosh, arcsinh, arctanh

Graphiques : plot, pointplot, spacecurve, plot3d, bibliothèque plots: display

Algèbre linéaire : bibliothèque linalg: matrix, vector, evalm, transpose, diag,

band, augment, concat, matadd, scalarmul, &*, multiply, inverse, det,

rank, kernel, linsolve, gausselim, charpoly, eigenvals, eigenvects, norm

Géométrie : dotprod, crossprod

Programmation : restart, proc, local, RETURN, remember, :=, ->, unapply, print,

do, for, while, if

1 @ (composition) Exemple (D@@k) <= <> (différent) Concaténation : ||

abs affectation ( :=) allops animate arccos arccosh ... args args[k] assign assume asympt

binomial boolean break

coeff collect combine (linéariser) complex concat (et ,) convert coords=polar [...] (pour Liste)

D denom det diag Digits Diff diff display do (od) dsolve Désaffecter n n :=’n’ ;

elif (if...then...elif...then...else...fi) expand eval evalb evalc evalf evalm

factor floor (partie entière) for... from... to...do... od (boucle) fsolve

I if ifactor Im implicitplot infinity Int int iquo irem ithprime isprime (true, false)

Limit limit linsolve (avec le package with(linalg)) lhs(left hand side cf. rhs) Liste [...] lprint

map max member (à une liste) min

nargs nops normal numer (numérateur) NULL (séquence vide, pour initialiser)

odeplot op (nops...)

parfrac Pi piecewise plot plots (+display) polar (forme trigonométrique) polygonplot polynom

pourcentage (dernière réponse) print product Produit matriciel, symbole Et * touches 1 *

quo (quotient de division polynômiale, cf. iquo)

Re (partie réelle) rem remember (option remember, gain de temps) RETURN restart RootOf rsolve

scaling=constrained repère o.n. select seq series set simplify solve sort subs subsop sum

taylor thickness tickmarks title

unapply (transforme une expression en fonction) unassign (désaffecter sans restart)

whattype (string=chaine de caractères) while with(...) Exemples : with(linalg), with(plots) while...do

ALG. LIN. with(linalg) :

charpoly colspace crossprod diag dotprod eigenvals eigenvects identity inverse kernel linsolve

matrix Matrix minpoly norm rank sparse (matrice nulle) trace transpose vandermonde vector

3

Table des matières.

1. Premières commandes fondamentales p5

2. Nombres réels. Et divers essais avec : seq p7

3. Les boucles : for from... to... do... od p9

4. Suites et Listes. Utilité ? p11

5. Les équations avec solve. Exercices p13

6. Les fonctions. Les courbes p15

7. Les polynômes. Les fractions rationnelles p17

8. Calculs divers (sum, product...) Limites p19

9. Comment dériver (d’abord déclarer) une fonction ? p21

10. Dériver plusieurs fois. Equations différentielles p23

11. Pour composer les fonctions ? Suites un+1 = f(un) p25

12. Intégrer une fonction. Primitives p27

13. Développements limités. Développements généralisés p29

14. Matrices et déterminants p31

15. Cas des espaces vectoriels euclidiens p35

16. Exercices corrigés. Procédures p38

4y

x

4

20

-4

-2

-4 -2 0

2

4

1 Premières commandes fondamentales

1.1 Les entiers

1. Il est souvent bon de donner un nom aux quantités. On met := pour l’affectation.

2. Pour valider et afficher une instruction, on met ; Pour valider seulement, on met :

> 10 ! ; a:= 10!; b:=15!: c:=ifactor(b);

3628800

a := 3628800 # b non affiché mais affecté

car factorisé... ci-dessous

11 6 3 2

c := (2) (3) (5) (7) (11) (13) # c vaut b_factorisé !

3. ifactor pour factoriser les entiers i = integer et factor pour factoriser les polynômes.

> P:=x^2-1; factor(P); Q:=x^2+1; R:=factor(Q, complex);

2

P := x - 1

(x - 1) (x + 1)

2

Q := x + 1

R := (x + 1.000000000 I) (x - 1. I)

1.2 Des manipulations de base au clavier

1. Repérer et utiliser les touches Début տ et Fin de ligne

2. Bien savoir utiliser le Copier Control C et Coller Control V

3. Avec Maple, on peut Créer des lignes avec la commande à voir (à la souris) [>

4. o/o désigne le dernier résultat, même si c’est une erreur ! Ainsi :

> restart; R:=x^2-2*x+1; S:=factor(%); T:=ifactor(R);

2

R := x - 2 x + 1

2

S := (x - 1)

Error, (in ifactor) invalid arguments # Car il fallait factor et non ifactor

5

1.3 L’aide en ligne essentielle en Maple

1. Reprenons l’instruction factor. On met le curseur dessus ou on la surligne (ou encore ?factor).

On va dans Help sur factor et on va de suite aux exemples en rouge

C’est ici qu’on lit assez vite dans les exemples, celui qui suit :

> factor(x^3+5,complex);

(x + 1.709975947) (x + (-0.8549879733 + 1.480882610 I)) (x

+ (-0.8549879733 - 1.480882610 I))

• Voilà comment on a trouvé cette option complex : dans l’aide

• La lettre I est réservée au complexe usuel.

2. Comment régler le nombre de décimales ? Avec Digits avec un D Majuscule. digits ne donne rien.

> restart; Digits:=3; factor(x^3+5,complex);

Digits := 3

(x + 1.71) (x + (-0.855 + 1.48 I)) (x + (-0.855 - 1.48 I))

> restart: Digits:= 8: factor(x^3+5,complex); # Digits := 8 non affiché !

(x + 1.7099759) (x + (-0.85498797 + 1.4808826 I)) (x

+ (-0.85498797 - 1.4808826 I)) # 8 chiffres

> digits:=5; factor(x^3+5,complex);

digits := 5 # rien de modifié car il

fallait Digits

(x + 1.7099759) (x + (-0.85498797 + 1.4808826 I)) (x non pas digits

+ (-0.85498797 - 1.4808826 I))

3. Deux exercices avec la commande donnée seq (sequence, suite)

• Aller dans l’aide. Donner la suite des 15 carrés des entiers (1, 4, 9, 16, ...)

• On donne, de plus, la commande ithprime (A ne pas confondre avec isprime)

Donner alors la suite des 15 premiers nombres premiers (2, 3, 5, 7, ...)

La 1ère réponse est dans l’aide; La seconde analogue:

> s:= seq( i^2, i=1..15 ); s[3]; # A bien noter s[3]

s:= 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225

9

> t:= seq( ithprime(i), i=1..15 );

t:= 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47

6

2 Nombres réels. Et divers essais avec seq

2.1 Les nombres réels

1. Le nombre π = 3, 14... se note avec Maple Pi (avec une majuscule)

> evalf(Pi, 4); # 4 chiffres, donc seulement 3 décimales !

3.142 # réel, type float

Pour les réels evalf pour les entiers eval pour les complexes evalc pour les matrices evalm

2. whattype ( sur des exemples) Attention : , est la juxtaposition

> whattype(3.14); whattype(3,14); whattype(Pi) ;

float # retenir: à virgule flottante = un réel !

exprseq # Le premier est une suite d’expressions

# car attention : , est la juxtaposition !

symbol

3. Re-parlons des majuscules. Lettres protégées :Pi est avec une majuscule, sinon c’est la lettre grecque comme alpha,..., piI est une lettre réservée pour le complexe usuel. Ainsi I :=4 provoque une erreur.D est aussi une lettre réservée pour la dérivation. (On le verra plus tard avc diff)Digits est encore avec une majuscule, sinon inactif.

> Digits := 6: evalf(Pi); # Digits := 6 non affiché car on finit par :

3.14159 # 6 chiffres donc 5 décimales. Par défaut 10 chiffres

> restart: evalf(Pi); evalf(pi, 4);

3.141592654

pi # Rien car pi n’est pas le nombre connu

4. Le nombre e et l’affectation := (rappel)

> restart: exp(1); evalf(exp(1));

exp(1)

2.718281828 # exp(1) est une bonne commande !

> e=exp(1); evalf(e); e:=exp(1); evalf(e);

e = exp(1)

e # Car = n’est pas une affectation,

e := exp(1)

2.718281828 # ... mais := en est une !

7

2.2 Pour désaffecter une lettre :

1. Attention restart ré-initialise tout !

2. Si on ne veut désaffecter qu’une lettre : (2 façons)

> a:=10; a; unassign(’a’): a; # 1ère façon

a := 10

10

a

> a:=20; a; a:=’a’; a; # 2ème façon

a := 20

20

a := a

a

2.3 Avec seq ... dont une ligne du triangle de Pascal avec binomial

> seq( ithprime(i), i=1..100 ); # Les 15 premiers déjà vus

2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73

79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163

167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,

257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,

353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,

449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541

> seq(‘ Bonjour ! ‘, i=1..5); # Symbole penché de la touche du chiffre 7

Bonjour ! , Bonjour ! , Bonjour ! , Bonjour ! , Bonjour !

> binomial(6,2);

15

> seq(binomial(6,i), i=0..6 );

1, 6, 15, 20, 15, 6, 1 # Bientôt, le Triangle en entier.

> seq(binomial(6,i)^2, i=0..6 );

1, 36, 225, 400, 225, 36, 1

8

3 Les boucles : for ... from... to...do...od

3.1 On a en vue de faire automatiquement plusieurs lignes.

> for k from 1 to 5 do ithprime(k) od; # A retenir : le "od" final

2 # Ne surtout pas oublier od à la fin

3

5

7

11 # Bien sûr, on sait le faire en ligne...

3.2 Voyons les polynômes de Tchebychev de 1ère espèce :

T4 s’obtient, par exemple, en exprimant cos(4.t) en fonction de cos(t)

> expand(cos(4*t)); # Piège: Bien mettre 4*t signe multiplié

4 2

8 cos(t) - 8 cos(t) + 1

> subs(cos(t)=X , %); # subs pour substituer % désigne la dernière réponse

4 2

8 X - 8 X + 1 # On a appellé X=cos(t) l’indéterminée

> restart: for k from 0 to 5 do T[k](X)=subs(cos(t)=X, expand(cos(k*t))) od;

T[0](X) = 1 # La présentation de Maple est meilleure

T[1](X) = X # En effet dans T[k], [k] est en indice.

2

T[2](X) = 2 X - 1

3

T[3](X) = 4 X - 3 X

4 2

T[4](X) = 8 X - 8 X + 1

5 3

T[5](X) = 16 X - 20 X + 5 X

Remarque La commande suivante est possible (meilleure ? car les [...] sont une liste pour Maple

-voir après- et risque d’erreur par intéférences...)

> restart: for k from 0 to 5 do T||k(X)=subs(cos(t)=X, expand(cos(k*t))) od;

—–

9

3.3 Exercice : Polynômes de Tchebychev de 2ème espèce

Faire de même : sin(k.t)/sin(t) comme polynôme en cos(t) en partant de k = 1.

A noter une autre commande souvent utile simplify

3.4 Le Triangle de Pascal (Blaise Pascal)

On avait déjà fait une ligne ; ajoutons ce qu’il manque...

> seq(binomial(6,i), i=0..6 );

1, 6, 15, 20, 15, 6, 1

> for n from 0 to 6 do seq(binomial(n,k), k=0..n ) od;

1

1, 1

1, 2, 1

1, 3, 3, 1

1, 4, 6, 4, 1

1, 5, 10, 10, 5, 1

1, 6, 15, 20, 15, 6, 1

3.5 Exercice : Faire le triangle de Pascal des restes, dans la division par 2, descoefficients binômiaux (on obtient une "fractale")

Indication : iquo, irem dans l’aide. Ici, utiliser : irem(binomial (n,k) , 2)

1

1, 1

1, 0, 1

1, 1, 1, 1

1, 0, 0, 0, 1

1, 1, 0, 0, 1, 1

1, 0, 1, 0, 1, 0, 1

1, 1, 1, 1, 1, 1, 1, 1

1, 0, 0, 0, 0, 0, 0, 0, 1

10

4 Suites et listes. Utilité ?

4.1 Passer de suite à liste ? Exemple :

> S:=seq( ithprime(k),k=1..10);

S := 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

> L:= [S] ; whattype(S) ; whattype(L) ;

L := [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

exprseq # suite (d’expressions)

list

Pour passer de suite à liste, on met des crochets. Les [crochets] pour Maple = LISTE

4.2 Passer de liste à suite ? On reprend L précédente. On utilise op

> A:= op(L); whattype(A) ;

A := 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

exprseq # suite (d’expressions)

Bien voir aussi les commandes op(2, L) ops nops ... dans l’aide

4.3 Utilité d’une Liste ? La commande op

Si on veut le 5ème terme de S (qui est 11), que faire ?

> op(5,S) ; op(5,L); # op(5,S) ne va pas aller; op(5,L) convient (avec Liste):

Error, wrong number (or type) of parameters in function op # Comme prévu

11 # La réponse voulue: avec une Liste !

Remarque : A noter que pour avoir le 5ème terme d’une liste ou d’une suite, on peut aussi faire :

> S[5]; L[5];

11

11

4.4 La commande map qui utilise également une Liste

1. Reprenons l’exemple :

> S:=seq( ithprime(k),k=1..10 );

S := 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

> L:= [S] ; A:= op(L);

11

L := [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

A := 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

2. Imaginons qu’on veuille les inverses. 1ère façon : On peut faire ce qui suit

> T := seq(1/ithprime(k),k=1..10);

1 1 1 1 1 1 1 1 1 1

T := -, -, -, -, --, --, --, --, --, --

2 3 5 7 11 13 17 19 23 29

3. 2ème façon : On peut aussi appliquer avec map f à chaque élément ; mais avoir une liste

1

> f := x-> ---- ;

x

> map(f,S); map(f,L);

1

- # Que le premier; on les voulait tous !

2

[1 1 1 1 1 1 1 1 1 1 ]

[-, -, -, -, --, --, --, --, --, --] # C’est bon !

[2 3 5 7 11 13 17 19 23 29] (Maple présente mieux...)

4.5 Voir encore map dans l’aide ... et ce qui suit :

• Déjà, on peut aussi vérifier que map ne change pas le type de l’objet avec whattype

> map( x -> x^2 , x + y); # les espaces: pour mieux voir.

2 2

x + y

> whattype(%); whattype(x+y) ;

+

+ # Chaque quantité est de même type.

• Voici encore, avec une fonction arbitraire, un "triangle..." en utilisant map

> f:=x-> exp(x)+x^2-x^5: for n from 0 to 3 do seq(map(f,binomial(n,k)),k=0..n) od;

exp(1) # Mais ici map peu utile !

exp(1), exp(1)

exp(1), exp(2) - 28, exp(1)

exp(1), exp(3) - 234, exp(3) - 234, exp(1)

Note Pour Maple, a.x2 + b.x + c est constitué au final de 3 morceaux (a.x2, b.x, c) rassemblés par +Aussi, son type est +. map(sin, a.x2 + b.x + c) respecte le type et vaut sin(a.x2) + sin(b.x) + sin(c)

12

5 Les équations avec solve, allvalues . Exercices

5.1 Exemple

> restart: eq:= {x+2*y-1 , 2*x-y-1} : inc:={x,y} : sys:= solve(eq, inc);

/ 1 3\

sys:= { y = -, x = - }

\ 5 5/

> # Donner un nom aux quantités. Et puis x+2*y-1 ou x+2*y-1=0 sont

pareils dans solve(...)

> inc; x;

{x, y}

x

> assign(sys); # C’est pour assigner les réponses x, y car pas fait justement.

> inc, x; # Au passage, on peut séparer les instructions par ,

/1 3\ 3

{ -, - }, -

\5 5/ 5

Remarques :

1. Avec RootOf bien voir la commande allvalues

2. On verra que pour résoudre les équations différentielles, on utilise dsolve(...) .

3. Et pour résoudre les systèmes linéaires, on utilise un "package" with(linalg) :et alors la commande linsolve (...) ;

4. Autre exemple fsolve (...)

> restart: P:=(2*x^5-7*x^2+x-3);

> fsolve(P); # Une seule racine réelle dirait-on, résolution approchée.

1.559929234

> sort(-7*x^2+x-3+2*x^5);

5 2

2 x - 7 x + x - 3

> S:=seq(coeff(P,x,k), k=0..degree(P));

S := -3, 1, -7, 0, 0, 2

> min(S); S[2]; # Très utile et commode !

-7

1

13

5.2 Exercice avec sum : Calcul de

n∑

k=1

kp pour p = 2, 3...

> for p from 1 to 3 do S[p](n)=factor(sum(k^p,k=1..n)) od ; # Rappel S||p(n)

1 serait aussi bien.

S[1](n) = - n (n + 1)

2

1

S[2](n) = - n (n + 1) (2 n + 1)

6

1 2 2

S[3](n) = - n (n + 1)

4

5.3 Exercice : 10 premiers nombres premiers de Mersenne (type 2n − 1)

> seq(2^n-1,n=2..20);

3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535,

131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215, 33554431,

67108863, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823

> S:=seq(2^n-1,n=2..90):

> for k from 1 to 90 do if isprime(S[k]) then print(S[k]) fi od;

3

7

31

127

8191

131071

524287

2147483647

2305843009213693951

618970019642690137449562111

Error, invalid subscript selector # car aller jusqu’à 89 seulement.

14

6 Les fonctions. Les courbes

6.1 Tracé de y = f(x) en cartésiennes

> f:= x -> (x^2-x+4)/(3*(x-2)) ;

2

x - x + 4

f := x -> ----------

3 (x - 2)

> plot(f(x),x=-5..5,y=-5..5);

-4

x

6y

4

4

2

20

-2

0

-4

-2

1. Comment avoir un repère orthonormé ? Dur à trouver dans l’aide ! Clic-droit scaling=constrained

2. Comment faire en sorte que f(x) n’aille pas à l’infini ? (x = 2) En limitant les y −5..5

3. Comment avoir l’autre asymptote oblique ?Déjà, ici, f(x) est une fraction rationnelle ; On peut la décomposer en éléments simples ;

avec Maple, la commande est convert(f(x), parfrac)

> convert(f(x), parfrac);

1 1 2

- x + - + -----

3 3 x - 2

Donc l’asymptote a pour équation g(x) =x + 1

3. Voilà donc ce que l’on peut faire avec Maple :

> plot( [f(x),(x+1)/3], x=-5..6,y=-5..5, scaling=constrained, color=[red,blue]);

-4

x

6y

4

4

2

20

-2

0

-4

-2

Remarques : Tout (sauf repère orthonormé ) se voit aisément dans l’aide sur plot

� On a mis des crochets [...] de liste ; on pouvait aussi mettre des accolades ..., mais pas pour color !� On peut ajouter l’option tickmarks=[3,3] pour contrôler le nombre de marques sur les axes...� On peut ajouter l’option thickness=[1,2] pour l’épaisseur des courbes ! ...� Avec convert, des quotes penchés pour convertir une Liste en somme ou produit : convert([2,5,a],‘∗‘) ;

6.2 Tracé de plusieurs fonctions avec même intervalle de x : comme ci-dessus

Exercice f(x) = sin(x), g(x) = x − x3/3!, et h(x) = x − x3/3! + x5/5!

15

6.3 Tracé d’une courbe en paramétriques : voir la place du crochet fermant ]

Par exemple : t 7−→{

x = cos3(t)

y = sin3(t)L’aide sur plot indique l’instruction :

> plot( [cos(t)^3,sin(t)^3,t=-4..4] , x=-1.1..1.1 , y=-1.1..1.1 , thickness=2);

y

x

1

1

0,5

00,5

-0,5

-1

0-0,5-1

(Astroïde).

6.4 Tracé d’une courbe en coordonnées polaires : coords=polar

Par exemple : ρ = 1 + cos(theta) Instruction : (Limitation des axes très utile si branche infinie...)

> plot([1+cos(theta), theta, theta=-4..4], x=-0.3..2.3, y=-1.3..1.3, coords=polar);

0,50

1

2

0,5

1,50

-0,5

1

-1

(Cardioïde).

6.5 Tracé plus délicat avec plots non pas plot : 2 courbes avec x différents !

Instruction plots et ici voir display Déjà, recopions l’exemple de l’aide et adaptons-le :

> with(plots): # Maple charge ici un "package" (des instructions complémentaires)

F:=plot(cos(x),x=-Pi..Pi,y=-Pi..Pi,style=line):

G:=plot(tan(x),x=-Pi..Pi,y=-Pi..Pi,style=point):

display({F,G},axes=boxed,scaling=constrained,title=‘Cosine and Tangent‘); # des options!

Dessinons sin et la partie que l’on inverse sin/[−π/2,π/2] pour Arcsin (arcsin pour Maple)

Toujours avec with(plots) : (Voir ici aussi implicitplot, polarplot, textplot, polygonplot...)

F:=plot(sin(x),x=-Pi/2..Pi/2, y=-1..1.1, color=red, thickness=3):

G:=plot(sin(x), x=-3.5..5.5, color=blue, thickness=1):

display({F,G} , scaling=constrained ,tickmarks=[4,2]);

plot(arcsin(x), x=-1.1..1.3 , tickmarks=[3,3], thickness=2);

x

420-2y 0

1

0

x

1-1

-1

0

16

7 Les Polynômes. Les fractions rationnelles

7.1 Les polynômes Voir subs sort surtout (Tout est dans l’aide)

> a := x^3+5*x^2+11*x+15: degree(a,x);

3

> coeff(a,x,1); coeffs(a,x);

11

15, 11, 1, 5 # en désordre !

> subs(x=3,a);

120

> type(a,‘+‘);

true

> nops(a); op(1,a);

4

3

x

> op(a);

3 2

x , 5 x , 11 x, 15

> A:=factor(a);

2

A := (x + 3)(x + 2 x + 5)

> b:= x^6-11*x+7*x^3+8;

6 3

b := x - 11 x + 7 x + 8

> a*b;

3 2 6 3

(x + 5 x + 11 x + 15)(x - 11 x + 7 x + 8)

> expand(%);

9 4 6 3 8 5 2 7

x + 66 x + 22 x + 58 x + 5 x + 35 x - 81 x + 11 x - 77 x + 120

> sort(%); # Voir aussi collect

9 8 7 6 5 4 3 2

x + 5 x + 11 x + 22 x + 35 x + 66 x + 58 x - 81 x - 77 x + 120

> seq(coeff(%,x,k),k=0..degree(%));

120, -77, -81, 58, 66, 35, 22, 11, 5, 1

17

7.2 Les fractions rationnelles : parfrac avec convert, numer denom

> f := (x^5+1)/(x^4-x^2);

5

x + 1 # Voir les commandes numer (numérateur)

f := ------- et denom (dénominateur)

4 2

x - x

> convert(f,parfrac,x); # (ou) convert(f,parfrac); (idem)

1 1

x - -- + -----

2 x - 1

x

> f := (2.3*x)/(5.4*x^3-2.3*x+1);

2.3 x

f := ------------------

3

5.4 x - 2.3 x + 1

> Digits:= 5: convert(f,parfrac,x); convert(f,parfrac,x,complex);

0.22404 0.063361 + 0.22404 x

- ---------------- + ----------------------------------

x + 0.8091847442 2

x - 0.8091847442 x + 0.2288540244

0.22402 0.11201 + 0.30166 I 0.11202 - 0.30166 I

- ----------- + -------------------------- + --------------------------

0.80918 + x x + (-0.40459 + 0.25526 I) x + (-0.40459 - 0.25526 I)

7.3 Note sur les complexes : Voir polar evalc abs Re conjugate

> z:= polar( 2^(1/2), Pi/4 );

(1/2) 1

z := polar (2 , - Pi)

4

> u:=evalc(z); abs(z); v:=conjugate(u); Re(z); argument (u);

u:= 1 + I

(1/2)

2 # noté aussi sqrt(2) par Maple

v:= 1 - I

1

1

- Pi

4

18

8 Calculs divers [dont linéarisation] Limites

8.1 Commandes en Maple : sum, product

> S[2](n)=sum(k^2,k=1..n); # ou S||2(n) ...

1 3 1 2 1 1

S[2](n) = - (n + 1) - - (n + 1) + - n + -

3 2 6 6

> factor(%);

1

S[2](n) = - n (n + 1) (2 n + 1) # Maple fait du calcul formel

6

(On peut essayer S[3](n) bien sûr)

> product(k,k=1..n); subs(n=10,%); eval(%);

GAMMA(n + 1) # Fonction mathématique connue...

mais difficile

GAMMA(11)

3628800 # C’est 10!= 3628800

8.2 Une somme classique où Maple a du mal à simplifier

Il s’agit du résultat (obtenu avec les complexes) :

n∑

k=0

cos(kt) =sin((n + 1)t/2)

sin(t/2).cos(nt/2)

> S:= sum(cos(k*t),k=0..n);

(cos(t) + 1) sin((n + 1) t) 1 1

S= --------------------------- - - cos((n + 1) t) + -

2 sin(t) 2 2

> S1:= factor(combine(%,trig));

sin(t n) + sin((n + 1) t) + sin(t)

S1 := ---------------------------------- # Ici Maple pas très bon

2 sin(t)

> limit(S1,t=0); simplify( subs(n=0,S1) ); # Pour vérifier !

n + 1

1 # Rien d’anormal !

8.3 Retenir combine qui sert à linéariser, inverse de expand , déjà vue

> combine(sin(x)^4);

3 1 1

- + - cos(4 x) - - cos(2 x)

8 8 2

19

8.4 Limites de fonctions limit asympt

> Limit(sin(x)/x,x=0) = limit(sin(x)/x,x=0) ;

sin(x)

lim ------ = 1 # Avec L majuscule, c’est la commande inerte

x -> 0 x (Elle donne l’énoncé !)

> Limit((cos(x)-1)/x^2,x=0) = limit((cos(x)-1)/x^2,x=0) ;

cos(x) - 1 -1

lim ---------- = --

x -> 0 2 2

x

> limit(arctan(x), x=infinity); asympt(arctan(x),x,2);

1

- Pi

2

1 1 1

- Pi - --- + O(---) # Ici, on déborde sur les DL

2 x 3

x

> limit(arcsinh(x),x=infinity); asympt(arcsinh(x),x); # Fonction hyperbolique

infinity

1 3 1

ln(2) + ln(x) + ---- - ----- + O(---) # Gardons le début :

2 4 6

4 x 32 x x

> convert(arcsinh(x), ln); # L’expression logarithmique :

Réponse Argsh(x) = ln(x +√

1 + x2) ∼x→+∞

ln(x) car ln(2x) = ln(x) + ln(2) ∼x→+∞

ln(x).

8.5 Limites de suites : un exemple

> restart: S[n] :=sum(1/k^2,k=1..n); # sum ou bien value(Sum(...))

1 2

S[n] := -Psi(1, n + 1) + - Pi # Psi, une fonction compliquée !

6 (mais connue ...)

> limit(S[n], n=infinity);

1 2

- Pi # Résultat extraordinaire dû à Euler

6 (’problème de Bâle’ longtemps irrésolu)

> sum(1/k^2, k=1..infinity);

1 2

- Pi # Avec evalf, on trouve 1.644934068

6

20

9 Comment dériver une fonction

9.1 Comment déclarer une fonction ? f :=x−> ... ou unapply

1. Fonction Arctan par exemple

Déjà, pour Maple, la syntaxe est arctan (et arctanh pour Argth usuel des mathématiques)

> restart: a:=arctan(1); evalf(a);

1

a := - Pi # Maple connait donc arctan

4

0.7853981635

> plot(arctan,-3..4); # ou plot(arctan(x), x=-3..4);

43210-1

1

-3

-1

0,5

-20

-0,5

2. Bien voir : la commande unapply si besoin

> arctan(1.0); # 1.0 Maple comprend qu’on donne un réel; il rend un réel.

0.7853981634

En plus de f (ci-dessous) on peut déclarer : g := x− > arctan(x) qui va très bien

> restart: f:=arctan ; g:= x->arctan(x); h(x):=arctan(x) ;

f := arctan

g := x -> arctan(x)

h(x) := arctan(x)

> f(1); g(1); h(1); # Mais h pas bon... (toutefois subs

1 pourrait nous tirer d’affaire)

- Pi

4

1

- Pi

4

h(1) # Pas de réponse !

h(1) ne va pas, donc h(x) ne va pas très bien ; c’est ici qu’on utilise unapply

> H:= unapply(h(x) , x); H(1); # l’expression h(x) transformée en fonction

H := x -> arctan(x)

1

- Pi

4

Exercice Que donne : (Noter à nouveau f := x−>... qui va bien )

f:=x-> if x<0 then 0 else exp(-1/x) fi; plot(f,-1..2,scaling=constrained,thickness=3);

21

9.2 Dériver avec D

> f1:=D(arctan); f1(x);

1

f1 := x -> ------

2

1 + x

1

------

2

1 + x

> g1:=D(g); g1(x); # Donc g:= x-> arctan(x) toujours TB

1

g1 := x -> ------

2

1 + x

1

------

2

1 + x

> D(h(x));

D(arctan(x)) # Ne va pas; mais D(H) conviendrait.

9.3 Dériver avec diff

> restart; f:=x->diff(arctan(x),x); g(x):=diff(arctan(x),x);

d

f := x -> -- arctan(x)

dx

1

g(x) := ------ # g(x) est une expression.

2

1 + x

> f(1); g(1);

Error, (in f) wrong number (or type) of parameters in function diff

g(1) # RIEN ne va! Que faire? Utiliser unapply !

> restart: f:= unapply( diff(arctan(x),x) , x); f(1);

1

f := x -> ------ # unapply transforme l’expression en application !

2

1 + x

1

- # Tout va bien avec unapply si on utilise diff

2 (pour f(x) aussi)

Retenons : Pour avoir une fonction avec diff utiliser (ici aussi) unapply

22

10 Dériver plusieurs fois. Equations différentielles

10.1 Dériver plusieurs fois avec D

1. La syntaxe est (D@D) et (D@@k)

> f[2]:= (D@D)(ln); for k from 3 to 4 do f[k]:=(D@@k)(ln) od ; f[4](1);

1

f[2] := x -> - ---

2

x

2

f[3] := x -> ---

3

x

6

f[4] := x -> - ---

4

x

-6

2. Signalons le cas des fonctions de plusieurs variables

> f:= (x,y)->x^2*y^3 ;

2 3

f := (x, y) -> x y

> D[1](f); D[2](f); D[1,2](f); D[2,2](f);

3

(x, y) -> 2 x y

2 2

(x, y) -> 3 x y

2

(x, y) -> 6 x y

2

(x, y) -> 6 x y # Dérivée 2 fois / 2ème variable

10.2 Dériver plusieurs fois avec diff

> Diff(sin(x),x$3)=diff(sin(x),x$3) ;

3

d

--- sin(x) = -cos(x)

3

dx

Rappel : Avec diff utiliser la commande unapply pour avoir une application

23

10.3 Equations différentielles dsolve sans condition initiale

1. Avec diff

Attention: Maple note de façon bizarre (en première lecture) les constantes;

_C1 etc; et de plus, il note h(x)_C1 pour indiquer un produit !

> dsolve(diff(y(x),x$2) +diff(y(x),x)+y(x)= sin(x), y(x));

/ 1 \ /1 (1/2) \ / 1 \ /1 (1/2) \

y(x)= exp|- - x | sin| - 3 x| _C2 + exp|- - x | cos| - 3 x | _C1 - cos(x)

\ 2 / \2 / \ 2 / \2 /

Ici une équ. diff. linéaire du 2ème ordre à coefficients constants avec second membre sin(x)

2. Avec D

> dsolve((D@D)(y)(x) + D(y)(x)+y(x)= sin(x),y(x)); # Même réponse.

> dsolve((D@D)(y)(x)+diff(y(x),x)=0); # Un mélange !

y(x) = _C1 + _C2 exp(-x)

> dsolve(diff(y(x),x)-y(x)^2=x); # Une équation non linéaire intordable !

_C1 AiryAi(1, -x) + AiryBi(1, -x)

y(x) = --------------------------------- # Une seule constante,

_C1 AiryAi(-x) + AiryBi(-x) on le savait !

Noter : Pour une famille de courbes, écrire f := (C1, x)− > ... et faire seq(..., C1 = −4..5)

10.4 Equations différentielles avec condition initiale : ajouter {...}1. Conditions initiales avec D

> dsolve( {(D@D)(y)(x) -diff(y(x),x)=0, D(y)(0)=3, y(0)=2} , y(x));

y(x) = -1 + 3 exp(x)

2. Conditions initiales avec diff : compliqué

> dsolve( {(D@D)(y)(x) -diff(y(x),x)=0, diff(y(x),x)(0)=3, y(0)=2} , y(x));

# Il ne se passe rien ! Celà ne va pas !

Il faut ajouter la commande unapply ! unapply( diff(y(x),x), x) est: x-> ...

> dsolve({(D@D)(y)(x)-diff(y(x),x)=0, unapply(diff(y(x),x),x)(0)=3, y(0)=2}, y(x));

y(x) = -1 + 3 exp(x) # Juste mais retenir 1)

Remarque : solve(f(x)=0) ou solve(f(x)) pareils. =0 est sous entendu s’il y a rien

24

11 Comment composer les fonctions. Suites un+1 = f(un)

11.1 Rappels avec (D@D) (D@@k) la composition est notée avec @

> (sin@cos)(x);

sin(cos(x))

> g:= x-> sin(cos(x)); evalf(g(3)); # écriture toujours permise !

g := x -> sin(cos(x))

-.8360218615

> (sin@arcsin)(x);

x

> sin@arcsin; f:=simplify(%);

sin@arcsin

f := () -> args # Bizarre, l’écriture...

> f(0); f(1); f(2);

0

1

2 # f(2) défini ? ?

> sin@@0;

() -> args # L’identité comme ci-dessus

> sin@@1;

sin

> sin@@(-1);

arcsin

11.2 Exemple. Avec f(x) = −x + 3, g(x) = x2, faire fof (identité), fog, gof

> f:=x->-x+3 : g:=x->x^2 : (f@f)(x); (f@g)(x); (g@f)(x);

x

2

-x + 3

2

(-x + 3)

11.3 Exercice : Calculer ((xn−1 ∗ ln(x))(n) le même n, et observer !

> seq( (D@@n)(x->x^(n-1)*ln(x))(x), n=1..5) ;

1 1 2 6 24

-, -, -, -, -- # On reconnait (n-1)!/x

x x x x x

> seq ( diff(x^(n-1)*ln(x),x$n), n=1..5); # Etait aussi facile !

1 1 2 6 24

-, -, -, -, -- # Même réponse

x x x x x

25

11.4 Suite un+1 = f(un)

1. Le contexte On a u1 = f(u0) u2 = f(u1) = fof(u0) u3 = fofof(u0) etcNaturellement, on va calculer (f@@k)(u0) pour k variant de 1 à 10, par exemple.

2. Exercice classique. Avec la suite de Fibonacci (un+2 = un+1 + un, u0 = 0, u1 = 1, étude de

vn = un+1/un. Ici, on dit que vn+1 = 1 + 1/vn, v1 = 1, qui converge vers le nombre d’or racinepositive de x2 = x + 1 : 1.618033988 (On retrouve ce nombre souvent dans l’art en particulier).

> f:=x->1+1/x; seq( (f@@k)(1), k=1..10); Digits:= 4: evalf(%%);

1

f := x -> - + 1

x

3 5 8 13 21 34 55 89 144

2, -, -, -, --, --, --, --, --, --- # Termes v2, v3, v4, v5...

2 3 5 8 13 21 34 55 89

2., 1.500, 1.667, 1.600, 1.625, 1.615, 1.619, 1.61_, 1.618, 1.618

3. Autre exemple où un+1 = f(un) : Soit f(x) = 3/(1 + 2x2) et u0 = 0 ; voyons (u2p), (u2p+1)

> Digits:= 6: f:=x->3.0 /(1+2*x^2); seq( (f@@k)(0), k=0..13);

3.0

f := x -> -------- # Avec 3.0 Maple reçoit et rend des réels!

2

1 + 2 x

0, 3.0, 0.157895, 2.85752, 0.173102, 2.83038, 0.176241, 2.82454, 0.176927,

2.82324, 0.177081, 2.82294, 0.177117, 2.82289 # Les 2 sous-suites convergent,

mais pas vers la même limite!

Remarque : Mathématiquement, l’exercice précédent est difficile.

On peut montrer que (u2p) et (u2p+1) convergent vers un point fixe de fof .Mais résoudre fof(x) = x est du 5ème degré. On y arrive car :On voit que : f(x) = x =⇒ fof(x) = x ; donc fof(x) − x est divisible par f(x) − x.f(x) − x est un polynôme de degré 3, mais possédant une racine évidente valant 1...

En plus de 1, fof possède 2 autres points fixes : 0.177... et 2.82...

3

x

2,5

1

2,5 3

0,5

21,50,5

2

1,5

010

11.5 Avec des matrices carrées, les puisances successives sont des compositions

(Voir plus loin)

26

12 Intégrer une fonction. Primitives

12.1 Primitives

> int( sin(x), x );

-cos(x) # Maple ne met pas les constantes.

> int(1/x,x);

ln(x) # Maple ne met pas les |...|

> int(1/(x+I),x);

1 / 2 \ # D’ailleurs Maple travaille

- ln\x + 1/ - I arctan(x) avec les complexes

2

> int( x/(x^3-1), x); # Inutile de dire à Maple de décomposer

1 / 2 \ 1 (1/2) /1 (1/2)\ 1

- - ln\x + x + 1/ + - 3 arctan|- (2 x + 1) 3 | + - ln(x - 1)

6 3 \3 / 3

> int( exp(-x^2), x ); # Primitive inconnue, fonction d’erreur de Gauss

1 (1/2) (erf)

- Pi erf(x)

2

12.2 Intégrales

> Int(sin(x)^6,x=0..Pi/2) = int(sin(x)^6,x=0..Pi/2); # Int: énoncé

(Majuscule=commande inerte)

/1/2 Pi

| 6 5

| sin(x) dx = -- Pi # C’est une intégrale de Wallis)

| 32

/0

> int(ln(x)/(1+x^2),x=1/a..a);

/ln(x) /1 \\

int|------, x = | - .. a|| # Elle vaut toujours 0 mais

| 2 \a /| Maple ne sait pas le reconnaitre.

\x + 1 /

> subs(a=4,%); evalf(%);

/ln(x) /1 \\ # C’est le recopiage de la

int|------, x = | - .. 4|| présentation qui n’est pas fameux

| 2 \4 /| L’original est très bon ...

\x + 1 /

-9

2 10 + 0. I

12.3 Exercice corrigé : CNS pour que

∫

a.x2 + b.x + c

(x2 + k2)2soient rationnelles

Avec Maple

27

> Int( (a*x^2+b*x+c)/(x^2+k^2)^2, x)= int( (a*x^2+b*x+c)/ (x^2+k^2)^2, x); A:=op(%) ;

/ /x\ /x\

| 2 a arctan|-| / 2\ 2 arctan|-| c

| a x + b x + c \k/ \2 c - 2 a k / x - 2 b k \k/

| -------------- dx = ----------- + ------------------------- + -----------

| 2 2 k 2 / 2 2\ 3

/ / 2 2\ 4 k \x + k / 2 k

\x + k /

/

| 2

| a x + b x + c

A := | -------------- dx, # Les opérandes de A,

| 2 le 2ème ci-dessous...

/ / 2 2\

\x + k /

/x\ /x\

a arctan|-| / 2\ 2 arctan|-| c

\k/ \2 c - 2 a k / x - 2 b k \k/

----------- + ------------------------- + -----------

2 k 2 / 2 2\ 3

4 k \x + k / 2 k

> whattype(A) ; B:= op(2,[A]) ; # A du type "suite" donc op(A) ne va pas mais op([A])

exprseq # [ ]=liste

/x\ /x\

a arctan|-| / 2\ 2 arctan|-| c

\k/ \2 c - 2 a k / x - 2 b k \k/ # Membre de droite

B := ----------- + ------------------------- + ----------- de l’égalité

2 k 2 / 2 2\ 3 ci-dessus

4 k \x + k / 2 k (en 1ère ligne)

> op(B); op(2, [op(B)]) ; # Voir op. Il faut [op(B)] une liste !

/x\ /x\

a arctan|-| / 2\ 2 arctan|-| c

\k/ \2 c - 2 a k / x - 2 b k \k/

----------, -------------------------, -----------

2 k 2 / 2 2\ 3

4 k \x + k / 2 k

/ 2\ 2

\2 c - 2 a k / x - 2 b k # La fraction rationnelle qui

------------------------- ne gêne pas et qu’on va

2 / 2 2\ enlever à B pour ne garder

4 k \x + k / que les arctan

> simplify( B- op(2, [op(B)]) ) ;

/x\ / 2 \

arctan|-| \a k + c/

\k/ # Primitives rationnelles ssi

-------------------- les arctan se suppriment.

3

2 k Donc CNS : ak^2+c=0 Fin.

28

13 Développements limités. Développements généralisés

13.1 La commande est taylor ou series

> taylor(sin(x),x=0, 8); # Au point 0, à l’ordre 8 ...

1 3 1 5 1 7 / 8\

x - --- x + --- x - ---- x + O\x / # C’est le O de Landau, non pas le o

6 120 5040 (le terme suivant peut être en k.x^8;

ici en réalité, en k.x^9, imparité)

> series(sin(x),x=0, 8);

Même réponse

> taylor(sin(sinh(x))-sinh(sin(x)), x=0, 9); # Maple bien commode pour un équivalent!

1 7 / 9\ (A la main on ne sait à quel ordre aller)

- --- x + O\x /

45

> taylor(sin(1/x),x=infinity,4);

1 1 /1\

- - ---- + O|-- |

x 3 | 4 |

6 x \x /

> asympt(sin(1/x),x,4); # Convient aussi. Infini sous entendu

avec asympt

1 1 /1\

- - ---- + O|-- |

x 3 | 5 |

6 x \x /

> taylor(arctan(x),x=infinity,6);

1 1 1 1 /1 \

- Pi - - + ---- - ---- + O|--|

2 x 3 5 | 6|

3 x 5 x \x /

13.2 Un développement généralisé

> taylor(arccos(x),x=1, 2); # Au point, à l’ordre 2

Error, does not have a taylor expansion, try series()

> series(arccos(x),x=1, 2); # series plus général que taylor

(1/2) (1/2) / (3/2)\

I 2 (x - 1) + O\(x - 1) /

Si on lit le début, c’est I.√

2.√

x − 1 =√

2(1 − x) en 1−. Prouver : Arccos(x) ∼x→1−

√

2(1 − x)

29

13.3 Avec une suite. Maple donnen

√n! ∼

n→+∞

n

e

> series((n!)^(1/n),n=infinity,3); # On va voir, selon Maple...

/ / (1/2) (1/2)\ 1 \ /1\

exp(-1) n + exp(-1) |ln\2 Pi / + - ln(n)| + O|-|

\ 2 / \n/

> asympt((n!)^(1/n),n,3); # Même réponse...

13.4 Avec les développements limités : approximant de Padé

1. Enoncé. Soit la différence d(x) = cos(x)− 1 + ax2

1 + bx2. On cherche a, b de façon à avoir, au voisinage

de x = 0, un infiniment petit d’ordre maximum ; dont on donnera un équivalent.

2. Ce que l’on fait : On va faire un DL d’ordre 6 (au moins) car on vise à supprimer les x2 et les x4,

en jouant sur 2 lettres a, b ; logiquement, il doit rester des x6.

> Dl:= taylor(cos(x)-(1+a*x^2)/(1+b*x^2),x=0,7);

/ 1 \ 2 / 1 \ 4 / 2 1 \ 6 / 8\

Dl := |- - - a + b| x + |-(-a + b) b + -- | x + |-(a - b) b - --- | x + O\x /

\ 2 / \ 24/ \ 720/

> op(Dl); # On visualise tous les morceaux ("opérandes") de Dl...

1 1 2 1

- - - a + b, 2 , -(-a + b) b + --, 4 , -(a - b) b - ---, 6 , O(1) , 8

2 24 720

> solve({ op(1,Dl)=0, op(3,Dl)=0}); # ... pour annuler les termes en x^2 et x^4

/ -5 1 \

{ a = --, b = -- }

\ 12 12/

> subs(%,Dl);

1 6 / 8\

--- x + O\x /

480

13.5 Note : dérivée 5ème de Arctan en 0, son Dl étant aisément connu

> (D@@7)(arctan)(0); # 1ère façon; directement

-720

> p(x):=diff(arctan(x),x$7): g:= unapply(p(x),x): g(0);

-720 # 2ème façon; avec unapply

> taylor(arctan(x),x=0, 8);

1 3 1 5 1 7 / 8\ # 3ème façon! Le coefficient de x^7 :

x - - x + - x - - x + O\x / -1/7 est aussi f^(7)(0)/7! selon Taylor-

3 5 7 Young! Donc ... f^(7)(0)= -6!= -720

30

14 Matrices et déterminants

14.1 On télécharge un package : with(linalg) evalm concat...

> with(linalg);

Warning, the protected names norm and trace have been redefined and unprotected

[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian,

addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout,

blockmatrix, charmat, charpoly, cholesky, col, coldim, colspace, colspan,

companion, concat, cond, copyinto, crossprod, curl, definite, delcols,

delrows, det, diag, diverge, dotprod, eigenvals, eigenvalues, eigenvectors,

eigenvects, entermatrix, equal, exponential, extend, ffgausselim, fibonacci,

forwardsub, frobenius, gausselim, gaussjord, geneqns, genmatrix, grad,

hadamard, hermite, hessian, hilbert, htranspose, ihermite, indexfunc,

innerprod, intbasis, inverse, ismith, issimilar, iszero, jacobian, jordan,

kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor, minpoly,

mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent,

pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim,

rowspace, rowspan, rref, scalarmul, singularvals, smith, stackmatrix,

submatrix, subvector, sumbasis, swapcol, swaprow, sylvester, toeplitz,

trace, transpose, vandermonde, vecpotent, vectdim, vector, wronskian]

> u:=vector(3,i->i^2); v:=vector([5,6,7]); A:=concat(u,v); # Commande

essentielle:

u := [1, 4, 9] Juxtaposition

des colonnes

v := [5, 6, 7]

[1 5]

A := [4 6] # C’était des colonnes sauf gain de place

[9 7]

> op(2,u); op(2, evalm(u)); u[2]; # A signaler :

Error, improper op or subscript selector # Ne va pas !

1 .. 3 # Ne va pas !

4 # Convient !

> A; evalm(A);

A

[1 5]

[4 6] # evalm(A) pour afficher !

[9 7]

> B:=matrix(2,2,[1,2,3,4]); matrix([[1,2],[3,4]]); det(%); # Conviennent.

[1 2]

[3 4]

[1 2]

[3 4]

-2

31

14.2 La matrice identité, le plus simple, même "rectangle" à retenir !

> with(linalg): A:=diag(1,1); # Avec le package linalg

[1 0]

A := [ ]

[0 1]

> f:=(x,y)->if x=y then 1 else 0 fi: B:=matrix(2,3,f); # Rectangle !

[1 0 0]

B := [ ]

[0 1 0]

> C:=evalm(array(identity,1..2,1..3)); # array et pas matrix ici

[1 0 0]

B := [ ]

[0 1 0]

14.3 Matrice identité avec "procédure" ... si on veut ; ou bien sans !

> identité:=proc(n) local Z,i; Z:=array(sparse,1..n,1..n); for i to n do Z[i,i]:=1 od;

evalm(Z) end; identité(4);

identité := proc(n) local Z, i; Z := array(sparse, 1 .. n, 1 .. n); for i to n do

Z[i, i] := 1 end do; evalm(Z); end proc;

[1 0 0 0]

[0 1 0 0]

[0 0 1 0]

[0 0 0 1]

> restart: Matrix(4,4,shape=identity); # On pouvait aussi taper ceci ! Même avec

restart, donc sans package... même réponse

14.4 Calculs de base (à faire) Voir aussi : Matrix Vector

> A:= matrix(2,2,[1,2,3,4]); b:=vector([alpha,beta]); c:=[alpha,beta];

> evalm(A &* b); evalm(A &* c); # Voir la notation !

> linsolve(A,b,’r’); r; # Devrait résoudre de suite l’équation A.X = b;

Comme r=rang=2, A est inversible: X=A^(-1).b. Mais rien de fait sans package

> with(linalg): linsolve(A,b,’r’); r; # Voir encore ?rank

C’est fait ! On pouvait certes résoudre avec solve({eqs},{var}): 4 équ., 4 inc.

Mais mauvais: Maple résoud illico les systèmes linéaires! D’autres matrices:

> B:= matrix(3,3,10); C:= matrix(3,3,(i,j)->i+j); C1:=matrix(3,3,(i,j)->i^2+j);

> m:=’m’; M:= matrix(3,3,m); M1:= subs(m(1,2)=4,%);

> eval(C &* B); evalm(C &* B); # La bonne commande : "evalm" au lieu de "eval"!

32

> H:=hilbert(3); K:=inverse(H); # hilbert à ne pas savoir! evalm(H^(-1)) convient

[ 1 1]

[1 - -]

[ 2 3]

[ ]

[1 1 1]

H := [- - -] # Présentation de Maple meilleure !

[2 3 4]

[ ] (les inverses des entiers)

[1 1 1]

[- - -]

[3 4 5]

[ 9 -36 30]

K := [-36 192 -180]

[ 30 -180 180]

> b:=’b’; c:=’c’; v:=vandermonde([a,b,c]); det(v); factor(%); # b et c désaffectés

résultat classique sur matrices de Vandermonde.

b := b

c := c

[ 2]

[1 a a ]

[ 2]

v := [1 b b ]

[ 2]

[1 c c ]

2 2 2 2 2 2

b c - b c - a c + a c + a b - a b

(b - a) (-a + c) (c - b)

14.5 Inverse d’une matrice 2x2 et de la matrice du triangle de Pascal

> B:= inverse(matrix(2,2,[a,b,c,d]));

[ d b ]

[- ---------- ---------- ]

[ -a d + b c -a d + b c ]

B:= [ ]

[ c a ]

[ ---------- - ----------]

[ -a d + b c -a d + b c]

> det(B);

1

- ---------- # Comme il se doit !

-a d + b c dét(t.A)=t^2.dét(A) si matr. 2x2

> # Exercice 2): Matrice de Pascal P:=matrix(6,6,(i,j)-> binomial(i-1,j-1))

et voir P^(-1)

33

14.6 Des déterminants 3x3 (nuls) !

> A:=matrix(3,3, (i,j)->cos((i+j-2)*x));

[ 1 cos(x) cos(2 x)]

[ ]

A := [ cos(x) cos(2 x) cos(3 x)]

[ ]

[cos(2 x) cos(3 x) cos(4 x)]

> with(linalg): det(A); expand(%);

Warning, the protected names norm and trace have been redefined and unprotected

2 2

cos(2 x) cos(4 x) - cos(3 x) - cos(x) cos(4 x) + 2 cos(x) cos(2 x) cos(3 x)

3

- cos(2 x)

0

> M:=matrix(3,3, (i,j)->sin(a[i]+b[j]));

[sin(a[1] + b[1]) sin(a[1] + b[2]) sin(a[1] + b[3])]

[ ]

M := [sin(a[2] + b[1]) sin(a[2] + b[2]) sin(a[2] + b[3])]

[ ]

[sin(a[3] + b[1]) sin(a[3] + b[2]) sin(a[3] + b[3])]

> det(M); expand(%);

sin(a[1] + b[1]) sin(a[2] + b[2]) sin(a[3] + b[3])

- sin(a[1] + b[1]) sin(a[2] + b[3]) sin(a[3] + b[2])

- sin(a[2] + b[1]) sin(a[1] + b[2]) sin(a[3] + b[3])

+ sin(a[2] + b[1]) sin(a[1] + b[3]) sin(a[3] + b[2])

+ sin(a[3] + b[1]) sin(a[1] + b[2]) sin(a[2] + b[3])

- sin(a[3] + b[1]) sin(a[1] + b[3]) sin(a[2] + b[2])

0 # On l’avait vu ...

(3 colonnes liées)

Puissances de matrice : An

A:=matrix(2,2,[3,2,1,2]) (plusieurs façons) Corrigé plus loin.

34

15 Cas des espaces vectoriels euclidiens

15.1 Construire une matrice de rotation dans R3

On donne : r(−→x ) = c−→x + s−→ω ∧ −→x + (1 − c)(−→w �

−→x )−→w c = cos(a), s = sin(a) [cours]

> r:= x->evalm( cos(a)*x + sin(a)*crossprod(omega,x)/norm(omega,2) +

(1-cos(a))*dotprod(omega,x)/norm(omega,2)^2*omega );

/ sin(a) crossprod(omega, x)

r := x -> evalm|cos(a) x + --------------------------

| norm(omega, 2)

\

(1 - cos(a)) dotprod(omega, x) omega\

+ ------------------------------------ |

2 |

norm(omega, 2) /

> e1:= [1,0,0]: e2:= [0,1,0]: e3:= [0,0,1]: a:= 2*Pi/3; omega:= [1,1,0];

2

a := - Pi

3

omega := [1, 1, 0]

> u1:=r(e1): u2:=r(e2): u3:=r(e3): R:=concat(u1,u2,u3);

[ 1 3 1 (1/2) (1/2) ]

[ - - - 3 2 ]

[ 4 4 4 ]

[ ]

[ 3 1 1 (1/2) (1/2)]

R := [ - - - - 3 2 ]

[ 4 4 4 ]

[ ]

[ 1 (1/2) (1/2) 1 (1/2) (1/2) -1 ]

[- - 3 2 - 3 2 -- ]

[ 4 4 2 ]

15.2 Vérifications déterminant...

> det(R); trace(R); r(omega); R&*omega; evalm(R&*omega); # det(R)=1 OK !

1

0

[1, 1, 0]

R &* [1, 1, 0]

[1, 1, 0]

35

15.3 Matrice du retournement autour de V ect(a, b, c) avec A = PDP−1

> u:=1/ (a^2+b^2+c^2)^(1/2)*vector([a,b,c]);

[a, b, c]

u := -------------------

(1/2)

/ 2 2 2\

\a + b + c /

> v:=1/ (a^2+b^2)^(1/2)*vector([-b,a,0]);

[-b, a, 0]

v := --------------

(1/2)

/ 2 2\

\a + b /

> with(linalg): w:=crossprod(u,v);

[

[ c a

w := [- ----------------------------------,

[ (1/2) (1/2)

[ / 2 2 2\ / 2 2\

[ \a + b + c / \a + b /

c b

- ----------------------------------,

(1/2) (1/2)

/ 2 2 2\ / 2 2\

\a + b + c / \a + b /

2 2 ]

a b ]

---------------------------------- + ----------------------------------]

(1/2) (1/2) (1/2) (1/2)]

/ 2 2 2\ / 2 2\ / 2 2 2\ / 2 2\ ]

\a + b + c / \a + b / \a + b + c / \a + b / ]

> P:=concat(u,v,w);

P:=

[ a b c a ]

[-------------------, - --------------, - ----------------------------------,]

[ (1/2) (1/2) (1/2) (1/2) ]

[/ 2 2 2\ / 2 2\ / 2 2 2\ / 2 2\ ]

[\a + b + c / \a + b / \a + b + c / \a + b / ]

36

[ b a c b ]

[-------------------, --------------, - ----------------------------------],

[ (1/2) (1/2) (1/2) (1/2)]

[/ 2 2 2\ / 2 2\ / 2 2 2\ / 2 2\ ]

[\a + b + c / \a + b / \a + b + c / \a + b / ]

[

[ c

[-------------------, 0,

[ (1/2)

[/ 2 2 2\

[\a + b + c /

2 2 ]

a b ]

---------------------------------- + ----------------------------------]

(1/2) (1/2) (1/2) (1/2)]

/ 2 2 2\ / 2 2\ / 2 2 2\ / 2 2\ ]

\a + b + c / \a + b / \a + b + c / \a + b / ]

> A:=simplify(evalm(P&*diag(1,-1,-1)&*P^(-1))); # La réponse :

[ 2 2 2 ]

[ b - a + c 2 a b 2 a c ]

[- ------------ ------------ ------------ ]

[ 2 2 2 2 2 2 2 2 2 ]

[ a + b + c a + b + c a + b + c ]

[ ]

[ 2 2 2 ]

[ 2 a b b - a - c 2 b c ]

A := [ ------------ ------------ ------------ ]

[ 2 2 2 2 2 2 2 2 2 ]

[ a + b + c a + b + c a + b + c ]

[ ]

[ 2 2 2]

[ 2 a c 2 b c b + a - c ]

[ ------------ ------------ - ------------]

[ 2 2 2 2 2 2 2 2 2]

[ a + b + c a + b + c a + b + c ]

> # Ne pas faire d’erreur de lecture sur la diagonale avec les 2 signes - !

Il y aurait avantage à mettre 1/(a^2+b^2+c^2) en facteur.

Comme en page précédente, on peut vérifier avec det(A), Tr(A) et

aussi le vecteur (a,b,c) invariant !

37

16 Exercices corrigés Procédures

16.1 Vérification numérique d’égalités

•n

∑

k=0

(

2kk

)

.

(

2n − 2kn − k

)

= 4n. • an =1

n + 1

(

2nn

)

vérifie : a0 = 1, an+1 =n

∑

k=0

ak.an−k donc entiers !

> seq(u[n]=sum(binomial(2*k,k)*binomial(2*(n-k),n-k),k=0..n),n=0..5);

seq(v[n]=4^n,n=0..5);

u[0] = 1, u[1] = 4, u[2] = 16, u[3] = 64, u[4] = 256, u[5] = 1024

v[0] = 1, v[1] = 4, v[2] = 16, v[3] = 64, v[4] = 256, v[5] = 1024 # (1) vérifiée

----------

> restart: a[0]:=1 : for n from 0 to 5 do a[n+1]:= sum(a[k]*a[n-k],k=0..n) od;

a[1] := 1

# Les notations u||k v||k

a[2] := 2 a||k b||k sont aussi

bonnes (meilleures?)

a[3] := 5

a[4] := 14

a[5] := 42

a[6] := 132

> seq(b[n]=1/(n+1)*binomial(2*n,n),n=1..6); # Et (2) vérifiée (si n petit).

b[1] = 1, b[2] = 2, b[3] = 5, b[4] = 14, b[5] = 42, b[6] = 132

16.2 Quelques limites (à surtout savoir faire à la main !)

> Limit((1+\lambda/x)^x,x=infinity)=limit((1+\lambda/x)^x,x=infinity);

x

/ lambda\

lim |1 + ------| = exp(lambda)

x -> infinity \ x /

> Limit((x^2-20*x+11)^(1/2)+x,x=-infinity)=limit((x^2-20*x+11)^(1/2)+x,x=-infinity);

/ (1/2) \

|/ 2 \ |

lim \\x - 20 x + 11/ + x/ = 10

x -> -infinity

16.3 Vérifier que J =

∫ b

a

dx√

(x − a)(b − x)= π I : lettre réservée

> assume(a<b): J=int(1/((x-a)*(b-x))^(1/2),x=a..b): # Essentiel: assume(a<b):

38

16.4 Le paradoxe des anniversaires.

Nombre de personnes pour que la probabilité que 2 d’entre elles aient le même jour

d’anniversaire soit p >0,5? Réponse 1-p =(365-0)(365-1)...(365-n+1)/365^n. Et n=23.

> 365! / 342! ; 365^23 ; evalf( %% / % ,5 ); # C’est 1-p < 0,5.

42200819302092359872395663074908957253749760700776448000000

85651679353150321236814267844395152689354622364044189453125

0.49270 # Donc vrai que n=23 est la réponse.

Mais essayons de la trouver directement:

> seq( evalf( 365!/(365^n*(365-n)!), 2), n= 15..25); # A nouveau n=23.

0.75, 0.72, 0.68, 0.65, 0.62, 0.59, 0.56, 0.52, 0.49, 0.46, 0.43

16.5 Courbes en paramétriques avec asymptote

> plot([3*t^2/(1+t^3), 3*t^3/(1+t^3), t=-8..8], -4..4,-3..5, scaling=constrained);

... # scaling=constrained est une façon pour un repère orthonormé.

# Et si on veut mettre une autre courbe, par exemple l’asymptote y= - x+1 ?

> plot( {[3*t^2/(1+t^3), 3*t^3/(1+t^3), t=-8..80], -x+1}, x=-4..4,-3..5,

color=[red, blue], scaling=constrained,thickness=2);

x

4

4

2

02

-2

0-2-4

x

2

2

1

1

00

-1

-1

-2

-2

Par contre, ci-dessus, à droite (et ci-dessous avec Maple), c’est le folium de Descartes.

> plot( {[3*t^2/(1+t^3), 3*t/(1+t^3), t=-8..80],-x-1}, x=-4..4,-3..5,

color=[red, blue], scaling=constrained, thickness=[2,1]);

16.6 Une courbe en polaires avec asymptote

plot(1/cos(2*t),t, t=-5..5, coords=polar, view=[-3..3,-3..3]); # l’inverse du trèfle

3

3

2

2

1

01

-1

-2

0

-3

-1-2-3 -0,5-1

1

1

0,5

0,50

-0,5

0

-1

39

16.7 Une propriété du nombre d’or

On sait que : ϕ = 1, 618... est la racine positive de x2 = x + 1 ou de 1/x = x − 1.

Si on a un pentagone régulier : M0(1), M1(ω = e2iπ/5), M2(ω2), M3(ω

3), M4(ω4) alors ω

racine de x4 + x3 + x2 + x + 1 = 0, etM0M2

M0M1=| ω2 − 1

ω − 1|=| ω + 1 |= ϕ. Vérifier !

> S:= solve(x^4+x^3+x^2+x+1=0) ;

(1/2)

1 (1/2) 1 1 (1/2) / (1/2)\

S := - 5 - - + - I 2 \5 + 5 / ,

4 4 4

(1/2)

1 (1/2) 1 1 (1/2) / (1/2)\

- - 5 - - + - I 2 \5 - 5 / ,

4 4 4

(1/2)

1 (1/2) 1 1 (1/2) / (1/2)\

- - 5 - - - - I 2 \5 - 5 / ,

4 4 4

(1/2)

1 (1/2) 1 1 (1/2) / (1/2)\

- 5 - - - - I 2 \5 + 5 /

4 4 4

> op(S); A:= op(1,[S]);

Error, wrong number (or type) of parameters in function op # Car avec op, une Liste !

(1/2)

1 (1/2) 1 1 (1/2) / (1/2)\

A := - 5 - - + - I 2 \5 + 5 / # C’est omega

4 4 4

> (A+conjugate(A))/2; # C’est cosinus(2*Pi/5) qui est inutile ici

1 (1/2) 1

- 5 - - # mais qui peut servir avec cos(Pi/5)=-cos(4*Pi/5)

4 4

> B:=A+1 ; abs(B) ; C:= simplify(%) ; # C’est le nombre d’or; vérifions:

à faire

> solve (x^2-x-1=0) ; # La racine positive est le Nombre d’Or.

à faire (Juste)

16.8 Une suite de polynômes : dérivées successives de g(x) =1

1 + x2= Arctan′(x)

> restart: g:=x->1/(1+x^2); # 1ère façon, de manière directe.

1

g := x -> ------

2

1 + x

> seq(P[k](x)=factor(simplify((D@@k)(g)(x)*(1+x^2)^(k+1))),k=0..9);

40

2

P[0](x) = 1, P[1](x) = -2 x, P[2](x) = 6 x - 2,

4 2

P[3](x) = -24 x (x - 1) (1 + x), P[4](x) = 120 x - 240 x + 24,

/ 2 \ / 2 \ 6 4 2

P[5](x) = -240 x \3 x - 1/ \x - 3/, P[6](x) = 5040 x - 25200 x + 15120 x - 720,

> convert(g(x),parfrac, complex); # 2ème façon, décomposons sur C

0.5000000000 I 0.5000000000 I

----------------- - --------------

x + 1.000000000 I x - 1. I

> h:=x->I/2*(1/(x+I)-1/(x-I)); simplify(h(x));

1 / 1 1 \

h := x -> - I |----- - -----|

2 \x + I x - I/

1

------

2

1 + x

> seq(Q[k](x)= factor(simplify(I/2*k!*(-1)^k*((x-I)^(k+1)-(x+I)^(k+1)))),k=0..9);

2

Q[0](x) = 1, Q[1](x) = -2 x, Q[2](x) = 6 x - 2,

4 2

Q[3](x) = -24 x (x - 1) (1 + x), Q[4](x) = 120 x - 240 x + 24,

/ 2 \ / 2 \ 6 4 2

Q[5](x) = -240 x \3 x - 1/ \x - 3/, Q[6](x) = 5040 x - 25200 x + 15120 x - 720,

> for k from 0 to 4 do R[k](x)=factor(simplify(I/2*k!*(-1)^k*((x-I)^(k+1)-(x+I)^(k+1))))

od;

R[0](x) = 1 # Les mêmes, mieux présentés !

R[1](x) = -2 x

2

R[2](x) = 6 x - 2

R[3](x) = -24 x (x - 1) (1 + x)

4 2

R[4](x) = 120 x - 240 x + 24 # etc

41

16.9 Puissance d’une matrice : polynôme annulateur et diagonalisation

> restart: A:=matrix(2,2,[3,2,1,2]);

[3 2]

A := [ ]

[1 2]

> evalm(A^2-5*A+4); # Un polynôme annulateur de racines 1 et 4 (vérifions)

[0 0]

[ ]

[0 0]

> solve({4*a+b=4^n,a+b=1},{a,b}); assign(%); # Reste de la division de x^n

par le polyn. annulateur

( x^n=(x^2-5*x+4).Q + ax+b et on prend les 2 racines...)

/ 4 1 n 1 1 n\

{ b = - - - 4 , a = - - + - 4 }

\ 3 3 3 3 /

> An:=evalm(a*A+b); # C’est A^n (autre méthode après qui va vérifier)

[ 1 2 n 2 2 n]

[ - + - 4 - - + - 4 ]

[ 3 3 3 3 ]

An := [ ]

[ 1 1 n 2 1 n ]

[- - + - 4 - + - 4 ]

[ 3 3 3 3 ]

----

> with(linalg): D:=jordan(A,’P’); evalm(P); # 2ème méthode: A= P D^n P^(-1)

Maple donne aussi P

Warning, the protected names norm and trace have been redefined and unprotected

[1 0]

D := [ ]

[0 4]

[ 1 2]

[ - -]

[ 3 3]

[ ]

[-1 1]

[-- -]

[3 3]

> Bn:=evalm( P &* diag(1,4^n) &* P^(-1)); # Même réponse (non reproduite).

16.10 Diverses notes sur les matrices

� Exercice : Produire les matrices Eij (ci-après)

42

> restart: for k from 1 to 2 do for l from 1 to 2 do g||k||l:=(x,y)->if x=k then if

y=l then 1 else 0 fi else 0 fi: E||k||l:=matrix(2,2,g||k||l) od; od; evalm(E||1||2);

� Puis une faute qui se crée avec ... -> ... et qui n’a pas lieu avec unapply :

> restart: f:=(P,Q)->int(P(t)*Q(t),t=-1..1)-int(D(P)(t)*D(Q)(t),t=-1..1); # Un p.s.

> for k from 1 to 2 do e||k:=unapply(t^(k-1),t) od; for k to 2 do u||k:=t->t^(k-1) od;

> A:=matrix(2,2, [seq(seq(f(e||i,e||j), j=1..2),i=1..2)]); # Matrice A juste

B:=matrix(2,2, [seq(seq(f(u||i,u||j),j=1..2),i=1..2)]); matrice B fausse.

� Pour forcer la simplification des matrices, retenir : > map(eval, A) ;� Pour chercher le Commutant d’une matrice A par exemple 2x2 :

> M:=matrix(2,2); N:=evalm(M &* A- A &* M);

s:=solve({seq(seq(N[i,j],j=1..2),i=1..2)}); assign(s); M1:=evalm(M); # etc

16.11 Des procédures assez faciles (Fonction, Fibonnacci, Moyenne)

� Une fonction : (Mais non utile ici ! Pour max(x, y)2 peut-être). On peut dire :

> f:=proc(x) x^2 end; f(4);

16

� Récursivité : pour n!

> fact:=proc(n) if n<=1 then 1 else n*fact(n-1) fi end:

� Suite de Fibonnacci : Mais bien voir rsolve (r pour récurrence), également :

> u[0]:=0 : u[1]:=1 : for k from 2 to 4 do u[k]:=u[k-1]+u[k-2] od;

u[2] := 1

u[3] := 2

u[4] := 3 # à comparer à

> Fib:=proc(n) local k, s ,u: if 1>n then print(1, ‘terme_nul‘) else u[0]:=0: u[1]:=1:

s:=0,1: for k from 2 to n do u[k]:=u[k-1]+u[k-2]: s:=s,u[k]: od fi: s=n+1,‘termes‘ end:

> Fib(8);

(0, 1, 1, 2, 3, 5, 8, 13, 21) = 9, termes

� Moyenne d’un nombre variable de notes ! et voir args nargs :

> moy:=proc() evalf(convert([args],‘+‘)/nargs) end:

> moy(13,15,16);

14.66666667

16.12 Polynômes de Tchebychev de 1ère espèce par récurrence (procédure possible)

Avec cos(n + 1)t + cos(n − 1)t = ... Pn+1(x) = 2x.Pn(x) − Pn−1(x) ; P0 = 1, P1(x) = x :

> P[0](x):=1 : P[1](x):=x : for k from 1 to 2 do

P[k+1](x):= simplify( 2*x*P[k](x)-P[k-1](x)) od; # simplify ou expand, bon aussi

2

P[2](x) := 2 x - 1

3

P[3](x) := 4 x - 3 x # A comparer avec:

> Tch:=proc(n) option remember; if n=0 then RETURN(1);

elif n=1 then RETURN(x); else RETURN(expand(2*x*Tch(n-1)-Tch(n-2))) fi end:

43

16.13 (*) Procédure pour une suite un+1 = f(un)

> tracé:= proc(f,u0, n,a,b)

> local s,k,u; u:=u0; s:=[u,0],[u,f(u)]; for k from 1 to n do u:=evalf(f(u));

s:=s,[u,u],[u,f(u)] od; plots[display]({plot([f(x),x], x=a..b,color=[blue,red],

scaling=constrained), plot([s],x=a..b,color=gold,thickness=3)},thickness=2,

tickmarks=[3,3]); end; # Voir plots[display] ou display( )

et plot(liste_de_points)

tracé := proc(f, u0, n, a, b)

local s, k, u; u := u0; s := [u, 0], [u, f(u)]; for k to n do

u := evalf(f(u)); s := s, [u, u], [u, f(u)]; end do;

plots[display]({

plot([f(x), x], x = (a .. b), color = [blue, red], scaling = constrained),

plot([s], x = (a .. b), color = gold, thickness = 3)}, thickness = 3,

tickmarks = [3, 3]); end proc; # Ce qu’affiche Maple

> tracé(x->cos(x), -1, 11, -1.1,1.3);

0-1

1

10

x

-1

16.14 Suite de Syracuse : on ne sait pas prouver le résultat observé !

Soit un entier naturel n ; s’il est pair, on divise par 2, s’il est impair, faire 3.n + 1 ;recommencer cette opération ; alors : on arrive toujours sur 1. (Mais on ne sait pas le prouver)

44

Déjà: iquo(23,4); irem(23,4); # Quotient Reste des entiers (integer)

(cf. quo rem pour polynômes)

5

3

> restart: f:= n-> if irem(n, 2)=0 then n/2 else 3*n+1 fi;

> g:= n-> if type(n, even) then n/2 else 3*n+1 fi; # convient aussi, on le voit :

> f(6); g(6); # Donnent tous deux la valeur 3

> s := seq( (f@@k)(6), k=0..20); # f composée avec f k fois: (f@@k)

s := 6, 3, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1

# Comment faire pour s’arrêter juste à temps ?

1. Une amélioration : (Ci-dessous r,s désigne la juxtaposition).

> restart: r:=9; n:= 0: s:= r: while s>1 do n:= n+1: if irem(s,2)=0

then s:= s/2 else s:= 3*s+1: fi: r:= r,s: od: r; NombreDePas =n ;

r := 9

9, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1

NombreDePas = 19

> r:=30; n:= 0: s:=r: while s>1 do n:= n+1: if irem(s,2)=0 then s:= s/2

else s:= 3*s+1: fi: r:= r,s: od: r; NombreDePas =n ;

r := 30

30, 15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1

NombreDePas = 18

2. On se limite maintenant au Nombre de Pas pour arriver à 1.

> for i from 1 to 30 do n:=0: s:=i: while s>1 do n:= n+1: if irem (s,2)=0

then s:=s/2 else s:=3*s+1: fi: od: N[i]:=n: od: seq(N[i],i=1..30);

0, 1, 7, 2, 5, 8, 16, 3, 19, 6, 14, 9, 9, 17, 17, 4, 12, 20, 20, 7, 7, 15,

15, 10, 23, 10, 111, 18, 18, 18 # Donc que pour 27, il faut 111 étapes!

16.15 Suite de Syracuse : 2ème façon. Avec une procédure.

> restart: f:= n-> if irem(n,2)=0 then n/2 else 3*n+1 fi :

> syracuse:= proc(n) if n=1 then RETURN(1) else a:= n: s:= a: for k from 1

while a>1 do a:= f(a): s:=s,a od: print(‘NombreDePas‘, k-1): s: fi: end:

# On a donné une réponse avec un test! Après RETURN la fonction s’arrête

Warning, ‘a‘ is implicitly declared local to procedure ‘syracuse‘

Warning, ‘s‘ is implicitly declared local to procedure ‘syracuse‘

Warning, ‘k‘ is implicitly declared local to procedure ‘syracuse‘

> syracuse(6); # A comparer avec ci-dessus

NombreDePas, 8

6, 3, 10, 5, 16, 8, 4, 2, 1

45

> syracuse(27);

NombreDePas, 111

27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364,

182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263,

790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377,

1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238,

1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077,

9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122,

61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1

# Tout va bien !

16.16 (*) Faire un tri ("à bulles"). Procédure encore

� On va faire un tri de valeurs dans une liste pour l’ordonner.� D’abord transposer :

> restart : L:=[9,11,5,211,1,1,0,-1]:

> transposer:= proc(L,i,j) M:=L: M[i]:=L[j]: M[j]:=L[i]: M; end:

Warning, ‘M‘ is implicitly declared local to procedure ‘transposer‘

> transposer(L,2,4); transposer(op(L),2,4); transposer([a,b,c,d,e],2,4);

[9, 211, 5, 11, 1, 1, 0, -1]

M # Rien de fait: il fallait une Liste !

[a, d, c, b, e]

. On est prêt pour tri "à bulles" (par propagation comme les bulles):

> provisoire:=proc(L) n:=nops(L): T:=L: print(Liste=L): i:=n: for j from 1 to

i-1 do if T[j]>T[j+1] then T:=transposer(T,j,j+1): fi: od: Triéeprovisoire=T: end:

> provisoire(L);

Liste = [9, 11, 5, 211, 1, 1, 0, -1] # On fait monter le plus

grand terme en haut.

Triéeprovisoire = [9, 5, 11, 1, 1, 0, -1, 211]

> tri:=proc(L) n:=nops(L): T:=L: print(Liste=L); for i from n to 2 by -1 do

for j to i-1 do if T[j]>T[j+1] then T:=transposer(T,j,j+1): fi: od: od: Triée=T: end:

> tri(L);

Liste = [9, 11, 5, 211, 1, 1, 0, -1] # ... le tri complet

Triée = [-1, 0, 1, 1, 5, 9, 11, 211]

> hasard:= rand(-10..20): N:= [seq(hasard(k),k=1..20)]; tri(N);

N := [11, 0, -4, -3, 0, -5, 7, 5, 0, 11, 15, 14, -7, 5, -2, 8, 19, 14, -3, 13]

Liste = [11, 0, -4, -3, 0, -5, 7, 5, 0, 11, 15, 14, -7, 5, -2, 8, 19, 14, -3, 13]

Triée = [-7, -5, -4, -3, -3, -2, 0, 0, 0, 5, 5, 7, 8, 11, 11, 13, 14, 14, 15, 19]

46

16.17 Exercices divers. 8) : (*) Encore un tri, corrigé.

1) Courbe de: f(x)=sin(x)^(cos(x)) en repère ORTHONORME ? # 1)2)3)4)5)6) non corrigés.

2) Que donne: g:=x->int(exp(-x.sin(t)), t=0..Pi); plot(g(x), x=-3..5,y=0..20);

3) Limite quand x tend vers a de (x^a-a^x)/(x-a)? Equivalent si a=e? [-(x-e)^2/ 2e]

4) Numériquement: voir que la suite u_n= sin( Pi.(n^2+1)^(1/2) ) tend vers 0 quand

n devient grand (100 à 150). Observer le signe de u_n.

5) Polynômes d’Hermite (cf. c) h[k])

a) Définir la fonction f qui à x associe exp(-x^2).

b) Dérivées successives sous forme factorisée f[1], f[2], f[3] (f[3]= dérivée 3ème)?

c) On pose h[n] = exp(x^2)*f[n] . Calculer et simplifier h[1], h[2], h[3], h[4], h[5]?

d) Calculer les racines des polynômes h[1], h[2], h[3] ...

e) Représenter h[1], h[2], h[3] ... sur un même repère orthonormé, x dans [-2,2].

6) On veut résoudre (par exemple) sin(x)=x/2 dans [0,Pi] de racine r=1,9 à peu près.

Pour celà, on pose g(x)=x+a(sin(x)-x/2): Trouver a (à peu près) pour que g’(r)=0.

Vérifier que la suite u[n+1]=g(u[n]) converge vite vers r. (20 décimales possibles)

7) Puissance de matrice (comme vu déjà et vérifier):

Soit A:=matrix(2,2,[1,2,4,3]); Calculer A^n avec A=PJP^(-1) en

voyant l’aide sur jordan (diagonalisation). Puis avec un polynôme annulateur?

8) Tri par insertion: on range les 2 premiers; puis le 3ème/ eux; etc. CORRIGE :

------------------

> tri2 := proc(L) T:=L: n:=nops(L): print(Liste=L): for k from 2 to n do for i from k-1

to 1 by -1 while T[i] > T[i+1] do T:=transposer(T,i,i+1): print(T) od: od: T end:

> tri2([-5,-8,9,-11,2]) ;

Liste = [-5, -8, 9, -11, 2]

[-8, -5, 9, -11, 2]

[-8, -5, -11, 9, 2]

[-8, -11, -5, 9, 2]

[-11, -8, -5, 9, 2]

[-11, -8, -5, 2, 9]

# Le dernier T avant end est inutile

[-11, -8, -5, 2, 9] ou alors on aurait pu écrire Triée=T

47

16.18 (*) Nombres et polynômes de Bernouilli

On a: (B[k])’=k.B[k-1] et intégrale B[k] sur [0,1] nulle. On part de B[0](x) qui vaut 1.

> restart ; B[0] := 1 ;

B[0] := 1

> P[1]:=int(B[0],x)+a; solve(int(P[1],x=0..1),a); B[1]:=subs(a=%,P[1]);

P[1] := x + a

-1

---

2

1

B[1] := x - - # On vient de faire B[1], on systématise

2

> for k from 1 to 3 do P[k]:=k*int(B[k-1],x)+a; solve(int(P[k],x=0..1),a):

B[k]:=subs(a=%,P[k]): od;

P[1] := x + a

-1

---

2

1

B[1] := x - -

2

2

P[2] := x - x + a

1

-

6

2 1

B[2] := x - x + -

6

3 3 2 1

P[3] := x - - x + - x + a

2 2

0

3 3 2 1

B[3] := x - - x + - x

2 2

> S:=seq( [Bernouilli[k]=B[k]] , k=1..3);

[ 1] [ 2 1] [ 3 3 2 1 ]

S:=[Bernouilli[1]= x- -], [Bernouilli[2]= x - x+ -], [Bernouilli[3]= x - - x + - x]

[ 2] [ 6] [ 2 2 ]

48

# (*) Utilité. A partir de B[p+1](n+1), on obtient somme des k^p k dans [0,n]

comme suit : ceci un thème de problème !

> factor( (subs(x=n+1,B[3])-subs(x=0,B[3]))/3 ); # est la somme des k^2 de 0 (!) à n.

1

- n (n + 1) (2 n + 1) # ... c’est vrai !

6

16.19 (*) Développée d’une courbe, sur un exemple. Procédure

> normale:=proc() local coords, X, Y, l, param, n, e; coords:=[op(1,args),

op(2,args)]; param:=op(3,args); n:=map(diff,coords,param);

l:=[X-coords[1],Y-coords[2]]; e:=linalg[dotprod](l,n,orthogonal); lprint(‘Eq de la

normale‘,param); print(e=0); [coeff(e,X),coeff(e,Y),-coeff(coeff(e,X,0),Y,0)]; end:

> normale([(1+cos(t))*cos(t),(1+cos(t))*sin(t),t]);

‘Eq de la normale‘, t

(X - (1 + cos(t)) cos(t)) (-sin(t) cos(t) - (1 + cos(t)) sin(t))

/ 2 \

+ (Y - (1 + cos(t)) sin(t)) \-sin(t) + (1 + cos(t)) cos(t)/ = 0

[ 2

[-sin(t) cos(t) - (1 + cos(t)) sin(t) , -sin(t) + (1 + cos(t)) cos(t) ,

(1 + cos(t)) cos(t) (-sin(t) cos(t) - (1 + cos(t)) sin(t))

/ 2 \]

+ (1 + cos(t)) sin(t) \-sin(t) + (1 + cos(t)) cos(t)/]

> with(plots): F:=implicitplot( {seq (subs(t=i/4 ,

(-sin(t)*cos(t)-(1+cos(t))*sin(t))*x + (-sin(t)^2+(1+cos(t))*cos(t))*y =

(1+cos(t))*cos(t)*(-sin(t)*cos(t)-(1+cos(t))*sin(t))+(1+cos(t))*sin(t)*(-sin(t)^2+

(1+cos(t))*cos(t))),i=-20..60)},x=-0.6..2.1,y=-1.3..1.4,color=red,scaling=constrained):

> G:=plot( [(1+cos(t))*cos(t),(1+cos(t))*sin(t), t=-2..8], color=blue, thickness=3):

> display( {F,G}, scaling=constrained, title=‘2_Beaux_Coeurs‘); # une solution.

2

0,5

1

1

1,5

x

0,5-0,5

-1

-0,5

00

y

2_Beaux_Coeurs

Cela parait bien difficile...

49

> with(plots): F:=implicitplot({seq(subs(t=i/5,

(-sin(t)*cos(t)-(1+cos(t))*sin(t))*x+( -sin(t)^2+(1+cos(t))*cos(t))*y=

(1+cos(t))*cos(t)*(-sin(t)*cos(t)-(1+cos(t))*sin(t))+(1+cos(t))*sin(t)*(-sin(t)^2+

(1+cos(t))*cos(t))),i=-20..10)},x=-0.6..2.1,y=-1.3..1.4,color=red,scaling=constrained):

> G:=plot([(1+cos(t))*cos(t),(1+cos(t))*sin(t),t=-2..8], color=blue,thickness=3):

> display({F,G},scaling=constrained); # La même aussi jolie (mais sans titre) !

x

y

2

1

0,5

1,50

-0,5

1

-1

0,50-0,5

  

16.20 Encore la même en plus simple (et plus belle) sans procédure !

> X_1:=(1+cos(t))*cos(t): Y_1:=(1+cos(t))*sin(t):

A:=plot([X_1,Y_1,t=0..10],color=blue,thickness=3):

> u:=diff(X_1,t); v:=diff(Y_1,t); w:=(Y_1)*diff(Y_1,t)+(X_1)*diff(X_1,t);

> s(t):=solve({u*x+v*y=w,diff(u,t)*x+diff(v,t)*y=diff(w,t)},{x,y}); assign(%);

> B:=plot([x,y,t=0..10],color=maroon,thickness=4): with(plots):

> C:=seq(implicitplot( subs(t=k*Pi/33.3, eq),X=subs(t=k*Pi/33.3,x) ..

subs(t=k*Pi/33.3,X_1) , Y=subs(t=k*Pi/33.3,y) ..subs(t=k*Pi/33.3,Y_1)),

k=1..70): display([A,B,C],scaling=constrained);

-0,5

20,5

1

0,5

-1

00 1 1,5

 

Ainsi on simplifie les choses et on améliore les dessins tout en même temps ! Donc courage...

50