nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/dense/gemm.template.c

@@ -1,159 +0,0 @@
-
-int %%TYPE_ABBREV%%gemm(enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB,
-  const int M, const int N, const int K, const %%TYPE%% alpha,
-  const %%TYPE%%* A, const int lda,
-  const %%TYPE%%* B, const int ldb, const %%TYPE%% beta,
-  %%TYPE%%* C, const int ldc)
-{
-  int num_rows_a, /*num_cols_a,*/ num_rows_b; // nrowa, ncola, nrowb
-
-  // use longest possible type for intermediate value storage:
-  %%TYPE_LONG%% temp;
-  %%= if [:rational,:complex,:value].include?(dtype.type); "#{dtype.long_dtype.sizeof} temp1, temp2;"; end%%
-  int i, j, l;
-
-  if (TransA == CblasNoTrans) num_rows_a = M;
-  else                        num_rows_a = K;
-
-  if (TransB == CblasNoTrans) num_rows_b = K;
-  else                        num_rows_b = N;
-
-  // Test the input parameters
-  if (TransA < 111 || TransA > 113) {
-    fprintf(stderr, "GEMM: TransA must be CblasNoTrans, CblasTrans, or CblasConjTrans\n");
-    return 0;
-  } else if (TransB < 111 || TransB > 113) {
-    fprintf(stderr, "GEMM: TransB must be CblasNoTrans, CblasTrans, or CblasConjTrans\n");
-    return 0;
-  } else if (M < 0) {
-    fprintf(stderr, "GEMM: Expected M >= 0\n");
-    return 0;
-  } else if (N < 0) {
-    fprintf(stderr, "GEMM: Expected N >= 0\n");
-    return 0;
-  } else if (K < 0) {
-    fprintf(stderr, "GEMM: Expected K >= 0\n");
-    return 0;
-  } else if (lda < NM_MAX(1, num_rows_a)) {
-    fprintf(stderr, "GEMM: Expected lda >= max(1, num_rows_a), with num_rows_a = %d; got lda=%d\n", num_rows_a, lda);
-    return 0;
-  } else if (ldb < NM_MAX(1, num_rows_b)) {
-    fprintf(stderr, "GEMM: Expected ldb >= max(1, num_rows_b), with num_rows_b = %d; got ldb=%d\n", num_rows_b, ldb);
-    return 0;
-  } else if (ldc < NM_MAX(1,M)) {
-    fprintf(stderr, "GEMM: Expected ldc >= max(1,M) with M=%d; got ldc=%d\n", M, ldc);
-    return 0;
-  }
-
-  // Quick return if possible
-  if (!M || !N || (%%TYPE alpha == 0%% || !K) && %%TYPE beta == 1%%) return 0;
-
-  // For alpha = 0
-  if (%%TYPE alpha == 0%%) {
-    if (%%TYPE beta == 0%%) {
-      for (j = 0; j < N; ++j)
-        for (i = 0; i < M; ++i) {
-          %%TYPE C[i+j*ldc] = 0%%
-        }
-    } else {
-      for (j = 0; j < N; ++j)
-        for (i = 0; i < M; ++i) {
-          %%TYPE C[i+j*ldc] *= beta%%
-        }
-    }
-    return 0;
-  }
-
-  // Start the operations
-  if (TransB == CblasNoTrans) {
-    if (TransA == CblasNoTrans) {
-      // C = alpha*A*B+beta*C
-      for (j = 0; j < N; ++j) {
-        if (%%TYPE beta == 0%%) {
-          for (i = 0; i < M; ++i) {
-            %%TYPE C[i+j*ldc] = 0%%
-          }
-        } else if (%%TYPE beta != 1%%) {
-          for (i = 0; i < M; ++i) {
-            %%TYPE C[i+j*ldc] *= beta%%
-          }
-        }
-
-        for (l = 0; l < K; ++l) {
-          if (%%TYPE B[l+j*ldb] != 0%%) {
-            %%TYPE_LONG temp = alpha * B[l+j*ldb]%%
-            for (i = 0; i < M; ++i) {
-              %%TYPE C[i+j*ldc] += A[i+l*lda] * temp%%
-            }
-          }
-        }
-      }
-
-    } else {
-
-      // C = alpha*A**T*B + beta*C
-      for (j = 0; j < N; ++j) {
-        for (i = 0; i < M; ++i) {
-          %%TYPE temp = 0%%
-          for (l = 0; l < K; ++l) {
-            %%TYPE_LONG temp += A[l+i*lda] * B[l+j*ldb]%%
-          }
-
-          if (%%TYPE beta == 0%%) {
-            %%TYPE C[i+j*ldc] = alpha*temp%%
-          } else {
-            %%TYPE C[i+j*ldc] = alpha*temp + beta*C[i+j*ldc]%%
-          }
-        }
-      }
-
-    }
-
-  } else if (TransA == CblasNoTrans) {
-
-    // C = alpha*A*B**T + beta*C
-    for (j = 0; j < N; ++j) {
-      if (%%TYPE beta == 0%%) {
-        for (i = 0; i < M; ++i) {
-          %%TYPE C[i+j*ldc] = 0%%
-        }
-      } else if (%%TYPE beta != 1%%) {
-        for (i = 0; i < M; ++i) {
-          %%TYPE C[i+j*ldc] *= beta%%
-        }
-      }
-
-      for (l = 0; l < K; ++l) {
-        if (%%TYPE B[j+l*ldb] != 0%%) {
-          %%TYPE_LONG temp = alpha * B[j+l*ldb]%%
-          for (i = 0; i < M; ++i) {
-            %%TYPE C[i+j*ldc] += A[i+l*lda] * temp%%
-          }
-        }
-      }
-
-    }
-
-  } else {
-
-    // C = alpha*A**T*B**T + beta*C
-    for (j = 0; j < N; ++j) {
-      for (i = 0; i < M; ++i) {
-        %%TYPE temp = 0%%
-        for (l = 0; l < K; ++l) {
-          %%TYPE_LONG temp += A[l+i*lda] * B[j+l*ldb]%%
-        }
-
-        if (%%TYPE beta == 0%%) {
-          %%TYPE C[i+j*ldc] = alpha*temp%%
-        } else {
-          %%TYPE C[i+j*ldc] = alpha*temp + beta*C[i+j*ldc]%%
-        }
-      }
-    }
-
-  }
-
-  return 0;
-}
-

