9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

Related Articles

Program for conversion of 32 Bits Single

Precision IEEE 754 Floating Point
Representation
Difficulty Level :
Medium ● Last Updated :
04 Aug, 2021

Pre-Requisite : IEEE Standard 754 Floating Point Numbers

Write a program to find out the 32 Bits Single Precision IEEE 754 Floating-Point

representation of a given real value and vice versa. 

Examples : 

Input: real number = 16.75

WeOutput:
use cookies0to ensure
| 10000011 | best
you have the 00001100000000000000000

browsing experience on our website. By using our Got It !

site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 1/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

Input: floating point number = 0 | 10000011 | 00001100000000000000000

Output: 16.75

Approach: 

This implementation is based on Union Datatype in C and using the concept of Bit Fields. 

Bit Fields are assigned when we don’t require the full memor y that is usually allocated to

some variables but we want to limit the amount of memor y taken up by those variables. In

C, members of a Union share the common memor y space and taken we can access the

members only one at a time. 

Below is the implementation of the above approach:

Program 1: Conver t a real value to its floating point representation

C++

// C++ program to convert a real value

// to IEEE 754 floating point representation
#include<bits/stdc++.h>
using namespace std;
 
void printBinary(int n, int i)
{
 
    // Prints the binary representation
    // of a number n up to i-bits.
    int k;
    for (k = i - 1; k >= 0; k--) {
 
        if ((n >> k) & 1)
            cout << "1";
        else
            cout << "0";
    }
}
 
typedef union {
 
    float f;
    struct
    {
 
        // Order is important.
        //
We use cookies toHere
ensurethe members
you have the bestof the experience
browsing union dataon ourstructure
website. By using our Got It !
        //
site, use that
you
acknowledge theyousame
have memory (32 bits).
read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 2/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

        // The ordering is taken

        // from the LSB to the MSB.
        unsigned int mantissa : 23;
        unsigned int exponent : 8;
        unsigned int sign : 1;
 
    } raw;
} myfloat;
 
// Function to convert real value
// to IEEE floating point representation
void printIEEE(myfloat var)
{
 
    // Prints the IEEE 754 representation
    // of a float value (32 bits)
 
    cout << var.raw.sign << " | ";
    printBinary(var.raw.exponent, 8);
    cout << " | ";
    printBinary(var.raw.mantissa, 23);
    cout << "\n";
}
 
// Driver Code
int main()
{
 
    // Instantiate the union
    myfloat var;
 
    // Get the real value
    var.f = -2.25;
 
    // Get the IEEE floating point representation
    cout << "IEEE 754 representation of ";
    cout << fixed << setprecision(6) << var.f << " is : " << endl;
    printIEEE(var);
 
    return 0;
}
 
//This code is contributed by shubhamsingh10

// C program to convert a real value

// to IEEE 754 floating point representation
We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
 
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy
#include <stdio.h>
https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 3/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

 
void printBinary(int n, int i)
{
 
    // Prints the binary representation
    // of a number n up to i-bits.
    int k;
    for (k = i - 1; k >= 0; k--) {
 
        if ((n >> k) & 1)
            printf("1");
        else
            printf("0");
    }
}
 
typedef union {
 
    float f;
    struct
    {
 
        // Order is important.
        // Here the members of the union data structure
        // use the same memory (32 bits).
        // The ordering is taken
        // from the LSB to the MSB.
        unsigned int mantissa : 23;
        unsigned int exponent : 8;
        unsigned int sign : 1;
 
    } raw;
} myfloat;
 
// Function to convert real value
// to IEEE floating point representation
void printIEEE(myfloat var)
{
 
    // Prints the IEEE 754 representation
    // of a float value (32 bits)
 
    printf("%d | ", var.raw.sign);
    printBinary(var.raw.exponent, 8);
    printf(" | ");
    printBinary(var.raw.mantissa, 23);
    printf("\n");
}
 
// Driver Code
We
intusemain()
cookies to ensure you have the best browsing experience on our website. By using our Got It !
site,
{ you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 4/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

 
    // Instantiate the union
    myfloat var;
 
    // Get the real value
    var.f = -2.25;
 
    // Get the IEEE floating point representation
    printf("IEEE 754 representation of %f is : \n",
           var.f);
    printIEEE(var);
 
    return 0;
}

P ython3

# Python program to convert a real value

# to IEEE 754 Floating Point Representation.
 
# Function to convert a
# fraction to binary form.
def binaryOfFraction(fraction):
 
    # Declaring an empty string
    # to store binary bits.
    binary = str()
 
    # Iterating through
    # fraction until it
    # becomes Zero.
    while (fraction):
         
        # Multiplying fraction by 2.
        fraction *= 2
 
        # Storing Integer Part of
        # Fraction in int_part.
        if (fraction >= 1):
            int_part = 1
            fraction -= 1
        else:
            int_part = 0
     
        # Adding int_part to binary
        # after every iteration.
        binary += str(int_part)
 
We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
    # Returning the binary string.
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy
    return binary
