Hi -core,

I've commented matrix.rb, and in the process made the following
observations about its implementation.


Matrix:
 - initialize should be protected/private
 - class methods could be wrapped in class << Matrix (matter of taste)
 - the error mapping device is clumsy; why not just use normal exceptions?
 - #slice would be a good alias for #minor
 - it is possible to create uneven matrices (e.g. Matrix[ [1,2], [1] ].
   This should be either disallowed, or at least a method should exist to
   verify it.  The above matrix returns true for #square?, which is
   disappointing.
 - in general, some more exception handling should be added.  For instance,
   Matrix[ [1,2], [1,2], [1,2] ].rank raises a low-level exception, not a
   Matrix exception
 - #compare_by_row_vectors should be private/protected
 - #inverse_from should be private/protected?
 - determinant of a non-square matrix should be an exception instead of 0?
 - Matrix#diagonalize() should return a [M:Matrix,D:Matrix] pair such that
   M*D*M.inverse == self
 - ** is too slow.  Using matrix diagonalisation is a more efficient algorithm
   and works for all exponents, not just positive integers.  Here is a more
   efficient **
           def ** n
                m, d = diagonalize
                (0...d.row_size).each { |i| d[i,i] **= n }
                (m * d * m).inverse
           end

Vector:
 - initialize, init_elements should be private/protected
 - eqn? should be eql?
 - compare_by should be private/protected
 - collect2 and map2 are different!
 - #r should be something more normal, like #modulus (with #r an alias)
 - BUG! Vector#coerce uses class Scalar, which doesn't exist in scope

Matrix::Scalar:
 - what is the point of this class? (just curious)
 - BUG! Scalar#** uses Matrix#powered_by


Gavin