fast_matrix 0.1.4 → 0.1.5

data/ext/fast_matrix/matrix.h

@@ -3,9 +3,8 @@
 
 #include "ruby.h"
 
-static VALUE matrix_eTypeError;
-static VALUE matrix_eIndexError;
-static VALUE cMatrix;
+extern VALUE cMatrix;
+extern const rb_data_type_t matrix_type;
 
 // matrix
 //     m --->
@@ -22,22 +21,8 @@ struct matrix
     double* data;
 };
 
-void matrix_free(void* data);
-size_t matrix_size(const void* data);
-
-static const rb_data_type_t matrix_type =
-{
-	.wrap_struct_name = "matrix",
-	.function =
-    {
-		.dmark = NULL,
-		.dfree = matrix_free,
-		.dsize = matrix_size,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
+void c_matrix_init(struct matrix* mtr, int m, int n);
 
 void init_fm_matrix();
 
-#endif /* FAST_MATRIX_MATRIX_H */
+#endif /* FAST_MATRIX_MATRIX_H */

data/ext/fast_matrix/vector.c

@@ -0,0 +1,273 @@
+#include "vector.h"
+#include "c_array_operations.h"
+#include "errors.h"
+#include "matrix.h"
+
+VALUE cVector;
+
+void vector_free(void* data);
+size_t vector_size(const void* data);
+
+const rb_data_type_t vector_type =
+{
+    .wrap_struct_name = "vector",
+    .function =
+    {
+                .dmark = NULL,
+                .dfree = vector_free,
+                .dsize = vector_size,
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+void vector_free(void* data)
+{
+	free(((*(struct vector*)data)).data);
+    free(data);
+}
+
+size_t vector_size(const void* data)
+{
+	return sizeof(struct vector);
+}
+
+VALUE vector_alloc(VALUE self)
+{
+	struct vector* vct = malloc(sizeof(struct vector));
+    vct->data = NULL;
+	return TypedData_Wrap_Struct(self, &vector_type, vct);
+}
+
+void c_vector_init(struct vector* vect, int n)
+{
+    vect->n = n;
+    vect->data = malloc(n * sizeof(double));
+}
+
+VALUE vector_initialize(VALUE self, VALUE size)
+{
+	struct vector* data;
+    int n = raise_rb_value_to_int(size);
+
+    if(n <= 0)
+        rb_raise(fm_eIndexError, "Size cannot be negative or zero");
+
+	TypedData_Get_Struct(self, struct vector, &vector_type, data);
+
+    c_vector_init(data, n);
+
+	return self;
+}
+
+//  []=
+VALUE vector_set(VALUE self, VALUE idx, VALUE v)
+{
+    int i = raise_rb_value_to_int(idx);
+    double x = raise_rb_value_to_double(v);
+
+	struct vector* data;
+	TypedData_Get_Struct(self, struct vector, &vector_type, data);
+
+    raise_check_range(i, 0, data->n);
+
+    data->data[i] = x;
+    return v;
+}
+
+//  []
+VALUE vector_get(VALUE self, VALUE idx)
+{
+    int i = raise_rb_value_to_int(idx);
+
+	struct vector* data;
+	TypedData_Get_Struct(self, struct vector, &vector_type, data);
+
+    raise_check_range(i, 0, data->n);
+
+    return DBL2NUM(data->data[i]);
+}
+
+VALUE c_vector_size(VALUE self)
+{
+	struct vector* data;
+	TypedData_Get_Struct(self, struct vector, &vector_type, data);
+    return INT2NUM(data->n);
+}
+
+
+VALUE vector_add_with(VALUE self, VALUE value)
+{
+	struct vector* A;
+    struct vector* B;
+	TypedData_Get_Struct(self, struct vector, &vector_type, A);
+	TypedData_Get_Struct(value, struct vector, &vector_type, B);
+
+    if(A->n != B->n)
+        rb_raise(fm_eIndexError, "Different sizes matrices");
+
+    int n = A->n;
+
+    struct vector* C;
+    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, C);
+
+    c_vector_init(C, n);
+    add_d_arrays_to_result(n, A->data, B->data, C->data);
+
+    return result;
+}
+
+
+VALUE vector_add_from(VALUE self, VALUE value)
+{
+	struct vector* A;
+    struct vector* B;
+	TypedData_Get_Struct(self, struct vector, &vector_type, A);
+	TypedData_Get_Struct(value, struct vector, &vector_type, B);
+
+    if(A->n != B->n)
+        rb_raise(fm_eIndexError, "Different sizes matrices");
+
+    int n = A->n;
+
+    add_d_arrays_to_first(n, A->data, B->data);
+
+    return self;
+}
+
+VALUE vector_equal(VALUE self, VALUE value)
+{
+	struct vector* A;
+    struct vector* B;
+	TypedData_Get_Struct(self, struct vector, &vector_type, A);
+	TypedData_Get_Struct(value, struct vector, &vector_type, B);
+
+    if(A->n != B->n)
+		return Qfalse;
+
+    int n = A->n;
+
+    if(equal_d_arrays(n, A->data, B->data))
+		return Qtrue;
+	return Qfalse;
+}
+
+VALUE vector_copy(VALUE v)
+{
+	struct vector* V;
+	TypedData_Get_Struct(v, struct vector, &vector_type, V);
+
+    struct vector* R;
+    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
+
+    c_vector_init(R, V->n);
+    copy_d_array(R->n, V->data, R->data);
+
+    return result;
+}
+
+// V - vector n
+// M - matrix m x 1
+// R - matrix m x n
+void c_vector_matrix_multiply(int n, int m, const double* V, const double* M, double* R)
+{
+    fill_d_array(m * n, R, 0);
+
+    for(int j = 0; j < n; ++j)
+    {
+        double* p_r = R + m * j;
+        double d_v = V[j];
+        
+        for(int i = 0; i < m; ++i)
+            p_r[i] += d_v * M[i];
+    }
+}
+
+VALUE vector_multiply_vm(VALUE self, VALUE other)
+{
+	struct vector* V;
+    struct matrix* M;
+	TypedData_Get_Struct(self, struct vector, &vector_type, V);
+	TypedData_Get_Struct(other, struct matrix, &matrix_type, M);
+
+    if(M->n != 1)
+        rb_raise(fm_eIndexError, "Number of rows must be 1");
+
+    int m = M->m;
+    int n = V->n;
+
+    struct matrix* R;
+    VALUE result = TypedData_Make_Struct(cMatrix, struct matrix, &matrix_type, R);
+
+    c_matrix_init(R, m, n);
+    c_vector_matrix_multiply(n, m, V->data, M->data, R->data);
+
+    return result;
+}
+
+VALUE vector_multiply_vn(VALUE self, VALUE value)
+{
+	struct vector* A;
+	TypedData_Get_Struct(self, struct vector, &vector_type, A);
+
+    double d = NUM2DBL(value);
+
+    struct vector* R;
+    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
+
+    c_vector_init(R, A->n);
+    copy_d_array(R->n, A->data, R->data);
+    multiply_d_array(R->n, R->data, d);
+
+    return result;
+}
+
+VALUE vector_multiply_vv(VALUE self, VALUE other)
+{
+    struct vector* A;
+    struct vector* B;
+    TypedData_Get_Struct(self, struct vector, &vector_type, A);
+    TypedData_Get_Struct(other, struct vector, &vector_type, B);
+    
+    if(B->n != 1)
+        rb_raise(fm_eIndexError, "Length of vector must be equal to 1");
+
+    struct vector* R;
+    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
+
+    c_vector_init(R, A->n);
+    copy_d_array(A->n, A->data, R->data);
+    multiply_d_array(R->n, R->data, B->data[0]);
+
+    return result;
+}
+
+VALUE vector_multiply(VALUE self, VALUE v)
+{
+    if(RB_FLOAT_TYPE_P(v) || FIXNUM_P(v)
+        || RB_TYPE_P(v, T_BIGNUM))
+        return vector_multiply_vn(self, v);
+    if(RBASIC_CLASS(v) == cMatrix)
+        return vector_multiply_vm(self, v);
+    if(RBASIC_CLASS(v) == cVector)
+        return vector_multiply_vv(self, v);
+    rb_raise(fm_eTypeError, "Invalid klass for multiply");
+}
+
+void init_fm_vector()
+{
+    VALUE  mod = rb_define_module("FastMatrix");
+	cVector = rb_define_class_under(mod, "Vector", rb_cData);
+
+	rb_define_alloc_func(cVector, vector_alloc);
+
+	rb_define_method(cVector, "initialize", vector_initialize, 1);
+	rb_define_method(cVector, "[]", vector_get, 1);
+	rb_define_method(cVector, "[]=", vector_set, 2);
+	rb_define_method(cVector, "size", c_vector_size, 0);
+	rb_define_method(cVector, "+", vector_add_with, 1);
+	rb_define_method(cVector, "+=", vector_add_from, 1);
+	rb_define_method(cVector, "==", vector_equal, 1);
+	rb_define_method(cVector, "clone", vector_copy, 0);
+	rb_define_method(cVector, "*", vector_multiply, 1);
+}

data/ext/fast_matrix/vector.h

@@ -0,0 +1,20 @@
+#ifndef FAST_MATRIX_VECTOR_H
+#define FAST_MATRIX_VECTOR_H 1
+
+#include "ruby.h"
+
+extern VALUE cVector;
+extern const rb_data_type_t vector_type;
+
+// vector
+struct vector
+{
+    int n;
+    double* data;
+};
+
+void c_vector_init(struct vector* vect, int n);
+
+void init_fm_vector();
+
+#endif /* FAST_MATRIX_VECTOR_H */

data/lib/errors.rb

@@ -0,0 +1,9 @@
+module FastMatrix
+  # From C:
+  #   TypeError
+  #   IndexError
+
+  class Error < StandardError; end
+  class NotSupportedError < NotImplementedError; end
+
+end

data/lib/fast_matrix.rb

@@ -1,72 +1,3 @@
-require "fast_matrix/version"
-require "fast_matrix/fast_matrix"
-require "constructors"
-
-module FastMatrix
-  class Error < StandardError; end
-
-  # Matrix with fast implementations of + - * determinate in C
-  class Matrix
-
-    # Aliases just for compatibility with standard matrix
-    #
-    # Returns the number of rows.
-    #
-    alias_method :row_size, :row_count
-    #
-    # Returns the number of columns.
-    #
-    alias_method :column_size, :column_count
-
-    #
-    # Create fast matrix from standard matrix
-    #
-    def self.convert(matrix)
-      fast_matrix = Matrix.new(matrix.row_count, matrix.column_count)
-      (0...matrix.row_count).each do |i|
-        (0...matrix.column_count).each do |j|
-          fast_matrix[i, j] = matrix[i, j]
-        end
-      end
-      fast_matrix
-    end
-
-    def each_with_index
-      (0...row_count).each do |i|
-        (0...column_count).each do |j|
-          yield self[i, j], i, j
-        end
-      end
-    end
-
-    def each_with_index!
-      (0...row_count).each do |i|
-        (0...column_count).each do |j|
-          self[i, j] = yield self[i, j], i, j
-        end
-      end
-      self
-    end
-
-    #
-    # Convert to standard ruby matrix.
-    #
-    def convert
-      ::Matrix.build(row_size, column_size) { |i, j| self[i, j] }
-    end
-
-
-    # FIXME for compare with standard matrix
-    def ==(other)
-      # TODO check class and use fast compare from C if possibly
-      return false unless %i[row_size column_size \[\]].all? { |x| other.respond_to? x }
-      return false unless self.row_size == other.row_size && self.column_size == other.column_size
-
-      result = true
-      each_with_index do |elem, i, j|
-        result &&= elem == other[i, j].to_f
-      end
-      result
-    end
-  end
-end
+require 'fast_matrix/version'
+require 'vector/vector'
+require 'matrix/matrix'

data/lib/fast_matrix/version.rb

@@ -1,3 +1,3 @@
 module FastMatrix
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/matrix/constructors.rb

@@ -0,0 +1,253 @@
+require 'fast_matrix/fast_matrix'
+require 'errors'
+
+module FastMatrix
+  #
+  # Constructors as in the standard matrix
+  #
+  class Matrix
+
+    #
+    # Creates a matrix of size +row_count+ x +column_count+.
+    # It fills the values by calling the given block,
+    # passing the current row and column.
+    # Returns random matrix if no block is given.
+    #
+    #   m = Matrix.build(2, 4) {|row, col| col - row }
+    #     => Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]]
+    #   m = Matrix.build(3) { rand }
+    #     => a 3x3 matrix with random elements
+    #
+    def self.build(row_count, column_count = row_count, &block)
+      check_dimensions(row_count, column_count)
+      matrix = self.new(row_count, column_count)
+      matrix.each_with_index! { |_, i, j| block.call(i, j) } if block_given?
+      matrix
+    end
+
+    #
+    # Creates a matrix where +rows+ is an array of arrays, each of which is a row
+    # of the matrix.
+    # The optional argument +copy+ exists only for compatibility with standard.
+    # The optional argument +copy+ cannot be false, unlike standard.
+    #   Matrix.rows([[25, 93], [-1, 66]])
+    #      =>  25 93
+    #          -1 66
+    #
+    def self.rows(rows, copy = true)
+      check_flag_copy(copy)
+      lines(rows, true)
+    end
+
+    #
+    # Creates a matrix using +columns+ as an array of column vectors.
+    #   Matrix.columns([[25, 93], [-1, 66]])
+    #      =>  25 -1
+    #          93 66
+    #
+    def self.columns(columns)
+      lines(columns, false)
+    end
+
+    #
+    # Creates a matrix where each argument is a row.
+    #   Matrix[ [25, 93], [-1, 66] ]
+    #      =>  25 93
+    #          -1 66
+    #
+    def self.[](*rows)
+      self.rows(rows)
+    end
+
+    #
+    # Creates a single-column matrix where the values of that column are as given
+    # in +column+.
+    #   Matrix.column_vector([4,5,6])
+    #     => 4
+    #        5
+    #        6
+    #
+    def self.column_vector(column)
+      matrix = Matrix.build(column.size, 1)
+      column.each_with_index { |elem, i| matrix[i, 0] = elem }
+      matrix
+    end
+
+    #
+    # Creates a single-row matrix where the values of that row are as given in
+    # +row+.
+    #   Matrix.row_vector([4,5,6])
+    #     => 4 5 6
+    #
+    def self.row_vector(row)
+      matrix = Matrix.build(1, row.size)
+      row.each_with_index { |elem, j| matrix[0, j] = elem }
+      matrix
+    end
+
+    #
+    # Creates a matrix where the diagonal elements are composed of +values+.
+    #   Matrix.diagonal(9, 5, -3)
+    #     =>  9  0  0
+    #         0  5  0
+    #         0  0 -3
+    #
+    def self.diagonal(*values)
+      matrix = Matrix.build(values.size, values.size) { |i, j| i == j ? values[i] : 0 }
+      matrix
+    end
+
+    #
+    # Creates an +n+ by +n+ diagonal matrix where each diagonal element is
+    # +value+.
+    #   Matrix.scalar(2, 5)
+    #     => 5 0
+    #        0 5
+    #
+    def self.scalar(n, value)
+      Matrix.build(n, n) { |i, j| i == j ? value : 0 }
+    end
+
+    #
+    # Creates an +n+ by +n+ identity matrix.
+    #   Matrix.identity(2)
+    #     => 1 0
+    #        0 1
+    #
+    def self.identity(n)
+      scalar(n, 1)
+    end
+    class << Matrix
+      alias unit identity
+      alias I identity
+    end
+
+    #
+    # Creates a zero matrix +n+ by +n+.
+    #   Matrix.zero(2)
+    #     => 0 0
+    #        0 0
+    #
+    def self.zero(n)
+      Matrix.build(n, n) { 0 }
+    end
+
+    #
+    # Empty matrices does not supported
+    #
+    def self.empty(_ = 0, _ = 0)
+      raise NotSupportedError, 'Empty matrices does not supported'
+    end
+
+    #
+    # Create a matrix by stacking matrices vertically
+    #
+    #   x = Matrix[[1, 2], [3, 4]]
+    #   y = Matrix[[5, 6], [7, 8]]
+    #   Matrix.vstack(x, y) # => Matrix[[1, 2], [3, 4], [5, 6], [7, 8]]
+    # TODO: optimize (maybe in C)
+    def self.vstack(x, *matrices)
+      column_count = x.column_count
+      row_count = x.row_count
+      matrices.each do |matrix|
+        raise IndexError unless matrix.column_count == column_count
+
+        row_count += matrix.row_count
+      end
+      result = new(row_count, column_count)
+      m_i = 0
+      [x, *matrices].each do |matrix|
+        matrix.each_with_index do |elem, i, j|
+          result[m_i + i, j] = elem
+        end
+        m_i += matrix.row_count
+      end
+      result
+    end
+
+    #
+    # Create a matrix by stacking matrices horizontally
+    #
+    #   x = Matrix[[1, 2], [3, 4]]
+    #   y = Matrix[[5, 6], [7, 8]]
+    #   Matrix.hstack(x, y) # => Matrix[[1, 2, 5, 6], [3, 4, 7, 8]]
+    #
+    def self.hstack(x, *matrices)
+      column_count = x.column_count
+      row_count = x.row_count
+      matrices.each do |matrix|
+        raise IndexError unless matrix.row_count == row_count
+
+        column_count += matrix.column_count
+      end
+      result = new(row_count, column_count)
+      m_j = 0
+      [x, *matrices].each do |matrix|
+        matrix.each_with_index do |elem, i, j|
+          result[i, m_j + j] = elem
+        end
+        m_j += matrix.column_count
+      end
+      result
+    end
+
+    #
+    # Create a matrix by combining matrices entrywise, using the given block
+    #
+    #   x = Matrix[[6, 6], [4, 4]]
+    #   y = Matrix[[1, 2], [3, 4]]
+    #   Matrix.combine(x, y) {|a, b| a - b} # => Matrix[[5, 4], [1, 0]]
+    # TODO: optimize in C
+    def self.combine(*matrices)
+      return Matrix.empty if matrices.empty?
+
+      result = convert(matrices.first)
+      matrices[1..matrices.size].each do |m|
+        raise IndexError unless result.row_count == m.row_count &&
+                                result.column_count == m.column_count
+
+        result.each_with_index! { |elem, i, j| yield elem, m[i, j] }
+      end
+      result
+    end
+
+    class << Matrix
+      private
+
+      def check_empty_matrix(row_count, column_count)
+        empty if row_count.zero? || column_count.zero?
+      end
+
+      def check_negative_sizes(row_count, column_count)
+        raise IndexError if column_count.negative? || row_count.negative?
+      end
+
+      def check_dimensions(row_count, column_count)
+        check_empty_matrix(row_count, column_count)
+        check_negative_sizes(row_count, column_count)
+      end
+
+      def check_flag_copy(copy)
+        unless copy
+          raise NotSupportedError, "Can't create matrix without copy elements"
+        end
+      end
+
+      # generalization between ::rows and ::columns
+      def lines(lines, main_is_rows)
+        sizes = [lines.size, (lines[0] || []).size]
+        offset = main_is_rows ? 0 : -1
+        matrix = build(sizes[offset], sizes[1 + offset])
+        lines.each_with_index do |second_dim, main_index|
+          raise IndexError if second_dim.size != sizes[1]
+
+          second_dim.each_with_index do |elem, second_index|
+            indices = [main_index, second_index]
+            matrix[indices[offset], indices[1 + offset]] = elem
+          end
+        end
+        matrix
+      end
+    end
+  end
+end