Re: Larger matrices

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

Dmitry A. Kazakov schrieb:

> They are not. Lisp is a list-oriented language, Prolog is a logical
> inference language.

Lisp and Prolog with FFI(!) are not universal? Come on.


>> This notion of "purpose" is not very specific.
>> Let me put is this way: Ada has to be especially good at
>> systems programming, hence it has to be fairly low level.
> 
> Wrong. Where that follows from? Systems programming need not to be
> low-level.

A systems programming language must provide for the low
level.  A language that does not provide for the low level
is not a systems programming language.  Ada has many features
that provide for low level programming.  It lacks a numer of
features used in higher level programming (E.g. function
environments, unbounded numbers, ...).  Systems programming
is not the same as low level programming or high level programming;
rather, the set of objects is typically not as abstract as
some mathematical N-array of numbers.  The set of objects in
a systems programming language is more like a real N-array
of numbers: storage cells of well defined meaning, with just
one layer of abstraction above the storage cells.

>> What hardware?
> 
> Vector processors.

OK, I wasn't aware that the LA packages were made for vector
processors only.


>> Assume data flow hardware, and assume a way
>> to put the function result in the input box of the next processing unit.
>> What now?
> 
> Nothing, Ada.Numerics.Generic_Real_Arrays was not designed in order to
> support this hardware.

Aha?   I see that GNAT delegates to Fortran libraries. Traditionally,
Fortran is certainly an associate of non-PC hardware.


> Which is the point. Ada is not low-level,

Ada is fairly low-level.


>> I don't see how prototyping a hypertext graph algorithm
>> requires a maximally efficient implementation of matrix
>> computations.
> 
> Because of the problem size. Incidence matrices grow as O(n**2), i.e.
> extremely fast.

O(N**2) is not extremely fast; many non-extreme algorithms
are in this class.  The case discussed hits some memory barrier
at n = 5_000 and that's it. We get elaborate array indexing support
in some array programming languages.  If chosing one of those
PLs costs me a constant factor of 10, I get all the indexing
stuff in return, it seems worth the cost during prototyping.



>> A production system may require increased
>> efficiency. At that stage you have to pay attention to
>> the tiny bits, possibly redesigning the algorithm.
> 
> Numerics is all about algorithms.

Numerics is about numbers (or about numeric control, depending).


> This BTW is exactly the problem OP has. He has "prototyped" the thing using
> Ada.Numerics.Generic_Real_Arrays. Now, he faces the problem that the
> prototype does not scale due to stack overflow. The consequence is a need
> in full redesign. Ergo, prototyping was time wasting.

Nice rhetoric logic error.


--
Georg Bauhaus
Y A Time Drain  http://www.9toX.de