Newsgroup: it.comp.lang.delphi
Titolo: Differenza tra compilatori

Un mio amico (con il quale creiamo spesso programmi in VB6) ha realizzato
una routine ciclica che ha accorciato di gran lunga i tempi di elaborazione
del ns. VB6.
Ho visionato il suo sorgente
ho tolto una routine completamente inutile che gli faceva elaborare circa un
miliardo di operazioni inutili ed ho ricompilato.
Ho lanciato il programma "mio" ed ha impiegato 1' 26"
ho lanciato il suo ed ha impiegato 6 secondi in meno.
Per fugare ogni dubbio circa l'utilità della routine che ho cancellato...
1° for do da 5000
2° for do da 89
3° for  do da 90
soltanto commenti e nessuna istruzione
fine 3° ciclo
fine 2° ciclo
fine 1° ciclo
Mi chiedo "Può aver compilato il suo sorgente con un compilatore diverso dal
mio?"
Io ho usato Delphi 7
Ciao


Scusa eh...ma non ho capito una mazza....lui ha usato VB6 e tu Delphi7 
giusto? Il tuo sorgente č pił snello (ovvero hai usato il suo "codice" 
adattato a pascal e gli hai tolto delle righe che erano inutili).
La tua domanda č strana...ha usato sģ un compilatore diverso...lui VB6 e tu 
Delphi 7!

 Io ho usato Delphi 7
Quella routine non fa nulla, quindi non può migliorare in nulla le
performance.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 performance.
Uhm...forse posso riprendermi una rivincita sul mitico Andrea....
Secondo me la routine fà...se nel il compilatore non vengono impostate le 
ottimizzazioni, un ciclo "for i:=1 to 100 do begin end;" conta a tutti gli 
effetti da 1 a 100.
O sbaglio?

 effetti da 1 a 100.
"Contare" è un'attività che potrebbe avere un senso per un umano, non per
un computer.  Quando dico che quel codice non fa nulla, intendo che non
esegue nessuna operazione utile e tantomeno che possa portare vantaggi in
termini prestazionali.


Non sono d'accordo!
Il computer svolge tutti i cicli che sono 40.050.000
Quando il programma entra dentro i vari loop NON SA se troverà operazioni da
eseguire e quindi svolge ogni ciclo.
"Andrea Laforgia" <x...@xx.xx> ha scritto nel messaggio
news:ecs7sc$dcp$1...@news.newsland.it...


 Delphi 7!
****
Cerco di farmi capire meglio:
eseguiamo una serie di calcoli, alcuni semplici ed alcuni
luuunnngghiiiissssiimmmiiiiii
Cosa facciamo?
Parte l'elaborazione del programma VB
prima di elaborare i cicli più laboriosi passa dei paramentri a Delphi
Delphi elabora i dati e restituisce il risultato a VB
Adesso non voglio entrare nei particolari ma riproporre la stessa domanda di
prima:
Perché il mio eseguibile (Delphi), pur essendo mancante di 40.050.000
operazioni inutili è un po' più lento di quello del mio amico? (Delphi)
Preciso che ho operato sullo stesso codice sorgente dal quale ho tolto
alcune operazioni inutili.
Ciao

 performance.
*****
Infatti dovrebbe peggiorarla...

 eseguire e quindi svolge ogni ciclo.
Non è vero affatto: l'ottimizzatore riesce a capire se quel ciclo contiene
istruzioni sensate o meno, ai fini del flusso del programma e potrebbe
benissimo non compilarle affatto.


 operazioni inutili č un po' piů lento di quello del mio amico? 
