CALCULER LA DÉTERMINANTE D'UNE MATRICE ALÉATOIRE DE GRANDEUR DÉFINIE

/* Juste la partie principale du code source. */

int choose_line( MATRIX *pMatrix )
{
        int curr = 0;
        int max  = 0;
        int line = 0;
        int i, j;

        for( i = 0 ; i < pMatrix->iSize ; i++ ) {
                for( j = 0 ; j < pMatrix->iSize ; j++ ) {
                        if( pMatrix->pData[XY( j, i, pMatrix->iSize)] == 0 )
                                curr++;
                }
                if( curr > max ) {
                        max = curr;
                        line = i;
                }
                curr = 0;
        }

        return line + 1;
}

int calc_minor( MATRIX *pMatrix, int Line, int Column )
{
        MATRIX *pTemp = NULL;
        int i = 0,
            j = 0;

        g_nbr_minors++;

        /* (-1) ^ (i+j) */
        i     = pow( -1, (long)(Line + Column) );
        /* La determinante de la matrice kon a si on supprimme la ligne et
         * la colonne de l'element dont on doit calculer le mineur.
         */
        pTemp = matrix_delete_line_column( pMatrix, Line, Column );
        j     = calc_determinante( pTemp );

        SAFE_FREE( pTemp->pData );
        SAFE_FREE( pTemp );

        return i * j;
}

int iLastPercent = -1;
int iLastPerthousand = 0;
int calc_determinante( MATRIX *pMatrix )
{
        int iChoosenLine = 1,
            iChoosenLineIsLine = 1,
            iResult = 0,
            a = 0,
            b = 0,
            i = 0,
            k = 0;
        float fPercent = 0.0f;

        g_real_nbr_determs++, g_virt_nbr_determs++;
        fPercent = (((float)g_virt_nbr_determs / (float)g_needed_determinants) * 100.0f);

        /* Actualiser la barre des % a chak fois kon est 1 % plus loin. */
        if( iLastPercent < (int)fPercent ) {
                iLastPercent = (int)fPercent;
                for( a = 0 ; a < 100 ; a++ )
                        printf( "\b" );
                printf( "Prog: |" );
                for( i = 0 ; i < (int)(fPercent / 2.0f) ; i++ )
                        printf( "=" );
                for( i = (int)(fPercent / 2.0f) ; i < 50 ; i++ )
                        printf( " " );
                if( fPercent < 10.0f )
                        printf( "|      ", fPercent );
                else
                        printf( "|       ", fPercent );
                fflush( stdout );
        }

        /* Actualiser l'affiche des % et du temps restant a chak fois kon est 0.1 % plus loin. */
        if( iLastPerthousand < (int)(fPercent * 10.0f) ) {
                iLastPerthousand = (int)(fPercent * 10.0f);

                /* Et afficher sa :p */
                if( fPercent < 10.0f )
                        printf( "\b\b\b\b\b%3.1f %%", fPercent );
                else
                        printf( "\b\b\b\b\b\b%3.1f %%", fPercent );
                fflush( stdout );
        }

        /* Si la matrice n'est plus ke de 2x2, alors c gagner ^^ */
        if( pMatrix->iSize == 2 )
                return pMatrix->pData[0] * pMatrix->pData[3] - pMatrix->pData[2] * pMatrix->pData[1];

        /* Autment bin tampi :p */
        /* On le fait comme jviens de lapprendre en maths :p */
        /* c "la somme des produits des elements d'une rangee et leur mineur" */
        /* demerdez vous :D:D */

        /* On choisit la ligne/colonne qui contient le plus de 0. */
        iChoosenLine = choose_line( pMatrix );

        /* Sa c pour faire sa sur une ligne. */
        if( iChoosenLineIsLine ) {
                for( i = 1 ; i <= pMatrix->iSize ; i++ ) {
                        k = XY( i-1, iChoosenLine-1, pMatrix->iSize );
                        /* La valeur de l'element de la rangee choisie. */
                        a = pMatrix->pData[k];
                        /* Le mineur de l'element de la rangee choisie.
                         * Si a est dja 0, plus bsoin de calculer le mineur, puiske 0*x = 0
                         */
                        if( a != 0 ) {
                                b = calc_minor( pMatrix, iChoosenLine, i );
                        } else {
                                g_virt_nbr_determs += calc_nbr_determinants( pMatrix->iSize - 1 );
                        }
                        iResult += a * b;
                }
        /* Et sa c pour faire sa sur une colonne. */
        } else {
                for( i = 1 ; i <= pMatrix->iSize ; i++ ) {
                        k = XY( iChoosenLine-1, i-1, pMatrix->iSize );
                        /* La valeur de l'element de la rangee choisie. */
                        a = pMatrix->pData[k];
                        /* Le mineur de l'element de la rangee choisie.
                         * Si a est dja 0, plus bsoin de calculer le mineur, puiske 0*x = 0
                         */
                        if( a != 0 )
                                b = calc_minor( pMatrix, i, iChoosenLine );
                        iResult += a * b;
                }
        }

        return iResult;
}