Hi,
I have an idea on the stability and performance of matrix determinant.
Improved algorithm with complete source code is at the end of this post.
I hope someone would test it and give me a feed-back :-)

note:
 Similar issues have discussed in ruby-dev around 2005.
 They compromised to the current state.

Good Day,
Yu (Kyoto JAPAN)

------------------------
Ruby Matrix Library (matrix.rb) is easygoing and I love it.
Determinant (presumably rank too), however, contains critical flaws.
Ruby 1.9 API document says;
 [determinant] require 'mathn' for integer matrices. (already resolved?)
 [determinant_e] doesn't work for matrices with Float elements.

Flaws in current version (1.9.1)
 0. typo bug (http://redmine.ruby-lang.org/issues/show/1531)
    Matrix[[0,1],[1,0].determinant #=> nil error
 1. returns Rational without mathn (unnatural)
    Matrix[[0,1],[1,0]].det #=> (-1/1)
 2. indivisible fraction (quo) must be avoided (not exact)
 3. unnecessary swap operation (slow)

Solution
 fraction-free version of Gaussian elimination (Bareiss algorithm)
 1. mathn is unnecessary
 2. exact for integer matrix
 3. modest speed

Benchmark
 A: 10 random (Integer) matrix with size 44
  det:   10.0 sec
  det_e: 10.3 sec
  det_b:  1.3 sec
 B: 10 random (Float) matrix with size 44
  det:   0.36 sec
  det_b: 0.88 sec

Issue
 - what is the reason det is faster in Float?
 - many test cases required

#############################################
require 'matrix'
class Matrix
 def det_b
  abort '!error: not square!' unless square?
  n=row_size
  a=to_a
  (0...n).inject(1) do |det,k|
   i=a.transpose[k].slice(k...n).index{|e| e!=0}
   return 0 if i.nil? #not full ranked
   if i!=0 then
    a[k],a[k+i]=a[k+i],a[k]
    det*=-1
   end
   for i in (k+1)...n
    for j in (k...n).to_a.reverse
     a[i][j]=a[k][k]*a[i][j]-a[i][k]*a[k][j]
     a[i][j]/=a[k-1][k-1] if k!=0
    end
   end
   det/=a[k-1][k-1] if k!=0
   det*a[k][k]
  end
 end
end
#############################################

EOF the post.