Commentçamarche.net
CodeS-SourceS
Rechercher un code, un tuto, une réponse

Opération matricielle

0/5 (1 avis)

Vue 15 247 fois - Téléchargée 185 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

Commentaires

Votre évaluation

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.