pnmatrix 1.2.4

data/ext/nmatrix/util/sl_list.h

@@ -0,0 +1,144 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == sl_list.h
+//
+// Singly-linked list implementation used for List Storage.
+
+#ifndef SL_LIST_H
+#define SL_LIST_H
+
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <type_traits>
+#include <cstdlib>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+#include "data/data.h"
+
+#include "nmatrix.h"
+
+namespace nm { namespace list {
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+ 
+
+/*
+ * Functions
+ */
+ 
+////////////////
+// Lifecycle //
+///////////////
+
+LIST*  create(void);
+void  del(LIST* list, size_t recursions);
+void  mark(LIST* list, size_t recursions);
+
+///////////////
+// Accessors //
+///////////////
+
+NODE* insert(LIST* list, bool replace, size_t key, void* val);
+NODE* insert_copy(LIST *list, bool replace, size_t key, void *val, size_t size);
+NODE* insert_first_node(LIST* list, size_t key, void* val, size_t val_size);
+NODE* insert_first_list(LIST* list, size_t key, LIST* l);
+NODE* insert_after(NODE* node, size_t key, void* val);
+NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t copy_size);
+void* remove(LIST* list, size_t key);
+void* remove_by_node(LIST* list, NODE* prev, NODE* rm);
+bool remove_recursive(LIST* list, const size_t* coords, const size_t* offset, const size_t* lengths, size_t r, const size_t& dim);
+bool node_is_within_slice(NODE* n, size_t coord, size_t len);
+
+template <typename Type>
+inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type val) {
+  Type* val_mem = NM_ALLOC(Type);
+  *val_mem = val;
+  
+  if (node == NULL) {
+    return insert(list, false, key, val_mem);
+    
+  } else {
+    return insert_after(node, key, val_mem);
+  }
+}
+
+template <typename Type>
+inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type* ptr) {
+  if (node == NULL) {
+    return insert(list, false, key, ptr);
+    
+  } else {
+    return insert_after(node, key, ptr);
+  }
+}
+
+///////////
+// Tests //
+///////////
+
+
+/////////////
+// Utility //
+/////////////
+
+NODE* find(LIST* list, size_t key);
+NODE* find_preceding_from_node(NODE* prev, size_t key);
+NODE* find_preceding_from_list(LIST* l, size_t key);
+NODE* find_nearest(LIST* list, size_t key);
+NODE* find_nearest_from(NODE* prev, size_t key);
+
+/////////////////////////
+// Copying and Casting //
+/////////////////////////
+
+template <typename LDType, typename RDType>
+void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions);
+
+}} // end of namespace nm::list
+
+extern "C" {
+  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, nm::dtype_t lhs_dtype, nm::dtype_t rhs_dtype, size_t recursions);
+  VALUE nm_list_copy_to_hash(const LIST* l, const nm::dtype_t dtype, size_t recursions, VALUE default_value);
+} // end of extern "C" block
+
+#endif // SL_LIST_H

data/ext/nmatrix/util/util.h

@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == util.h
+//
+// Header file for utility functions and data.
+
+#ifndef UTIL_H
+#define UTIL_H
+
+/*
+ * Standard Includes
+ */
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+/*
+ * Functions
+ */
+namespace nm {
+  template <typename Type>
+  inline Type gcf(Type x, Type y) {
+    Type t;
+
+    if (x < 0) x = -x;
+    if (y < 0) y = -y;
+
+    if (x == 0) return y;
+    if (y == 0) return x;
+
+    while (x > 0) {
+      t = x;
+      x = y % x;
+      y = t;
+    }
+
+    return y;
+  }
+} // end of namespace nm
+
+
+#endif // UTIL_H

data/lib/nmatrix/blas.rb

