Je suis étonné que personne n'ai suggéré de les mettre dans un std::vector, de le trier et de prendre les 1er et dernier éléments. ;))
Le problème a été traité dans un fil voisin, il y a quelques jours.
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
Jean-Noël Mégoz
Salut !
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ? Cela dépend-il du compilateur ? Déclarer i en int ou en long a-t-il un effet là-dessus ?
J.No.
Salut !
Soit une variable i entière et initialisée.
Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Cela dépend-il du compilateur ?
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ? Cela dépend-il du compilateur ? Déclarer i en int ou en long a-t-il un effet là-dessus ?
J.No.
Vincent Lascaux
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Moi je pense que la premiere est de loin la plus comprehensible. Et je me demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie du code à optimiser qui te ferait gagner bien plus en rapidité que les quelques instructions machines que tu vas gagner en changeant de méthode.
-- Vincent
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Moi je pense que la premiere est de loin la plus comprehensible. Et je me
demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie du
code à optimiser qui te ferait gagner bien plus en rapidité que les quelques
instructions machines que tu vas gagner en changeant de méthode.
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Moi je pense que la premiere est de loin la plus comprehensible. Et je me demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie du code à optimiser qui te ferait gagner bien plus en rapidité que les quelques instructions machines que tu vas gagner en changeant de méthode.
-- Vincent
Jean-Noël Mégoz
"Vincent Lascaux" a écrit dans le message de news:414a088e$0$20447$
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Moi je pense que la premiere est de loin la plus comprehensible.
Entièrement d'accord, et c'est d'ailleurs celle que j'ai écrite dans mon code.
Et je me demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie du
code à optimiser qui te ferait gagner bien plus en rapidité que les quelques
instructions machines que tu vas gagner en changeant de méthode.
Là aussi, j'approuve. Si je pose la question, c'est juste par curiosité ! D'où le titre de mon message... ;)
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:414a088e$0$20447$626a14ce@news.free.fr...
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution
?
Moi je pense que la premiere est de loin la plus comprehensible.
Entièrement d'accord, et c'est d'ailleurs celle que j'ai écrite dans mon
code.
Et je me
demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie
du
code à optimiser qui te ferait gagner bien plus en rapidité que les
quelques
instructions machines que tu vas gagner en changeant de méthode.
Là aussi, j'approuve. Si je pose la question, c'est juste par curiosité !
D'où le titre de mon message... ;)
"Vincent Lascaux" a écrit dans le message de news:414a088e$0$20447$
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Moi je pense que la premiere est de loin la plus comprehensible.
Entièrement d'accord, et c'est d'ailleurs celle que j'ai écrite dans mon code.
Et je me demande aussi si tu t'es bien demandé s'il n'y avait pas une autre partie du
code à optimiser qui te ferait gagner bien plus en rapidité que les quelques
instructions machines que tu vas gagner en changeant de méthode.
Là aussi, j'approuve. Si je pose la question, c'est juste par curiosité ! D'où le titre de mon message... ;)
Philippe Guglielmetti
"Jean-Noël Mégoz" a écrit
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2); Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
la seconde, et très nettement car il n'y a pas de test et donc pas de rupture dans le flux d'instructions et donc le pipeline du proc reste bien plein. On peut d'ailleurs encore faire encore mieux: i-= 1-(i&1); qui ne fait pas de division. pour la lisibilité, tu peux faire: i-= 1-(i&1); // force i pair à l'impair inférieur
Cela dépend-il du compilateur ? non, je ne crois pas qu'il y ait des compilos assez malins pour
"convertir" le source de la première méthode en exécutable sans test et sans division.
Déclarer i en int ou en long a-t-il un effet là-dessus ? sur les machines modernes, les int et les longs ont tous deux 32 bits
: pas d'effet. si tes int font 16 bits, ca ira plus vite sur un proc 16 bits. Philippe - www.goulu.net
"Jean-Noël Mégoz" a écrit
Soit une variable i entière et initialisée.
Je veux que i soit impair. S'il est pair, je veux le ramener à
l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un
exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à
l'exécution ?
la seconde, et très nettement car il n'y a pas de test et donc pas de
rupture dans le flux d'instructions et donc le pipeline du proc reste
bien plein.
On peut d'ailleurs encore faire encore mieux: i-= 1-(i&1); qui ne
fait pas de division.
pour la lisibilité, tu peux faire:
i-= 1-(i&1); // force i pair à l'impair inférieur
Cela dépend-il du compilateur ?
non, je ne crois pas qu'il y ait des compilos assez malins pour
"convertir" le source de la première méthode en exécutable sans test
et sans division.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
sur les machines modernes, les int et les longs ont tous deux 32 bits
: pas d'effet. si tes int font 16 bits, ca ira plus vite sur un proc
16 bits.
Philippe - www.goulu.net
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2); Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
la seconde, et très nettement car il n'y a pas de test et donc pas de rupture dans le flux d'instructions et donc le pipeline du proc reste bien plein. On peut d'ailleurs encore faire encore mieux: i-= 1-(i&1); qui ne fait pas de division. pour la lisibilité, tu peux faire: i-= 1-(i&1); // force i pair à l'impair inférieur
Cela dépend-il du compilateur ? non, je ne crois pas qu'il y ait des compilos assez malins pour
"convertir" le source de la première méthode en exécutable sans test et sans division.
Déclarer i en int ou en long a-t-il un effet là-dessus ? sur les machines modernes, les int et les longs ont tous deux 32 bits
: pas d'effet. si tes int font 16 bits, ca ira plus vite sur un proc 16 bits. Philippe - www.goulu.net
Loïc Joly
Jean-Noël Mégoz wrote:
Salut !
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Celle qu'une mesure dans ton environnement aura montré être la plus rapide.
Cela dépend-il du compilateur ?
Peut-être. A confirmer par la mesure.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Peut-être. A confirmer par la mesure.
-- Loïc
Jean-Noël Mégoz wrote:
Salut !
Soit une variable i entière et initialisée.
Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Celle qu'une mesure dans ton environnement aura montré être la plus rapide.
Cela dépend-il du compilateur ?
Peut-être. A confirmer par la mesure.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Celle qu'une mesure dans ton environnement aura montré être la plus rapide.
Cela dépend-il du compilateur ?
Peut-être. A confirmer par la mesure.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Peut-être. A confirmer par la mesure.
-- Loïc
kanze
"Jean-Noël Mégoz" wrote in message news:<414a00eb$0$29069$...
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ? Cela dépend-il du compilateur ?
Ça dépend beaucoup du compilateur et du processeur. Il se peut que la réponse ne soit pas la même sur un Pentium Pro que sur un Dimension, de même qu'il peut dépendre du niveau de l'optimisation du compilateur.
Ceci dit, la solution classique serait plutôt :
i &= ~1 ;
d'après ce qu'il me semble. Solution qui risque aussi d'être la plus rapide.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Là aussi, ça dépend. En revanche, avec la solution classique que j'ai présenté, il faudrait se méfier -- ça doit marcher sur une machine complémente à deux dans tous les cas, mais sur une architecture magnitude signée, il vaudrait mieux que le 1 ait le même type que i.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Jean-Noël Mégoz" <nospam_jnmegoz@infonie.fr> wrote in message
news:<414a00eb$0$29069$626a14ce@news.free.fr>...
Soit une variable i entière et initialisée. Je veux que i soit
impair. S'il est pair, je veux le ramener à l'impair immédiatement
inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
-> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à
l'exécution ? Cela dépend-il du compilateur ?
Ça dépend beaucoup du compilateur et du processeur. Il se peut que la
réponse ne soit pas la même sur un Pentium Pro que sur un Dimension, de
même qu'il peut dépendre du niveau de l'optimisation du compilateur.
Ceci dit, la solution classique serait plutôt :
i &= ~1 ;
d'après ce qu'il me semble. Solution qui risque aussi d'être la plus
rapide.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Là aussi, ça dépend. En revanche, avec la solution classique que j'ai
présenté, il faudrait se méfier -- ça doit marcher sur une machine
complémente à deux dans tous les cas, mais sur une architecture
magnitude signée, il vaudrait mieux que le 1 ait le même type que i.
--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Jean-Noël Mégoz" wrote in message news:<414a00eb$0$29069$...
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple ! -> i -= 1 - (i % 2);
Je me demandais laquelle des solutions est la plus rapide à l'exécution ? Cela dépend-il du compilateur ?
Ça dépend beaucoup du compilateur et du processeur. Il se peut que la réponse ne soit pas la même sur un Pentium Pro que sur un Dimension, de même qu'il peut dépendre du niveau de l'optimisation du compilateur.
Ceci dit, la solution classique serait plutôt :
i &= ~1 ;
d'après ce qu'il me semble. Solution qui risque aussi d'être la plus rapide.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
Là aussi, ça dépend. En revanche, avec la solution classique que j'ai présenté, il faudrait se méfier -- ça doit marcher sur une machine complémente à deux dans tous les cas, mais sur une architecture magnitude signée, il vaudrait mieux que le 1 ait le même type que i.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Alexandre Bacquart
Jean-Noël Mégoz wrote:
Salut !
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
1 modulo, 1 test, 1 décrémentation (éventuelle).
-> i -= 1 - (i % 2);
1 modulo, 2 soustractions.
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Je pense que les 2 se valent, mais pour la rapidité, je préfère la seconde car il n'y a pas de test (pipeline exploité) et son temps d'exécution est fixe. Pour la lisibilité, je préfère la première.
Cela dépend-il du compilateur ?
S'il n'optimise pas, il va faire le modulo (donc une division). Et dans le premier cas, je ne pense pas qu'il y ait beaucoup de compilos capables d'optimiser un if(), même aussi simple que celui-ci. Mais aujourd'hui comme hier il n'y a pas 36 façons d'optimiser ça pour les entiers :
i -= (i & 1) ^ 1; // pas très propre
Ca évite le modulo. Je te conseille quand-même de n'utiliser ça que si le compilo n'optimise pas et que c'est du code critique. Et j'espère que tu n'oublies pas le cas i == 0 aussi.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
En termes de vitesse ? si l'implémentation fait que sizeof(int)!=sizeof(long), cela dépend alors de la plateforme mais dans ce cas, en principe (mais pas forcément) int est l'entier "idéal".
-- Tek
Jean-Noël Mégoz wrote:
Salut !
Soit une variable i entière et initialisée.
Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair
immédiatement inférieur. Je vois deux façons d'écrire ça :
-> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
1 modulo, 1 test, 1 décrémentation (éventuelle).
-> i -= 1 - (i % 2);
1 modulo, 2 soustractions.
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Je pense que les 2 se valent, mais pour la rapidité, je préfère la
seconde car il n'y a pas de test (pipeline exploité) et son temps
d'exécution est fixe. Pour la lisibilité, je préfère la première.
Cela dépend-il du compilateur ?
S'il n'optimise pas, il va faire le modulo (donc une division). Et dans
le premier cas, je ne pense pas qu'il y ait beaucoup de compilos
capables d'optimiser un if(), même aussi simple que celui-ci. Mais
aujourd'hui comme hier il n'y a pas 36 façons d'optimiser ça pour les
entiers :
i -= (i & 1) ^ 1; // pas très propre
Ca évite le modulo. Je te conseille quand-même de n'utiliser ça que si
le compilo n'optimise pas et que c'est du code critique. Et j'espère que
tu n'oublies pas le cas i == 0 aussi.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
En termes de vitesse ? si l'implémentation fait que
sizeof(int)!=sizeof(long), cela dépend alors de la plateforme mais dans
ce cas, en principe (mais pas forcément) int est l'entier "idéal".
Soit une variable i entière et initialisée. Je veux que i soit impair. S'il est pair, je veux le ramener à l'impair immédiatement inférieur. Je vois deux façons d'écrire ça : -> if(i % 2 == 0) i--; // foin des accolades, c'est un exemple !
1 modulo, 1 test, 1 décrémentation (éventuelle).
-> i -= 1 - (i % 2);
1 modulo, 2 soustractions.
Je me demandais laquelle des solutions est la plus rapide à l'exécution ?
Je pense que les 2 se valent, mais pour la rapidité, je préfère la seconde car il n'y a pas de test (pipeline exploité) et son temps d'exécution est fixe. Pour la lisibilité, je préfère la première.
Cela dépend-il du compilateur ?
S'il n'optimise pas, il va faire le modulo (donc une division). Et dans le premier cas, je ne pense pas qu'il y ait beaucoup de compilos capables d'optimiser un if(), même aussi simple que celui-ci. Mais aujourd'hui comme hier il n'y a pas 36 façons d'optimiser ça pour les entiers :
i -= (i & 1) ^ 1; // pas très propre
Ca évite le modulo. Je te conseille quand-même de n'utiliser ça que si le compilo n'optimise pas et que c'est du code critique. Et j'espère que tu n'oublies pas le cas i == 0 aussi.
Déclarer i en int ou en long a-t-il un effet là-dessus ?
En termes de vitesse ? si l'implémentation fait que sizeof(int)!=sizeof(long), cela dépend alors de la plateforme mais dans ce cas, en principe (mais pas forcément) int est l'entier "idéal".
