Re: Any easy/build-in construct to extract submatrices from larger matrix?

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

On 25.06.12 15:17, Nasser M. Abbasi wrote:
> On 6/25/2012 3:36 AM, Georg Bauhaus wrote:
>> On 25.06.12 08:32, Nasser M. Abbasi wrote:
>>>
>>> In Mathematica for example, I do this whole operation in one line:
>>>
>>> ---------------------------
>>> Table[ReplacePart[A,{{i},{i,_},{_,j}}:>Sequence[]],{i,nRow},{j,nCol}];
>>> ---------------------------
>>>
>>> That is all. This generates all submatrices from A as needed
>>> in this problem :)
>>
> 
>> What if, as is usually the case, you'd have "primitive" array routines
>> like Pick, Take, Drop, Transpose, and then (this is what it looks
>> like here) implement the removals at i, j like like this:
>>
>>      Shrunk := Transpose (Drop (i, Transpose (Drop (j, Matrix))));
>>
> 
> Yes, that would help. Transpose is there already in Ada. (good).
> Drop? I did not find this. googled for it. I assume this is just
> an example then.

It is fairly easy to write, indeed. Nevertheless, I believe that
such operations should be a little higher level than Fortran's pack.
The latter seems good for implementing the operations, provided
the language allows (re-)attaching dimensions to a lump of data.
I am not sure that Ada's index type based array indexing
is the best model for such flexibility at all levels.
It certainly does not seem strictly necessary to implement some
"primitive" operations.

Nevertheless, Iverson's A Programming Language, and more specifically,
introductory work based on it (things that I can hope to understand in finite
time :), and language work based on it (APL, J, possibly S and R),
reveal a good set of "primitive" operations on arrays, functional style.
Some of these are in Ada already, for example, array concatenation "&",
and (some) indexing. Some can be built using a container/iterator
approach, I think, for example, applying a function to all elements,
either updating the array, or producing a new one. There are simpler
ways to do that, though, even in Ada 83, but they may be a little
less flexible for STL style algorithm work. Just a guess.

Array operations are again interesting for automatic parallelism in
the small, now that consumer hardware has a small array of vector
hardware.