ch3-FloatBinary (Print bits of float and double in C/C++)

Chapter_3 Exercise_3-22

FloatBinary TCP1, p. 173, 203-204 (floatbinary.c, FloatBinary.cpp)

floatbinary.c download

#include <stdio.h> // for printf(), putchar()
#include <stdlib.h> // for atof(), exit()

// Display a byte in binary
void printBinary(const unsigned char val);

int main(int argc, char* argv[])
{
if(argc != 2)
{
printf("Must provide a number\n");
exit(1); // out of main(), end program; return value 1 signals an error
}
int i;
double d = atof(argv[1]);
float f = d;
unsigned char* cp = (unsigned char*)(&f);
for(i = sizeof(float); i > 0; i--)
{
printBinary(cp[i-1]); // cp[3], cp[2], cp[1], cp[0]
}
putchar('\n');

cp = (unsigned char*)(&d);
for(i = sizeof(double); i > 0; i--)
{
printBinary(cp[i-1]); // cp[7], cp[6], ..., cp[1], cp[0]
}
putchar('\n');

return 0; // normal return value for main(), signals no errors
}
// Display a byte in binary
void printBinary(const unsigned char val)
{
int i;

for(i = 7; i >= 0; i--)
{ // print bits from first (most significant) to last (least significant)
if(val & (1 << i)) // set (1) bit
{putchar('1');}
else {putchar('0');} // 0 bit
}
}
/*
gcc floatbinary.c -o floatbinary
./floatbinary
Must provide a number

./floatbinary 0 1
Must provide a number // exactly one number

./floatbinary 0
00000000000000000000000000000000 // single-precision floating-point
0000000000000000000000000000000000000000000000000000000000000000 // double

./floatbinary 1
00111111100000000000000000000000
0011111111110000000000000000000000000000000000000000000000000000

./floatbinary 2
01000000000000000000000000000000
0100000000000000000000000000000000000000000000000000000000000000

./floatbinary 3
01000000010000000000000000000000
0100000000001000000000000000000000000000000000000000000000000000

./floatbinary 4
01000000100000000000000000000000
0100000000010000000000000000000000000000000000000000000000000000

./floatbinary 0.1
00111101110011001100110011001101
0011111110111001100110011001100110011001100110011001100110011010

./floatbinary 0.2
00111110010011001100110011001101
0011111111001001100110011001100110011001100110011001100110011010

./floatbinary -0.1
10111101110011001100110011001101
1011111110111001100110011001100110011001100110011001100110011010

./floatbinary -.2
10111110010011001100110011001101
1011111111001001100110011001100110011001100110011001100110011010

./floatbinary 15
01000001011100000000000000000000
0100000000101110000000000000000000000000000000000000000000000000

./floatbinary 15.1
01000001011100011001100110011010
0100000000101110001100110011001100110011001100110011001100110011

./floatbinary 15.2
01000001011100110011001100110011
0100000000101110011001100110011001100110011001100110011001100110

./floatbinary 15.3
01000001011101001100110011001101
0100000000101110100110011001100110011001100110011001100110011010
*/

Notes: See Single-precision and Double-precision floating-point formats on Wikipedia.

00000000000000000000000000000000 = ((-1)^0)*2^(0-127)*(1+0) = 1*2^(-127)*1 ~ 0
(here ^ means "raised to power" and ~ means "approximates to").
00111111100000000000000000000000 = ((-1)^0)*2^(2^0+2^1+2^2+2^3+2^4+2^5+2^6-127)*(1+0) = 1*2^0*1 = 1.
01000000000000000000000000000000 = ((-1)^0)*2^(2^7-127)*(1+0) = 1*2^1*1 = 2.
01000000010000000000000000000000 = ((-1)^0)*2^(2^7-127)*(1+2^(-1)) = 1*2^1*1.5 = 3.
01000000100000000000000000000000 = ((-1)^0)*2^(2^0+2^7-127)*(1+0) = 1*2^2*1 = 4.
((-1)^0)*2^(2^0+2^1+2^3+2^4+2^5+2^6-127)*(1+2^(-1)+2^(-4)+2^(-5)+...) ~ 1*2^(-4)*1.6 = 0.1.
01000001011100000000000000000000 = ((-1)^0)*2^(2^1+2^7-127)*(1+2^(-1)+2^(-2)+2^(-3)) = 1*2^3*1.875 = 15.
etc.

Note: See ch3-Bitwise in Section ch3-Operators for PrintBinary.hpp and PrintBinary.cpp. Add the two files in the same folder as FloatBinary.cpp:

FloatBinary.cpp download

#include "PrintBinary.hpp" // for printBinary()
#include <cstdlib> // for atof(), exit()
#include <iostream>
using std::cout;
using std::endl;

int main(int argc, char* argv[])
{
if(argc != 2)
{
cout << "Must provide a number" << endl;
exit(1); // out of main(), end program; return value 1 signals an error
}
double d = atof(argv[1]);
float f = d;
unsigned char* cp = reinterpret_cast<unsigned char*>(&f);
for(int i = sizeof(float); i > 0; i--)
{
printBinary(cp[i-1]); // cp[3], cp[2], cp[1], cp[0]
}
cout << endl;

cp = reinterpret_cast<unsigned char*>(&d);
for(int i = sizeof(double); i > 0; i--)
{
printBinary(cp[i-1]); // cp[7], cp[6], ..., cp[1], cp[0]
}
cout << endl;

return 0; // normal return value for main(), signals no errors
}
/*
g++ -c PrintBinary.cpp FloatBinary.cpp // create object files
g++ -c *.cpp
g++ PrintBinary.o FloatBinary.o -o FloatBinary // link object files,
g++ *.o -o FloatBinary // create executable
rm *.o // clean (delete object files)
./FloatBinary
Must provide a number

./FloatBinary 0 1
Must provide a number // exactly one number

./FloatBinary 0
00000000000000000000000000000000 // single-precision floating-point
0000000000000000000000000000000000000000000000000000000000000000 // double

./FloatBinary 1
00111111100000000000000000000000
0011111111110000000000000000000000000000000000000000000000000000

./FloatBinary 2
01000000000000000000000000000000
0100000000000000000000000000000000000000000000000000000000000000

./FloatBinary 3
01000000010000000000000000000000
0100000000001000000000000000000000000000000000000000000000000000

./FloatBinary 4
01000000100000000000000000000000
0100000000010000000000000000000000000000000000000000000000000000

./FloatBinary 0.1
00111101110011001100110011001101
0011111110111001100110011001100110011001100110011001100110011010

./FloatBinary 0.2
00111110010011001100110011001101
0011111111001001100110011001100110011001100110011001100110011010

./FloatBinary -0.1
10111101110011001100110011001101
1011111110111001100110011001100110011001100110011001100110011010

./FloatBinary -.2
10111110010011001100110011001101
1011111111001001100110011001100110011001100110011001100110011010

./FloatBinary 15
01000001011100000000000000000000
0100000000101110000000000000000000000000000000000000000000000000

./FloatBinary 15.1
01000001011100011001100110011010
0100000000101110001100110011001100110011001100110011001100110011

./FloatBinary 15.2
01000001011100110011001100110011
0100000000101110011001100110011001100110011001100110011001100110

./FloatBinary 15.3
01000001011101001100110011001101
0100000000101110100110011001100110011001100110011001100110011010
*/

Chapter_3 Exercise_3-22

BACK_TO_TOP

FloatLimits Exercise_3-23

Search This Blog

Thinking in C++ vol. 1