obtenez la valeur absolue sans utiliser la fonction abs ni l'instruction if

int abs(int v) 
{
  return v * ( (v<0) * (-1) + (v>0));
  // simpler: v * ((v>0) - (v<0))   thanks Jens
}

Ce code multiplie la valeur de v avec -1 ou 1 pour obtenir abs(v). Par conséquent, à l'intérieur de la parenthèse sera l'un des -1 ou 1.

Si v est positif, l'expression (v>0) est vrai et aura la valeur de 1 tout (v<0) est faux (avec une valeur de 0 pour faux). Par conséquent, quand {[1] } est positif ((v>0) - (v<0)) = (1-0) = 1. Et l'expression entière est: v * (1) == v.

Si v est négatif, l'expression (v>0) est faux et aura la valeur de 0 tout (v<0) est vrai (valeur 1). Ainsi, pour négatif v, ((v>0) - (v<0)) = (0-1) = -1. Et toute l'expression est: v * (-1) == -v.

Lorsque v == 0, les deux (v<0) et (v>0) évaluera à 0, laissant: v * 0 == 0.

Sans branchement^*:

int abs (int n) {
    const int ret[2] = { n, -n };
    return ret [n<0];
}

_{Remarque 4.7 Partie Intégrante Des Conversions / 4: [...] If the source type is bool, the value false is converted to zero and the value true is converted to one.}

_{^*: en ce sens qu'il n'y a pas de branchement conditionnel dans votre code. Sous le capot, l'opérateur ternaire produira également une branche. Cependant, c'est aussi une réponse valide, car la ternaire n'est pas une instruction if. Cela n'implique pas que votre compilateur ne soit pas capable d'émettre du code d'assemblage branchfree pour le code qui se branche logiquement.}

En supposant des entiers signés 32 bits (Java), vous pouvez écrire:

public static int abs(int x)
{
    return (x + (x >> 31)) ^ (x >> 31);
}

Pas de multiplication, pas de branche.

BTW, return (x ^ (x >> 31)) - (x >> 31); fonctionnerait aussi bien mais il est breveté. Yup!

Note: Ce code peut prendre plus de 10 fois plus longtemps que l'instruction conditionnelle (8bit Verison). Cela peut être utile pour la programmation Matérielle Du Système C etc

J'essaie ce code en C, et ça marche.

int abs(int n){
   return n*((2*n+1)%2); 
}

J'espère que cette réponse sera utile.

Le décalage de bits des entiers signés de la manière que vous considérez est un comportement indéfini et donc pas une option. Au lieu de cela, vous pouvez faire ceci:

int abs(int n) { return n > 0 ? n : -n; }

Pas d'instructions if, juste une expression conditionnelle.

Essayez ce qui suit:

int abs(int n) 
{
  return sqrt(n*n);
}

Voici une autre approche sans abs(), si ni aucune expression logique / conditionnelle: supposons que int est un entier 32 bits ici. L'idée est assez simple: (1 - 2 * sign_bit) convertira sign_bit = 1 / 0 to -1 / 1.

unsigned int abs_by_pure_math( int a ) {
   return (1 - (((a >> 31) & 0x1) << 1)) * a;
}

N'a pas vu celui-ci. Pour la représentation du complément de deux et 32 bits int

( n >> 31 | 1 ) * n

Si votre langue permet à bool de lancer int (C / C++ like):

float absB(float n) {
    return n - n * 2.0f * ( n < 0.0f );
}

Utiliser l'opérateur ternaire:

y = condition ? value_if_true : value_if_false;

Que diriez-vous de ça:

value = value > 0 ? value: ~value + 1

C'est basé sur le fait que les nombres négatifs sont stockés comme complément de 2 à l'équivalent positif, et que l'on peut construire le complément de 2 en construisant d'abord le complément de 1 et en ajoutant 1, donc

 5 ->   0000 0101b
-5 ->  (1111 1010b) + 1 -> 1111 1011b 

Ce que j'ai fait était essentiellement d'inverser cela, donc

-5 ->  1111 1011b
 5 -> (0000 0100b) + 1 -> 0000 0101b

Je sais qu'il est un peu tard mais j'ai juste eu le même problème et j'ai atterri ici, j'espère que cela aide.

Il y a plusieurs raisons à gauche Déplacer le signe bit out et à droite déplacer en place (v << 1 >> 1):

• le déplacement à gauche d'un type signé avec une valeur négative a un comportement indéfini, il ne devrait donc pas être utilisé du tout.
• lancer la valeur sur {[2] } aurait l'effet désiré: (unsigned)v << 1 >> 1 se débarrasse du bit de signe, s'il n'y a pas de bits de remplissage, mais la valeur résultante est la valeur absolue de {[4] } uniquement sur les systèmes avec une représentation de signe + magnitude, qui disparaissent rare de nos jours. Sur l'architecture du complément omniprésent 2, la valeur résultante pour négatif v est INT_MAX+1-v

La solution de Hasturkun a malheureusement un comportement défini par l'implémentation.

Voici une variation qui est entièrement définie pour les systèmes avec la représentation du complément de 2 pour les valeurs signées:

int v;           // we want to find the absolute value of v
unsigned int r;  // the result goes here 
unsigned int mask = -((unsigned int)v >> (sizeof(unsigned int) * CHAR_BIT - 1));

r = ((unsigned int)v + mask) ^ mask;

Pas de succursales ou de multiplication:

int abs(int n) {
    int mask = n >> 31;
    return (mask & -n) | (~mask & n);
}

Vous devez combiner bit à bit not et addition.

Quel est le problème avec juste:

-1 * n

En utilisant le principe moins moins est égal à plus

Si vous voulez une manière purement mathématique qui n'est pas trop coûteuse, Essayez

f(x) = (x*x)/x

Ou en C++

function abs(auto x) {return ((x*x)/x);}