Valore di ritorno in C

[mikael_c]

in questa procedura ci sono dei return ma non funzionano correttamente perchè non ritonano niente come posso modificare la procedura in modo da farla ritornare correttamente???

void genTPerm(int k)
 {
  int i=0;
  
  if(k>(n-1))
   {
    stampaVett();

    /* verifica se la soluzione trovata è un ciclo: se si succ=1 e termina genTPerm */
    
    nChr++;
    
    if(nChr>n)
     {
     
     Succ=0;
     return  ;
  
        
     }
   }
  else
   for(i=0;i<n;i++)
    {if(Chr1[i]==n)
      {Chr[k]=i;
       Chr1[i]=k;
       genTPerm(k+1);
       Chr1[i]=n;
       Chr[k]=n;
      
      }
    }
 }

[misterx]

già nella dichiarazione gli chiedi di non ritornare nulla, se vuoi ad esempio che ti rutorni un intero

void genTPerm(int k)

int genTPerm(int k)
{
      resto della tua funzione ................
      return (valore desiderato;)
}

main()
{
         printf("risultato: %d\n", genTPerm(50));
}

[Eduadie]

Inoltre n è una variabile globale?
Perchè nella funzione non gli viene assegnato alcun valore...

[mikael_c]

n è una variabile globale

[mikael_c]

il codice è più complesso e mi va in loop, ho notato che non mi ritorna e poi il ciclo while(while(fabs(p-pSup)>0.05)) è infinito.Come va corretto per farlo funzionare correttamente???

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>

const int N0=10; /* limite inferiore al numero di vertici dei digrafi da generare */
const int N= 10; /* limite superiore al numero di vertici dei digrafi da generare */
const int H0= 0;  /* limite inferiore al numero dei digrafi da generare */
const int H=10; /* limite superiore al numero dei digrafi da generare */

/* variabili globali */
typedef int matrice [10][10] ; /* matrice adiacenza dei grafi */
matrice  m;

int Chr[100];  /* vettore soluzione (permutazione) */
int Chr1[100]; /* soluzione inversa */
int nChr=0;    /* numero soluzioni costruite dalla procedura esaustiva */
int Succ=1;    /* flag che indica il successo della procedura esaustiva */
int n=3;	       /* numero vertici digrafi */
double p=0.0;
double supp=0.0;
double infp=0.0;
int Ftns=0;

void  genera_matrice(matrice  m, size_t n, double p)  {
    size_t  i = 0,  j = 0;
   
    srand((unsigned)  time(NULL));
    for  (i = 0;  i < n; i++) {
        for  (j = 0;  j < n; j++) { m[i][j]  =  rand() < p * RAND_MAX ? 1 : 0; }
    }
}

void  stampa_matrice(matrice  m, size_t n)  {
    size_t  i = 0,  j = 0;
    
    for (i = 0; i < n; i++)  {
        for  (j = 0; j < n; j++) { printf("%d  ",  m[i][j]); }
        printf("\n");
    }
}


void initChr()
 {
  int i=0;

  for(i=0;i<n;i++)
   {
       Chr[i]=n;
       Chr1[i]=n;

   }
 }

/* procedura di stampa di Chr[] */

void stampaVett()
 {
  int i=0;

  for(i=0;i<n;i++)
   printf ("%d ",Chr[i]);
  printf("\n");
 }

/* procedura esaustiva di calcolo soluzioni */
/* ho modificato da void a int per errori*/

int genTPerm(int k)
 {

  int i=0;

  if(k>(n-1))
   {

/* aggiornamento di Ftns, del numero di link ciclci consecutivi della soluzione */

    Ftns=Ftns+m[Chr[k-1]][Chr[0]];

    stampaVett();

/* Incrementa il numero di soluzioni (permutazioni) calcolate */

    nChr++;

/* verifica se la soluzione trovata è un ciclo: se si Succ=1 e termina genTPerm */

   if(Ftns==n)
     {

     Succ=1;
     return;


     }


/* 

nel caso in cui la soluzione trovata non è un ciclo Hamiltoniano ed il numero di soluzioni
generate è maggiore di una soglia polinomiale (ThSol=n), allora: Succ=0 e termina genTPerm 

*/
   int ThSol=n;
    if(nChr>ThSol)
     {

     Succ=0;
     return  ;


     }

/* aggiornamento di Ftns, del numero di link ciclci consecutivi della soluzione */

    Ftns=Ftns-m[Chr[k-1]][Chr[0]];


   }
  else
   for(i=0;i<n;i++)
    {if(Chr1[i]==n)
      {Chr[k]=i;
       Chr1[i]=k;

/* aggiornamento di Ftns, del numero di link consecutivi della soluzione */

       if(k>0){
        Ftns=Ftns+m[Chr[k-1]][Chr[k]];  
        genTPerm(k+1);
       }    
       if(k>0){
       
       Ftns=Ftns+m[Chr[k-1]][Chr[k]];  
       Chr1[i]=n;
       Chr[k]=n;
       }
      
      
      }
    }
 }




