fast_matrix 0.2.0 → 0.3.0

data/ext/fast_matrix/Matrix/c_matrix.h

@@ -16,6 +16,8 @@ struct matrix
     int n;
 
     double* data;
+
+    bool frozen;
 };
 
 double c_matrix_trace(int n, const double* A);
@@ -30,6 +32,7 @@ void c_matrix_column_vector(int m, int n, const double* M, double* V, int idx);
 void c_matrix_scalar(int n, double* C, double v);
 void c_matrix_minor(int m, int n, const double* A, double* B, int m_idx, int n_idx);
 void c_matrix_vstack(int argc, struct matrix** mtrs, double* C);
+void c_matrix_lup(int n, const double* A, double* LU, int* V, int* sign, bool* singular);
 
 bool c_matrix_symmetric(int n, const double* C);
 bool c_matrix_antisymmetric(int n, const double* C);
@@ -41,6 +44,8 @@ bool c_matrix_identity(int n, const double* A);
 bool c_matrix_equal_by_m(int argc, struct matrix** mtrs);
 bool c_matrix_equal_by_n(int argc, struct matrix** mtrs);
 bool c_matrix_inverse(int n, const double* A, double* B);
+bool c_matrix_adjugate(int n, const double* A, double* B);
+bool c_matrix_exponentiation(int m, int n, const double* A, double* B, int d);
 
 int c_matrix_sum_by_m(int argc, struct matrix** mtrs);
 int c_matrix_sum_by_n(int argc, struct matrix** mtrs);

data/ext/fast_matrix/Matrix/errors.h

@@ -18,6 +18,13 @@ inline void raise_check_square_matrix(struct matrix* A)
         rb_raise(fm_eIndexError, "Expected square matrix");
 }
 