Sicuramente non per via del fatto che hai tolto quelle 40.050.000
istruzioni.


 
E lui?
Ah, no, questa e' l'incognita...
Supponendo che si tratti di codice Delphi, abbiamo alcuni casi possibili:
- il tuo amico ti ha fregato e in realta' ha compilato un codice diverso 
da quello che ti ha dato,
- il tuo amico sta usando il compilatore di una versione diversa di 
Delphi (quello del 7 non mi pare il piu' veloce, ma non ne sono sicuro),
- il tuo amico sta usando il compilatore di un clone di Delphi (Es. 
Lazarus?) che magari ottimizza meglio il compilato,
- il tuo amico sta usando Delphi 7 ma ha attivato le opzioni di 
ottimizzazione del codice e tu no.
- tu hai sbagliato le misurazioni dei benchmark,
- hai provato i 2 eseguibili su due PC differenti.
Il tutto (o quasi) molto scherzosamente (o quasi).
-- 
Roal Zanazzi

 Nonostante qualcuno sembri sicuro del contrario.
Nessuno in questo thread ha detto questo.  Quello di cui si può essere
sicuri al 100% è che del codice che a livello di sorgente presenta solo
commenti come nucleo di un ciclo for OGGETTIVAMENTE non può produrre
miglioramenti nelle performance.


 benissimo non compilarle affatto.
E' proprio questo che dicevo...se non c'è ottimizzazione, almeno ina   "inc 
cx" (bei tempi l'assembler...come lo rimpiango!)  la fà, o sbaglio?

 miglioramenti nelle performance.
****
Non so perché non riesco a farmi capire.
Oppure...
Cmq...
non ho detto che quel codice commentato poteva migliorare le performance del
programma, semmai (quasi sicuramente) peggiorarle.
Compilo la domanda in modo differente: conoscete un compilatore per codice
Delphi più veloce di quello della versione 7 (Borland) ???

 In che linguaggio di programmazione e' scritto?
Delphi. Mi sembra di averlo scritto un po' di volte in questo thread

 Delphi più veloce di quello della versione 7 (Borland) ???
Che intendi per "più veloce" ? che produce codice più veloce ?
Se è questa la domanda, la risposta è no, perché non esistono.


 Se è questa la domanda, la risposta è no, perché non esistono.
***
Con il termine "più veloce" intendo un eseguibile che a parità di codice
sorgente produce un eseguibile che compie lo stesso tipo e numero di
operazioni in un tempo minore.

 ho lanciato il suo ed ha impiegato 6 secondi in meno.
il suo in VB con ciclo inutile impiega 6 secondi in meno del tuo col 
delphi e ciclo tolto.
- il tipo di dati e' uguale tra i due programmi?
- ci sono componenti che durante il ciclo vengono usati?
- fai qualcosa di particolare?
.........
-- 
-------------------------------
per scrivere in privato
togliere "1975nosp"
to reply remove "1975nosp"

 operazioni in un tempo minore.
Intendi che produce un eseguibile più veloce.  Confermo la risposta: non
esiste.  Delphi è compilato prevalentemente con Delphi, appunto.  Esiste
Lazarus che è un ambiente open source gratuito ma non lo eguaglia dal
punto di vista delle prestazioni né del compilatore, né del codice
prodotto, né nella compattezza del codice prodotto.  La compilazione, in
Delphi, è molto ben ottimizzata, peraltro.


Ok, grazie per la risposta
"Andrea Laforgia" <x...@xx.xx> ha scritto nel messaggio
news:ect2bu$am6$1...@news.newsland.it...


 delphi e ciclo tolto.
Si tratta dello stesso codice scritto in Delphi

 Si tratta dello stesso codice scritto in Delphi
Secondo me prima dovresti provare a scrivere in italiano e poi cominciare a
programmare...
bye, giubbe

 ha scritto nel messaggio
news:5fdg17k8...@id2670.giubbe.altervista.org...


 
che tipo di dati usi:
real, integer, ......
in VB ci sono tipi identici?
Solo calcolo, non usi componenti nel ciclo?
funzioni particolari?


 ha scritto nel messaggio 
news:44f29b63$0$15872$4faf...@reader2.news.tin.it...


 diversi ha prodotto velocità di elaborazione diverse.
Se compili lo stesso codice su due PC diversi, è NORMALE che si possano
avere tempi di risposta diversi, perché basta che cambi un qualsiasi
parametro hardware (vedi velocità del processore, velocità della memoria,
velocità del disco, ecc...) o software (vedi paging/caching da parte del
sistema operativo, ecc..).  Se esegui un codice con quel ciclo di cui
parli su una macchina sufficientemente veloce ed esegui il codice privato
del ciclo su una macchina sufficientemente lenta, è possibile che la prima
si sbrighi prima della seconda.  D'altronde se ho 100 istruzioni da
eseguire su una macchina da 100 istruzioni/secondo, il tempo di esecuzione
sarà di 1 secondo, se ho 50 istruzioni da eseguire, su una macchina da 25
istruzioni al secondo, il tempo di esecuzione sarà di 2 secondi.
La domanda fondamentale è, quindi, i due PC sono gemelli ?


 commento) che compivano 40.050.000 cicli
