Does Ada need elemental functions to make it suitable for scientific work?

Does Ada need elemental functions to make it suitable for scientific work?

[Nasser M. Abbasi]

I have been trying Ada to see how suitable it is for computational
work (I am studying finite elements, and wanted to try Ada for
basic programs).

And even though I find its type system a great asset to help
catch many errors, I find it a little awkward for programming on
arrays and matrices which ones does alot in scientific numerical
programming. The most important feature which I found missing is
that Ada functions do not automatically work on arrays and matrices.

In Fortran, we see

http://en.wikipedia.org/wiki/Fortran_95_language_features#Elemental_operations.2C_assignments_and_procedures

"Most intrinsic functions are elemental and Fortran 95
extends this feature to non-intrinsic procedures"

intrinsic functions in Fortran are those build-in (like
sin/cos, etc...)

Lets look at a very simple example to help explain what I mean.
I wanted to raise each entry in a vector to the second power.

In Fortran, I can just write V**2, where V is a vector. In Ada,
I can't do that. Since ** is not defined on this array type
and this number type.

I would have to write a loop to iterate over V and do V(I)**2 on
each element.

This for me, is a step backward. This is how Fortran77 was.

I know I am a newbie in Ada, and I could have overlooked a
simple solution to do this. But I really do not want to
write packages and define operators each time and for each type
I make to have it work as elemental function each time.

This is something that should be build into the language.

Here are two complete trivial examples of what I mean.

I was wondering if there is a chance that something like
this can be added to Ada like what was done for Fortran?

---- fortran -------------------------
!-- showing how to use Fortran for vectored operations
!-- equations work on vectors, no need for loop
program f08
   implicit none

   integer, parameter :: N = 7
   real   , parameter :: D(N) = [-0.2,1.0,1.5,3.0,-1.0,4.2,3.1]
   real   , parameter :: H(N) = [2.1,2.4,1.8,2.6,2.6,2.2,1.8]
   real               :: V(N)

   V = D**2 * H       ! all vectored operations
   print *, v
end program f08
---------------------------------
>gfortran f08.f90
>./a.out
   8.39999989E-02  2.4000001 4.0499997 23.400000  2.5999999  38.807995  17.297998

---------Ada ------------------
procedure foo2 is
   N : integer :=7;
   type array_t is array(1..N) OF float;
   
   D : constant array_t :=(-0.2,1.0,1.5,3.0,-1.0,4.2,3.1);
   H : constant array_t :=(2.1,2.4,1.8,2.6,2.6,2.2,1.8);
   V : array_t;
   
   begin
     V := D**2 * H;
end foo2;
-------------------

>gnatmake foo2.adb
gcc -c foo2.adb
foo2.adb:11:10: invalid operand types for operator "**"
foo2.adb:11:10: left operand has type "array_t" defined at line 4
foo2.adb:11:10: right operand has type universal integer
gnatmake: "foo2.adb" compilation error
>

--Nasser

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Nasser M. Abbasi]

On 7/9/2012 10:59 PM, Dennis Lee Bieber wrote:

> 	Also, unless things have changed, the FORTRAN language standard
> defines at least two levels of the language; the full language you are
> describing, and a subset implementation which not only may not have the
> vectorization features,

There is only one Fortran ISO standard, just like with Ada.

http://gcc.gnu.org/wiki/GFortranStandards

--Nasser

Re: Does Ada need elemental functions to make it suitable for scientific work?

[gautier_niouzes]

Le mardi 10 juillet 2012 01:27:54 UTC+2, Nasser M. Abbasi a écrit :

> In Fortran, I can just write V**2, where V is a vector. In Ada,
> I can't do that. Since ** is not defined on this array type
> and this number type.
> 
> I would have to write a loop to iterate over V and do V(I)**2 on
> each element.
> 
> This for me, is a step backward. This is how Fortran77 was.

Interesting example... How often do you do need that, frankly ?
The standard is there for... standard operations, like a * v (a is a number).
There are always things you might feel it is missing.
For instance the shortcuts "and then" and "or else" are missing in Fortran, and to my opinion it is something more cumbersome than the lack of v**2 in Ada.

G.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Ada novice]

On Tuesday, July 10, 2012 5:24:57 AM UTC+1, (unknown) wrote:
> Le mardi 10 juillet 2012 01:27:54 UTC+2, Nasser M. Abbasi a écrit :
> 
> > In Fortran, I can just write V**2, where V is a vector. In Ada,
> > I can't do that. Since ** is not defined on this array type
> > and this number type.
> > 
> > I would have to write a loop to iterate over V and do V(I)**2 on
> > each element.
> > 
> > This for me, is a step backward. This is how Fortran77 was.
> 

> Interesting example... How often do you do need that, frankly ?

Believe me, for someone who do numerical computations on a daily basis, an operation like V**2 is a NECESSITY. It's a pity that Ada does not offer such a facility. I do not blame those who stick to Matlab (or Fortran?) for doing numerical computations.

YC

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Mon, 9 Jul 2012 22:22:58 -0700 (PDT), Ada novice wrote:

>> Interesting example... How often do you do need that, frankly ?
> 
> Believe me, for someone who do numerical computations on a daily basis, an
> operation like V**2 is a NECESSITY.

Where is a problem? "**" is a user-definable operator in Ada. Moreover, it
can be overloaded. Provided that V**2 is quite ambiguous. it could mean 

1. inner product
2. cross product
3. matrix: Transpose (V) * V
...

> It's a pity that Ada does not offer such a facility.

Ada does it. Maybe some library X does not, then take Y or extend X. 

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[gautier_niouzes]

Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a écrit :

> Believe me, for someone who do numerical computations on a daily basis, an operation like V**2 is a NECESSITY. It's a pity that Ada does not offer such a facility. I do not blame those who stick to Matlab (or Fortran?) for doing numerical computations.
Wait... There are *such* facilities and several built-in operations *like* that:
http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html

Apparently it is not enough. But it is possible to make a proposal for the next standard (and shorter term, for the next GNAT version).

The snag with that *specific* operation, v**2 meaning "v(i)**2 for each i", is that it is counter-intuitive from a linear algebra point of view. You would rather expect v**2 = v*v. Now another snag is should "*" be the dot or the cross product ?...