@@ -0,0 +1,378 @@
+#--
+# = 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 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, 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
+#
+# == blas.rb
+#
+# This file contains the safer accessors for the BLAS functions
+# supported by NMatrix.
+#++
+
+module NMatrix::BLAS
+
+  #Add functions from C extension to main BLAS module
+  class << self
+    if jruby?
+      # BLAS functionalities for JRuby need to be implemented
+    else
+      NMatrix::Internal::BLAS.singleton_methods.each do |m|
+        define_method m, NMatrix::Internal::BLAS.method(m).to_proc
+      end
+    end
+  end
+
+  class << self
+    #
+    # call-seq:
+    #     gemm(a, b) -> NMatrix
+    #     gemm(a, b, c) -> NMatrix
+    #     gemm(a, b, c, alpha, beta) -> NMatrix
+    #
+    # Updates the value of C via the matrix multiplication
+    #   C = (alpha * A * B) + (beta * C)
+    # where +alpha+ and +beta+ are scalar values.
+    #
+    # * *Arguments* :
+    #   - +a+ -> Matrix A.
+    #   - +b+ -> Matrix B.
+    #   - +c+ -> Matrix C.
+    #   - +alpha+ -> A scalar value that multiplies A * B.
+    #   - +beta+ -> A scalar value that multiplies C.
+    #   - +transpose_a+ ->
+    #   - +transpose_b+ ->
+    #   - +m+ ->
+    #   - +n+ ->
+    #   - +k+ ->
+    #   - +lda+ ->
+    #   - +ldb+ ->
+    #   - +ldc+ ->
+    # * *Returns* :
+    #   - A NMatrix equal to (alpha * A * B) + (beta * C).
+    # * *Raises* :
+    #   - +ArgumentError+ -> +a+ and +b+ must be dense matrices.
+    #   - +ArgumentError+ -> +c+ must be +nil+ or a dense matrix.
+    #   - +ArgumentError+ -> The dtype of the matrices must be equal.
+    #
+    def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0,
+             transpose_a = false, transpose_b = false, m = nil,
+             n = nil, k = nil, lda = nil, ldb = nil, ldc = nil)
+
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+            unless a.is_a?(NMatrix) and b.is_a? \
+            (NMatrix) and a.stype == :dense and b.stype == :dense
+
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') \
+            unless c.nil? or (c.is_a?(NMatrix)  \
+            and c.stype == :dense)
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+            unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
+
+      # First, set m, n, and k, which depend on whether we're taking the
+      # transpose of a and b.
+      if c
+        m ||= c.shape[0]
+        n ||= c.shape[1]
+        k ||= transpose_a ? a.shape[0] : a.shape[1]
+
+      else
+        if transpose_a
+          # Either :transpose or :complex_conjugate.
+          m ||= a.shape[1]
+          k ||= a.shape[0]
+
+        else
+          # No transpose.
+          m ||= a.shape[0]
+          k ||= a.shape[1]
+        end
+
+        n ||= transpose_b ? b.shape[0] : b.shape[1]
+        c  = NMatrix.new([m, n], dtype: a.dtype)
+      end
+
+      # I think these are independent of whether or not a transpose occurs.
+      lda ||= a.shape[1]
+      ldb ||= b.shape[1]
+      ldc ||= c.shape[1]
+
+      # NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
+      if a.dtype == :complex64 or a.dtype == :complex128
+        alpha = Complex(1.0, 0.0) if alpha == 1.0
+        beta  = Complex(0.0, 0.0) if beta  == 0.0
+      end
+
+      # For argument descriptions, see: http://www.netlib.org/blas/dgemm.f
+      ::NMatrix::BLAS.cblas_gemm(:row, transpose_a, transpose_b,
+       m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
+
+      return c
+    end
+
+    #
+    # call-seq:
+    #     gemv(a, x) -> NMatrix
+    #     gemv(a, x, y) -> NMatrix
+    #     gemv(a, x, y, alpha, beta) -> NMatrix
+    #
+    # Implements matrix-vector product via
+    #   y = (alpha * A * x) + (beta * y)
+    # where +alpha+ and +beta+ are scalar values.
+    #
+    # * *Arguments* :
+    #   - +a+ -> Matrix A.
+    #   - +x+ -> Vector x.
+    #   - +y+ -> Vector y.
+    #   - +alpha+ -> A scalar value that multiplies A * x.
+    #   - +beta+ -> A scalar value that multiplies y.
+    #   - +transpose_a+ ->
+    #   - +m+ ->
+    #   - +n+ ->
+    #   - +lda+ ->
+    #   - +incx+ ->
+    #   - +incy+ ->
+    # * *Returns* :
+    #   -
+    # * *Raises* :
+    #   - ++ ->
+    #
+    def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0,
+             transpose_a = false, m = nil, n = nil, lda = nil,
+             incx = nil, incy = nil)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+       unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and \
+       a.stype == :dense and x.stype == :dense
+
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') \
+       unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
+
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+       unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
+
+      m ||= transpose_a == :transpose ? a.shape[1] : a.shape[0]
+      n ||= transpose_a == :transpose ? a.shape[0] : a.shape[1]
+      raise(ArgumentError, "dimensions don't match") \
+       unless x.shape[0] == n && x.shape[1] == 1
+
+      if y
+        raise(ArgumentError, "dimensions don't match") \
+         unless y.shape[0] == m && y.shape[1] == 1
+      else
+        y = NMatrix.new([m,1], dtype: a.dtype)
+      end
+
+      lda  ||= a.shape[1]
+      incx ||= 1
+      incy ||= 1
+
+      ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n,
+       alpha, a, lda, x, incx, beta, y, incy)
+
+      return y
+    end
+
+    #
+    # call-seq:
+    #     rot(x, y, c, s) -> [NMatrix, NMatrix]
+    #
+    # Apply plane rotation.
+    #
+    # * *Arguments* :
+    #   - +x+ -> NMatrix
+    #   - +y+ -> NMatrix
+    #   - +c+ -> cosine of the angle of rotation
+    #   - +s+ -> sine of the angle of rotation
+    #   - +incx+ -> stride of NMatrix +x+
+    #   - +incy+ -> stride of NMatrix +y+
+    #   - +n+ -> number of elements to consider in x and y
+    #   - +in_place+ -> true   if it's okay to modify the supplied
+    #                           +x+ and +y+ parameters directly;
+    #                   false if not. Default is false.
+    # * *Returns* :
+    #   - Array with the results, in the format [xx, yy]
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrices as first two arguments.
+    #   - +ArgumentError+ -> NMatrix dtype mismatch.
+    #   - +ArgumentError+ -> Need to supply n for non-standard incx,
+    #                         incy values.
+    #
+    def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+       unless x.is_a?(NMatrix) and y.is_a?(NMatrix) \
+       and x.stype == :dense and y.stype == :dense
+
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+       unless x.dtype == y.dtype
+
+      raise(ArgumentError, 'Need to supply n for non-standard incx, incy values') \
+       if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
+
+      n ||= [x.size/incx.abs, y.size/incy.abs].min
+
+      if in_place
+        ::NMatrix::BLAS.cblas_rot(n, x, incx, y, incy, c, s)
+        return [x,y]
+      else
+        xx = x.clone
+        yy = y.clone
+
+        ::NMatrix::BLAS.cblas_rot(n, xx, incx, yy, incy, c, s)
+
+        return [xx,yy]
+      end
+    end
+
+
+    #
+    # call-seq:
+    #     rot!(x, y, c, s) -> [NMatrix, NMatrix]
+    #
+    # Apply plane rotation directly to +x+ and +y+.
+    #
+    # See rot for arguments.
+    def rot!(x, y, c, s, incx = 1, incy = 1, n = nil)
+      rot(x,y,c,s,incx,incy,n,true)
+    end
+
+
+    #
+    # call-seq:
+    #     rotg(ab) -> [Numeric, Numeric]
+    #
+    # Apply givens plane rotation to the coordinates (a,b),
+    #  returning the cosine and sine of the angle theta.
+    #
+    # Since the givens rotation includes a square root,
+    #  integers are disallowed.
+    #
+    # * *Arguments* :
+    #   - +ab+ -> NMatrix with two elements
+    # * *Returns* :
+    #   - Array with the results, in the format [cos(theta), sin(theta)]
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrix of size 2
+    #
+    def rotg(ab)
+      raise(ArgumentError, "Expected dense NMatrix of shape [2,1] or [1,2]") \
+       unless ab.is_a?(NMatrix) && ab.stype == :dense && ab.size == 2
+
+      ::NMatrix::BLAS.cblas_rotg(ab)
+    end
+
+
+    #
+    # call-seq:
+    #     asum(x, incx, n) -> Numeric
+    #
+    # Calculate the sum of absolute values of the entries of a
+    #  vector +x+ of size +n+
+    #
+    # * *Arguments* :
+    #   - +x+ -> an NMatrix (will also allow an NMatrix,
+    #             but will treat it as if it's a vector )
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The sum
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def asum(x, incx = 1, n = nil)
+      n ||= x.size / incx
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") \
+       unless x.is_a?(NMatrix)
+
+      raise(RangeError, "n out of range") \
+       if n*incx > x.size || n*incx <= 0 || n <= 0
+       ::NMatrix::BLAS.cblas_asum(n, x, incx)
+    end
+
+    #
+    # call-seq:
+    #     nrm2(x, incx, n)
+    #
+    # Calculate the 2-norm of a vector +x+ of size +n+
+    #
+    # * *Arguments* :
+    #   - +x+ -> an NMatrix (will also allow an
+    #             NMatrix, but will treat it as if it's a vector )
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The 2-norm
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def nrm2(x, incx = 1, n = nil)
+      n ||= x.size / incx
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") \
+       unless x.is_a?(NMatrix)
+
+      raise(RangeError, "n out of range") \
+       if n*incx > x.size || n*incx <= 0 || n <= 0
+       ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
+    end
+
+    #
+    # call-seq:
+    #     scal(alpha, vector, incx, n)
+    #
+    # Scale a matrix by a given scaling factor
+    #
+    # * *Arguments* :
+    #   - +alpha+ -> a scaling factor
+    #   - +vector+ -> an NMatrix
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The scaling result
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def scal(alpha, vector, incx=1, n=nil)
+      n ||= vector.size / incx
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless vector.is_a?(NMatrix)
+      raise(RangeError, "n out of range") if n*incx > vector.size || n*incx <= 0 || n <= 0
+      ::NMatrix::BLAS.cblas_scal(n, alpha, vector, incx)
+    end
+
+    # The following are functions that used to be implemented in C, but
+    # now require nmatrix-atlas or nmatrix-lapcke to run properly, so we can just
+    # implemented their stubs in Ruby.
+    def cblas_trmm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, b, ldb)
+      raise(NotImplementedError,"cblas_trmm requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
+    end
+
+    def cblas_syrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
+      raise(NotImplementedError,"cblas_syrk requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
+    end
+
+    def cblas_herk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
+      raise(NotImplementedError,"cblas_herk requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
+    end
+  end
+end