Apprendre Maple Polynômes et fractions rationnelles

 
  Page d'accueilPage d'accueil   RechercherRechercher   Forum de discussionForum de discussion   ContactContact   SommaireSommaire 
  Cours MapleCours Maple   Travaux dirigésTravaux dirigés   Thèmes d'activitésThèmes d'activités   Thèmes d'activitésMaplets
Ecran MapleEcran Maple  TéléchargementTéléchargement  BibliographieBibliographie  LiensLiens  

 

Page d'accueil   Cours Maple   << Chapitre précédent   Chapitre suivant >>



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);

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);

true, `+`, `*`

 

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

 

> nops(P),nops(Q);

3, 3

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

 

> op(P);op(Q);

-7*x, 5*x^2, 75*x^3

x, (2*x-3*y)^2, x-y

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

> coeff(P,x^3);

75

> coeff(P,x,3);

75

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

> coeffs(P);coeffs(Q);

5, 75, -7

 

Error, invalid arguments to coeffs

> coeffs(expand(Q));

-16, 21, -9, 4

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

> lcoeff(P),tcoeff(P);

75, -7

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

-9*x, 4*x^4

Degré et valuation:

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

3, 4, 3

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

1, 1, 0

 

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;

x^3-x^2+1

-2-x

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;

-2-x

x^3-x^2+1

 

Discriminant:

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

-4*a^3-27*b^2

Evaluer, ordonner, transformer un polynôme:

 

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

-15+5*I

Ordonner Q selon les puissances décroissantes de y:

> sort(expand(Q),y);

-9*x*y^3+21*x^2*y^2-16*x^3*y+4*x^4

Développer:

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

x-x*a^2+x^2-2*x*y-3*y+3*y*a^2-3*y^2+a-a^3+a*x+a*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);

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

Mettre P sous la forme de Hörner:

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

-7*x+5*x^2+75*x^3

H := (-7+(5+75*x)*x)*x

> with(codegen,cost);

[cost]

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

 

> cost(P),cost(H);

2*additions+6*multiplications, 3*multiplications+2*...

Factoriser sur le corps Q des rationnels

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

(1+x)*(x^2+1)

Normaliser:

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

16*x^2-23*x+8

 

 

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);

-.6823278038

> fsolve(P,x,complex);

-.6823278038, .3411639019-1.161541400*I, .341163901...

 

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

> realroot(P,0.001);

[[-699/1024, -349/512]]

Calcul des zéros avec solve(P) :

> solve(x^4+1);

1/2*sqrt(2)+1/2*I*sqrt(2), 1/2*I*sqrt(2)-1/2*sqrt(2...

 

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

> factor(x^4-1);

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

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

-(x+I)*(-x+1+I)*(x+1)

 

Pour obtenir la factorisation complète:

factor (P,{ alpha[1], alpha[2] ,..., alpha[n] }) autorise Maple à factoriser P sur un corps contenant les nombres algébriques alpha[1], alpha[2] ,..., alpha[n]

 

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

-(x+I)*(-x+I)*(x+1)*(x-1)

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

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

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

(x-I*sqrt(2))*(x+I*sqrt(2))*(x-1)

 

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

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

P := (x+RootOf(_Z^2+1))*(x-1)*(x-RootOf(_Z^2+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;

(x+alpha)*(x-1)*(x-alpha)*(x+1)

Pour calculer les valeurs possibles de alpha :

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

I, -I

 

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);

[[-I, 1], [I, 1]]

 

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)

(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, { alpha[1], alpha[2] ,..., alpha[n] } ) autorise Maple à décomposer sur un corps contenant les nombres algébriques alpha[1], alpha[2] ,..., alpha[n]

 

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))};

{1/2*sqrt(2)+1/2*I*sqrt(2), -1/2*sqrt(2)-1/2*I*sqrt...

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 P = X(X-1)(X-2)(X-3) .

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);

dP := 4*X^3-18*X^2+22*X-6

> zeros:=[solve(dP)];

zeros := [3/2, 1/2*sqrt(5)+3/2, 3/2-1/2*sqrt(5)]

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);

zeros := [3/2-1/2*sqrt(5), 3/2, 1/2*sqrt(5)+3/2]

On calcule les écarts entre 2 termes consécutifs , la raison est sqrt(5)/2 :

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

1/2*sqrt(5)

1/2*sqrt(5)

 


 

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 :

 

P(x) = ((((a[n]*x+a[n-1])*x+a[n-2])*x+` . . . `+a[2...

 

Exemple:

Q := 3*x^4+2*x^3-x^2+2*x+1

Q := (((3*x+2)*x-1)*x+2)*x+1

 

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 


©  - Alain Le Stang - Navigation optimisée pour une résolution 1024 x 768.