------art_9518_1589047.1142052244523
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

If you wanted to be even trickier, you could just use [i,j] as the key and
use a "MatrixColumn" to access the columns in the same way. Everything would
still look like an array, of course.

- Charlie

On 3/10/06, Charles O Nutter <headius / headius.com> wrote:
>
> If I am understanding correctly, the columns would contain the actual
> values, while the rows would extend across all columns but point at the
> same
> values. So for example, if you have four columns of four elements, row
> three
> would contain four references to the items at index three (one-based, not
> zero-based for this example) in each column. You can access all elements
> using either rows or columns. This provides the ability to invert the
> matrix
> making columns rows and rows columns without altering the contents of
> either.
>
> These must also be sparse, so that if you have 5 elements in a 100-slot
> column, it only takes up 5 elements-worth of space. For this, you would
> need
> to use hashes with the [x,y] as the key.
>
> Since you may need to access things by either row or column, you only have
> two options:
>
> 1. Maintain a set of columns pointing at the actual values and a set of
> rows
> that reference the appropriate indexed element in each column (what you
> want
> above)
> 2. Create both row and column hashes that key off [x,y] (but cause twice
> as
> much memory to be consumed for storing both)
>
> I see your conundrum. However I think it should be possible to do what you
> want. If you maintain only the list of columns I think you can still make
> it
> work.
>
>
> class MatrixRow
>   def initialize(columns, row_number)
>    @columns = columns
>    @row_number = row_number
>   end
>   def [](index)
>    @columns[row_number][index]
>   end
>   def []=(index, value)
>    @columns[row_number][index] = value
>   end
> end
>
> class SparseMatrix
> def initialize()
>    @columns=Hash.new{|hash,key|hash[key]=Hash.new}
> end
> def []=(i,j,value)
>    @columns[j][i]=value
> end
> def getRow(i)
>    return MatrixRow.new(@colums, i)
> end
> def getCol(j)
>    return @columns[j]
> end
> end
>
> You can probaby build in some smarts to avoid recreating the virtual
> "rows"
> every time too.
>
> - Charlie
>
>
> On 3/10/06, Jim Weirich <jim / weirichhouse.org> wrote:
> >
> > Jim Weirich wrote:
> > > What does your C/C++ program do to get around this difficulty?
> >
> > Geert Fannes wrote:
> > > The columns store the actual values (doubles), and the rows store
> > > pointers to the corresponding doubles. This way, I can update a
> > > double directly via the columns, via the rows after dereferencing
> > > the pointers.
> > >
> > > (The real truth is a bit more complex since pointers on a 64 bit
> > > machine take 64 bit, which wastes too much memory space. I
> > > store float and unsigned int indices instead of pointers, but
> > > the principle is the same)
> >
> > I think you are saying that the rows of your matrix contain the value,
> > and the columns contain references (either pointers or indices) to the
> > row values.  Is that correct (modulo having rows/columns reversed)?
> >
> > I'm still unclear why this solution wouldn't work in Ruby.
> >
> > --
> > -- Jim Weirich       jweirich / one.net       http://onestepback.org
> > -----------------------------------------------------------------
> > "Beware of bugs in the above code; I have only proved it correct,
> > not tried it." -- Donald Knuth (in a memo to Peter van Emde Boas)
> >
> >
>
>
> --
> Charles Oliver Nutter @ headius.blogspot.com
> JRuby Developer @ jruby.sourceforge.net
> Application Architect @ www.ventera.com
>
>


--
Charles Oliver Nutter @ headius.blogspot.com
JRuby Developer @ jruby.sourceforge.net
Application Architect @ www.ventera.com

------art_9518_1589047.1142052244523--