Cours

Cours Maple

Vous devez vous identifier ou créer un compte pour écrire des commentaires

Chapitre 09 : Maple en géométrie

GEOMETRIE PLANE:

> restart;

Le package geometry contient des outils pour la géométrie plane :

> with(geometry);

La fonction point permet de définir un point du plan:
Syntaxes équivalentes: point(P, Px, Py) ou point(P, [Px, Py]).

Exemple: pour définir les points O(0,0) , A(-1,3) et B(4,2).

>

point(O,[0,0]):point(A,[-1,3]):point(B,[4,2]):

La fonction detail permet d'obtenir des informations sur un objet géométrique:

> detail(A);

$`name of the object: A\nform of the object: point...$
$`name of the object: A\nform of the object: point...$
$`name of the object: A\nform of the object: point...$

> point(M,X,Y):

La fonction line permet de définir une droite, dont on peut avoir l'équation.

> line(AB,[A,B]):Equation(AB,[x,y]);

La fonction triangle permet de définir un triangle , dont on peut avoir l'orthocentre , ou le centre

de gravité.

> triangle(OAB,[O,A,B]):orthocenter(H,OAB):coordinates(H);

> centroid(K,OAB):coordinates(K);

La fonction circle permet de définir un cercle, dont on peut avoir le centre, ou le rayon :

> circle(C,[O,A,B]):omega:=center(C):coordinates(omega);r:=radius(C);

> detail(C);

assume that the names of the horizontal and vertical axes are _x and _y, respectively

$`name of the object: C\nform of the object: circl...$
$`name of the object: C\nform of the object: circl...$
$`name of the object: C\nform of the object: circl...$
$`name of the object: C\nform of the object: circl...$
$`name of the object: C\nform of the object: circl...$
$`name of the object: C\nform of the object: circl...$

Calcul de la distance entre 2 points ou de la distance d'un point à une droite:

> distance(A,B);

> distance(M,AB);

Projeté d'un point sur une droite
projeté de M sur (AB):

> projection(P,M,AB):coordinates(P);

Equation de la parallèle ou de la perpendiculaire à une droite donnée passant par un point donné
d1 est la parallèle à (AB) passant par K, d2 est la perpendiculaire à (AB) passant par K:

> ParallelLine(d1,K,AB):Equation(d1,[x,y]);

> PerpendicularLine(d2,K,AB):Equation(d2,[x,y]);

> ArePerpendicular(d1,d2);

Intersection de 2 droites , d'une droite et d'un cercle , de 2 cercles

> intersection(i1,d1,d2):detail(i1);coordinates(i1);

$`name of the object: i1\nform of the object: poin...$
$`name of the object: i1\nform of the object: poin...$
$`name of the object: i1\nform of the object: poin...$

> intersection(i2,d1,C):detail(i2);

