Hi,
    Just like counting the number of bits set to
1 in an integral variable, can we count the same
in a float?

    I have two solutions in my mind:

1.
    union {
        float   f;
        int     i;
    }u = { 10 };

    Now, count the required number from u.i.
    Will this work?


2.
    float           f;
    unsigned char   uc[sizeof (float)];

    memcpy ( uc, &f, sizeof (float) );

    Now count from the array.  How about this?


Season's Greetings!

--
Vijay Kumar R Zanvar
My Home Page - http://www.geocities.com/vijoeyz/


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"Vijay Kumar R Zanvar" <vijoeyz@hotpop.com> wrote in message
news:bt3kt1$30ugj$1@ID-203837.news.uni-berlin.de...
> Hi,
>     Just like counting the number of bits set to
> 1 in an integral variable, can we count the same
> in a float?
>
>     I have two solutions in my mind:
>
> 1.
>     union {
>         float   f;
>         int     i;
>     }u = { 10 };
>
>     Now, count the required number from u.i.
>     Will this work?
>
>
> 2.
>     float           f;
>     unsigned char   uc[sizeof (float)];
>
>     memcpy ( uc, &f, sizeof (float) );
>
>     Now count from the array.  How about this?
>
>
> Season's Greetings!
>
> --
> Vijay Kumar R Zanvar
> My Home Page - http://www.geocities.com/vijoeyz/
>
>
Hello,

It is enough to declare the float then take a char* to it as:
float f;
char *p = &f;
// now do the bit counting in 'p' till sizeof(f) , making at most
sizeof(f)*8 bits

--
Elias



~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lallous wrote:

> Hello,
>
> It is enough to declare the float then take a char* to it as:
> float f;
> char *p = &f;

You need an explicit cast here. And it should be unsigned char*
probably.

unsigned char *p = (unsigned char *)&f;

> // now do the bit counting in 'p' till sizeof(f) , making at most
> sizeof(f)*8 bits

Note that this will also count any padding bits if there are any.

--
Thomas.


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

On Fri, 2 Jan 2004 13:49:15 +0200, "lallous" <lallous@lgwm.org> wrote
in comp.lang.c:

> "Vijay Kumar R Zanvar" <vijoeyz@hotpop.com> wrote in message
> news:bt3kt1$30ugj$1@ID-203837.news.uni-berlin.de...
> > Hi,
> >     Just like counting the number of bits set to
> > 1 in an integral variable, can we count the same
> > in a float?
> >
> >     I have two solutions in my mind:
> >
> > 1.
> >     union {
> >         float   f;
> >         int     i;
> >     }u = { 10 };
> >
> >     Now, count the required number from u.i.
> >     Will this work?
> >
> >
> > 2.
> >     float           f;
> >     unsigned char   uc[sizeof (float)];
> >
> >     memcpy ( uc, &f, sizeof (float) );
> >
> >     Now count from the array.  How about this?
> >
> >
> > Season's Greetings!
> >
> > --
> > Vijay Kumar R Zanvar
> > My Home Page - http://www.geocities.com/vijoeyz/
> >
> >
> Hello,
>
> It is enough to declare the float then take a char* to it as:
> float f;
> char *p = &f;
> // now do the bit counting in 'p' till sizeof(f) , making at most
> sizeof(f)*8 bits

Aside from what others have said, your very last sentence is
completely wrong.  I am working on a platform right now where CHAR_BIT
is 16.  sizeof(float) is 2, and a float contains 32 bits.

It is definitely possible for the binary representation of a float to
have more than sizeof(float)*8 1 bits.  In fact it could have as many
as sizeof(float)*16 1 bits.

But it will never, ever have more than sizeof(float)*CHAR_BIT 1 bits.

--
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.learn.c-c++ ftp://snurse-l.org/pub/acllc-c++/faq
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"Vijay Kumar R Zanvar" <vijoeyz@hotpop.com> writes:
>     Just like counting the number of bits set to
> 1 in an integral variable, can we count the same
> in a float?
>
>     I have two solutions in my mind:
>
> 1.
>     union {
>         float   f;
>         int     i;
>     }u = { 10 };
>
>     Now, count the required number from u.i.
>     Will this work?

Not reliably.  Note that float and int may or may not be the same
size.  (As a matter of style, I'd use "10.0", or even "10.0f", rather
than "10" in the initialization to make it clear that you're
initializing the float member.)

> 2.
>     float           f;
>     unsigned char   uc[sizeof (float)];
>
>     memcpy ( uc, &f, sizeof (float) );
>
>     Now count from the array.  How about this?

Yes, that should work, though others have pointed out that you don't
really need to copy f to an array.

BTW, I can't think of any use for the number of 1 bits in a float
other than idle curiosity -- not that there's anything wrong with idle
curiosity.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org  <http://www.ghoti.net/~kst>;
San Diego Supercomputer Center             <*>  <http://www.sdsc.edu/~kst>;
Schroedinger does Shakespeare: "To be *and* not to be"
(Note new e-mail address)