Newsgroup: it.comp.lang.c
Titolo: Usare proprio i float (niente conversione implicita a double)

Salve a tutti,
ho bisogno di utilizzare i numeri reali in singola precisione, i float, ma
_senza_ che essi vengano tradotti in double per eseguire le operazioni.
Ho trovato l'opzione del gcc (uso la versione 3.3)
`-fallow-single-precision', ma viene ignorata se i mantiene lo standard C
di default; ho provato a cambiarlo ma non torna piu' niente.
Avete qualche consiglio per come usarli?
Grazie in anticipo


Forse (dico forse!) aiuterebbe se tu ci dicessi quale e'
lo scopo di questa cosa che vuoi ottenere. Per quale
motivo ti danno fastidio questi double "invisibili" ?
In ogni caso la risposta
potrebbe anche dipendere dalla CPU del tuo sistema.
Se i dati che puo' manipolare in modo nativo sono i double (o meglio)
allora ragionevolmente convertira' in double
per fare i conti. Una alternativa (su alcune macchine) e'
forzare l'uso di librerie software per evitare l'uso del
coprocessore matematico.
Puoi anche guardare l'opzione -ffloat-store
ciao,
g.

 Puoi anche guardare l'opzione -ffloat-store
la guarderò!
Grazie

 double... ;)
Tanto prima o poi lo fa lo stesso (vedi, ad esempio, con printf() e la
promozione dei tipi da float a double).  Tralascio i miei personali
giudizi negativi su questo tipo di ottimizzazioni preventive.

 tanto quanto usando i double...
Mi sembra che sulla maggior parte delle CPU moderne i calcoli
con i double siano veloci quanto quelli con i float, perche'
di fatto i calcoli vengono effettuati dal coprocessore interno o esterno
o dalla stessa CPU in precisione maggiore di quella float in modo
nativo.
Quindi penso che il tuo non sia un problema. Caso mai puoi
lavorare sull'algoritmo (ovvio!) e sull'ordine al quale accedi
ai dati. Se lavori su matrici di dimensioni medio/grandi e che
quindi non stanno nella cache, allora l'ordine con il quale accedi
agli elementi della matrice puo' avere un certo impatto sulle
prestazioni. Per esempio sulla mia macchina con questo programmino
di test
#include<stdio.h>
double A[2000][2000];
main()
{
   int i,j,k;
   double a=0.0;
  for (j=0; j<2000; j++)
  for (i=0; i<2000; i++) A[i][j]=0.005*i+0.007*j;
   for (k=0; k<10; k++)
     {
	 for (j=0; j<2000; j++)
          for (i=0; i<2000; i++)
               A[i][j]=A[i][j]/(1+A[i][j]*A[i][j]);
     }
  for (j=0; j<2000; j++)
  for (i=0; i<2000; i++) a+=A[i][j];
  printf("%.10f\n",(double)a/4000000.0);
  return 0;
}
il tempo impiegato cambia radicalmente se uno
inverte l'ordine dei cicli cioe' se scrive
for (i=0; i<2000; i++) for (j=0; j<2000; j++) ...
invece di
for (j=0; j<2000; j++) for (i=0; i<2000; i++) ...
ci mette in un caso 1.35 sec. e nell'altro 5.12 sec.
L'uso dei float io li consiglio solo se uno puo' ragionevolmente
infischiarsene della precisione (cosa che va studiata con molta
attenzione) E ha la necessita' di tenere milioni e milioni di numeri
in memoria centrale.
Nel caso di calcoli su molti dati l'uso dei float potrebbe dare
un lieve incremento di velocita' ma dovuto piu' che altro
al ridotto accesso alla memoria.
Inoltre se hai problemi di efficienza (o meglio
di velocita' di calcolo) significa probabilmente che stai
facendo molti calcoli e quindi potenzialmente introduci molti
errori e li amplifichi. Un programma corretto che ottiene
risultati ragionevoli usando i double puo' dare risultati
quasi casuali usando numeri float, per esempio nel caso
di sistemi lineari mal condizionati.
ciao,
g.

 di sistemi lineari mal condizionati.
infatti, poi mi ha detto che tanto verrà utilizzato (per un progetto...) la
versione fortran in double compex...
ciao e grazie!!