Newsgroup: it.comp.lang.c
Titolo: ciclo efficiente

Salve,
ho win98 ed il dev c++.
Ammettiamo che io debba eseguire nella maniera efficiente (ottimizzata) la
funzione:
f(double *s,double *sp,double *sd, int N)
dove:
s, N sono gli argomenti di ingresso
sp, sd, sono gli argomenti di uscita
s, sd, sp  sono i vettori
Il cuore della funzione è il codice che segua:
////////////////////////////////////////////////////////////////////////////
///////
int N;
...
for(i=0;p<N/4;p++)
{
sp[p]=s[p]-s[N/2-p];
sd[p]=s[p]+s[N/2-p];
}
////////////////////////////////////////////////////////////////////////////
///////
allora come conviene agire?
1)lo lascio così;
2)lo riscrivo così:
////////////////////////////////////////////////////////////////////////////
///////
int N, N2, N4;
...
N2=N/2;
N4=N/4;
for(i=0;p<N4;p++)
{
sp[p]=s[p]-s[N2-p];
sd[p]=s[p]+s[N2-p];
}
////////////////////////////////////////////////////////////////////////////
///////
Oppure i compilatori di oggi sono abbastanza intelligenti da capire da soli
che, nella prima
versione del codice, i calcoli: "N/2", "N/4" non convenga ripeterli ad ogni
iterazione del ciclo,
 ma
convenga calcolarli la singla volta per tutte, coniando delle variabili ad
hoc per contenerli?
Ammettiamo che valga questa questa seconda ipotesi.
Ora però secondo me nche in questo caso l efficienza del C non sarà ottima.
Infatti come fa il C
a capire a priori (già in fase di compilazione, prima di
 conoscere il valore di N) quale tipo di dato impiegare per contenere:
"N1/2" o "N1/4"? Chi gli assicura che basta il tipo int? Io so che N sarà in
ogni caso la potenza
 del 2, e pertanto N2 ed N4 saranno anch'esse del tipo int.
Invece esso non può saperlo, e pertanto, per non sbagliare, è indotto
gestirli come "double".
Sbaglio?
E' corretto dunque dedurre che in ogni caso, la 2° versione del codice, sarà
più efficiente della
 prima.
Ora io chiedo: la 2° versione del codice sarà più efficente anche se questo
codice lo
implementassi in
Matlab (opportunmente tradotto), oppure queste considerazioni valgono solo
nel C?
grazie,
adriano


Vorrei puntualizzare che nel tuo codice, N e' dichiarato int, e il
risultato di N/2 e N/4 e' int pure lui, indipendentemente dal valore
di N: forse tu ti stai confondendo con altri linguaggi.
Le due versioni sono identiche dal punto di vista dell'efficenza.

 wrote in message
511e6632-b1a0-4566...@c65g2000hsa.googlegroups.com...


cioè intendi dire che:
1)se N è dichiarato come "int", allora l'operatore "/" viene inteso dal
compilatore come la
 divisione intera (senza virgola, mozzata). per esempio se N=3 allora N/2
restituisce 1.
2)Se N sia dichiarato come double, allora l'operatore "/" viene inteso dal
compilatore come la
divisione esatta con la virgola. per esempio se N=3 allora N/2 restituisce
1.5.
ora però non capisco perchè ciò implichi che l'efficienza dei due metodi
coincida.
Infatti, affinchè l'efficienza coincida, serve che il calcolo di N/2 o N/4,
indipendentemente che restituisca
il valore intero o il valore double, venga calcolato solo una volta, anche
nella 1° versione del
codice, dove le quantità N/2 ed N/4, non vengano espicitamente assegnate ad
una variabile.
Ciò è garantito per nessuno, qualcuno, o tutti i compilatori C oodierni?
grazie,
adriano

adriano meis ha scritto:

Dal punto di vista dell'efficienza sono indifferenti le due versioni, la 
quasi totalità dei compilatori compie l'ottimizzazione che hai scritto. 
Dal mio punto di vista conviene per chiarezza e sinteticità scrivere il 
codice nel secondo modo.
Se N è int allora N/2 sarà int, per cui se N=3 allora N/2=1