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

[sjw <simon.j.wright@mac.com>]

On Jan 14, 8:13 pm, ChristopherL <clusard...@aol.com> wrote:
> On Jan 14, 8:08 am, Adam Beneschan <a...@irvine.com> wrote:
>
>
>
> > On Jan 14, 6:59 am, ChristopherL <clusard...@aol.com> wrote:
>
> > > Hello again,
>
> > > Trying twice, I seem not to be able to get the "Unchecked_Conversion"
> > > to compile. See below, and explain this to me.
>
> > > Thanks,
> > > Chris L.
>
> > > -- Program (1) --
>
> > > with Ada.Unchecked_Conversion;
>
> > > procedure test is
> > >    subtype Shrt is Integer range -(2 ** 7) .. ((2 ** 7) - 1 );
> > >    Result:Shrt;
>
> > >    Arg:Float;
>
> > >    function To_Bits is new
> > >       Ada.Unchecked_Conversion (Source => Float, Target => Shrt);
>
> > > Begin
> > >    Arg := 200.0;
>
> > >    Result := To_Bits(Arg + 0.5);  -- crude round then type conversion
> > > End test;
>
> > > -- Error Message Received
>
> > >     210       Ada.Unchecked_Conversion (Source => Float, Target =>
> > > Shrt);
>
> > > *** 387E-0: Identifier ADA is not directly visible
>
> > >     236       Result := To_Bits( Arg + 0.5 )
>
> > > *** 387E-0: Identifier TO_BITS is not directly visible
>
> > > ==================================================================
>
> > > -- Program (2) --
>
> > > with Unchecked_Conversion;
>
> > > procedure test is
> > >    subtype Shrt is Integer range -(2 ** 7) .. ((2 ** 7) - 1 );
> > >    Result:Shrt;
>
> > >    Arg:Float;
>
> > >    function To_Bits is new
> > >       Unchecked_Conversion (Source => Float, Target => Shrt);
>
> > > Begin
> > >    Arg := 200.0;
>
> > >    Result := To_Bits(Arg + 0.5);  -- crude round then type conversion
> > > End test;
>
> > (1) The error messages don't make any sense to me.  If you say "with
> > Ada.Unchecked_Conversion", then Ada and Ada.Unchecked_Conversion
> > should both be visible and you shouldn't be getting "not directly
> > visible" errors.  You did include the "with" statement in your source
> > file, right, rather than putting it in another source?  I'd check your
> > compiler manual here; maybe you didn't configure things properly and
> > you need to do something special in order to access the Ada standard
> > library.  I'm just guessing here.  I have no idea what compiler you're
> > using.
>
> > (2) Even if you get past that, your program will not work as
> > intended.  Unchecked_Conversion simply copies bit representations from
> > one type to another.  A floating-point type will contain bits in a
> > floating-point format, and that format won't look like an integer
> > format.  If Float is an IEEE-standard 32-bit float, the representation
> > of 200.0 looks like
>
> >    01000011010010000000000000000000
>
> > If you convert this to Shrt, which is probably 8 bits, the language
> > doesn't really tell you what happens when you Unchecked_Conversion a
> > 32-bit value to an 8-bit value.  But most likely you'll either get the
> > upper 8 bits (01000011) or the lower 8 bits (00000000), neither of
> > which is what you want.
>
> > You need a regular type conversion to convert the float to an integer,
> > not an Unchecked_Conversion.
>
> > (3) You still haven't been clear on what you want to do, but it now
> > looks like you're trying to take an 8-bit integer in the range 0..255
> > and convert it to an 8-bit Shrt (in the range -128..127) with the same
> > bit representation.  Did I guess right?  If that's the case, it might
> > be helpful to do this the simple way:
>
> >    type Signed_Short is range -128 .. 127;
> >      -- more readable than "Shrt", which could be mistaken for
> >      -- "shirt", or some other word with four letters
> >    for Signed_Short'Size use 8;
>
> >    type Unsigned_Short is range 0 .. 255;
> >    for Unsigned_Short'Size use 8;
>
> >    Arg : Float;
> >    Unsigned_Result : Unsigned_Short;
> >    Result : Signed_Short;
> > begin
> >    Arg := 200.0;
> >    Unsigned_Result := Unsigned_Short (Arg + 0.5);
> >        -- will raise exception if Arg is out of the range 0.0 ..
> > 255.0,
> >        -- after rounding
>
> >    if Unsigned_Result >= 128
> >       then Result := Signed_Short (Integer(Unsigned_Result) - 256)
> >       else Result := Signed_Short (Unsigned_Result);
> >    end if;
>
> > (You may have to convert to "Integer" before subtracting 256 because
> > otherwise Ada may try to use 8-bit integers to do the arithmetic and
> > then
> > things will be out of range.)
>
> > Or maybe you don't need the Unsigned_Short type:
>
> >    if Arg >= 128.0
> >       then Result := Signed_Short (Arg + 0.5 - 256.0)
> >       else Result := Signed_Short (Arg + 0.5);
> >    end if;
>
> > Or you can use Unchecked_Conversion if you want:
>
> >    function To_Signed_Short is new Unchecked_Conversion
> >        (Source => Unsigned_Short, Target => Signed_Short);
> >    ...
> > begin
> >    ...
> >    Unsigned_Result := Unsigned_Short (Arg + 0.5);
> >    Result := To_Signed_Short (Unsigned_Result);
>
> > This seems to be what you want... copying bits from an unsigned
> > integer to a signed integer.  Not copying bits from a float to an
> > integer---that is not at all what you're trying to accomplish.
>
> I want to copy bits from an Ada float to a user defined short integer
> maintaining the same
> bit representation.
>
> Arg:Float;  -- From this with a value of 200
> subtype Short_integer is Integer range -(2 ** 7) .. ((2 ** 7) - 1 );
> Result: Short_integer; --to this, and I want to round Arg

Chris,

Never mind the rounding; tell us what you need the value in Result to
be for Arg = 200?

It clearly can't be 200, because that's outside the range you've
specified.


Note that the numeric range you've specified for Short_Integer will
fit into 8 bits, but because you've made it a subtype of Integer,
variables will occupy the same space as an Integer (32 bits usually;
it will be at least 16 bits).


It'd also help to know what compiler you're using.