nmatrix 0.0.1

data/ext/nmatrix/yale/complexmath.template.c

@@ -0,0 +1,71 @@
+
+inline static %%TYPE%% BOOL2%%= dtype.id.to_s.upcase%%(bool expr) {
+  %%TYPE%% result;
+  result.r = expr;
+  result.i = 0;
+  return result;
+}
+
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_mul(double ar, double ai, double br, double bi) {
+  %%TYPE%% result;
+
+  result.r = ar * br - ai * bi;
+  result.i = ar * bi + br * ai;
+
+  return result;
+}
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_div(double ar, double ai, double br, double bi) {
+  %%TYPE%% result;
+  double denom = br * br + bi * bi;
+
+  result.r = (ar * br + ai * bi) / denom;
+  result.i = (ai * br - ar * bi) / denom;
+
+  return result;
+}
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_add(%%= dtype.sym == :complex128 ? "double ar, double ai, double br, double bi" : "float ar, float ai, float br, float bi"%%) {
+  %%TYPE%% result;
+
+  result.r = ar + br;
+  result.i = ai + bi;
+
+  return result;
+}
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_sub(%%= dtype.sym == :complex128 ? "double ar, double ai, double br, double bi" : "float ar, float ai, float br, float bi"%%) {
+  %%TYPE%% result;
+
+  result.r = ar - br;
+  result.i = ai - bi;
+
+  return result;
+}
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_mod(%%= dtype.sym == :complex128 ? "double ar, double ai, double br, double bi" : "float ar, float ai, float br, float bi"%%) {
+  %%TYPE%% result;
+  rb_raise(rb_eNotImpError, "modulo arithmetic for complex numbers not yet implemented");
+
+  return result;
+}
+
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_bang(%%= dtype.sym == :complex128 ? "double ar, double ai" : "float ar, float ai"%%) {
+  %%TYPE%% result = {!ar, 0};
+  return result;
+}
+
+inline static %%TYPE%% %%TYPE_ABBREV%%_negate(%%= dtype.sym == :complex128 ? "double ar, double ai" : "float ar, float ai"%%) {
+  %%TYPE%% result;
+  result.r = -ar;
+  result.i = -ai;
+  return result;
+}
+

data/ext/nmatrix/yale/elementwise.template.c

@@ -0,0 +1,46 @@
+
+int %%INT_ABBREV%%_%%TYPE_ABBREV%%_ew(y_size_t n, y_size_t m, enum NMatrix_Ops op, const u_%%INT%%* ija, const u_%%INT%%* ijb, const u_%%INT%%* ijc, %%TYPE%%* a, %%TYPE%%* b, %%TYPE%%* c)
+{
+  y_size_t i;
+  y_size_t c_jj, a_jj, b_jj;
+  %%TYPE%% left, right;
+
+  for (i = 0; i < n; ++i) {
+    // do operation on diagonals first:
+    if (i < m) {
+      if (b) %%TYPE_ABBREV%%_ew_op_binary(op, &(c[i]), a[i], b[i]);
+      else   %%TYPE_ABBREV%%_ew_op_unary(op, &(c[i]), a[i]);
+    }
+
+    c_jj = ijc[i];
+    a_jj = ija[i];
+    if (ijb) b_jj = ijb[i];
+
+    //fprintf(stderr, "i16_f64_ew: n=%d, i=%d, c_jj=%d\n", (int)(n), (int)(i), (int)(c_jj));
+    while (c_jj < ijc[i+1]) {
+      // one or the other has to be the correct column (j = ijc[c_jj] ==? ija[a_jj])
+      if (a_jj < ija[i+1] && ija[a_jj] == ijc[c_jj]) {
+        %%TYPE left = a[a_jj]%%
+        ++a_jj;
+      } else {
+        %%TYPE left = 0%%
+      }
+
+      if (b) { // some ops don't have a second vector
+        if (b_jj < ijb[i+1] && ijb[b_jj] == ijc[c_jj]) {
+          %%TYPE right = b[b_jj]%%
+          ++b_jj;
+        } else {
+          %%TYPE right = 0%%
+        }
+
+        %%TYPE_ABBREV%%_ew_op_binary(op, &(c[c_jj]), left, right);
+      } else {
+        %%TYPE_ABBREV%%_ew_op_unary(op,  &(c[c_jj]), left);
+      }
+
+      ++c_jj;
+    }
+  }
+  return 0;
+}

