Floating point number to binary

[Gaurav Verma]

Hi,

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

Thanks
Gaurav
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[Jack Klein]

On 16 Sep 2004 14:25:56 -0700, ol*****@inspire .net.nz (Old Wolf) wrote
in comp.lang.c:

Brian Gough <bj*@network-theory.co.uk> wrote:

ve**********@gm ail.com (Gaurav Verma) writes:

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

If you want the underlying IEEE representation of a floating point
number you can use a union to access the individual bytes.

e.g. union { double d; struct { unsigned char byte[8]; } ieee ; } u;

This is undefined behaviour; to be portable you should go:
unsigned char *ptr = (unsigned char *)&d;
and then access the first (sizeof d) bytes of ptr.

Also note that the size of double is not required to be 8, and it is
not required to use IEEE format (although usually it is).

The union method is neither more nor less portable than the type
punning through the pointer. Any object in C may be accessed as an
array of unsigned character types, this being specifically defined as
its "object representation" .

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Dan Pop]

In <41************ **@yahoo.com> CBFalconer <cb********@yah oo.com> writes:

Dan Pop wrote:

CBFalconer <cb********@yah oo.com> writes:

Brian Gough wrote:
... snip ...
If you want the underlying IEEE representation of a floating
point number you can use a union to access the individual bytes.

e.g. union {double d; struct {unsigned char byte[8];} ieee ;} u;

No you can't, at least not portably.

Care to elaborate on the portability problems of:

union { double d; unsigned char bytes[sizeof(double)]; } u;

As I understand it accessing a union member as other than the type
that was stored in it is either implementation or undefined.

As usual, you have difficulties engaging your brain...

In this particular case, the result is implementation-defined for
*exactly* the same reason it is implementation-defined in your suggested
method: the representation of floating point values itself is
implementation-defined.

Aliasing any object by an array of unsigned char is blessed by the
standard, no matter how the aliasing is achieved. See 6.5p7 and its
footnote.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Currently looking for a job in the European Union

[Joe Wright]

Dan Pop wrote:

In <41************ **@yahoo.com> CBFalconer <cb********@yah oo.com> writes:

Dan Pop wrote:

CBFalconer <cb********@yah oo.com> writes:

Brian Gough wrote:

... snip ...

>If you want the underlying IEEE representation of a floating
>point number you can use a union to access the individual bytes.
>
>e.g. union {double d; struct {unsigned char byte[8];} ieee ;} u;

No you can't, at least not portably.

Care to elaborate on the portability problems of:

union { double d; unsigned char bytes[sizeof(double)]; } u;

As I understand it accessing a union member as other than the type
that was stored in it is either implementation or undefined.

As usual, you have difficulties engaging your brain...

In this particular case, the result is implementation-defined for
*exactly* the same reason it is implementation-defined in your suggested
method: the representation of floating point values itself is
implementation-defined.

Aliasing any object by an array of unsigned char is blessed by the
standard, no matter how the aliasing is achieved. See 6.5p7 and its
footnote.

Given float and unsigned int are both 32 bits wide (on my system)..

union {
float f;
unsigned u;
} flt;

flt.f = 1.0;

Now, examining flt.u we find it's 32 bits look like..

00111111 10000000 00000000 00000000

Still as flt.u we split it up to its float components.

Exp = 127 (1)
00000001
Man = .10000000 00000000 00000000

Having assigned to flt.f, does examining flt.u cause problems?
Clearly we are allowed to examine flt as..

unsigned char *ft = (unsigned char *)&flt;

...and examine ft[0] through ft[3] without problem.
--
Joe Wright mailto:jo****** **@comcast.net
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[Chris Torek]

In article <news:5a******* *************@c omcast.com>
Joe Wright <jo********@com cast.net> wrote:

Given float and unsigned int are both 32 bits wide (on my system)..

union {
float f;
unsigned u;
} flt;

flt.f = 1.0;
[snippage]
Having assigned to flt.f, does examining flt.u cause problems?
Possibly. That it must work, the C Standards sayeth not; and in
fact, at least one implementation (gcc, on SPARC) sometimes seems
to leave the floating point part in a floating point register, and
the integer part in an integer register, and never the twain do
meet. The bits found in flt.u thus have no correspondence to those
underlying flt.f.

