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

Gah, ok, so I made a small mistake.  That should be @row_number..

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

But perhaps you get the idea.

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_9546_32353633.1142053575015--