IEEE 754 Standards - "float" and "double" - Test

This section provides a tutorial example on how to convert a 'float' number into the IEEE 754 binary expression format.

Now, let's see a program I wrote to convert a "float" number into the IEEE 754 expression format:

```// IeeeFloat.cs

using System;
public class IeeeFloat {
private const int fraction_size = 23;
private const int bias = 127;

private float original_value;
private float value;
private int sign;
private long exponent;
private int[] fraction;

public IeeeFloat(float v) {
original_value = v;
value = original_value;

sign = 1;
exponent = 0;
fraction = new int[fraction_size];

int i;
for (i=0; i<fraction_size; i++) {
fraction[i] = 0;
}

// of course, working on the sign first
if (value==0.0f) {
sign = 1;
} else if (value==-0.0f) { // not sure if this detect the -0
sign = -1;
value = -1.0f*value;
} else if (value<0.0f) {
sign = -1;
value = -1.0f*value;
}

if (value>0.0f) {
// now, the exponent part
while (value>=2.0f) {
exponent++;
value = value/2.0f;
}
while (value<1.0f && exponent>-bias) {
exponent--;
value = value*2.0f;
}

if (value>=1.0f) {
value = value-1.0f;
value = value*2.0f;
} else {
}

// time for the fraction part
for (i=0; i<fraction_size; i++) {
if (value>=1.0f) {
fraction[i] = 1;
value = value-1.0f;
} else {
fraction[i] = 0;
}
value = value*2.0f;
}
}
}

public string toBinaryExpression() {
string str = "";
if (sign<0) str = str + "-";
str = str + "b(" + lead;
str = str + ".";
for (int i=0; i<fraction_size; i++) {
str = str + fraction[i];
}
str = str + ")*2**(" + exponent + ")";
return str;
}

public void outputDebugText() {
int i;

Console.WriteLine("======");
Console.WriteLine("Converting a real number to IEEE Standard");
Console.WriteLine("Floating Point with Single Precision:");
Console.WriteLine("");
Console.WriteLine(" Value:    {0}",original_value);
Console.WriteLine(" Sign:     {0}",sign);
Console.WriteLine(" Exponent: {0}",exponent);
Console.Write(" Fraction: ");
for (i=0; i<fraction_size; i++) {
Console.Write("{0}",fraction[i]);
}
Console.WriteLine("");
Console.Write(" Position: ");
Console.Write("{0} ",' ');
for (i=0; i<fraction_size; i++) {
Console.Write("{0}",i%10);
}
Console.WriteLine("");
Console.WriteLine("");
}

public static void Main() {
float v;
IeeeFloat x;

v = 0.0f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = 1.0f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = 2.0f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = 0.5f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = 1.0f/3.0f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = 0.1f;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = float.MaxValue;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = float.MinValue;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = float.Epsilon;
x = new IeeeFloat(v);
Console.WriteLine("{0}, {1}", v, x.toBinaryExpression());

v = float.Epsilon;
x = new IeeeFloat(v);
x.outputDebugText();

v = 1.0f/3.0f;
x = new IeeeFloat(v);
x.outputDebugText();

v = float.MaxValue;
x = new IeeeFloat(v);
x.outputDebugText();
}
}
```

Output:

```0, b(0.00000000000000000000000)*2**(0)
1, b(1.00000000000000000000000)*2**(0)
2, b(1.00000000000000000000000)*2**(1)
0.5, b(1.00000000000000000000000)*2**(-1)
0.3333333, b(1.01010101010101010101011)*2**(-2)
0.1, b(1.10011001100110011001101)*2**(-4)
3.402823E+38, b(1.11111111111111111111111)*2**(127)
-3.402823E+38, -b(1.11111111111111111111111)*2**(127)
1.401298E-45, b(0.00000000000000000000001)*2**(-127)
======
Converting a real number to IEEE Standard
Floating Point with Single Precision:

Value:    1.401298E-45
Sign:     1
Exponent: -127
Fraction: 0.00000000000000000000001
Position:   01234567890123456789012

======
Converting a real number to IEEE Standard
Floating Point with Single Precision:

Value:    0.3333333
Sign:     1
Exponent: -2
Fraction: 1.01010101010101010101011
Position:   01234567890123456789012

======
Converting a real number to IEEE Standard
Floating Point with Single Precision:

Value:    3.402823E+38
Sign:     1
Exponent: 127
Fraction: 1.11111111111111111111111
Position:   01234567890123456789012
```

Exercise: Add a new method in IeeeFloat class to output the value in IEEE 754 storage format, with the following method signature:

```   public string ToBits()
```