Re: Signed integer to modular type conversion

[adam@irvine.com (Adam Beneschan)]

Mark Johnson <mark_h_johnson@raytheon.com> wrote in message news:<3CE26A21.3EC6F802@raytheon.com>...
> Adam Beneschan wrote:
> > 
> > Supposing Standard.Integer is a 32-bit signed integer type.  I have a
> > modular type
> > 
> >     type ModType is mod 2**32;
> > 
> >     X : Integer;
> >     Y : ModType;
> > 
> > I'd like to set Y := X mod 2**32 (which should essentially just treat
> > X as an unsigned integer without changing the data).

> A reasonably efficient way to do this is Unchecked_Conversion. This for
> types of the same size (as in this case), it will copy the bytes from
> the source to destination. As you noted in the rest of your message, the
> direct type conversion doesn't do what you want and the arithmetic is an
> inefficient method. There are a lot of reasons not to use
> Unchecked_Conversion, but this doesn't appear to be one of them.
>   --Mark

OK, let me try a variation, and see if you still think
Unchecked_Conversion an appropriate way (or the best way) to handle
it.

I have two integer values.  One is in the range 0 .. 2**32-1, and the
other is in the range -2**31 .. 2**31-1.  I want to find the
mathematical sum of these two integers.  Let's assume that I expect
the result to be in the range 0..2**32-1, and am not worried about
what happens if it isn't.

    type ModType is mod 2**32;
    X : ModType;
    Y : Integer;
    Z : ModType;

I want to compute Z := X + Y, but of course I can't write this.  Z :=
X + ModType(Y) won't work if Y is negative; this is what led me to ask
the previous question, since I was trying to find a way to convert Y
to a ModType.

Again, I believe this is something that can be computed with one
machine instruction, so I'd like to avoid time-wasters like

    if Y < 0 then
	Z := X - ModType(-Y);
    else
	Z := X + ModType(Y);
    end if;

Would you still use something like Z := X + ToModType(Y) [where
ToModType is an instance of Unchecked_Conversion]?

				-- Adam