Re: matrix and vector iterators

From: Hubert HOLIN (Hubert.Holin_at_[hidden])
Date: 2001-06-11 16:24:54

Paris (U.E.), le 11/06/2001

        I would just like to say at this point that higher-dimentional 
tensors whould gain from having a nice iterator interface.

        I had once cause to consider a "stack" of several usual matrices, 
for which it was advantageous to consider all elements of the same *
last* index.

        Also, fft in more than 2 dimensions simultaneously (I also need 
that sometimes) could benefit from such tools (remember the index 
dance!).

        Quadtrees and higher-dimentional analogues represent another form 
of indexing fun that should not be overlooked.

        Finaly, valarray has (more or less) efficient traversal with 
strides and (hopefully) very efficient computational power, but next to 
no tensorial behaviour, whereas matrices (and tensors) could have good 
algebraic properties but currently lack good traversal. It would be 
ideal to be able to go back and forth between the two concepts (TNT can 
build matrices and vectors upon valarrays, but the crawling of said 
seems to be slowing still, as if it were possible...), as far as 
possible anyway (sparse matrices may be out of luck).

        We should also remember to look at TNT for implementation of 
frequent LA algorithms (still no svd, unfortunately...).

                Hubert Holin
                Hubert.Holin_at_[hidden]

--- In boost_at_y..., Jeremy Siek <jsiek_at_r...> wrote:
> 
> One thing that we need to decide on is the interface for traversing
> vectors and matrices. I see a couple options:
> 
> 1. MTL-style iterators
> 
>   *i          // return a matrix/vector element
>   i.index()   // return the index of the element pointed to (for vectors)
>   i.row()     // return the row index (for matrices)
>   i.colummn() // return the column indexn (for matrices)
> 
> 2. iterator over "matrix elements" or "vector elements"
>   *i         // returns a matrix or vector element object.
>   value(*i)  // return the element value
>   row(*i)    // returns the row index
>   column(*i) // return the column index
>   index(*i)  // return the index (for vectors)
> 
> Also, there is the question of whether the above iterator interfaces
> should apply to both sparse and dense, or whether the dense iterators
> would just use the normal STL style iterators which would leave the
> indices out of the picture (for dense iterators they can be obtained in
> other ways).
> 
> Comments, suggestions?
> 
> Cheers,
> Jeremy
> 
> 
> ----------------------------------------------------------------------
>  Jeremy Siek                        www: http://www.lsc.nd.edu/~jsiek/
>  Ph.D. Candidate, IU B'ton          email: jsiek_at_r...
>  Summer Manager, AT&T Research      phone: [phone]
> ---------------------------------------------------------------------
-