Bonjour,
Je cherche à écrire une fonction de recherche du code dual d'une matrice. J'ai essayé un code par une élimination de gauss (que j'ai peché sur internet puis legerement modifié)mais quand je teste la matrice que j'obtiens sur un vecteur, que je multiplie par la matrice d'origine puis je remultiplie par la matrice duale, je n'obtiens pas 0 !
est ce que quelqu'un aurait une idee sur comment faire pr obtenir le code dual?
Je vous remercie bcp pr l'aide!

voici ma fonction:

[cpp]

// starting from HH matrix, an int** of _M by N

/* invert HH matrix here */
    /* row and column indices */
    int* ir = new int [_M];
    int* jc = new int[_N];
    for( int i=0 ; i<_M ; i++)
        ir[i] = i;
    for( int j=0 ; j<_N ; j++)
        jc[j] = j;

    /* perform Gaussian elimination on H, store reodering operations */
   int rdep = 0; /* number of dependent rows in H*/
   int d = 0;    /* current diagonal element */
    while( (d+rdep) < _M) { /* cycle through independent rows of H */ 
        int j = d; /* current column index along row ir[d] */
        while( (HH[ir[d]][jc[j]] == 0) && (j<(_N-1)) )
            j++;            /* find first nonzero element in row i */
        if( HH[ir[d]][jc[j]] ) { /* found nonzero element */
            /* swap columns */
            int tmp = jc[d]; jc[d] = jc[j]; jc[j] = tmp;
            if(_q==2) { /* GF2 */
              /* eliminate current column using row operations */
                for(int ii=0 ; ii<_M ; ii++)
                 if(matrH[ir[ii]][jc[d]] && (ii != d)) /* nonzero and non-diagonal */
                    for(int jj=d ; jj<_N ; jj++)
                     HH[ir[ii]][jc[jj]] = (HH[ir[ii]][jc[jj]]+HH[ir[d]][jc[jj]])%2;
            }
            else { /* GFq */                 
                int scale = GFq_inv(matrH[ir[d]][jc[d]],_q); /* inverse of the diag. element */
                /* scale the current row to make the first element 1 */
                for(int jj=0 ; jj<_N ; jj++)
                    HH[ir[d]][jc[jj]] = GFq_m(matrH[ir[d]][jc[jj]],scale,_q);
                /* eliminate current column using row operations */
                for(int ii=0 ; ii<_M ; ii++) {
                    if(HH[ir[ii]][jc[d]] && (ii != d)) {
                        scale =HH[ir[ii]][jc[d]];
                        for(int jj=d ; jj<_N ; jj++) {
                            tmp = GFq_m(HH[ir[d]][jc[jj]],scale,_q);
                            H[ir[ii]][jc[jj]] = GFq_ad(matrH[ir[ii]][jc[jj]],tmp);
                        }
                    }
                }
            }
        }
        else { /* all zeros -  need to delete this row and update indices */
            rdep++; /* increase number of dependent rows */
            int tmp = ir[d];
            ir[d] = ir[_M-rdep];
            ir[_M-rdep] = tmp;
            d--; /* no diagonal element is found */
        }
        d++; /* increase the number of diagonal elements */
    }/*while i+rdep*/
/* done inverting HH */
    _K = _N-_M+rdep; /* true K */
/* create G matrix  G = [A'| I] if H = [I|A]*/


GG = new int*[_K]; 
   for(int i=0 ; i<_K ; i++)   GG[i] = new int [_N];
   
    for(int i=0 ; i<_K ; i++)
        for(int j=0 ; j<(_N-_K) ; j++) {
            int tmp = (_N-_K+i);
 
           GG[i][j] = HH[ir[j]][jc[tmp]];
        }
    for(int i=0 ; i<_K ; i++)
        for(int j=(_N-_K); j<_N ; j++)
            if(i == (j-_N+_K) ) /* diagonal */
               GG[i][j] = 1;
            else
                GG[i][j] = 0;



[/cpp]