Les fonctions courantes de Maple
Maple peut être très utile, à condition de savoir le maitriser.
Voici un mini formulaire, qui ne remplacera pas un cours, mais saura vous aider pour les trous de mémoire.
En marquant la fonction avec une majuscule sur la première lettre, on affiche l'expression qui va être calculée. Cela permet de clarifier la lecture du document !
Manipulation d'expression
Valeurs approchées :
> evalf(Pi,25);
\(3.141592653589793238462643\)
Tests Logiques :
> is(2>1);
\(true\)
Sommes
> Sum(x,x=1..5) = sum(x,x=1..5);
\(\sum_1^5 x=15\)
Produits
> Product(x,x=1..5) = product(x,x=1..5);
\(\prod_1^5 x=120\)
Manipulation de fonctions
Définition de fonction :
Attention à bien faire la différence entre une fonction et une expression.
Pour créer directement une fonction :
> f:=x->1/(x*(x+1)*(x+2)(x+3));
\(f:=x\rightarrow\frac{1}{x(x + 1)(x + 2)(x + 3)}\)
On peut aussi transformer une expression (i.e une chaine alphanumérique) en fonction, il suffit d'indiquer de quelles variables doit dépendre la fonction.
> f:=unapply(1/(x*(x+1)*(x+2)(x+3)),x);
\(f:=x\rightarrow\frac{1}{x(x + 1)(x + 2)(x + 3)}\)
Fractions
Décomposition en élements simples :
> convert(f(x),parfrac,x);
\(\frac{1}{2(x+2)} + \frac{1}{6x} - \frac{1}{6x+3} - \frac{1}{2(x+1)}\)
Réduction au même dénominateur
> Req:=1/((1/R1)+(1/R2));
\(Req:=\frac{1}{\frac{1}{R_1}+\frac{1}{R_2}}\)
> normal(Req);
\(\frac{R_1R_2}{R1+R2}\)
Tri par puissances décroissantes
> sort(1/(x+x^2+1));
\(\frac{1}{x^2+x+1}\)
Dérivation, primitives et intégration :
> f:=x->sqrt(x)+cos(x);
\(f:=x\rightarrow \sqrt{x}+\cos(x)\)
Dérivation :
> Diff(f(x),x)=diff(f(x),x);
\(\frac{d}{dx}\left(\sqrt{x}+\cos(x)\right) = \frac{1}{2\sqrt{x}}-\sin(x)\)
Primitives :
> Int(f(x),x)=int(f(x),x);
\(\int \,\sqrt{x}+\cos(x)dx = \frac23 x^{\frac32}+\sin(x)\)
Intégration
> Int(x^9,x=0..1)=int(x^9,x=0..1);
\(\int_0^1\,x^9dx = \frac{1}{10}\)
Somme :
> u:=n->sum(f(k),k=1..n-1);
\(u:=n \rightarrow \sum_{k=1}^{n-1}f(k)\)
Limites :
> Limit(u(x),x=+infinity) = limit(u(x),x=+infinity);
\(\lim_{x \rightarrow \infty} \left(\frac{1}{3x(x+1)(x+2)}+\frac{1}{18} \right) = \frac{1}{18}\)
Linéarisation
> sin(x)^5 = combine(sin(x)^5);
\(\sin(x)^5=\frac{1}{16}\sin(5x)-\frac{5}{16}\sin(3x)+\frac58 sin(x)\)
Développement
> expand((x+1)^5*(x-1)^2);
\(x^7 + 3x^6 + x^5 - 5x^4 - 5x^3 + x^2 + 3x + 1\)
Factorisation
> factor(x^7 + 3*x^6 + x^5 - 5*x^4 - 5*x^3 + x^2 + 3*x + 1);
\((x+1)^5(x-1)^2\)
On peut aussi indiquer par quel nombre on souhaite factoriser en deuxième argument.
Développements limités
> taylor(sin(x),x=0,7);
\(x-\frac16x^3+\frac{1}{120}x^5+o(x^7)\)
Fonctions polynomiales
Degré d'un polynome
> degree(x^2+9);
\(2\)
Valuation d'un polynome
> degree(x^2+9,lcoeff);
\(0\)
Quotient et reste
Quotient
> quo(x^2+x,x-1,x);
\(x+2\)
Reste
> rem(x^2+x,x-1,x);
\(2\)
Algèbre linéaire
Chargement du package :
> restart:with(linalg):
\(Warning,\,the\, protected\, names\, norm\, and\, trace\, have\, been\, redefined\, and\, unprotected\)
Maple indique donc que certaines fonctions ont changées : il montre aussi toutes les nouvelles fonctions chargées.
Définition de vecteurs :
V:=vector(dimension,[..,..,...];
> A:=vector(4,[3,2,3,4]);
\(A:= \begin{bmatrix} 3 & 2 & 3 & 4 \end{bmatrix}\)
> B:=vector(4,[1,1,0,0]);
\(B:= \begin{bmatrix} 1 & 1 & 0 & 0 \end{bmatrix}\)
> B2 :=scalarmul(B,2);
\(B2:= \begin{bmatrix} 2 & 2 & 0 & 0 \end{bmatrix}\)
> C:=vector(4,[2,1,5,0]);
\(C:= \begin{bmatrix} 2 & 1 & 5 & 0 \end{bmatrix}\)
Produit scalaire:
> dotprod(A,C);
\(23\)
Produit vectoriel
> crossprod(A,B);
Ne fonctionne pas avec les deux vecteurs utilisés, car ils doivent être de dimension 3.
Bases, images, espaces vectoriels, matrices:
Création de matrice:
A partir de deux vecteurs :
> M:=concat(A,C);
\(M:= \begin{bmatrix} 3 & 2 \\ 2 & 1 \\ 3 & 5 \\ 4 & 0 \end{bmatrix}\)
Directement avec des valeurs :
> L:=matrix(4,2,[3,2,2,1,3,5,4,0]);
\(M:= \begin{bmatrix} 3 & 2 \\ 2 & 1 \\ 3 & 5 \\ 4 & 0 \end{bmatrix}\)
Matrice Identité :
Par défaut, Maple ne permet pas de créer une matrice identité...mais on peut ruser !
> diag(seq(1,x=1..4));
\(M:= \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\)
Deuxième solution :
> diag(1$4);
\(M:= \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\)
Produit de matrices:
> N:=matrix(2,4,[2,0,1,0,4,5,9,0]);
\(N:= \begin{bmatrix} 2 & 0 & 1 & 0 \\ 4 & 5 & 9 & 0 \end{bmatrix}\)
Attention ! Pour la multiplication de matrices, on utilise le symbole &* et pas * !
> LN:=evalm(L&*N);
\(LN := \begin{bmatrix} 14 & 10 & 21 & 0 \\ 8 & 5 & 11 & 0 \\ 26 & 25 & 48 & 0 \\ 8 & 0 & 4 & 0 \end{bmatrix}\)
> LN:=multiply(L,N);
\(LN := \begin{bmatrix} 14 & 10 & 21 & 0 \\ 8 & 5 & 11 & 0 \\ 26 & 25 & 48 & 0 \\ 8 & 0 & 4 & 0 \end{bmatrix}\)
Multiplication matrice-scalaire:
> L3:=evalm(3*L);
\(L3:= \begin{bmatrix} 9 & 6 \\ 6 & 3 \\ 9 & 15 \\ 12 & 0 \end{bmatrix}\)
> L3bis:=scalarmul(evalm(L),3);
\(L3bis:= \begin{bmatrix} 9 & 6 \\ 6 & 3 \\ 9 & 15 \\ 12 & 0 \end{bmatrix}\)
Addition de 2 matrices:
> evalm(M+L3);
\(N:= \begin{bmatrix} 12 & 8 \\ 8 & 4 \\ 12 & 20 \\ 16 & 0 \end{bmatrix}\)
On utilise evalm pour forcer l'affichage de la matrice
Noyau, image:
Noyau
> kernel(N);
\(\begin{Bmatrix} [1,\frac{14}{5},-2,0],[0,0,0,1] \end{Bmatrix}\)
Base de l'image
> colspace(N);
\(\begin{Bmatrix} [1, 0], [0, 1] \end{Bmatrix}\)
Calcul d'une base
> basis([A,B,C,B2]);
\([A, B, C]\)
(on avait bien défini B2 linéairement dépendant de B : la base ne l'inclue donc pas)
Déterminant :
> det(LN);
\(0\)
Vecteurs et valeurs propres:
On va redéfinir les matrices, pour simplifier les exemples :-) !
> L:=matrix(2,2,[1,0,0,1]);
\(L3:= \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}\)
> eigenvectors(L);
\([1, 2, \{[1, 0], [0, 1]\}]~\)
1=valeur propre, 2=sa multiplicité, 3=base du SEV propre associé.
Eh oui, ce serait bien d'avoir droit à Maple en interro !
Matrice transposée:
> transpose(N);
\(L3:= \begin{bmatrix} 2 & 4 \\ 0 & 5 \\ 1 & 9 \\ 0 & 0 \end{bmatrix}\)
Pour résoudre une équation
> linsolve(LN,A);
\(\left[t_1,\frac{14}{5}t_1-\frac95,-2t_1+1,t_2\right]\)
Intersection de bases
> AB:=basis([A,B]);
\(AB := [A, B]\)
> B2C:=basis([B2,C]);
\(B2C := [B2, C]\)
> intbasis(AB,B2C);
\(\{[2, 2, 0, 0]\}~\)