https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 5/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

 
# Function to get sign  bit,
# exp bits and mantissa bits,
# from given real no.
def floatingPoint(real_no):
 
    # Setting Sign bit
    # default to zero.
    sign_bit = 0
 
    # Sign bit will set to
    # 1 for negative no.
    if(real_no < 0):
        sign_bit = 1
 
    # converting given no. to
    # absolute value as we have
    # already set the sign bit.
    real_no = abs(real_no)
 
    # Converting Integer Part
    # of Real no to Binary
    int_str = bin(int(real_no))[2 : ]
 
    # Function call to convert
    # Fraction part of real no
    # to Binary.
    fraction_str = binaryOfFraction(real_no - int(real_no))
 
    # Getting the index where
    # Bit was high for the first
    # Time in binary repres
    # of Integer part of real no.
    ind = int_str.index('1')
 
    # The Exponent is the no.
    # By which we have right
    # Shifted the decimal and
    # it is given below.
    # Also converting it to bias
    # exp by adding 127.
    exp_str = bin((len(int_str) - ind - 1) + 127)[2 : ]
 
    # getting mantissa string
    # By adding int_str and fraction_str.
    # the zeroes in MSB of int_str
    # have no significance so they
    # are ignored by slicing.
    mant_str = int_str[ind + 1 : ] + fraction_str
 
We use cookies
    # Addingto ensure you have
Zeroes in the
LSBbestofbrowsing experience on our website. By using our Got It !
site,
    # mantissa string so as and
you
acknowledge that you have read to understood
make our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 6/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

    # it's length of 23 bits.

    mant_str = mant_str + ('0' * (23 - len(mant_str)))
 
    # Returning the sign, Exp
    # and Mantissa Bit strings.
    return sign_bit, exp_str, mant_str
 
# Driver Code
if __name__ == "__main__":
 
    # Function call to get
    # Sign, Exponent and
    # Mantissa Bit Strings.
    sign_bit, exp_str, mant_str = floatingPoint(-2.250000)
 
    # Final Floating point Representation.
    ieee_32 = str(sign_bit) + '|' + exp_str + '|' + mant_str
 
    # Printing the ieee 32 representation.
    print("IEEE 754 representation of -2.250000 is :")
    print(ieee_32)

Output : 

Ad

Keto Diet

IEEE 754 representation of -2.250000 is :

1 | 10000000 | 00100000000000000000000

Program 2: Conver t a floating point representation to its real value

We
  use cookies to ensure you have the best browsing experience on our website. By using our Got It !
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 7/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

C++

// C++ program to convert

// IEEE 754 floating point representation
// into real value
 
#include<bits/stdc++.h>
using namespace std;
 
typedef union {
 
    float f;
    struct
    {
 
        // Order is important.
        // Here the members of the union data structure
        // use the same memory (32 bits).
        // The ordering is taken
        // from the LSB to the MSB.
        unsigned int mantissa : 23;
        unsigned int exponent : 8;
        unsigned int sign : 1;
 
    } raw;
} myfloat;
 
// Function to convert a binary array
// to the corresponding integer
unsigned int convertToInt(unsigned int* arr, int low, int high)
{
    unsigned int f = 0, i;
    for (i = high; i >= low; i--) {
        f = f + arr[i] * pow(2, high - i);
    }
    return f;
}
 
// Driver Code
int main()
{
 
    // Get the 32-bit floating point number
    unsigned int ieee[32]
        = { 1,
            1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0 };
  use cookies to ensure you have the best browsing experience on our website. By using our
We Got It !
    myfloat
site, var;
you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 8/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

 
    // Convert the least significant
    // mantissa part (23 bits)
    // to corresponding decimal integer
    unsigned int f = convertToInt(ieee, 9, 31);
 
    // Assign integer representation of mantissa
    var.raw.mantissa = f;
 
    // Convert the exponent part (8 bits)
    // to a corresponding decimal integer
    f = convertToInt(ieee, 1, 8);
 
    // Assign integer representation
    // of the exponent
    var.raw.exponent = f;
 
    // Assign sign bit
    var.raw.sign = ieee[0];
 
    cout << "The float value of the given"
           " IEEE-754 representation is : \n";
    cout << fixed << setprecision(6) << var.f <<endl;
    return 0;
}
 
// This code is contributed by ShubhamSingh10

// C program to convert
// IEEE 754 floating point representation
// into real value
 
#include <math.h>
#include <stdio.h>
 
typedef union {
 
    float f;
    struct
    {
 
        // Order is important.
        // Here the members of the union data structure
        // use the same memory (32 bits).
        // The ordering is taken
        // from the LSB to the MSB.
We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
 
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy
        unsigned int mantissa : 23;
https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 9/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

        unsigned int exponent : 8;

        unsigned int sign : 1;
 
    } raw;
} myfloat;
 
// Function to convert a binary array
// to the corresponding integer
unsigned int convertToInt(int* arr, int low, int high)
{
    unsigned f = 0, i;
    for (i = high; i >= low; i--) {
        f = f + arr[i] * pow(2, high - i);
    }
    return f;
}
 
