Actually the expression is wrong. If you test it, for example in a Python interpreter, you will see that it does not increment i, but decrements it:

>>> i = 10
>>> i = ~-i
>>> i
9

This is already quite mysterious anyway, how is it that it decrements i?

The reason is that a sign change is implemented in the architecture by what is called a "2's complement", and the operator ~performs a "1's complement". Both operations combined result in the decrement, as we will see.

2's complement

The logic behind "2's complement" is to be able to do subtraction using the same machinery that you have for doing addition. Imagine that your CPU has only 8 bits (it's actually 32 or 64, but let's keep the example manageable), and therefore the only numbers it can handle are from 0 to 255. Also imagine that this CPU only knows addition (what which is quite close to reality).

Now imagine that we have the number 2 and we want to subtract 1 from it. Since the CPU only knows how to add, how could we subtract?

The trick is to realize that having only 8 bits, if a result goes over 255, it somehow "flips the marker" and starts over at zero. So if instead of subtracting 1 from 2, we add 255, the result would be 257, but this does not fit in 8 bits. The remaining bit (the most significant) is discarded, and the remaining bits would remain encoding 1 (257-256).

In binary you can see:

  2: --> 00000010
255: --> 11111111
------------------
       1 00000001

The leftover (carry) bit is not part of the response, which would be 00000001. Therefore we have added a quantity to 2 and 1 has come out. That quantity therefore has to be -1, right? So we choose that 255 actually represents -1.

This can be done for any positive N between 1 and 127. Make it negative by changing it to (256-N) and this is called a "2's complement".

So the 2's complement of a number N is 256-N (on 8-bit CPUs, in general, with M bits it would be 2 ^M -N). And that's what the operator -in front of an integer does, get its 2's complement.

So -icompute the 2's complement of i.

It turns out that there is another, simpler way to calculate this 2's complement if we look at it in binary. We saw that the 2's complement of 1 was 255, which in binary looks like this:

dato:  00000001
C-2:   11111111

If you compare both you see that C-2 has been obtained by changing all 0's to 1's, except the last one. Actually there is a general rule of how to calculate it:

• Change all 0's to 1's and all 1's to 0's (this is called "1's complement", or also "logical negation", or "NOT")
• Add 1 to the result

This method works for any number, not just -1. And for any number of bits.

Explanation of the expression

And we already have the ingredients to know how the expression works:

i = ~-i

First, due to -ithe 2's complement of is calculated i, which consists of changing all 1's to 0's and all 0's to 1's, and finally adding 1 to the result.

Then it is applied ~to the result. This operator does logical negation, or "1's complement". That is, it changes all 1's to 0's and 0's to 1's again (except then it doesn't add 1 to the result).

Let's see how it works assuming that iit is equal to 10 (which in binary and with 8 bits is 00001010)

Valor inicial  i:   00001010
Compl.2       -i:   11110110
Negación     ~-i:   00001001

And it turns out that what comes out is 9, one less than the initial value.

What if I want to increase?

Once the mechanism is understood, we see that to increase it is enough to use those same operators but in reverse order:

i = -~i

Here it is even easier to explain how it works:

• First, the logical negation is done, ~which changes the 1s to zeros and zeros to 1.
• Then the C-2 of the result is done, which is equivalent to:
  • Do a logical negation first (so that 1 is changed back to 0 and 0 to 1 and the data remains as it was originally)
  • Add 1. That's why at the end we have the increased data!