{"id":2010,"date":"2016-07-16T00:01:29","date_gmt":"2016-07-16T07:01:29","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2010"},"modified":"2022-11-26T10:09:01","modified_gmt":"2022-11-26T18:09:01","slug":"more-negative-integers","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2010","title":{"rendered":"More Negative Integers"},"content":{"rendered":"

The far left bit in a signed<\/em> integer value — no matter how wide the integer — is the sign bit. If it’s set, the value is negative. Otherwise, the value is positive. But the sign bit is more than just a minus sign. It also plays into binary math.
\n
\nBinary math<\/em>. There’s a term to plunge a college sophomore into convulsions. It’s not that terrible of a concept. That’s because the early proto-nerds figured everything out for you. You just need to accept it.<\/p>\n

For example, consider the elementary school math problem: 9 – 5<\/p>\n

In your head (I hope), you know the result is 4. From your programming experience, you might even know that hexadecimal 0x09<\/code> minus 0x05<\/code> is equal to 0x04<\/code>. That’s simple enough. Here are the values in binary:<\/p>\n

9 = 0x09 = 0000-1001
\n5 = 0x05 = 0000-0101
\n4 = 0x04 = 0000-0100<\/code><\/p>\n

In the computer, however, the problem isn’t really 9 – 5. No, it’s 9+(-5). At the low level, the processor adds<\/em> bits. Even when the machine language instruction is SUBTRACT, the processor is adding bits.<\/p>\n

In binary, -5 isn’t 1000-0101 it’s 1111-1011 or 0xFB<\/code>. I’ll show how that translation works in this Lesson’s sample code later, but for now understand that 0xFB<\/code> is the binary representation of -5. Math-wise, the problem is illustrated in Figure 1.<\/p>\n

\"Figure

Figure 1. Binary addition of a positive and negative value.<\/p><\/div>\n

The values 0x09<\/code> (9) and 0xFB<\/code> (-5) are added in Figure 1. Binary addition works the same as the math you already know:<\/p>\n

0 + 0 = 0
\n0 + 1 = 1
\n1 + 1 = 0 and carry the 1 to the next digit<\/p>\n

For the math in Figure 1, the sum at bit 3 gets carried all the way over past the sign bit (bit 7) in the value. This condition sets what’s called the carry bit<\/em> in the processor. It might also be called an overflow and set an overflow flag<\/em>. Regardless, the final value is 0x04<\/code> or 0000-0100, which is the result of subtracting 5 from 9 — or adding 9 and -5.<\/p>\n

Don’t wrack your brain on this binary math! The processor handles all the details. A bigger question might be how do you get from 5 binary 0000-0101 to -5 binary 1111-1011. For that answer, you need to do some binary manipulation. The steps to convert a positive binary value to a negative binary value are:<\/p>\n

1. Take the two’s complement of the original value, C operator:<\/strong> ~<\/code>
\n2. Increment the result, C operator:<\/strong> ++<\/code><\/p>\n

Here’s sample code that implements this process:<\/p>\n

\r\n#include <stdio.h>\r\n\r\nchar *binbin(char n);\r\n\r\nint main()\r\n{\r\n    int v;\r\n    char i;\r\n\r\n    printf(\"Enter a value (-127 to 127): \");\r\n    scanf(\"%d\",&v);\r\n    i = (char)v;\r\n    printf(\"Value = %d\\n\",i);\r\n    printf(\"Binary: %s\\n\",binbin(i));\r\n    i = ~i;\r\n    printf(\"Two's complement = %d\\n\",i);\r\n    printf(\"Binary: %s\\n\",binbin(i));\r\n    i++;\r\n    printf(\"Increment result = %d\\n\",i);\r\n    printf(\"Binary: %s\\n\",binbin(i));\r\n\r\n    return(0);\r\n}\r\n\r\nchar *binbin(char n)\r\n{\r\n    static char bin[9];\r\n    int x;\r\n\r\n    for(x=0; x<8; x++)\r\n    {\r\n        bin[x] = n & 0x80 ? '1' : '0';\r\n        n <<= 1;\r\n    }\r\n    bin[x] = '\\0';\r\n    return(bin);\r\n}<\/pre>\n
The code prompts for an input value between -127 and 127 (Line 10).  Though the range of an signed char<\/em> value really goes to -128, that specific value creates problems with the integer conversion required at Line 12. (Otherwise, int<\/em> variable v<\/code> pads bits on the left.)<\/p>\n
At Lines 13 and 14, the original is shown in decimal and then binary, thanks to the binbin()<\/em> function.<\/p>\n
Line 15 converts variable i<\/code> into its two’s complement value. Then Lines 16 and 17 display the result in decimal and binary.<\/p>\n
Line 18 increments variable i<\/code>, resulting in the final, negative value displayed in Lines 19 and 20.<\/p>\n
Run the code a few times to test its output. Here is a sample run:<\/p>\n
Enter a value (-127 to 127): 5\r\nValue = 5\r\nBinary: 00000101\r\nTwo's complement = -6\r\nBinary: 11111010\r\nIncrement result = -5\r\nBinary: 11111011<\/code><\/pre>\n
Also, note that when you start with a negative number, you get a positive value in return:<\/p>\n
Enter a value (-127 to 127): -100\r\nValue = -100\r\nBinary: 10011100\r\nTwo's complement = 99\r\nBinary: 01100011\r\nIncrement result = 100\r\nBinary: 01100100<\/code><\/pre>\n
That’s pretty solid. Further, here’s the result when you process the value zero:<\/p>\n
Enter a value (-127 to 127): 0\r\nValue = 0\r\nBinary: 00000000\r\nTwo's complement = -1\r\nBinary: 11111111\r\nIncrement result = 0\r\nBinary: 00000000<\/code><\/pre>\n
And all the mathematicians shout, “Amen!”<\/p>\n","protected":false},"excerpt":{"rendered":"
It’s an attitude thing. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-2010","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2010","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2010"}],"version-history":[{"count":6,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2010\/revisions"}],"predecessor-version":[{"id":5665,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2010\/revisions\/5665"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2010"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2010"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2010"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}