data/ext/nmatrix/dense/gemv.template.c

@@ -1,130 +0,0 @@
-
-int %%TYPE_ABBREV%%gemv(enum CBLAS_TRANSPOSE Trans, const size_t M, const size_t N, const %%TYPE%% alpha,
-  const %%TYPE%%* A, const size_t lda, const %%TYPE%%* X, const int incX, const %%TYPE%% beta, %%TYPE%%* Y, const int incY)
-{
-  size_t lenX, lenY, i, j;
-  int kx, ky, iy, jx, jy, ix;
-  %%TYPE_LONG%% temp;
-  %%= if [:rational,:complex,:value].include?(dtype.type); "#{dtype.long_dtype.sizeof} temp1;"; end%%
-
-  // Test the input parameters
-  if (Trans < 111 || Trans > 113) {
-    fprintf(stderr, "IGEMV: TransA must be CblasNoTrans, CblasTrans, or CblasConjTrans\n");
-    return 0;
-  } else if (lda < NM_MAX(1, N)) {
-    fprintf(stderr, "IGEMV: Expected lda >= max(1, N), with N = %d; got lda=%d\n", N, lda);
-    return 0;
-  } else if (incX == 0) {
-    fprintf(stderr, "IGEMV: Expected incX != 0\n");
-    return 0;
-  } else if (incY == 0) {
-    fprintf(stderr, "IGEMV: Expected incY != 0\n");
-    return 0;
-  }
-
-  // Quick return if possible
-  if (!M || !N || %%TYPE alpha == 0%% && %%TYPE beta == 1%%) return 0;
-
-  if (Trans == CblasNoTrans) {
-    lenX = N;
-    lenY = M;
-  } else {
-    lenX = M;
-    lenY = N;
-  }
-
-  if (incX > 0) kx = 0;
-  else          kx = (lenX - 1) * -incX;
-
-  if (incY > 0) ky = 0;
-  else          ky =  (lenY - 1) * -incY;
-
-  // Start the operations. In this version, the elements of A are accessed sequentially with one pass through A.
-  if (%%TYPE beta != 1%%) {
-    if (incY == 1) {
-      if (%%TYPE beta == 0%%) {
-        for (i = 0; i < lenY; ++i) {
-          %%TYPE Y[i] = 0%%
-        }
-      } else {
-        for (i = 0; i < lenY; ++i) {
-          %%TYPE Y[i] *= beta%%
-        }
-      }
-    } else {
-      iy = ky;
-      if (%%TYPE beta == 0%%) {
-        for (i = 0; i < lenY; ++i) {
-          %%TYPE Y[iy] = 0%%
-          iy += incY;
-        }
-      } else {
-        for (i = 0; i < lenY; ++i) {
-          %%TYPE Y[iy] *= beta%%
-          iy += incY;
-        }
-      }
-    }
-  }
-
-  if (%%TYPE alpha == 0%%) return 0;
-
-  if (Trans == CblasNoTrans) {
-
-    // Form  y := alpha*A*x + y.
-    jx = kx;
-    if (incY == 1) {
-      for (j = 0; j < N; ++j) {
-        if (%%TYPE X[jx] != 0%%) {
-          %%TYPE_LONG temp = alpha * X[jx]%%
-          for (i = 0; i < M; ++i) {
-            %%TYPE Y[i] += A[j+i*lda] * temp%%
-          }
-        }
-        jx += incX;
-      }
-    } else {
-      for (j = 0; j < N; ++j) {
-        if (%%TYPE X[jx] != 0%%) {
-          %%TYPE_LONG temp = alpha * X[jx]%%
-          iy = ky;
-          for (i = 0; i < M; ++i) {
-            %%TYPE Y[iy] += A[j+i*lda] * temp%%
-            iy += incY;
-          }
-        }
-        jx += incX;
-      }
-    }
-
-  } else { // TODO: Check that indices are correct! They're switched for C.
-
-    // Form  y := alpha*A**T*x + y.
-    jy = ky;
-
-    if (incX == 1) {
-      for (j = 0; j < N; ++j) {
-        %%TYPE temp = 0%%
-        for (i = 0; i < M; ++i) {
-          %%TYPE_LONG temp += A[j+i*lda]*X[j]%%
-        }
-        %%TYPE Y[jy] += alpha * temp%%
-        jy += incY;
-      }
-    } else {
-      for (j = 0; j < N; ++j) {
-        %%TYPE temp = 0%%
-        ix = kx;
-        for (i = 0; i < M; ++i) {
-          %%TYPE_LONG temp += A[j+i*lda] * X[ix]%%
-          ix += incX;
-        }
-
-        %%TYPE Y[jy] += alpha * temp%%
-        jy += incY;
-      }
-    }
-  }
-
-  return 0;
-}  // end of GEMV