Secondo me, senza vedere alcuna parte di quel codice, non si riesce 
materialmente a capire cosa è stato materialmente fatto sul codice stesso.
Non comprendo poi come si possano fare cicli, peraltro inutili, che 
contengono addirittura solo commenti... che senso ha una cosa del 
genere? :-)
Senza qualcosa di tangibile, almeno questo riguarda la mia posizione 
personale, non è possibile verificare cosa è stato fatto e quindi 
comprendere i motivi dei risultati che hai ottenuto nel tuo "benchmark".
Ciao,
   Marco.
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)

 cx" (bei tempi l'assembler...come lo rimpiango!)  la fŕ, o sbaglio?
Sě.  In realtŕ, nel caso dei cicli operativamente vuoti, come in questo
caso, l'ottimizzatore non prende quasi mai iniziative, perché il ciclo
potrebbe essere costruito ad hoc per implementare una "pausa" (seppure
questa tecnica č non portabile).


 questa tecnica è non portabile).
********
Quindi divevo bene quando scrivevo:
-----------------------------
Non sono d'accordo!
Il computer svolge tutti i cicli che sono 40.050.000
Quando il programma entra dentro i vari loop NON SA se troverà operazioni da
eseguire e quindi svolge ogni ciclo.
---------------------------- 

 La domanda fondamentale è, quindi, i due PC sono gemelli ?
I due PC sono diversi ma i due eseguibili li ho testati sul mio PC.
Dunque, compilare un sorgente su un PC piuttosto che in un altro comporta 
una diversa velocità in fase di elaborazione?

 una diversa velocità in fase di elaborazione?
E' possibile che l'ambiente prenda decisioni in base all'architettura
della macchina; bisognerebbe confrontare il codice assembly dell'uno e
dell'altro programma.  Delphi ha delle opzioni specifiche per i Pentium,
comunque.  Se puoi, procurati il codice macchina di entrambi i programmi
(lo fai con un normalissimo debugger) e confrontali.


 Quindi divevo bene quando scrivevo:
[...]
No, perché non hai capito nulla di quanto scrivevo nel primo messaggio.


 una diversa velocità in fase di elaborazione?
Scusa, ma non puoi compilare sulla tua macchina sia il tuo codice 
"ottimizzato" che quello "coi cicli inutili", e poi fare un confronto? 
Così vedi se la differenza sta nel sorgente o nel compilato su due 
macchine diverse.
-- 
news:it-alt.comp.software.openoffice : Il newsgroup dedicato a
OpenOffice.org, la suite open source di applicazioni per ufficio.
Saluti, VITRIOL

 diversi ha prodotto velocità di elaborazione diverse.
Se il delphi e' lo stesso ( stessa versione, sia del compilatore che 
delle librerie)....
Forse il loop non era proprio inutile, non e' che questo loop portava le 
variabili ad una situazione vantaggiosa?
Purtroppo sono un pessimo legimens e la sfera di cristallo e' in 
assistenza......


 questa tecnica è non portabile).
Probabilmente,oltre ad una "inc cx" farà anche una NOP...chissà...mai 
provato,andrebbe "debuggato" 

 Probabilmente,oltre ad una "inc cx" farà anche una NOP...
No, la NOP appesantisce solo il codice.
In condizioni normali, un ciclo loop viene compilato come:
xor registro, registro
.... (operazione)
inc registro
cmp registro, valore di uscita dal ciclo
jnz (indirizzo iniziale)
Questo se ci sono istruzioni da compiere; se invece non ci sono istruzioni
è presumibile che il compilatore, al fine di evitare un'istruzione in più,
traduca il codice invertendo lo scorrimento dell'indice:
mov registro, valore di uscita dal ciclo
dec registro
jnz (indirizzo iniziale)


 eseguire e quindi svolge ogni ciclo.