data/ext/nmatrix/yale/elementwise_op.template.c

@@ -0,0 +1,73 @@
+
+static inline void %%TYPE_ABBREV%%_ew_op_unary(enum NMatrix_Ops op, %%TYPE%%* result, %%TYPE%% left) {
+  switch(op) {
+  case '!':
+    %%TYPE *result = !left%%
+    break;
+  case NM_OP_NEG:
+    %%TYPE *result = -left%%
+    break;
+  case '~':
+    %%TYPE *result = ~left%%
+    break;
+  default:
+    rb_raise(rb_eNotImpError, "Unrecognized element-wise unary operator");
+  }
+}
+
+
+
+static inline void %%TYPE_ABBREV%%_ew_op_binary(enum NMatrix_Ops op, %%TYPE%%* result, %%TYPE%% left, %%TYPE%% right) {
+  switch(op) {
+  case '+':
+    %%TYPE *result = left + right%%
+    break;
+  case '-':
+    %%TYPE *result = left - right%%
+    break;
+  case '*':
+    %%TYPE *result = left * right%%
+    break;
+  case '/':
+    %%TYPE *result = left / right%%
+    break;
+  case '%':
+    %%TYPE *result = left % right%%
+    break;
+  case NM_OP_EQEQ:
+    %%TYPE *result = left == right%%
+    break;
+  case NM_OP_NEQ:
+    %%TYPE *result = left != right%%
+    break;
+  case '>':
+    %%TYPE *result = left > right%%
+    break;
+  case '<':
+    %%TYPE *result = left < right%%
+    break;
+  case NM_OP_GTE:
+    %%TYPE *result = left >= right%%
+    break;
+  case NM_OP_LTE:
+    %%TYPE *result = left <= right%%
+    break;
+  case '&':
+    %%TYPE *result = left & right%%
+    break;
+  case '|':
+    %%TYPE *result = left | right%%
+    break;
+  case '^':
+    %%TYPE *result = left ^ right%%
+    break;
+  case NM_OP_LSH:
+    %%TYPE *result = left << right%%
+    break;
+  case NM_OP_RSH:
+    %%TYPE *result = left >> right%%
+    break;
+  default:
+    rb_raise(rb_eNotImpError, "Unrecognized element-wise binary operator");
+  }
+}

data/ext/nmatrix/yale/numbmm.template.c

