fast_matrix 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0e98406e186191f8308eeca9cc81293343f44fd4a6e97559c6b4e3ce2d8b0b7
-  data.tar.gz: a6e2c1b4f49e62c76e27e23df7a358ca22c927099868f990488e5ea5c1ca21e6
+  metadata.gz: 34d254515edd7b453efe7fdedb7b360c462faa53c9ec13de7f4beb5cf989e536
+  data.tar.gz: 5b9c35116c61a67f498badf12980d71d275e8020900ab48eb710aa74cd17ed71
 SHA512:
-  metadata.gz: 596d0c7a7bec078b328968e0a1a0c20e83076215594807395e2323eabf239fa5a61d88cde3564219b28f8520f97d40e06d34e39e5aea8ec0db0c08befddc2b39
-  data.tar.gz: a53d3c85372d7f9273cdee68789a2fadecae44f05f2f6244c6661970de890b246e81d44800354964ea32cf5f80292f2464ca7fb6b2b30683a90f6fcd3cdeba74
+  metadata.gz: a011340ce71b58856512df1b6da78af5f510ae6789a8cdfd69f3793370533f66d6c2a6647abde1c5ef42a2928f8118528d976f6402be3ff3a81f16e519ec700a
+  data.tar.gz: f618591f305fb3d9d2b97819833398e571fa99e0fcf43ad74fc8152e9fb3e6c7d97a1128933cbbc9b8b4b8bda642e1d6f5e7be4a04abc1c47d994981f43ac560

data/README.md

