Imaginons que je sois obligé d'utiliser ma propre fonction signum. Dans notre cas on dira que sgn(n) fonction renvoie -1 si n est negatif, et 1 si n est positif. Son comportement n'est pas défini pour n = 0 et on l'assume.

Laquelle de ces 2 formulations est la plus rapide sachant que c'est un programme écrit en C? et en Python?

(formulations en pseudocode)

sgn(n):
if(n>0) return 1
return -1

sgn(n):
return -1+2*(n>0)

Bah teste ? :p
En tout cas c'est moche.

Il est difficile de repondre a une question comme celle la. Ca depend beaucoup de ce que le compilateur va faire. Et de comment le processeur est construit.

Cependant, la fonction est tellement simple qu'il ne devrait pas etre important quelle version est la plus rapide. Deplus ca change certainement d'un processeur a l'autre.

Personnellement, je pense qu'il est au contraire trivial de répondre à une telle question.

En C, je ne vois pas pourquoi le second code serait correct déjà. Et puis de toute façon, c'est le boulot du compilateur de transformer la première version en quelque chose d'efficace sur l'architecture cible. D'ailleurs, ce qui me vient en tête c'est plutôt :

sgn(n):
return (n & (0x80000000) >> 30) + 1

(code à ajuster en fonction de la taille des entiers) si n est entier, et

sgn(n):
return (n & 0x8000000000000000) | 0x7ff0000000000000

si n est un double.

PS: Ne pas utiliser le premier code tel quel en C, ça ne marchera sans doute pas à cause du >> qui risque de ne pas être traduit en un shift arithmetique. Quant au deuxième code, il faudra abuser du cast (et passer par du unsigned long*) pour le faire marcher correctement en C.

PPS: "(formulations en pseudocode) " non, formulation en python (modulo l'omission de def)

J'oubliais... en python, la question ne se pose juste pas. La couche d'interprétation fait que ce genre d'optimisations n'apporte rien d'autre que des noeuds au cerveau.

Comme godrik j'aurai opté pour un test.
Les micro-optimisations c'est tellement contre-intuitif parfois...

Chris_27 Je comptais poster une solution similaire (n & MOST_SIGNIFICANT_BIT_HERE ) >> TYPE_BITS (Pour un nombre entier). Avec la même réserve sur le comportement du décalage (conservera-t-il le signe ?).
Pour python, je confirme que ça n'a pas trop de sens d'essayer de gratter quoi que ce soit à ce niveau :D

((n & MOST_SIGNIFICANT_BIT_MASK_HERE ) >> TYPE_BITS)|1

J'avais oublié un bout. Encore une fois, uniquement si
0x80000000>>32 = 0xFFFFFFFF

EDIT : En C, >> a un comportement signé si le type décalé est signé, cool

ok merci

Chris le second code est correcte en C I'll me semble. Qu'est ce qui t'embete ?

Selon l'architecture. Le premier code peut se faire en 3 instructions le deuxieme pourrait en couter plus. (En fonction de la presence d'encodage de constante dans le jeu d'instruction)