@@ -0,0 +1,94 @@
+// numeric matrix multiply c=a*b
+void %%INT_ABBREV%%_%%TYPE_ABBREV%%_numbmm_(y_size_t n, y_size_t m, YALE_PARAM A, YALE_PARAM B, YALE_PARAM C)
+{
+  u_%%INT%% next[m];
+  %%TYPE%% sums[m];
+
+  %%TYPE%% v;
+  %%= if [:rational,:complex,:value].include?(dtype.type); "#{dtype.long_dtype.sizeof} temp1;"; end%%
+
+  u_%%INT%% head, length, temp, ndnz = 0;
+  u_%%INT%% jj_start, jj_end, kk_start, kk_end;
+  u_%%INT%% i, j, k, kk, jj;
+  u_%%INT%% minmn = SMMP_MIN(m,n);
+
+  u_%%INT%% *ia = (u_%%INT%%*)(A.ia),
+            *ja = (u_%%INT%%*)(A.ja),
+            *ib = (u_%%INT%%*)(B.ia),
+            *jb = (u_%%INT%%*)(B.ja),
+            *ic = (u_%%INT%%*)(C.ia),
+            *jc = (u_%%INT%%*)(C.ja);
+  %%TYPE%% *a = A.a,
+           *b = B.a,
+           *c = C.a;
+
+  for (i = 0; i < m; ++i) { // initialize scratch arrays
+    next[i] = U%%INT_MAX%%;
+    %%TYPE sums[i] = 0%%
+  }
+
+  for (i = 0; i < n; ++i) { // walk down the rows
+    head = U%%INT_MAX%%-1; // head gets assigned as whichever column of B's row j we last visited
+    length = 0;
+
+    jj_start = ia[i];
+    jj_end   = ia[i+1];
+
+    for (jj = jj_start; jj <= jj_end; ++jj) { // walk through entries in each row
+
+      if (jj == jj_end) { // if we're in the last entry for this row:
+        if (!A.diag || i >= minmn) continue;
+        j   = i;      // if it's a new Yale matrix, and last entry, get the diagonal position (j) and entry (ajj)
+        %%TYPE v = a[i]%%
+      } else {
+        j   = ja[jj]; // if it's not the last entry for this row, get the column (j) and entry (ajj)
+        %%TYPE v = a[jj]%%
+      }
+
+      kk_start = ib[j];   // Find the first entry of row j of matrix B
+      kk_end   = ib[j+1];
+      for (kk = kk_start; kk <= kk_end; ++kk) {
+
+        if (kk == kk_end) { // Get the column id for that entry
+          if (!B.diag || j >= minmn) continue;
+          k  = j;
+          %%TYPE sums[k] += v*b[k]%%
+        } else {
+          k  = jb[kk];
+          %%TYPE sums[k] += v*b[kk]%%
+        }
+
+        if (next[k] == U%%INT_MAX%%) {
+          next[k] = head;
+          head    = k;
+          ++length;
+        }
+      }
+    }
+
+    for (jj = 0; jj < length; ++jj) {
+      if (%%TYPE sums[head] != 0%%) {
+        if (C.diag && head == i) {
+          %%TYPE c[head] = sums[head]%%
+        } else {
+          jc[n+1+ndnz] = head;
+          %%TYPE c[n+1+ndnz] = sums[head]%%
+          ++ndnz;
+        }
+      }
+
+      temp = head;
+      head = next[head];
+
+      next[temp] = U%%INT_MAX%%;
+      %%TYPE sums[temp] = 0%%
+    }
+
+    ic[i+1] = n+1+ndnz;
+  }
+} /* numbmm_ */
+
+
+
+
+

data/ext/nmatrix/yale/smmp1.template.c