data/ext/nmatrix/dense/rationalmath.template.c

@@ -1,68 +0,0 @@
-
-inline %%TYPE%% BOOL2%%= dtype.id.to_s.upcase%%(bool expr) {
-  %%TYPE%% result;
-  result.n = expr;
-  result.d = 1;
-  return result;
-}
-
-inline %%TYPE%% %%TYPE_ABBREV%%_bang(%%= dtype.sym == :rational128 ? "int64_t n, int64_t d" : (dtype.sym == :rational64 ? "int32_t n, int32_t d" : "int16_t n, int16_t d")%%)
-{
-  %%TYPE%% result = {!n, 1};
-  return result;
-}
-
-inline %%TYPE%% %%TYPE_ABBREV%%_negate(%%= dtype.sym == :rational128 ? "int64_t n, int64_t d" : (dtype.sym == :rational64 ? "int32_t n, int32_t d" : "int16_t n, int16_t d")%%)
-{
-  %%TYPE%% result = {-n, -d};
-  return result;
-}
-
-inline %%TYPE%% %%TYPE_ABBREV%%_muldiv(int64_t anum, int64_t aden, int64_t bnum, int64_t bden, char k) {
-  %%TYPE%% result;
-  int64_t t, g1, g2;
-
-  if (k == '/') { // Switch numerator and denominator for division (and move sign)
-    if (bnum < 0) {
-      anum = -anum;
-      bnum = -bnum;
-    }
-    t = bnum;
-    bnum = bden;
-    bden = t;
-  }
-
-  g1 = nmrb_gcd(anum, bden);
-  g2 = nmrb_gcd(aden, bnum);
-
-  result.n = (anum / g1) * (bnum / g2);
-  result.d = (aden / g2) * (bden / g1);
-
-  return result;
-}
-
-inline %%TYPE%% %%TYPE_ABBREV%%_addsub(int64_t anum, int64_t aden, int64_t bnum, int64_t bden, char k) {
-  %%TYPE%% result;
-
-  int64_t ig = nmrb_gcd(aden, bden);
-  int64_t a  = anum * (bden / ig);
-  int64_t b  = bnum * (aden / ig);
-  int64_t c;
-
-  if (k == '+') c=a+b;
-  else          c=a-b;
-
-  b        = aden / ig;
-  ig       = nmrb_gcd(aden, ig);
-  result.n = c / ig;
-  a        = bden / ig;
-  result.d = a*b;
-
-  return result;
-}
-
-inline %%TYPE%% %%TYPE_ABBREV%%_mod(%%= dtype.sym == :rational128 ? "int64_t anum, int64_t aden, int64_t bnum, int64_t bden" : (dtype.sym == :rational64 ? "int32_t anum, int32_t aden, int32_t bnum, int32_t bden" : "int16_t anum, int16_t aden, int16_t bnum, int16_t bden")%%)
-{
-  // a - (b * int(a/b))
-  return %%TYPE_ABBREV%%_addsub(anum, aden, bnum*((int64_t)((anum * bden) / (aden * bnum))), bden, '-');
-}