e quello che avevi scritto tu PRIMA
Non è vero affatto: l'ottimizzatore riesce a capire se quel ciclo contiene
istruzioni sensate o meno, ai fini del flusso del programma e potrebbe
benissimo non compilarle affatto.
e quello che hai scritto DOPO
Sì.  In realtà, nel caso dei cicli operativamente vuoti, come in questo
caso, l'ottimizzatore non prende quasi mai iniziative, perché il ciclo
potrebbe essere costruito ad hoc per implementare una "pausa" (seppure
questa tecnica è non portabile).
Al mio paese UNA PAUSA rappresenta del tempo perso. O no?
Quindi, avendo tolto questi milioni di operazioni...avrei dovuto ottenere 
una elaborazione(*) più veloce.
(*) codice identico (delphi 7) con l'unica differenza di quei cicli 
eliminati (nell'eseguibile che cionondimeno si è rivelato il più lento)
PS.
Preciso che la mia domanda da perfetto incompetente (per quanto riguarda 
Delphi) era questa:
"E' possibile che il mio amico abbia utilizzato un compilatore diverso?"
Adesso, probabilmente per colpa mia, si sta scadendo nella polemica e non 
vorrei.
Se sono stato io il fomentatore...scusatemi!

 "E' possibile che il mio amico abbia utilizzato un compilatore diverso?"
Mettiamola in questi termini: tu sei sicuro che quel ciclo, nel codice del
tuo amico, venga effettivamente eseguito ?


 ha scritto nel messaggio
news:ecuftv$7ha$1...@megan.servidellagleba.it...


 comprendere i motivi dei risultati che hai ottenuto nel tuo "benchmark".
Ecco la parte di codice:
Ho tolto il codice che sta tra gli asterischi
******************
codice tolto
******************
procedure Carica_Distanze();
 var
  x: Integer; y, k, z, w, Estratto: Byte;
  Cicli, Inizio, Fine: Integer;
  nE, nS, nA: Integer;
  LeRuoteGioco: array[1..10] Of Byte;
begin
  for x := 1 to 10 do
    leRuoteGioco[x] := StrToInt(MidStr(RuoteGioco,x,1));
  { ***************  ROUTINE DI CARICAMENTO IN MEMORIA DISTANZE PER CICLO
****************** }
  For Cicli := Numero_Cicli DownTo 1 do {xxx NUMERI_CICLI }
    begin
    Inizio := leEstrazioni[Cicli, 1];        {xxx leEstrazioni }
    Fine := leEstrazioni[Cicli, 2];
    Estratto := Estrazioni[Inizio, laRuota, lEstratto];   {xxx lEstratto ,
CmbRuota.ListIndex + 1 }
    For x := Inizio + 1 To Fine do
      begin
      For y := 1 To 10 do
        begin
        If LeRuoteGioco[y] = 1 then    {xxx OptRuota[y]}
         begin
          if Quanti = 1 then
            begin
              For k := 1 To 5 do
                begin
                  If Estrazioni[x, y, k] <> 0 Then
                  begin
                    nS := Estrazioni[x, y, k];
                    nE := nS - Estratto;       {xxx F90 }
                    nA := F90(nE);
                    Ambate[Cicli, nA] := 1;
                  end;
                end;
            end
         else if Quanti = 2 then
            begin
              For k := 1 To 4 do
                begin
                For z := k + 1 To 5 do
                  begin
                  If (Estrazioni[x, y, k] <> 0) And (Estrazioni[x, y, z] <>
0) then
                   begin
                    nS := Estrazioni[x, y, k];
                    nE := F90(nS - Estratto);
                    nS := Estrazioni[x, y, z];
                    nA := F90(nS - Estratto);
                    Ambi[Cicli, nE, nA] := 1;
                    Ambi[Cicli, nA, nE] := 1;
                   end;
                  end;
                end;
            end
**************************************
         else if Quanti = 3 then
            begin
              For k := 1 To 3 do
                begin
                For z := k + 1 To 4 do
                  begin
                   For w := z + 1 To 5 do
                    begin
                  If (Estrazioni[x, y, k] <> 0)
                   And (Estrazioni[x, y, z] <> 0)
                    And (Estrazioni[x, y, w] <> 0) then
                   begin
                    {nS := Estrazioni[x, y, k];
                    nE := F90(nS - Estratto);
                    nS := Estrazioni[x, y, z];
                    nA := F90(nS - Estratto);
                    nS := Estrazioni[x, y, w];
                    nT := F90(nS - Estratto);
                    Terni[Cicli, nE, nA, nT] := 1;
                    Terni[Cicli, nE, nT, nA] := 1;
                    Terni[Cicli, nA, nE, nT] := 1;
                    Terni[Cicli, nA, nT, nE] := 1;
                    Terni[Cicli, nT, nA, nE] := 1;
                    Terni[Cicli, nT, nE, nA] := 1;}
                   end;
                   end;
                  end;
                end;
            end;
****************************************************
         end;
        end;
      end;
    end;
end;

procedure Carica_Distanze();
[brrr]
Dio mio, ma come si fa a programmare cosě ? :-S

 Dio mio, ma come si fa a programmare cosě ? :-S
Cosě come?
Cosa avresti preteso da UNO che ha sempre programmato in VB e si accinge a
programmare in Delphi senza averlo mai studiato?
Oltre la critica che hai fatto...c'č qualche consiglio tecnico?
Mi pare che l'attenzione doveva essere riposta su tre cicli "inutili" invece
mi avete spinto a riportare il codice. E perché??? Per essere criticato non
costruttivamente????

costruttivamente????
Vedi sopra.

Ok, scusami per il disturbo arrecatoti.
Sei stato davvero gentile. Mi scuso anche a nome del mio amico che ha 
improvvisato un codice così obbrobrioso e mi scuso per avertelo fatto 
vedere.
Mi scuso per il fatto di non essere bravo e borioso come te.
Ci sono stati molti interventi in questo thread. Quasi tutti sono stati 
mirati a fornirmi una risposta. Non quelli tuoi.
Ti ringrazio per avermi risposto: questo mi ha onorato. Un programmatore 
della tua levatura si è abbassato con me (che ho proposto il codice di un 
mio amico che ha *improvvisato* un programma in Delphi).
Sono stato uno stupido: invece che porre la mia prima domanda...avrei dovuto 
riportare il sorgente e dire "Andrea, per piacere...prendimi un po' in giro! 
Dimmi che il mio amico è uno stupido in quanto non ha imparato Delphi in 
soli 5 minuti!"
Invece...
P.S.:
Sai cosa mi sta suggerendo un uccellino?
Che forse il codice ti è incomprensibile in quanto sei fuori dal campo 
trattato in quel codice.
Oppure sei così bravo che, se ti riporto una parte di codice di un qualsiasi 
altro programma, sei in grado di capire tutto?
Boh!
Preferisco rimanere con il dubbio.
"Andrea Laforgia" <a.laf...@andrealaforgia.it.invalid> ha scritto nel 
messaggio news:mbn7f2h45n0qp4uvn...@4ax.com...


 trattato in quel codice.
ROTFL.. e certo come no.  Fa' vedere il tuo codice a qualunque esperto di
programmazione e ti dirà le stesse cose che ti ho detto io.  Non fosse
altro che per regole spannometriche, quel codice è da gettare.


 altro che per regole spannometriche, quel codice è da gettare.
Quel codice da gettare...(che è *una parte di tutto*) ci è servito a 
velocizzare un nostro programma VB.
Questo programma (parlo di tutta l'applicazione) viene attualmente 
utilizzato da centinaia di persone che nel loro campo vengono definite 
"Esperti del Settore".
La parte di programma che hai visionato (che è una parte del codice delphi 
che è, a sua volta, parte di tutta l'applicazione) non fa altro che caricare 
un array dopo aver realizzato delle operazioni di somma-sottrazione).
Ti assicuro che funziona!
Io avevo chiesto se sapevate il perché *lo stesso codice* compilato da due 
PC diversi abbia fornito due .exe di differente velocità.
L'unica cosa che sono costretto ad ammettere (perché quando sbaglio... lo 
ammetto) è che probabilmente quella parte di codice è stata scritta in 
Delphi *con la mentalità di VB*
Tu, dopo un'attenta analisi del problema, SONO CERTO (e non lo dico per 
scherzo) che saresti riuscito a velocizzarla almeno del 50%. Purtroppo noi 
ci siamo dovuti accontentare di quello che siamo riusciti a fare.

 PC diversi abbia fornito due .exe di differente velocità.
Ed io personalmente ti ho detto che lo stesso codice, compilato da due PC
diversi NON può fornire due exe di differente velocità, a meno che il
sistema non prenda decisioni legate all'architettura.  Ti ho detto (e non
una volta) di prendere il codice macchina di entrambi i programmi e di
confrontarli.  Ora che stai aspettando?


 ...il che non aggiunge nulla al discorso...


Ciao a tutti.
Per quel che vale, io do ragione a Ilono.
Non mi pare che un NG sia un posto dove dare risposte come quelle di
laforgia. Nessuno ci obbliga a leggere/scrivere qui, ma non credo che la
cosa debba degenerare come quando parla quell\\\\\\\'impasticcato.
Voglio solo dire che certi modi di fare/scrivere qui sopra, non penso
debbano essere ulteriormente tollerati. Credo che i suoi post siano nella
hall-of-fame del ridicolo. Se non fosse che magari ci crede a quello che
dice, sarebbe anche comico; quasi una specie di confessionale del G.F.
dove uno si va a sfogare con gli altri. Patetico.
Insomma laforgia, datti una calmata. Oppure, se preferisci, credo che ci
sia un NG riservato alle discussioni; magari sottoscrivi quello.
Credo che molti saranno d\\\\\\\'accordo con me. Come dice Ilono,
comunque, questa è la mia opinione e penso di avere più diritti
dell\\\\\\\'esaurito ad esprimerla.
Ciao a tutti. Marco.
ilono ha scritto:


Magari mi manderai a quel paese...ma è veramente incomprensibile,concordo 
con Andrea.
Vorrei SOLO farti notare che un codice scritto così è veramente 
incomprensibile se lo passi a qualcun'altro.
Come ti hanno già detto, non è un fattore di "DELPHI" o "VB"...è un fattore 
puramente di "formattazione testo".
Il mio vuol essere solo un consiglio per il futuro (vedrai che se riprendi 
in mano quel codice dopo un'anno...non ci capirai niente).
Spero tu prenda nel "senso giusto" questa mia critica (buona o cattiva che 
tu la interpreti).
In bocca al lupo per il "problema lentezza codice".
Ciao!

Andrea, non ci combina nulla con questo post...cm se ti ricordi, in passato 
di "plonkai" per una discussione MOLTO animata...per me č acqua passata ok?

 davvero non si regge più quest'esaurito.
Qui, di esauriti, ovvero di gente che non ha più risorse (e probabilmente
non ne ha mai avute) al fine di alimentare discussioni sul piano tecnico,
probabilmente ci sei tu e molti altri, non di certo io.


 Insomma laforgia, datti una calmata.
Sorvolo volutamente su tutte le cazzate di cui sopra (qui nessuno si
impasticca, per la cronaca). Non ho bisogno di darmi nessuna calmata.
Io rispondo a chi mi pare, nel modo in cui mi pare, come faccio da una
decina d'anni a questa parte, rovesciando codice Delphi e scrivendone di
nuovo, dimostrando in che modo le cose sono sbagliate e consigliando il
modo di scriverne di giuste.  Questo è quello che io faccio
volontariamente; se la cosa ti sta bene, bene, altrimenti sei libero di
sottoscrivere TU un altro gruppo e seguirlo al posto di questo ;-)


 di "plonkai" per una discussione MOLTO animata...per me è acqua passata ok?
Eh ?! ... "acqua passata" ? guarda che del fatto che tu possa plonkarmi
non me ne frega un bel niente, caro "Michelinok", anche tu omino
mascherato.  Bada invece alle risposte che ti dò per scrivere programmi
corretti ;-)


ROTFL! ... da una ricerca veloce su Google viene fuori che tale "ilono" e
tale "marco moretti" appaiono solo oggi su Usenet e... solo in questo
thread! :)
AH AH AH... patetici, ragazzi ;)


 fattore puramente di "formattazione testo".
Con umiltà ti chiedo: puoi farmi vedere, anche solo per qualche riga, la 
differenza tra il mio codice *formattato male* ed il mio codice *formattato 
correttamente* ???
Io vorrei migliorarmi... 

 corretti ;-)
Mascherato per via dello spam, i consigli sono sempre ben accetti e motivo 
sempre di discussione/miglioramento (è quel che penso).
Ciao!

 
Invece di scrivere eresie su un NG pubblico perchè non scrivi in privato al
tuo interlocutore e eviti a noi di scaricare ciofeche inutili?
(vale anche per Moretti).
bye, giubbe

 Ciao
Ciao,
Andrea

 Ho tolto il codice che sta tra gli asterischi

Un pò di suggerimenti:
1) Usa un CASE OF anziché gli IF.
2) Usa nomi di variabili comprensibili anziché delle
    lettere come indici, anche perché chi conosce il
    gioco del lotto riesce a capire, gli altri no.
