# Compute the integer absolute value (abs) without branching

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).

` mask = n>>31 `

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.

` mask + n `

` (mask + n)^mask `

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 << ``"Absoute 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``(``"Absoute 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(``"Absoute 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(``"Absoute 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 ` `?> `

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).

` mask = n>>31 `

2) XOR the mask with number

` mask ^ n `

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

` (mask^n) - mask `

Implementation:

 `/* 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); ` `} `

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.

Please write comments if you find any of the above explanations/algorithms incorrect, or a better ways to solve the same problem.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.