The Pioneer 10 (also known as Pioneer F) spacecraft, launched in 1972 and now on a very long journey towards Taurus, has a plaque mounted on it which is designed to inform alien civilizations about the spacecraft’s origin. The plaque contains a diagram of our solar system, the trajectory of the spacecraft, a drawing of a man and woman, and groups of vertical and horizontal strokes — you guessed it, binary code — that gives information about how to find us:
Did you know you can use the calculator with numbers in different bases? It can convert numbers between decimal, binary, hexadecimal, and octal, as well as do arithmetic in those bases. To work in a non-decimal base, just prefix numbers as follows: 0b for binary, for example, 0b1010; 0x for hexadecimal, for example, 0xFF; and 0o for octal, for example, 0o701.
This is what it sounds like to count from 1 to 255 in binary (music courtesy of Jake Joaquin). It’s so simple, reflecting the simplicity of binary code; yet it speaks volumes about the structure of binary numbers. It inspired me to draw a picture, so I could see what binary counting looks like as well:
I’m not the only one with a binary brain.
The other day my son showed me a page in a Star Wars® book which described a character named Ki-Adi-Mundi, who up until that point we knew as “big brain head.” I read in his bio that he has a binary brain, at which point I exclaimed, “Hey, just like me!” Well, not quite — his is binary in a different sense:
“Ki’s most distinguishing physical feature was an enlarged conical cranium that contained a binary brain.”
To write a computer program to print the first 1000 nonnegative powers of two, do you think you’d need to use arbitrary precision arithmetic? After all, 21000 is a 302-digit number. How about printing the first 1000 negative powers of two? 2-1000 weighs in at a whopping 1000 decimal places. It turns out all you need is standard double-precision floating-point arithmetic — and the right compiler!
Recently I showed that programming languages vary in how much precision they allow in printed floating-point fractions. Not only do they vary, but most don’t meet my standard — printing, to full precision, decimal values that have exact floating-point representations. Here I’ll present a similar study for floating-point integers, which had similar results.
In my article “One Hundred Cheerios in Binary”, I made a comment about the decimal number 100, and its binary equivalent, 1100100:
“And will they wonder if the two sub strings of ‘100’ in the binary number have any significance?”
What I meant is if a novice might wonder if a decimal string made up of 1s and 0s must appear in its binary equivalent. Of course that’s not true in general, but it is true for nonnegative powers of ten — the trailing digits of the binary number will match the power of ten!
My son had to do a project for his 100th day of first grade. Since I’ve been teaching him binary — he knows the powers of two from 1 to 512 — we decided to incorporate it into his project. His assignment was to assemble 100 objects in a creative way. This is as creative as I get:
Interestingly, programming languages vary in how much precision they allow in printed floating-point fractions. You would think they’d all be the same, allowing you to print as many decimal places as you ask for. After all, a floating-point fraction is a dyadic fraction; it has as many decimal places as it has bits in its fractional representation.
Consider the dyadic fraction 5,404,319,552,844,595/253. Its decimal expansion is 0.59999999999999997779553950749686919152736663818359375, and its binary expansion is 0.10011001100110011001100110011001100110011001100110011. Both are 53 digits long. The ideal programming language lets you print all 53 decimal places, because all are meaningful. Unfortunately, many languages won’t let you do that; they typically cap the number of decimal places at between 15 and 17, which for our example might be 0.59999999999999998.
To write a program to check if an integer is a power of two, you could follow two basic strategies: check the number based on its decimal value, or check it based on its binary representation. The former approach is more human-friendly but generally less efficient; the latter approach is more machine-friendly but generally more efficient. We will explore both approaches, comparing ten different but equivalent C functions.
A power of two, when expressed as a binary number, is easy to spot: it has one, and only one, 1 bit. For example, 1000, 10, and 0.001 are powers of two. Inside a computer, however, numbers are more generally represented in binary code, not as “pure” binary numbers. As a result, you may not be able to look at the binary representation of a number and tell at a glance whether it’s a power of two or not; it depends on how it’s encoded.