nmatrix-atlas 0.2.0

data/ext/nmatrix/storage/yale/iterators/row_stored.h

@@ -0,0 +1,139 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+//
+// == row_stored.h
+//
+// Iterator for traversing a single stored row of a matrix (needed
+// for row.h). FIXME: This is not as efficient as it could be; it uses
+// two binary searches to find the beginning and end of each slice.
+// The end search shouldn't be necessary, but I couldn't make it
+// work without it, and eventually decided my dissertation should
+// be a priority.
+//
+
+#ifndef YALE_ITERATORS_ROW_STORED_H
+# define YALE_ITERATORS_ROW_STORED_H
+
+#include <stdexcept>
+
+namespace nm { namespace yale_storage {
+
+
+/*
+ * Iterator for visiting each stored element in a row, including diagonals.
+ */
+template <typename D,
+          typename RefType,
+          typename YaleRef = typename std::conditional<
+            std::is_const<RefType>::value,
+            const nm::YaleStorage<D>,
+            nm::YaleStorage<D>
+          >::type,
+          typename RowRef = typename std::conditional<
+            std::is_const<RefType>::value,
+            const row_iterator_T<D,RefType,YaleRef>,
+            row_iterator_T<D,RefType,YaleRef>
+          >::type>
+class row_stored_iterator_T : public row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> {
+protected:
+  using row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef>::r;
+  using row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef>::p_;
+  bool d_visited, d;
+
+public:
+
+  // end_ is necessary for the logic when a row is empty other than the diagonal. If we just
+  // relied on pp == last_p+1, it'd look like these empty rows were actually end() iterators.
+  // So we have to actually mark end_ by telling it to ignore that diagonal visitation.
+  row_stored_iterator_T(RowRef& row, size_t pp, bool end_ = false)
+  : row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef>(row, pp),
+    d_visited(!row.has_diag()), // if the row has no diagonal, just marked it as visited.
+    d(r.is_diag_first() && !end_)        // do we start at the diagonal?
+  {
+  }
+
+  /* Diagonal constructor. Puts us on the diagonal (unless end is true) */
+  /*row_stored_iterator_T(RowRef& row, bool end_, size_t j)
+  : row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef>(row.ndfind(j)),
+    d_visited(false),
+    d(!end_ && j + row.offset(1) == row.real_i())
+  { }*/
+
+  virtual bool diag() const {
+    return d;
+  }
+
+  virtual bool end() const {
+    return !d && p_ > r.p_last;
+  }
+
+  row_stored_iterator_T<D,RefType,YaleRef,RowRef>& operator++() {
+    if (end()) throw std::out_of_range("cannot increment row stored iterator past end of stored row");
+    if (d) {
+      d_visited = true;
+      d         = false;
+    } else {
+      ++p_;
+      // Are we at a diagonal?
+      // If we hit the end or reach a point where j > diag_j, and still
+      // haven't visited the diagonal, we should do so before continuing.
+      if (!d_visited && (end() || j() > r.diag_j())) {
+        d = true;
+      }
+    }
+
+    return *this;
+  }
+
+  row_stored_iterator_T<D,RefType,YaleRef,RowRef> operator++(int dummy) const {
+    row_stored_iterator_T<D,RefType,YaleRef,RowRef> r(*this);
+    return ++r;
+  }
+
+  size_t j() const {
+    if (end()) throw std::out_of_range("cannot dereference an end pointer");
+    return (d ? r.p_diag() : r.ija(p_)) - r.offset(1);
+  }
+
+  // Need to declare all row_stored_iterator_T friends of each other.
+  template <typename E, typename ERefType, typename EYaleRef, typename ERowRef> friend class row_stored_iterator_T;
+
+  // De-reference the iterator
+  RefType& operator*()       {
+    return d ? r.a(r.p_diag()) : r.a(p_);
+  }
+
+  RefType& operator*() const {
+    return d ? r.a(r.p_diag()) : r.a(p_);
+  }
+
+  // Ruby VALUE de-reference
+  VALUE operator~() const {
+    return nm_rb_dereference<D>(**this);
+  }
+
+};
+
+}} // end of namespace nm::yale_storage
+
+#endif // YALE_ITERATORS_ROW_STORED_H

data/ext/nmatrix/storage/yale/iterators/row_stored_nd.h

