Opération matricielle

Soyez le premier à donner votre avis sur cette source.

Vue 19 490 fois - Téléchargée 478 fois

Description

C'est un ensemble de codes qui permettent d'éfectuer les opérations matricielles comme l'addition la multiplication, la transposée, la comatrice, l'inversion,...
Vous n'avez qu'à appeller une fonction et l'utiliser. J'espère que cela va vous être utile;

Source / Exemple :


# -*- coding: cp1252 -*-

# C'est un ensemble de codes sources permettant d'effectuer les opérations matricielles, à savoir
# l'addtion, la multiplication, le déterminant, la comatrice, la transposée d'une matrice, l'inverse d'une matrice
#Extraire une ligne i et une colonne j d'une matrice. Notez q'une matrice a pour syntaxe:
# A=[[a, b],[c,d]], la matrice est représentée ligne par ligne donc A est équivalent à:   
# [a   b]
# [ c  d]

def Extrtlincol(m,n,M):
      "retourne la matrice A sans la m ième ligne et la n ième colonne"
      Mlin=len(M)
      result=[]
      Rep=[]
      for i in range(Mlin):
            if i!=m:
                  for j in range(Mlin):
                        if (j!=n):
                              result.append(M[i][j])
      for k in range(0,len (result),Mlin-1):
            Rep.append(result[k:k+Mlin-1])
      return Rep
##################################################
def Det(A):
      " retourne le déterminat de la matrice A"
      if len(A)==1:
            return A[0][0]
      if len(A)==2:
            r=A[0][0]*A[1][1]-A[0][1]*A[1][0]
            return r
      else:
            s=0
            j=0
            while j<len(A):
                  B=Extrtlincol(j,0,A)
                  if j%2==0:
                        s=s+A[j][0]*Det(B)
                  else:
                        s=s-A[j][0]*Det(B)
                  j=j+1
            return s
######################################################                  
def  comat(A):
      "Donne la comatrice d'une matrice A"
      N=len (A)
      k=0
      com=[None]*N
      while k<N:
            com[k]=[0]*N
            l=0
            while l<N:
                  B=Extrtlincol(k,l,A)
                  if (k+l)%2==0:
                        com[k][l]=(Det(B))
                  else:
                        com[k][l]=((-1)*Det(B))
                  l=l+1
            k=k+1
      return com
###################################################
def transpos(A):
      "Donne la transposée d'une matrice A"
      N=len(A)
      M=[None]*N
      for i in range(N):
            M[i]=[0]*N
            for j in range(N):
                  M[i][j]=A[j][i]
      return M
#####################################################
def multcoef(A,r):
      "Donne le produit d'une matrice A par le coefficient r"
      N=len(A)
      Mat=[None]*N
      for i in range(N):
            Mat[i]=[0]*N
            for j in range(N):
                  Mat[i][j]=r*A[i][j]
      return Mat
######################################################                  
      
def invmat(A):
      "Donne l'inverse d'une matrice carrée  A"
      d=Det(A)
      if d==0:
            return 'La Matrice n\'est pas inversible'
      else:
            B=multcoef(comat(A),1./d)
            inv=transpos(B)
      return inv
###############################################################      
def Multmat( Mat1,Mat2):
      "Donne le produit de deux matrices"
      Mat1lign,Mat1col= len (Mat1), len (Mat1[0])
      Mat2lign,Mat2col= len (Mat2), len (Mat2[0])
      A=[]
      M=[None]*Mat1lign
      if  Mat1col!=Mat2lign:
            print " Erreur!  Votre première matrice à un nombre de colonne\ n inferieur à celle de la seconde matrice"
      for  i in  range(Mat1lign):
            M[i]=[0]*Mat2col
            for j in range(Mat2col):
                  for k in range(Mat1col):
                        M[i][j]=M[i][j]+Mat1[i][k]*Mat2[k][j]
      for m in range(Mat1lign):
            print M[m]
####################################################
def Addmat(M1,M2):
      "Additionne deux matrices carrées"
      N=len(M1)
      M=[None]*N
      for i in range (N):
            M[i]=[0]*N
            for j in range (N):
                  M[i][j]=M1[i][j]+M2[i][j]
      return M

Codes Sources

A voir également

Ajouter un commentaire

Commentaire

Messages postés
19
Date d'inscription
mardi 30 septembre 2008
Statut
Membre
Dernière intervention
3 août 2009

Salut

Le programmeur qui utilise ton code ne devrait pas avoir à comprendre le modèle que tu utilises pour tes matrices, ni à retenir le nom de toutes tes fonctions.
C'est pourquoi ce serait Beaucoup Mieux si tu définissais une classe matrice. Tu pourrais alors définir les opérateurs associés : +, -, * etc.
J'ai pas le temps de regarder le code de chaque fonction, mais je te fais confiance.

A+

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.