Exposing the problem is tricky, as the optimization changes the
machine code if the source code is even sneezed-upon.
Clearly we are allowed to examine flt as..

unsigned char *ft = (unsigned char *)&flt;

..and examine ft[0] through ft[3] without problem.

Yes -- and this did work on that same gcc.
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[LM]

I don't know any special function for this in C, but it is very easy to do
if you know method of convertion... If you need if, I can describe...
--
LM
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[pete]

Gaurav Verma wrote:

Hi,

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

#include <stdio.h>
#include <limits.h>

#define E_TYPE float
#define STRING " %s = %f\n"
#define VALUE 123.456f

typedef E_TYPE e_type;

void bitstr(char *, void const *, size_t);

int main(void)
{
e_type e;
char ebits[CHAR_BIT * sizeof e + 1], *s;

s = STRING;
e = VALUE;
bitstr(ebits, &e, sizeof e);
printf(s, ebits, e);
return 0;
}

void bitstr(char *str, const void *obj, size_t n)
{
unsigned mask;
const unsigned char *byte = obj;

while (n--) {
mask = ((unsigned char)-1 >> 1) + 1;
do {
*str++ = (char)(mask & byte[n] ? '1' : '0');
mask >>= 1;
} while (mask != 0);
}
*str = '\0';
}

--
pete
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[Nicolas Pavlidis]

ve**********@gm ail.com (Gaurav Verma) writes:

Hi,

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

If I understand you right, that you want print out a binary notation of
a floating point number, here is an algorithm that will do this:

1) Divide the number into pre and post comma part
2) Convert each part into a string
3) Print out the two converted parts delimited by a '.'

Here is (one) way to convert a number into a binary representation:

----------8<-------------------snapp------------------------>8----------
char* getBinRep(unsig ned char number)
{
char* help;
unsigned char comp_mask = 0x1 << ((sizeof(char) * 8) -1);
char* bin_rep = malloc(sizeof(c har) * sizeof(char) * 8 + 1);
if(!bin_rep)
standartErrorHa ndler(OUT_OF_ME MORY);
help = bin_rep;
while(comp_mask )
{
*help++ = (number & comp_mask) ? '1' : '0';
comp_mask >>= 1;
}
*help = '\0';
return(bin_rep) ;
}
----------8<-------------------snipp------------------------>8----------

HTH && kind regards,
Nicolas
--
| Nicolas Pavlidis | Elvis Presly: |\ |__ |
| Student of SE & KM | "Into the goto" | \|__| |
| pa****@sbox.tug raz.at | ICQ #320057056 | |
|-------------------University of Technology, Graz----------------|
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[Richard Bos]

ve**********@gm ail.com (Gaurav Verma) wrote:

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

What, _exactly_, have you got; what, exactly do you want? Have you got a
float in memory, or a string containing "123.456"? Do you want a float
in memory (since all C objects are stored binarily), or do you want a
string containing "1010.1010" ?
If you want to go from string to object, use strtod().
If you want to go from object to binary representation in memory, do
nothing; you've already got it.
If you want to go from object to string, that's harder; there is no
built-in printf() specifier for binary as there is for decimal and hex,
so you'll have to roll your own. Keep dividing by two and adding ones or
zeroes depending on the modulus.
If you want to go from decimal representation string to binary
representation string, it's probably easiest to use strtod() first and
then apply the previous solution.

Richard
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[Malcolm]

"Gaurav Verma" <ve**********@g mail.com> wrote

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

Take the second logarithm of the number passed in. This tells you the place
value of the first binary digit.
Set that digit to a 1, then subtract from the passed number. Check for
equality or greater with the power of 2 1 less than the greatest digit. This
tells you if the next binary digit is 1 or zero. If it is 1, subtract.
Continue until the value goes to 0 or infinitesimal (the smallest positive
number representable in your floating point format).
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et

[Keith Thompson]

ve**********@gm ail.com (Gaurav Verma) writes:

I want to convert a floating point number (or a decimal number say
123.456) into binary notation using a C program. Can somebody help me
out with it?

Your question is ambiguous. What kind of binary representation are
you looking for? Do you want to see the representation of the
floating point number (sign, exponent, mantissa)? Or are you looking
for a binary representation of the mathematical value, something like
"1111011.011110 110100" for 123.456?

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
--
comp.lang.c.mod erated - moderation address: cl**@plethora.n et