These kind of things are thought-out carefully before landing into an Ada standard...

G.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Nasser M. Abbasi]

On 7/10/2012 3:02 AM, gautier.de.montmollin@gmail.com wrote:
> Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a �crit :
>
>> Believe me, for someone who do numerical computations on a daily basis, an operation
>like V**2 is a NECESSITY. It's a pity that Ada does not offer such a facility.
>I do not blame those who stick to Matlab (or Fortran?) for doing numerical computations.
>
> Wait... There are *such* facilities and several built-in operations *like* that:
> http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html
>
> Apparently it is not enough. But it is possible to make a proposal for
>  the next standard (and short term for the next GNAT version).
>

That is a start. But not enough by any means. All functions should be
vectorized. Even user defined ones.

In Ada, I can't even take the sin of a vector

----------------------
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;

procedure foo3 is
   type array_t is array(1..5) OF float;
   D : constant array_t :=(0.1,0.2,0.3,0.4,0.5);
   V : array_t;
   
   begin
     -- V := sin(D);  -- ERROR

     for I in D'Range loop  -- must use a LOOP
         V(I) := sin(D(I));
     end loop;
        
end foo3;
--------------------

I can ofcourse overload sin, hide the loop inside my own sine
and then do

    V:= myPackage.sin(D);

All of this is possible in Ada. It is just a little (alot?)
more effort compared to what is out there.

octave/Matlab:
--------------------------
D=[0.1,0.2,0.3,0.4,0.5];
sin(D)

ans =
     0.0998    0.1987    0.2955    0.3894    0.4794
---------------------------

> The snag with that *specific* operation, v**2 meaning "v(i)**2 for each i",
>is that it is counter-intuitive from a linear algebra point of view. You
>would rather expect v**2 = v*v. Now another snag is should "*" be the
>dot or the cross product ?...
>
> These kind of things are thought-out carefully before landing into an Ada standard...
>

But these issue have been solved long time time. (like maybe
30 years ago? and are well defined for all cases:

http://www.mathworks.com/help/techdoc/ref/arithmeticoperators.html

There are element-wise operators, and operators that work
on the whole vector or matrix.

In octave/Matlab world, V.^2 means element-wise. (notice
the ".")

-------------------------
octave:3> V=[1 2 3 4];
octave:4> v.^2
ans =

     1    4    9   16
--------------------------

Otherwise, it becomes standard matrix operation.
A^2 means A*A

------------------------
octave:17> A=[1 2;3 4]
A =
    1   2
    3   4

octave:18> A^2
ans =
     7   10
    15   22

octave:19> A*A
ans =
     7   10
    15   22
---------------------

To do dot product, it has its own operator, called dot() !

----------------------
octave:5> dot(V,V)
ans =  30
-------------------------

To do cross product, it has its own operator, called cross() !

-----------------------
octave:9> D=[1 2 3]; V=[3 4 5]; cross(D,V)
ans =

   -2   4  -2
-------------------

btw, in Mathematica, it is the other way around. V*V does
element by element multiplication, and V.V does matrix product.
It has also Dot[] and Cross[] and all functions are vectorized,
and all user defined functions can be vectorized by simply
giving them the attribute Listable.

--Nasser

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Ada novice]

On Tuesday, July 10, 2012 9:39:58 AM UTC+1, Nasser M. Abbasi wrote:

> That is a start. But not enough by any means. All functions should be
> vectorized. Even user defined ones.
> 

Good examples to illustrate what other mathematical languages offer and what people doing calculations may be / are missing daily with Ada. 

Let's hope for some changes in this respect in the next Ada standard.


YC

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Tue, 10 Jul 2012 03:39:58 -0500, Nasser M. Abbasi wrote:

> That is a start. But not enough by any means. All functions should be
> vectorized.

It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
exponents or exponent matrix? To me it is the second. A similar example for
vectors: abs V. Is it a vector of absolute values, or maybe ||V||?

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Nasser M. Abbasi]

On 7/10/2012 4:07 AM, Dmitry A. Kazakov wrote:
> On Tue, 10 Jul 2012 03:39:58 -0500, Nasser M. Abbasi wrote:
>
>> That is a start. But not enough by any means. All functions should be
>> vectorized.
>
> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
> exponents or exponent matrix?

Solved:

-----------------------
octave:21> exp(A)
ans =

     2.7183    7.3891
    20.0855   54.5982

octave:22> expm(A)
ans =

     51.969    74.737
    112.105   164.074
-----------------------------

>To me it is the second.

It is simply the way it is defined.

Just like when I read a paper, I first look for the definitions
of symbols and terms used by the author. one does not have to
guess. Everything is defined. To do these in Ada, Ada will
define them as it wishes. As long as there are there, and
well defined, no one will complain. All of these issue have
been solved in many other languages.

>A similar example for
> vectors: abs V. Is it a vector of absolute values, or maybe ||V||?
>

Also defined.

-------------------------------
octave:23> A=rand(3,1)
A =
    0.45896
    0.61557
    0.26697

octave:24> abs(V)
ans =
    3   4   5

octave:25> norm(V)
ans =  7.0711
-------------------------

--Nasser

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Nasser M. Abbasi]

On 7/10/2012 4:21 AM, Nasser M. Abbasi wrote:

> -------------------------------
> octave:23> A=rand(3,1)
> A =
>      0.45896
>      0.61557
>      0.26697
>
> octave:24> abs(V)
> ans =
>      3   4   5
>
> octave:25> norm(V)
> ans =  7.0711
> -------------------------

meant to use A, not v above ofcourse:

----------------------
octave:26> abs(A)
ans =
    0.45896
    0.61557
    0.26697

octave:27> norm(A)
ans =  0.81293
----------------------

--Nasser

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Tue, 10 Jul 2012 04:21:17 -0500, Nasser M. Abbasi wrote:

> On 7/10/2012 4:07 AM, Dmitry A. Kazakov wrote:
>> On Tue, 10 Jul 2012 03:39:58 -0500, Nasser M. Abbasi wrote:
>>
>>> That is a start. But not enough by any means. All functions should be
>>> vectorized.
>>
>> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
>> exponents or exponent matrix?

