RE: Signed integer to modular type conversion

["Steven Deller" <deller@smsail.com>]

Compute in "integer" (the wider type) and then coerce into your modtype.

Y := modtype( X mod 2**32 ) ;
Z := modtype( integer(X) + Y ) ;

Makes it clear that the computation is done as "integer" with an
expected result that fits into "modtype".

You could also do:
   function "+" ( L : modtype ; R : integer ) return modtype is
   begin
       return modtype( integer(L) + R ) ;
   end "+"; 

and then write
    z := x + y ;

But unless mixing the two types is done a lot and you write "all" mixing
functions in a package (which can lead to disambiguation difficulties),
this is not good technique.

Some of your difficulty may be from looking at types as simply sets of
"the same" numeric values, rather than as abstractions of distinctly
different values that just happen to use the same "untyped" number set
to name the values.  

When you leave out abstraction, modtype simply looks like an integer
with some values taken out, and "+" looks like a single operator.

The real meaning of the values and operators depends on the abstraction
you are trying to model with each different type.  Usually, when the
full abstraction is considered, I find the problem of "mixing" types
resolves rather easily, or reveals an incorrect mix or incorrect
abstraction.

Regards,
Steve

> -----Original Message-----
> > 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).
...
> 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
> _______________________________________________
> comp.lang.ada mailing list
> comp.lang.ada@ada.eu.org 
> http://ada.eu.org/mailman/listinfo/comp.lang.ad> a
>