numo-linalg 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5f5428ade2504c871f78f77e76a74efaad30853
+  data.tar.gz: 002524df9a6acb2c6701c234cc4216fde88a7e2e
+SHA512:
+  metadata.gz: dfb994654259edc522233e5196bf461797fa0aa9d552e7530c3657da826c3e1ad8ca280e9fade6b3413bc961c81c39ce86314e31f2c37b7d3a282e476611fe49
+  data.tar.gz: 1ec749584936a93a62717aa9073cd1b391d3fd64b9858b28fcefd3973c4f0c63cb2fe9ba429ed30e492ecff8af7d183aa35029bd9e9c06be3eaf82ff3f9ad597

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in narray-devel.gemspec
+gemspec

data/README.md

@@ -0,0 +1,80 @@
+# Numo::Linalg : Linear Algebra library with BLAS/LAPACK binding to Numo::NArray
+
+[![Binder](http://mybinder.org/badge.svg)](http://mybinder.org/repo/ruby-numo/linalg)
+[![Build Status](https://travis-ci.org/ruby-numo/linalg.svg?branch=master)](https://travis-ci.org/ruby-numo/linalg)
+
+[GitHub](https://github.com/ruby-numo/linalg)
+
+Under development!
+
+## Introduction
+
+This is a binding of BLAS/LAPACK for Numo::NArray using dynamic linking loader.
+This desgin allows you to change backend libraries without re-compiling.
+
+### [Numo::Linalg API](http://ruby-numo.github.io/linalg/yard/Numo/Linalg.html)
+
+* Matrix and vector products
+    * dot, matmul
+* Decomposition
+    * lu\_fact, lu\_inv, lu\_solve, cho\_fact, cho\_inv, cho\_solve
+      qr, svd, svdvals
+* Matrix eigenvalues
+    * eig, eigh, eigvals, eigvalsh
+* Norms and other numbers
+    * norm, cond, det, slogdet, matrix\_rank, matrix\_power
+* Solving equations and inverting matrices
+    * solve, lstsq, inv, pinv
+
+### Low-level modules
+
+* [Numo::Linalg::Blas](http://ruby-numo.github.io/linalg/yard/Numo/Linalg/Blas.html) - Low-level BLAS functions
+* [Numo::Linalg::Lapack](http://ruby-numo.github.io/linalg/yard/Numo/Linalg/Lapack.html) - Low-level LAPACK functions
+
+## Installation
+
+* Install [Numo::NArray](https://github.com/ruby-numo/narray)
+
+* Install [LAPACK](http://www.netlib.org/lapack/) or alternative package.
+
+    * Numo::Linalg requires C-interface
+      [CBLAS](http://www.netlib.org/blas/#_cblas) and
+      [LAPACKE](http://www.netlib.org/lapack/lapacke.html) interface.
+      These are included in LAPACK package.
+
+    * Recommended: use one of following faster libraries:
+        * [ATLAS](https://sourceforge.net/projects/math-atlas/)
+        * [OpenBLAS](http://www.openblas.net/)
+        * [Intel MKL](https://software.intel.com/intel-mkl)
+
+    * Note that the performance depends on the backend library as shown in
+      [benchmark](https://github.com/ruby-numo/linalg/tree/master/bench).
+
+* Install Numo::Linalg
+
+```shell
+$ gem install numo-linalg
+```
+
+or
+
+```shell
+$ git clone https://github.com/ruby-numo/linalg.git
+$ cd linalg
+$ rake build
+$ gem install pkg/numo-linalg-*.gem
+```
+
+* Read also instruction for [Selecting Backend Library](https://github.com/ruby-numo/linalg/tree/master/doc/select-backend.md).
+
+## Authors
+
+* Masahiro TANAKA
+* Makoto KISHIMOTO
+* This work is partly supported by 2016 Ruby Association Grant.
+
+## ToDo
+
+* More functions
+* write test
+* Documentation

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+
+task :doc do
+  srcs = []
+  Dir.glob("ext/numo/linalg/*").each do |d|
+    if File.exist?(d+"/extconf.rb")
+      sh "cd #{d}; ruby extconf.rb; make clean; make src"
+      srcs << d+"/*.c"
+    end
+  end
+  srcs << "lib/numo/linalg.rb"
+  srcs << "lib/numo/linalg/*.rb"
+  sh "yard -m markdown -o yard -r README.md #{srcs.join(' ')}"
+end
+
+task :cleandoc do
+  sh "rm -r yard .yardoc"
+end

data/ext/numo/linalg/blas/blas.c

@@ -0,0 +1,352 @@
+/*
+  blas.c
+  BLAS wrapper for Ruby/Numo
+    (C) Copyright 2017 by Masahiro TANAKA
+
+  This program is free software.
+  NO WARRANTY.
+*/
+#include <assert.h>
+#include <ruby.h>
+#include "numo/narray.h"
+#include "numo/template.h"
+#include "cblas.h"
+
+// from ruby/ext/fiddle/fiddle.h
+#if defined(HAVE_DLFCN_H)
+# include <dlfcn.h>
+# /* some stranger systems may not define all of these */
+#ifndef RTLD_LAZY
+#define RTLD_LAZY 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#else
+# if defined(_WIN32)
+#   include <windows.h>
+#   define dlopen(name,flag) ((void*)LoadLibrary(name))
+#   define dlerror() strerror(rb_w32_map_errno(GetLastError()))
+#   define dlsym(handle,name) ((void*)GetProcAddress((handle),(name)))
+#   define RTLD_LAZY -1
+#   define RTLD_NOW  -1
+#   define RTLD_GLOBAL -1
+# endif
+#endif
+
+static void *blas_handle = 0;
+static char *blas_prefix = 0;
+
+VALUE
+numo_cblas_option_value(VALUE order, VALUE default_value)
+{
+    switch(TYPE(order)) {
+    case T_NIL:
+    case T_UNDEF:
+        return default_value;
+    }
+    return order;
+}
+
+enum CBLAS_ORDER
+numo_cblas_option_order(VALUE order)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(order)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CblasRowMajor;
+    case T_TRUE:
+        return CblasColMajor;
+    case T_FIXNUM:
+        opt = FIX2INT(order);
+        if (opt >= CblasRowMajor && opt <= CblasColMajor) {
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        order = rb_sym2str(order);
+    case T_STRING:
+        ptr = RSTRING_PTR(order);
+        if (RSTRING_LEN(order) > 0) {
+            switch(ptr[0]){
+            case 'R': case 'r':
+                return CblasRowMajor;
+            case 'C': case 'c':
+                return CblasColMajor;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for CBLAS_ORDER");
+    return 0;
+}
+
+enum CBLAS_TRANSPOSE
+numo_cblas_option_trans(VALUE trans)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(trans)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CblasNoTrans;
+    case T_TRUE:
+        return CblasTrans;
+    case T_FIXNUM:
+        opt = FIX2INT(trans);
+        if (opt >= CblasNoTrans && opt <= CblasConjTrans) {
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        trans = rb_sym2str(trans);
+    case T_STRING:
+        ptr = RSTRING_PTR(trans);
+        if (RSTRING_LEN(trans) > 0) {
+            switch(ptr[0]){
+            case 'N': case 'n':
+                return CblasNoTrans;
+            case 'T': case 't':
+                return CblasTrans;
+            case 'C': case 'c':
+                return CblasConjTrans;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for CBLAS_TRANSPOSE");
+    return 0;
+}
+
+enum CBLAS_UPLO
+numo_cblas_option_uplo(VALUE uplo)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(uplo)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CblasUpper;
+    case T_TRUE:
+        return CblasLower;
+    case T_FIXNUM:
+        opt = FIX2INT(uplo);
+        switch(opt){
+        case CblasUpper:
+        case CblasLower:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        uplo = rb_sym2str(uplo);
+    case T_STRING:
+        ptr = RSTRING_PTR(uplo);
+        if (RSTRING_LEN(uplo) > 0) {
+            switch(ptr[0]){
+            case 'U': case 'u':
+                return CblasUpper;
+            case 'L': case 'l':
+                return CblasLower;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for CBLAS_UPLO");
+    return 0;
+}
+
+enum CBLAS_DIAG
+numo_cblas_option_diag(VALUE diag)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(diag)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CblasNonUnit;
+    case T_TRUE:
+        return CblasUnit;
+    case T_FIXNUM:
+        opt = FIX2INT(diag);
+        switch(opt){
+        case CblasNonUnit:
+        case CblasUnit:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        diag = rb_sym2str(diag);
+    case T_STRING:
+        ptr = RSTRING_PTR(diag);
+        if (RSTRING_LEN(diag) > 0) {
+            switch(ptr[0]){
+            case 'N': case 'n':
+                return CblasNonUnit;
+            case 'U': case 'u':
+                return CblasUnit;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for CBLAS_DIAG");
+    return 0;
+}
+
+enum CBLAS_SIDE
+numo_cblas_option_side(VALUE side)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(side)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CblasLeft;
+    case T_TRUE:
+        return CblasRight;
+    case T_FIXNUM:
+        opt = FIX2INT(side);
+        switch(opt){
+        case CblasLeft:
+        case CblasRight:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        side = rb_sym2str(side);
+    case T_STRING:
+        ptr = RSTRING_PTR(side);
+        if (RSTRING_LEN(side) > 0) {
+            switch(ptr[0]){
+            case 'L': case 'l':
+                return CblasLeft;
+            case 'R': case 'r':
+                return CblasRight;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for CBLAS_SIDE");
+    return 0;
+}
+
+void
+numo_cblas_check_func(void **func, const char *name)
+{
+    char *s, *error;
+
+    if (*func==0) {
+        if (blas_handle==0) {
+            rb_raise(rb_eRuntimeError,"BLAS library is not loaded");
+        }
+        if (blas_prefix==0) {
+            rb_raise(rb_eRuntimeError,"CBLAS prefix is not set");
+        }
+        s = alloca(strlen(blas_prefix)+strlen(name)+1);
+        strcpy(s,blas_prefix);
+        strcat(s,name);
+        dlerror();
+        *func = dlsym(blas_handle, s);
+        error = dlerror();
+        if (error != NULL) {
+            rb_raise(rb_eRuntimeError, "%s", error);
+        }
+    }
+}
+
+/*
+  module definition: Numo::Linalg
+*/
+static VALUE mLinalg;
+
+/*
+  module definition: Numo::Linalg::Blas
+*/
+static VALUE mBlas;
+
+
+static VALUE
+blas_s_dlopen(int argc, VALUE *argv, VALUE mod)
+{
+    int i, f;
+    VALUE lib, flag;
+    char *error;
+    void *handle;
+
+    i = rb_scan_args(argc, argv, "11", &lib, &flag);
+    if (i==2) {
+        f = NUM2INT(flag);
+    } else {
+        f = RTLD_LAZY | RTLD_LOCAL;
+    }
+    dlerror();
+    handle = dlopen(StringValueCStr(lib), f);
+    error = dlerror();
+    if (error != NULL) {
+        rb_raise(rb_eRuntimeError, "%s", error);
+    }
+    blas_handle = handle;
+    return Qnil;
+}
+
+
+static VALUE
+blas_s_prefix_set(VALUE mod, VALUE prefix)
+{
+    long len;
+
+    if (TYPE(prefix) != T_STRING) {
+        rb_raise(rb_eTypeError,"argument must be string");
+    }
+    if (blas_prefix) {
+        free(blas_prefix);
+    }
+    len = RSTRING_LEN(prefix);
+    blas_prefix = malloc(len+1);
+    strcpy(blas_prefix, StringValueCStr(prefix));
+    return prefix;
+}
+
+
+void Init_numo_linalg_blas_s();
+void Init_numo_linalg_blas_d();
+void Init_numo_linalg_blas_c();
+void Init_numo_linalg_blas_z();
+
+void
+Init_blas(void)
+{
+    VALUE mN;
+
+    mN = rb_define_module("Numo");
+    /*
+      Document-module: Numo::Linalg
+    */
+    mLinalg = rb_define_module_under(mN, "Linalg");
+    mBlas = rb_define_module_under(mLinalg, "Blas");
+
+    rb_define_module_function(mBlas, "dlopen", blas_s_dlopen, -1);
+    rb_define_module_function(mBlas, "prefix=", blas_s_prefix_set, 1);
+
+    blas_prefix = malloc(strlen("cblas_")+1); // default prefix
+    strcpy(blas_prefix,"cblas_");
+
+    Init_numo_linalg_blas_s();
+    Init_numo_linalg_blas_d();
+    Init_numo_linalg_blas_c();
+    Init_numo_linalg_blas_z();
+}