+//  check if the matrix is frozen and raise an error if not
+inline void raise_check_frozen_matrix(struct matrix* A)
+{
+    if(A->frozen)
+        rb_raise(fm_eFrozenError, "Can't modify frozen Matrix");
+}
+
 //  check if the value is zero and raise an error if not
 inline void raise_check_no_arguments(int argc)
 {

data/ext/fast_matrix/Matrix/matrix.c

@@ -5,6 +5,8 @@
 #include "Matrix/errors.h"
 #include "Matrix/helper.h"
 #include "Vector/helper.h"
+#include "LUPDecomposition/c_lup.h"
+#include "LUPDecomposition/lup.h"
 
 VALUE cMatrix;
 
@@ -39,6 +41,7 @@ VALUE matrix_alloc(VALUE self)
 {
 	struct matrix* mtx = malloc(sizeof(struct matrix));
     mtx->data = NULL;
+    mtx->frozen = false;
 	return TypedData_Wrap_Struct(self, &matrix_type, mtx);
 }
 
@@ -46,7 +49,7 @@ VALUE matrix_initialize(VALUE self, VALUE rows_count, VALUE columns_count)
 {
     int m = raise_rb_value_to_int(columns_count);
     int n = raise_rb_value_to_int(rows_count);
-
+    
     if(m <= 0 || n <= 0)
         rb_raise(fm_eIndexError, "Size cannot be negative or zero");
 
@@ -58,11 +61,13 @@ VALUE matrix_initialize(VALUE self, VALUE rows_count, VALUE columns_count)
 //  []=
 VALUE matrix_set(VALUE self, VALUE row, VALUE column, VALUE v)
 {
+	struct matrix* data = get_matrix_from_rb_value(self);
+    raise_check_frozen_matrix(data);
+
     int m = raise_rb_value_to_int(column);
     int n = raise_rb_value_to_int(row);
     double x = raise_rb_value_to_double(v);
-	struct matrix* data = get_matrix_from_rb_value(self);
-    
+
     m = (m < 0) ? data->m + m : m;
     n = (n < 0) ? data->n + n : n;
 
@@ -158,11 +163,53 @@ VALUE matrix_multiply(VALUE self, VALUE v)
         return matrix_multiply_mn(self, v);
     if(RBASIC_CLASS(v) == cMatrix)
         return matrix_strassen(self, v);
-    if(RBASIC_CLASS(v) == cVector);
+    if(RBASIC_CLASS(v) == cVector)
         return matrix_multiply_mv(self, v);
     rb_raise(fm_eTypeError, "Invalid klass for multiply");
 }
 
+VALUE matrix_division_mn(VALUE self, VALUE value)
+{
+    double d = NUM2DBL(value);
+	struct matrix* A = get_matrix_from_rb_value(self);
+
+    MAKE_MATRIX_AND_RB_VALUE(R, result, A->m, A->n);
+    copy_d_array(A->m * A->n, A->data, R->data);
+    multiply_d_array(R->m * R->n, R->data, 1 / d);
+
+    return result;
+}
+
+VALUE matrix_division_mm(VALUE self, VALUE other)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+	struct matrix* B = get_matrix_from_rb_value(other);
+
+    if(A->m != B->n)
+        rb_raise(fm_eIndexError, "First columns differs from second rows");
+    raise_check_square_matrix(B);
+
+    int n = B->n;
+    double* M = malloc(n * n * sizeof(double));
+    c_matrix_inverse(n, B->data, M);
+
+    MAKE_MATRIX_AND_RB_VALUE(C, result, n, n);
+    c_matrix_strassen(n, n, n, A->data, M, C->data);
+
+    free(M);
+    return result;
+}
+
+VALUE matrix_division(VALUE self, VALUE v)
+{
+    if(RB_FLOAT_TYPE_P(v) || FIXNUM_P(v)
+        || RB_TYPE_P(v, T_BIGNUM))
+        return matrix_division_mn(self, v);
+    if(RBASIC_CLASS(v) == cMatrix)
+        return matrix_division_mm(self, v);
+    rb_raise(fm_eTypeError, "Invalid klass for division");
+}
+
 VALUE matrix_copy(VALUE self)
 {
 	struct matrix* M = get_matrix_from_rb_value(self);
@@ -207,8 +254,9 @@ VALUE matrix_add_with(VALUE self, VALUE other)
 
 VALUE matrix_add_from(VALUE self, VALUE other)
 {
-    raise_check_rbasic(other, cMatrix, "matrix");
 	struct matrix* A = get_matrix_from_rb_value(self);
+    raise_check_frozen_matrix(A);
+    raise_check_rbasic(other, cMatrix, "matrix");
 	struct matrix* B = get_matrix_from_rb_value(other);
 
     raise_check_equal_size_matrix(A, B);
@@ -232,8 +280,9 @@ VALUE matrix_sub_with(VALUE self, VALUE other)
 
 VALUE matrix_sub_from(VALUE self, VALUE other)
 {
-    raise_check_rbasic(other, cMatrix, "matrix");
 	struct matrix* A = get_matrix_from_rb_value(self);
+    raise_check_frozen_matrix(A);
+    raise_check_rbasic(other, cMatrix, "matrix");
 	struct matrix* B = get_matrix_from_rb_value(other);
 
     raise_check_equal_size_matrix(A, B);
@@ -251,8 +300,9 @@ VALUE matrix_determinant(VALUE self)
 
 VALUE matrix_fill(VALUE self, VALUE value)
 {
-    double d = raise_rb_value_to_double(value);
 	struct matrix* A = get_matrix_from_rb_value(self);
+    raise_check_frozen_matrix(A);
+    double d = raise_rb_value_to_double(value);
     fill_d_array(A->m * A->n, A->data, d);
     return self;
 }
@@ -293,7 +343,46 @@ VALUE matrix_greater_or_equal(VALUE self, VALUE other)
     return Qfalse;
 }
 
-struct matrix** convert_matrix_array(int argc, VALUE *argv, struct matrix*** mtrs)
+VALUE matrix_less_or_equal(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cMatrix, "matrix");
+	struct matrix* A = get_matrix_from_rb_value(self);
+	struct matrix* B = get_matrix_from_rb_value(other);
+
+    raise_check_equal_size_matrix(A, B);
+
+    if(less_or_equal_d_array(A->n * A->m, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE matrix_greater(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cMatrix, "matrix");
+	struct matrix* A = get_matrix_from_rb_value(self);
+	struct matrix* B = get_matrix_from_rb_value(other);
+
+    raise_check_equal_size_matrix(A, B);
+
+    if(greater_d_array(A->n * A->m, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE matrix_less(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cMatrix, "matrix");
+	struct matrix* A = get_matrix_from_rb_value(self);
+	struct matrix* B = get_matrix_from_rb_value(other);
+
+    raise_check_equal_size_matrix(A, B);
+
+    if(less_d_array(A->n * A->m, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+void convert_matrix_array(int argc, VALUE *argv, struct matrix*** mtrs)
 {
     for(int i = 0; i < argc; ++i)
         raise_check_rbasic(argv[i], cMatrix, "matrix");
@@ -517,7 +606,7 @@ VALUE matrix_round(int argc, VALUE *argv, VALUE self)
     else
         d = 0;
 
-	struct matrix* A = get_matrix_from_rb_value(self);
+    struct matrix* A = get_matrix_from_rb_value(self);
     MAKE_MATRIX_AND_RB_VALUE(R, result, A->m, A->n);
     round_d_array(A->m * A->n, A->data, R->data, d);
     return result;
@@ -584,6 +673,101 @@ VALUE matrix_inverse(VALUE self)
     return result;
 }
 
+VALUE matrix_adjugate(VALUE self)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    raise_check_square_matrix(A);
+    MAKE_MATRIX_AND_RB_VALUE(R, result, A->n, A->n);
+    if(!c_matrix_adjugate(R->n, A->data, R->data))
+        rb_raise(fm_eIndexError, "The discriminant is zero");
+    return result;
+}
+
+VALUE matrix_exponentiation(VALUE self, VALUE value)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    int d = raise_rb_value_to_int(value);
+    
+    MAKE_MATRIX_AND_RB_VALUE(C, result, A->m, A->n);
+    if(!c_matrix_exponentiation(A->m, A->n, A->data, C->data, d))
+        rb_raise(fm_eIndexError, "Invalid exponentiation");
+    return result;
+}
+
+VALUE matrix_normal(VALUE self)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    if(A->m != A-> n)
+        return Qfalse;
+    
+    int n = A->n;
+    double* B = malloc(n * n * sizeof(double));
+    double* C = malloc(n * n * sizeof(double));
+    double* D = malloc(n * n * sizeof(double));
+    
+    c_matrix_transpose(n, n, A->data, B);
+    c_matrix_strassen(n, n, n, A->data, B, C);
+    c_matrix_strassen(n, n, n, B, A->data, D);
+    
+    VALUE res = Qfalse;
+    if(equal_d_arrays(n * n, C, D))
+        res = Qtrue;
+    
+    free(B);
+    free(C);
+    free(D);
+    return res;
+}
+
+VALUE matrix_unitary(VALUE self)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    if(A->m != A-> n)
+        return Qfalse;
+    
+    int n = A->n;
+    double* B = malloc(n * n * sizeof(double));
+    double* C = malloc(n * n * sizeof(double));
+    
+    c_matrix_transpose(n, n, A->data, B);
+    c_matrix_strassen(n, n, n, A->data, B, C);
+    
+    VALUE res = Qfalse;
+    if(c_matrix_identity(n, C))
+        res = Qtrue;
+    
+    free(B);
+    free(C);
+    return res;
+}
+
+VALUE matrix_freeze(VALUE self)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    A->frozen = true;
+    return self;
+}
+
+VALUE matrix_lup(VALUE self)
+{
+	struct matrix* A = get_matrix_from_rb_value(self);
+    raise_check_square_matrix(A);
+
+    int n = A->n;
+
+    struct lupdecomposition lp;
+    lp.n = n;
+    lp.data = malloc(n * n * sizeof(double));
+    lp.permutation = malloc(n * sizeof(double));
+    c_matrix_lup(n, A->data, lp.data, lp.permutation, &(lp.pivot_sign), &(lp.singular));
+    
+    struct lupdecomposition* p_lp;
+    VALUE result = TypedData_Make_Struct(cLUPDecomposition, struct lupdecomposition, &lup_type, p_lp); 
+    *p_lp = lp;
+
+    return result;
+}
+
 void init_fm_matrix()
 {
     VALUE  mod = rb_define_module("FastMatrix");
@@ -600,12 +784,15 @@ void init_fm_matrix()
 	rb_define_method(cMatrix, "clone", matrix_copy, 0);
 	rb_define_method(cMatrix, "transpose", matrix_transpose, 0);
 	rb_define_method(cMatrix, "+", matrix_add_with, 1);
-	rb_define_method(cMatrix, "+=", matrix_add_from, 1);
+	rb_define_method(cMatrix, "add!", matrix_add_from, 1);
 	rb_define_method(cMatrix, "-", matrix_sub_with, 1);
-	rb_define_method(cMatrix, "-=", matrix_sub_from, 1);
+	rb_define_method(cMatrix, "sub!", matrix_sub_from, 1);
 	rb_define_method(cMatrix, "fill!", matrix_fill, 1);
     rb_define_method(cMatrix, "abs", matrix_abs, 0);
     rb_define_method(cMatrix, ">=", matrix_greater_or_equal, 1);
+    rb_define_method(cMatrix, "<=", matrix_less_or_equal, 1);
+    rb_define_method(cMatrix, ">", matrix_greater, 1);
+    rb_define_method(cMatrix, "<", matrix_less, 1);
     rb_define_method(cMatrix, "determinant", matrix_determinant, 0);
     rb_define_method(cMatrix, "eql?", matrix_equal, 1);
     rb_define_method(cMatrix, "antisymmetric?", matrix_antisymmetric, 0);
@@ -627,6 +814,13 @@ void init_fm_matrix()
     rb_define_method(cMatrix, "permutation?", matrix_permutation, 0);
     rb_define_method(cMatrix, "orthogonal?", matrix_orthogonal, 0);
     rb_define_method(cMatrix, "inverse", matrix_inverse, 0);
+    rb_define_method(cMatrix, "adjugate", matrix_adjugate, 0);
+    rb_define_method(cMatrix, "/", matrix_division, 1);
+    rb_define_method(cMatrix, "**", matrix_exponentiation, 1);
+    rb_define_method(cMatrix, "normal?", matrix_normal, 0);
+    rb_define_method(cMatrix, "unitary?", matrix_unitary, 0);
+    rb_define_method(cMatrix, "freeze", matrix_freeze, 0);
+    rb_define_method(cMatrix, "lup", matrix_lup, 0);
     rb_define_module_function(cMatrix, "vstack", matrix_vstack, -1);
     rb_define_module_function(cMatrix, "hstack", matrix_hstack, -1);
     rb_define_module_function(cMatrix, "scalar", matrix_scalar, 2);

data/ext/fast_matrix/Vector/c_vector.h

@@ -8,6 +8,8 @@ struct vector
 {
     int n;
     double* data;
+    
+    bool frozen;
 };
 
 double c_vector_magnitude(int n, const double* A);

data/ext/fast_matrix/Vector/errors.h

@@ -11,4 +11,11 @@ inline void raise_check_equal_size_vectors(struct vector* A, struct vector* B)
         rb_raise(fm_eIndexError, "Different sizes vectors");
 }
 
+//  check if the vector is frozen and raise an error if not
+inline void raise_check_frozen_vector(struct vector* A)
+{
+    if(A->frozen)
+        rb_raise(fm_eFrozenError, "Can't modify frozen Vector");
+}
+
 #endif /* FAST_MATRIX_VECTOR_ERRORS_H */

data/ext/fast_matrix/Vector/vector.c

@@ -41,6 +41,7 @@ VALUE vector_alloc(VALUE self)
 {
 	struct vector* vct = malloc(sizeof(struct vector));
     vct->data = NULL;
+    vct->frozen = false;
 	return TypedData_Wrap_Struct(self, &vector_type, vct);
 }
 
@@ -51,7 +52,7 @@ VALUE vector_initialize(VALUE self, VALUE size)
     if(n <= 0)
         rb_raise(fm_eIndexError, "Size cannot be negative or zero");
 
-	struct vector* data = get_vector_from_rb_value(self);
+    struct vector* data = get_vector_from_rb_value(self);
     c_vector_init(data, n);
 
 	return self;
@@ -60,9 +61,10 @@ VALUE vector_initialize(VALUE self, VALUE size)
 //  []=
 VALUE vector_set(VALUE self, VALUE idx, VALUE v)
 {
+	struct vector* data = get_vector_from_rb_value(self);
+    raise_check_frozen_vector(data);
     int i = raise_rb_value_to_int(idx);
     double x = raise_rb_value_to_double(v);
-	struct vector* data = get_vector_from_rb_value(self);
 
     i = (i < 0) ? data->n + i : i;
     raise_check_range(i, 0, data->n);
@@ -113,8 +115,9 @@ VALUE vector_add_with(VALUE self, VALUE other)
 
 VALUE vector_add_from(VALUE self, VALUE other)
 {
-    raise_check_rbasic(other, cVector, "vector");
 	struct vector* A = get_vector_from_rb_value(self);
+    raise_check_frozen_vector(A);
+    raise_check_rbasic(other, cVector, "vector");
 	struct vector* B = get_vector_from_rb_value(other);
     raise_check_equal_size_vectors(A, B);
 
@@ -162,8 +165,9 @@ VALUE vector_equal(VALUE self, VALUE other)
 {
     if(RBASIC_CLASS(other) != cVector)
         return Qfalse;
-	struct vector* A = get_vector_from_rb_value(self);
-	struct vector* B = get_vector_from_rb_value(other);
+
+    struct vector* A = get_vector_from_rb_value(self);
+    struct vector* B = get_vector_from_rb_value(other);
 
     if(A->n != B->n)
 		return Qfalse;
@@ -297,7 +301,7 @@ VALUE vector_plus(VALUE self)
     return self;
 }
 
-struct vector** convert_vector_array(int argc, VALUE *argv, struct vector*** vcts)
+void convert_vector_array(int argc, VALUE *argv, struct vector*** vcts)
 {
     for(int i = 0; i < argc; ++i)
         raise_check_rbasic(argv[i], cVector, "vector");
@@ -367,8 +371,9 @@ VALUE vector_zero(VALUE self)
 
 VALUE vector_fill(VALUE self, VALUE value)
 {
-    double d = raise_rb_value_to_double(value);
 	struct vector* A = get_vector_from_rb_value(self);
+    raise_check_frozen_vector(A);
+    double d = raise_rb_value_to_double(value);
     fill_d_array(A->n, A->data, d);
     return self;
 }
@@ -383,7 +388,7 @@ VALUE vector_round(int argc, VALUE *argv, VALUE self)
     else
         d = 0;
 
-	struct vector* A = get_vector_from_rb_value(self);
+    struct vector* A = get_vector_from_rb_value(self);
 
     struct vector* R;
     VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
@@ -441,6 +446,79 @@ VALUE vector_cross_product(int argc, VALUE* argv, VALUE obj)
     return result;
 }
 
+VALUE vector_greater_or_equal(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cVector, "vector");
+	struct vector* A = get_vector_from_rb_value(self);
+	struct vector* B = get_vector_from_rb_value(other);
+
+    raise_check_equal_size_vectors(A, B);
+
+    if(greater_or_equal_d_array(A->n, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE vector_less_or_equal(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cVector, "vector");
+	struct vector* A = get_vector_from_rb_value(self);
+	struct vector* B = get_vector_from_rb_value(other);
+
+    raise_check_equal_size_vectors(A, B);
+
+    if(less_or_equal_d_array(A->n, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE vector_greater(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cVector, "vector");
+	struct vector* A = get_vector_from_rb_value(self);
+	struct vector* B = get_vector_from_rb_value(other);
+
+    raise_check_equal_size_vectors(A, B);
+
+    if(greater_d_array(A->n, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE vector_less(VALUE self, VALUE other)
+{
+    raise_check_rbasic(other, cVector, "vector");
+	struct vector* A = get_vector_from_rb_value(self);
+	struct vector* B = get_vector_from_rb_value(other);
+
+    raise_check_equal_size_vectors(A, B);
+
+    if(less_d_array(A->n, A->data, B->data))
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE vector_freeze(VALUE self)
+{
+	struct vector* A = get_vector_from_rb_value(self);
+    A->frozen = true;
+    return self;
+}
+
+VALUE vector_division(VALUE self, VALUE v)
+{
+    double d = raise_rb_value_to_double(v);
+    struct vector* A = get_vector_from_rb_value(self);
+
+    struct vector* R;
+    VALUE result = TypedData_Make_Struct(cVector, struct vector, &vector_type, R);
+    c_vector_init(R, A->n);
+
+    multiply_d_array_to_result(A->n, A->data, 1/d, R->data);
+
+    return result;
+}
+
 void init_fm_vector()
 {
     VALUE  mod = rb_define_module("FastMatrix");
@@ -453,9 +531,9 @@ void init_fm_vector()
 	rb_define_method(cVector, "[]=", vector_set, 2);
 	rb_define_method(cVector, "size", vector_length, 0);
 	rb_define_method(cVector, "+", vector_add_with, 1);
-	rb_define_method(cVector, "+=", vector_add_from, 1);
+	rb_define_method(cVector, "add!", vector_add_from, 1);
 	rb_define_method(cVector, "-", vector_sub_with, 1);
-	rb_define_method(cVector, "-=", vector_sub_from, 1);
+	rb_define_method(cVector, "sub!", vector_sub_from, 1);
 	rb_define_method(cVector, "eql?", vector_equal, 1);
 	rb_define_method(cVector, "clone", vector_copy, 0);
 	rb_define_method(cVector, "magnitude", vector_magnitude, 0);
@@ -471,6 +549,12 @@ void init_fm_vector()
 	rb_define_method(cVector, "round", vector_round, -1);
 	rb_define_method(cVector, "inner_product", vector_inner_product, 1);
 	rb_define_method(cVector, "angle_with", vector_angle_with, 1);
+	rb_define_method(cVector, ">=", vector_greater_or_equal, 1);
+	rb_define_method(cVector, "<=", vector_less_or_equal, 1);
+	rb_define_method(cVector, ">", vector_greater, 1);
+	rb_define_method(cVector, "<", vector_less, 1);
+	rb_define_method(cVector, "/", vector_division, 1);
+	rb_define_method(cVector, "freeze", vector_freeze, 0);
 	rb_define_module_function(cVector, "independent?", vector_independent, -1);
 	rb_define_module_function(cVector, "cross_product", vector_cross_product, -1);
 }