IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Opération sur ma matrice


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé Avatar de mouchT8
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    141
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 141
    Par défaut Opération sur ma matrice
    Bonjour,

    Me revoilà avec des problèmes de Matrice.
    C'est la première fois que j'utilise les Matrice, et ça se voit !!

    J'ai plusieurs problèmes à résoudre mais tout d'abord commençons par ce qui me pose le plus gros problème!

    J'ai une matrice carré 4X4 a initialiser jusque là pas trop de problème mais là ou ça "choc" c'est lorsque je doit calculer le déterminant !
    Je ne trouve pas la formule correcte !!!
    Pour une 2X2 facil, POur une 3X3 idem, mais la 4X4 ...

    J'ai bien une "formule" donné par mon énoncé mais alors impossible de la rentré correctement avec VS !!

    La voici:

    Det(A)= detA = somme[1<=i<=n] (-1)i+1 ai1 |Aij|;

    avec
    A: une matrice carrée
    (a): l'élément unique de la matrice
    (aij): les éléments de la matrice (je sais pas pourquoi mais les indices ne s'affiche pas dsl)
    det(A): le déterminant
    A(ij) une sous matrice de A

    J'avoue que je ne comprend rien !!!
    N'y aurait t il pas une formule plus "soft" ???

    Merci de votre aide !!

  2. #2
    Expert confirmé

    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    4 253
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Février 2007
    Messages : 4 253
    Billets dans le blog
    3
    Par défaut
    Ben non... c'est la formule de base du déterminant.... Et c'est la même quelque soit la taille de matrice...

    On prend une colonne (ou un ligne), et pour chaque element on ajoute (pour les index pairs) ou on retire (pour les index impairs) sa valeur multiplié par le determinant de la matrice qui reste une fois qu'on a enleve la colonne et la ligne de cet élément.

    Pour
    00 01
    10 11
    on a donc: 00 * det(11) - 10 * det(01) = 00 * 11 - 10 * 01

    Pour:
    00 01 02
    10 11 12
    20 21 22
    on a donc: 00 * det (11,12,21,22) - 10 * det(01,02,21,22) + 20 * det(01,02,11,12)
    soit: 00*11*22 - 00*12*21 - 10*01*22 + 10*21*02 + 20*01*12 - 20*02*11


    Pour:
    00 01 02 03
    10 11 12 13
    20 21 22 23
    30 31 32 33

    Le determinant est:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
             11 12 13             01 02 03             01 02 03             01 02 03
    00 * det(21 22 23) - 10 * det(21 22 23) + 20 * det(11 12 13) - 30 * det(11 12 13)
             31 32 33             31 32 33             31 32 33             21 22 23
    Maintenant, je ne sais pas ce que tu fais sur ces matrices, peut-être ont elles des particularités ?
    Parceque pour une matrice 'quelconque', ca fait quand même (n! - 1) additions et (n-1)*n! multiplications

  3. #3
    Membre confirmé Avatar de mouchT8
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    141
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 141
    Par défaut
    non je ne fait rien de particulier,
    c'est une simple matrice, juste pour apprendre à les manipuler quoi.

    Mais le probleme c'est que de la manière dont la formule est écrite, j'ai plein d'erreur sur cette ligne avec VS.
    Deja les indices ne s'écrivent pas en indices
    et on dirait qu'il manque des opérateurs non ??
    Mon dieu que le temps du lycée est loin

  4. #4
    Membre éprouvé Avatar de Flow_75
    Femme Profil pro
    Ingénieure
    Inscrit en
    Mai 2005
    Messages
    1 100
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 42
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieure
    Secteur : Transports

    Informations forums :
    Inscription : Mai 2005
    Messages : 1 100
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Det(A)= detA = somme[1<=i<=n] (-1)i+1 ai1 |Aij|
    Tu le code comment sous VC ?

    sinon, la méthode de nicroman est correcte pour un déterminant d'une matrice 4x4 et assez simple à coder si tu as fait le calcul de déterminant pour 3x3

  5. #5
    Expert confirmé

    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    4 253
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Février 2007
    Messages : 4 253
    Billets dans le blog
    3
    Par défaut
    Faudrait voir un bout de code...
    C++ (forum C++)


    Voici un 'exemple' de code (j'ai pas compilé, mais l'idée y est):
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     
    /// on passe n ligne de n valeurs....
    template<type T> T det(int numRows, const T** rows)
    {
         int numSubRows = numRows - 1;
         if (numSubRows == 0)
             return rows[0][0];
     
         T acc = 0;
     
         const T** subrows = new (const T*)[numRows-1];
         for (int i = 0; (i < numRows); ++i) {
             // filling subrows
             if (i == 0) {
                 // initial setup
                 for (int j = 0; (j < numSubRows ); ++j) 
                    subrows[j] = rows[j+1] + 1;
             } else {
                 // we just have to replace row i-1  !!!
                 subrows[i-1] = rows[i-1] + 1;
             }
             T subdet = det<T>(numSubRows,subrows);
             if (i % 2)
                acc -= rows[i][0] * subdet;
             else
                acc += rows[i][0] * subdet;
         }
         delete [] subrows;
         return acc;
    }

  6. #6
    Expert confirmé

    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    4 253
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Février 2007
    Messages : 4 253
    Billets dans le blog
    3
    Par défaut
    Et un exemple à base de template (déroulés)
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
     
    ///
    /// Initial setup of sub-elements, starting with last row...
    ///
    template<type T, int row> void det_subelts_setup(const T** elts, const T** subelts)
    {
        det_subelts_setup<T,row-1>(elts,subelts);
        subelts[row] = elts[row]+1;
    }
    ///
    /// Specialisation when row index is 0 (no call to previous row)
    ///
    template<type T, 0> void det_subelts_setup(const T** elts, const T** subelts)
    {
        subelts[0] = elts[0] +1;
    }
     
    ///
    /// Code factorisation to retrieve a sub-matrix * element value
    ///
    template<type T, int n, int row> T det_part(const T** elts, const T** subelts)
    {
        return (row%2) ? 
            -elts[row][0] * det<T,n-1>(subelts) :
            +elts[row][0] * det<T,n-1>(subelts);
    }
     
    ///
    /// Determinant accumlation for any row (subelts must be already setup 
    /// for that row).
    ///
    template<type T, int n, int row> T det_acc(const T** elts, const T** subelts)
    {
        // subelts is already setup to handle row !
        T ret = det_part<T,n,row>(elts,subelts);
        // replacing previous row
        subelts[row-1] = elts[row]+1;
        // accumulating (loop)
        ret += det_acc<T,n,row-1>(elts,subelts);
        return ret;
    }
    ///
    /// Specialisation for row 0 (no call to previous row)
    ///
    template<type T, int n, 0> T det_acc(const T** elts, const T** subelts)
    {
         return det_part<T,n,row>(elts,subelts);
    }
     
    ///
    /// Determinant function:
    /// - Prepare sub-rows
    /// - Start accumulation
    template<type T, int n> det(const T** elts)
    {
         const T* subelts[n-1];
         det_subelts_setup<T,n-2>(elts,subelts);
         // making the loop
         return det_acc<T,n,n-1>(elts,subelts);
    }
     
    /// specialization for n==1
    template<type T,1> T det(const T** elts)
    { 
        return elts[0][0];
    }
     
    /// specialization for n==2 (optionel)
    template<type T,2> T det(const T** elts)
    { 
        return elts[0][0]*elts[1][1] - elts[0][1]*elts[1][0];
    }

    Là encore, j'ai pas compilé... mais le coeur y est !

Discussions similaires

  1. programme qui fait des opérations sur la matrices
    Par nomadstorm dans le forum Débuter
    Réponses: 6
    Dernier message: 06/01/2010, 23h05
  2. API pour effectuer des opérations sur des matrices
    Par Mobius dans le forum API standards et tierces
    Réponses: 2
    Dernier message: 14/11/2008, 15h18
  3. Opérations sur les matrices
    Par mister3957 dans le forum Développement 2D, 3D et Jeux
    Réponses: 2
    Dernier message: 01/11/2007, 23h47
  4. Opérations sur les matrices...
    Par aokiseiichiro dans le forum C
    Réponses: 32
    Dernier message: 28/07/2005, 17h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo