Merci de poster les réponses au groupe afin d'en faire profiter à tous
ng
Salut,
Je ne pense pas qu'il y ait une grosse différence à ce niveau là.
Si tu connais par avance le nombre de tour, je te conseille For, ca t'évite d'incrémenter toi même la variable et c'est peut être ca qui fait la différence de rapidité entre les 2.
-- Nicolas G. FAQ VB : http://faq.vb.free.fr API Guide : http://www.allapi.net Google Groups : http://groups.google.fr/ MZ-Tools : http://www.mztools.com/
Titeuf a écrit :
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
Salut,
Je ne pense pas qu'il y ait une grosse différence à ce niveau là.
Si tu connais par avance le nombre de tour, je te conseille For, ca t'évite
d'incrémenter toi même la variable et c'est peut être ca qui fait la
différence de rapidité entre les 2.
--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/
Titeuf <titeuf@no-spam.fr> a écrit :
Quel type est plus rapide pour effectuer un nombre important de boucle
(5000) ?
For...next ou Do...loop while ?
Je ne pense pas qu'il y ait une grosse différence à ce niveau là.
Si tu connais par avance le nombre de tour, je te conseille For, ca t'évite d'incrémenter toi même la variable et c'est peut être ca qui fait la différence de rapidité entre les 2.
-- Nicolas G. FAQ VB : http://faq.vb.free.fr API Guide : http://www.allapi.net Google Groups : http://groups.google.fr/ MZ-Tools : http://www.mztools.com/
Titeuf a écrit :
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
Jean-Marc
"Titeuf" a écrit dans le message de news:c1g674$7ns$
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
Bonjour, En général, le temps d'exécution de la boucle est petit devant le temps dans la boucle. De plus, on n'obtient de différences significatives (mesurables) que pour de *grand* nombre de boucles (1 million dans mon exemple).
Le programme suivant fait la même choses de 2 façons différentes: une fois avec while, une fois avec for. Dans les 2 cas, je le force à utiliser la variable de la boucle à l'intérieur pour forcer réellement le for à utiliser sa variable.
Si on exécute ce programme depuis l'IDE, on ontient: WHILE : 411 ms , FOR : 200
Chouette se dit on, je vais faire des for, et tout est dit. Ouais.. Sauf que si on compile, et qu'on exécute en lançant l'exécutable, on trouve: WHILE : 10 ms FOR: 10 ms ..... Surprise !!
C'est bien normal: lors de la compilation, le compilateur fait son job: il compile et il "comprend" qu'on veut dans les 2 cas faire la même chose. Il génère donc le même code dans les 2 cas, d'ou lles résultats identiques.
Jean-Marc
---------------------------------------------------------------- Option Explicit Private Declare Function GetTickCount Lib "kernel32" () As Long
Private Sub Command1_Click() Dim i As Long Dim j As Long Dim a As Integer Dim b As Integer Dim t1 As Long Dim t2 As Long Dim tt As Long
i = 1 a = 0 b = 1 t1 = GetTickCount() While i <> 1000000 a = a + b If a > 1000 Then a = 0 End If If i Mod 2 Then a = 1 End If i = i + 1 Wend t2 = GetTickCount() tt = t2 - t1
a = 0 b = 1 t1 = GetTickCount() For i = 1 To 1000000 a = a + b If a > 1000 Then a = 0 End If If i Mod 2 Then a = 1 End If Next i t2 = GetTickCount() MsgBox "while : " & tt & " for : " & (t2 - t1) End Sub
"Titeuf" <titeuf@no-spam.fr> a écrit dans le message de
news:c1g674$7ns$1@news-reader2.wanadoo.fr...
Quel type est plus rapide pour effectuer un nombre important de boucle
(5000) ?
For...next ou Do...loop while ?
Merci
Bonjour,
En général, le temps d'exécution de la boucle est petit devant le temps dans
la boucle. De plus, on n'obtient de différences significatives (mesurables)
que pour de *grand* nombre de boucles (1 million dans mon exemple).
Le programme suivant fait la même choses de 2 façons différentes: une fois
avec while, une fois avec for. Dans les 2 cas, je le force à utiliser la
variable de la boucle à l'intérieur pour forcer réellement le for à utiliser
sa variable.
Si on exécute ce programme depuis l'IDE, on ontient:
WHILE : 411 ms , FOR : 200
Chouette se dit on, je vais faire des for, et tout est dit. Ouais.. Sauf que
si on compile, et qu'on exécute en lançant l'exécutable, on trouve:
WHILE : 10 ms FOR: 10 ms ..... Surprise !!
C'est bien normal: lors de la compilation, le compilateur fait son job: il
compile et il "comprend" qu'on veut dans les 2 cas faire la même chose. Il
génère donc le même code dans les 2 cas, d'ou lles résultats identiques.
Jean-Marc
----------------------------------------------------------------
Option Explicit
Private Declare Function GetTickCount Lib "kernel32" () As Long
Private Sub Command1_Click()
Dim i As Long
Dim j As Long
Dim a As Integer
Dim b As Integer
Dim t1 As Long
Dim t2 As Long
Dim tt As Long
i = 1
a = 0
b = 1
t1 = GetTickCount()
While i <> 1000000
a = a + b
If a > 1000 Then
a = 0
End If
If i Mod 2 Then
a = 1
End If
i = i + 1
Wend
t2 = GetTickCount()
tt = t2 - t1
a = 0
b = 1
t1 = GetTickCount()
For i = 1 To 1000000
a = a + b
If a > 1000 Then
a = 0
End If
If i Mod 2 Then
a = 1
End If
Next i
t2 = GetTickCount()
MsgBox "while : " & tt & " for : " & (t2 - t1)
End Sub
"Titeuf" a écrit dans le message de news:c1g674$7ns$
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
Bonjour, En général, le temps d'exécution de la boucle est petit devant le temps dans la boucle. De plus, on n'obtient de différences significatives (mesurables) que pour de *grand* nombre de boucles (1 million dans mon exemple).
Le programme suivant fait la même choses de 2 façons différentes: une fois avec while, une fois avec for. Dans les 2 cas, je le force à utiliser la variable de la boucle à l'intérieur pour forcer réellement le for à utiliser sa variable.
Si on exécute ce programme depuis l'IDE, on ontient: WHILE : 411 ms , FOR : 200
Chouette se dit on, je vais faire des for, et tout est dit. Ouais.. Sauf que si on compile, et qu'on exécute en lançant l'exécutable, on trouve: WHILE : 10 ms FOR: 10 ms ..... Surprise !!
C'est bien normal: lors de la compilation, le compilateur fait son job: il compile et il "comprend" qu'on veut dans les 2 cas faire la même chose. Il génère donc le même code dans les 2 cas, d'ou lles résultats identiques.
Jean-Marc
---------------------------------------------------------------- Option Explicit Private Declare Function GetTickCount Lib "kernel32" () As Long
Private Sub Command1_Click() Dim i As Long Dim j As Long Dim a As Integer Dim b As Integer Dim t1 As Long Dim t2 As Long Dim tt As Long
i = 1 a = 0 b = 1 t1 = GetTickCount() While i <> 1000000 a = a + b If a > 1000 Then a = 0 End If If i Mod 2 Then a = 1 End If i = i + 1 Wend t2 = GetTickCount() tt = t2 - t1
a = 0 b = 1 t1 = GetTickCount() For i = 1 To 1000000 a = a + b If a > 1000 Then a = 0 End If If i Mod 2 Then a = 1 End If Next i t2 = GetTickCount() MsgBox "while : " & tt & " for : " & (t2 - t1) End Sub
La présence d'un compteur de boucle ralentit la procédure.
En d'autre termes, une boucle folle dont le compteur est de type Byte tournera plus vite que celle dotée d'un type Long ... mais sa rotation sera imitée à 256 tours.
La boucle Do ... Loop n'est freinée que par le test de sa condition. Globalement ça doit revenir au même. -- Bonne réception.
http://perso.wanadoo.fr/andre.araste/ Membre du Club Win's: http://www.clubwins.org Avertissement: Je ne vends rien.
"Titeuf" a écrit dans le message de news:c1g674$7ns$
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
La présence d'un compteur de boucle ralentit la procédure.
En d'autre termes, une boucle folle dont le compteur est de type Byte
tournera plus vite que celle dotée d'un type Long ... mais sa rotation sera
imitée à 256 tours.
La boucle Do ... Loop n'est freinée que par le test de sa condition.
Globalement ça doit revenir au même.
--
Bonne réception.
andre.araste@wanadoo.fr
http://perso.wanadoo.fr/andre.araste/
Membre du Club Win's: http://www.clubwins.org
Avertissement: Je ne vends rien.
"Titeuf" <titeuf@no-spam.fr> a écrit dans le message de
news:c1g674$7ns$1@news-reader2.wanadoo.fr...
Quel type est plus rapide pour effectuer un nombre important de boucle
(5000) ?
For...next ou Do...loop while ?
La présence d'un compteur de boucle ralentit la procédure.
En d'autre termes, une boucle folle dont le compteur est de type Byte tournera plus vite que celle dotée d'un type Long ... mais sa rotation sera imitée à 256 tours.
La boucle Do ... Loop n'est freinée que par le test de sa condition. Globalement ça doit revenir au même. -- Bonne réception.
http://perso.wanadoo.fr/andre.araste/ Membre du Club Win's: http://www.clubwins.org Avertissement: Je ne vends rien.
"Titeuf" a écrit dans le message de news:c1g674$7ns$
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
François Picalausa
Bonjour/soir,
concernant For...Next, et de son bon usage, il y a un article intéressant ici: http://www.xbeat.net/vbspeed/c_ForNext.htm
"Titeuf" a écrit dans le message de news:c1g674$7ns$
Quel type est plus rapide pour effectuer un nombre important de boucle (5000) ? For...next ou Do...loop while ?
Merci
Zoury
Salut Andre! :O)
La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
En d'autre termes, une boucle folle dont le compteur est de type Byte tournera plus vite que celle dotée d'un type Long ... mais sa rotation
sera
imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur. Là où je ne suis pas d'accord, est que soit plus rapide si le compteur est de type Byte. La majorité des systèmes sont encore optimisé pour les formats de données sur 32 bits, ce sera donc plus rapide si le compteur est de type Long.
Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement minime qu'il faudrait un bon nombre de tours (quelques millions par exemple) avant d'avoir une différence notable à AMHA..
Merci de poster les réponses au groupe afin d'en faire profiter à tous
Salut Andre! :O)
La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
En d'autre termes, une boucle folle dont le compteur est de type Byte
tournera plus vite que celle dotée d'un type Long ... mais sa rotation
sera
imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la
faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la
structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur. Là
où je ne suis pas d'accord, est que soit plus rapide si le compteur est de
type Byte. La majorité des systèmes sont encore optimisé pour les formats de
données sur 32 bits, ce sera donc plus rapide si le compteur est de type
Long.
Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement
minime qu'il faudrait un bon nombre de tours (quelques millions par exemple)
avant d'avoir une différence notable à AMHA..
La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
En d'autre termes, une boucle folle dont le compteur est de type Byte tournera plus vite que celle dotée d'un type Long ... mais sa rotation
sera
imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur. Là où je ne suis pas d'accord, est que soit plus rapide si le compteur est de type Byte. La majorité des systèmes sont encore optimisé pour les formats de données sur 32 bits, ce sera donc plus rapide si le compteur est de type Long.
Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement minime qu'il faudrait un bon nombre de tours (quelques millions par exemple) avant d'avoir une différence notable à AMHA..
Merci de poster les réponses au groupe afin d'en faire profiter à tous
andre.araste
>Je ne vois pas en quoi le type de la variable compteur intervient en la
faveur d'un Byte plus que d'un Long.
Je crains qu'on se comprenne mal.
Une variable de type Byte est codée sur un seul octet dans l'intervalle de valeurs de 0 à 255
Pour vous en convaincre, réalisez ce programme :
Dim Compteur As Byte For Compteur = 0 To 256 Then Print "Bonjour !" Next Compteur
Dès que Compteur va prendre la valeur 256 soit au 257ème tour vous allez constater une belle erreur système ... avec la sortie de programme qui s'impose.
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un type Double elle mettrait 8 fois plus de temps.
D'accord ? -- Bonne réception.
http://perso.wanadoo.fr/andre.araste/ Membre du Club Win's: http://www.clubwins.org Avertissement: Je ne vends rien.
"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de news:eAhc4d6%
Salut Andre! :O)
> La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
> En d'autre termes, une boucle folle dont le compteur est de type Byte > tournera plus vite que celle dotée d'un type Long ... mais sa rotation sera > imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur.
Là
où je ne suis pas d'accord, est que soit plus rapide si le compteur est de type Byte. La majorité des systèmes sont encore optimisé pour les formats
de
données sur 32 bits, ce sera donc plus rapide si le compteur est de type Long.
> Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement minime qu'il faudrait un bon nombre de tours (quelques millions par
exemple)
avant d'avoir une différence notable à AMHA..
>Je ne vois pas en quoi le type de la variable compteur intervient en la
faveur d'un Byte plus que d'un Long.
Je crains qu'on se comprenne mal.
Une variable de type Byte est codée sur un seul octet dans l'intervalle de
valeurs de 0 à 255
Pour vous en convaincre, réalisez ce programme :
Dim Compteur As Byte
For Compteur = 0 To 256 Then
Print "Bonjour !"
Next Compteur
Dès que Compteur va prendre la valeur 256 soit au 257ème tour vous allez
constater une belle erreur système ... avec la sortie de programme qui
s'impose.
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un
seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un
type Double elle mettrait 8 fois plus de temps.
D'accord ?
--
Bonne réception.
andre.araste@wanadoo.fr
http://perso.wanadoo.fr/andre.araste/
Membre du Club Win's: http://www.clubwins.org
Avertissement: Je ne vends rien.
"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de
news:eAhc4d6%23DHA.2552@TK2MSFTNGP09.phx.gbl...
Salut Andre! :O)
> La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
> En d'autre termes, une boucle folle dont le compteur est de type Byte
> tournera plus vite que celle dotée d'un type Long ... mais sa rotation
sera
> imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la
faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la
structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur.
Là
où je ne suis pas d'accord, est que soit plus rapide si le compteur est de
type Byte. La majorité des systèmes sont encore optimisé pour les formats
de
données sur 32 bits, ce sera donc plus rapide si le compteur est de type
Long.
> Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement
minime qu'il faudrait un bon nombre de tours (quelques millions par
>Je ne vois pas en quoi le type de la variable compteur intervient en la
faveur d'un Byte plus que d'un Long.
Je crains qu'on se comprenne mal.
Une variable de type Byte est codée sur un seul octet dans l'intervalle de valeurs de 0 à 255
Pour vous en convaincre, réalisez ce programme :
Dim Compteur As Byte For Compteur = 0 To 256 Then Print "Bonjour !" Next Compteur
Dès que Compteur va prendre la valeur 256 soit au 257ème tour vous allez constater une belle erreur système ... avec la sortie de programme qui s'impose.
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un type Double elle mettrait 8 fois plus de temps.
D'accord ? -- Bonne réception.
http://perso.wanadoo.fr/andre.araste/ Membre du Club Win's: http://www.clubwins.org Avertissement: Je ne vends rien.
"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de news:eAhc4d6%
Salut Andre! :O)
> La présence d'un compteur de boucle ralentit la procédure.
Je suis d'accord.
> En d'autre termes, une boucle folle dont le compteur est de type Byte > tournera plus vite que celle dotée d'un type Long ... mais sa rotation sera > imitée à 256 tours.
Je ne vois pas en quoi le type de la variable compteur intervient en la faveur d'un Byte plus que d'un Long.
Je suis d'accord avec le fait qu'une boucle For soit plus lente que le la structure Do Loop dans la mesure ou celle-ci doit incrémenté un compteur.
Là
où je ne suis pas d'accord, est que soit plus rapide si le compteur est de type Byte. La majorité des systèmes sont encore optimisé pour les formats
de
données sur 32 bits, ce sera donc plus rapide si le compteur est de type Long.
> Globalement ça doit revenir au même.
J'suis d'accord. La différence entre les deux structures est tellement minime qu'il faudrait un bon nombre de tours (quelques millions par
exemple)
avant d'avoir une différence notable à AMHA..
Zoury
Resalut!
Une variable de type Byte est codée sur un seul octet dans l'intervalle de valeurs de 0 à 255
On ne peut plus d'accord! :O)
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un type Double elle mettrait 8 fois plus de temps.
D'accord ?
Nope!
Dans un système 32bits, comme c'est le cas pour la majorité des logiciels (et matériels) actuels (NT4, 2000, XP, 95, 98, Me, VB6, etc.), le CPU traite les données en bloc de 32bits (et les bus aussi). Si on lui passe une données de type Long qui est stockée sur 32 bits, il traite la valeur tel quelle sans aucune modification supplémentaire. Si toutefois on lui passe une variable de Byte qui est stockée sur 8 bits, le système devra masquer les 24bits qui sont inutilisé par ce format de variable avant d'envoyé la valeur au CPU, ce qui demande évidemment des intructions supplémentaires. Le nombres d'instructions effectuées sur les données afin de les formattés correctement pour le CPU peuvent varier d'un type à l'autre, mais une chose est sûre, c'est que d'utiliser un type dont la taille est identique à celle utilisé par le matériel/logiciel du système demande moins de ressources.
Merci de poster les réponses au groupe afin d'en faire profiter à tous
Resalut!
Une variable de type Byte est codée sur un seul octet dans l'intervalle de
valeurs de 0 à 255
On ne peut plus d'accord! :O)
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un
seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un
type Double elle mettrait 8 fois plus de temps.
D'accord ?
Nope!
Dans un système 32bits, comme c'est le cas pour la majorité des logiciels
(et matériels) actuels (NT4, 2000, XP, 95, 98, Me, VB6, etc.), le CPU traite
les données en bloc de 32bits (et les bus aussi).
Si on lui passe une données de type Long qui est stockée sur 32 bits, il
traite la valeur tel quelle sans aucune modification supplémentaire. Si
toutefois on lui passe une variable de Byte qui est stockée sur 8 bits, le
système devra masquer les 24bits qui sont inutilisé par ce format de
variable avant d'envoyé la valeur au CPU, ce qui demande évidemment des
intructions supplémentaires. Le nombres d'instructions effectuées sur les
données afin de les formattés correctement pour le CPU peuvent varier d'un
type à l'autre, mais une chose est sûre, c'est que d'utiliser un type dont
la taille est identique à celle utilisé par le matériel/logiciel du système
demande moins de ressources.
Une variable de type Byte est codée sur un seul octet dans l'intervalle de valeurs de 0 à 255
On ne peut plus d'accord! :O)
... mais la boucle va tourner à une vitesse folle car elle n'explore qu'un seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec un type Double elle mettrait 8 fois plus de temps.
D'accord ?
Nope!
Dans un système 32bits, comme c'est le cas pour la majorité des logiciels (et matériels) actuels (NT4, 2000, XP, 95, 98, Me, VB6, etc.), le CPU traite les données en bloc de 32bits (et les bus aussi). Si on lui passe une données de type Long qui est stockée sur 32 bits, il traite la valeur tel quelle sans aucune modification supplémentaire. Si toutefois on lui passe une variable de Byte qui est stockée sur 8 bits, le système devra masquer les 24bits qui sont inutilisé par ce format de variable avant d'envoyé la valeur au CPU, ce qui demande évidemment des intructions supplémentaires. Le nombres d'instructions effectuées sur les données afin de les formattés correctement pour le CPU peuvent varier d'un type à l'autre, mais une chose est sûre, c'est que d'utiliser un type dont la taille est identique à celle utilisé par le matériel/logiciel du système demande moins de ressources.
Merci de poster les réponses au groupe afin d'en faire profiter à tous
jmn
mais comme le compilateur utilise systématiquement ?X pour les entiers 8 ou 16 bits, et E?X pour les entiers longs, et que de plus il génère un XOR sur le registre concerné avant chaque séquence de calcul pour le mettre à zéro, il n'y a pas de traitement particulier pour les 'petites valeurs' et, in fine, l'utilisation d'un entier 8, 16 ou 32 bits revient strictement au même...
mais comme le compilateur utilise systématiquement ?X pour les entiers 8 ou
16 bits, et E?X pour les entiers longs, et que de plus il génère un XOR sur
le registre concerné avant chaque séquence de calcul pour le mettre à zéro,
il n'y a pas de traitement particulier pour les 'petites valeurs' et, in
fine, l'utilisation d'un entier 8, 16 ou 32 bits revient strictement au
même...
mais comme le compilateur utilise systématiquement ?X pour les entiers 8 ou 16 bits, et E?X pour les entiers longs, et que de plus il génère un XOR sur le registre concerné avant chaque séquence de calcul pour le mettre à zéro, il n'y a pas de traitement particulier pour les 'petites valeurs' et, in fine, l'utilisation d'un entier 8, 16 ou 32 bits revient strictement au même...
