Re: Computer Language Shootout

[mheaney@on2.com (Matthew Heaney)]

mheaney@on2.com (Matthew Heaney) wrote in message news:<1ec946d1.0307111358.fb772@posting.google.com>...
> Craig Carey <research@ijs.co.nz> wrote in message news:<n54tgvgugor0ag2qsv97t9mf9sn9rr542i@4ax.com>...
> > The Ada 95 entries have appeared that the new
> >  "Computer Language Shootout" website:
> > 
> >    http://dada.perl.it/shootout/gnat.html
> 
> I just cobbled together the "hash table (associative array)" example
> using the hashed set in Charles.  Here it is:

Here's the word frequency example:

procedure Wordfreq is

   Line  : String (1 .. 133);
   Last  : Natural;
   
   Word : Charles.Strings.Unbounded.Container_Type;
   Map : String_Integer_Maps.Container_Type;

   type Integer_Access is access all Integer;
   for Integer_Access'Storage_Size use 0;
   
   function To_Access is
      new Generic_Element (Integer_Access);   
      
   procedure Insert is
      I : Iterator_Type;
      B : Boolean;
   begin
      if Is_Empty (Word) then
         return;
      end if;

      Insert (Map, To_String (Word), 0, I, B);
      
      declare
         Count : Integer renames To_Access (I).all;
      begin
         Count := Count + 1;
      end;
      
      Clear (Word);
   end Insert;
               
begin

   while not End_Of_File loop
   
      Get_Line (Line, Last);
            
      for I in Line'First .. Last loop
         if Is_Alphanumeric (Line (I)) then
            Append (Word, To_Lower (Line (I)));            
         else
            Insert;
         end if;
      end loop;
      
      if Last < Line'Last then
         Insert;
      end if;
      
   end loop;       
   
   declare
      A : array (1 .. Length (Map)) of Iterator_Type;
      
      function Is_Less (R, L : Positive) return Boolean is
         RI : constant Iterator_Type := A (R);
         LI : constant Iterator_Type := A (L);
      begin
         if Element (RI) = Element (LI) then
            return Key (RI) > Key (LI);
         else
            return Element (RI) > Element (LI);
         end if;
      end Is_Less;
      
      procedure Swap (I, J : Positive) is
         E : constant Iterator_Type := A (I);
      begin
         A (I) := A (J);
         A (J) := E;
      end;
      
      procedure Sort is
         new Charles.Algorithms.Generic_Quicksort (Positive);
         
      I : Iterator_Type := First (Map);
   begin
      for Index in A'Range loop
         A (Index) := I;
         I := Succ (I);
      end loop;
      
      Sort (First => A'First, Back => A'First + A'Length);

      for Index in A'Range loop
         Put (Element (A (Index)), Width => 0);
         Put (':');
         Put (Key (A (Index)));
         New_Line;
      end loop;
   end;
         
end Wordfreq;

The Charles library includes the map used in the example, as well as
the generic algorithm for sorting a container.

http://home.earthlink.net/~matthewjheaney/charles/index.html

Instead of using an array as in the example, I could have used a list,
which comes with its own sort operation.  (For a list, the sort is
stable.)

-Matt