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

[Adam Beneschan <adam@irvine.com>]

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.

Hope this gives you some idea of how this language works.  It's quite
simple, really.

                              -- Adam