Hi,
I am looking for the suitability of ruby for numerical applications.
I am currently using MATLAB and Octave for this purpose (see
www.octave.org, www.mathworks.com).
For vectors and matrices a single “" or “/” operator is not
sufficient to implement the necessary matrix/vector arithmetic in a
convinient and consistent operator notation. In OOPS languages like C++
which support operator overloading, Matrix class libraries usually
resort to a mixed functional/operator notation and assign the matrix
product to the "” and implement the dot-product by a function e.g as
dot(A, B).
Besides product and division operators for matrix/vector operations
it is necessary to introduce a transpose and hermite operator which is
of no interest in scalar arithmetic. In MATLAB the transpose of a
matrix X is expressed as X.’ and the conjugate transpose is X’.
A simple and compact example of how this notation can be used is in
computing the 2-norm of a vector:
x = 1:1:10 % Vector counting from 1 to 10
norm2 = sqrt( xx’ ) % use matrix multiplication to compute the
squared sum
norm2 = sqrt(sum(x . x)) % use elementwise multiplication
norm2 = sqrt(sum(x .^ 2)) % square element by element
In standart programming languages with an OOPS library this might
look like:
x = [1 2 3 4 … 10] ;
norm2 = sqrt( x*x.transpose()) ; // use matrix multiplication
norm2 = sqrt(sum(dot(x, x))) ; // use dot-product auxiliary
function
While for such a simple example, there is not so much difference in
readability, but for real world examples, the matrix operator notation
makes the code more compact and readable. Conceptionally it lacks
consistency, if the maybe more often used dot-product is implemented as
function and the matrix product as operator.
My assumption is that is might be possible to extend ruby with
reasonable effort to add the additional “.*” “./” and “.^2” binary
operators and the transpose / conjugate transpose operators. For the
standard ruby this function would just do the same as their scalar
conterparts, however, when implementing a matrix class these additional
operators can become alive and be used to implement the elementwise dot
operations.
Aside from the operators a second concept is quite essential for a
scripting matrix and vector class. This requires a new data-type to
express strides.
Suppose one wants to access only every second element of a vector or
reverse a vector, then usually this has to be done in a loop. Since
looping over elements is prohibitively expensive in a scripting
language, the preferred solution for doing such common indexing
operation is to use strides. For ruby, it would be possible to define a
stride class, which stores the index of the first, last and stepsize.
Reversing a vector might look like:
vector x=stride(1, 3) // use a stride to construct a new vector
from 1 to 3.
reverse_x = x( stride(3, 1, -1) )
More elegantly, if strides are natively supported by the scripting
language, then the example could be implemented as
x = 1:3 ;
reverse_x = x(3:-1:1) ;
Has anybody implemented a patch to include dot-operators or index
strides to ruby? Are there any plans / discussion to include
MATLAB/Octave-alike features in the future?
Regards,
よろしくおねがいします
Roderick Koehle
References:
* http://en.wikipedia.org/wiki/Matlab
* http://en.wikipedia.org/wiki/IDL_programming_language
