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

Vecteur-colonne d'ordre 3 avec initialisation:

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

Matrice carrée d'ordre 2 sans initialisation:

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

Matrice carrée d'ordre 2 avec initialisation:

> N:=array([[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);

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

> evalm(M &* N);

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

> evalm(N^(-1));

Puissance n-ième avec ^n

> evalm(N^3);

Multiplication par un scalaire avec *

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

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

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

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

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

> inverse(N);

Multiplication par un scalaire avec scalarmul

> scalarmul(P,lambda);

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

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

> colspace(A);

> rowspace(A);

Matrice caractéristique: , .

> charmat(A,lambda);

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

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

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

> stackmatrix(A,N);

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

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

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

transpose(M) permet de transposer la matrice M :

> print(M);transpose(M);

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

Matrices particulières:

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

> JordanBlock(expr,4);

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

Rechercher les matrices carrées X d'ordre 2 telles que , où .

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

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

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

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

Donc 4 matrices solutions.

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

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

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