Quel commento è proprio del codice originale? Sei sicuro che lui l'abbia
tenuto commentato? Magari ha tolto il commento ed ha sfruttato il
codice, in quel caso probabilmente quei calcoli sono serviti a
migliorare le performance complessive del programma.
Ciao,
Andrea

 Io vorrei migliorarmi...
Visto che lo chiedi provo a darti qualche suggerimento, qualcosa non ti
piacerà, ma non importa; l'hai chiesto tu.
Prima di tutto un buon libro di letteratura, qualsiasi genere. Se ti
piace la fantascienza puoi leggere qualcosa di Orson Scott, comunque a
tua scelta. Questo ti serve anche nel mondo del lavoro, oltre che qui
sul gruppo.
Poi sul gruppo qualsiasi esso poniti sempre nell'ottica che qualcuno ne
sappia più di te, non devi dimostrare a nessuno di essere il più
bravo. Se lo fai rischi di precluderti delle risposte che ti aiutano ad
imparare argomenti nuovi.
Infine qualche consiglio di buona scrittura.
Non usare infiniti if then else su dei eventi (come la variabile
"quale" nel tuo esempio), in sua vece usa "case of". Fai una funzione
diversa per ogni evento che semplicemente richiamerai nel corpo del
case.
Usa nomi di variabili siginificativi, quindi niente "t", "r", "quale" o
altro. Per esempio, al posto di "quale" puoi usare
"NumeroCombinazioniScelte".
Questo aiuta chi legge il tuo codice e soprattutto aiuterà te quando
tra qualche tempo il cliente ti chiederà una modifica al software.
Sempre per i nomi degli elementi della GUI usa la convenzione di
indicare nelle prime lettere il tipo di elemento seguito da un nome
significativo.
Per esempio per un elemento di tipo Tedit che contiene il cognome di un
tizio, usa edCognome e non il classico edit1
Poi ricordati che stai usando un ambiente ad oggetti, quindi impara al
più presto l'uso delle classi. Il tuo codice sarà ancora più
leggibile e probabilmente con menu bug.
bye, giubbe

    gioco del lotto riesce a capire, gli altri no.
******
Quel ciclo che vedi sopra normalmente lo utilizziamo per ottenere le 
permutazioni (ordinate e senza ripetizioni) di tre numeri compresi tra 1 e 
90.
Seguendo il tuo consiglio avrei dovuto scrivere quanto segue?
else if Quanti = 3 then //quanti indica QUANTI elementi elaborare
 begin
   For primo_elemento := 1 To 3 do
   begin
     For secondo_elemento := primo_elemento + 1 To 4 do
     begin
       For terzo_elemento := secondo_elemento + 1 To 5 do
       begin
         If (Estrazioni[numero_estrazione, ruota, primo_elemento] <> 0) And 
(Estrazioni[numero_estrazione, ruota, secondo_elemento] <> 0) And
            (Estrazioni[numero_estrazione, ruota, terzo_elemento] <> 0) then
         begin
???

 ha scritto nel messaggio 
news:1156933642.5...@m73g2000cwd.googlegroups.com...
Poi sul gruppo qualsiasi esso poniti sempre nell'ottica che qualcuno ne
sappia piů di te, non devi dimostrare a nessuno di essere il piů
bravo. Se lo fai rischi di precluderti delle risposte che ti aiutano ad
imparare argomenti nuovi.
***
Ho dato l'impressione di uno che si crede il piů bravo?
In Delphi???
Sarei un pazzo!
Infine qualche consiglio di buona scrittura.
***
Ne terrň conto. Grazie mille! 

 ???
Io farei così:
case Quanti of
   1: Fai1; // Codice per l'1 qui
   2: Fai2;
   3: Pappardella;// Sostituisci a "pappardella" tutto il necessario
end;
poi all'interno avrei scritto così:
// Le var vanno all'inizio del blocco di codice della routine,
// devono essere locali ad esso sennò Delphi si incavola alquanto.
var Elem1_Idx, Elem2_Idx,Elem3_Idx;
     // Questi sono gli indici per ottenere combinazioni di 3 elementi
     // senza ripetizioni di numeri da 1 a 90