int main(void)
{    
      int flag=0;

      double p = 0.5; /* probabilità di definizione per grafi di Gilbert */

      nChr = 0;
      int h;
      int media[n];
      int media2[n];
      int devstandard[n];

/* inizializza variabili e vettori */

      initChr();
      
/* calcola le soluzioni (permutazioni) */
   genera_matrice(m, n, p);
    stampa_matrice( m,  n);
/* inizializzazione di p */

/* 

definisci i limiti inferiore pInf e superiore pSup per p tali che: 
pSup rappresenta il valore di caso peggiore noto per cui genTPerm ha sempre successo 
pInf rappresenta il valore di caso migliore noto per cui genTPerm fallisce almeno una volta

Inizialmente pSup=1 e pInf=0


*/

/* Inizializza p al valor medio tra pInf e pSup */
int pSup=1;
int pInf=0;
p=(pSup+pInf)/2;


/* ciclo su p per determinare le soglie di resistenza per istanze con n vertici */

 while(fabs(p-pSup)>0.05)
  { 

/* inizializza le statitische di successo */
   int PS;
   PS=0;

/* generazione ciclica dei grafi di Gilbert con probabilità p */
   int Gg;
   int MaxGg=5;
   for(Gg=0;Gg<=MaxGg;Gg++) 
    {

/* Gg conta l'occorrenza di grafo di Gibert di n vertici generata con probabilità p */

/* generazione di un'istanza (digrafo) */

   /*genera_matrice(m, n, p);
    stampa_matrice( m,  n); */

/* 

   sequenzizione dei vertici dell'istanza (codificata dal grafo), ovvero

   calcolo di una permutazione di vertici che formino un ciclo Hamiltoniano 

*/

     genTPerm(0);

/* aggiorna le statistiche di successo (percentuale di successi PS + deviazione standard) */

   PS=PS+Succ;

/* Fine ciclo su Gg */

    }

/* se genTPerm ha avuto sempre successo (PS==MaxGg), allora pSup=p e p=(pSup+pInf)/2 */
  if(PS==MaxGg){
  pSup=p;
  p=(pSup+pInf)/2 ;
  }

/* se invece genTPerm ha fallito almeno una volta (PS!=MaxGg), allora pInf=p e p=(pSup+pInf)/2 */
  if(PS!=MaxGg){
  pInf=p;
  p=(pSup+pInf)/2;
  }
/* Fine ciclo su p */

  }

  for ( n=10;n<N;n++){
     for( h=0;h<H;h=h+2){
       p=0.5;
	    supp=1.0;
        infp=0.0;
        flag = 1;
        while(flag)
         { 
	      genera_matrice(m, n, p);
	 
          int  succ=genTPerm(0);
          if(succ==0){infp=p; p=0.5*(supp+p);}
          else{supp=p;p=0.5*(p+infp);}
          if(fabs(infp-supp)<.05){flag=0;}

/* fine ciclo while(flag) */

         }
          
       media[n]+=supp;
        media2[n]+=supp*supp;

/* fine ciclo for(h... */

       }
       devstandard[n]=sqrt(1/(H-1)*(media2[n]-media[n]*media[n]));
       media[n]=media[n]/(H-1);

/* fine ciclo for(n... */

     }
}

[misterx]

Originariamente inviato da mikael_c

n è una variabile globale

ma hai parlato di valori di ritorno

[mikael_c]

Come imposto il codice tipo verifica se la soluzione trovata è un ciclo: se si Succ=1 e termina genTPerm?? ho inserito return(1)

if(Ftns==n)
     {

     Succ=1;
     return(1);


     }

[lorenzo001]

Non è che si capisca molto ("se la soluzione trova è un ciclo" non vuol dire nulla) ...

Penso che, se ti serve un valore che ti indichi cosa è successo e questo valore è in Succ, puoi tranquillamente scrivere

return Succ;

[mikael_c]

ok grazie, il ciclo while come può essere corretto perchè va in loop??