I&#39;m in a computer systems course and have been *struggling*, in part, with [Two&#39;s Complement][1]. I want to understand it but everything I&#39;ve read hasn&#39;t brought the picture together for me. I&#39;ve read the [wikipedia article][1] and various other articles, including [my text book][2].

Hence, I wanted to start this **community wiki** post to define what Two&#39;s Complement is, how to use it and how it can affect numbers during operations like casts (from signed to unsigned and vice versa), bit-wise operations and bit-shift operations.

What I&#39;m hoping for is **a clear and concise definition** that is easily understood by a programmer.


  [1]: http://en.wikipedia.org/wiki/Two%27s_complement
  [2]: http://www.amazon.com/Computer-Systems-Programmers-Randal-Bryant/dp/013034074X

What is “2&#39;s Complement”?

I&#39;m just curious if there&#39;s a reason why in order to represent -1 in binary, two&#39;s complement is used: flipping the bits and adding 1?

-1 is represented by 11111111 (two&#39;s complement) rather than (to me more intuitive) 10000001 which is binary 1 with first bit as negative flag.

Disclaimer: I don&#39;t rely on binary arithmetic for my job!

Why prefer two&#39;s complement over sign-and-magnitude for signed numbers?

Does this code always evaluate to false? Both variables are two&#39;s complement signed ints.

    ~x + ~y == ~(x + y)

I feel like there should be some number that satisfies the conditions. I tried testing the numbers between `-5000` and `5000` but never achieved equality. Is there a way to set up an equation to find the solutions to the condition? 

Will swapping one for the other cause an insidious bug in my program?



~x + ~y == ~(x + y) is always false?

I am trying to understand how Java stores integer internally. I know all java primitive integers are signed, (except short?). That means one less bit available in a byte for the number.

My question is, are all integers (positive and negative) stored as two&#39;s complement or are only negative numbers in two&#39;s complement?

I see that the specs says `x bit two&#39;s complement number`. But I often get confused.

For instance:

      int x = 15; // Stored as binary as is?  00000000 00000000 00000000 00001111?
      int y = -22; // Stored as two complemented value? 11111111 11111111 11111111 11101010

**Edit**

To be clear, `x = 15` 

       In binary as is: `00000000 00000000 00000000 00001111&#39;
      Two&#39;s complement: `11111111 11111111 11111111 11110001`

So if your answer is  `all` numbers are stored as two&#39;s complement then:

      int x = 15; // 11111111 11111111 11111111 11110001
      int y = -22 // 11111111 11111111 11111111 11101010

The confusion here again is the sign says, both are negative numbers. May be I am misreading / misunderstanding it?

**Edit**
Not sure my question is confusing. Forced to isolate the question:

**My question precisely: Are positive numbers stored in `binary as is` while negative numbers are stored as `two&#39;s complement`?**

Some said all are stored in two&#39;s complement and one answer says only negative numbers are stored as two&#39;s complement.

How are integers internally represented at a bit level in Java?

Is there a built in function in python which will convert a binary string, for example &#39;111111111111&#39;, to the [two&#39;s complement integer](http://en.wikipedia.org/wiki/Two%27s_complement) -1? 

Two&#39;s Complement in Python

Why doesn&#39;t this code print same number? : 

    long long a, b;
    a = 2147483647 + 1;
    b = 2147483648;
    printf(&quot;%lld\n&quot;, a);
    printf(&quot;%lld\n&quot;, b);

I know that int variable&#39;s maximum number is 2147483647 because int variable is 4 byte.
But as I know, long long variable is 8 byte, but why does that code act like that?

why does long long 2147483647 + 1 = -2147483648?

I think the question is self explanatory, I guess it probably has something to do with overflow but still I do not quite get it. What is happening, bitwise, under the hood?

Why does `-(-2147483648) = -2147483648` (at least while compiling in C)?

Why is -(-2147483648) = - 2147483648 in a 32-bit machine?

The [manpage](http://linux.die.net/man/3/memset) says about `memset`: 
&gt; 
    #include &lt;string.h&gt;
    void *memset(void *s, int c, size_t n)
&gt;The `memset()` function fills the first `n` **bytes** of the memory area pointed to by `s` with the constant byte `c`.   

It is obvious that `memset` can&#39;t be used to initialize `int` array as shown below:  

    int a[10];
    memset(a, 1, sizeof(a));  
it is because `int` is represented by 4 bytes (say) and one can not get the desired value for the integers in array `a`.  
But I often see the programmers use  `memset` to set the `int` array elements to either `0` or `-1`.  

    int a[10];
    int b[10];
    memset(a, 0, sizeof(a));  
    memset(b, -1, sizeof(b));  
As per my understanding, initializing with integer `0` is OK because `0` can be represented in 1 byte (may be I am wrong in this context). But how is it possible to initialize `b` with `-1` (a 4 bytes value)?   

How memset initializes an array of integers by -1?

I&#39;m trying to figure out why `String.format()` is behaving the way it does.

Context: Systems programming class, writing an assembler.

There is a 5 character hex field in the object file, which I am creating from a value.

Tried using: `String.format(&quot;%05X&quot;, decInt);`

This works as intended for positive numbers
(11 -&gt; `0000B`)
However it fails for negative numbers
(-1 -&gt; `FFFFFFFF` instead of `FFFFF`)

I suppose I could just take a substring of the last 5 characters, but I would still like to figure out why it behaves this way.

All Twos Complement Solutions on Gang of Coders

Total of 9 Twos Complement Solutions

What is “2's Complement”?

Why prefer two's complement over sign-and-magnitude for signed numbers?

~x + ~y == ~(x + y) is always false?

How are integers internally represented at a bit level in Java?

Two's Complement in Python

why does long long 2147483647 + 1 = -2147483648?

Why is -(-2147483648) = - 2147483648 in a 32-bit machine?

How memset initializes an array of integers by -1?

String.format() and hex numbers in Java