The problem with the code you sent is that you have to go through ALL
your matrix elements to get a certain row or column, which takes too
long. Remember that this is a LARGE matrix (my current C implementation
can handle 100M row and cols and 800M elements). Of course this will be
too much for Ruby since its memory footprint is larger and its garbage
collecter will burn a lot of cpu with this number of elements, but
still, I want the Ruby implementation to contain also a lot of elements.
It is not feasible to iterate through all elements for retrieving just
one row or col. What I want looks more like:

class SparseMatrix
  def initialize()
    @rows=Hash.new{|hash,key|hash[key]=Hash.new}
    @columns=Hash.new{|hash,key|hash[key]=Hash.new}
  end
  def []=(i,j,value)
    @rows[i][j]=value
    @columns[j][i]=value
  end
  def getRow(i)
    return @rows[i]
  end
  def getCol(j)
    return @columns[j]
  end
end

m=SparseMatrix.new
m[10000,200000]=12.01
m[10000,400000]=12.02
p m.getRow(10000)
p m.getCol(200000)

Unfortunately, this code duplicates the content values of the matrix, it
has a copy inside the @columns and one inside the @rows and these need
to be maintained so they stay the same, which is programming and
execution overhead.

Geert.

-----Original Message-----
From: Hugh Sasse [mailto:hgs / dmu.ac.uk] 
Sent: Friday, March 10, 2006 3:32 PM
To: ruby-core / ruby-lang.org
Subject: Re: how to introduce reference objects into ruby

On Fri, 10 Mar 2006, Geert Fannes wrote:

> But things change when you want to implement a SPARSE matrix, i.e., a
> matrix for which most of its elements are empty. E.g., I am analyzing
> call-networks, data from a telecom firm that contains the call
durations
> for its customers, which can be represented with a matrix: element
(i,j)
> is the duration that j calls i. Since not everybody calls to
everybody,

# Untested code.  
# There may well be a faster way, but you don't need pointers to do 
# this.
class Durations
  def initialize()
    @matrix = Hash.new
  end

  def insert(i,j,duration)
    @matrix[[i,j]] = duration
  end

  def getrow(i)
    return getline(0,1,i)
  end

  def getcol(i)
    return getline(1,0,i)
  end

  private

  # get horizontal or vertical line
  def getline(a,b,i)
    line = []
    linehash = {}
    @matrix.keys.each do |k|
      linehash[k[b]] = @matrix[k] if k[a] == i 
    end
    linehash.keys.sort.each do |index|
      line << linehas[index]
    end
    return line
  end 

end

#       HTH
#       Hugh