nmatrix 0.1.0 → 0.2.0

data/ext/nmatrix/math/potrs.h

@@ -1,129 +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 - 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
-//
-// == getrs.h
-//
-// getrs function in native C++.
-//
-
-/*
- *             Automatically Tuned Linear Algebra Software v3.8.4
- *                    (C) Copyright 1999 R. Clint Whaley
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions, and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *   3. The name of the ATLAS group or the names of its contributers may
- *      not be used to endorse or promote products derived from this
- *      software without specific written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef POTRS_H
-#define POTRS_H
-
-extern "C" {
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-}
-
-namespace nm { namespace math {
-
-/*
- * Solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization computed by POTRF.
- *
- * From ATLAS 3.8.0.
- */
-template <typename DType, bool is_complex>
-int potrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, const DType* A,
-           const int lda, DType* B, const int ldb)
-{
-  // enum CBLAS_DIAG Lunit, Uunit; // These aren't used. Not sure why they're declared in ATLAS' src.
-
-  CBLAS_TRANSPOSE MyTrans = is_complex ? CblasConjTrans : CblasTrans;
-
-  if (!N || !NRHS) return 0;
-
-  const DType ONE = 1;
-
-  if (Order == CblasColMajor) {
-    if (Uplo == CblasUpper) {
-      nm::math::trsm<DType>(Order, CblasLeft, CblasUpper, MyTrans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
-      nm::math::trsm<DType>(Order, CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
-    } else {
-      nm::math::trsm<DType>(Order, CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
-      nm::math::trsm<DType>(Order, CblasLeft, CblasLower, MyTrans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
-    }
-  } else {
-    // There's some kind of scaling operation that normally happens here in ATLAS. Not sure what it does, so we'll only
-    // worry if something breaks. It probably has to do with their non-templated code and doesn't apply to us.
-
-    if (Uplo == CblasUpper) {
-      nm::math::trsm<DType>(Order, CblasRight, CblasUpper, CblasNoTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
-      nm::math::trsm<DType>(Order, CblasRight, CblasUpper, MyTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
-    } else {
-      nm::math::trsm<DType>(Order, CblasRight, CblasLower, MyTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
-      nm::math::trsm<DType>(Order, CblasRight, CblasLower, CblasNoTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
-    }
-  }
-  return 0;
-}
-
-
-/*
-* Function signature conversion for calling LAPACK's potrs functions as directly as possible.
-*
-* For documentation: http://www.netlib.org/lapack/double/dpotrs.f
-*
-* This function should normally go in math.cpp, but we need it to be available to nmatrix.cpp.
-*/
-template <typename DType, bool is_complex>
-inline int clapack_potrs(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, const int nrhs,
-                         const void* a, const int lda, void* b, const int ldb) {
-  return potrs<DType,is_complex>(order, uplo, n, nrhs, reinterpret_cast<const DType*>(a), lda, reinterpret_cast<DType*>(b), ldb);
-}
-
-
-} } // end nm::math
-
-#endif // POTRS_H

data/ext/nmatrix/math/swap.h

@@ -1,52 +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 - 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
-//
-// == swap.h
-//
-// BLAS level 2 swap function in native C++.
-//
-
-#ifndef SWAP_H
-#define SWAP_H
-
-namespace nm { namespace math {
-// This is the old BLAS version of this function. ATLAS has an optimized version, but
-// it's going to be tough to translate.
-template <typename DType>
-static void swap(const int N, DType* X, const int incX, DType* Y, const int incY) {
-  if (N > 0) {
-    int ix = 0, iy = 0;
-    for (int i = 0; i < N; ++i) {
-      DType temp = X[i];
-      X[i]       = Y[i];
-      Y[i]       = temp;
-
-      ix += incX;
-      iy += incY;
-    }
-  }
-}
-
-}} // end nm::math
-
-#endif

data/lib/nmatrix/lapack.rb

@@ -1,240 +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 - 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
-#
-# == lapack.rb
-#
-# This file contains LAPACK functions accessible in their C versions,
-# e.g., NMatrix::LAPACK::clapack_func. There are some exceptions,
-# such as clapack_gesv, which is implemented in Ruby but calls
-# clapack_getrf and clapack_getrs.
-#
-# Note: most of these functions are borrowed from ATLAS, which is available under a BSD-
-# style license.
-#++
-
-class NMatrix
-  module LAPACK
-    class << self
-      #
-      # call-seq:
-      #     clapack_gesv(order, n, nrhs, a, lda, ipiv, b, ldb) -> NMatrix
-      #
-      # Computes the solution to a system of linear equations
-      #   A * X = B,
-      # where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
-      #
-      # The LU factorization used to factor A is dependent on the +order+
-      # parameter, as detailed in the leading comments of clapack_getrf.
-      #
-      # The factored form of A is then used solve the system of equations
-      # A * X = B.
-      #
-      # A is overwritten with the appropriate LU factorization, and B, which
-      # contains B on input, is overwritten with the solution X on output.
-      #
-      # From ATLAS 3.8.0.
-      #
-      # Note: Because this function is implemented in Ruby, the ATLAS lib 
-      # version is never called! For float32, float64, complex64, and 
-      # complex128, the ATLAS lib versions of getrf and getrs *will* be called.
-      #
-      # * *Arguments* :
-      #   - +order+ ->
-      #   - +n+ ->
-      #   - +nrhs+ ->
-      #   - +a+ ->
-      #   - +lda+ ->
-      #   - +b+ ->
-      #   - +ldb+ ->
-      #   - +ipiv+ -> A pivot array (if nil, one will be generated with +clapack_getrf+)
-      # * *Returns* :
-      #   -
-      # * *Raises* :
-      #   - ++ ->
-      #
-      def clapack_gesv(order, n, nrhs, a, lda, b, ldb, ipiv=nil)
-        ipiv ||= clapack_getrf(order, n, n, a, lda)
-        clapack_getrs(order, :no_transpose, n, nrhs, a, lda, ipiv, b, ldb)
-      end
-
-      #
-      # call-seq:
-      #     clapack_posv(order, uplo, n ,nrhs, a, lda, b, ldb) -> ...
-      #
-      # TODO Complete this description.
-      #
-      # Computes the solution to a real system of linear equations
-      #   A * X = B,
-      # where A is an N-by-N symmetric positive definite matrix and X and B
-      # are N-by-NRHS matrices.
-      #
-      # The Cholesky decomposition is used to factor A as
-      #   A = U**T* U,  if UPLO = 'U', or
-      #   A = L * L**T,  if UPLO = 'L',
-      # where U is an upper triangular matrix and L is a lower triangular
-      # matrix.  The factored form of A is then used to solve the system of
-      # equations A * X = B.
-      #
-      # From ATLAS 3.8.0.
-      #
-      # Note: Because this function is implemented in Ruby, the ATLAS lib
-      # version is never called! For float32, float64, complex64, and 
-      # complex128, the ATLAS lib versions of potrf and potrs *will* be called.
-      #
-      # * *Arguments* :
-      #   - +order+ ->
-      #   - +uplo+ ->
-      #   - +n+ ->
-      #   - +nrhs+ ->
-      #   - +a+ ->
-      #   - +lda+ ->
-      #   - +b+ ->
-      #   - +ldb+ ->
-      # * *Returns* :
-      #   -
-      # * *Raises* :
-      #   - ++ ->
-      #
-      def clapack_posv(order, uplo, n, nrhs, a, lda, b, ldb)
-        clapack_potrf(order, uplo, n, a, lda)
-        clapack_potrs(order, uplo, n, nrhs, a, lda, b, ldb)
-      end
-
-      #     laswp(matrix, ipiv) -> NMatrix
-      #
-      # Permute the columns of a matrix (in-place) according to the Array +ipiv+.
-      #
-      def laswp(matrix, ipiv)
-        raise(ArgumentError, "expected NMatrix for argument 0") unless matrix.is_a?(NMatrix)
-        raise(StorageTypeError, "LAPACK functions only work on :dense NMatrix instances") unless matrix.stype == :dense
-        raise(ArgumentError, "expected Array ipiv to have no more entries than NMatrix a has columns") if ipiv.size > matrix.shape[1]
-
-        clapack_laswp(matrix.shape[0], matrix, matrix.shape[1], 0, ipiv.size-1, ipiv, 1)
-      end
-
-      def alloc_svd_result(matrix)
-        [
-          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
-          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
-          NMatrix.new(matrix.shape[1], dtype: matrix.dtype)
-        ]
-      end
-
-
-      #
-      # call-seq:
-      #     gesvd(matrix) -> [u, sigma, v_transpose]
-      #     gesvd(matrix) -> [u, sigma, v_conjugate_transpose] # complex
-      #
-      # Compute the singular value decomposition of a matrix using LAPACK's GESVD function.
-      #
-      # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
-      # requires.
-      #
-      def gesvd(matrix, workspace_size=1)
-        result = alloc_svd_result(matrix)
-        NMatrix::LAPACK::lapack_gesvd(:a, :a, matrix.shape[0], matrix.shape[1], matrix, matrix.shape[0], result[1], result[0], matrix.shape[0], result[2], matrix.shape[1], workspace_size)
-        result
-      end
-
-      #
-      # call-seq:
-      #     gesdd(matrix) -> [u, sigma, v_transpose]
-      #     gesdd(matrix) -> [u, sigma, v_conjugate_transpose] # complex
-      #
-      # Compute the singular value decomposition of a matrix using LAPACK's GESDD function. This uses a divide-and-conquer
-      # strategy. See also #gesvd.
-      #
-      # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
-      # requires.
-      #
-      def gesdd(matrix, workspace_size=nil)
-        min_workspace_size = matrix.shape.min * (6 + 4 * matrix.shape.min) + matrix.shape.max
-        workspace_size = min_workspace_size if workspace_size.nil? || workspace_size < min_workspace_size
-        result = alloc_svd_result(matrix)
-        NMatrix::LAPACK::lapack_gesdd(:a, matrix.shape[0], matrix.shape[1], matrix, matrix.shape[0], result[1], result[0], matrix.shape[0], result[2], matrix.shape[1], workspace_size)
-        result
-      end
-
-      def alloc_evd_result(matrix)
-        [
-          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
-          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
-          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
-          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
-        ]
-      end
-
-
-      #
-      # call-seq:
-      #     geev(matrix) -> [eigenvalues, left_eigenvectors, right_eigenvectors]
-      #     geev(matrix, :left) -> [eigenvalues, left_eigenvectors]
-      #     geev(matrix, :right) -> [eigenvalues, right_eigenvectors]
-      #
-      # Perform eigenvalue decomposition on a matrix using LAPACK's xGEEV function.
-      #
-      def geev(matrix, which=:both)
-        jobvl = (which == :both || which == :left) ? :left : false
-        jobvr = (which == :both || which == :right) ? :right : false
-
-        # Copy the matrix so it doesn't get overwritten.
-        temporary_matrix = matrix.clone
-
-        # Outputs
-        real_eigenvalues = NMatrix.new([matrix.shape[0], 1], dtype: matrix.dtype)
-        imag_eigenvalues = NMatrix.new([matrix.shape[0], 1], dtype: matrix.dtype)
-
-        left_output      = jobvl == :left ? matrix.clone_structure : NMatrix.new(1, dtype: matrix.dtype)
-        right_output     = jobvr == :right ? matrix.clone_structure : NMatrix.new(1, dtype: matrix.dtype)
-
-        NMatrix::LAPACK::lapack_geev(jobvl, # compute left eigenvectors of A?
-                                     jobvr, # compute right eigenvectors of A? (left eigenvectors of A**T)
-                                     matrix.shape[0], # order of the matrix
-                                     temporary_matrix,# input matrix (used as work)
-                                     matrix.shape[0], # leading dimension of matrix
-                                     real_eigenvalues,# real part of computed eigenvalues
-                                     imag_eigenvalues,# imag part of computed eigenvalues
-                                     left_output,     # left eigenvectors, if applicable
-                                     left_output.shape[0], # leading dimension of left_output
-                                     right_output,    # right eigenvectors, if applicable
-                                     right_output.shape[0], # leading dimension of right_output
-                                     2*matrix.shape[0])
-
-        # Put the real and imaginary parts together
-        eigenvalues = real_eigenvalues.to_a.flatten.map.with_index do |real,i|
-          imag_eigenvalues[i] != 0 ? Complex(real, imag_eigenvalues[i]) : real
-        end
-
-        if which == :both
-          return [eigenvalues, left_output.transpose, right_output.transpose]
-        elsif which == :left
-          return [eigenvalues, left_output.transpose]
-        else
-          return [eigenvalues, right_output]
-        end
-      end
-
-    end
-  end
-end

data/nmatrix.gemspec

@@ -1,55 +0,0 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-
-require 'nmatrix/version'
-
-Gem::Specification.new do |gem|
-  gem.name = "nmatrix"
-  gem.version = NMatrix::VERSION::STRING
-  gem.summary = "NMatrix is a linear algebra library for Ruby"
-  gem.description = "NMatrix is a linear algebra library for Ruby, written mostly in C and C++."
-  gem.homepage = 'http://sciruby.com'
-  gem.authors = ['John Woods', 'Chris Wailes', 'Aleksey Timin']
-  gem.email =  ['john.o.woods@gmail.com']
-  gem.license = 'BSD 3-clause'
-  gem.post_install_message = <<-EOF
-***********************************************************
-Welcome to SciRuby: Tools for Scientific Computing in Ruby!
-
-NMatrix requires a C compiler, and has been tested only
-with GCC 4.6+. We are happy to accept contributions
-which improve the portability of this project.
-
-Also required is ATLAS. Most Linux distributions and Mac
-versions include ATLAS, but you may wish to compile it
-yourself. The Ubuntu/Debian apt package for ATLAS WILL
-NOT WORK with NMatrix if LAPACK is also installed.
-
-More explicit instructions for NMatrix and SciRuby should
-be available on the SciRuby website, sciruby.com, or
-through our mailing list (which can be found on our web-
-site).
-
-Thanks for trying out NMatrix! Happy coding!
-
-***********************************************************
-EOF
-
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.extensions = ['ext/nmatrix/extconf.rb']
-  gem.require_paths = ["lib"]
-
-  gem.required_ruby_version = '>= 1.9'
-
-  gem.add_dependency 'rdoc', '~>4.0', '>=4.0.1'
-  gem.add_dependency 'packable', '~> 1.3', '>= 1.3.5'
-  gem.add_development_dependency 'rake', '~>10.3'
-  gem.add_development_dependency 'bundler', '~>1.6'
-  gem.add_development_dependency 'rspec', '~>2.14'
-  gem.add_development_dependency 'rspec-longrun', '~>1.0'
-  gem.add_development_dependency 'pry', '~>0.10'
-  gem.add_development_dependency 'rake-compiler', '~>0.8'
-end
-