Processing: Creative Coding and Computational Art

Here’s the output:
c1 in binary = 10000000111111111111111111111111
c1 in decimal = -2130706433
----------------------------------------------------------------------c2
in binary = 1111111111111111111111111111111
c2 in decimal = 2147483647
Look at the output closely. Notice that c1’s binary bit string (32 digits) is actually 1 digit
longer than c2’s (31 digits). (If you don’t feel like counting all the ones, just take my word
for it.) Also, and more bewildering, c1’s decimal value is negative while c2’s is positive.
Why?
Both c1 and c2 have identical RGB values. However, their alpha values are 128 and 127,
respectively. So all the variations between their binary bit strings and decimal values are
somehow caused by this slight variation (probably not even visibly noticeable) in their
alpha values. Why again? The long answer is not simple, so I’ll give a “good enough”
answer (and of course provide a link to a more detailed explanation).
Processing’s (and Java’s) 32-bit integer type needs to account for positive and negative values
(and 0). There are various ways of coding these values as a binary bit string. The most
efficient and common approach is using what’s referred to as a two’s complement system.
The very basic way the two’s complement system works is as follows: to create a positive
number, you simply encode the value using standard binary conversion, as you looked at
earlier. So for example, the number 8 in decimal becomes 2 3 , or 1000 in binary. To create
a negative number, you need to first create a positive binary equivalent of the number,
and then invert all the bits (zeros become ones and ones become zeros), and then add 1.
So to express –8 in a two’s complement system, first you need to specify 8 as a positive
binary number, which you know is 1000. However, 1000 is not the full 32-bit representation
of 8, as Processing discarded the 28 zeros to the left of the number. Normally this
would be fine, as these zeros on the left side of the number don’t change its actual value.
But to understand the two’s complement system, you need to account for these bits.
Here’s the full 32-bit binary representation of 8 (with the 28 zeros added on):
00000000000000000000000000001000
So to calculate –8, first you invert all the bits:
11111111111111111111111111110111
And then you add 1:
11111111111111111111111111111000
Simple, right? OK, I know this stuff is pretty confusing. If the two’s complement stuff isn’t
doing it for you, just remember one final rule about it: if the leftmost digit of the entire bit
string (referred to as the signed bit ) is a zero, the value will be positive, and if the signed
bit is a one, the number will be negative. To confirm this, try looking at the binary equivalent
of some positive and negative numbers in Processing (or just take my word for it).
If this exciting two’s complement discussion really did it for you, check out http://
en.wikipedia.org/wiki/Two's_complement.
MATH REFERENCE
765
B