Re: on using array index, vectorized operation

["Nasser M. Abbasi" <nma@12000.org>]

On 3/29/2011 1:11 PM, Phil Clayton wrote:

>  Unfortunately, if you use real arrays for the i+1 in your
> example, you'll have real subscripts.  That may be acceptable when
> modelling e.g. in Matlab but not in an implementation.

I am a little confused on the above.

What do you mean by "you'll have real subscripts" ?

Are you talking about Fortran now? Lets forget Matlab, since
Matlab is special case. (default is double for everything, etc...)

For Fortran, why would the subscripts have to be floating point
numbers if the array content happened to be floating point values?

Or are you talking about Ada here?

> Phil
>
> P.S. I still think Ada should allow us to write something like
>
>    u (2 .. 5) := (for i in 2 .. 5 =>
>                    u (i) -
>                    (a / 2.0) * (u (i+1) - u (i-1)) +
>                    (a ** 2) / 2.0 *
>                    (u (i-1) - 2.0 * u (i) + u(i+1)));
>
> (which avoids the temporary variable that the equivalent loop
> requires).


Thats nice if possible to do. But just being able to write  in Ada
an index array as a variable and then write

i := 2..5;  -- using the correct range etc... syntax  for Ada

and then write
  
  u(i) := u(i) + u(i-1) - ......

would be nice.

which is the 'standard' way in Fortran and Matlab type synatx.

> This enables on-the-fly vectorization by promoting scalar
> operations inline in expressions.  For example, if you didn't have a
> version of some function F vectorized in its second argument, you
> could write
>
>    (for I in B'Range =>  F(A, B(I), C))

I do think that Fortran still has more support and build-in
functions (called intrinsics) and syntax to working with vectors
and matrices than Ada does, at least it seems it requires less
work to set things up.

But again, this is what Fortran was originally designed for, so this is
not too surprising. Each language has its strong and not too strong
areas.

--Nasser