{"id":470,"date":"2024-09-18T11:46:44","date_gmt":"2024-09-18T10:46:44","guid":{"rendered":"https:\/\/blog.powered-up-games.com\/wordpress\/?p=470"},"modified":"2024-09-18T13:14:49","modified_gmt":"2024-09-18T12:14:49","slug":"delving-too-deeply","status":"publish","type":"post","link":"https:\/\/powered-up-games.com\/blog\/wordpress\/archives\/470","title":{"rendered":"Delving too deeply"},"content":{"rendered":"\n

What happens if you try to negate the smallest 32 bit integer in c#?<\/p>\n\n\n\n

C#<\/span><\/path><\/path><\/svg><\/span>
void<\/span> <\/span>Start<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>print<\/span>(<\/span>-int<\/span>.<\/span>MinValue<\/span>)<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
If you try to compile this code, the compiler will helpfully emit error code CS0220<\/a>: the operation overflows.<\/p>\n\n\n\n
However, if you wrap it in a function:<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
int<\/span> <\/span>Negate<\/span>(<\/span>int<\/span> value<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>-<\/span>value<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Start<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>print<\/span>(<\/span>Negate<\/span>(<\/span>int<\/span>.<\/span>MinValue<\/span>))<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
It compiles without errors.<\/p>\n\n\n\n
But what does it do?<\/p>\n\n\n\n
The value of int.MinValue<\/strong><\/code> is -2,147,483,648. So, you might expect it would return 2,147,483,648.<\/p>\n\n\n\n
But, int.MaxValue<\/strong><\/code> is 2,147,483,647. That is one less than the value it would need. Accounting for that, you might think it would either throw an exception, or return 2,147,483,647.<\/p>\n\n\n\n
In fact it returns -2,147,483,648.<\/p>\n\n\n\n
The same behaviour happens with smaller integer representations like short <\/strong><\/code>and sbyte<\/strong><\/code>, returning -32,768 and -128 respectively.<\/p>\n\n\n\n
To see why this is the case, it’s helpful to know how numbers are stored. For example, an 8 bit byte<\/strong><\/code> value has (as it’s name suggests) 8 bits, each of which can be either 0 or 1.<\/p>\n\n\n\n
To work out how many combinations this gives us, start with 1 bit. With 1 bit we have two possible combinations: the bit is either 0 or 1. Each bit we add, doubles the combinations, since we have all the combinations we had before with the new bit set to 0, and again with the new bit as 1. Do that 8 times and we end up with 256 possible combinations in 8 bits.<\/p>\n\n\n\n
\\begin{align*}\n\\square &= \\text{2 combinations} \\\\\n\\square\\square &= \\text{4 combinations} \\\\\n\\square\\square\\square &= \\text{8 combinations} \\\\\n\\square\\square\\square\\square &= \\text{16 combinations} \\\\\n\\square\\square\\square\\square\\square &= \\text{32 combinations} \\\\\n\\square\\square\\square\\square\\square\\square &= \\text{64 combinations} \\\\\n\\square\\square\\square\\square\\square\\square\\square &= \\text{128 combinations} \\\\\n\\square\\square\\square\\square\\square\\square\\square\\square &= \\text{256 combinations} \\\\\n\\end{align*}<\/pre><\/div>\n\n\n\n
If you keep going, you will reach 65,536 for 16 bits, and 4,294,967,296 for 32 bits.<\/p>\n\n\n\n
\"\"\/<\/figure>\n\n\n\n
Now, if we need to represent both positive and negative numbers, we need to divide up those combinations somehow. So we take half of the combinations for the positive numbers and half for the negative.<\/p>\n\n\n\n
However, that does leave an odd one out. What do we do with zero? Zero is not strictly positive or negative. But we have to assign it one way or another. And it seems only logical that the combination for zero ought to be all zeros.<\/p>\n\n\n\n
\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0} = 0<\/pre><\/div>\n\n\n\n
And if we follow the convention for our normal number system, then positive one should be all zeros followed by a one on the right.<\/p>\n\n\n\n
\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1} = 1<\/pre><\/div>\n\n\n\n
This gives us the desirable property, that we can add these numbers just by adding the bits. This works fine for 0 and 1, but what happens when we want to add 1 and 1? In that case, we follow the same rules as we do for normal numbers and carry 1 to the left. And so we can keep assigning numbers until we run out of bits.<\/p>\n\n\n\n
\\begin{align*}\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0} &= 0 \\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1} &= 1 \\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1}\\fbox{0} &= 2 \\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1}\\fbox{1} &= 3 \\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1}\\fbox{0}\\fbox{0} &= 4 \\\\\n... \\\\\n\\fbox{0}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0} &= 126 \\\\\n\\fbox{0}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1} &= 127 \\\\\n\n\\end{align*}<\/pre><\/div>\n\n\n\n
But when we reach 127 we have already used half of our combinations and we still need to represent the negatives.<\/p>\n\n\n\n
One thing you might notice at this point, is that all of our positive numbers so far have a 0 in the leftmost bit. We can use this to quickly check that our number is positive. (Or at least zero.)<\/p>\n\n\n\n
So for the negative numbers, the leftmost bit should be 1. And again it would be nice if in our representation when we add 1, it should give us the next number up. To start, we would need a representation for -1 such that adding 1 to it would naturally give us the representation for 0.<\/p>\n\n\n\n
\\begin{align*}\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1} \\\\\n+ \\fbox{1}\\fbox{?}\\fbox{?}\\fbox{?}\\fbox{?}\\fbox{?}\\fbox{?}\\fbox{?} \\\\\n=\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0} \\\\\n\\end{align*}<\/pre><\/div>\n\n\n\n
If we start at the right hand side, the first bit can’t be a zero, since that would leave a 1 in the result. So it must be a 1. But that would mean carrying 1 to the next position. So that bit would also need to be a 1 or it would put a 1 in the result. This continues all the way to the right until we carry 1 but we don’t have anywhere to put it. They all rolled over and one fell out, leaving us with all zeros.<\/p>\n\n\n\n
\n
they all rolled over and one fell out<\/p>\n\u2014 traditional nursery rhyme<\/cite><\/blockquote>\n\n\n\n
With -1 defined, we can proceed as before, subtracting one each time until we run out of combinations:<\/p>\n\n\n\n
\\begin{align*}\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1} &= -1 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0} &= -2 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0}\\fbox{1} &= -3 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0}\\fbox{0} &= -4 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0}\\fbox{1}\\fbox{1} &= -5 \\\\\n... \\\\\n\\fbox{1}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1} &= -127 \\\\\n\\fbox{1}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0} &= -128 \\\\\n\\end{align*}<\/pre><\/div>\n\n\n\n
Now we have assigned all of the combinations in an order that allows us to use our common arithmetic rules. We end up with 1 more negative number than positive numbers because we needed to represent zero somewhere.<\/p>\n\n\n\n
But what happens now if we subtract 1 from -128, or add 1 to 127?<\/p>\n\n\n\n
If we add 1 to 127, we end up with a bit overflowing into the negative bit. The negative bit changes from 0 to 1 and the result becomes -128.<\/p>\n\n\n\n
If we subtract 1 from -128, the opposite happens: the 1 is borrowed out of the negative bit, turning it into positive 127.<\/p>\n\n\n\n
Now we know all this, can we see why negating -128 would cause it to remain -128?<\/p>\n\n\n\n
If we pair up the positive and negative number representations, we can see that there is a certain symmetry there:<\/p>\n\n\n\n
\\begin{align*}\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0} &= 0 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1} &= -1 \\\\\n\\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1} &= 1 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0} &= -2 \\\\\n\\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1}\\fbox{0} &= 2 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0}\\fbox{1} &= -3 \\\\\n\\\\\n\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{0}\\fbox{1}\\fbox{1} &= 3 \\\\\n\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{1}\\fbox{0}\\fbox{0} &= -4 \\\\\n\\end{align*}<\/pre><\/div>\n\n\n\n
It seems that for every negative number, the opposite representation in terms of its bits is the positive equivalent minus 1. And this pattern continues for every negative number. So to negate any number in our representation, all we need to do is flip all the bits and then add 1.<\/p>\n\n\n\n
And it works for all the numbers in the representation. The problem is, with the number -128, it returns 127 + 1. And, as we saw above, 127 + 1 wraps back around to -128. So we end up back where we started.<\/p>\n\n\n\n
And the same thing happens with the 16 bit and 32 bit numbers.<\/p>\n\n\n\n
So be aware of that when negating at the negative limit of your number representation.<\/p>\n\n\n\n
\"\"\/<\/figure>\n","protected":false},"excerpt":{"rendered":"
What happens if you try to negate the smallest 32 bit integer in c#?<\/p>\n","protected":false},"author":1,"featured_media":470,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[62,6],"tags":[24,39],"class_list":["post-470","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-education","category-programming","tag-education","tag-programming"],"_links":{"self":[{"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/posts\/470","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/comments?post=470"}],"version-history":[{"count":10,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/posts\/470\/revisions"}],"predecessor-version":[{"id":481,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/posts\/470\/revisions\/481"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/posts\/470"}],"wp:attachment":[{"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/media?parent=470"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/categories?post=470"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/powered-up-games.com\/blog\/wordpress\/wp-json\/wp\/v2\/tags?post=470"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}