[...]

> Just like when I read a paper, I first look for the definitions
> of symbols and terms used by the author.

Exactly. This is how you define it, it is not how LaTeX or TeX does. Since
there is no unambiguous semantics of f(), the language shall not introduce
them.

If you want scalar f() to apply to a matrix in some certain way, just
define that in Ada. You can even do it in generic way:

1. Using generics:

generic
   with function Scalar_F (X : Float) return Float;
function Generic_Vector_F (X : Vector) return Vector;

function Generic_Vector_F (X : Vector) return Vector is
begin
   return Result : Vector (X'Range) do
      for I in X'Range loop
         Result (I) := Scalar_F (X (I));
      end loop;
   end return;
end Generic_Vector_F;
 
function Sin is new Generic_Vector_F (Sin);
function Cos is new Generic_Vector_F (Cos);
...
-------------------------------------------------------------
2. Using functional composition:

function "*"
   (  F : not null access function (X : Float) return Float;
      X : Vector
   )  return Vector is
begin
   return Result : Vector (X'Range) do
      for I in X'Range loop
         Result (I) := F (X (I));
      end loop;
   end return;
end "*";

Used as:

sin'Access * V  -- Applies sin to V

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Simon Wright]

"Nasser M. Abbasi" <nma@12000.org> writes:

> In Fortran, I can just write V**2, where V is a vector. In Ada, I
> can't do that. Since ** is not defined on this array type and this
> number type.
>
> I would have to write a loop to iterate over V and do V(I)**2 on each
> element.
>
> This for me, is a step backward. This is how Fortran77 was.
>
> I know I am a newbie in Ada, and I could have overlooked a simple
> solution to do this. But I really do not want to write packages and
> define operators each time and for each type I make to have it work as
> elemental function each time.
>
> This is something that should be build into the language.

The relevant AI is, I think, AI95-00296[1]. The !discussion says that

   "The component by component operations of * / and ** on vectors have
   been deleted [from ISO/IEC 13813] on the grounds that they are not
   useful. (They might be useful for manipulating arrays in general but
   we are concerned with arrays used as vectors for linear algebra.)

   "Operations for vector products were considered but not added. This
   is because, as usually defined, they only apply in three-dimensional
   space."

GNAT would allow you to implement them fairly easily using
System.Generic_Array_Operations (which is a GNAT internal package that
survived the transition to GNAT GPL 2012!).

You could make the case that they are in fact useful and should be
incorporated, but of course that won't happen until the 202x revision.

[1] http://www.ada-auth.org/cgi-bin/cvsweb.cgi/ais/ai-00296.txt?rev=1.23

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Georg Bauhaus]

On 10.07.12 01:27, Nasser M. Abbasi wrote:
> In Fortran, I can just write V**2, where V is a vector. In Ada,
> I can't do that. Since ** is not defined on this array type
> and this number type.

As Gautier pointed out, a general purpose language must be better
than convenient for some. What the convenient operations might offer
to a small niche of science is not good enough, even when one
personally considers them important.

You mentioned operations on vectors. Mine would include
operations like

- manipulate only values of a vector at certain indices,
  or produce a result from some components only,
  fold style, or something even more involved.

Such as: Make all negative values 0.0.

It is possible to do this using array operations and has been ever
since APL (late 1960s), and R, and others, by composing functions.
But APL programmers and others have explained that there is
only a slight chance that composed operations will be efficient
since many results will be computed needlessly, wasting real time
and real memory. If efficiency is a concern, one might have to
dismiss such designs of inefficient computations. This is s first
trade-off.

For the above computation, then, I might need some kind of loop,
be it expressed as a simple loop, or as a clever, if intricate,
tail recursive function. This is easily done using languages
Ada, or Fortran, or C++, language that, incidentally, are used
to write advanced mathematician's (or physicist's) calculators
like Octave. The languages enable methods of controlling the
operational aspects of an algorithm that vector operators will
by definition take out of the hands of programmers.

When writing Ada, I will expect to be able to look at the
constituent parts of a computation. For example, my program might
need to decide whether or not a computation can continue, at least
for parts of the vector, when one component has an unusable
intermediate result. For example,

   Sum (V);  --  V = Vector'(1.2, 3.4, broken, ..., 11.12);

If programmers should be able to attach their code between the
steps that operators perform (be they in parallel or in sequence),
then I imagine a library based "operator" could at least be made
very flexible. Still, compilers could select more optimal
alternatives where possible.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Brian Drummond]

On Mon, 09 Jul 2012 18:27:54 -0500, Nasser M. Abbasi wrote:

On Mon, 09 Jul 2012 18:27:54 -0500, Nasser M. Abbasi wrote:

> The most important feature which I found missing is that Ada functions
> do not automatically work on arrays and matrices.

Everyone moving from a domain-specific language to a general one will have
a "most important missing feature".

> In Fortran, I can just write V**2, where V is a vector. In Ada,
> I can't do that. Since ** is not defined on this array type and this
> number type.
> 
> ... I really do not want to write packages and
> define operators each time and for each type I make to have it work as
> elemental function each time.
> 
> This is something that should be build into the language.

No, it is something that can be added to the language where necessary, 
with the minimum of wasted effort.

For example, write ONCE, a generic ** function, which you can instantiate 
with any (numeric!) array type.

Now a package of such generic functions, extending
Numerics.Generic_Real_Arrays, might be a useful addition to Ada.

O course it would have to be clear from the package documentation which of
the possible meanings of "**" was implemented. You might want separate
packages implementing element_wise operators or array operators.

Or you may want different ad-hoc operator symbols, like "^" or ".^" in
your Octave examples, to distinguish the different meanings. (But in your
examples, even the domain-specific languages can't agree to use the same
symbols!)

This would be one use case for my recent proposal to allow user-
defined operator symbols in a future Ada. Given a few restrictions, (e.g.
on operator precedence) it looked like a relatively harmless addition to 
Ada, and fairly general in application (not specific to one domain).

- Brian

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Brian Drummond]

On Tue, 10 Jul 2012 01:02:13 -0700, gautier.de.montmollin wrote:

> Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a écrit :
> 
>> Believe me, for someone who do numerical computations on a daily basis,
>> an operation like V**2 is a NECESSITY. It's a pity that Ada does
>> not offer such a facility. I do not blame those who stick to Matlab (or
>> Fortran?) for doing numerical computations.
> 
> Wait... There are *such* facilities and several built-in operations
> *like* that:
> http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html
> 
> Apparently it is not enough. But it is possible to make a proposal for
> the next standard (and short term for the next GNAT version).

Furthermore, they are not really "built-in", so there is no need to go 
back to the standards authority if you feel they are lacking. The source 
for Ada.Numerics.Generic_Real_Array is right there, and contains no magic.

Adding "**" to suit your own purposes should be no more complicated than
the implementation of "+" in Ada.Numerics.Generic_Real_Array.

So, how does that work?

Ada.Numerics.Generic_Real_Array is found (on my machine) at
/usr/lib/gcc/i586-suse-linux/4.6/adainclude/a-ngrear.ads (specification) 
and /usr/lib/gcc/i586-suse-linux/4.6/adainclude/a-ngrear.adb (body)

The specification is
   function "+"   (Right : Real_Vector)       return Real_Vector;
...
   pragma Inline_Always ("+");

The body - you might expect a loop , performing addition on each element.
Well, not quite...

----------------------------------------------------------------------
with System.Generic_Array_Operations; use System.Generic_Array_Operations;

...
   --  Instantiating the following subprograms directly would lead to
   --  name clashes, so use a local package.

   package Instantiations is
...
      function "+" is new
        Vector_Vector_Elementwise_Operation
          (Left_Scalar   => Real'Base,
           Right_Scalar  => Real'Base,
           Result_Scalar => Real'Base,
           Left_Vector   => Real_Vector,
           Right_Vector  => Real_Vector,
           Result_Vector => Real_Vector,
           Operation     => "+");
...
   end Instantiations;

   function "+" (Left, Right : Real_Vector) return Real_Vector
      renames Instantiations."+";

----------------------------------------------------------------------

So it uses a generic function from System.Generic_Array_Operations to 
loop over the vector, applying the Operation argument to each element.

And this generic function is available for you to use in the same manner.
(There are similar ones for unary operations like sin(), and others for 
2D matrix operations, etc)

So you can create a package along the same lines, and add **, sin, etc to 
it. Once you have the package in place, adding more matrix operations of 
your own is trivial.

What does this generic function look like?
Excerpt from System.Generic_Array_Operations - on this system, at
/usr/lib/gcc/i586-suse-linux/4.6/adainclude/s-gearop.ads(specification)
--------------------------------
   generic
      type Left_Scalar is private;
      type Right_Scalar is private;
      type Result_Scalar is private;
      type Left_Vector is array (Integer range <>) of Left_Scalar;
      type Right_Vector is array (Integer range <>) of Right_Scalar;
      type Result_Vector is array (Integer range <>) of Result_Scalar;
      with function Operation
             (Left  : Left_Scalar;
              Right : Right_Scalar) return Result_Scalar;
   function Vector_Vector_Elementwise_Operation
     (Left  : Left_Vector;
      Right : Right_Vector) return Result_Vector;
--------------------------------
which should be enough information to let you use it...

If you are curious about its implementation, look at
/usr/lib/gcc/i586-suse-linux/4.6/adainclude/s-gearop.adb (body)
--------------------------------
   -----------------------------------------
   -- Vector_Vector_Elementwise_Operation --
   -----------------------------------------

   function Vector_Vector_Elementwise_Operation
     (Left  : Left_Vector;
      Right : Right_Vector) return Result_Vector
   is
      R : Result_Vector (Left'Range);

   begin
      if Left'Length /= Right'Length then
         raise Constraint_Error with
            "vectors are of different length in elementwise operation";
      end if;

      for J in R'Range loop
         R (J) := Operation (Left (J), Right (J - R'First + Right'First));
      end loop;

      return R;
   end Vector_Vector_Elementwise_Operation;
--------------------------------
which is of course the expected loop, plus a sanity check.

- Brian

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Marco]

On Monday, July 9, 2012 9:22:59 PM UTC-7, Nasser M. Abbasi wrote:

> 
> There is only one Fortran ISO standard, just like with Ada.
> 
> http://gcc.gnu.org/wiki/GFortranStandards

 That is not reality based. When a language standard is published there will effectively be code bases around that need to conform to that older standard and compilers need to be able to handle that. For example, the Intel Fortran compiler deals nicely with existing F77 code mixed with newer F90 and later.

Just because the Ada 2012 standard exists does not mean 100% of the Ada community will adopt it today or even tomorrow.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Ada novice]

On Tuesday, July 10, 2012 12:27:54 AM UTC+1, Nasser M. Abbasi wrote:
> I have been trying Ada to see how suitable it is for computational
> work (I am studying finite elements, and wanted to try Ada for
> basic programs).


In finite element formulations, one will usually end up with sparse matrices. I do not know whether Ada has support for such matrices. Matlab for instance has dedicated solver(s) for the system Ax=b when A is a sparse matrix. I think beside storage consideration, sparse matrices solvers are faster (I can be wrong though).

There was a discussion in one posts on CLA here some two years back about sparse matrices. Forgotten which thread it was though.

YC 

Re: Does Ada need elemental functions to make it suitable for scientific work?

[gautier_niouzes]

Ada novice :

> In finite element formulations, one will usually end up with sparse matrices. I do not know whether Ada has support for such matrices. Matlab for instance has dedicated solver(s) for the system Ax=b when A is a sparse matrix. I think beside storage consideration, sparse matrices solvers are faster (I can be wrong though).

They are fast but it all depends on the problem and the conditioning of the matrix. Sometimes you are also well served by band matrices and a good algorithm to rearrange the node numbering so that nodes that are close in the mesh end up with close indices and then the matrix has fewer non-zero diagonal bands around the main diagonal.
Choice of solvers for sparse matrices are limited - because they need to. e.g. a LU decomposition would require to know where are the non-zeros for having L and U stored as sparse matrices. And probably they are not sparse at all...

You find a sparse matrix package and appropriate solvers in Mathpaqs pack there:
  http://sf.net/projects/mathpaqs/
