classifier 1.4.4 → 2.1.0

data/ext/classifier/matrix.c

@@ -0,0 +1,387 @@
+/*
+ * matrix.c
+ * Matrix implementation for Classifier native linear algebra
+ */
+
+#include "linalg.h"
+
+const rb_data_type_t cmatrix_type = {
+    .wrap_struct_name = "Classifier::Linalg::Matrix",
+    .function = {
+        .dmark = NULL,
+        .dfree = cmatrix_free,
+        .dsize = NULL,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+/* Allocate a new CMatrix */
+CMatrix *cmatrix_alloc(size_t rows, size_t cols)
+{
+    CMatrix *m = ALLOC(CMatrix);
+    m->rows = rows;
+    m->cols = cols;
+    m->data = ALLOC_N(double, rows * cols);
+    memset(m->data, 0, rows * cols * sizeof(double));
+    return m;
+}
+
+/* Free a CMatrix */
+void cmatrix_free(void *ptr)
+{
+    CMatrix *m = (CMatrix *)ptr;
+    if (m) {
+        if (m->data) xfree(m->data);
+        xfree(m);
+    }
+}
+
+/* Transpose a matrix */
+CMatrix *cmatrix_transpose(CMatrix *m)
+{
+    CMatrix *result = cmatrix_alloc(m->cols, m->rows);
+    for (size_t i = 0; i < m->rows; i++) {
+        for (size_t j = 0; j < m->cols; j++) {
+            MAT_AT(result, j, i) = MAT_AT(m, i, j);
+        }
+    }
+    return result;
+}
+
+/* Matrix multiplication */
+CMatrix *cmatrix_multiply(CMatrix *a, CMatrix *b)
+{
+    if (a->cols != b->rows) {
+        rb_raise(rb_eArgError, "Matrix dimensions don't match for multiplication: %ldx%ld * %ldx%ld",
+                 (long)a->rows, (long)a->cols, (long)b->rows, (long)b->cols);
+    }
+
+    CMatrix *result = cmatrix_alloc(a->rows, b->cols);
+
+    for (size_t i = 0; i < a->rows; i++) {
+        for (size_t j = 0; j < b->cols; j++) {
+            double sum = 0.0;
+            for (size_t k = 0; k < a->cols; k++) {
+                sum += MAT_AT(a, i, k) * MAT_AT(b, k, j);
+            }
+            MAT_AT(result, i, j) = sum;
+        }
+    }
+    return result;
+}
+
+/* Matrix-vector multiplication */
+CVector *cmatrix_multiply_vector(CMatrix *m, CVector *v)
+{
+    if (m->cols != v->size) {
+        rb_raise(rb_eArgError, "Matrix columns (%ld) must match vector size (%ld)",
+                 (long)m->cols, (long)v->size);
+    }
+
+    CVector *result = cvector_alloc(m->rows);
+
+    for (size_t i = 0; i < m->rows; i++) {
+        double sum = 0.0;
+        for (size_t j = 0; j < m->cols; j++) {
+            sum += MAT_AT(m, i, j) * v->data[j];
+        }
+        result->data[i] = sum;
+    }
+    return result;
+}
+
+/* Create diagonal matrix from vector */
+CMatrix *cmatrix_diagonal(CVector *v)
+{
+    CMatrix *result = cmatrix_alloc(v->size, v->size);
+    for (size_t i = 0; i < v->size; i++) {
+        MAT_AT(result, i, i) = v->data[i];
+    }
+    return result;
+}
+
+/* Ruby allocation function */
+static VALUE rb_cmatrix_alloc_func(VALUE klass)
+{
+    CMatrix *m = cmatrix_alloc(0, 0);
+    return TypedData_Wrap_Struct(klass, &cmatrix_type, m);
+}
+
+/*
+ * Matrix.alloc(*rows)
+ * Create a new matrix from nested arrays
+ */
+static VALUE rb_cmatrix_s_alloc(int argc, VALUE *argv, VALUE klass)
+{
+    CMatrix *m;
+    VALUE result;
+
+    if (argc == 0) {
+        rb_raise(rb_eArgError, "Matrix.alloc requires at least one row");
+    }
+
+    /* Handle single array argument containing rows */
+    VALUE rows_ary;
+    if (argc == 1 && RB_TYPE_P(argv[0], T_ARRAY)) {
+        VALUE first = rb_ary_entry(argv[0], 0);
+        if (RB_TYPE_P(first, T_ARRAY)) {
+            rows_ary = argv[0];
+        } else {
+            /* Single row */
+            rows_ary = rb_ary_new_from_values(argc, argv);
+        }
+    } else {
+        rows_ary = rb_ary_new_from_values(argc, argv);
+    }
+
+    long num_rows = RARRAY_LEN(rows_ary);
+    if (num_rows == 0) {
+        rb_raise(rb_eArgError, "Matrix cannot be empty");
+    }
+
+    VALUE first_row = rb_ary_entry(rows_ary, 0);
+    long num_cols = RARRAY_LEN(first_row);
+
+    m = cmatrix_alloc((size_t)num_rows, (size_t)num_cols);
+
+    for (long i = 0; i < num_rows; i++) {
+        VALUE row = rb_ary_entry(rows_ary, i);
+        if (RARRAY_LEN(row) != num_cols) {
+            cmatrix_free(m);
+            rb_raise(rb_eArgError, "All rows must have the same length");
+        }
+        for (long j = 0; j < num_cols; j++) {
+            MAT_AT(m, i, j) = NUM2DBL(rb_ary_entry(row, j));
+        }
+    }
+
+    result = TypedData_Wrap_Struct(klass, &cmatrix_type, m);
+    return result;
+}
+
+/*
+ * Matrix.diag(vector_or_array)
+ * Create diagonal matrix from vector
+ */
+static VALUE rb_cmatrix_s_diag(VALUE klass, VALUE arg)
+{
+    CVector *v;
+    CMatrix *m;
+    int free_v = 0;
+
+    if (rb_obj_is_kind_of(arg, cClassifierVector)) {
+        GET_CVECTOR(arg, v);
+    } else if (RB_TYPE_P(arg, T_ARRAY)) {
+        long len = RARRAY_LEN(arg);
+        v = cvector_alloc((size_t)len);
+        free_v = 1;
+        for (long i = 0; i < len; i++) {
+            v->data[i] = NUM2DBL(rb_ary_entry(arg, i));
+        }
+    } else {
+        rb_raise(rb_eTypeError, "Expected Vector or Array");
+        return Qnil;
+    }
+
+    m = cmatrix_diagonal(v);
+    if (free_v) cvector_free(v);
+
+    return TypedData_Wrap_Struct(klass, &cmatrix_type, m);
+}
+
+/* Matrix#size -> [rows, cols] */
+static VALUE rb_cmatrix_size(VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    return rb_ary_new_from_args(2, SIZET2NUM(m->rows), SIZET2NUM(m->cols));
+}
+
+/* Matrix#row_size */
+static VALUE rb_cmatrix_row_size(VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    return SIZET2NUM(m->rows);
+}
+
+/* Matrix#column_size */
+static VALUE rb_cmatrix_column_size(VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    return SIZET2NUM(m->cols);
+}
+
+/* Matrix#[](i, j) */
+static VALUE rb_cmatrix_aref(VALUE self, VALUE row, VALUE col)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    long i = NUM2LONG(row);
+    long j = NUM2LONG(col);
+
+    if (i < 0) i += m->rows;
+    if (j < 0) j += m->cols;
+    if (i < 0 || (size_t)i >= m->rows || j < 0 || (size_t)j >= m->cols) {
+        rb_raise(rb_eIndexError, "index out of bounds");
+    }
+
+    return DBL2NUM(MAT_AT(m, i, j));
+}
+
+/* Matrix#[]=(i, j, val) */
+static VALUE rb_cmatrix_aset(VALUE self, VALUE row, VALUE col, VALUE val)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    long i = NUM2LONG(row);
+    long j = NUM2LONG(col);
+
+    if (i < 0) i += m->rows;
+    if (j < 0) j += m->cols;
+    if (i < 0 || (size_t)i >= m->rows || j < 0 || (size_t)j >= m->cols) {
+        rb_raise(rb_eIndexError, "index out of bounds");
+    }
+
+    MAT_AT(m, i, j) = NUM2DBL(val);
+    return val;
+}
+
+/* Matrix#trans (transpose) */
+static VALUE rb_cmatrix_trans(VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    CMatrix *result = cmatrix_transpose(m);
+    return TypedData_Wrap_Struct(cClassifierMatrix, &cmatrix_type, result);
+}
+
+/* Matrix#column(n) -> Vector */
+static VALUE rb_cmatrix_column(VALUE self, VALUE col_idx)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    long j = NUM2LONG(col_idx);
+
+    if (j < 0) j += m->cols;
+    if (j < 0 || (size_t)j >= m->cols) {
+        rb_raise(rb_eIndexError, "column index out of bounds");
+    }
+
+    CVector *v = cvector_alloc(m->rows);
+    v->is_col = 1;
+    for (size_t i = 0; i < m->rows; i++) {
+        v->data[i] = MAT_AT(m, i, j);
+    }
+
+    return TypedData_Wrap_Struct(cClassifierVector, &cvector_type, v);
+}
+
+/* Matrix#row(n) -> Vector */
+static VALUE rb_cmatrix_row(VALUE self, VALUE row_idx)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    long i = NUM2LONG(row_idx);
+
+    if (i < 0) i += m->rows;
+    if (i < 0 || (size_t)i >= m->rows) {
+        rb_raise(rb_eIndexError, "row index out of bounds");
+    }
+
+    CVector *v = cvector_alloc(m->cols);
+    v->is_col = 0;
+    memcpy(v->data, &MAT_AT(m, i, 0), m->cols * sizeof(double));
+
+    return TypedData_Wrap_Struct(cClassifierVector, &cvector_type, v);
+}
+
+/* Matrix#to_a */
+static VALUE rb_cmatrix_to_a(VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    VALUE ary = rb_ary_new_capa((long)m->rows);
+
+    for (size_t i = 0; i < m->rows; i++) {
+        VALUE row = rb_ary_new_capa((long)m->cols);
+        for (size_t j = 0; j < m->cols; j++) {
+            rb_ary_push(row, DBL2NUM(MAT_AT(m, i, j)));
+        }
+        rb_ary_push(ary, row);
+    }
+    return ary;
+}
+
+/* Matrix#* - multiply with matrix or vector */
+static VALUE rb_cmatrix_mul(VALUE self, VALUE other)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+
+    if (rb_obj_is_kind_of(other, cClassifierMatrix)) {
+        CMatrix *b;
+        GET_CMATRIX(other, b);
+        CMatrix *result = cmatrix_multiply(m, b);
+        return TypedData_Wrap_Struct(cClassifierMatrix, &cmatrix_type, result);
+    } else if (rb_obj_is_kind_of(other, cClassifierVector)) {
+        CVector *v;
+        GET_CVECTOR(other, v);
+        CVector *result = cmatrix_multiply_vector(m, v);
+        return TypedData_Wrap_Struct(cClassifierVector, &cvector_type, result);
+    } else if (RB_TYPE_P(other, T_FLOAT) || RB_TYPE_P(other, T_FIXNUM)) {
+        /* Scalar multiplication */
+        double scalar = NUM2DBL(other);
+        CMatrix *result = cmatrix_alloc(m->rows, m->cols);
+        for (size_t i = 0; i < m->rows * m->cols; i++) {
+            result->data[i] = m->data[i] * scalar;
+        }
+        return TypedData_Wrap_Struct(cClassifierMatrix, &cmatrix_type, result);
+    }
+
+    rb_raise(rb_eTypeError, "Cannot multiply Matrix with %s", rb_obj_classname(other));
+    return Qnil;
+}
+
+/* Matrix#_dump for Marshal */
+static VALUE rb_cmatrix_dump(VALUE self, VALUE depth)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+    VALUE ary = rb_cmatrix_to_a(self);
+    return rb_marshal_dump(ary, Qnil);
+}
+
+/* Matrix._load for Marshal */
+static VALUE rb_cmatrix_s_load(VALUE klass, VALUE str)
+{
+    VALUE ary = rb_marshal_load(str);
+    long argc = RARRAY_LEN(ary);
+    VALUE *argv = RARRAY_PTR(ary);
+    return rb_cmatrix_s_alloc((int)argc, argv, klass);
+}
+
+void Init_matrix(void)
+{
+    cClassifierMatrix = rb_define_class_under(mClassifierLinalg, "Matrix", rb_cObject);
+
+    rb_define_alloc_func(cClassifierMatrix, rb_cmatrix_alloc_func);
+    rb_define_singleton_method(cClassifierMatrix, "alloc", rb_cmatrix_s_alloc, -1);
+    rb_define_singleton_method(cClassifierMatrix, "diag", rb_cmatrix_s_diag, 1);
+    rb_define_singleton_method(cClassifierMatrix, "diagonal", rb_cmatrix_s_diag, 1);
+    rb_define_singleton_method(cClassifierMatrix, "_load", rb_cmatrix_s_load, 1);
+
+    rb_define_method(cClassifierMatrix, "size", rb_cmatrix_size, 0);
+    rb_define_method(cClassifierMatrix, "row_size", rb_cmatrix_row_size, 0);
+    rb_define_method(cClassifierMatrix, "column_size", rb_cmatrix_column_size, 0);
+    rb_define_method(cClassifierMatrix, "[]", rb_cmatrix_aref, 2);
+    rb_define_method(cClassifierMatrix, "[]=", rb_cmatrix_aset, 3);
+    rb_define_method(cClassifierMatrix, "trans", rb_cmatrix_trans, 0);
+    rb_define_alias(cClassifierMatrix, "transpose", "trans");
+    rb_define_method(cClassifierMatrix, "column", rb_cmatrix_column, 1);
+    rb_define_method(cClassifierMatrix, "row", rb_cmatrix_row, 1);
+    rb_define_method(cClassifierMatrix, "to_a", rb_cmatrix_to_a, 0);
+    rb_define_method(cClassifierMatrix, "*", rb_cmatrix_mul, 1);
+    rb_define_method(cClassifierMatrix, "_dump", rb_cmatrix_dump, 1);
+}

