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

[Brian Drummond <brian_drummond@btconnect.com>]

On Tue, 13 Jan 2009 20:33:19 -0800 (PST), ChristopherL
<clusardi2k@aol.com> wrote:

>On Jan 13, 9:33�pm, Brian Drummond <brian_drumm...@btconnect.com>
>wrote:
>> what are you really trying to do?
>>
>> - Brian
>
>
>What I want to do is this. I have a variable holding the base 10 value
>200. It has a certain bit representation. If the variable was an
>integer of 16 bits it's representation would be something such as
>0000000011001000. For give me if I'm wrong. Anyway, what I'd like to
>do is put that exact bit representation in another variable of a
>different type.
>
>How do I proceed?

UNCHECKED_CONVERSION is central to this.
But unless you are trying to write C in Ada, take Ludovic's suggestions
seriously.

You may not have LONG_LONG_INTEGER, and FLOAT may not be the size you
expect. If you want specific representations, then specify what you
want.

Making a couple of unjustified wild assumptions about what you want to
do:

(a) by FLOAT you mean IEEE P754 32-bit single precision (or something
closely compatible with it; there are sloppy implementations out there)

(b) you need to translate from your 16 bit integer input to the
identical number represented as 32-bit integer as a first step; there
may be endian issues to worry about here; THEN to FLOAT

(c) you don't want to translate 200 (16#C8#) to 200.0 (otherwise you'd
simply convert it!) but to some very very small denormalised number
(16#000000C8# is in the region below 10^-37)
(Aside to Ludovic: it's a legal FLOAT value in any FP representation
I've seen; but may be invalid for obscure or prehistoric machines)

(d) All your 16 bit inputs translate to denorms, which makes me wonder
if this is really what you want. But if you want the inputs in the most
significant bits of the 32-bit type you have to say so...

>I was thinking of trying to do it with code such as the below. The
>below code is not mine and came from this group. So, tomorrow I am
>planning on modifying my first example above to use the below code.
>What are my chances of doing it?

>package INT_IO is new TEXT_IO.INTEGER_IO(LONG_LONG_INTEGER);


Type Float_32 is new digits 7;
-- hack warning: most systems will adopt IEEE 754 SP for this
-- I think "Float" could be 64 bit in some implementations
-- Either way CHECK the size you get...
pragma Assert(Float'Size = 32);
-- you need to use Ada.Assertions

Type Integer_32_bit is -- ... see Ludovic's code
package INT_32_IO is new TEXT_IO.INTEGER_IO(Integer_32_bit);

>INT:=2#11111111100000000000000000000000#;

Unless you are better at counting zeroes than I am,

INT := 16#3f800000#;		-- known 1.0 in P754 SP

and test this independently of your 16-bit to 32-bit translation

Disclaimer: I am new to Ada, but not to FP bit wrangling in the closely
related language VHDL.

- Brian