______________________________________________________________________________
Gautier's Ada programming -- http://gautiersblog.blogspot.com/search/label/Ada 
NB: follow the above link for a valid e-mail address

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Ken Thomas]

On Wednesday, July 11, 2012 9:41:50 AM UTC+1, (unknown) wrote:
> Ada novice :
> 
> > In finite element formulations, one will usually end up with sparse matrices. I do not know whether Ada has support for such matrices. Matlab for instance has dedicated solver(s) for the system Ax=b when A is a sparse matrix. I think beside storage consideration, sparse matrices solvers are faster (I can be wrong though).
> 
> They are fast but it all depends on the problem and the conditioning of the matrix. Sometimes you are also well served by band matrices and a good algorithm to rearrange the node numbering so that nodes that are close in the mesh end up with close indices and then the matrix has fewer non-zero diagonal bands around the main diagonal.
> Choice of solvers for sparse matrices are limited - because they need to. e.g. a LU decomposition would require to know where are the non-zeros for having L and U stored as sparse matrices. And probably they are not sparse at all...
> 
> You find a sparse matrix package and appropriate solvers in Mathpaqs pack there:
>   http://sf.net/projects/mathpaqs/
> ______________________________________________________________________________
> Gautier's Ada programming -- http://gautiersblog.blogspot.com/search/label/Ada 
> NB: follow the above link for a valid e-mail address

I have written finite element codes in Ada2005 and sparse matrices are essential. Without these only small toy problems are possible. There are several  stages in the method:

Given a FEM mesh, assemble mass and stiffness  matrices. The matrix structure is unknown so I used an instantiation of Ada.Containers.Ordered_Maps. The Key_Type is the indices and the Element_Type a Real type. The ordering function can give row or column ordering.

The next stage is the linear algebra; both linear equations and eigenvalues are important. The choices are direct solvers for example http://www.cise.ufl.edu/research/sparse/umfpack
or iterative solvers. Writing direct solvers is very difficult (I have tried) and the best advice is to obtain or write bindings to some of the codes.

For iterative solvers, you will need good preconditioning. 

Ken

Re: Does Ada need elemental functions to make it suitable for scientific work?

[robin.vowels]

On Tuesday, 10 July 2012 18:39:58 UTC+10, Nasser M. Abbasi  wrote:
> On 7/10/2012 3:02 AM, gautier.de...@gmail.com wrote:
> > Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a écrit :
> >
> >> Believe me, for someone who do numerical computations on a daily basis, an operation
> >like V**2 is a NECESSITY. It's a pity that Ada does not offer such a facility.
> >I do not blame those who stick to Matlab (or Fortran?) for doing numerical computations.
> >
> > Wait... There are *such* facilities and several built-in operations *like* that:
> > http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html
> >
> > Apparently it is not enough. But it is possible to make a proposal for
> >  the next standard (and short term for the next GNAT version).
> >
> 
> That is a start. But not enough by any means. All functions should be
> vectorized. Even user defined ones.
> 
> In Ada, I can't even take the sin of a vector

But you can in PL/I.

> ----------------------
> with Ada.Numerics.Elementary_Functions;
> use Ada.Numerics.Elementary_Functions;
> 
> procedure foo3 is
>    type array_t is array(1..5) OF float;
>    D : constant array_t :=(0.1,0.2,0.3,0.4,0.5);
>    V : array_t;
>    
>    begin
>      -- V := sin(D);  -- ERROR
> 
>      for I in D'Range loop  -- must use a LOOP
>          V(I) := sin(D(I));
>      end loop;
>         
> end foo3;
> --------------------
> 
> I can ofcourse overload sin, hide the loop inside my own sine
> and then do
> 
>     V:= myPackage.sin(D);
> 
> All of this is possible in Ada. It is just a little (alot?)
> more effort compared to what is out there.
> 
> octave/Matlab:
> --------------------------
> D=[0.1,0.2,0.3,0.4,0.5];
> sin(D)
> 
> ans =
>      0.0998    0.1987    0.2955    0.3894    0.4794
> ---------------------------

and PL/I.

> > The snag with that *specific* operation, v**2 meaning "v(i)**2 for each i",
> >is that it is counter-intuitive from a linear algebra point of view. You
> >would rather expect v**2 = v*v. Now another snag is should "*" be the
> >dot or the cross product ?...
> >
> > These kind of things are thought-out carefully before landing into an Ada standard...
> >
> 
> But these issue have been solved long time time. (like maybe
> 30 years ago? and are well defined for all cases:

More like 45 years ago,
for PL/I has had that facility since 1966.

For vectors, matrices (in fact multi-dimensional arrays),
and for cross-sections of arrays.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[robin.vowels]

On Tuesday, 10 July 2012 19:07:05 UTC+10, Dmitry A. Kazakov  wrote:
> On Tue, 10 Jul 2012 03:39:58 -0500, Nasser M. Abbasi wrote:
> 
> > That is a start. But not enough by any means. All functions should be
> > vectorized.
> 
> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
> exponents or exponent matrix?

In languages that provide whole array operations (i.e.,
element-by-element operations -- such as PL/I and Fortran),
it is the former.

BTW., I think you mean matrix exponential, which is a far
less common operation than exp(A) or e**A(i) for i = 1 to n,
and would be written MATRIX_EXPONENTIAL or some such,
just as matrix multiplication would be written MATRIX_MULT
or some such, to distinguish it from the more common
element-by-element product.

> To me it is the second. A similar example for
> vectors: abs V. Is it a vector of absolute values, or maybe ||V||?

For element-by-element operations, it means the first,
as in PL/I and Fortran.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Wed, 11 Jul 2012 17:31:33 -0700 (PDT), robin.vowels@gmail.com wrote:

>> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
>> exponents or exponent matrix?
> 
> In languages that provide whole array operations (i.e.,
> element-by-element operations -- such as PL/I and Fortran),
> it is the former.
> 
> BTW., I think you mean matrix exponential, which is a far
> less common operation than exp(A) or e**A(i) for i = 1 to n,

In linear algebra, provided matrices mean matrices, per-element operation
just does not make any sense. Exp(A), as well as power series are fairly
common in spectral analysis.

> and would be written MATRIX_EXPONENTIAL or some such,
> just as matrix multiplication would be written MATRIX_MULT
> or some such, to distinguish it from the more common
> element-by-element product.

My FORTRAN and PL/1 are quite rusty, but even these incredibly poor
languages did not define multiplication for matrices that way. In fact they
just had no matrices last time I used either.

I remember one library for sparse matrices in FORTRAN-IV, doing LU
decomposition and other stuff. It was quite fun. The library was in fact
very well-designed, but since FORTRAN-IV lacked even elementary data types,
they did all memory management required using INTEGER*4 as an index in one
huge REAL*4 array, serving as a memory pool.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3093 bytes --]

