Newsgroup: it.comp.lang.delphi
Titolo: Funzione random

Salve sono elio, cerco di capire come si comporta la funzione " random
".
Ho notato che inserendo in un ciclo for tale funzione, questa in
qualche maniera a me ignota,Interferisce con la variabile di ciclo.
Ad esempio nel cod. sottostante, accade che alla prima iterazione la
variabile i assume valore 50(cioč il valore di uscita dal ciclo).
Qualcuno sŕ perchč?
Grazie in anticipo, elio.
E-Mail : 
lfio...@gsmbox.it
 
procedure TForm1.FormCreate(Sender: TObject);
var
  i : Integer;
begin
   Randomize;
   for I := 1 to 50 do begin
     { Write to window at random locations }
     Canvas.TextOut(Random(Width), Random(Height), 'Boo!');
   end;
end;

 Qualcuno sà perchè?
Non dipende dal random, e' solo un'ottimizzazione del compilatore. Se la
variabile indice non viene utilizzata nel codice, il compilatore fa il conto
alla rovescia perche' e' piu' veloce.
prova cosi', dovrebbe andare a posto (dovrebbe)
for I := 1 to 50 do begin
 Canvas.TextOut(Random(Width), Random(Height), inttostr(i)); <<<-- leggi I
per forzare il compilatore a non ottimizzare
Ciao!                {MSX}
P.S. se non funziona, vuol dire che mi sono inventato tutto.. :)
--
{MSX}  -  
http://msx.rules.it
Mantenitore delle FAQ di it.comp.lang.delphi,
reperibili qui: 
http://gpi.infomedia.it/abc/delphi/FaqDelphi.txt

fico ... non sapevo sto fatto ...
grande borland!
"{MSX}" <nlugat...@THISinwind.it> wrote in message
news:J1c68.1350$kv.3...@twister2.libero.it...


comecomecome?
anche io mi chiedo sempre perchè il ciclo spesso me lo fa al contrario...
perchè è più veloce?
che differenza fa contare da 1 a 50 invece che da 50 a 1.
non so perchè ma io faccio prima a fare il conto per diritto ma non a
ritroso...
mi spieghi perchè è più veloce?
"{MSX}" <nlugat...@THISinwind.it> ha scritto nel messaggio
news:J1c68.1350$kv.3...@twister2.libero.it...


 wrote in message
news:%od68.13209$3J1.4...@news2.tin.it...


 ha scritto nel messaggio
news:4wd68.1825$kv.4...@twister2.libero.it...


 wrote in message
news:9Dd68.13265$3J1.4...@news2.tin.it...


 direttamente.
Salve a tutti e scusate se mi intrometto nella discussione.
Non ho ancora provato il codice in esame ma sono molto
cursioso di vedere cosa succede...
comunque un ciclo a decremento e' piu' veloce che a incremento
perche' le cpu quando fanno una sottrazione mettono nel flag di
stato ZF 0 o 1 a seconda se se il risultato e' zero o maggiore di zero.
Lo stesso vale per la somma con il flag OF che indice se c'e' stato un overflow.
Come sfrutta tale cosa l'ottimizzatore?
Normalmente il ciclo sarebbe metti in I 1 e (incrementa e controlla se I=50) 50
volte.
Questo controllo richiede 2 istruzioni asm, una di confronto e una di salto
condizionato.
Facendo il contrario si risparmia un'istruzione:
decrementa e salta se ZF<>0
Ciao a tutti
Mirko

 decrementa e salta se ZF<>0
Quindi, nel caso dovessimo scrivere un ciclo che analizza l'indice
all'interno del ciclo, ma risulta irrilevante se fatto come incremento o
come decremento, potrebbe essere un pelino più prestante farlo a ritroso. E'
corretto quello che ho detto o è una ottimizzazione che può farla solo il
compilatore se non si guarda l'indice del ciclo?
Ciao
Matteo

 compilatore se non si guarda l'indice del ciclo?
Si tecnicamente e' corretto, ma ricorda che un'istruzione macchina e' una
ottimizzazione veramente ininfluente.. se non sbaglio circa 2*e-9 secondi
nel mio 450mhz.. davvero poca cosa, che non regge proprio la perdita di
leggibilita' del codice..
Come diceva il saggio, "non perdete tempo a limare codice che spreca pochi
millisecondi, quando procedure mal fatte sprecano interi secondi". :)
Ciao!                {MSX}

 ritroso...
Ehehe questa non mi sembra granche' come argomentazione :))
comunque non va piu' veloce a contare, ma a fare il confronto. ad ogni ciclo
deve fare il confronto con il valore limite, e fare un confronto con 0 e'
piu' veloce che con n
Bye :D
Che dite la FAQo sta domanda ?


 > corretto quello che ho detto o è una ottimizzazione che può farla solo


l'operazione + e - utilizzando tutte e due un solo ciclo macchina
Non e' detto.
Il codice prodotto da Delphi per un ciclo tipico:
var
  I: Integer;
...
for I := 1 to 50 do
begin
  WriteLn(Random(100));
end;
produce il codice macchina:
mov   ebx, $00000032 ; mette 50 in ebx
mov   eax, $00000064
call  @RandInt
mov   edx, eax
mov   eax, [$004092f8]
call  @Write0Long
call  @WriteLn
call  @_IOTest
dec   ebx           ; decrementa il contatore di ciclo
jnz   -$23          ; se non e' zero salta all'inizio
Il codice, invece, prodotto per:
var
  I: Integer;
...
for I := 1 to 50 do
begin
  WriteLn(Random(I)); // forziamo l'uso di I
end;
e' il seguente:
mov   ebx, $00000001 ; questa volta inizia a contare da 1
mov   eax, ebx
call  @RandInt
mov   edx, eax
mov   eax, [$004092f8]
call  @Write0Long
call  @WriteLn
call  @_IOTest
inc   ebx           ; incrementa il contatore di ciclo
cmp   ebx, $33      ; il contatore e' diventato 51 ?
jnz   -$23          ; se no salta all'inizio
Come si puo' vedere, nel secondo caso c'e' un'operazione in
piu', quella di confronto per stabilire l'uscita o meno dal
ciclo.
-- 
Andrea Laforgia (
walkie...@libero.it
)
"Usenet is a strange place" [Dennis Ritchie]