[c++] Problema con funzione ricorsiva

[Gervasoni]

Devo scrivere un programma che calcoli il determinante di una matrice al max 6*6 mediante una funzione ricorsiva.

Il codice della funzione che calcola il determinante che ho scritto è questo:

float determinante(float x[IMAX][IMAX], int n_rig)
   {
     float min_estratto[IMAX][IMAX];
     float det;
     int h=n_rig-1;

     if (n_rig>2)
         {

            for (int n_col=0; n_col<IMAX; n_col++)
              {
               matrice_minore(x,min_estratto,n_col,h+1);
               det=det+(x[n_rig][n_col]*pow(-1,n_col+n_rig)*determinante(min_estratto,h));
               printf("\t\t%d\n",h);
              }
            h=h-1;
         }
     if (n_rig==2) return (x[0][0]*x[1][1]-x[0][1]*x[1][0]);
     return det;
   }

matrice_minore è il nome della funzione che calcola la matrice ottenuta cancellando una determinata riga e colonna.

Il problema non è della funzione matrice_minore che mediante dei printf ho visto che funziona correttamente quanto della funzione determinante che mi restituisce sempre e comunque un valore del determinante uguale a zero.

Cosa c'è che non va?

[/\/\@®¢Ø]

attento che non inizializzi det a zero.

[Gervasoni]

Una variabile locale viene automaticamente inizializzata a zero.
Il problema è che non funge proprio la ricorsione...

Perchè a det non viene assegnato questo valore?

det=det+(x[n_rig][n_col]*pow(-1,n_col+n_rig)*determinante(min_estratto,h));

Help please!

[cionci]

Originariamente inviato da Gervasoni
Una variabile locale viene automaticamente inizializzata a zero.

Questo non è assoultamente vero...

[ri]

Originariamente inviato da Gervasoni
Una variabile locale viene automaticamente inizializzata a zero.

ommiodio

scusa sa rotflo ma l'hai detto troppo convinto per non farmi ridere

[/\/\@®¢Ø]

Originariamente inviato da Gervasoni
Una variabile locale viene automaticamente inizializzata a zero.
Il problema è che non funge proprio la ricorsione...

non e' garantito, anche se probabilmente alcuni compilatori permettono di impostare tale opzione.
Infatti il seguente codice

void foo()
{
    float f;
    cout << f;
}

stampa

1.#QNAN

sul mio compilatore.

[/\/\@®¢Ø]

if (n_rig>2)
{
for (int n_col=0; n_col<IMAX; n_col++)
{
matrice_minore(x,min_estratto,n_col,h+1);
det=det+(x[n_rig][n_col]*pow(-1,n_col+n_rig)*determinante(min_estratto,h));
printf("\t\t%d\n",h);
}
h=h-1;
}

h a cosa serve ? Non dovrebbe bastarti n_col e n_rig ?
Ancora piu' dubbio quel pow(-1,...) , dovrebbe bastare qualcosa del tipo

det = det + x[n_rig][n_col]*determinante(min_estratto);

[/\/\@®¢Ø]

Originariamente inviato da /\/\@®¢Ø
non e' garantito, anche se probabilmente alcuni compilatori permettono di impostare tale opzione.
Infatti il seguente codice

void foo()
{
    float f;
    cout << f;
}

stampa

1.#QNAN

sul mio compilatore.

Dimenticavo di dire che invece sono le variabili globali quelle che vengono inizializzate a 0.

[Gervasoni]

l'h la passo a n_rig

Il pow serve perchè x[n_rig][n_col] deve essere alternativamente positiva e negativa.

Cmq Marco grazie per l'aiuto.

[cionci]

Al posto di pow(-1,n_col+n_rig) metti:

inline float pow_minus1(const int riga, const int colonna)
{
    return (float)((riga+colonna)&0x1)?-1:1;
}

Direi 5 o 6 volte + veloce... Pensa che il pow era l'operazione + lenta del tuo programma

[/\/\@®¢Ø]

Originariamente inviato da Gervasoni
l'h la passo a n_rig

Ok, ma allora che serve decrementarlo dopo il ciclo for visto che non lo usi piu' ?

Il pow serve perchè x[n_rig][n_col] deve essere alternativamente positiva e negativa.

Cmq Marco grazie per l'aiuto.

Hai ragione avevo l'avevo letto come x^-1 invece che -1^x

[Gervasoni]

Ok, ma allora che serve decrementarlo dopo il ciclo for visto che non lo usi piu' ?

Già! Sarebbe quindi giusto levare

int h=n_rig-1;

e

h=h-1;

e chiamare la funzione direttamente come
determinante(min_estratto,n_rig-1)?

[angelica]

Originariamente inviato da cionci
Direi 5 o 6 volte + veloce... Pensa che il pow era l'operazione + lenta del tuo programma

Mi son sempre chiesta come si faccia a sapere quanto più veloce giri il proprio prog post-modifiche, e la velocità/lentezza delle singole operazioni...

[/\/\@®¢Ø]

Originariamente inviato da cionci
Al posto di pow(-1,n_col+n_rig) metti:

inline float pow_minus1(const int riga, const int colonna)
{
    return (float)((riga+colonna)&0x1)?-1:1;
}

Direi 5 o 6 volte + veloce... Pensa che il pow era l'operazione + lenta del tuo programma

In teoria trasformando l'if in operazioni artimetiche ne dovrebbe trar giovamento la pipeline giusto ?
(pensavo a qualcosa del tipo ((riga+colonna)&0x1)*2-1))

[verloc]

Originariamente inviato da angelica
Mi son sempre chiesta come si faccia a sapere quanto più veloce giri il proprio prog post-modifiche, e la velocità/lentezza delle singole operazioni...

Con un "profiler".


Mi ricordo che ne esisteva uno gratise.

[cionci]

Originariamente inviato da /\/\@®¢Ø
In teoria trasformando l'if in operazioni artimetiche ne dovrebbe trar giovamento la pipeline giusto ?
(pensavo a qualcosa del tipo ((riga+colonna)&0x1)*2-1))

Certo....ma ti sei dimenticato un - davanti (dispari: 1*2-1 dovrebbe rendere -1; pari: 0*2-1, ma dovrebbe rendere 1)... Non avevo pensato a farlo in questo modo Anche se allora sarebbe più veloce così: -((riga+colonna)&0x1)<<1 - 1)

[Gervasoni]

C'è l'ho fatta!!!

Grazie per l'aiuto!

[/\/\@®¢Ø]

Originariamente inviato da Gervasoni
C'è l'ho fatta!!!

Grazie per l'aiuto!

Eh, ma adesso devi dirci come, altrimenti non vale

[Gervasoni]

Ho riscritto il programma da zero.
C'erano vari errori cmq non grossolani...

Ti allego il file .cpp così mi dai un parere

[Gervasoni]

Ecco il file