Re: How to put 200 into an integer sub-type of 16 bits (code included)

["Stuart" <stuart@0.0>]

"ChristopherL" <clusardi2k@aol.com> wrote in message 
news:1a2b31ac-cf6b-44e3-85b7-04594460db87@d36g2000prf.googlegroups.com...

<snip much>

> Please remove the rounding operation for now from this discussion.

OK.

> This problem was given to me to try to solve who said it's probably
> impossible!

Not being funny or anything but it might be as well to describe the problem 
as given.  I think the exchanges elsewhere in this thread demonstrate that 
there is a great deal of confusion.

> The size of floating point number is 32 bits on my system, and my
> float will always be positive.
>
> General information about floating point numbers in general:

<snip description of sign + biased exponent + mantissa representation>

> So, what is the proper way to store a number (never being greater
> than 200.5) in a 8 bit short number as outlined above?

OK - there is no 'proper' way, there are several ways, each of which has 
advantages and disadvantages.

I get the impression that you have a 'real' input in the range: 0.0 .. 200.5 
and you want to have this value held in an 8-bit variable.

You do not say to what precision you need this value, or how this precision 
might vary over the value range.  Floating point representations provide a 
relative precision, so while values around 200.0 might only be represented 
with a precision of 1.0, values around 20.0 would be represented with a 
precision of 0.1, and those around 2.0 with a precision of 0.01.  Fixed 
point representations provide a fixed precision, so all values might be 
represented with a precision of 1.0 whether they be 200.0, 20.0 or 2.0.

You need to clarify what your requirements are!

If fixed point precision is adequate to your needs then you should find that 
Ada fixed point types will meet your needs most adequately (you may need to 
specify the 'small attribute to extract the maximum amount of precision) and 
you will be able to use a simple type conversion.

If you need floating point precision things are going to be more difficult 
because you are going to have to roll your own representation.  You seem to 
have done some research on floating point representations so I won't go into 
detail now, but I would note that:
   a) You do not need a sign bit as all values are positive.
   b) You might want to consider something other than base 2 representation 
to eke out a little more precision given your data range (200.5).

On the subject of extracting 'values' out of  floating point representations 
I should like to suggest you track down a copy of the PowerPC Compiler 
Writers guide - this shows a process for injecting/extracting values by 
adding/subtracting a bias to move the values of interest to a more useful 
part of the representation and exclude the effects of the biased exponent. 
(The method may be described elsewhere - but this is one that I am familiar 
with and the guide is available on-line (or was).

On the subject of range you may need to think very carefully about whether 
200.5 is or isn't in your number range.  It may be the case that when you 
look at alternative number bases it will become a moot point, but in your 
earlier examples you were running into a constraint problem because 200.5 
was being rounded up to 201.  (Read a bit more about rounding if you are 
unclear about this).

Regards
   Stuart




Chris L.