data/ext/nmatrix/dense.c

@@ -1,307 +0,0 @@
-/////////////////////////////////////////////////////////////////////
-// = 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
-//
-// == dense.c
-//
-// Dense n-dimensional matrix storage.
-
-#ifndef DENSE_C
-#define DENSE_C
-
-#include <ruby.h>
-
-#include "nmatrix.h"
-
-
-/* Calculate the number of elements in the dense storage structure, based on shape and rank */
-size_t count_dense_storage_elements(const DENSE_STORAGE* s) {
-  size_t i;
-  size_t count = 1;
-  for (i = 0; i < s->rank; ++i) count *= s->shape[i];
-  return count;
-}
-
-
-// Do these two dense matrices of the same dtype have exactly the same contents?
-bool dense_storage_eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
-  return !memcmp(left->elements, right->elements, count_dense_storage_elements(left) / nm_sizeof[left->dtype]);
-}
-
-
-size_t dense_storage_pos(DENSE_STORAGE* s, size_t* coords) {
-  size_t k, l;
-  size_t inner, outer = 0;
-  for (k = 0; k < s->rank; ++k) {
-    inner = coords[k];
-    for (l = k+1; l < s->rank; ++l) {
-      inner *= s->shape[l];
-    }
-    outer += inner;
-  }
-  return outer;
-}
-
-
-
-void* dense_storage_get(DENSE_STORAGE* s, size_t* coords) {
-  return (char*)(s->elements) + dense_storage_pos(s, coords) * nm_sizeof[s->dtype];
-}
-
-
-/* Does not free passed-in value! Different from list_storage_insert. */
-void dense_storage_set(DENSE_STORAGE* s, size_t* coords, void* val) {
-  memcpy((char*)(s->elements) + dense_storage_pos(s, coords) * nm_sizeof[s->dtype], val, nm_sizeof[s->dtype]);
-}
-
-
-DENSE_STORAGE* copy_dense_storage(DENSE_STORAGE* rhs) {
-  DENSE_STORAGE* lhs;
-  size_t count = count_dense_storage_elements(rhs), p;
-  size_t* shape = ALLOC_N(size_t, rhs->rank);
-  if (!shape) return NULL;
-
-  // copy shape array
-  for (p = 0; p < rhs->rank; ++p)
-    shape[p] = rhs->shape[p];
-
-  lhs = create_dense_storage(rhs->dtype, shape, rhs->rank, NULL, 0);
-
-  if (lhs && count) // ensure that allocation worked before copying
-    memcpy(lhs->elements, rhs->elements, nm_sizeof[rhs->dtype] * count);
-
-  return lhs;
-}
-
-
-DENSE_STORAGE* cast_copy_dense_storage(DENSE_STORAGE* rhs, int8_t new_dtype) {
-  DENSE_STORAGE* lhs;
-  size_t count = count_dense_storage_elements(rhs), p;
-  size_t* shape = ALLOC_N(size_t, rhs->rank);
-  if (!shape) return NULL;
-
-  // copy shape array
-  for (p = 0; p < rhs->rank; ++p) shape[p] = rhs->shape[p];
-
-  lhs = create_dense_storage(new_dtype, shape, rhs->rank, NULL, 0);
-
-  if (lhs && count) // ensure that allocation worked before copying
-    if (lhs->dtype == rhs->dtype)
-      memcpy(lhs->elements, rhs->elements, nm_sizeof[rhs->dtype] * count);
-    else
-      SetFuncs[lhs->dtype][rhs->dtype](count, lhs->elements, nm_sizeof[lhs->dtype], rhs->elements, nm_sizeof[rhs->dtype]);
-
-
-  return lhs;
-}
-
-
-
-// Copy a set of default values into dense
-static inline void cast_copy_dense_list_default(void* lhs, void* default_val, int8_t l_dtype, int8_t r_dtype, size_t* pos, const size_t* shape, size_t rank, size_t max_elements, size_t recursions) {
-  size_t i;
-
-  for (i = 0; i < shape[rank-1-recursions]; ++i, ++(*pos)) {
-    //fprintf(stderr, "default: pos = %u, dim = %u\t", *pos, shape[rank-1-recursions]);
-
-    if (recursions == 0) { cast_copy_value_single((char*)lhs + (*pos)*nm_sizeof[l_dtype], default_val, l_dtype, r_dtype); fprintf(stderr, "zero\n"); }
-    else                 { cast_copy_dense_list_default(lhs, default_val, l_dtype, r_dtype, pos, shape, rank, max_elements, recursions-1); fprintf(stderr, "column of zeros\n"); }
-  }
-  --(*pos);
-}
-
-
-// Copy list contents into dense recursively
-static void cast_copy_dense_list_contents(void* lhs, const LIST* rhs, void* default_val, int8_t l_dtype, int8_t r_dtype, size_t* pos, const size_t* shape, size_t rank, size_t max_elements, size_t recursions) {
-  NODE *curr = rhs->first;
-  int last_key = -1;
-  size_t i = 0;
-
-  for (i = 0; i < shape[rank-1-recursions]; ++i, ++(*pos)) {
-
-    if (!curr || (curr->key > (size_t)(last_key+1))) {
-      //fprintf(stderr, "pos = %u, dim = %u, curr->key XX, last_key+1 = %d\t", *pos, shape[rank-1-recursions], last_key+1);
-      if (recursions == 0) cast_copy_value_single((char*)lhs + (*pos)*nm_sizeof[l_dtype], default_val, l_dtype, r_dtype); //fprintf(stderr, "zero\n"); }
-      else                 cast_copy_dense_list_default(lhs, default_val, l_dtype, r_dtype, pos, shape, rank, max_elements, recursions-1); //fprintf(stderr, "column of zeros\n"); }
-
-      ++last_key;
-    } else {
-      //fprintf(stderr, "pos = %u, dim = %u, curr->key = %u, last_key+1 = %d\t", *pos, shape[rank-1-recursions], curr->key, last_key+1);
-      if (recursions == 0) cast_copy_value_single((char*)lhs + (*pos)*nm_sizeof[l_dtype], curr->val, l_dtype, r_dtype); //fprintf(stderr, "value\n"); }
-      else                 cast_copy_dense_list_contents(lhs, curr->val, default_val, l_dtype, r_dtype, pos, shape, rank, max_elements, recursions-1); //fprintf(stderr, "column of values\n"); }
-
-      last_key = curr->key;
-      curr     = curr->next;
-    }
-  }
-  --(*pos);
-}
-
-
-// Convert (by creating a copy) from list storage to dense storage.
-DENSE_STORAGE* scast_copy_dense_list(const LIST_STORAGE* rhs, int8_t l_dtype) {
-  DENSE_STORAGE* lhs;
-  size_t pos   = 0; // position in lhs->elements
-
-  // allocate and copy shape
-  size_t* shape = ALLOC_N(size_t, rhs->rank);
-  memcpy(shape, rhs->shape, rhs->rank * sizeof(size_t));
-
-  lhs = create_dense_storage(l_dtype, shape, rhs->rank, NULL, 0);
-
-  // recursively copy the contents
-  cast_copy_dense_list_contents(lhs->elements, rhs->rows, rhs->default_val, l_dtype, rhs->dtype, &pos, shape, lhs->rank, count_storage_max_elements((STORAGE*)rhs), rhs->rank-1);
-
-  return lhs;
-}
-
-
-DENSE_STORAGE* scast_copy_dense_yale(const YALE_STORAGE* rhs, int8_t l_dtype) {
-  DENSE_STORAGE* lhs;
-  y_size_t i, j, // position in lhs->elements
-           ija, ija_next, jj; // position in rhs->elements
-  y_size_t pos = 0;          // position in dense to write to
-  void* R_ZERO = (char*)(rhs->a) + rhs->shape[0] * nm_sizeof[rhs->dtype]; // determine zero representation
-
-  // allocate and set shape
-  size_t* shape = ALLOC_N(size_t, rhs->rank);
-  memcpy(shape, rhs->shape, rhs->rank * sizeof(size_t));
-
-  lhs = create_dense_storage(l_dtype, shape, rhs->rank, NULL, 0);
-
-  // Walk through rows. For each entry we set in dense, increment pos.
-  for (i = 0; i < rhs->shape[0]; ++i) {
-
-    // get boundaries of this row, store in ija and ija_next
-    YaleGetIJA(ija,      rhs, i);
-    YaleGetIJA(ija_next, rhs, i+1);
-
-    if (ija == ija_next) { // row is empty?
-
-      for (j = 0; j < rhs->shape[1]; ++j) {  // write zeros in each column
-
-        // Fill in zeros (except for diagonal)
-        if (i == j) cast_copy_value_single((char*)(lhs->elements) + pos*nm_sizeof[l_dtype], (char*)(rhs->a) + i*nm_sizeof[rhs->dtype], l_dtype, rhs->dtype);
-        else        cast_copy_value_single((char*)(lhs->elements) + pos*nm_sizeof[l_dtype], R_ZERO, l_dtype, rhs->dtype);
-
-        ++pos; // move to next dense position
-      }
-
-    } else {
-      // row contains entries: write those in each column, interspersed with zeros
-      YaleGetIJA(jj, rhs, ija);
-
-      for (j = 0; j < rhs->shape[1]; ++j) {
-        if (i == j) {
-
-          cast_copy_value_single((char*)(lhs->elements) + pos*nm_sizeof[l_dtype], (char*)(rhs->a) + i*nm_sizeof[rhs->dtype], l_dtype, rhs->dtype);
-
-        } else if (j == jj) {
-
-          // copy from rhs
-          cast_copy_value_single((char*)(lhs->elements) + pos*nm_sizeof[l_dtype], (char*)(rhs->a) + ija*nm_sizeof[rhs->dtype], l_dtype, rhs->dtype);
-
-          // get next
-          ++ija;
-
-          // increment to next column ID (or go off the end)
-          if (ija < ija_next) YaleGetIJA(jj, rhs, ija);
-          else jj = rhs->shape[1];
-
-        } else { // j < jj
-
-          // insert zero
-          cast_copy_value_single((char*)(lhs->elements) + pos*nm_sizeof[l_dtype], R_ZERO, l_dtype, rhs->dtype);
-        }
-        ++pos; // move to next dense position
-      }
-    }
-  }
-
-  return lhs;
-}
-
-
-// Note that elements and elements_length are for initial value(s) passed in. If they are the correct length, they will
-// be used directly. If not, they will be concatenated over and over again into a new elements array. If elements is NULL,
-// the new elements array will not be initialized.
-DENSE_STORAGE* create_dense_storage(int8_t dtype, size_t* shape, size_t rank, void* elements, size_t elements_length) {
-  DENSE_STORAGE* s;
-  size_t count, i, copy_length = elements_length;
-
-  s = ALLOC( DENSE_STORAGE );
-  //if (!(s = malloc(sizeof(DENSE_STORAGE)))) return NULL;
-
-  s->rank       = rank;
-  s->shape      = shape;
-  s->dtype      = dtype;
-
-  //fprintf(stderr, "create_dense_storage: %p\n", s);
-
-  count         = count_dense_storage_elements(s);
-  //fprintf(stderr, "count_dense_storage_elements: %d\n", count);
-
-  if (elements_length == count) s->elements = elements;
-  else {
-    s->elements = ALLOC_N(char, nm_sizeof[dtype]*count);
-
-    if (elements_length > 0) {
-      // repeat elements over and over again until the end of the matrix
-      for (i = 0; i < count; i += elements_length) {
-        if (i + elements_length > count) copy_length = count - i;
-        memcpy((char*)(s->elements)+i*nm_sizeof[dtype], (char*)(elements)+(i % elements_length)*nm_sizeof[dtype], copy_length*nm_sizeof[dtype]);
-      }
-
-      // get rid of the init_val
-      free(elements);
-    }
-  }
-
-  return s;
-}
-
-
-void delete_dense_storage(DENSE_STORAGE* s) {
-  if (s) { // sometimes Ruby passes in NULL storage for some reason (probably on copy construction failure)
-    free(s->shape);
-    free(s->elements);
-    free(s);
-  }
-}
-
-
-void mark_dense_storage(void* m) {
-  size_t i;
-  DENSE_STORAGE* storage;
-
-  if (m) {
-    storage = (DENSE_STORAGE*)(((NMATRIX*)m)->storage);
-    //fprintf(stderr, "mark_dense_storage\n");
-    if (storage && storage->dtype == NM_ROBJ)
-      for (i = 0; i < count_dense_storage_elements(storage); ++i)
-        rb_gc_mark(*((VALUE*)((char*)(storage->elements) + i*nm_sizeof[NM_ROBJ])));
-  }
-}
-
-
-
-#endif

data/ext/nmatrix/depend

@@ -1,18 +0,0 @@
-dtypes.h dtypes.c smmp1.c smmp2.c blas.c: generator.rb
-	$(RUBY) -I$(srcdir) $(srcdir)/generator.rb
-
-blas.o: blas.c
-
-smmp2.o: smmp1.c smmp2.c nmatrix.h yale/smmp2_header.template.c yale/symbmm.template.c yale/transp.template.c yale/numbmm.template.c
-
-smmp1.o: smmp1.c nmatrix_config.h nmatrix.h yale/smmp1_header.template.c
-
-dfuncs.o: dfuncs.c $(hdrdir)/ruby.h
-
-$(DLLIB): dtypes.h dtypes.c dfuncs.c $(OBJS) Makefile
-	# $(ECHO) linking shared-object $(DLLIB)
-	@-$(RM) $(@)
-	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
-
-soclean:
-	@-$(RM) *.so *.o *.bundle