Compute the integer absolute value (abs) without branching

• Difficulty Level : Hard
• Last Updated : 18 Jan, 2022

We need not to do anything if a number is positive. We want to change only negative numbers. Since negative numbers are stored in 2’s complement form, to get the absolute value of a negative number we have to toggle bits of the number and add 1 to the result.
For example -2 in a 8 bit system is stored as follows 1 1 1 1 1 1 1 0 where leftmost bit is the sign bit. To get the absolute value of a negative number, we have to toggle all bits and add 1 to the toggled number i.e, 0 0 0 0 0 0 0 1 + 1 will give the absolute value of 1 1 1 1 1 1 1 0. Also remember, we need to do these operations only if the number is negative (sign bit is set).
Method 1
1) Set the mask as right shift of integer by 31 (assuming integers are stored using 32 bits).

2) For negative numbers, above step sets mask as 1 1 1 1 1 1 1 1 and 0 0 0 0 0 0 0 0 for positive numbers. Add the mask to the given number.

Implementation:

C++

 #include using namespace std; #define CHARBIT 8   /* This function will return absolute value of n*/ unsigned int getAbs(int n) {     int const mask = n >> (sizeof(int) * CHARBIT - 1);     return ((n + mask) ^ mask); }   /* Driver program to test above function */ int main() {     int n = -6;     cout << "Absolute value of " << n << " is " << getAbs(n);     return 0; }   // This code is contributed by rathbhupendra

C

 #include #define CHAR_BIT 8   /* This function will return absolute value of n*/ unsigned int getAbs(int n) {     int const mask = n >> (sizeof(int) * CHAR_BIT - 1);     return ((n + mask) ^ mask); }   /* Driver program to test above function */ int main() {     int n = -6;     printf("Absolute value of %d is %u", n, getAbs(n));       getchar();     return 0; }

Java

 // Java implementation of above approach class GFG {       static final int CHAR_BIT = 8;     static final int SIZE_INT = 8;       /* This function will return absolute value of n*/     static int getAbs(int n)     {         int mask = n >> (SIZE_INT * CHAR_BIT - 1);         return ((n + mask) ^ mask);     }       /* Driver code */     public static void main(String[] args)     {         int n = -6;         System.out.print("Absolute value of " + n + " is " + getAbs(n));     } }   // This code is contributed by Rajput-Ji

Python3

 # Python3 implementation of above approach CHARBIT = 8; SIZE_INT = 8;   # This function will return # absolute value of n def getAbs(n):     mask = n >> (SIZE_INT * CHARBIT - 1);     return ((n + mask) ^ mask);   # Driver Code n = -6; print("Absolute value of",n,"is",getAbs(n));   # This code is contributed by mits

C#

 // C# implementation of above approach using System;   class GFG {       static int CHAR_BIT = 8;     static int SIZE_INT = 8;       /* This function will return absolute value of n*/     static int getAbs(int n)     {         int mask = n >> (SIZE_INT * CHAR_BIT - 1);         return ((n + mask) ^ mask);     }       /* Driver code */     static void Main()     {         int n = -6;         Console.Write("Absolute value of " + n + " is " + getAbs(n));     } }   // This code is contributed by mits

PHP

 > (\$SIZE_INT * \$CHARBIT - 1);     return ((\$n + \$mask) ^ \$mask); }   // Driver Code \$n = -6; echo "Absolute value of " . \$n .             " is " . getAbs(\$n);   // This code is contributed by mits ?>

Javascript



Output:

Absolute value of -6 is 6

Method 2:
1) Set the mask as right shift of integer by 31 (assuming integers are stored using 32 bits).

2) XOR the mask with number

3) Subtract mask from result of step 2 and return the result.

Implementation:

c

 /* This function will return absolute value of n*/ unsigned int getAbs(int n) {     int const mask = n >> (sizeof(int) * CHAR_BIT - 1);     return ((n ^ mask) - mask); }

Java

 // Java implementation of above approach class GFG {       /* This function will return absolute value of n*/     static int getAbs(int n)     {         int mask = n >> (SIZE_INT * CHAR_BIT - 1);         return ((n + mask) ^ mask);     }   }   // This code is contributed by code_hunt.

On machines where branching is expensive, the above expression can be faster than the obvious approach, r = (v < 0) ? -(unsigned)v : v, even though the number of operations is the same.