data/ext/classifier/svd.c

@@ -0,0 +1,208 @@
+/*
+ * svd.c
+ * Jacobi SVD implementation for Classifier native linear algebra
+ *
+ * This is a port of the pure Ruby SVD implementation from
+ * lib/classifier/extensions/vector.rb
+ */
+
+#include "linalg.h"
+
+#define SVD_MAX_SWEEPS 20
+#define SVD_CONVERGENCE_THRESHOLD 0.001
+
+/* Helper: Create identity matrix */
+static CMatrix *cmatrix_identity(size_t n)
+{
+    CMatrix *m = cmatrix_alloc(n, n);
+    for (size_t i = 0; i < n; i++) {
+        MAT_AT(m, i, i) = 1.0;
+    }
+    return m;
+}
+
+/* Helper: Clone a matrix */
+static CMatrix *cmatrix_clone(CMatrix *m)
+{
+    CMatrix *result = cmatrix_alloc(m->rows, m->cols);
+    memcpy(result->data, m->data, m->rows * m->cols * sizeof(double));
+    return result;
+}
+
+/* Helper: Apply Jacobi rotation to matrix Q and accumulator V */
+static void apply_jacobi_rotation(CMatrix *q, CMatrix *v, size_t p, size_t r,
+                                   double cosine, double sine)
+{
+    size_t n = q->rows;
+
+    /* Apply rotation to Q: Q = R^T * Q * R */
+    /* First: Q = Q * R (affects columns p and r) */
+    for (size_t i = 0; i < n; i++) {
+        double qip = MAT_AT(q, i, p);
+        double qir = MAT_AT(q, i, r);
+        MAT_AT(q, i, p) = cosine * qip - sine * qir;
+        MAT_AT(q, i, r) = sine * qip + cosine * qir;
+    }
+
+    /* Second: Q = R^T * Q (affects rows p and r) */
+    for (size_t j = 0; j < n; j++) {
+        double qpj = MAT_AT(q, p, j);
+        double qrj = MAT_AT(q, r, j);
+        MAT_AT(q, p, j) = cosine * qpj - sine * qrj;
+        MAT_AT(q, r, j) = sine * qpj + cosine * qrj;
+    }
+
+    /* Accumulate rotation in V: V = V * R */
+    for (size_t i = 0; i < v->rows; i++) {
+        double vip = MAT_AT(v, i, p);
+        double vir = MAT_AT(v, i, r);
+        MAT_AT(v, i, p) = cosine * vip - sine * vir;
+        MAT_AT(v, i, r) = sine * vip + cosine * vir;
+    }
+}
+
+/*
+ * Jacobi SVD decomposition
+ *
+ * Computes A = U * S * V^T where:
+ * - U is m x m orthogonal
+ * - S is m x n diagonal (returned as vector of singular values)
+ * - V is n x n orthogonal
+ *
+ * Based on one-sided Jacobi algorithm from vector.rb
+ */
+void jacobi_svd(CMatrix *a, CMatrix **u_out, CMatrix **v_out, CVector **s_out)
+{
+    size_t m = a->rows;
+    size_t n = a->cols;
+    int transposed = 0;
+    CMatrix *work_matrix;
+
+    /* Ensure we work with a "tall" matrix for numerical stability */
+    if (m >= n) {
+        /* A^T * A */
+        CMatrix *at = cmatrix_transpose(a);
+        work_matrix = cmatrix_multiply(at, a);
+        cmatrix_free(at);
+    } else {
+        /* A * A^T */
+        CMatrix *at = cmatrix_transpose(a);
+        work_matrix = cmatrix_multiply(a, at);
+        cmatrix_free(at);
+        transposed = 1;
+    }
+
+    size_t size = work_matrix->rows;  /* This is min(m, n) effectively */
+    CMatrix *q = cmatrix_clone(work_matrix);
+    CMatrix *v = cmatrix_identity(size);
+    CMatrix *prev_q = NULL;
+
+    /* Jacobi iteration */
+    for (int sweep = 0; sweep < SVD_MAX_SWEEPS; sweep++) {
+        /* Apply rotations to diagonalize Q */
+        for (size_t p = 0; p < size - 1; p++) {
+            for (size_t r = p + 1; r < size; r++) {
+                double qpr = MAT_AT(q, p, r);
+                double qpp = MAT_AT(q, p, p);
+                double qrr = MAT_AT(q, r, r);
+
+                /* Compute rotation angle */
+                double numerator = 2.0 * qpr;
+                double denominator = qpp - qrr;
+                double angle;
+
+                if (fabs(denominator) < CLASSIFIER_EPSILON) {
+                    angle = (numerator >= 0) ? M_PI / 4.0 : -M_PI / 4.0;
+                } else {
+                    angle = atan(numerator / denominator) / 2.0;
+                }
+
+                double cosine = cos(angle);
+                double sine = sin(angle);
+
+                apply_jacobi_rotation(q, v, p, r, cosine, sine);
+            }
+        }
+
+        /* Check for convergence */
+        if (sweep == 0) {
+            prev_q = cmatrix_clone(q);
+        } else {
+            double sum_diff = 0.0;
+            for (size_t i = 0; i < size; i++) {
+                double diff = fabs(MAT_AT(q, i, i) - MAT_AT(prev_q, i, i));
+                if (diff > SVD_CONVERGENCE_THRESHOLD) {
+                    sum_diff += diff;
+                }
+            }
+
+            /* Update prev_q for next iteration */
+            memcpy(prev_q->data, q->data, size * size * sizeof(double));
+
+            if (sum_diff <= SVD_CONVERGENCE_THRESHOLD) {
+                break;
+            }
+        }
+    }
+
+    if (prev_q) cmatrix_free(prev_q);
+
+    /* Extract singular values (sqrt of diagonal elements of Q) */
+    CVector *s = cvector_alloc(size);
+    for (size_t i = 0; i < size; i++) {
+        double val = MAT_AT(q, i, i);
+        s->data[i] = (val > 0) ? sqrt(val) : 0.0;
+    }
+
+    /* Compute U = A * V * S^(-1) or handle transposed case */
+    /* Create S^(-1) diagonal matrix */
+    CMatrix *s_inv = cmatrix_alloc(size, size);
+    for (size_t i = 0; i < size; i++) {
+        double sv = s->data[i];
+        MAT_AT(s_inv, i, i) = (sv > CLASSIFIER_EPSILON) ? (1.0 / sv) : 0.0;
+    }
+
+    CMatrix *u;
+    CMatrix *source = transposed ? cmatrix_transpose(a) : cmatrix_clone(a);
+
+    /* U = source * V * S^(-1) */
+    CMatrix *temp = cmatrix_multiply(source, v);
+    u = cmatrix_multiply(temp, s_inv);
+
+    cmatrix_free(temp);
+    cmatrix_free(s_inv);
+    cmatrix_free(source);
+    cmatrix_free(q);
+    cmatrix_free(work_matrix);
+
+    *u_out = u;
+    *v_out = v;
+    *s_out = s;
+}
+
+/* Ruby wrapper: Matrix#SV_decomp */
+static VALUE rb_cmatrix_sv_decomp(int argc, VALUE *argv, VALUE self)
+{
+    CMatrix *m;
+    GET_CMATRIX(self, m);
+
+    /* Optional max_sweeps argument (ignored for now, using default) */
+    (void)argc;
+    (void)argv;
+
+    CMatrix *u, *v;
+    CVector *s;
+    jacobi_svd(m, &u, &v, &s);
+
+    VALUE rb_u = TypedData_Wrap_Struct(cClassifierMatrix, &cmatrix_type, u);
+    VALUE rb_v = TypedData_Wrap_Struct(cClassifierMatrix, &cmatrix_type, v);
+    VALUE rb_s = TypedData_Wrap_Struct(cClassifierVector, &cvector_type, s);
+
+    return rb_ary_new_from_args(3, rb_u, rb_v, rb_s);
+}
+
+void Init_svd(void)
+{
+    rb_define_method(cClassifierMatrix, "SV_decomp", rb_cmatrix_sv_decomp, -1);
+    rb_define_alias(cClassifierMatrix, "svd", "SV_decomp");
+}