@@ -0,0 +1,21 @@
+
+void %%TYPE_ABBREV%%_symbmm(y_size_t n, y_size_t m, YALE_PARAM A, YALE_PARAM B, YALE_PARAM C)
+{
+  if (A.diag && A.ia != A.ja) {
+    fprintf(stderr, "A.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (B.diag && B.ia != B.ja) {
+    fprintf(stderr, "B.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (C.diag && C.ia != C.ja) {
+    fprintf(stderr, "C.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+
+  %%TYPE_ABBREV%%_symbmm_(n, m, A, B, C);
+}

data/ext/nmatrix/yale/smmp1_header.template.c

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == smmp1.c
+//
+// smmp1.c is automatically generated by generator.rb. Do not modify
+// it directly!
+//
+// This file ensures that all SMMP functions have the same signature,
+// so we can call them using arrays of function pointers.
+
+#include "nmatrix.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+
+

data/ext/nmatrix/yale/smmp2.template.c

@@ -0,0 +1,43 @@
+
+void %%INT_ABBREV%%_%%TYPE_ABBREV%%_numbmm(y_size_t n, y_size_t m, YALE_PARAM A, YALE_PARAM B, YALE_PARAM C)
+{
+  if (A.diag && A.ia != A.ja) {
+    fprintf(stderr, "A.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (B.diag && B.ia != B.ja) {
+    fprintf(stderr, "B.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (C.diag && C.ia != C.ja) {
+    fprintf(stderr, "C.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  %%INT_ABBREV%%_%%TYPE_ABBREV%%_numbmm_(n, m, A, B, C);
+}
+
+// Perform both the symbolic and numeric steps together.
+void %%INT_ABBREV%%_%%TYPE_ABBREV%%_smmp(y_size_t n, y_size_t m, YALE_PARAM A, YALE_PARAM B, YALE_PARAM C)
+{
+  if (A.diag && A.ia != A.ja) {
+    fprintf(stderr, "A.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (B.diag && B.ia != B.ja) {
+    fprintf(stderr, "B.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  if (C.diag && C.ia != C.ja) {
+    fprintf(stderr, "C.diag=true, but ia!=ja. For new yale, ia must equal ja.");
+    return;
+  }
+
+  %%INT_ABBREV%%_symbmm_(n, m, A, B, C);
+  %%INT_ABBREV%%_%%TYPE_ABBREV%%_numbmm_(n, m, A, B, C);
+  %%INT_ABBREV%%_%%TYPE_ABBREV%%_smmp_sort_columns_(n, C);
+}

data/ext/nmatrix/yale/smmp2_header.template.c

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == smmp2.c
+//
+/* ======================================================================= *
+ * Sparse Matrix Multiplication Package                                    *
+ * Randolph E. Bank and Craig C. Douglas                                   *
+ * na.bank@na-net.ornl.gov and na.cdouglas@na-net.ornl.gov                 *
+ * ======================================================================= */
+// This was originally derived from the above paper, but the algorithm they
+// give, in Fortran, uses 1-based indexing, and I simply could not make it
+// work. So I went back to where I found the link to that paper -- SciPy's
+// CSR type -- and looked at what they had done:
+//
+// https://github.com/scipy/scipy/blob/master/scipy/sparse/sparsetools/csr.h
+//
+// However, the SciPy version does not use the "new Yale" format, but rather
+// "old Yale." Thus, some modification was necessary -- reincorporating some
+// stuff from the original Bank & Douglas paper.
+//
+//
+// DO NOT MODIFY smmp2.c DIRECTLY, as it is autogenerated by generator.rb.
+
+#include <stdio.h>
+#include "nmatrix.h"

data/ext/nmatrix/yale/sort_columns.template.c

@@ -0,0 +1,56 @@
+//TODO: More efficient sorting algorithm than selection sort would be nice, probably.
+// Remember, we're dealing with unique keys, which simplifies things.
+// Doesn't have to be in-place, since we probably just multiplied and that wasn't in-place.
+
+void %%INT_ABBREV%%_%%TYPE_ABBREV%%_smmp_sort_columns_(y_size_t n, YALE_PARAM A)
+{
+  u_%%INT%% i, jj, jj_start, jj_end, min, min_jj;
+  %%TYPE%% temp_val;
+
+  u_%%INT%% *ia = (u_%%INT%%*)(A.ia),
+            *ja = (u_%%INT%%*)(A.ja);
+  %%TYPE%% *a = (%%TYPE%%*)(A.a);
+
+  for (i = 0; i < n; ++i) {
+    // No need to sort if there are 0 or 1 entries in the row
+    if (ia[i+1] - ia[i] < 2) continue;
+
+    jj_end = ia[i+1];
+    for (jj_start = ia[i]; jj_start < jj_end; ++jj_start) {
+
+      // If the previous min is just current-1, this key/value pair is already in sorted order.
+      // This follows from the unique condition on our column keys.
+      if (jj_start > ia[i] && min+1 == ja[jj_start]) {
+        min    = ja[jj_start];
+        continue;
+      }
+
+      // find the minimum key (column index) between jj_start and jj_end
+      min    = ja[jj_start];
+      min_jj = jj_start;
+      for (jj = jj_start+1; jj < jj_end; ++jj) {
+        if (ja[jj] < min) {
+          min_jj = jj;
+          min    = ja[jj];
+        }
+      }
+
+      // if min is already first, skip this iteration
+      if (min_jj == jj_start) continue;
+
+      for (jj = jj_start; jj < jj_end; ++jj) {
+        // swap minimum key/value pair with key/value pair in the first position.
+        if (min_jj != jj) {
+          // min already = ja[min_jj], so use this as temp_key
+          %%TYPE temp_val = a[min_jj]%%
+
+          ja[min_jj] = ja[jj];
+          %%TYPE a[min_jj] = a[jj]%%
+
+          ja[jj] = min;
+          %%TYPE a[jj] = temp_val%%
+        }
+      }
+    }
+  }
+}