Re: Ada95 speed

["Clifford J. Nelson" <cnelson9@gte.net>]

I could have answered my own questions if I had had the patience.

a) Is Ada95 slow in order to be safe?

 No. It's fast even when it tries to be safe.

b) Is GNAT-for-the-Mac slow? CodeBuilder 1.1?

 No. It's fast.

But, the operating systems for low end computers in 1999 are awkward to
program in. More so than fifteen years ago, especially for graphics.

Here are timing tests in Mathematica and Ada95.

Mma Version 3.0.1  gives 0.1 seconds.

GNAT Ada95 gives 0.066 seconds.

See:
http://forum.swarthmore.edu/epigone/geometry-research/brydilyum

In[1]:=
<<RBFields.m

Out[1]=
{"E"}

In[2]:=
a = B[makezero[Table[1,{96}]]];

In[3]:=
t = B[N[makezero[Range [96]]]];

In[4]:=
First[Timing[vt = t/t-a]]

Out[4]=
0.1*Second

In[5]:=
VectorDistance[First[vt]]

Out[5]=
1.197930643570543*^-13

Now Ada95.

with bnumbers;
with Calendar;
with Ada.Text_io;
use Calendar;
use Ada.Text_io;
use bnumbers;

procedure testbnumber is
 T : duration;
 V : real;
 N : constant integer := 97;
 A,B,C : bnumber(1..N);

 begin
 for I in 1..N-1 loop
 A(I) := 1.0;
 B(I) := real(I);
 end loop;
 A(N) := real(-N+1);
 B(N) := real(-(N*(N-1))/2);
 T := Seconds(Clock);
 C := B / B - A;
 T := Seconds(Clock) - T;
for I in C'range loop
put(real'image(C(I)));
end loop;
 V := vectordistance(C);
 Put(" It took " & Duration'Image(T) & " seconds. " & " V = " &
real'image(V));
 end testbnumber;

package bnumbers is

type real is digits 15;

type bnumber is array (positive range <>)  of real;

type coords is array(positive range <>) of real;

function "+" (X : bnumber; Y : bnumber) return bnumber;
function "-" (X : bnumber; Y : bnumber) return bnumber;
function "*" (X : bnumber; Y : bnumber) return bnumber;
function "/" (X : bnumber; Y : bnumber) return bnumber;
function "abs" (X : bnumber) return real;
function vectordistance (X : bnumber) return real;
function ptos(X : coords) return bnumber;
function abssq (X : bnumber) return real;

pragma inline("+");
pragma inline("-");
pragma inline("*");
pragma inline("/");
pragma inline("abs");
pragma inline(abssq);
pragma inline(vectordistance);
pragma inline(ptos);

end bnumbers;

with realfunctions;
use realfunctions;


Package body bnumbers is


function "+" (X : bnumber; Y : bnumber) return bnumber is
Z : bnumber(X'range);
begin
for I in X'range loop
Z(I) := X(I)+Y(I);
end loop;
return Z;
end "+";
pragma inline("+");

function "-" (X : bnumber; Y : bnumber) return bnumber is
Z : bnumber(X'range);
begin
for I in X'range loop
Z(I) := X(I)-Y(I);
end loop;
return Z;
end "-";

pragma inline("-");

function "*" (X : bnumber; Y : bnumber) return bnumber is
XJ : Integer;
T,TT: real;
len : constant integer := X'length;
Z : bnumber(1..len);
D : constant real := real(-len);
begin
TT := 0.0;
for I in 1..len-1 loop
T := 0.0;
for J in 1..len loop
XJ :=   I + len  - J;
if XJ > len then
T := T + X(XJ - len ) * Y(J);
else
T := T + X(XJ) * Y(J);
end if;
end loop;
T := T / D;
Z(I) := T;
TT := TT + T;
end loop;
Z(len) := -TT;
return Z;
end "*";

pragma inline("*");

function "/" (X : bnumber; Y : bnumber) return bnumber is
T : real := 0.0;
len : constant integer := X'length;
TL : constant real := real(-len);
Z,W : bnumber(1..len);
begin
 for I in 1 .. len - 1 loop
  Z(I) := Y((2 * I) mod len);
 end loop;
 Z(len) := Y(len);
 if (len > 3) then
  W(len) := Y(len);
  for I in 3..len-1 loop
   for J in 1.. len-1 loop
    W(J) := Y((J * I) mod len);
   end loop;
  Z := W * Z;
  end loop;
 end if;
 for J in 1..len loop
  T := T + Y((len) + 1 - J) * Z(J) ;
 end loop;
 for I in 1..len loop
  Z(I) := TL * Z(I) / T;
 end loop;
 Z := X * Z;
 return Z;
end "/";

pragma inline("/");

function "abs" (X : bnumber) return real is
T : real := 0.0;
begin
for I in X'range loop
T := X(I)*X(I) +T;
end loop;
return sqrt(T/2.0);
end "abs";

function abssq (X : bnumber) return real is
T : real := 0.0;
begin
for I in X'range loop
T := X(I)*X(I) +T;
end loop;
return T/2.0;
end abssq;


function vectordistance (X : bnumber) return real is
T : real := 0.0;
begin
for I in X'range loop
T := (abs(X(I))) +T;
end loop;
return (T/2.0);
end vectordistance;

function uni(val : real; ival,length  : integer) return bnumber is
Y : bnumber(1..length);
begin
for I in 1..ival-1 loop
 Y(I) := val;
 end loop;
Y(ival) := real(- (ival - 1)) * val;
for I in ival+1..length loop
Y(I) := 0.0;
end loop;
return Y;
end uni;

pragma inline(uni);

function tri(x : integer) return real is
begin
return sqrt(real((x * (x - 1))/2));
end tri;

pragma inline(tri);

function ptos(X : coords) return bnumber is
L : constant integer := X'length +1;
T : bnumber(1..L);

begin
T := uni(X(1),2,L);
for I in 3..L loop
T := T + uni(X(I-1)/tri(I),I,L);
end loop;
return T;
end ptos;





pragma inline("abs");
pragma inline(vectordistance);
pragma inline(ptos);

end bnumbers;

with Ada.Numerics.Generic_Elementary_Functions;
with bnumbers;
package realfunctions is
  new Ada.Numerics.Generic_Elementary_Functions (bnumbers.real);