"Nasser M. Abbasi" <nma@12000.org> wrote in message 
news:jtgpos$20g$2@speranza.aioe.org...
> On 7/10/2012 3:02 AM, gautier.de.montmollin@gmail.com wrote:
>> Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a �crit :
>>
>>> Believe me, for someone who do numerical computations on a daily basis, 
>>> an operation
>>like V**2 is a NECESSITY. It&#39;s a pity that Ada does not offer such a 
>>facility.
>>I do not blame those who stick to Matlab (or Fortran?) for doing numerical 
>>computations.
>>
>> Wait... There are *such* facilities and several built-in operations 
>> *like* that:
>> http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html
>>
>> Apparently it is not enough. But it is possible to make a proposal for
>>  the next standard (and short term for the next GNAT version).
>>
>
> That is a start. But not enough by any means. All functions should be
> vectorized. Even user defined ones.

That would be a complete change in philosophy for Ada. The expectation is 
that everything that can reasonably be done in libraries will be done that 
way. Note that Ada didn't add advanced containers directly in the syntax.

It might be reasonable to propose to add additional operators to the Ada 
language to make this more possible. We did look at that for Ada 2005 and 
decided not to do it, mainly because most of the interesting operators are 
not unary or binary. (Think integration and differentiation.)

> In Ada, I can't even take the sin of a vector

Of course you can, with a trivial loop.

     for E of Vect loop
           E := Sin(E);
     end loop;

And this has the distinct advantage of making it clear to other readers what 
it is that you are doing.

> ----------------------
> with Ada.Numerics.Elementary_Functions;
> use Ada.Numerics.Elementary_Functions;
>
> procedure foo3 is
>   type array_t is array(1..5) OF float;
>   D : constant array_t :=(0.1,0.2,0.3,0.4,0.5);
>   V : array_t;
>   begin
>     -- V := sin(D);  -- ERROR
>
>     for I in D'Range loop  -- must use a LOOP
>         V(I) := sin(D(I));
>     end loop;
>        end foo3;
> --------------------
>
> I can ofcourse overload sin, hide the loop inside my own sine
> and then do
>
>    V:= myPackage.sin(D);
>
> All of this is possible in Ada.

Right. And this is what you are supposed to do.

Note that in any case the Sin you are calling is not specially known to the 
compiler, so there is no benefit to having the compiler vectorize it: it 
will end up writing the loop anyway. (And hardware implementations of Sin 
generally do not meet Ada's checking and accuracy requirements, so it's hard 
to use them even if the compiler could recognize them.)

> It is just a little (alot?) more effort compared to what is out there.

Writing functions is what you do in Ada. And Ada is always about 
readability, including for those who aren't familar with your code.

Things like Matlab have a very different purpose than Ada and of course are 
going to be easier to write. Ease of writing is not now and never will be a 
goal for Ada!

                                            Randy.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Randy Brukardt]

"Nasser M. Abbasi" <nma@12000.org> wrote in message 
news:jtgs6g$833$1@speranza.aioe.org...
...
> Just like when I read a paper, I first look for the definitions
> of symbols and terms used by the author. one does not have to
> guess. Everything is defined. To do these in Ada, Ada will
> define them as it wishes. As long as there are there, and
> well defined, no one will complain. All of these issue have
> been solved in many other languages.

We try very hard in Ada not to define things that will be confusing to 
casual readers. If you have to look up the definition of how something works 
in Ada, we've pretty much failed that.

For instance, there has been a long controversy about using unary "+" as a 
short-hand conversion operator. That was it's original intent, but efforts 
to add such operators to packages like Ada.Strings.Unbounded have failed 
mainly because some people think that the usage
     Unb_String := +"string";
would be confusing to casual Ada users. (It's common in my code, but I have 
to define the "+" myself.)

So it's not at all clear that the sort of operators you are suggesting are a 
good idea.

                                                 Randy.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Adam Beneschan]

On Thursday, July 19, 2012 6:56:20 PM UTC-7, Randy Brukardt wrote:

> 
> For instance, there has been a long controversy about using unary "+" as a 
> short-hand conversion operator. That was its original intent

It was?  Interesting.  I thought it was just there for "completeness" and because other languages did the same thing--specifically, I think Pascal and Algol have unary *non-overloadable* "+" operators that don't really serve any purpose except for mathematical types to put into their alternating Taylor series computations or something:

   if mod(N,2) = 0 then Term := +(X**2)/Factorial(N)
                   else Term := -(X**2)/Factorial(N);

But my memory about those other languages could be wrong.  Anyway, if overloading was the reason unary "+" was kept in Ada 83, that's an interesting fact I wouldn't have guessed. 

                          -- Adam

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Robin Vowels]

On Jul 12, 5:12 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Wed, 11 Jul 2012 17:31:33 -0700 (PDT), rrrrrrr@gmail.com wrote:
> >> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
> >> exponents or exponent matrix?
>
> > In languages that provide whole array operations (i.e.,
> > element-by-element operations -- such as PL/I and Fortran),
> > it is the former.
>
> > BTW., I think you mean matrix exponential, which is a far
> > less common operation than exp(A) or e**A(i) for i = 1 to n,
>
> In linear algebra, provided matrices mean matrices, per-element operation
> just does not make any sense.

Element-by-element operations are required routinely in numerical
work.  They have been demanded and have been available since
at least 1955.