begin
... // Qui ci va tutta la roba prima dei for
   for Elem1_Idx := ...
     for Elem2_Idx := ...
       for Elem3_Idx := ...
       begin
         If (Estrazioni[NumEstrazione, ruota, Elem1_Idx] <> 0) And
            (Estrazioni[NumEstrazione, ruota, Elem2_Idx] <> 0) And
            (Estrazioni[NumEstrazione, ruota, Elem3_Idx] <> 0) then
         begin
           ...
         end;
       end;
Così sarebbe stato decisamente meglio, ovviamente tenendo conto delle
nidificazioni del codice e possibilmente spezzettando dove possibile.
Avreste potuto, tanto per dirne una, estrarre tre procedure(o
funzioni) dai valori di "Quanti", in questo modo semplificando di
molto il corpo principale.
Ciao,
Andrea

 Nessuno in questo thread ha detto questo.
 >
Non mi sembra di aver scritto "... qualcuno _in questo thread_ ...".
-- 
Roal Zanazzi


Non ci metterei la mano sul fuoco.
-- 
Roal Zanazzi

 
No, l'italiano e' comprensibile, e' solo che tralasci un quantita' di 
informazioni UTILI che potrebbero metterci in grado di capire di cosa 
stai parlando.
Senza offesa, non tutti si esprimono nello stesso modo.
-- 
Roal Zanazzi

 
<megasnip>
Ma Dio dei Programmatori!
Ma cos'e'?!?!
-- 
Roal Zanazzi

 Non ci metterei la mano sul fuoco.
Metticela pure.


 
Purtroppo, come gia' accaduto piu' volte in passato, questo post (e 
quelli di altri), non cambiera' la situazione.
Ignorare a volte migliora la vita.
-- 
Roal Zanazzi

 Ma cos'e'?!?!
NB che le tre righe di sopra erano soltanto un ulteriore aiuto per
individuare quale parte di codice avevo tolto.
Se avessi guardato più in basso...avresti trovato quanto segue:
**************************************
         else if Quanti = 3 then
            begin
              For k := 1 To 3 do
                begin
                For z := k + 1 To 4 do
                  begin
                   For w := z + 1 To 5 do
                    begin
                  If (Estrazioni[x, y, k] <> 0)
                   And (Estrazioni[x, y, z] <> 0)
                    And (Estrazioni[x, y, w] <> 0) then
                   begin


 
Con la tua ci puoi fare quello che vuoi (se vuoi ti do qualche idea), la 
mia e' affare mio.
Chiuso l'argomento.
-- 
Roal Zanazzi

 mia e' affare mio.
Bravo! qui hai dato il meglio di te stesso.
Che pena.


 Ignorare a volte migliora la vita.
Infatti ti beccherai a breve un bel *plonk* ;-)


 
Non mi interessa un granche', lui era finito nella mia blacklist tempo 
fa, ne e' uscito solo per sfortuna (mia), ma penso che ci rientrera'.
Peccato perche' tecnicamente avrebbe molto da dire, solo che e' una vera 
testa di cazzo sul lato caratteriale e delle relazioni inter-personali.
Comunque potevi anche scrivere col tuo vero nome, Andrea Laforgia...
o sei un suo collega in SISAL?
Oh si', non ci vuole molto a leggere gli header, mi risulta che lo 
sappia fare persino tu.
Vedo che laggiu' giudicate tanto (e a sproposito) sull'altrui uso di 
nickname, doppie personalita' e altre amenita' simili e poi...
Sono disgustato.
E qui chiudo definitivamente l'argomento, di Laforgia non ne voglio piu' 
sentire.
-- 
Roal Zanazzi

 sentire.
Io sono almeno sei casi che salto a piedi pari i post di questo
esaurito...ma quando PER CASO ne ho aperto uno, non ho potuto far altro
che indignarmi.
Sarebbe bello se si facesse il suo NG:
it.comp.lang.lafogia
Così si potrebbe fare le domande e rispondere da solo.
Prepariamoci ad entrare nell\'era laforgia ragazzi.Adoriamo.
Poveraccio! Che tristezza!


 Che pena.
procedure zittiamo_laforgia(andrea:tlaforgia);
var risultato:integer;
begin
  risultato:=andrea.diamogli_un_flacone_di_prozac_in_supposte;
  case risultato of
    sta_zitto: break;
    rompe_ancora: zittiamo_laforgia(andrea);
  end;
end;
Missione per laforgia:
Scegli il compilatore. Ottimizza il codice di cui sopra. RUN !!!!
