Newsgroup: it.hobby.elettronica.digitale
Titolo: ogni tanto bisogna usare le float

..ciao
 
..ma qual'� il modo meno oneroso per il micro?(cortex-M0 )
 
    unsigned int var_a=200;
    float var_b=3.54
 
  deve avere un valore float =a/b;
 
   mi conviene dichiarare float_a   e   metterci var_a  e il risultato in 
float_c  che avr� dichiarato
    oppure lasciare fare al compilatore?
 
es
funzione(dividi )
{
    unsigned int var_a=200;
    float_b=3.54;
    float_a,float_c;
 
    float_a=(float)var_a;
    floatc=float_a / float/b;
    .....
    .....
}
 
oppure
funzione(dividi )
{
    unsigned int var_a=200;
    float_b=3.54;
 
    float_b=((float)var_a)/float_b?
    .....
    .....
}
 
o nessuna delle due?
grazie
 
 

 ..ma qual'ï¿œ il modo meno oneroso per il micro?(cortex-M0 )
???
Non e' che di capisca molto quello che vuoi fare ...
comunque, se e' un numero fisso che voi, assegna direttamente
il valore con una macro :-)
#define MY_K    (200.0/3.45)
 
se non lo e', allora usa la forma piu' semplice:
    float fc= ((float)var_a)/3.54;
 
aa.
 


 
Prima di tutto grazie e buon anno,se non � troppo tardi,
e poi � il primo post del 2013 su questo newsgroup
 
evidentemente mi sono spiegato male
 
no,i numeri erano fissi giusto per fare l'esempio.avrei potuto evitare di 
farli sembrare tali
sono variabili entrambi
 
quello che chiedo � (e penso che valga per tutti i tipi di variabile)
 
quando tu fai ((float)var_a)  immagino che varr� allocato spazio per una 
variabile float da qualche parte (non ho ancora guardato se il compilatore 
lo faccia nello stack ,o nei  registri ...dove?)
 
cambia qualcosa se invece alloco io ,esplicitamente ,la variabile float dove 
verr� messo il valore convertito in questo tipo?
 
Il dubbio mi � venuto per il float perch� immagino che anche su un cortex 
M-0(LPC1224)richieda  qualche calcolo in pi� 
 
 

 verrï¿œ messo il valore convertito in questo tipo?
Ah, ok.. ;-)
Qui penso che parliamo di codice embedded (visto che citi M0), per cui
se la tua preoccupazione e' quella di 'ottimizzare' spazio di codice e
'tempo', basta un po' di buon senso ed evitare di compiere operazioni
evidentemente ridondanti e limitare le conversioni di formato di
variabili il piu' possibile :-)
Di solito, se non ci sono problemi di altra natura, nell' embedded
si cerca di evitare ottimizzazioni troppo spinte, che rendono difficile
da debuggare il codice e possono introdurre anomalie particolarmente
antipatiche da rilevare, per cui e' giusto e doveroso scrivere del
codice in modo 'pulito' e 'ottimizzato', detto cio':
 
1)
float dividi(int a, int b)
{
     float af;
     float bf;
     float cf;
 
     af=a;  // af= converti_in_float(a);
     bf=b;  // af= converti_in_float(a);
 
     cf = af/bf;
     return(cf);
}
2)
float dividi(int a, int b)
{
    // temp=(converti_in_float(a)/converti_in_float(b));
     return( ((float)(a)/(float(b)) );
}
 
3)
// Se a,b NON float, allora:
// r= dividi(converti_in_float(a),converti_in_float(b))
//
float dividi(float a, float b)
{
     return( (a)/(b)) );
}
 
In tutti e 3 i casi, viene fatta la stessa cosa: anche nel terzo caso, 
pur passando alla funzione due variabili non float, quello che fa e', 
prima della chiamata, convertire in float i due valori passati.
Dal punto di vista di operazioni FP, non ci sono differenze:
sono sempre solo due chiamate per la conversione.
 
Se un compilatore e' molto efficiente, tra la 1 e la 2 potrebbe non 
esserci differenza di codice (ovviamente con ottimizzazione massima, non 
in modo debug (OT=OFF), dove invece la differenza c'e', ma ovviamente 
spesso e' bene non ottimizzare troppo).
 
La 2 comunque e' quella che comporta meno operazioni inutili e lascia
al compilatore creare le variabili di appoggio, che potrebbero anche
essere semplici registri.
 
Invece la 3 potrebbe essere la meno efficiente di tutte :-)
Questo perche' se e' chiamata molto spesso, la conversione a float
delle variabili sara' fatta sui parametri prima di ogni chiamata!
Quando la conversione ï¿œ fatta nella funzione (come 1 e 2), il codice di
conversione viene aggiunto una sola volta indipendentemente da quante
volte verra' chiamata dividi .
Questo se ovviamente i parametri di ingresso NON sono gia' float....
 
aa.
 
 
 
 


 
....
 
chiarissima spiegazione,grazie davvero Cortex