> Exp(A), as well as power series are fairly
> common in spectral analysis.
>
> > and would be written MATRIX_EXPONENTIAL or some such,
> > just as matrix multiplication would be written MATRIX_MULT
> > or some such, to distinguish it from the more common
> > element-by-element product.
>
> My FORTRAN and PL/1 are quite rusty, but even these incredibly poor
> languages did not define multiplication for matrices that way.

PL/I defined multiplication for matrices as an element-by-element
product, as I said before.
Back then, FORTRAN did not offer such operations on matrices,
however it now does, and has done so since Fortran 90.

> In fact they
> just had no matrices last time I used either.

Back then, both PL/I and FORTRAN offered matrices (and still do).
For that matter, both offered multi-dimensional arrays (and still do).

> I remember one library for sparse matrices in FORTRAN-IV, doing LU
> decomposition and other stuff. It was quite fun. The library was in fact
> very well-designed, but since FORTRAN-IV lacked even elementary data types,

FORTRAN always has had elementary data types.

> they did all memory management required using INTEGER*4 as an index in one
> huge REAL*4 array, serving as a memory pool.

That's because FORTRAN IV did not have dynamic arrays.
PL/I did, of course, from the first compilers in c. 1966.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Robin Vowels]

On Jul 20, 11:51 am, "Randy Brukardt" <ra...@rrsoftware.com> wrote:
> "Nasser M. Abbasi" <n...@12000.org> wrote in messagenews:jtgpos$20g$2@speranza.aioe.org...
>
>
>
>
>
>
>
>
>
> > On 7/10/2012 3:02 AM, gautier.de.montmol...@gmail.com wrote:
> >> Le mardi 10 juillet 2012 07:22:58 UTC+2, Ada novice a crit :
>
> >>> Believe me, for someone who do numerical computations on a daily basis,
> >>> an operation
> >>like V**2 is a NECESSITY. It&#39;s a pity that Ada does not offer such a
> >>facility.
> >>I do not blame those who stick to Matlab (or Fortran?) for doing numerical
> >>computations.
>
> >> Wait... There are *such* facilities and several built-in operations
> >> *like* that:
> >>http://www.ada-auth.org/standards/12rm/html/RM-G-3-1.html
>
> >> Apparently it is not enough. But it is possible to make a proposal for
> >>  the next standard (and short term for the next GNAT version).
>
> > That is a start. But not enough by any means. All functions should be
> > vectorized. Even user defined ones.
>
> That would be a complete change in philosophy for Ada. The expectation is
> that everything that can reasonably be done in libraries will be done that
> way. Note that Ada didn't add advanced containers directly in the syntax.
>
> It might be reasonable to propose to add additional operators to the Ada
> language to make this more possible. We did look at that for Ada 2005 and
> decided not to do it, mainly because most of the interesting operators are
> not unary or binary. (Think integration and differentiation.)
>
> > In Ada, I can't even take the sin of a vector
>
> Of course you can, with a trivial loop.
>
>      for E of Vect loop
>            E := Sin(E);
>      end loop;

Somewhat long-winded, wouldn't you say, when in Fortran and PL/I
you can write it as
E = sin(E);

> And this has the distinct advantage of making it clear to other readers what
> it is that you are doing.

No, it obfuscates what is happening.
It is as verbose as the old-fashioned way of writing a loop:
do i = 1, n;
   E(i) = sin(E(i))
end do
end the equivalent in PL/I.

> Note that in any case the Sin you are calling is not specially known to the
> compiler,

but in PL/I and Fortran it is.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Sun, 29 Jul 2012 06:39:58 -0700 (PDT), Robin Vowels wrote:

> On Jul 12, 5:12�pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>> On Wed, 11 Jul 2012 17:31:33 -0700 (PDT), rrrrrrr@gmail.com wrote:
>>>> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
>>>> exponents or exponent matrix?
>>
>>> In languages that provide whole array operations (i.e.,
>>> element-by-element operations -- such as PL/I and Fortran),
>>> it is the former.
>>
>>> BTW., I think you mean matrix exponential, which is a far
>>> less common operation than exp(A) or e**A(i) for i = 1 to n,
>>
>> In linear algebra, provided matrices mean matrices, per-element operation
>> just does not make any sense.
> 
> Element-by-element operations are required routinely in numerical
> work.

I wrote specifically about matrices as known in linear algebra.

> PL/I defined multiplication for matrices as an element-by-element
> product, as I said before.

Sorry for PL/1!

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[J-P. Rosen]

Le 29/07/2012 15:53, Robin Vowels a �crit :
>> Note that in any case the Sin you are calling is not specially known to the
>> > compiler,
> but in PL/I and Fortran it is.
Which implies that you can work only with predefined types.

One of the great benefits of Ada (for floating point types) is the
ability to chose accurracy and range, and let the compiler find the
appropriate underlying hardware type. Most machines have more than float
and double!

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Dmitry A. Kazakov]

On Sun, 29 Jul 2012 17:51:25 +0200, J-P. Rosen wrote:

> One of the great benefits of Ada (for floating point types) is the
> ability to chose accurracy and range, and let the compiler find the
> appropriate underlying hardware type. Most machines have more than float
> and double!

Which advantage gets lost when external numeric libraries are used.

Let us hope that growing interest in scientific computations in Ada will
result in natively Ada numeric libraries to appear.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Simon Wright]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Sun, 29 Jul 2012 17:51:25 +0200, J-P. Rosen wrote:
>
>> One of the great benefits of Ada (for floating point types) is the
>> ability to chose accurracy and range, and let the compiler find the
>> appropriate underlying hardware type. Most machines have more than float
>> and double!

ix86's have 80-bit floats (GNAT's Long_Long_Float); what other
commonly-available extended hardware precisions are there?

> Which advantage gets lost when external numeric libraries are used.

I believe that BLAS & possibly LAPACK can be built for extended
precision. But (usually) aren't.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[glen herrmannsfeldt]

In comp.lang.pl1 Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:

(snip, someone wrote)
>>>>> It is ill-defined. E.g. exp(A), where A is a matrix. 
>>>>> Is exp(A) a matrix of exponents or exponent matrix?

I can see a general purpose (more or less) high-level languages
offering a matrix multiply operator, but this seems a little
less common.

The only language I know of that offers matrix multiply and
not element-by-element multiply is BASIC.

