We are very used to using + and - to do addition and subtraction. Have you considered how to use bitwise operations to do these? In this article, let's explore some of them.

Addition

First, let's see how to do simple addition in 2 base in normal way.

3 + 5

  11
 101
----
1000 <= answer

We do it from right to left on every digits. Note that if current sum is bigger than the base, then a carry need to be stored to be used in next digit addition.

Now let's see how to do it using only bitwise operation.

First, calculate answer without considering carry.

  11
 101
----
 110 <= answer without carry

This operation can be done by a ^ b.

Then calculate carry(without considering previous carry).

  11
 101
----
001  <= carry

This operation can be done by (a & b) << 1.

Do this process again, until carry is 0, then we can get the final result.

Let's see this process in code.

function add(a: number, b: number) {
    while (b > 0) {
        const answer = a ^ b;
        const carry = (a & b) << 1;
        a = answer;
        b = carry;
    }
    return a;
}

console.log(add(3, 5));

Subtraction

Same as addition, let's first see how to do subtraction in 2 base.

5 - 3

   101
-   11
------
   010 <= answer

Remember that, if current digit is not enough to subtrack, then a borrow needed to be made from next digit.

Now let's see how to do is in bitwise operations.

First, calculate answer without considering borrow.

   101
-   11
------
   110 <= answer without considering borrow

This operation can be done by a ^ b.

Then calculate borrow without considering previous borrow.

   101
-   11
------
  010  <= borrow

This operation can be done by ((~a) & b) << 1.

Then let answer subtrack borrow again, until borrow is 0, then we can get final result.

Let's see this process in code.

function subtrack(a: number, b: number) {
    while(b > 0) {
        const answer = a ^ b;
        const borrow = ((~a) & b) << 1;
        a = answer;
        b = borrow;
    }

    return a;
}

console.log(subtrack(105, 3))

Sum of Two Integers

Now we can use this leetcode problem to test the above code.

function getSum(a: number, b: number): number {
    let [x, y] = [Math.abs(a), Math.abs(b)];
    if (x < y) {
        // abs big one first
        return getSum(b, a);
    }

    // consider negative
    const sign = a > 0 ? 1 : -1;
    if (a * b >= 0) {
        return add(x, y) * sign;
    } else {
        return subtrack(x, y) * sign;
    }
};

console.log(getSum(-14, 16))