@@ -1,6 +1,8 @@
-[![Build Status](https://travis-ci.org/mmcs-ruby/fast_matrix.svg?branch=master)](https://travis-ci.org/mmcs-ruby/fast_matrix)
-[![Maintainability](https://api.codeclimate.com/v1/badges/fd171bae2ca444aaca29/maintainability)](https://codeclimate.com/github/mmcs-ruby/fast_matrix/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/fd171bae2ca444aaca29/test_coverage)](https://codeclimate.com/github/mmcs-ruby/fast_matrix/test_coverage)
+|Gem|Activity|Code|Issue|Statistic|
+|--:|--:|--:|--:|--:|
+|![Gem](https://img.shields.io/gem/v/fast_matrix?color=light)|![GitHub last commit](https://img.shields.io/github/last-commit/mmcs-ruby/fast_matrix)|[![Build Status](https://travis-ci.org/mmcs-ruby/fast_matrix.svg?branch=master)](https://travis-ci.org/mmcs-ruby/fast_matrix)|![GitHub issues](https://img.shields.io/github/issues-raw/mmcs-ruby/fast_matrix)|[![Top language](https://img.shields.io/github/languages/top/mmcs-ruby/fast_matrix.svg)](https://img.shields.io/github/languages/top/mmcs-ruby/fast_matrix.svg)
+|[![Downloads](https://img.shields.io/gem/dt/fast_matrix.svg)]((https://img.shields.io/gem/dt/fast_matrix.svg))|![GitHub commits since tagged version](https://img.shields.io/github/commits-since/mmcs-ruby/fast_matrix/v0.2.0/develop?color=light)|[![Maintainability](https://api.codeclimate.com/v1/badges/fd171bae2ca444aaca29/maintainability)](https://codeclimate.com/github/mmcs-ruby/fast_matrix/maintainability)|![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/mmcs-ruby/fast_matrix)|[![Languages](https://img.shields.io/github/languages/count/mmcs-ruby/fast_matrix.svg)](https://img.shields.io/github/languages/count/mmcs-ruby/fast_matrix.svg)
+|[![Downloads Latest](https://img.shields.io/gem/dtv/fast_matrix.svg)](https://badge.fury.io/rb/fast_matrix.svg)|![GitHub commit activity](https://img.shields.io/github/commit-activity/m/mmcs-ruby/fast_matrix?color=light)|[![Test Coverage](https://api.codeclimate.com/v1/badges/fd171bae2ca444aaca29/test_coverage)](https://codeclimate.com/github/mmcs-ruby/fast_matrix/test_coverage)|![GitHub issues by-label](https://img.shields.io/github/issues-raw/mmcs-ruby/fast_matrix/bug)|![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/mmcs-ruby/fast_matrix)
 
 # FastMatrix
 

data/ext/fast_matrix/Helper/c_array_opeartions.c

@@ -78,6 +78,30 @@ bool greater_or_equal_d_array(int len, const double* A, const double* B)
     return true;
 }
 
+bool less_or_equal_d_array(int len, const double* A, const double* B)
+{
+    for(int i = 0; i < len; ++i)
+        if(A[i] > B[i])
+            return false;
+    return true;
+}
+
+bool greater_d_array(int len, const double* A, const double* B)
+{
+    for(int i = 0; i < len; ++i)
+        if(A[i] <= B[i])
+            return false;
+    return true;
+}
+
+bool less_d_array(int len, const double* A, const double* B)
+{
+    for(int i = 0; i < len; ++i)
+        if(A[i] >= B[i])
+            return false;
+    return true;
+}
+
 bool zero_d_array(int len, const double* A)
 {
     for(int i = 0; i < len; ++i)

data/ext/fast_matrix/Helper/c_array_operations.h

@@ -15,6 +15,9 @@ void sub_d_arrays_to_first(int len, double* dif, const double* sub);
 bool equal_d_arrays(int len, const double* A, const double* B);
 void abs_d_array(int len, const double* A, double* B);
 bool greater_or_equal_d_array(int len, const double* A, const double* B);
+bool less_or_equal_d_array(int len, const double* A, const double* B);
+bool greater_d_array(int len, const double* A, const double* B);
+bool less_d_array(int len, const double* A, const double* B);
 bool zero_d_array(int len, const double* A);
 void swap_d_arrays(int len, double* A, double* B);
 void round_d_array(int len, const double* Input, double* Output, int acc);

data/ext/fast_matrix/Helper/errors.c

@@ -2,6 +2,7 @@
 
 VALUE fm_eTypeError;
 VALUE fm_eIndexError;
+VALUE fm_eFrozenError;
 
 double raise_rb_value_to_double(VALUE v)
 {
@@ -40,4 +41,5 @@ void init_fm_errors()
     
     fm_eTypeError  = rb_define_class_under(mod, "TypeError",  rb_eTypeError);
     fm_eIndexError = rb_define_class_under(mod, "IndexError", rb_eIndexError);
+    fm_eFrozenError = rb_define_class_under(mod, "FrozenError", rb_eFrozenError);
 }

data/ext/fast_matrix/Helper/errors.h

@@ -5,6 +5,7 @@
 
 extern VALUE fm_eTypeError;
 extern VALUE fm_eIndexError;
+extern VALUE fm_eFrozenError;
 
 //  convert ruby value to double or raise an error if this is not possible
 double raise_rb_value_to_double(VALUE v);

data/ext/fast_matrix/LUPDecomposition/c_lup.c

@@ -0,0 +1,97 @@
+#include "LUPDecomposition/c_lup.h"
+#include "Helper/c_array_operations.h"
+
+void c_lup_l(int n, const double* LUP, double* L)
+{
+    for(int i = 0; i < n; ++i)
+    {
+        double* l_line = L + n * i;
+        const double* lup_line = LUP + n * i;
+        for(int j = 0; j < n; ++j)
+        {
+            if(i < j)
+                l_line[j] = 0;
+            else if(i == j)
+                l_line[j] = 1;
+            else
+                l_line[j] = lup_line[j];
+        }
+    }
+}
+
+void c_lup_u(int n, const double* LUP, double* U)
+{
+    for(int i = 0; i < n; ++i)
+    {
+        double* u_line = U + n * i;
+        const double* lup_line = LUP + n * i;
+        for(int j = 0; j < n; ++j)
+        {
+            if(i > j)
+                u_line[j] = 0;
+            else
+                u_line[j] = lup_line[j];
+        }
+    }
+}
+
+void c_lup_p(int n, const int* prm, double* P)
+{
+    for(int i = 0; i < n; ++i)
+    {
+        double* p_line = P + n * i;
+        int current = prm[i];
+        for(int j = 0; j < current; ++j)
+            p_line[j] = 0;
+        p_line[current] = 1;
+        for(int j = current + 1; j < n; ++j)
+            p_line[j] = 0;
+    }
+}
+
+double c_lup_determinant(int n, double* LUP, int sign)
+{
+    double res = sign;
+    for(int i = 0; i < n; ++i)
+        res *= LUP[i + i * n];
+    return res;
+}
+
+void c_lup_apply_permutation(int m, int n, const double* A, const int* permutation, double* R)
+{
+    for(int i = 0; i < n; ++i)
+        copy_d_array(m, A + m * permutation[i], R + m * i);
+}
+
+void c_lup_solve(int m, int n, const double* lp, const double* B, const int* permutation, double* R)
+{
+    c_lup_apply_permutation(m, n, B, permutation, R);
+
+    for(int k = 0; k < n; ++k)
+        for(int i = k + 1; i < n; ++i)
+        {
+            double* line = R + i * m;
+            int mul = lp[i * n + k];
+
+            for(int j = 0; j < m; ++j)
+                line[j] -= line[j] * mul;
+        }
+    
+    for(int k = n - 1; k >= 0; --k)
+    {
+        double* line = R + k * m;
+        int div = lp[k * n + k];
+
+        for(int j = 0; j < m; ++j)
+            line[j] /= div;
+        
+        for(int i = 0; i < k; ++i)
+        {
+            double* line_out = R + i * m;
+            int mul = lp[i * n + k];
+            
+            for(int j = 0; j < m; ++j)
+                line_out[j] -= line[j] * mul;
+        }
+    }
+}

data/ext/fast_matrix/LUPDecomposition/c_lup.h

@@ -0,0 +1,22 @@
+#ifndef FAST_MATRIX_MATRIX_C_LUPDECOMPOSITION_H
+#define FAST_MATRIX_MATRIX_C_LUPDECOMPOSITION_H 1
+
+#include <stdbool.h>
+
+struct lupdecomposition
+{
+    int n;
+    double* data;
+    int* permutation;
+    int pivot_sign;
+    bool singular;
+};
+
+double c_lup_determinant(int n, double* LUP, int sign);
+
+void c_lup_l(int n, const double* LUP, double* L);
+void c_lup_u(int n, const double* LUP, double* U);
+void c_lup_p(int n, const int* prm, double* P);
+void c_lup_solve(int m, int n, const double* lp, const double* B, const int* permutation, double* R);
+
+#endif /* FAST_MATRIX_MATRIX_C_LUPDECOMPOSITION_H */

data/ext/fast_matrix/LUPDecomposition/helper.h

@@ -0,0 +1,14 @@
+#ifndef FAST_MATRIX_LUPDECOMPOSITION_HELPER_H
+#define FAST_MATRIX_LUPDECOMPOSITION_HELPER_H 1
+
+#include "ruby.h"
+#include "Matrix/c_matrix.h"
+
+inline struct lupdecomposition* get_lup_from_rb_value(VALUE lp)
+{
+	struct lupdecomposition* data;
+	TypedData_Get_Struct(lp, struct lupdecomposition, &lup_type, data);
+    return data;
+}
+
+#endif /* FAST_MATRIX_LUPDECOMPOSITION_HELPER_H */

data/ext/fast_matrix/LUPDecomposition/lup.c

@@ -0,0 +1,124 @@
+#include "LUPDecomposition/lup.h"
+#include "LUPDecomposition/c_lup.h"
+#include "LUPDecomposition/helper.h"
+#include "Matrix/matrix.h"
+#include "Matrix/helper.h"
+#include "Helper/errors.h"
+
+VALUE cLUPDecomposition;
+
+void lup_free(void* data);
+size_t lup_size(const void* data);
+
+const rb_data_type_t lup_type =
+{
+    .wrap_struct_name = "lupdecomposition",
+    .function =
+    {
+        .dmark = NULL,
+        .dfree = lup_free,
+        .dsize = lup_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+void lup_free(void* data)
+{
+    free(((*(struct lupdecomposition*)data)).data);
+    free(((*(struct lupdecomposition*)data)).permutation);
+    free(data);
+}
+
+size_t lup_size(const void* data)
+{
+	return sizeof(struct lupdecomposition);
+}
+
+VALUE lup_alloc(VALUE self)
+{
+	struct lupdecomposition* lp = malloc(sizeof(struct lupdecomposition));
+    lp->data = NULL;
+    lp->permutation = NULL;
+    lp->pivot_sign = 1;
+    lp->singular = false;
+	return TypedData_Wrap_Struct(self, &lup_type, lp);
+}
+
+VALUE lup_l(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    MAKE_MATRIX_AND_RB_VALUE(R, result, lp->n, lp->n);
+    c_lup_l(lp->n, lp->data, R->data);
+    return result;
+}
+
+VALUE lup_u(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    MAKE_MATRIX_AND_RB_VALUE(R, result, lp->n, lp->n);
+    c_lup_u(lp->n, lp->data, R->data);
+    return result;
+}
+
+VALUE lup_p(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    MAKE_MATRIX_AND_RB_VALUE(R, result, lp->n, lp->n);
+    c_lup_p(lp->n, lp->permutation, R->data);
+    return result;
+}
+
+VALUE lup_determinant(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    return DBL2NUM(c_lup_determinant(lp->n, lp->data, lp->pivot_sign));
+}
+
+VALUE lup_singular(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    if(lp->singular)
+        return Qtrue;
+    return Qfalse;
+}
+
+VALUE lup_pivots(VALUE self)
+{
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+    VALUE* v = malloc(lp->n * sizeof(VALUE));
+    for(int i = 0; i < lp->n; ++i)
+        v[i] = INT2NUM(lp->permutation[i]);
+    VALUE res = rb_ary_new_from_values(lp->n, v);
+    free(v);
+    return res;
+}
+
+VALUE lup_solve(VALUE self, VALUE mtrx)
+{
+    raise_check_rbasic(mtrx, cMatrix, "matrix");
+	struct lupdecomposition* lp = get_lup_from_rb_value(self);
+	struct matrix* M = get_matrix_from_rb_value(mtrx);
+    if(lp->singular)
+        rb_raise(fm_eIndexError, "Matrix is singular");
+    if(lp->n != M->n)
+        rb_raise(fm_eIndexError, "Columns of different size");
+
+    MAKE_MATRIX_AND_RB_VALUE(C, result, M->m, lp->n);
+    c_lup_solve(M->m, lp->n, lp->data, M->data, lp->permutation, C->data);
+    return result;
+}
+
+void init_fm_lup()
+{
+	cLUPDecomposition = rb_define_class_under(cMatrix, "LUPDecomposition", rb_cData);
+	rb_define_alloc_func(cLUPDecomposition, lup_alloc);
+
+	rb_define_method(cLUPDecomposition, "l", lup_l, 0);
+	rb_define_method(cLUPDecomposition, "u", lup_u, 0);
+	rb_define_method(cLUPDecomposition, "p", lup_p, 0);
+	rb_define_method(cLUPDecomposition, "det", lup_determinant, 0);
+	rb_define_method(cLUPDecomposition, "singular?", lup_singular, 0);
+	rb_define_method(cLUPDecomposition, "pivots", lup_pivots, 0);
+	rb_define_method(cLUPDecomposition, "solve", lup_solve, 1);
+}

data/ext/fast_matrix/LUPDecomposition/lup.h

@@ -0,0 +1,10 @@
+#ifndef FAST_MATRIX_LUPDECOMPOSITION_H
+#define FAST_MATRIX_LUPDECOMPOSITION_H 1
+
+#include "ruby.h"
+
+extern VALUE cLUPDecomposition;
+extern const rb_data_type_t lup_type;
+void init_fm_lup();
+
+#endif /* FAST_MATRIX_LUPDECOMPOSITION_H */

data/ext/fast_matrix/Matrix/c_matrix.c

@@ -1,4 +1,5 @@
 #include "c_matrix.h"
+#include "Helper/c_array_operations.h"
 
 // in  - matrix m x n
 // out - matrix n x m
@@ -604,3 +605,133 @@ bool c_matrix_inverse(int n, const double* A, double* B)
     free(M);
     return true;
 }
+
+bool c_matrix_adjugate(int n, const double* A, double* B)
+{
+    if(!c_matrix_inverse(n, A, B))
+        return false;
+    double d = c_matrix_determinant(n, A);
+    multiply_d_array(n * n, B, d);
+    return true;
+}
+
+void c_matrix_recursive_exponentiation(int n, const double* A, double* B, int d)
+{
+    if(d == 2)
+        return c_matrix_strassen(n, n, n, A, A, B);
+    
+    double* C = malloc(n * n * sizeof(double));
+    
+    if(d == 3)
+    {
+        c_matrix_strassen(n, n, n, A, A, C);
+        c_matrix_strassen(n, n, n, A, C, B);
+        free(C);
+        return;
+    }
+
+    c_matrix_recursive_exponentiation(n, A, C, d / 2);
+    
+    if(d % 2 == 0)
+    {
+        c_matrix_strassen(n, n, n, C, C, B);
+        free(C);
+        return;
+    }
+    
+    double* D = malloc(n * n * sizeof(double));
+    
+    c_matrix_strassen(n, n, n, C, C, D);
+    c_matrix_strassen(n, n, n, A, D, B);
+    free(C);
+    free(D);
+}
+
+bool c_matrix_exponentiation(int m, int n, const double* A, double* B, int d)
+{
+    if(d == 1)
+    {
+        copy_d_array(m * n, A, B);
+        return true;
+    }
+
+    if(m != n)
+        return false;
+
+    if(d == 0)
+    {
+        c_matrix_shift_identity(n, B, n);
+        return true;
+    }
+
+    if(d > 0)
+    {
+        c_matrix_recursive_exponentiation(n, A, B, d);
+        return true;
+    }
+
+    if(d == -1)
+    {
+        c_matrix_inverse(n, A, B);
+        return true;
+    }
+
+    double* C = malloc(n * n * sizeof(double));
+    c_matrix_inverse(n, A, C);
+    c_matrix_recursive_exponentiation(n, C, B, -d);
+    free(C);
+    
+    return true;
+}
+
+void c_matrix_fill_range_array(int n, int* V)
+{
+    for(int i = 0; i < n; ++i)
+        V[i] = i;
+}
+
+void c_matrix_lup(int n, const double* A, double* LU, int* V, int* sign, bool* singular)
+{
+    copy_d_array(n * n, A, LU);
+    c_matrix_fill_range_array(n, V);
+    *sign = 1;
+    *singular = false;
+
+    for(int i = 0; i < n; ++i)
+    {
+        double* line = LU + n * i;
+        double current = 0;
+        int swap_line = -1;
+        for(int j = i; j < n; ++j)
+            if(fabs(LU[j * n + i]) > current)
+            {
+                swap_line = j;
+                current = fabs(LU[j * n + i]);
+            }
+
+        if(swap_line == -1)
+        {
+            *singular = true;
+            continue;
+        }
+
+        if(swap_line != i)
+        {
+            swap_d_arrays(n, LU + swap_line * n, line);
+            int buf = V[i];
+            V[i] = V[swap_line];
+            V[swap_line] = buf;
+            *sign = -*sign;
+        }
+
+        current = line[i];
+        for(int j = i + 1; j < n; ++j)
+        {
+            double* w_line = LU + j * n;
+            w_line[i] = w_line[i] / current;
+            double start = w_line[i];
+            for(int k = i + 1; k < n; ++k)
+                w_line[k] -= start * line[k];
+        }
+    }
+}