C koi l'algo pour calculer le determiant d'une matrice a 2 dimension de taille [n][n]?
C chaud et je trouve pas

essai avec les co-matrice

et c'est koi?

Vendeeman a écrit a écrit : C koi l'algo pour calculer le determiant d'une matrice a 2 dimension de taille [n][n]? C chaud et je trouve pas

Qu'appelle tu une matrice à 2 dimensions si elle est de taille [n][n]. Pour moi ça veux dire que (n - 2) lignes ou colonnes sont des combaisons linéaires des 2 restantes. J'ai du mal à croire que ce soit ton problème ?!

je crois que ça veut tout simplement dire une matrice carrée (au vu du post...)

Oui, je veux bien, mais en math, il faut être précis.

euh, j'ai un doute Ca existe le déterminant d'une matrice non carrée  
pffff la prépa c loin

dropsy a écrit a écrit : euh, j'ai un doute Ca existe le déterminant d'une matrice non carrée   pffff la prépa c loin

 
ah ba non ca existe, pas. gtait une burne en math apres le bac, maos qd meme.
pour repondre a la question, j'ai déja vu trainé l'algo quelquepart, mais je saispu ou, mais faut bien chercher et c un truc baleze car il y a plein de recusivité!

Bon un déterminant c'est tout con.
if (!matrice_carré(matrice)) {
   print "grosse burne";
}
else {
   return sarrus(matrice);
}
 
où sarrus est la règle de Sarrus. On somme le produit des éléments d'une même diagonale (cyclique) et on soustrait la somme des produits des antidiagonales.

ah ba oui, vu de ce point, c tout con, c sur !!!
Ce qu'il veut Vendeeman, je pense que ce serait le code source de la fonction sarrus(), ou alors si elle est déja implémenté dans le langage ou il veut écrire son algo, ce serait top !!!

Aurel a écrit a écrit :   ah ba oui, vu de ce point, c tout con, c sur !!! Ce qu'il veut Vendeeman, je pense que ce serait le code source de la fonction sarrus(), ou alors si elle est déja implémenté dans le langage ou il veut écrire son algo, ce serait top !!!

Ouais, mais Vendeeman il faut qu'il bosse aussi un peu.

bon ba bonne chance Vendeeman, alors...

En basic sur Ti89 tu fais det([x,y;z,w]) et hop ta le déterminant        

c pas si dur...
 
au moins pour une 3*3: ....Ex:
 
2 3 4
7 8 9
4 5 6
 
le det de cet matrice est: (2*8*6+3*9*4+7*5*4)-(4*8*4+3*7*6+9*5*2)
A partir de la tu mets des i pour ligne et j pour colonne dans ton algo...mais je suppose que tu veux que ca marche pour tout type de matrice ??
parce que pour une 4*4, ca se complique (moi je me ramène tjs a une 3*3) ...

Sarrus ne marche (efficaxcement en tout cas) que dans la cas 3*3

Allons bon !

Merci les mecs de vos explications
G tout compris!!!
Bon, resultat: j'y arrive pour une 3*3, et pis au dessus, ben tant pis
 
AU fait, c ki Sarrus

Tu codes sous koi comme langage ??? Si tu veux j'ai un algorithme c++ qui utilise de la recurisvité et qui résoud pour n'importe quelle grandeur

Vendeeman a écrit a écrit :   AU fait, c ki Sarrus

Un mathématicien ?

bon c'est du c ou pas ??? que tu veux ??

Tu peux me l'envoyer par mail ton algo stp
vendeeman@libertysurf.fr
Merci
C pr ce soir que j'en aurais desoin!

j'crois qu'il y avait une methode avec un pivot de gauss
genre tu ramenes ta matrice a une forme diagonale superieure.
 
Tu ne t'autorises que deux operations:
Une soustraction d'une ligne par une ligne d'ordre superieure
multiplie par un facteur reel non nul.
Une permutation de lignes si tu te retrouves avec un zero sur une diagonale et les coefficients de colonne inferieurs. (en n'oubliant pas de multiplier ton determinant par -1).
 
A la fin ca se ramene a calculer le produit des coefficients
sur la diagonale.
 
J'ai pas l'algo detaille en tete mais fais recherche
gauss + determinant
 
A+
LEGREG

bon le probleme de ce calcul c'est qu'il n'est pas deterministe
(contrairement a un calcul systematique avec la formule des determinants
det= somme sur p(sig(p)*produit(a(i,p(i))) )  
 
Mais qui s'en soucie .
 
A+
LEGREG

// Algorithme recursif de calcul du déterminant d'une matrice n*n
 
// tu dois insérer ce code dans une classe car le tableau ne passe pas par
// l'appel de la fonction, ou alors tu fais un tableau global beurk
 
 
int det(unsigned i)
{
 int d, s, j ;
   if(i < n-1)
   {
    d=0;
      s=-1;                //utilisé pour l'alternance + - + - + - ...
      for(j=0; j<n; ++j)
      {
       if(V[j])
         {
          s=-s;
            V[j]=false;
            d+=s*M[i][j]*det(i+1);        // appel recursif
            V[j]=true;
         }
      }
   }
   else
   {
    j=0;
      while(!V[j])
       ++j;
      d=M[i][j];
   }
   return d;
}
 
// tu dois déclarer dans le private de ta classe un tableau V de taille n
// int V[n]; n étant le nombre de ligne (=colonne) de ta matrice carré
// dans mon code, ta matrice s'appelle M
// tu dois donc avoir créé une matrice int M[n][n];
// si tu ne sais pas ce que c'est que la recursivité, il est normal que tu ne
// comprennes rien au code précédent
// @+

Arghhhhhhhhhhhh l'indentation ne ressemble à rien !!!!!
 
@+ ++

le probleme de ta methode
c'est qu'elle revient en complexite a calculer
le determinant avec la formule du determinant
et qu'elle est tres inefficace.
(nombreuses operations redondantes)
 
la methode de reduction de matrices par Gauss-Jordan,
est plus rapide et est facile a mettre en oeuvre.
(meme si ce n'est pas la plus rapide)
 
LEGREG