>>>> In languages that provide whole array operations (i.e.,
>>>> element-by-element operations -- such as PL/I and Fortran),
>>>> it is the former.

Fortran now has the MATMUL intrinsic to do matrix multiplication.
The * operator does element by element multiply.

One could ask for a MATEXP intrinsic, though it isn't likely
to be added soon.

-- glen

Re: Does Ada need elemental functions to make it suitable for scientific work?

[glen herrmannsfeldt]

In comp.lang.pl1 Simon Wright <simon@pushface.org> wrote:

(snip)
> ix86's have 80-bit floats (GNAT's Long_Long_Float); what other
> commonly-available extended hardware precisions are there?

IBM S/370 and successors (now z/Architecture), and VAX have a 128
bit floating point type. The hardware instructions might be
done by software emulation for VAX. For S/370, DXR (divide) was
done in software, but sometime in ESA/390 was added to the
architecture.

>> Which advantage gets lost when external numeric libraries are used.

> I believe that BLAS & possibly LAPACK can be built for extended
> precision. But (usually) aren't.

Many routines have to be modified for higher precision, such
as more coefficients for polynomial expansions. It can be done,
but often isn't.

-- glen

Re: Does Ada need elemental functions to make it suitable for scientific work?

[J-P. Rosen]

Le 29/07/2012 22:30, Simon Wright a �crit :
> ix86's have 80-bit floats (GNAT's Long_Long_Float); what other
> commonly-available extended hardware precisions are there?
Lots of them. See for example http://mrob.com/pub/math/floatformats.html


-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Simon Wright]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Le 29/07/2012 22:30, Simon Wright a écrit :
>> ix86's have 80-bit floats (GNAT's Long_Long_Float); what other
>> commonly-available extended hardware precisions are there?
> Lots of them. See for example http://mrob.com/pub/math/floatformats.html

Yes, but - *commonly-available*. And I think we can omit the ones used
in calculators.

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Robin Vowels]

On Jul 30, 12:22 am, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Sun, 29 Jul 2012 06:39:58 -0700 (PDT), Robin Vowels wrote:
> > On Jul 12, 5:12 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> > wrote:
> >> On Wed, 11 Jul 2012 17:31:33 -0700 (PDT), rrrr...@gmail.com wrote:
> >>>> It is ill-defined. E.g. exp(A), where A is a matrix. Is exp(A) a matrix of
> >>>> exponents or exponent matrix?
>
> >>> In languages that provide whole array operations (i.e.,
> >>> element-by-element operations -- such as PL/I and Fortran),
> >>> it is the former.
>
> >>> BTW., I think you mean matrix exponential, which is a far
> >>> less common operation than exp(A) or e**A(i) for i = 1 to n,
>
> >> In linear algebra, provided matrices mean matrices, per-element operation
> >> just does not make any sense.
>
> > Element-by-element operations are required routinely in numerical
> > work.
>
> I wrote specifically about matrices as known in linear algebra.
>
> > PL/I defined multiplication for matrices as an element-by-element
> > product, as I said before.
>
> Sorry for PL/1!

Nothing to be sorry about.
Trivial to use from the PL/I library or to write.

Term-by-term multiplication is the more often used
(along with term-by-term add, subtract, and divide).

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Robin Vowels]

On Jul 30, 1:51 am, "J-P. Rosen" <ro...@adalog.fr> wrote:
> Le 29/07/2012 15:53, Robin Vowels a écrit :>> Note that in any case the Sin you are calling is not specially known to the
> >> > compiler,
> > but in PL/I and Fortran it is.
>
> Which implies that you can work only with predefined types.
>
> One of the great benefits of Ada (for floating point types) is the
> ability to chose accurracy and range,

Which we can do in PL/I and Fortran.

> and let the compiler find the
> appropriate underlying hardware type.

Which is what happens with PL/I.

> Most machines have more than float and double!

Re: Does Ada need elemental functions to make it suitable for scientific work?

[Shmuel Metz]

In <jv3m5r$k2k$1@dont-email.me>, on 07/29/2012
   at 05:51 PM, "J-P. Rosen" <rosen@adalog.fr> said:

>Which implies that you can work only with predefined types.

Nonsense.

>One of the great benefits of Ada (for floating point types)

Over C and FORTRAN; not over PL/I.

>is the ability to chose accurracy and range,

I don't know of any Ada compiler that can extend the FP range of the
underlying hardware. As for accuracy, PL/I was there before the
original DOD/1 project began.

>and let the compiler find the appropriate underlying hardware 
>type.

A concept picked up from PL/I.

-- 
Shmuel (Seymour J.) Metz, SysProg and JOAT  <http://patriot.net/~shmuel>

Unsolicited bulk E-mail subject to legal action.  I reserve the
right to publicly post or ridicule any abusive E-mail.  Reply to
domain Patriot dot net user shmuel+news to contact me.  Do not
reply to spamtrap@library.lspace.org

Re: Does Ada need elemental functions to make it suitable for scientific work?

[glen herrmannsfeldt]

In comp.lang.pl1 Dennis Lee Bieber <wlfraed@ix.netcom.com> wrote:

(snip, I wrote)

>> The only language I know of that offers matrix multiply and
>> not element-by-element multiply is BASIC.

I used to use it in the HP TSB2000 systems around 1975.

I believe it traced back to the original Dartmouth versions.

I believe Stanford BASIC also had them, but maybe not in 
the Microsoft decendants.

-- glen

Re: MATRIX MULTIPLICATION

[Robin Vowels]

On Jul 31, 3:49 am, Dennis Lee Bieber <wlfr...@ix.netcom.com> wrote:

>        http://rosettacode.org/wiki/Matrix_multiplication
>
> seems a mixed bag. BBC BASIC,

The BBC BASIC "version" is a mess.
The declarations are for a  3 × 1 multiplied by a 1 × 3 to give a
3 × 2.
The data appears to be 4 × 2 and a 2 × 3,
while the product displayed is that of a 4 × 3.

Re: MATRIX MULTIPLICATION

[Robin Vowels]

Ignore what I just wrote.
I overlooked that the OP was using default lower bounds,
not lower bound of 1.