Re: efficient vector/matrix operations in Ada

[Ted Dennison<dennison@telepath.com>]

In article <bebbba07.0108132056.7bcc7c95@posting.google.com>, Russ says...
>
>Ted Dennison<dennison@telepath.com> wrote in message news:<aGXd7.88$2u.23428@www.newsranger.com>...
>> >    A  = B;
>> >    A += C;
>> >    A += D;
>> Perhaps to a reader who is *already* familiar with the idiom above that is 
>> true. I'm not, and it took me a couple of takes to see what you were doing 
>> here (and a bit of thought to figure out why). For someone starting from 
>> ground zero, I think the point is quite arguable.
>
>If you know even a tiny bit of C++, the "+=" notation is very obvious.

For one thing, the issue isn't that *one* of them is tough to decipher. The
issue is that the cumulative effect of all *three* of them is tough to deciper.

For another, you are again assuming someone comfortable with C++. If C++ is
going to remain your touchstone for readability, then there's no point at all in
having this discussion. Ada, or any other language with a different syntax, is
set up to loose from the get-go.

I hope you can see where I'm comming from here. If you want to know, "what's the
most readable way to do this efficiently in Ada", we can work with that. If you
want to know, "how can I make this look exactly like C++, because anything that
doesn't look that way is inferior", there's really nothing constructive anyone
here can do for you.

As for trying to be constructive, I think what I'd want to see in this situation
would be "Sum" routine with the following profile (uncompiled, and forgive me if
my posting s/w kills the formatting):
---------
type Matrices is array (Natural range <>) of Matrix;

procedure Sum
(Target :    out Matrix;
Source : in     Matrices
);
---------

That way the operation is carried out in one statement for clarity, and it can
have as many addends as you need, and can be implemented as efficiently as you
need. A call would loook something like:
----
Sum (Target => A, Source => (B, C, D));
----

That certianly looks clearer to me than your n lines of code (where n=# of
addends), all of which have to be read and mentally pieced together to figure
out what's going on.

If your compiler can't do this efficently (some might make copies of B, C, and D
on the stack), then a good subsitute would be to just have several overloaded
"Sum" routines containting as many addends as you might need.


---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html
          home email - mailto:dennison@telepath.com