From: Charles O Nutter <headius@...>
Date: 2006-03-11T13:41:55+09:00
Subject: Re: how to introduce reference objects into ruby

------=_Part_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 sam=
e
values. So for example, if you have four columns of four elements, row thre=
e
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 matri=
x
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 nee=
d
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 row=
s
that reference the appropriate indexed element in each column (what you wan=
t
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 i=
t
work.


 class MatrixRow
  def initialize(columns, row_number)
   @columns =3D columns
   @row_number =3D row_number
  end
  def [](index)
   @columns[row_number][index]
  end
  def []=3D(index, value)
   @columns[row_number][index] =3D value
  end
 end

class SparseMatrix
 def initialize()
   @columns=3DHash.new{|hash,key|hash[key]=3DHash.new}
 end
 def []=3D(i,j,value)
   @columns[j][i]=3Dvalue
 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

------=_Part_9506_1852207.1142052099475--