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

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

------art_9506_1852207.1142052099475--