@@ -0,0 +1,168 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+//
+// == row_stored_nd.h
+//
+// Yale storage row-by-row nondiagonal-storage iterator
+//
+
+#ifndef YALE_ITERATORS_ROW_STORED_ND_H
+# define YALE_ITERATORS_ROW_STORED_ND_H
+
+#include <type_traits>
+#include <typeinfo>
+#include <stdexcept>
+
+namespace nm { namespace yale_storage {
+
+/*
+ * Constants
+ */
+const float GROWTH_CONSTANT = 1.5;
+
+
+/*
+ * Forward declarations
+ */
+template <typename D, typename RefType, typename YaleRef> class row_iterator_T;
+
+/*
+ * Iterator for visiting each stored element in a row, including diagonals.
+ */
+template <typename D,
+          typename RefType,
+          typename YaleRef = typename std::conditional<
+            std::is_const<RefType>::value,
+            const nm::YaleStorage<D>,
+            nm::YaleStorage<D>
+          >::type,
+          typename RowRef = typename std::conditional<
+            std::is_const<RefType>::value,
+            const row_iterator_T<D,RefType,YaleRef>,
+            row_iterator_T<D,RefType,YaleRef>
+          >::type>
+class row_stored_nd_iterator_T {
+protected:
+  RowRef& r;
+  size_t p_;
+
+public:
+
+  row_stored_nd_iterator_T(RowRef& row, size_t pp)
+  : r(row),
+    p_(pp)        // do we start at the diagonal?
+  {
+  }
+
+  // DO NOT IMPLEMENT THESE FUNCTIONS. They prevent C++ virtual slicing
+  //template <typename T> row_stored_nd_iterator_T(T const& rhs);
+  //template <typename T> row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> const& operator=(T const& rhs);
+
+  // Next two functions are to ensure we can still cast between nd iterators.
+  row_stored_nd_iterator_T(row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> const& rhs)
+  : r(rhs.r), p_(rhs.p_)
+  { }
+
+  row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> const& operator=(row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> const& rhs) {
+    if (&r != &(rhs.r))
+      throw std::logic_error("can't assign iterator from another row iterator");
+    p_ = rhs.p_;
+    return *this;
+  }
+
+  virtual size_t p() const { return p_; }
+
+  virtual bool end() const {
+    return p_ > r.p_last;
+  }
+
+  row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef>& operator++() {
+    if (end()) throw std::out_of_range("cannot increment row stored iterator past end of stored row");
+    ++p_;
+
+    return *this;
+  }
+
+  row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> operator++(int dummy) const {
+    row_stored_nd_iterator_T<D,RefType,YaleRef,RowRef> r(*this);
+    return ++r;
+  }
+
+  virtual size_t j() const {
+    if (end()) throw std::out_of_range("cannot dereference (get j()) for an end pointer");
+    return r.ija(p_) - r.offset(1);
+  }
+
+  // Need to declare all row_stored_nd_iterator_T friends of each other.
+  template <typename E, typename ERefType, typename EYaleRef, typename ERowRef> friend class row_stored_nd_iterator_T;
+
+
+  virtual bool operator==(const row_stored_nd_iterator_T<D,RefType>& rhs) const {
+    if (r.i() != rhs.r.i())     return false;
+    if (end())                  return rhs.end();
+    else if (rhs.end())         return false;
+    return j() == rhs.j();
+  }
+
+  // There is something wrong with this function.
+  virtual bool operator!=(const row_stored_nd_iterator_T<D,RefType>& rhs) const {
+    if (r.i() != rhs.r.i()) return true;
+    if (end())              return !rhs.end();
+    else if (rhs.end())     return true;
+    return j() != rhs.j();
+  }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator<(const row_stored_nd_iterator_T<E,ERefType>& rhs) const {
+    if (r < rhs.r)      return true;
+    if (r > rhs.r)      return false;
+
+    // r == rhs.r
+    if (end())        return false;
+    if (rhs.end())    return true;
+    return j() < rhs.j();
+  }
+
+  // De-reference the iterator
+  RefType& operator*()       {
+    return r.a(p_);
+  }
+
+  RefType& operator*() const {
+    return r.a(p_);
+  }
+
+  // Ruby VALUE de-reference
+  VALUE operator~() const {
+    return nm_rb_dereference<D>(**this);
+  }
+
+  inline virtual VALUE rb_j() const { return LONG2NUM(j()); }
+
+};
+
+
+
+} } // end of namespace nm::yale_storage
+
+#endif // YALE_ITERATORS_ROW_STORED_ND_H

data/ext/nmatrix/storage/yale/iterators/stored_diagonal.h

@@ -0,0 +1,123 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+//
+// == stored_diagonal_iterator.h
+//
+// Yale storage diagonal-storage iterator
+//
+
+#ifndef YALE_ITERATORS_STORED_DIAGONAL_H
+# define YALE_ITERATORS_STORED_DIAGONAL_H
+
+#include <type_traits>
+#include <typeinfo>
+
+namespace nm { namespace yale_storage {
+
+/*
+ * Iterate across the stored diagonal.
+ */
+template <typename D,
+          typename RefType,
+          typename YaleRef = typename std::conditional<
+            std::is_const<RefType>::value,
+            const nm::YaleStorage<D>,
+            nm::YaleStorage<D>
+          >::type>
+class stored_diagonal_iterator_T : public basic_iterator_T<D,RefType,YaleRef> {
+  using basic_iterator_T<D,RefType,YaleRef>::p_;
+  using basic_iterator_T<D,RefType,YaleRef>::y;
+  using basic_iterator_T<D,RefType,YaleRef>::offset;
+  using basic_iterator_T<D,RefType,YaleRef>::shape;
+public:
+  stored_diagonal_iterator_T(YaleRef& obj, size_t d = 0)
+  : basic_iterator_T<D,RefType,YaleRef>(obj,                // y
+                   std::max(obj.offset(0), obj.offset(1)) + d - obj.offset(0), // i_
+                   std::max(obj.offset(0), obj.offset(1)) + d) // p_
+  {
+//      std::cerr << "sdbegin: d=" << d << ", p_=" << p_ << ", i()=" << i() << ", j()=" << j() << std::endl;
+    // p_ can range from max(y.offset(0), y.offset(1)) to min(y.real_shape(0), y.real_shape(1))
+  }
+
+
+  size_t d() const {
+    return p_ - std::max(offset(0), offset(1));
+  }
+
+  stored_diagonal_iterator_T<D,RefType,YaleRef>& operator++() {
+    if (i() < shape(0)) ++p_;
+    return *this;
+  }
+
+  stored_diagonal_iterator_T<D,RefType,YaleRef> operator++(int dummy) const {
+    stored_diagonal_iterator_T<D,RefType,YaleRef> iter(*this);
+    return ++iter;
+  }
+
+  // Indicates if we're at the end of the iteration.
+  bool end() const {
+    return p_ >= std::min( shape(0) + offset(0), shape(1) + offset(1) );
+  }
+
+  // i() and j() are how we know if we're past-the-end. i will be shape(0) and j will be 0.
+  size_t i() const {
+    return p_ - offset(0);
+  }
+
+  size_t j() const {
+    return p_ - offset(1);
+  }
+
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator!=(const stored_diagonal_iterator_T<E,ERefType>& rhs) const { return d() != rhs.d(); }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator==(const stored_diagonal_iterator_T<E,ERefType>& rhs) const { return !(*this != rhs); }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator<(const stored_diagonal_iterator_T<E,ERefType>& rhs) const {  return d() < rhs.d(); }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator<=(const stored_diagonal_iterator_T<E,ERefType>& rhs) const {
+    return d() <= rhs.d();
+  }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator>(const stored_diagonal_iterator_T<E,ERefType>& rhs) const {
+    return d() > rhs.d();
+  }
+
+  template <typename E, typename ERefType = typename std::conditional<std::is_const<RefType>::value, const E, E>::type>
+  bool operator>=(const stored_diagonal_iterator_T<E,ERefType>& rhs) const {
+    return d() >= rhs.d();
+  }
+
+  RefType& operator*() { return y.a(p_); }
+  RefType& operator*() const { return y.a(p_); }
+
+};
+
+} } // end of namespace nm::yale_storage
+
+#endif // YALE_ITERATORS_STORED_DIAGONAL_H

data/ext/nmatrix/storage/yale/math/transpose.h

@@ -0,0 +1,110 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+//
+// == transpose.h
+//
+// Functions for Yale math: transposing
+//
+
+#ifndef YALE_MATH_TRANSPOSE_H
+# define YALE_MATH_TRANSPOSE_H
+
+namespace nm { namespace yale_storage {
+
+/*
+ * Transposes a generic Yale matrix (old or new). Specify new by setting RDiag = true.
+ *
+ * Based on transp from SMMP (same as symbmm and numbmm).
+ *
+ * This is not named in the same way as most yale_storage functions because it does not act on a YALE_STORAGE
+ * object.
+ */
+
+template <typename AD, typename BD, bool DiagA, bool Move>
+void transpose_yale(const size_t n, const size_t m,
+                    const size_t* ia, const size_t* ja, const AD* a, const AD& a_default,
+                    size_t* ib, size_t* jb, BD* b, const BD& b_default) {
+
+  size_t index;
+
+  // Clear B
+  for (size_t i = 0; i < m+1; ++i) ib[i] = 0;
+
+  if (Move)
+    for (size_t i = 0; i < m+1; ++i) b[i] = b_default;
+
+  if (DiagA) ib[0] = m + 1;
+  else       ib[0] = 0;
+
+  /* count indices for each column */
+
+  for (size_t i = 0; i < n; ++i) {
+    for (size_t j = ia[i]; j < ia[i+1]; ++j) {
+      ++(ib[ja[j]+1]);
+    }
+  }
+
+  for (size_t i = 0; i < m; ++i) {
+    ib[i+1] = ib[i] + ib[i+1];
+  }
+
+  /* now make jb */
+
+  for (size_t i = 0; i < n; ++i) {
+
+    for (size_t j = ia[i]; j < ia[i+1]; ++j) {
+      index = ja[j];
+      jb[ib[index]] = i;
+
+      if (Move && a[j] != a_default)
+        b[ib[index]] = a[j];
+
+      ++(ib[index]);
+    }
+  }
+
+  /* now fixup ib */
+
+  for (size_t i = m; i >= 1; --i) {
+    ib[i] = ib[i-1];
+  }
+
+
+  if (DiagA) {
+    if (Move) {
+      size_t j = std::min(n,m);
+
+      for (size_t i = 0; i < j; ++i) {
+        b[i] = a[i];
+      }
+    }
+    ib[0] = m + 1;
+
+  } else {
+    ib[0] = 0;
+  }
+}
+
+} } // end of namespace nm::yale_storage
+
+#endif