$[`name of the object: d1_intersect1_C\nform of the...$
$[`name of the object: d1_intersect1_C\nform of the...$
$[`name of the object: d1_intersect1_C\nform of the...$
$[`name of the object: d1_intersect1_C\nform of the...$
$[`name of the object: d1_intersect1_C\nform of the...$
$[`name of the object: d1_intersect1_C\nform of the...$

Tracé de la figure:

on remarquera le paramétrage des 2 droites d1 et d2 et du cercle C .

La fonction display du package plots permet de représenter sur un même graphique différents

objets graphiques précédemment définis , tels ici OAB , texte , etc ...

> with(plots):

> OAB:=plot([[HorizontalCoord(O),VerticalCoord(O)],[HorizontalCoord(A),VerticalCoord(A)],
[HorizontalCoord(B),VerticalCoord(B)],[HorizontalCoord(O),VerticalCoord(O)]],color=green):

> d1:=plot([HorizontalCoord(K)-5*t,VerticalCoord(K)+t,t=-2/3..3/4],numpoints=100,color=red):

> d2:=plot([HorizontalCoord(K)+t,VerticalCoord(K)+5*t,t=-0.5..0.75],numpoints=100,color=red):

> cercleC:=plot([HorizontalCoord(omega)+r*cos(t),VerticalCoord(omega)+r*sin(t),t=0..2*Pi],
numpoints=100,color=blue):

> texte:=textplot([[-1.15,3,`A`],[4+0.15,2,`B`],[1.8,5.2,`D2`],[-2,1.9,`D1`],[1.3,1.9,`K`]],color=black):

> display({OAB,d1,d2,cercleC,texte},scaling=constrained);

[Maple Plot]

AUTRES OUTILS DU PACKAGE LINALG POUR LA GÉOMÉTRIE:

Le package linalg d'algèbre linéaire contient également quelques outils utiles en géométrie

euclidienne, notamment:

dotprod (v1,v2) calcule le produit scalaire(hermitien) des vecteurs v1 et v2.

norm (v) calcule la norme du vecteur v.

crossprod (v1,v2) calcule le produit vectoriel des vecteurs v1 et v2 (en dimension 3).

GramSchmidt ({v1,v2,...,vn}) retourne la base orthogonale déduite de la famille {v1,v2,...,vn}

par le procédé de Gram-Schmidt.

> with(linalg):
v1:=vector([x1,y1,z1]);v2:=vector([x2,y2,z2]);

> dotprod(v1,v2);

> norm(v1);

> crossprod(v1,v2);

> v1:=vector([1,2,4]);v2:=vector([-1,6,5]);v3:=vector([2,0,3]);
GramSchmidt({v1,v2,v3});

Représentation de polygônes réguliers, et polygônes étoilés:

> opts := filled=true, style=patch, axes=none:
    point(o,0,0):
    s1 := draw( RegularPolygon(_r7, 7, o, 3), opts, title="{7}" ):
    s2 := draw( RegularStarPolygon(_r7_2, 7/2, o, 3), opts, title="{7/2}" ):
    s3 := draw( RegularStarPolygon(_r7_3, 7/3, o, 3), opts, title="{7/3}" ):
    s4 := draw( RegularPolygon(_r9, 9, o, 3), opts, title="{9}" ):
    s5 := draw( RegularStarPolygon(_r9_2, 9/2, o, 3), opts, title="{9/2}" ):
    s6 := draw( RegularStarPolygon(_r9_4, 9/4, o, 3), opts, title="{9/4}" ):
    s7 := draw( RegularPolygon(_r11, 11, o, 3),opts, title="{11}" ):
    s8 := draw( RegularStarPolygon(_r11_3, 11/3, o, 3), opts, title="{11/3}" ):
    s9 := draw( RegularStarPolygon(_r11_5, 11/4, o, 3), opts, title="{11/5}" ):
    plots[display](array(1..3,1..3,[[s1,s4,s7],[s2,s5,s8],[s3,s6,s9]]));

[Maple Plot]

GEOMETRIE DE L'ESPACE:

Le package geom3d contient des outils pour travailler la géométrie dans l'espace :

> with(geom3d);

La définition de points , de droites , de plans , se fait comme en dimension 2 par les fonctions

point , line , et plane .

On définit 4 points O,A,B,C:

> point(O,[0,0,0]):point(A,[-1,2,0]):point(B,[0,1,1]):point(C,[-1,2,1]):

> detail(A);

$`name of the object: A\nform of the object: point...$
$`name of the object: A\nform of the object: point...$
$`name of the object: A\nform of the object: point...$

d est la droite passant par A dirigée par U(1,2,-1)

> U:=[1,2,-1]:line(d,[A,U]):

> plane(P,[A,B,C]):Equation(P,[x,y,z]);
# équation du plan P=(ABC)

Un plan a une structure que l'on peut visualiser par detail :

> detail(P);

$`name of the object: P\nform of the object: plane...$
$`name of the object: P\nform of the object: plane...$
$`name of the object: P\nform of the object: plane...$

> parallel(Q, O, P):detail(Q);
# Q est le plan passant par O et parallèle à P

$`name of the object: Q\nform of the object: plane...$
$`name of the object: Q\nform of the object: plane...$
$`name of the object: Q\nform of the object: plane...$

> plane(P1,[O,A,B]):
intersection(delta,P1,P):detail(delta);
# delta est l'intersection des plans P1 et P , définie par un système paramétrique :

Warning, assume that the parameter in the parametric equations is _t

$`name of the object: delta\nform of the object: l...$
$`name of the object: delta\nform of the object: l...$
$`name of the object: delta\nform of the object: l...$

> ArePerpendicular(P,P1);

> distance(O,P);

> sphere(S,[O,A,B,C]):detail(S);

Warning, assume that the name of the axes are _x, _y and _z

$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$
$`name of the object: S\nform of the object: spher...$

> omega:=center(S):coordinates(omega);
# centre omega de la sphère S

> projection(proj,O,P):coordinates(proj);
# projeté de O sur le plan P

AUTRES OUTILS DU PACKAGE GEOM3D:

Des outils existent pour représenter des polyèdres, solides de l'espace éventuellement étoilés:

> octahedron(Oct,point(O,0,0,0),1.):
stellate(StOct,Oct,1):
draw( StOct, cutout=7/8, lightmodel=light4);

[Maple Plot]

> point(e1,10,15,0), point(e2,-10,15,0), point(e3,-10,-15,0),point(e4,10,-15,0):
    r1 := 1.: point(o1,-2,2,r1):tetrahedron(p1,o1,r1):
    r2 := 2.: point(o2,-4,5,r2):cube(p2,o2,r2):
    r3 := 5./2: point(o3,-7,8,r3):octahedron(p3,o3,r3):
    r4 := 3.: point(o4,-3,12,r4):dodecahedron(p4,o4,r4):
    r5 := 7./2: point(o5,3,18,r5):icosahedron(p5,o5,r5):
    r6 := 6.: point(o6,15,9,r6):GreatStellatedDodecahedron(p6,o6,r6):
    r7 := 9./2: point(o7,11,23,r7):GreatDodecahedron(p7,o7,r7):
    r8 := 7.: point(o8,17,-9,r8):SmallStellatedDodecahedron(p8,o8,r8):
    r9 := 15./2: point(o9,2,-11,r9):GreatIcosahedron(p9,o9,r9):
    fl := [[25,30,0],[-10,30,0],[-10,-20,0],[25,-20,0]]:
    pic1 := plots[polygonplot3d](fl,color=sienna):
    pic2 := draw([seq(p||i,i=1..9)],color=COLOR(RGB,.9335294125,.9129411760,.5205882350)):
    plots[display]([pic2,pic1],style=patch,orientation=[-97,52],title="Les neuf polyèdres réguliers",
     lightmodel=light4);

[Maple Plot]

Exercice corrigé 9:

Déterminer et représenter la surface S, ensemble des points M dont la somme des

carrés des distances aux droites d1: y=x , z= 1 et d2 : y=-x , z=-

1 est égale à 3.

> restart:with(geom3d):

d1 est l'intersection de 2 plans p1 et q1:

> plane(p1,y-x=0,[x,y,z]):plane(q1,z-1=0,[x,y,z]):intersection(d1,p1,q1):

d2 est l'intersection de 2 plans p2 et q2:

> plane(p2,y+x=0,[x,y,z]):plane(q2,z+1=0,[x,y,z]):intersection(d2,p2,q2):

Définition d'un point quelconque M:

> point(M,X,Y,Z):

Equation et représentation de S:

> S:=distance(M,d1)^2+distance(M,d2)^2-3;

> with(plots):

> implicitplot3d(S,X=-1..1,Y=-1..1,Z=-1/sqrt(2)..1/sqrt(2),numpoints=300,color=blue,axes=BOXED);

[Maple Plot]

Il s'agit d'un ellipsoide d'équation X^2+Y^2+2*Z^2 = 1 de centre O.

Travail dirigé 9:

Soit ABC un triangle du plan affine euclidien , M un point quelconque que l'on projette

orthogonalement en H1,H2,H3 sur (BC) , (CA) , (AB) respectivement .

Montrer que M est sur le cercle circonscrit à ABC si et seulement si H1,H2,H3 sont

alignés, sur la droite dite de Simson associée à M:

On travaillera dans un repère orthonormal tel que A(0,0) , B(1,0) , C(-2,3).

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 08 : Maple en algèbre linéaire

FONCTIONS DE BASE:

> restart;

Les vecteurs et les matrices peuvent être définis comme des tableaux rectangulaires, par la

fonction array , rencontrée dans le chapitre sur les tableaux :

Vecteur-ligne d'ordre 3 sans initialisation:

> A:=array(1..3);

Vecteur-ligne d'ordre 3 avec initialisation:

> B:=array([x,y,z]);

Vecteur-colonne d'ordre 3 sans initialisation:

> U:=array(1..3,1..1);print(U);

matrix([[U[1,1]], [U[2,1]], [U[3,1]]])

Vecteur-colonne d'ordre 3 avec initialisation:

> V:=array([[x],[y],[z]]);

V := matrix([[x], [y], [z]])

Matrice carrée d'ordre 2 sans initialisation:

> M:=array(1..2,1..2);print(M);

matrix([[M[1,1], M[1,2]], [M[2,1], M[2,2]]])

Matrice carrée d'ordre 2 avec initialisation:

> N:=array([[a,b],[c,d]]);

N := matrix([[a, b], [c, d]])

Opérations sur les vecteurs et les matrices , avec la fonction evalm :

Somme de vecteurs ou de matrices de même dimension avec +

> evalm(A+U);

matrix([[A[1]+U[1,1]], [A[2]+U[2,1]], [A[3]+U[3,1]]...

Multiplication de vecteurs ou de matrices de dimensions compatibles avec &*

> evalm(M &* N);

matrix([[M[1,1]*a+M[1,2]*c, M[1,1]*b+M[1,2]*d], [M[...

Calcul de la matrice inverse, lorsque N est inversible, avec ^(-1)

> evalm(N^(-1));

matrix([[d/(a*d-b*c), -b/(a*d-b*c)], [-c/(a*d-b*c),...

Puissance n-ième avec ^n

> evalm(N^3);

matrix([[(a^2+b*c)*a+(a*b+b*d)*c, (a^2+b*c)*b+(a*b+...

Multiplication par un scalaire avec *

> evalm(2*M-5*N);

matrix([[2*M[1,1]-5*a, 2*M[1,2]-5*b], [2*M[2,1]-5*c...

LES OUTILS DU PACKAGE linalg:

Le package linalg contient plus d'une centaine d'outils en algèbre linéaire:

> with(linalg);

Les fonctions matrix et vector permettent de définir respectivement une matrice (tableau

rectangulaire d'objets) ou un vecteur (tableau d'objets à une seule ligne) :

Définition d'une matrice 2x4 :

> P:=matrix([[s,t,u,v],[w,x,y,z]]);

P := matrix([[s, t, u, v], [w, x, y, z]])

Définition d'un vecteur-ligne d'ordre 4 et d'une matrice-colonne d'ordre 3:

> V:=vector([a,b,c,d]);

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

C := matrix([[1], [2], [3]])

Une matrice a le type matrix , un vecteur a le type vector .

Opérations sur les matrices:

A la place de la fonction evalm , on peut utiliser les outils spécifiques du package linalg :

Multiplication de vecteurs ou de matrices de dimensions compatibles avec multiply

> multiply(M,N);

matrix([[M[1,1]*a+M[1,2]*c, M[1,1]*b+M[1,2]*d], [M[...

Calcul de la matrice inverse,lorsque N est inversible, avec inverse

> inverse(N);

matrix([[d/(a*d-b*c), -b/(a*d-b*c)], [-c/(a*d-b*c),...

Multiplication par un scalaire avec scalarmul

> scalarmul(P,lambda);

matrix([[lambda*s, lambda*t, lambda*u, lambda*v], [...

Test d'égalité de deux matrices avec equal

> equal(M,N);

Etude d'une matrice:

Déterminant et trace d'une matrice carrée (somme des éléments diagonaux):

> N:=matrix([[1,2],[4,-3]]);det(N);trace(N);

N := matrix([[1, 2], [4, -3]])

Rang d'une matrice:

> rank(N);

kernel(A); ou nullspace(A); détermine une base du noyau de A
colspace(A); détermine une base du sous-espace engendré par les vecteurs-colonnes de A
rowspace(A); détermine une base du sous-espace engendré par les vecteurs-lignes de A

> A:=matrix([[2,-2],[-1,1]]);kernel(A);

A := matrix([[2, -2], [-1, 1]])

> colspace(A);

> rowspace(A);

Matrice caractéristique: , .

> charmat(A,lambda);

matrix([[lambda-2, 2], [1, lambda-1]])

> charpoly(A,lambda);

Valeurs propres de A (ce sont les racines du polynôme caractéristique):

> eigenvals(A);

Un vecteur propre associé à la valeur propre est un vecteur X non nul tel que .

> eigenvects(A);

Le résultat affiché signifie que est une valeur propre d'ordre 1 de vecteur propre associé

et que est une valeur propre d'ordre 1 de vecteur propre associé .

Modification d'une matrice:

> print(P);

matrix([[s, t, u, v], [w, x, y, z]])

row(P,k) permet d'extraire la k-ième ligne de la matrice P. Le résultat est un vecteur.

col(P,k) permet d'extraire la k-ième colonne de la matrice P. Le résultat est un vecteur.

> row(P,2),col(P,3);

rowdim(P) et coldim(P) retournent le nombre de lignes et de colonnes de la matrice P .

> rowdim(P),coldim(P);

augment(M1,M2,...,Mn) permet de concaténer horizontalement les n matrices M1,M2,...,Mn :

> augment(A,P);

matrix([[2, -2, s, t, u, v], [-1, 1, w, x, y, z]])

stackmatrix(M1,M2,...,Mn) permet de concaténer verticalement les n matrices M1,M2,...,Mn :

> stackmatrix(A,N);

matrix([[2, -2], [-1, 1], [1, 2], [4, -3]])

copyinto(M,N,m,n) : copie M dans N , l'élément M[1,1] étant copié en

> copyinto(N,P,1,2);

matrix([[s, 1, 2, v], [w, 4, -3, z]])

swapcol(M,m,n) et swaprow(M,m,n) permettent d'échanger les colonnes (ou les lignes)

m et n de la matrice M :

> swaprow(A,1,2);

matrix([[-1, 1], [2, -2]])

transpose(M) permet de transposer la matrice M :

> print(M);transpose(M);

matrix([[M[1,1], M[1,2]], [M[2,1], M[2,2]]])

matrix([[M[1,1], M[2,1]], [M[1,2], M[2,2]]])

addcol(M,m,n,k) ou addrow(M,m,n,k) rendent une matrice obtenue à partir de M par

l'opération col n := col n + k * col m (respectivement lig n := lig n + k * lig m ) :

> print(N);addcol(N,1,2,mu);

matrix([[1, 2], [4, -3]])

matrix([[1, mu+2], [4, 4*mu-3]])

Matrices particulières:

> vandermonde([a,b,c,d]);

matrix([[1, a, a^2, a^3], [1, b, b^2, b^3], [1, c, ...

> JordanBlock(expr,4);

matrix([[expr, 1, 0, 0], [0, expr, 1, 0], [0, 0, ex...

LES OUTILS DU PACKAGE LinearAlgebra:

A partir de la version 7, existe dans Maple un nouveau package LinearAlgebra avec

des outils similaires à ceux du package linalg et destiné à supplanter l'ancien. En voici les fonctions:

> with(LinearAlgebra);

On définit une matrice A dont on calcule le déterminant, la matrice et le polynôme caractéristique,

ainsi que les valeurs propres et vecteurs propres associés:

> A:=Matrix([[1,-1,-1],[-2,2,3],[2,-2,-3]]);
    Determinant(A);
    CharacteristicMatrix(A,lambda);
    factor(CharacteristicPolynomial(A,lambda));
    Eigenvalues(A);
    Eigenvectors(A);

A := _rtable[4468540]

_rtable[14270440]

_rtable[14253092]

_rtable[14253172], _rtable[14279184]

Exercice corrigé 8:

Rechercher les matrices carrées X d'ordre 2 telles que X^2+X = A , où A := MATRIX([[1, 1], [1, 1]]) .

> with(linalg):A:=matrix(2,2,1);X:=matrix(2,2):

A := matrix([[1, 1], [1, 1]])

> Y:=evalm(X^2+X-A);

Y := matrix([[X[1,1]^2+X[1,2]*X[2,1]+X[1,1]-1, X[1,...

> Y:={seq(seq(Y[i,j],j=1..2),i=1..2)};

$Y := {X[1,1]^2+X[1,2]*X[2,1]+X[1,1]-1, X[1,2]*X[2,1...$
$Y := {X[1,1]^2+X[1,2]*X[2,1]+X[1,1]-1, X[1,2]*X[2,1...$

> solutions:={solve(Y)}:
    for k to nops(solutions) do
        X:=matrix(2,2):assign(solutions[k]):print(X);
    end do:

matrix([[0, 1], [1, 0]])

matrix([[-3/2, -1/2], [-1/2, -3/2]])

matrix([[1/2, 1/2], [1/2, 1/2]])

matrix([[-1, -1], [-1, -1]])

Donc 4 matrices solutions.

Travail dirigé 8:

TD 8.1:

Ecrire une procédure pcd(L::list) retournant à partir d'une liste donnée L la liste obtenue par

permutation circulaire vers la droite des éléments de L .

Exemple:

> pcd([a,b,c,d,e,f,g]);

TD 8.2:

Ecrire une procédure circulante_droite(n::posint) retournant à partir de l'entier n> 0

une matrice carrée d'ordre n telle que

- sa première ligne est constituée par les entiers de 1 à n .

- pour k> 1 , sa k-ième ligne est déduite de la ligne précédente par permutation

circulaire vers la droite de ses éléments.

Exemple:

> circulante_droite(5);

matrix([[1, 2, 3, 4, 5], [5, 1, 2, 3, 4], [4, 5, 1,...

TD 8.3:

Test d'égalité de 2 matrices:

2 matrices M et N sont égales si et seulement si elles ont même nombre de lignes, même

nombre de colonnes, et les mêmes coefficients .

Sans avoir recours à la fonction préexistante equal de Maple, écrire une procédure

egal(M: : matrix , N: : matrix) retournant la valeur booléenne true si M=N et false sinon.

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 07 : Maple en analyse

FONCTIONS NUMÉRIQUES:

Domaine de définition: la fonction singular permet de déterminer les singularités de certaines fonctions:

> restart;
singular(tan(x));

${x = _Z1*Pi+1/2*Pi}$

Continuité: la fonction iscont permet de déterminer la continuité de certaines fonctions.

closed signifie que l'intervalle est fermé.MAPLE travaille par défaut sur des intervalles ouverts.

> iscont(tan(x),x=-Pi/2..Pi/2,closed);

> iscont(tan(x),x=-Pi/2..Pi/2);

Image d'une réunion d'intervalles fermés , avec la fonction evalr :

> evalr((x->x^2)(INTERVAL(-1..-0.5)));

Extrema d'une fonction , avec les fonctions minimize et maximize :

> minimize(x^2+x-3),maximize(-x^4+x^2+1);

Fonctions définies par intervalles:
piecewise permet de définir une fonction à partir de conditions sur différents
intervalles: piecewise (cond1,f1, cond2,f2, ..., condN,fN, f_autrement)

> f:=piecewise(x<0,exp(x),x<=4,x/4+1,2);

f := PIECEWISE([exp(x), x < 0],[1/4*x+1, x <= 4],[2...

> plot(f(x),x=-4..8);

[Maple Plot]

Limites: avec la fonction limit(expr, x=a , option)

option = left , right .

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

> limit(1/x^3,x=0);

Utilisation de la forme inerte Limit :

> Limit(1/x^3,x=0,right) = limit(1/x^3,x=0,right);

Limit(1/(x^3),x = 0,right) = infinity

Etude locale: avec taylor(expr , x=a , n) pour les développements limités ou de Taylor,

series(expr , x=a , n) ou asympt(expr , x , n) pour des développements asymptotiques plus

généraux. L'ordre n est facultatif et vaut 6 par défaut .

> taylor(sin(x),x); # a=0 par défaut

> taylor(x^2/(x^2+1),x=infinity,10);

1-1/(x^2)+1/(x^4)-1/(x^6)+1/(x^8)+O(1/(x^10))

> series(exp(x)/x,x,9); # a=0 par défaut

> asympt(ln(x+1/x),x,7); # toujours en plus l'infini

ln(x)+1/(x^2)-1/2*1/(x^4)+1/3/x^6+O(1/(x^7))

> asympt(Sum(1/k,k=1..n)-ln(n),n,10); # la constante d'Euler gamma

32287/55440-O(1)+1/2/n-1/12*1/(n^2)+1/120/n^4-1/252...

> evalf(gamma);

leadterm donne le terme principal d'une série:

> series(leadterm(sin(x^3)/(2*x)),x=0);

Conversion en polynôme de Taylor:

> P:=convert(taylor(exp(x),x=0,5),polynom);

Dérivation:

Pour dériver une fonction , utiliser diff(expr,v1,v2,...,vn) qui calcule la dérivée partielle de expr

par rapport aux variables v1,v2,...,vn .

> Diff(x/(x^2+y^2),x,y)=diff(x/(x^2+y^2),x,y); # équivaut à Diff(x/(x^2+y^2),x,y): % = value(%);

Diff(x/(x^2+y^2),x,y) = -2/(x^2+y^2)^2*y+8*x^2/(x^2...

Noter l'absence de parenthèses dans l'écriture du premier membre .

On peut utiliser l'opérateur $ pour éviter de répéter plusieurs fois une variable :

> Diff(x/(x^2+y^2),x$2,y) : % = value(%);

Diff(x/(x^2+y^2),`$`(x,2),y) = 24/(x^2+y^2)^3*x*y-4...

Opérateur différentiel D: D( f ) retourne la fonction dérivée première de f
Fonctions dérivées première et seconde:

> D(sin),(D@@2)(sin);

> D(x->x*sin(x)-x);

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

fonction dérivée par rapport à x,y , et z respectivement :

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

D[i,j](f) équivaut à D[i](D[j](f)) :

> D[1,2](f);

SUITES ET SÉRIES:

Suites définies par des sommes ou des produits:

> Sum(k^2,k=1..n) : % = factor(value(%));

Sum(k^2,k = 1 .. n) = 1/6*n*(n+1)*(2*n+1)

> Product(k/(k+1),k=1..n) : % = simplify(value(%));

Product(k/(k+1),k = 1 .. n) = 1/(n+1)

Développement asymptotique de la somme partielle d'une série:

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

1/6*Pi^2-1/n+1/2/n^2-1/6*1/(n^3)+1/30/n^5+O(1/(n^6)...

Suites récurrentes:

Type :

Exemple: , calcul de , pour ,..,15.

> f:=x->cos(x):n:=15:u[0]:=-1:
for k to n do u[k]:=evalf(f(u[k-1])) end do:

On peut représenter graphiquement la convergence de la suite en construisant une liste T formée

des points (u(0),0) , (u(0),u(1)) , (u(1),u(1)) , (u(1),u(2)) , etc...

> T:=array(1..4*n,[u[0],0,u[0],f(u[0])]):
    for k from 2 to 2*n-1 do
        T[2*k+1]:=T[2*k]:
        if is(k,odd) then T[2*(k+1)]:=evalf(f(T[2*k+1])) else
            T[2*(k+1)]:=evalf(T[2*k+1])
        end if
    end do:
    T:=convert(T,list):U:=NULL:
    for k to nops(T)-1 by 2 do
        U:=U,[T[k],T[k+1]]
    end do:     U:=plot([U],color=blue):G:=plot({f(x),x},x=-1.3..1.3,scaling=constrained):plots[display]({G,U},title="point fixe du cosinus",view=[-1.3..1.3,-1.3..1.3]);

[Maple Plot]

Type :

Exemple: u(0) = 1, v(0) = 4, u(n+1) = sqrt(u(n)*v(n)), v(n+1... .

> u[0]:=1:v[0]:=4:n:=15:
    for k to n do
        u[k]:=evalf(sqrt(u[k-1]*v[k-1])):v[k]:=(u[k-1]+v[k-1])/2
    end do:

Type :

Exemple: .

> u[0]:=0:u[1]:=4:n:=15:
for k from 2 to n do u[k]:=evalf(sqrt(u[k-1]+u[k-2])) end do:

Résolution de récurrences , avec la fonction rsolve .

Une suite arithmétique de raison -3:

> restart:rsolve(w(n+1) = w(n)-3,w);

Une suite géométrique avec condition initiale:

> rsolve({w(n+1)=w(n)/3,w(0)=-7},w);

-7*(1/3)^n

La suite de Fibonacci:

> rsolve({fib(n+2)=fib(n+1)+fib(n),fib(0)=0,fib(1)=1},fib);

(1-1/5*sqrt(5))*(2*1/(-1+sqrt(5)))^n/(-1+sqrt(5))+(...

Séries numériques:

Somme d'une série de Riemann convergente:

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

La série harmonique est divergente:

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

Calcul de la somme d'une série de fonctions

> Sum(sin(x)^k,k=1..infinity)=sum(sin(x)^k,k=1..infinity);

Sum(sin(x)^k,k = 1 .. infinity) = -sin(x)/(sin(x)-1...

Le package powseries contient des fonctions mettant en jeu les séries entières:

Consulter les pages d'aide de powseries pour plus de précision.

> with(powseries);

> sh := evalpow( sinh(x) ): tpsform(sh, x, 9);

INTÉGRATION:

Le calcul des primitives et des intégrales se fait avec la fonction int .

Syntaxes: int(expr , x) et int(expr, x=a..b) .

> Int(x/(x^4+1),x)=int(x/(x^4+1),x);
# équivaut à Int(x/(x^4+1),x) : % = value(%);

Int(x/(x^4+1),x) = 1/2*arctan(x^2)

> Int(x/(x^4+1),x=0..1) : % = value(%);

Int(x/(x^4+1),x = 0 .. 1) = 1/8*Pi

Intégrale généralisée convergente:

> Int(x/(x^4+1),x=0..infinity) : % = value(%);

Int(x/(x^4+1),x = 0 .. infinity) = 1/4*Pi

Intégrale généralisée divergente:

> Int(exp(x)/x,x=1..infinity) : % = value(%);

Int(exp(x)/x,x = 1 .. infinity) = infinity

Le package inttrans contient quelques outils pour la transformation d'intégrales.

Consulter les pages d'aide de inttrans pour plus de précision.

> with(inttrans);

La transformée de Laplace de f est définie par = Int(f(t)*exp(-s*t),t = 0 .. infinity) .

> laplace(sin(omega*t), t, s);

omega/(s^2+omega^2)

Quelques outils du package student :

> with(student);

Changement de variables dans les intégrales: changevar(eq , intégrale , u)

eq est l'équation du changement de variable de la forme f(x)=g(u) , intégrale est l'intégrale

et u la nouvelle variable d'intégration :

> J:=Int(t/((t^2+1)*sqrt(1-t^4)),t=0..1);

J := Int(t/(t^2+1)/(1-t^4)^(1/2),t = 0 .. 1)

> changevar(t^2=u,J,u):% = value(%);

Int(1/2*1/((u+1)*sqrt(1-u^2)),u = 0 .. 1) = 1/2

Intégration par parties , avec la fonction intparts(intégrale,u) , u est le facteur à dériver.

> J:=Int(x^2*arccos(x),x):intparts(J,arccos(x));

1/3*arccos(x)*x^3-Int(-1/3/(1-x^2)^(1/2)*x^3,x)

> J:=value(%);

METHODES D'APPROXIMATION D'INTEGRALES:

METHODE DES RECTANGLES: On découpe [a,b] en n intervalles de même longueur

extrémité gauche :

représentation avec leftbox(expr,x=a..b,n) , calcul avec leftsum(expr,x=a..b,n)

extrémité droite :

représentation avec rightbox(expr,x=a..b,n) , calcul avec rightsum(expr,x=a..b,n)

point médian :

représentation avec middlebox(expr,x=a..b,n) , calcul avec middlesum(expr,x=a..b,n)

METHODE DES TRAPEZES: calcul avec trapezoid(expr,x=a..b,n)

METHODE DE SIMPSON:

calcul avec simpson(expr,x=a..b,n)
, avec
n
pair.

Exemple:
avec f:
proc (x) options operator, arrow; exp(-x^2) end pro...

>

middlebox(exp(-x^2),x=-1..1,20);middlesum(exp(-x^2),x=-1..1,20);evalf(%);

[Maple Plot]

1/10*Sum(exp(-(-19/20+1/10*i)^2),i = 0 .. 19)

>

evalf(trapezoid(exp(-x^2),x=-1..1,20));

>

evalf(simpson(exp(-x^2),x=-1..1,20));

Calcul d'intégrales doubles ou triples:

>

Doubleint(x^3*y-x^2-y*x,x=-a..a,y=-b..b):%=value(%);

Int(Int(x^3*y-x^2-y*x,x = -a .. a),y = -b .. b) = -...

>

Tripleint(x*y*z*sin(x+y+z),x=0..Pi,y=-Pi..Pi,z=0..Pi):%=value(%);

Int(Int(Int(x*y*z*sin(x+y+z),x = 0 .. Pi),y = -Pi ....

ÉQUATIONS ET SYSTÈMES DIFFÉRENTIELS:

Equations du premier ordre: MAPLE sait résoudre directement les équations de type classique

- linéaire - avec facteur intégrant - séparable - homogène - résolue en x - de Bernoulli - de Clairaut

- de Riccati .

Équation y ' + 3 y = exp(-x)

> restart:eq:=diff(y(x),x)+3*y(x)=exp(-x):dsolve(eq,y(x));

_C1 désigne une constante réelle arbitraire.

La même avec la condition initiale

> dsolve({eq,y(0)=1.5},y(x));

Les solutions y(x) ne sont pas directement utilisables : en assignant la solution à y(x) on peut utiliser le résultat , par exemple pour représenter les courbes intégrales :

> assign(dsolve(eq,y(x))):y:=unapply(y(x),_C1,x);

> plot({seq(y(_C1,x),_C1=-3..3)},x=-5..5,y=-20..20);

[Maple Plot]

On peut préciser des options de résolution : explicit (pour tenter d'exprimer la solution comme

fonction explicite de la variable) , series (chercher les solutions sous forme de séries)

> eq:={diff(z(x),x)+z(x)*cos(x)=1,z(0)=1}:
dsolve(eq,z(x));dsolve(eq,z(x),series);

z(x) = exp(-sin(x))*Int(exp(sin(u)),u = 0 .. x)+exp...

La fonction odeplot du package plots permet de représenter les solutions d'une équation différentielle:

> with(plots,odeplot):
p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric): odeplot(p,[x,z(x)],-2..2,title="Fonction exponentielle");

[Maple Plot]

Equations du second ordre: MAPLE sait résoudre directement les équations de type classique

- linéaire - d'Euler - de Bessel .

Équation y " + y ' + y = t

> restart:eq2:=diff(y(t),t$2)+diff(y(t),t)+y(t)=t;

eq2 := diff(y(t),`$`(t,2))+diff(y(t),t)+y(t) = t

> dsolve(eq2,y(t));

y(t) = exp(-1/2*t)*sin(1/2*sqrt(3)*t)*_C2+exp(-1/2*...

La même avec conditions initiales:

> dsolve({eq2,y(0)=0,D(y)(0)=-1},y(t));

y(t) = -exp(-1/2*t)*sin(1/2*sqrt(3)*t)*sqrt(3)+exp(...

Les options de résolution sont les mêmes qu'à l'ordre 1.

Systèmes différentiels:

Exemple: résoudre x ' =x- 2 y , y ' = 2 x+ 3 y . Représenter la solution vérifiant x (0) = 0 et y( 0) = 1 .

> restart:sys:=diff(x(t),t)=x(t)-2*y(t),diff(y(t),t)=2*x(t)+3*y(t):
dsolve({sys},{x(t),y(t)});

${x(t) = exp(2*t)*(_C1*sin(sqrt(3)*t)+_C2*cos(sqrt(3...$
${x(t) = exp(2*t)*(_C1*sin(sqrt(3)*t)+_C2*cos(sqrt(3...$

> p:=dsolve({sys,x(0)=0,y(0)=1},{x(t),y(t)},numeric):
with(plots):odeplot(p,[[t,x(t)],[t,y(t)]],-1..2);

[Maple Plot]

Résolution d'équations aux dérivées partielles:

> edp:=y*diff(U(x,y),x)+x*diff(U(x,y),y)=0;

> pdsolve(edp,U(x,y) );

_F1 désigne une fonction arbitraire de classe C1 de la variable -x^2+y^2 .

Travail dirigé 7:

Soit f la fonction définie pour tout réel x >0 par f(x) = x^(x/(1-x)) .

1° Etablir les singularités de la fonction f et vérifier sa continuité.

2° Etudier les limites de f aux bornes des intervalles composant Df.

Quelle est l'asymptote de la courbe Cf de f ?

3° Calculer f '( x ) et étudier son signe ( on aura recours à une fonction auxiliaire g ).

4° Représenter la courbe Cf.

5° Etudier la dérivabilité du prolongement par continuité de f aux points 0 et 1.

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 06 : Graphisme avec Maple

GRAPHIQUES EN DIMENSION 2:

La fonction smartplot constitue la façon la plus simple de représenter une ou plusieurs fonctions :
Par défaut , le range est -10..10.

> smartplot(cos(2*x)+sin(x),x);

[Maple Plot]

Pour représenter une ou plusieurs fonctions, utiliser plot(f , h , v) ou plot(f, h, v,...) où

f : fonction(s) représentée(s) , h et v : intervalle horizontal et vertical (optionnels).

La syntaxe la plus simple est plot(f) ou plot(f(x),x=a..b) :

> f:=x->cos(2*x)+sin(x):plot(f(x),x=-2*Pi..2*Pi);

[Maple Plot]

Les arguments restants sont des options que l'on peut spécifier par des équations de la forme option = valeur.

scaling = CONSTRAINED (repère orthonormal) ou UNCONSTRAINED (repère non

orthonormal) .Par défaut : UNCONSTRAINED.

axes = Spécifie le type d'axes : FRAMED , BOXED, NORMAL , et NONE.

coords = polar Indique une courbe paramétrique en coordonnées polaires.

numpoints = n Spécifie le nombre minimum de points à être générés (défaut n = 49 ).

resolution = n Spécifie la résolution horizontale en pixels (défaut n = 200 ).

color = n Spécifie la couleur des courbes à tracer .

xtickmarks = n ytickmarks = n Spécifie le nombre de graduations sur l'axe des x ou des y .

style = s Spécifie le style du tracé : par défaut LINE

POINT (tracé point par point) , LINE (points reliés par des segments)

PATCH (style pour les polygones) , SPLINE (points reliés par une courbe spline)

discont = s Mettre s à la valeur booléenne true pour des fonctions discontinues

title = t Spécifie le titre pour le graphique ( t de type string ).

thickness = n Spécifie l'épaisseur du trait , ( n = 0, 1, 2 , ou 3 , défaut : 0 ).

linestyle = n Spécifie le motif des lignes tracées (lignes pleines : 0 et 1, d'autres valeurs plus grandes donnent des pointillés par exemple).

symbol = s Spécifie le symbole de représentation d'un point : BOX, CROSS, CIRCLEPOINT, et DIAMOND.

font = liste Polices des caractères affichés . liste est une liste [famille, style, taille] ,

famille : TIMES, COURIER, HELVETICA, SYMBOL.

Pour TIMES, le style est ROMAN, BOLD, ITALIC ou BOLDITALIC.

Pour HELVETICA et COURIER style omis ou BOLD, OBLIQUE, ou

BOLDOBLIQUE. Pour SYMBOL , pas de style .

titlefont = liste , axesfont = liste , labelfont = l iste Polices des caractères affichés pour le titre,les graduations des axes,les légendes des axes (pour liste , voir font = liste).

view=[xmin .. xmax,ymin .. ymax] Spécifie la zone de dessin à représenter à l'écran .

Représenter un ensemble de plusieurs courbes:

> plot({sin(x),x, x-x^3/6}, x=-2..2,thickness=2,scaling=CONSTRAINED);

[Maple Plot]

Intervalle à borne infinie:

> plot(sin(x)/x, x=0..infinity);

[Maple Plot]

Représenter des points: on donne la liste des coordonnées, abscisse puis ordonnée.

> plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2, style=point);

[Maple Plot]

Représenter des lignes brisées: même principe que pour les points, en enlevant style=point .

> plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2);

[Maple Plot]

Courbe en coordonnées polaires: plot([r(t),theta(t),t=a..b],coords=polar,...)

> plot([sin(4*t),t,t=-2*Pi..2*Pi],coords=polar,thickness=2,font=[HELVETICA,BOLD,8],title="R=sin 4t",color=red);

[Maple Plot]

On obtient le même résultat en utilisant la fonction polarplot du package plots :

> with(plots):polarplot([sin(4*t),t,t=-2*Pi..2*Pi],thickness=2,font=[HELVETICA,BOLD,8],title="R=sin 4t",color=red);

Courbe paramétrée: plot([x(t),y(t),t=a..b],...)

> plot([cos(2*t)+2*cos(t),sin(2*t),t=0..2*Pi],color=blue);

[Maple Plot]

OUTILS 2D DU PACKAGE plots:

Le package plots fournit d'autres outils graphiques pour la dimension 2 :

> with(plots);

Citons , entre autres :

La fonction animate , qui permet de créer des animations dans une fenêtre dont la barre d'outils

comporte des touches identiques à celles d'un lecteur de cassettes :

Exemple: famille de paraboles dépendant de m

> animate(m*x^2,x=-3..3,m=-10..10);

Tracer des courbes définies implicitement sous la forme f(x,y)=0 avec implicitplot

> implicitplot(x^3+x-y^2+1=0,x=-10..10,y=-10..10);

[Maple Plot]

Visualiser un champ de vecteurs avec fieldplot , ( arrows = LINE,SLIM,THIN ou THICK)

> fieldplot([x*x-y*y,2*x+y^3],x=-1..1,y=-1..1,arrows=SLIM);

[Maple Plot]

gradplot permet de visualiser un champ de gradients .

logplot , loglogplot donnent une graduation logarithmique sur l'axe des y ou les 2 axes

odeplot permet de tracer les courbes intégrales d'une équation différentielle.

textplot permet d'écrire sur un dessin .

densityplot et contourplot permettent de tracer respectivement des graphes de densité ou

des courbes de niveau.

display permet de représenter plusieurs objets graphiques de nature éventuellement différentes

sur un même graphique. L'option insequence=true permet de le transformer en animation.

Exemple: tracé du cercle c de centre O de rayon 1, de la droite d: , de l'ellipse e

d'équation x^2/4+y^2 = 1 ,dans un même repère orthonormal.

> c:=plot([cos(t),sin(t),t=0..2*Pi],color=blue):
    d:=plot(x,x=-2..2,color=black):
    e:=implicitplot(x^2/4+y^2-1,x=-2..2,y=-1..1):
    display({c,d,e});

[Maple Plot]

GRAPHIQUES EN DIMENSION 3:

La fonction smartplot3d constitue la façon la plus simple de représenter une ou plusieurs surfaces :
Par défaut, le range est [-5..5,-5..5].

> smartplot3d(exp(-(x^2+y^2)));

[Maple Plot]

plot3d(f(x,y),x=a..b,y=c..d,...) ou plot3d(f,a..b,c..d,...) permettent de tracer une surface.

> f:=(x,y)->exp(-(x^2+y^2)):plot3d(f,-1..1,-1..1,axes=BOXED,orientation=[-45,60],numpoints =1000,color=blue);

[Maple Plot]

Comme pour la dimension 2 , on retrouve les options axes , scaling , tickmarks , title , view ,

numpoints (par défaut 625) et :

labels = [`x`,`y`,`z`]

orientation = [theta,phi] précise les angles de vision en coordonnées sphériques .

projection = r , avec r réel de [0,1] . FISHEYE=0 , NORMAL=0.5 , ORTHOGONAL=1.

grid = [m,n] détermine la grille rectangulaire m x n (par défaut 25 x 25)

style = s ( où s parmi POINT,HIDDEN,PATCH,WIREFRAME,CONTOUR,

PATCHNOGRID,PATCHNOCONTOUR,LINE . Par défaut : HIDDEN )

ambientlight = [r,v,b] fixe l'intensité des couleurs rouge,vert,bleu (valeurs dans [0,1]) .

colour = c fixe la couleur à c .

light = [phi,theta,r,v,b] fixe l'éclairage de la surface selon les angles phi,theta en coordonnées

sphériques avec les couleurs r,v,b .

shading = s ( où s parmi XYZ,XY,Z,ZGREYSCALE,ZHUE,NONE ) pour préciser la façon

dont la surface est coloriée .

coords = c ( ou c parmi cartesian,spherical,cylindrical )

Les surfaces peuvent être paramétrées :

> plot3d([(4+sin(t))*cos(u),(4+sin(t))*sin(u),2*sin(t)],t=0..2*Pi,u=0..2*Pi,axes=framed,shading=ZHUE,ambientlight =[0.85,0.75,0.1]);

[Maple Plot]

> plot3d(z,theta=0..2*Pi,z=0..2,coords=cylindrical,title="Un cône");

[Maple Plot]

> plot3d(5,theta=0..2*Pi,phi=0..Pi,axes=BOXED,coords=spherical,scaling=constrained,color=blue,title="Une sphère");

[Maple Plot]

OUTILS 3D DU PACKAGE plots:

Le package plots fournit d'autres outils graphiques pour la dimension 3 :

> with(plots);

Warning, the name changecoords has been redefined

Citons entre autres :

animate3d , pour créer des animations graphiques .

fieldplot3d , gradplot3d pour visualiser un champ de vecteurs ou de gradients .

display3d permet de représenter plusieurs objets graphiques de nature éventuellement différentes

sur un même graphique. L'option insequence=true permet de le transformer en animation.

polyhedraplot pour représenter des polyèdres : polyscale = n (taille du polyèdre)

polytype parmi tetrahedron,octahedron,hexahedron,dodecahedron,icosahedron.

> polyhedraplot([0,0,0],polyscale=10,polytype = icosahedron,scaling=CONSTRAINED,axes=BOXED,title="Icosaèdre");

[Maple Plot]

Tracé de surfaces implicites ou de courbes gauches:

> implicitplot3d(x^2+y^2/4+z^2/4-1=0,x=-1..1,y=-2..2,z=-2..2,title="ellipsoide",color=red);

[Maple Plot]

> spacecurve([cos(t),sin(t),t],t=-4*Pi..4*Pi,numpoints=500,axes=FRAMED,title="Courbe gauche : une hélice",color=black);

[Maple Plot]

Exercice corrigé 6:

Soit S la surface d'équation cartésienne x^2+y^2-z^2 = 1 (hyperboloide de révolution à une nappe)

1° Représenter S à partir de son équation implicite , pour z variant entre -1 et 1.

2° Définir S à partir d'une représentation paramétrique et représenter alors S .

> with(plots):implicitplot3d(x^2+y^2-z^2-1,x=-sqrt(2)..sqrt(2),y=-sqrt(2)..sqrt(2),z=-1..1,color=blue);

[Maple Plot]

> S:=[cosh(phi)*cos(theta),cosh(phi)*sin(theta),sin(phi)]:plot3d(S,phi=-arcsinh(1)..arcsinh(1),theta=0..2*Pi,color=blue);

[Maple Plot]

Travail dirigé 6:

TD 6.1:

Écrire une procédure polygone_regulier ( n:: posint) permettant de représenter un polygône

régulier à n côtés, de centre (0,0) et de rayon 1:

> polygone_regulier(8);

[Maple Plot]

TD 6.2:

1° Paramétrer en coordonnées sphériques une sphère de centre (x,y,z) de rayon R en créant

une fonction sphere des 4 variables x,y,z,R .

2° Représenter sur un même graphique les sphères de centres respectifs (3,0,0) ,

(0,3,0) et (0,0,0) et de rayons respectifs 2,2,1.

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 05 : Polynômes et fractions rationnelles

POLYNÔMES:

> restart;

Un polynôme a le type polynom , et peut avoir plusieurs variables :

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

> type(P,polynom),whattype(P),whattype(Q);

nops(P) donne le nombre de termes selon la forme , développée ou factorisée , de P :

> nops(P),nops(Q);

op(P) donne sous forme de séquence les termes ou les facteurs de P :

> op(P);op(Q);

Coefficients , degré , valuation:
Les 2 syntaxes sont équivalentes:

> coeff(P,x^3);

> coeff(P,x,3);

Obtenir tous les coefficients de P (valable lorsque P est sous forme développée)

> coeffs(P);coeffs(Q);

Error, invalid arguments to coeffs

> coeffs(expand(Q));

Coefficient du terme de plus haut (de plus bas) degré:

> lcoeff(P),tcoeff(P);

> lcoeff(Q,y),tcoeff(Q,y);

Degré et valuation:

> degree(P),degree(Q,x),degree(Q,y);

> ldegree(P),ldegree(Q,x),ldegree(Q,y);

FONCTIONS SUR LES POLYNÔMES:

quo(P,Q,x,'r') : quotient de la division euclidienne de P par Q , variable x , 'r' (optionnel)

variable non assignée recevant le reste .

> quo(x^5-1,x^2+x+1,x, 'r');r;

rem(P,Q,x,'q') : reste de la division euclidienne de P par Q , variable x , 'q' (optionnel)

variable non assignée recevant le quotient .

> rem(x^5-1,x^2+x+1,x, 'q');q;

Discriminant:

> discrim(x^3+a*x+b,x);

Evaluer, ordonner, transformer un polynôme:

> subs(x=1+2*I,y=I,Q);

Ordonner Q selon les puissances décroissantes de y:

> sort(expand(Q),y);

Développer:

> expand((x-3*y+a)*(1-a^2+x+y));

Regrouper les monômes de l'expression en l'indéterminée a :

> collect((x-3*y+a)*(1-a^2+x+y),a);

Mettre P sous la forme de Hörner:

> P;H:=convert(P,horner);

> with(codegen,cost);

Ce qui est moins coûteux en opérations:

> cost(P),cost(H);

Factoriser sur le corps Q des rationnels

> factor(x^3+x^2+x+1);

Normaliser:

> normal((4*x-3)^2+x-1);

RACINES ET FACTORISATION DES POLYNÔMES:

Valeur approchées des zéros réels ou complexes avec fsolve :

> P:=x^3+x+1:fsolve(P);

> fsolve(P,x,complex);

Localiser les zéros réels dans un intervalle de longueur voulue , ici 10^-3 , avec realroot :

> realroot(P,0.001);

Calcul des zéros avec solve(P) :

> solve(x^4+1);

Par la fonction factor , on peut factoriser sur Q ou sur le corps induit par les coefficients :

> factor(x^4-1);

> factor(x^3-I*x-I+1);

Pour obtenir la factorisation complète:

factor (P,{ ,..., }) autorise Maple à factoriser P sur un corps contenant les nombres algébriques ,...,

> factor(x^4-1,I);

> factor(x^3-x^2+2*x-2);

> factor(x^3-x^2+2*x-2,{I,sqrt(2)});

On peut aussi utiliser Split , qui donne une factorisation complète :

> with(PolynomialTools,Split):P:=Split(x^4-1,x);

RootOf désigne ici toute racine du polynôme _Z²+1, on peut simplifier l'écriture en

utilisant alias :

> alias(alpha=RootOf(_Z^2+1)):P;

Pour calculer les valeurs possibles de alpha :

> allvalues(RootOf(_Z^2+1));

La fonction roots donne les zéros avec leur ordre de multiplicité:
x^2+1 n'a aucun zéro sur Q:

> roots(x^2+1);

On calcule ses zéros sur le corps Q(I) induit par les coefficients:

> roots(x^2+1,I);

FRACTIONS RATIONNELLES : de type ratpoly

> F:=(2*x^2+x-3)^2/(x^4-1);numer(F),denom(F);

F := (2*x^2+x-3)^2/(x^4-1)

> simplify(F);

(2*x+3)*(2*x^2+x-3)/(x^3+x^2+x+1)

Factorisation sur IR ou C:

factorisation sur IR:

> factor(F);

(2*x+3)^2*(x-1)/(x+1)/(x^2+1)

factorisation sur C:

> factor(F,I);

(x-1)*(2*x+3)^2/(x+I)/(x-I)/(x+1)

retour à la forme normale:

> normal(%,expanded);

(4*x^3+8*x^2-3*x-9)/(x^3+x^2+x+1)

Décomposition en éléments simples sur IR ou C:

convert(F,parfrac, x ) décompose en éléments simples la fraction rationnelle F en l'indéterminée x .
convert(F,parfrac, x, { ,..., } ) autorise Maple à décomposer sur un corps contenant les nombres algébriques ,...,

Décomposition sur IR:

> convert(F,parfrac,x);

4-1/(x+1)+(-12+5*x)/(x^2+1)

Décomposition sur C:

> convert(F,parfrac,x,I);

4+(5/2-6*I)/(x+I)-(5/2+6*I)/(-x+I)-1/(x+1)

Exercice corrigé 5:

Ex 5.1: Décomposer en éléments simples sur F := 1/(x^4+1)

> F:=1/(x^4+1);

F := 1/(x^4+1)

> convert(F,parfrac,x);

1/(x^4+1)

F n'est pas décomposée. Voyons les racines du dénominateur:

> {solve(denom(F))};

On obtient la décomposition sur IR par:

> convert(F,parfrac,x,sqrt(2));

-1/4*(-2+x*sqrt(2))/(x^2-x*sqrt(2)+1)+1/4*(2+x*sqrt...

On obtient la décomposition sur C par:

> convert(F,parfrac,x,{I,sqrt(2)});

(-1/4+1/4*I)*2^(1/2)/(2*x-sqrt(2)+I*sqrt(2))-(1/4+1...

Ex 5.2: Soit .

Montrer que les zéros du polynôme dérivé P' sont 3 termes consécutifs d'une suite arithmétique.

> P:=X*(X-1)*(X-2)*(X-3):dP:=diff(expand(P),X);

> zeros:=[solve(dP)];

On trie les éléments de la liste par ordre croissant , sort ne fonctionnant pas ici :

> tri:=proc(L::list)
        local x,y,Z;
            Z:=L;
            for x to nops(Z)-1 do
                for y from x+1 to nops(Z) do
                      if evalf(Z[y]-Z[x])<0 then Z:=subsop(x=Z[y],y=Z[x],Z) end if;
                end do;
            end do;
            Z;
    end proc:

> zeros:=tri(zeros);

On calcule les écarts entre 2 termes consécutifs , la raison est :

> for k to nops(zeros)-1 do print(zeros[k+1]-zeros[k]) end do;

Travail dirigé 5:

TD 5.1:
Soit la fraction rationnelle F définie par : F = X^6/(X^2+1)^2/(X+1)^2

1° La décomposition de F en éléments simples dans R s'écrit:

G := a+(b*X+c)/(X^2+1)+(d*X+e)/(X^2+1)^2+f/(X+1)+g/...

On réduit les fractions composant G au même dénominateur et on identifie les

numérateurs de F et de G . En déduire les valeurs de a,b,c,d,e,f,g .

2° Calculer la décomposition de F en éléments simples dans C

TD 5.2:

Soit P un polynôme de K[ x ] , s'écrivant sous la forme :

P(x) = Sum(a[k]*x^k,k = 0 .. n)

L'algorithme de Hörner permet d'écrire P( x ) sous la forme :

Exemple:

Ecrire une procédure PolyHorner(P , x ) permettant d'écrire P( x ) sous cette forme ,

P étant un polynôme donné de K[ x ] , x étant le nom de la variable .

NB: il est interdit d'utiliser la fonction horner de MAPLE .

Grace à la fonction cost , évaluer le coût en opérations nécessaires pour évaluer Q et
PolyHorner(Q, x ) , Q étant le polynôme donné en exemple.

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 04 : Séquences, listes, ensembles, tables, tableaux

LES SÉQUENCES:

Une séquence , de type exprseq , est une suite d'éléments séparés par une virgule . On accède à

chaque élément par son rang , mais l'affectation est interdite :

> restart:
s:=a,b,-1,2*p-q,r;

> s[4];s[2..5];s[3]:=0;

Error, cannot assign to an expression sequence

NULL désigne la séquence vide:

> v:=NULL;

Pour répéter un élément , utiliser l'opérateur dollar $ :

> t:=a$2,y$5;

Pour concaténer 2 séquences ,utiliser l'opérateur virgule ,

> u:=s,t;

op(expr) retourne la séquence formée des opérandes de l'expression expr :

> op(a-y*(a+y+z)+3*z);

La fonction seq permet de créer une séquence

pour un indice i variant de a à b avec un pas de 1 : syntaxe seq(expr,i=a..b) , ou

pour un indice décrivant les opérandes d'une expression e : syntaxe seq(expr,i=e) :

> seq(i^3,i=-1/2..2);

> e:=a-y*(a+y+z)+3*z:op(e);
seq(mu+i,i=e);

> seq(seq(a||i||j,j=1..3),i=1..3);

LES LISTES:

Une liste , de type list , est obtenue en plaçant une séquence entre les crochets [ et ] .

La liste vide se note [] .

> s:=a$2,b$3,alpha,beta;L:=[s];

On accède à chaque élément d'une liste par son rang , l'affectation est autorisée:

> L[6];L[2..5];L[3]:=delta;

op transforme une liste en séquence , nops donne le nombre d'éléments d'une liste .

Les fonctions op et nops ne peuvent agir sur une séquence s : faire ops([s]) et nops([s])

> op(L);

> nops(L);

Pour modifier une liste, on peut aussi utiliser subs ou subsop :

> L:=subs(b=b1,L);

> L:=subsop(3=gamma,L);

La fonction booléenne member permet de savoir si une expression est membre d'une liste:

> member(gamma,L), member(epsilon,L);

LES ENSEMBLES:

Un ensemble , de type set , est obtenu en plaçant une séquence entre les accolades { et }.

Les éléments sont rangés par adresse , donc l'ordre initial n'est pas nécessairement conservé et les éléments en

double sont supprimés. L'ensemble vide se note {} .

> s:=a$2,b$3,alpha,beta;e:={s};

On accède à chaque élément d'un ensemble par son rang , mais l'affectation est interdite :

> e[2];e[2..3];e[3]:=delta;

Error, cannot assign to a set

op transforme un ensemble en séquence , nops donne le nombre d'éléments d'un ensemble .

> op(e);nops(e);

Pour modifier un ensemble , l'affectation étant interdite , utiliser sub s ou subsop :

> e:=subs(b=b1,e);

> e:=subsop(3=delta,e);

La fonction booléenne member permet de savoir si une expression est membre d'un ensemble:

> member(delta,e), member(epsilon,e);

Convertir un ensemble en somme, en produit, en liste, ou convertir une liste en

ensemble avec convert :

> convert(e,`+`);convert(e,`*`);
e:=convert(e,list);e:=convert(e,set);

Opérations sur les ensembles:

union (union) , intersect (intersection) , minus (différence) .
la fonction booléenne a indique si a est un sous-ensemble de b .

> e:={alpha,beta,gamma,delta}:f:={beta,delta,epsilon,phi,lambda}:
u:=e union f;i:=e intersect f;m:=f minus e;

> i subset e, i subset m;

QUELQUES OUTILS DU PACKAGE COMBINAT:

> with(combinat,choose):

(appel de l'outil choose , qui génère les sous-listes ordonnées d'une liste donnée)

> choose([a,b,c]);

Génération de toutes les sous-listes de longueur 2 ordonnées d'une liste de longueur 3:

> choose([a,b,c],2);

choose ( n , p ) avec n , p entiers , génère toutes les sous-listes de longueur p ordonnées de [1,2,.., n ]

> choose(4,3);

> with(combinat,permute):

(appel de l'outil permute , qui génère les listes de permutation d'une liste donnée)

> permute([a,b,c]);

Génération de toutes les sous-listes de permutation de longueur 2 de [a,b,c] :

> permute([a,b,c],2);

permute ( n ) , avec n entier , donne les listes de permutation de [1,2,..., n ]

> permute(3);

permute ( n , p ) , avec n , p entiers , donne les sous-listes de permutation de de longueur p de [1,2,..., n ]

> permute(3,2);

> restart;

LES TABLES:

Une table est une structure indexée dont les indices (ou index ) peuvent être de n'importe quel type.

La fonction table permet de créer une table :

Création d'une table vide:

> v:=table();

Création d'une table T avec une liste de valeurs:

> T:=table([valeur1,valeur2]);

Création d'une table U avec liste d'index (ici ° . *) et de valeurs:

> U:=table([`°`=valeur1,`.`=valeur2,`*`=valeur3]);

Pour afficher le contenu d'une table , utiliser print ou eval

> print(T),eval(U);

On peut modifier , créer un nouvel élément , ou supprimer un élément par affectation :

> T[a]:=valeur3:U[~]:=valeur4:print(T),eval(U);

Une table peut être directement créée par assignation :

> V[a]:=1:V[b]:=2:V[c]:=3:eval(V);

Fonctions agissant sur des tables:

> op(op(V));

> indices(V);

> entries(V);

La fonction map permet d'appliquer une fonction sur les valeurs d'une table:

>

V:=map(sqrt,V);

La fonction copy permet d'effectuer une copie d'une table:

> W:=copy(V);

LES TABLEAUX:

Un tableau est une structure indexée, de type array , de plusieurs dimensions, dont les indices

sont des entiers appartenant à un intervalle a..b (de type range ) .

La fonction array permet de créer un tableau :

Des fonctions analogues à celles utilisées pour les tables existent :

Création d'un tableau à une dimension:

> T:=array(1..3);

Création d'un tableau à une dimension avec initialisation partielle:

> U:=array(1..5,[a,b,c]);

Création d'un tableau à 2 dimensions avec initialisation complète:

> V:=array([[a,b,c],[d,e,f]]);

V := matrix([[a, b, c], [d, e, f]])

Création d'un tableau rectangulaire d'entiers par affectation à l'aide de boucles imbriquées:

> T:=array(1..2,1..3):
    for i to 2 do
        for j to 3 do
            T[i,j]:=(i-1)*3+j;
        end do;
    end do:
    print(T);

matrix([[1, 2, 3], [4, 5, 6]])

> op(op(T));

>

indices(T);

> entries(T);

> map(x->x^2,T);

matrix([[1, 4, 9], [16, 25, 36]])

Conversion d'un tableau en liste (si la dimension est 1) ou en liste de listes (si la dimension est >1):

> convert(U,list);convert(T,listlist);

Conversion d'un tableau de dimension quelconque en ensemble:

> convert(T,set);

> T:=convert([a,b,c,d],array);

> U:=copy(T);

Exercice corrigé 4:

Ex 4.1: Ecrire une procédure qui inverse les éléments d'une liste .

> restart;
    listeinverse:= proc(L::list)
        local i;
            [seq(op(nops(L)-i,L),i=0..nops(L)-1)];
    end proc:

> listeinverse([a,b,c,d,e,f]);

Ex 4.2: Créer une matrice de Vandermonde d'ordre n . Exemple , pour :

> VDM:=proc(n::posint)
        local i,j,a,V;
            a:=array(1..n):V:=array(1..n,1..n):
            for i to n do for j to n do V[i,j]:=a[i]^(j-1) end do end do;
            print(V);
    end proc:

> VDM(4);

matrix([[1, a[1], a[1]^2, a[1]^3], [1, a[2], a[2]^2...

Travail dirigé 4:

TD 4.1:

1° Un tableau T à n lignes et p colonnes étant donné , écrire une procédure

ligne( T , p , i ) qui calcule la somme des éléments de T situés en ligne i .

2° Un tableau T à n lignes et p colonnes étant donné , écrire une procédure

colonne( T , n , j ) qui calcule la somme des éléments de T situés en colonne j .

3° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale1( T , n ) qui calcule la somme des éléments de T situés sur la première diagonale.

4° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale2( T , n ) qui calcule la somme des éléments de T situés sur la seconde diagonale.

5° Un tableau T carré à n lignes et n colonnes est dit magique si la somme des éléments de

n'importe quelle ligne , de n'importe quelle colonne , et de n'importe quelle diagonale est

la même .

Utiliser les procédures précédentes pour écrire une fonction booléenne magique( T , n )

rendant la valeur true si T est magique, et false sinon .

Exemples:

T := MATRIX([[8, 1, 6], [3, 5, 7], [4, 9, 2]])

> magique(T,3);

U := matrix([[5, 6, 3], [0, 8, 1], [4, 7, 2]])

> magique(U,3);

TD 4.2:

Ecrire la procédure intitulée coder(st::string) qui convertit la chaîne de caractères st

(écrite en lettres minuscules) en un nombre.

On code : , , etc ... , .

Exemple: si alors , , 6 , , .

> coder("maple");

Aide: pour écrire cette procédure , on construira un alphabet puis une table T de conversion

et on utilisera au besoin les fonctions de Maple suivantes:

length(st) qui donne la longueur de la chaîne de caractères st .

substring(st,m..n) qui extrait de st la sous-chaîne des caractères situés entre les positions m et n .

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 03 : Programmation

Remarque importante: pour pouvoir entrer plusieurs lignes d'instructions Maple successives,
sans exécution à la fin de chaque ligne, presser Shift+Entrée à la fin de chaque ligne.
Puis, pour valider l'ensemble des lignes ainsi écrites, presser Entrée en plaçant le curseur par
exemple sur la dernière ligne écrite.

LES STRUCTURES DE CONTRÔLE:

Structure de contrôle if .. then:

if condition1 then instruction 1

elif condition2 then instruction2 elif et else sont optionnels)

elif condition3 then instruction3 ...

else instructionN

end if;

Effectue un test selon certaines conditions:

elif signifie "autrement si" . La dernière instruction à exécuter doit être précédée de else .

Exemple 1: résolution de l'équation du premier degré .
Modifiez les valeurs de a et de b , puis validez les lignes suivantes:

> a:=7:b:=3:

> if a<>0 then print(`Une solution : x `=-b/a)
        elif b=0 then print(`Tout x est solution`)
        else print(`Pas de solution`)
    end if;

Structure de contrôle while .. do:

while condition do ... end do;
Exécute une suite d'instructions, tant que la condition est vraie.

Exemple 2: calcul de la somme des 100 premiers entiers naturels

> somme:=0:k:=-1:
while k<100 do k:=k+1:somme:=somme+k end do:
`somme `=somme;

Structure de contrôle for .. to:

for variable from initiale to finale by pas do ... end do;

Exécute une boucle pour une variable allant d'une valeur initiale à une valeur finale,

avec un pas donné.

from , by peuvent être omises ou écrites dans un ordre quelconque.

Si l'on omet from , initiale vaut 1. Si l'on omet by , pas vaut 1.

Exemple 3: calcul de la somme des 100 premiers entiers naturels

> somme:=0:
for k from 0 to 100 do somme:=somme+k end do:
`somme `=somme;

Exemple 4: calcul de la somme des entiers impairs inférieurs à 100
Ici, on omet from donc la première valeur de k est 1. La dernière valeur prise par k sera 99.

> somme:=0:
for k to 100 by 2 do somme:=somme+k end do:
`somme `=somme;

for variable in expression do .. end do;

Exemple 5: donner les nombres premiers de la liste [31,39,47,105]

> for k in [31,39,47,105] do
if isprime(k) then print(k,`est premier`) end if
end do;

LES PROCÉDURES:

Un programme MAPLE peut être organisé en sous-programmes appelées procédures .
Une procédure, de type procedure , est définie par le mot-clé proc et peut être assignée à
un nom de variable. Pour définir une procédure intitulée nom , on utilisera la syntaxe suivante:

nom := proc (paramètres_formels)

global variables_globales; (la ligne global est optionnelle)

local variables_locales; (la ligne local est optionnelle)

description chaîne_de_description; (la ligne description est optionnelle)

option nom_option; (la ligne option est optionnelle)

. . . instructions . . . (corps de la procédure)

end proc;

Exemple 6:

La procédure intitulée maxi calcule le plus grand de 2 entiers positifs.
Elle comporte 2 paramètres formels u et v . Leur type peut être omis, mais si on le veut le préciser,
bien noter la syntaxe u :: posint , v :: posint pour signifier que u et v sont de type posint .
Elle ne comporte ni variables globales, ni variables locales, mais une chaîne de description

de la procédure et une option de copyright.

> maxi:=proc(u::posint,v::posint)
        description "calcule le plus grand de 2 entiers positifs";
        option `Copyright (c) 2001 MicroMaths`;
        if u<v then v else u end if;
    end proc;

> maxi(5,9);maxi(1.2,Pi);

Error, invalid input: maxi expects its 1st argument, u, to be of type posint, but received 1.2

Une variable locale est une variable qui n'est reconnue qu'à l'intérieur de la procédure,

contrairement à une variable globale accessible en dehors de la procédure.

Exemple 7:

> messages:=proc()
        global message1;
        local message2;
            message1:="Hello, world!";
            message2:="How are you?";
    end proc;

> messages();

w are you?

> message1,message2;

La valeur de la variable locale message2 n'a pas été reconnue, contrairement à celle de la
variable globale message1 .

Remarque importante:
Un paramètre formel passé à une procédure ne peut être modifié à l'intérieur de cette procédure

Exemple 8: Diviser un entier positif x par 2 tant qu'il est pair.

> div:=proc(x::posint)
while type(x,even) do x:=x/2 end do;

end proc;

>

div(48);

Error, (in div) illegal use of a formal parameter

La tentative d'affecter au paramètre formel

x
sa valeur divisée par 2 provoque une erreur.

On peut modifier la procédure de la manière suivante:

>

div:=proc(x::posint)

        local y;

            y:=x;

            while type(y,even) do y:=y/2 end do;

            y

    end proc;

>

div(48);

On obtient en effet successivement : 48,24,12,6,3.

>

div(45);

return
met fin à la procédure en donnant un résultat.

next
permet de passer à la valeur suivante dans une itération.

break
permet de sortir de la structure de contr
ô
le en cours.

Exemple 9:
On parcourt une liste de nombres. Au premier entier positif trouvé, on sort de la procédure

avec pour résultat cet entier, sinon si ce nombre est négatif, on sort de la boucle avec pour résultat -1,

sinon on passe au nombre suivant.

>

liste:=proc(L::list(numeric))

        local k;

            for k in L do

            print(`lecture de`,k);

            if type(k,nonnegint) then return k


elif k<0 then break;


else next;

            end if

            end do;

            return -1;

    end proc;

>

liste([12.56,8.9,7,3.14]);

>

liste([12.56,-8.9,7,3.14]);

>

liste([12.56,8.9,7.1,3.14]);

Récursivité:

Une procédure qui fait référence à elle même dans sa définition est une procédure
récursive
.

Exemple 10:
factorielle de
n

>

factorielle := proc(n::nonnegint)

if n>0 then n*factorielle(n-1) else 1 end if;

end proc;

>

factorielle(12);

Fonction
error:

La fonction
error
permet de définir des messages d'erreur personnalisés.

Exemple 11:
racine carrée de
x

>

racine := proc (x)

if x<0 then error "invalide x: %1", x else simplify(x^(1/2)) end if

end proc;

>

racine(144);

>

racine(-144);

Error, (in racine) invalide x: -144

LES MODULES:

Un
module
est une collection de procédures et de données.

Un module, de type
module
, est défini par le mot-clé
module
et peut être assigné à un

nom de variable. Pour définir un module intitulé
nom
, on utilisera la syntaxe suivante:

nom
:=
module
()

global
variables_globales; (la ligne
global
est optionnelle)

local
variables_locales; (la ligne
local
est optionnelle)

export
variables_locales_exportées; (la ligne
export
est optionnelle)

description
chaîne_de_description; (la ligne
description
est optionnelle)

option
nom_option; (la ligne
option
est optionnelle)

. . .
instructions
. . .
(corps du module)

end module;

Contrairement au cas des procédures,
le module ne peut avoir de paramètres formels
.

On retrouve les notions de variables globales et locales, comme pour les procédures,

mais
les modules peuvent exporter des variables locales
(celles de la ligne
export
),

auxquelles on a accès de l'extérieur du module en utilisant la syntaxe suivante:

nom
:-
var
permet d'accéder à la variable locale exportée
var
du module
nom
.

En utilisant la terminologie de la programmation orientée objet, les variables déclarées

dans la ligne
local
s'apparentent à des membres
privés
du module, tandis que celles

déclarées dans la ligne
export
s'apparentent à des membres
publics
du module.

Exemple 12:
Anneau Z/4Z des entiers modulo 4.

>

Z4:=module()


description "Arithmétique modulo 4";


export add,mult,opp;


add := (x,y)-> (x+y) mod 4;


mult := (x,y)-> (x*y) mod 4;


opp := x-> (-x) mod 4;


end module;

Le module comporte 3 variables locales exportées
add
,
mult
,
opp
.

Vérifions que: (2+3) mod 4 = 1 , que (2*3) mod 4 = 2 et
opp
(1) = -1 mod 4 = 3 :

>

Z4:-add(2,3);

>

Z4:-mult(2,3);

>

Z4:-opp(1);

Exemple 13:
Anneau Z/
n
Z des entiers modulo
n
.

On désire modifier le programme précédent pour effectuer de l'arithmétique modulo
n
,

avec

entier quelconque.

Un module n'acceptant pas de paramètre formel, écrivons une procédure
Construire_Zn

de paramètre formel
n
, rendant pour résultat un module:

>

Construire_Zn:=proc(n::posint)

        module()


description "Arithmétique modulo n";


export add,mult,opp;


add := (x,y)-> (x+y) mod n;


mult := (x,y)-> (x*y) mod n;


opp := x-> (-x) mod n;

        end module;

    end proc;

>

Z7:=Construire_Zn(7);

>

Z7:-add(6,5);

>

Z7:-mult(5,3);

>

Z7:-opp(3);

On peut utiliser la structure de contrôle
use
pour accéder aux variables locales exportées du module
nom
sans avoir recours

à l'utilisation de
:-

Exemple:
(opp(3) mod 7) = (4 mod 7) = 4 ( (opp(3) mod 7)*5 ) mod 7 = (4*5) mod 7 = 6

(2 + ( (opp(3) mod 7)*5 ) mod 7 ) = (2+6) mod 7 = 1

>

use Z7 in

add( 2, mult( opp(3), 5) )

end use;

La fonction
member
permet de savoir si une expression est membre d'un module:

>

member(mult,Z7) , member(prod,Z7);

Le constructeur Record:

Le constructeur

Record
crée un
enregistrement
Maple. Un enregistrement, de type
record
, est

défini par les noms de ses champs (appelés "slots" ou "fields" en anglais).

Exemple 14:
On veut créer un enregistrement pour modéliser les nombres complexes.

Un nombre complexe
z
est défini par 2 champs: sa partie réelle et sa partie imaginaire.

>

z := Record( 're', 'im' );

On voit qu'un enregistrement est un module particulier, qui a l'option
record
.

On définit un nouveau type
complexe
associé et la fonction module d'un nombre complexe:

>

`type/complexe` := 'record( re, im )':

Mon_module:=(z::complexe)->sqrt(z:-re^2+z:-im^2);

>
z:-re:=1 : z:-im:=2 :Mon_module(z);

On peut aussi initialiser les valeurs des parties réelle et imaginaire de la façon suivante:

>

z:= Record( 're' = 1, 'im' = 2 ):Mon_module(z);

LES LIBRAIRIES ET PACKAGES:

Pour obtenir le listing de certaines fonctions des librairies MAPLE, comme ici la fonction
ithprime

utiliser:

>

interface(verboseproc=2);print(ithprime);

Les
packages
regroupent des fonctions utiles dans des domaines particuliers.

La fonction suivante appelle la page d'aide donnant les packages existants :

>

?index,package

La fonction
with
permet de charger toute ou partie d'un package choisi:

>

with(student);

#charge toutes les fonctions du package student

Chargement de la fonction
binomial
du package
combinat :

>

with(combinat,binomial);

Cette fonction retourne le nombre binomial(

) =
n!/(p!*(n-p)!)
appelé aussi C(

).

Exercice corrigé 3:

Ex 3.1

Ecrire une procédure calculant le plus grand de 3 entiers naturels non nuls
a
,
b
,
c
.

>

max3:=proc(a::posint,b::posint,c::posint)


local max2;

            max2:=proc(x::posint,y::posint)


if x>y then x else y end if;

            end proc;

        max2(a,max2(b,c));

    end proc;

>

max3(5!,5^3,123);

max3
comporte une variable locale
max2
à laquelle est affectée une procédure calculant le

plus grand de 2 entiers naturels non nuls.

Ex 3.2

1° Écrire un module pnt permettant de modéliser un point du plan, défini par ses coordonnées
x , y . Ce module comportera des variables locales exportées rendant comme résultat l'abscisse
et l'ordonnée du point.

2° Écrire un module cercle permettant de modéliser un cercle du plan, défini par son centre et
son rayon. Ce module comportera des variables locales exportées rendant comme résultat le
centre, le rayon, le diamètre, l'aire, et la circonférence du cercle.

1° Définition de la procédure pnt rendant pour résultat un module:

> pnt:=proc(x,y)
        module()
            export abscisse,ordonnee;
                abscisse:=()->x;
                ordonnee:=()->y;
        end module
    end proc;

Définition d'un point A de coordonnées ( a , b ) :

> A:=pnt(a,b);

> A:-abscisse(), A:-ordonnee();

2° Définition de la procédure cercle rendant pour résultat un module:

> cercle:=proc(c,r)
        module()
            export centre,rayon,diametre,aire,circonference;
                centre:=()->c;
                rayon:=()->r;
                diametre:=()->2*rayon();
                aire:=()->Pi*r^2;
                circonference:=()->Pi*diametre();
        end module
    end proc;

Définition d'un cercle C de centre A de rayon R :

> C:=cercle(A,R);

> C:-centre(), C:-rayon(), C:-diametre(), C:-aire(), C:-circonference();

Utilisation des deux structures pour obtenir les coordonnées du centre de C :

> C:-centre():-abscisse(), C:-centre():-ordonnee();

Travail dirigé 3:

TD 3.1:

Écrire une procédure second_degré(a,b,c) qui résout l'équation du second degré à

coefficients réels: a*x^2+b*x+c = 0 en distinguant 3 cas selon le signe du discriminant.

TD 3.2:

Écrire une procédure somme(n) calculant récursivement la somme des entiers de 0 à n , pour

n entier naturel donné.

TD 3.3:

Écrire une procédure renverser(n) , qui , étant donné un entier naturel n ne comportant pas de

0 dans son écriture décimale , rend pour résultat l'écriture renversée de cet entier .

Prévoir un message d'erreur si l'entier comporte le chiffre 0.

Exemple:

> renverser(122564);

> renverser(120325);

Error, (in renverser) le chiffre 0 n'est pas autorisé.

TD 3.4:

Écrire un module segment permettant de modéliser un segment du plan, défini par ses deux
points extrémités.Ce module comportera des variables locales exportées rendant comme
résultat la première et la seconde extrémité du segment, sa longueur, et son milieu.
On pourra utiliser le module défini par la procédure pnt de l'exercice corrigé 3.2 .

haut de cette page

Vous devez vous identifier ou créer un compte pour écrire des commentaires
En savoir plus

Chapitre 02 : Éléments de base

LES VARIABLES:

Une variable informatique est l'adresse , dans la mémoire de l'ordinateur , d'un emplacement

permettant de stocker un objet d'un type donné .

Exemples: AB, aB , X1, _var , x[a] sont des noms de variables MAPLE .

Si l'on affecte à une variable une valeur , la variable est dite assignée .

Si elle n'est associée à aucune valeur , la variable est dite non assignée .

La fonction restart permet de réinitialiser toutes les variables de la feuille de calcul.

> restart;

var est une variable assignée, dont la valeur est 3 :

> var:=3;

La variable a et la variable indicée sont non assignées :

> a,x[a];

Une autre manière d'affecter une valeur à une variable est d'utiliser la fonction assign :

> assign(nom,10-var);

> nom;

Pour désaffecter une variable assignée, lui affecter son nom écrit entre deux accents aigus :

> nom:='nom':nom;

On peut aussi utiliser la fonction evaln (évaluer en un nom) :

> var:=evaln(var):var;

LES CONSTANTES:

true , false (valeurs booléennes vrai , faux) , I (complexe de carré -1) , Pi (nombre pi) ,

infinity (plus l'infini) sont des constantes MAPLE.

E (base des logarithmes népériens) n'est pas une constante MAPLE : faire exp(1).

> eval(exp(1))=evalf(exp(1));

LES EXPRESSIONS:

Elles sont évaluées de la gauche vers la droite , avec la priorité usuelle des opérateurs.

Pour afficher une expression, utiliser les fonctions lprint ou print :

> lprint(1-2/a+(a+1)/(a-5));

1-2/a+(a+1)/(a-5)

> print(1-2/a+(a+1)/(a-5));

Toute expression a un type que l'on peut obtenir grâce à la fonction

whattype :

Parmi les types possibles figurent : + (somme) , * (produit) , ^ (puissance) , = (égalité) , <> (non

égalité) , < , <= (inégalité au sens strict ou large) , and , or , not (et,ou,non) , integer (nb entier) ,

fraction (nb rationnel) , float (nb réel en virgule flottante) , complex (nb complexe) , numeric

(numérique) , symbol (symbole), string (chaîne de caractères) , list (liste) , set (ensemble) ,
table (table) , array(tableau) , function (fonction) , name (nom) , .. (intervalle).

> whattype(a+b),whattype(a>b),whattype(-1.2245),whattype(a^7),whattype((a and b) or (c or d));

> whattype(x-2/y),whattype(a/b),whattype(`MAPLE`),whattype("MAPLE"),whattype({a,b});

On peut tester si une expression a un type donné en utilisant la fonction type :

> type(x,name),type(a+3*x-7/5,list);

Autres fonctions :

> expr:=x-3*y+5/(x+y);

nops(expression) donne le nombre d'opérandes de l'expression:

> nops(expr);

op(i,expression) donne le i-ème opérande de l'expression:

> op(2,expr);

op(i..j,expression) donne les opérandes de l'expression, du i-ème au j-ème:

> op(2..3,expr);

Transformation des expressions:

Regrouper certains termes selon une ou plusieurs variables avec collect(expression,v) ; v est une variable ou

une liste de variables :

> expr:=x^3*ln(x)+3*x^2+ln(x)*x-x:collect(expr,ln(x));

> expr:=x^2+5*x-25*y+48*(x-2*y+7)+y^3:collect(expr,[x,y]);

Transformer en un seul terme avec combine(expression,noms) :

Le paramètre noms est optionnel et à choisir par exemple parmi : exp , ln , trig , power .

> combine(2*Sum(i^2,i=1..n)+Sum(i^3,i=1..n));

Sum(2*i^2+i^3,i = 1 .. n)

> combine(exp(sin(a)*cos(b))/exp(cos(a)*sin(b)),[trig,exp]);

Simplifier une expression avec normal(expression) , simplifier une expression contenant des

radicaux avec radsimp(expression) :

> normal( 1/x+x/(x+1) );

(x+1+x^2)/x/(x+1)

> normal( 1/x+x/(x+1), expanded );

(x+1+x^2)/(x^2+x)

> radsimp((x-1)*sqrt(x*x-2*x+1)*(x+1));

Ordonner une expression avec sort(expression,v) ; v est une variable ou une liste de variables :

> sort(expr,y);

Ordonner selon un critère avec sort(liste,paramètre) ; liste est une liste de valeurs ,

paramètre = `<` ou `>` (ordre croissant, décroissant) , lexorder ou string (ordre lexicographique) .

> liste1:=[12,-2,5,1]:liste2:=[s,q,a,g,h,p,z,j,l,m,o,b,i]:

>

sort(liste1,`>`),sort(liste2,lexorder);

Transformer une expression selon le modèle forme avec convert(expression,forme) :

> sin(2*x)=convert(sin(2*x),tan);

sin(2*x) = 2*tan(x)/(1+tan(x)^2)

Faire des substitutions avec subs(eq1,eq2,...,eqn,expression):

> expr;
subs(x=lambda,y=2*t,expr);
expr;

On constate que expr n'a pas changé.

> subsop(1=w,2=-t,4=mu,expr);

L'opérande n°1 a été remplacé par w , l'opérande n°2 a été remplacé par et le n°4 par .

On peut également utiliser use ... in .. end use :

> use x=4*rho, y=h, z=mu in
(x+y-z+3)^7
end use;

Appliquer une fonction à tous les opérandes avec map(fonction,expression) ;

> map(x->x^2,expr);

Isoler une expression dans une équation avec isolate(equation,expression) ;

> expr:=-x^3+2*(sqrt(y-sin(x))+1):isolate(expr,y);

y = (1/2*x^3-1)^2+sin(x)

Obtenir le membre gauche ou droit d'une égalité avec lhs(expression); ou rhs(expression);

> lhs(%);rhs(%%);

(1/2*x^3-1)^2+sin(x)

LES FONCTIONS:

Pour définir une fonction , on peut utiliser les syntaxes :

nom := var -> expr; pour une fonction d'une variable var

nom := (var1,var2,...,varN) -> expr; pour une fonction de N variables var1,var2,...,varN .

> f:=x->exp(x)-x;

> f:=(x,y,z,t)->x^2-3*y+4*z-t;

La fonction unapply (expr,var1,var2,...,varN) permet de transformer l'expression expr en une

fonction des N variables var1,var2,...,varN:

> expr:=u^2-3*v+4*w : f:=unapply(expr,u,v,w);

Composition des fonctions: l'opérateur @ , l'opérateur de composition itérée @@

> f:=u->u^3:g:=t->2*t+1:
(f@g)(a);(g@f)(a);

f@@N correspond à f o f o . . . o f (N fois)

> (f@@3)(u);

> (D@@2)(f); # fonction dérivée seconde de f

LES TYPES DE BASE:

LES TYPES NUMÉRIQUES:

On peut utiliser la fonction assume pour imposer une condition:
Exemple: on impose à r la condition ( r est alors affiché suivi d'une tilde: r ~ )

> assume(r,positive);r;
sign(r);

La fonction about permet d'obtenir une information sur une variable:

> about(r);

Originally r, renamed r~:

is assumed to be: RealRange(Open(0),infinity)

LES ENTIERS : ce sont des objets de typ e integer .

Un entier peut être positive (>0) , (<0), nonneg (>=0) , posint (entier>0) ,

negint (entier<0) , nonnegint (entier>=0) , even (pair) , odd (impair) , primeint (premier).

Ce que l'on peut tester avec type ou is .

> type(-15,negint), is(13,even);

On peut sélectionner des éléments répondant à une condition booléenne avec select(condition,v);
Exemple: sélectionner dans une liste de nombres ceux qui sont entiers >0

> select(x->type(x,posint),[-1/2,-7,Pi,3/4,0.25,18,2^5]);

Quelques fonctions utilisant les entiers:

> q:=iquo(89,-12);r:=irem(89,-12);

( quotient et reste de la division euclidienne de a par b : a =bq +r , avec |r|<|b| , ici

89 = (-12) (-7) + 5 )

54 est-il premier?

> isprime(54);

nombre premier suivant , nombre premier précédent:

> nextprime(215),prevprime(215);

Le 17 ème nombre premier:

> ithprime(17);

Décomposition en facteurs premiers:

> ifactor(117208);

Le ppcm et le pgcd de plusieurs entiers:

> ilcm(20,25,15);igcd(20,25,15);

Le plus petit ou le plus grand:

> min(712,56,100,25,125),max(712,56,100,25,125);

mod ( a modulo n donne le reste de la division de a par n , ici 31=4*7+3 ) :

> 31 mod 4;

rand(n) rend une fonction (appelée ici hasard) calculant un entier aléatoire entre .

> hasard:=rand(100):h:=hasard();

Fonction sign : cette fonction rend : -1 si , 1 si

> n:=-7;sign(n);

Fonction valeur absolue:

> abs(n);

LES RATIONNELS : ce sont des objets de type fraction (ou rational ) .

Un rationnel peut être positive (>0) , negative (<0) , nonneg (>=0) , ce qui peut être testé par

type ou is (comme pour les entiers).

Quelques fonctions utilisant les rationnels:

> q:=21*(144/124);numer(q);denom(q);

Comme pour les entiers , on a aussi les fonctions assume , min , max , sign , abs.

LES REELS : un réel de type float , a une mantisse et un exposant .

Exemple: 1234567=0.1234567*10^7 . La mantisse est 0.1234567 , et l'exposant 7 .

Le nombre s'écrit Float(0.1234567,7);

> evalf(Float(0.1234567,7));

L'utilisation du point . déclenche l'affichage en calcul flottant dans le second membre:

> 1/9=1.0/9;

Digits est une variable d'environnement représentant le nombre de décimales affichées (10 par défaut).

> Digits:=30:evalf(exp(1));

Quelques fonctions utilisant les réels:

abs , sqrt (racine carrée) , exp , ln , log10 , log[a] (logarithme de base a) , sin , cos , tan , cot

(fonctions circulaires) , sinh , cosh , tanh , coth (fonctions hyperboliques) , arcsin ,arccos ,

arctan , arccot (fonctions circulaires réciproques) , arcsinh , arccosh , arctanh , arccoth

(fonctions hyperboliques réciproques).

La fonction partie entière : floor(x) est le plus grand entier inférieur ou égal à x.

> sqrt(1250);ln(exp(7));arctan(1);

> floor(-7.98);floor(7.98);

La fonction Gamma d'Euler :

> GAMMA(x)=Int(t^(x-1)*exp(-t),t=0..infinity);

GAMMA(x) = Int(t^(x-1)*exp(-t),t = 0 .. infinity)

LES COMPLEXES : de type complex , sont constitués de deux réels , la partie réelle et la partie

imaginaire .

> z:=1-5*I*sqrt(2):z,Re(z),Im(z);

evalc : fonction d'évaluation des nombres complexes

> z:=evalc((1+exp(1)^(I*Pi/6))/(1-I));

> Digits:=10:evalf(z);

> map(evalc,polar(a+I*b));

Quelques fonctions utilisant les complexes:

abs(z) , argument(z) , conjugate(z) : module , argument dans ]-Pi,Pi] , conjugué de z .

> z:=1+sqrt(3)*I:abs(z),argument(z),conjugate(z);

AUTRES TYPES:

LE TYPE BOOLEAN :

Les booléens sont de type boolean et peuvent prendre 2 valeurs : false et true .

Si MAPLE ne parvient pas à résoudre un problème , il peut rendre le résultat FAIL .

Les opérateurs logiques sont : not (non) , or (ou) , and (et) , xor (ou exclusif) , implies (implication).

Une expression booléenne peut être évaluée par la fonction evalb :

> t:=10:
evalb(t*t>0),evalb(isprime(t) and t>0);

> evalb(evalf(exp(1))<evalf(Pi));

LES TYPES NOM (name), SYMBOLE (symbol), et INDEXÉ (indexed):

Une expression Maple est de type indexé, si elle définie à partir d'indices ou d'index. Elle est alors de

type indexed .
Exemple: est une variable indexée, contrairement à la variable

> type(a[x],`indexed`);

> type(nom_var,`indexed`);

Un nom, de type name , est une expression Maple définie à partir d'une lettre, suivie d'autres lettres
ou de chiffres, ou d'autres symboles, comme _ ,ou si elle est de type indexé.

Un nom peut aussi être formé en entourant une séquence de caractères par des accents graves ` `.

> type(a[x],`name`);

>

type(nom_var,`name`);

> type(a/b,`name`);

> type(`12345`,`name`);

> type(12345,`name`);

Un symbole, de type symbol, est une expression Maple qui est un nom, mais n'est pas de type indexé.

> type(a[x],`symbol`);

> type(nom_var,`symbol`);

> type(a/b,`symbol`);

Quelques fonctions utilisant ces types:

length ( c ) retourne la longueur de c ( c étant un nom ou un symbole ) .

L'opérateur de concaténation || ou la fonction cat permettent de rassembler 2 noms ou symboles.

> length(nom_var);

> nom_var || a;

> cat(nom_var,a);

LE TYPE CHAÎNE DE CARACTÈRES (string):

Les chaînes de caractères, de type string , se notent entre guillemets " " :
par exemple , "MAPLE " et "7 pour Linux et Windows" sont 2 chaînes de caractères .

L'opérateur de

concaténation || permet de rassembler 2 chaînes de caractères :

> ch:="MAPLE " || "7 pour Linux et Windows";