// Driver Code
int main()
{
 
    // Get the 32-bit floating point number
    unsigned int ieee[32]
        = { 1,
            1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
    myfloat var;
 
    // Convert the least significant
    // mantissa part (23 bits)
    // to corresponding decimal integer
    unsigned f = convertToInt(ieee, 9, 31);
 
    // Assign integer representation of mantissa
    var.raw.mantissa = f;
 
    // Convert the exponent part (8 bits)
    // to a corresponding decimal integer
    f = convertToInt(ieee, 1, 8);
 
    // Assign integer representation
    // of the exponent
    var.raw.exponent = f;
 
    // Assign sign bit
    var.raw.sign = ieee[0];
 
    printf("The float value of the given"
We use cookies to ensure
           " you haverepresentation
IEEE-754 the best browsing experience on our website. By using our
is : \n"); Got It !
site, you
acknowledge that
    printf("%f", var.f); you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 10/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

P ython3

# Python program to convert

# IEEE 754 floating point representation
# into real value
 
# Function to convert Binary
# of Mantissa to float value.
def convertToInt(mantissa_str):
 
    # variable to make a count
    # of negative power of 2.
    power_count = -1
 
    # variable to store
    # float value of mantissa.
    mantissa_int = 0
 
    # Iterations through binary
    # Number. Standard form of
    # Mantissa is 1.M so we have
    # 0.M therefore we are taking
    # negative powers on 2 for
    # conversion.
    for i in mantissa_str:
 
        # Adding converted value of
        # Binary bits in every
        # iteration to float mantissa.
        mantissa_int += (int(i) * pow(2, power_count))
 
        # count will decrease by 1
        # as we move toward right.
        power_count -= 1
         
    # returning mantissa in 1.M form.
    return (mantissa_int + 1)
 
if __name__ == "__main__":
    # Floating Point Representation
    # to be converted into real
    # value.
    ieee_32 = '1|10000000|00100000000000000000000'
 
    # First bit will be sign bit.
    sign_bit = int(ieee_32[0])
We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
 
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy
    # Next 8 bits will be
https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 11/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

    # Exponent Bits in Biased

    # form.
    exponent_bias = int(ieee_32[2 : 10], 2)
 
    # In 32 Bit format bias
    # value is 127 so to have
    # unbiased exponent
    # subtract 127.
    exponent_unbias = exponent_bias - 127
 
    # Next 23 Bits will be
    # Mantissa (1.M format)
    mantissa_str = ieee_32[11 : ]
 
    # Function call to convert
    # 23 binary bits into
    # 1.M real no. form
    mantissa_int = convertToInt(mantissa_str)
 
    # The final real no. obtained
    # by sign bit, mantissa and
    # Exponent.
    real_no = pow(-1, sign_bit) * mantissa_int * pow(2, exponent_unbias)
 
    # Printing the obtained
    # Real value of floating
    # Point Representation.
    print("The float value of the given IEEE-754 representation is :",real_no)

Output : 

The float value of the given IEEE-754 representation is :

-2.250000

Attention reader! Don’t stop learning now. Get hold of all the impor tant CS Theor y

concepts for SDE inter views with the CS Theor y Course at a student-friendly price and

become industr y ready.

We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 12/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

Like 0

Previous Next

RECOMMENDED ARTICLES Page : 1 2 3

IEEE Standard 754 Floating Point Abnormal behavior of floating point

01 05
Numbers and double values
12, Sep 18 01, Aug 21

Difference between Single Precision 06 Measure execution time with high

02
and Double Precision precision in C/C++
10, Aug 18
27, Apr 20

Difference between 1's Complement

C Program to Multiply two Floating 07 representation and 2's Complement
03
Point Numbers representation
We use cookies to ensure you have the best browsing experience on our website. By using our Technique
05, Oct 18 Got It !
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy
23, Nov 15 Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 13/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

Why floating-point values do not Difference between Bits and

04 08
represent exact value Quantum Bits
30, Jul 20 19, Jun 20

Ar ticle Contributed By :

Kaustav kumar Chanda

@Kaustav kumar Chanda

Vote for difficulty

Current difficulty :
Medium

Easy Normal Medium Hard Expert

Improved By : amit_mangal_, anikaseth98, varshagumber28, SHUBHAMSINGH10,

simmytarika5

Article Tags : C Programs, Computer Organization & Architecture

Improve Article Report Issue

Writing code in comment?

Please use ide.geeksforgeeks.org,
generate link and share the link here.

Load Comments

We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 14/15
9/5/21, 1:00 AM Program for conversion of 32 Bits Single Precision IEEE 754 Floating Point Representation - GeeksforGeeks

5th Floor, A-118,

Sector-136, Noida, Uttar Pradesh - 201305

feedback@geeksforgeeks.org

Company Learn
About Us Algorithms
Careers Data Structures
Privacy Policy Languages
Contact Us CS Subjects
Copyright Policy Video Tutorials

Web Development Contribute

HTML Write an Article
CSS Write Interview Experience
JavaScript Internships
Bootstrap Videos

@geeksforgeeks
, Some rights reserved

We use cookies to ensure you have the best browsing experience on our website. By using our Got It !
site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

https://www.geeksforgeeks.org/program-for-conversion-of-32-bits-single-precision-ieee-754-floating-point-representation/ 15/15