Editing Two's complement (section)

==Most negative number==
With only one exception, starting with any number in two's-complement representation, if all the bits are flipped and 1 added, the two's-complement representation of the negative of that number is obtained. Positive&nbsp;12 becomes negative&nbsp;12, positive&nbsp;5 becomes negative&nbsp;5, zero becomes zero(+overflow), etc.

{|class="wikitable floatright" style="width:18em;text-align:center"|"
|+ <span class="anchor" id="−128_example_anchor">The two's complement of {{math| −128 }}</span>
|-
| {{math| −128 }} || 1000 0000
|-
| invert bits || 0111 1111
|-
| add one || 1000 0000
|-
|colspan="2;" |{{small|Result is the same 8&nbsp;bit binary number.}}
|}

Taking the two's complement (negation) of the minimum number in the range will not have the desired effect of negating the number. For example, the two's complement of {{math| −128 }} in an eight-bit system is {{math| −128&nbsp;,}} as shown in the [[#−128_example_anchor|table to the right]]. Although the expected result from negating {{math| −128 }} is {{math| +128&nbsp;,}} there is no representation of {{math| +128 }} with an eight&nbsp;bit two's&nbsp;complement system and thus it is in fact impossible to represent the negation. Note that the two's complement being the same number is detected as an overflow condition since there was a carry into but not out of the most-significant bit.

Having a nonzero number equal to its own negation is forced by the fact that zero is its own negation, and that the total number of numbers is even. Proof: there are {{math| 2^n − 1}} nonzero numbers (an odd number). Negation would partition the nonzero numbers into sets of size 2, but this would result in the set of nonzero numbers having even cardinality. So at least one of the sets has size 1, i.e., a nonzero number is its own negation.

The presence of the most negative number can lead to unexpected programming bugs where the result has an unexpected sign, or leads to an unexpected overflow exception, or leads to completely strange behaviors. For example,
* the unary negation operator may not change the sign of a nonzero number. e.g., {{math| −(−128) &nbsp;⟼&nbsp; −128 &nbsp;}} (where "{{math|⟼}}" is read as "becomes").
* an implementation of [[absolute value]] may return a negative number;<ref>
{{cite web
 |title=Math
 |department=API specification
 |series=Java Platform SE&nbsp;7
 |url=http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html
}}
</ref> e.g., {{math|&nbsp; abs(−128) &nbsp;⟼&nbsp; −128&nbsp;.}}

* Likewise, multiplication by {{math| −1 }} may fail to function as expected; e.g., &nbsp; {{math| (−128) × (−1) &nbsp;⟼&nbsp; −128&nbsp;.}}
* Division by {{math| −1 }} may cause an exception (like that caused by dividing by {{math| 0 }});<ref>
{{cite web
 |first=John |last=Regehr
 |year=2013
 |title=Nobody expects the Spanish inquisition, or INT_MIN to be divided by −1
 |website=Regehr.org |type=blog
 |url=https://blog.regehr.org/archives/887
}}
</ref> even calculating the remainder (or [[modulo]]) by {{math| −1 }} can trigger this exception;<ref name=int32-c>
{{cite web
 |first=Robert C. |last=Seacord
 |year=2020
 |title=Ensure that operations on signed integers do not result in overflow
 |department=Rule INT32-C
 |series=SEI CERT C&nbsp;Coding Standard
 |website=wiki.sei.cmu.edu
 |url=https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow
}}
</ref> e.g., {{math| (−128) ÷ (−1) &nbsp;⟼&nbsp; {{small|[{{sc|crash}}]}}&nbsp;,}} &nbsp; {{math| (−128) % (−1) &nbsp;⟼&nbsp; {{small|[{{sc|crash}}]}}&nbsp;.}}

In the [[C (programming language)|C]] and [[C++]] programming languages, the above behaviours are [[Undefined behavior|undefined]] and not only may they return strange results, but the compiler is free to assume that the programmer has ensured that undefined numerical operations never happen, and make inferences from that assumption.<ref name=int32-c/> This enables a number of optimizations, but also leads to a number of strange bugs in programs with these undefined calculations.

This most negative number in two's&nbsp;complement is sometimes called "the weird number", because it is the only exception.<ref>
{{cite report
 |first1=Reynald |last1=Affeldt
 |first2=Nicolas |last2=Marti
 |name-list-style=amp
 |year=2006
 |title=Formal verification of arithmetic functions in SmartMIPS Assembly
 |url=http://www.ipl.t.u-tokyo.ac.jp/jssst2006/papers/Affeldt.pdf
 |url-status=dead
 |archive-url=https://web.archive.org/web/20110722080531/http://www.ipl.t.u-tokyo.ac.jp/jssst2006/papers/Affeldt.pdf
 |archive-date=2011-07-22
}}
</ref><ref>
{{cite book
 |first1=David Money |last1=Harris
 |first2=Sarah L.    |last2=Harris
 |year=2007
 |title=Digital Design and Computer Architecture
 |page=18
 |publisher=Morgan Kaufmann
 |isbn=978-0-08-054706-0
 |url=https://books.google.com/books?id=5X7JV5-n0FIC&q=%22weird+number%22+binary&pg=PA19
 |via=Google Books
}}
</ref>
Although the number is an exception, it is a valid number in regular two's&nbsp;complement systems. All arithmetic operations work with it both as an operand and (unless there was an overflow) a result.