From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=ham
	autolearn_force=no version=3.4.4
X-Google-Thread: a07f3367d7,e9dfe478ced46adc,start
X-Google-Attributes: gida07f3367d7,public,usenet
X-Google-NewGroupId: yes
X-Google-Language: ENGLISH,ASCII-7-bit
Path: 
 g2news2.google.com!news3.google.com!feeder.news-service.com!newsfeed.straub-nv.de!news-1.dfn.de!news.dfn.de!news.uni-weimar.de!not-for-mail
From: Stefan.Lucks@uni-weimar.de
Newsgroups: comp.lang.ada
Subject: Abstract operator does not hide predefined operator
Date: Fri, 12 Nov 2010 16:04:27 +0100
Organization: Bauhaus-Universitaet Weimar
Message-ID: <Pine.LNX.4.64.1011121513460.20835@medsec1.medien.uni-weimar.de>
NNTP-Posting-Host: medsec1.medien.uni-weimar.de
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
X-Trace: tigger.scc.uni-weimar.de 1289567185 12705 141.54.178.228 (12 Nov 2010
 13:06:25 GMT)
X-Complaints-To: news@tigger.scc.uni-weimar.de
NNTP-Posting-Date: Fri, 12 Nov 2010 13:06:25 +0000 (UTC)
X-X-Sender: lucks@medsec1.medien.uni-weimar.de
Xref: g2news2.google.com comp.lang.ada:16412
Date: 2010-11-12T16:04:27+01:00
List-Id: <comp.lang.ada>

Hi all,

I've implemented a small generic package for modular arithmetic. Note that 
Ada's "mod N" types define addition subtraction and multiplication right, 
but use the integer division for "/" instead of the proper modular 
division, where A/B is A * Inverse(B). I also tried to get rid of the 
unary "not" operator, who's purpose I don't understand for general 
modular arithmetic. (I understand that it is useful if the modulus is a 
power of two, just like the binary xor operator.)

This is the spec of my generic package:

generic
   type Mod_T is mod <>;
package Mod_Arith is
   type Modular is new Mod_T;
   function "/"(Left, Right: Modular) return Modular;
   function Inverse(Value: Modular) return Modular;
   function "not"(Value: Modular) return Modular is abstract;
end Mod_Arith;

For testing that package, I first instantiated it:

   type M3343 is mod 3343;
   package M is new Mod_Arith(Mod_T => M3343);
   use type M.Modular;
   S,T,U: M.Modular;

(Sidenote: 3343 is a prime, so addition and multiplication over M.Modular 
are field operations, mathematically.)

Now, my freshly defined division works as expected. The multiplication 
(and addition and subtraction) are inherited from the type M3343:

   S := 3;
   T := S/(2*S); -- T becomes the multiplicative Inverse of 2 mod 3343; 
                 -- the same expression's result in M3343 would be zero.
   Ada.Text_IO.Put_Line(M.Modular'Image(T) &
                          M.Modular'Image(M.Inverse(2)));
   -- The output is "1672 1672", as expected. 

But, unfortunately, the compiler (gnat) also accepts the following:

   U := not S; -- this should not be possible, because the "not" operator
               -- has been defined abstract ... but instead, the 
               -- predefined "not" from M3343 seems to be used
   Ada.Text_IO.Put_Line(M.Modular'Image(U));
   -- The output is "3339", which actually is not(M3343(S)) = 3342-S. 

What can I do to get rid of the predefined "not"? If I change the "not" 
from an abstract function to a function always raising an exception, the 
statement 

   U := not S;

raises the desired exception. But I would prefer to be told at compile 
time that I must not use "not", rather than at run time. Also, I would 
prefer not to define the type Mod_Arith.Modular as a private type.

Any ideas?

Stefan



-- 
------ Stefan Lucks   --  Bauhaus-University Weimar  --   Germany  ------
               Stefan dot Lucks at uni minus weimar dot de
------  I  love  the  taste  of  Cryptanalysis  in  the  morning!  ------