numo-narray 0.9.0.6 → 0.9.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc2454fb169ad87ab4cb44c775c52906cb7636e8
-  data.tar.gz: f81cd5ccc97b7fec259329021fce9ed896871670
+  metadata.gz: 2d0790c23a92e44538dfd0978899cdf87ccb5a36
+  data.tar.gz: c08e683349d0a8fad66c124f4fc687d79381a7bf
 SHA512:
-  metadata.gz: c0e17e85b64041604643c9dfec270466dcf298cb794059f62f203eb82eb0b001d7a60a1b992c4bba7e0c286b03f508aaab0181187c9dff983f78b1c1f860c2f5
-  data.tar.gz: 3a37fe344a33dd64effe30eb531300ef0144d250ad9223198bb4cbc016cbff7a312f3f39fdc4ad2bc83314dfc2de708d842c64740494690f79c62acfd58ef277
+  metadata.gz: 9f961ea396916fb91fc4e25cd93987786952397fbe75b9d7f11681e4abb3a764a8e12f9040ea2ed6a4164c4390535e01599ceba30351397617b4db39605b7bbe
+  data.tar.gz: f269691e7a51587070e4b548272ce56aeb84c6f036e2f70482801d7b4d8a19dadc96bf13783b19302ff1f937f3436240f23ca680676d7d54ffa77ae1fe1d1b8a

data/Rakefile

@@ -7,7 +7,7 @@ task :doc do
     map{|s| File.join(dir,s)} +
     [File.join(dir,"types/*.c"), "lib/numo/narray/extra.rb"]
   sh "cd ext/numo/narray; ruby extconf.rb; make src"
-  sh "rm -rf yard .yardoc; yard doc -o yard -r README.md #{src.join(' ')}"
+  sh "rm -rf yard .yardoc; yard doc -o yard -m markdown -r README.md #{src.join(' ')}"
 end
 
 require "rake/extensiontask"

data/ext/numo/narray/data.c

@@ -335,18 +335,15 @@ na_transpose(int argc, VALUE *argv, VALUE self)
 
 //----------------------------------------------------------------------
 
-/* private function for reshape */
-static VALUE
-na_reshape(int argc, VALUE *argv, VALUE self)
+static void
+na_check_reshape(int argc, VALUE *argv, VALUE self, size_t *shape)
 {
     int    i, unfixed=-1;
     size_t total=1;
-    size_t *shape; //, *shape_save;
     narray_t *na;
-    VALUE    copy;
 
     if (argc == 0) {
-        rb_raise(rb_eRuntimeError, "No argrument");
+        rb_raise(rb_eArgError, "No argrument");
     }
     GetNArray(self,na);
     if (NA_SIZE(na) == 0) {
@@ -354,7 +351,6 @@ na_reshape(int argc, VALUE *argv, VALUE self)
     }
 
     /* get shape from argument */
-    shape = ALLOCA_N(size_t,argc);
     for (i=0; i<argc; ++i) {
         switch(TYPE(argv[i])) {
         case T_FIXNUM:
@@ -362,6 +358,9 @@ na_reshape(int argc, VALUE *argv, VALUE self)
             break;
         case T_NIL:
         case T_TRUE:
+            if (unfixed >= 0) {
+                rb_raise(rb_eArgError,"multiple unfixed dimension");
+            }
             unfixed = i;
             break;
         default:
@@ -370,24 +369,66 @@ na_reshape(int argc, VALUE *argv, VALUE self)
     }
 
     if (unfixed>=0) {
-        if (NA_SIZE(na) % total != 0)
+        if (NA_SIZE(na) % total != 0) {
             rb_raise(rb_eArgError, "Total size size must be divisor");
+        }
         shape[unfixed] = NA_SIZE(na) / total;
     }
     else if (total !=  NA_SIZE(na)) {
         rb_raise(rb_eArgError, "Total size must be same");
     }
+}
 
-    copy = rb_funcall(self,rb_intern("dup"),0);
-    GetNArray(copy,na);
-    //shape_save = NA_SHAPE(na);
-    na_setup_shape(na,argc,shape);
-    //if (NA_SHAPE(na) != shape_save) {
-    //    xfree(shape_save);
-    //}
-    return copy;
+/*
+  Change the shape of self NArray without coping.
+  Raise exception if self is non-contiguous.
+
+  @overload  reshape!(size0,size1,...)
+  @param sizeN [Integer] new shape
+  @return [Numo::NArray] return self.
+  @example
+*/
+static VALUE
+na_reshape_bang(int argc, VALUE *argv, VALUE self)
+{
+    size_t *shape;
+    narray_t *na;
+
+    if (na_check_contiguous(self)==Qfalse) {
+        rb_raise(rb_eStandardError, "cannot change shape of non-contiguous NArray");
+    }
+    shape = ALLOCA_N(size_t, argc);
+    na_check_reshape(argc, argv, self, shape);
+
+    GetNArray(self, na);
+    na_setup_shape(na, argc, shape);
+    return self;
 }
 
+/*
+  Copy and change the shape of NArray.
+  Returns a copied NArray.
+
+  @overload  reshape(size0,size1,...)
+  @param sizeN [Integer] new shape
+  @return [Numo::NArray] return self.
+  @example
+*/
+static VALUE
+na_reshape(int argc, VALUE *argv, VALUE self)
+{
+    size_t *shape;
+    narray_t *na;
+    VALUE    copy;
+
+    shape = ALLOCA_N(size_t, argc);
+    na_check_reshape(argc, argv, self, shape);
+
+    copy = rb_funcall(self, rb_intern("dup"), 0);
+    GetNArray(copy, na);
+    na_setup_shape(na, argc, shape);
+    return copy;
+}
 
 //----------------------------------------------------------------------
 
@@ -739,6 +780,7 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
 //----------------------------------------------------------------------
 
 
+#if 0
 #ifdef SWAP
 #undef SWAP
 #endif
@@ -880,7 +922,7 @@ numo_na_dot(VALUE self, VALUE other)
     }
     return rb_funcall(a1,id_mulsum,2,a2,INT2FIX(-1));
 }
-
+#endif
 
 void
 Init_nary_data()
@@ -892,8 +934,8 @@ Init_nary_data()
     rb_define_method(cNArray, "transpose", na_transpose, -1);
 
     rb_define_method(cNArray, "reshape", na_reshape,-1);
-    /*
     rb_define_method(cNArray, "reshape!", na_reshape_bang,-1);
+    /*
     rb_define_alias(cNArray,  "shape=","reshape!");
     */
     rb_define_method(cNArray, "diagonal", na_diagonal,-1);
@@ -914,7 +956,7 @@ Init_nary_data()
     rb_define_method(cNArray, "to_host", nary_to_host, 0);
     rb_define_method(cNArray, "to_swapped", nary_to_swapped, 0);
 
-    rb_define_method(cNArray, "dot", numo_na_dot, 1);
+    //rb_define_method(cNArray, "dot", numo_na_dot, 1);
 
     id_mulsum       = rb_intern("mulsum");
     sym_mulsum      = ID2SYM(id_mulsum);

data/ext/numo/narray/gen/erbpp2.rb

@@ -109,6 +109,7 @@ end
 class DefLib < ErbPP
   def initialize(parent=nil, **opts, &block)
     opts[:erb_base] ||= 'lib'
+    opts[:include_files] ||= []
     super(parent, **opts, &block)
   end
   def id_assign
@@ -222,7 +223,7 @@ class DefMethod < ErbPP
   end
 
   def c_name
-    @opts[:name].gsub(/\?/,"_p").gsub(/\!/,"_bang")
+    @opts[:name].gsub(/\?/,"_p").gsub(/\!/,"_bang").gsub(/=/,"_set")
   end
 
   def op_map

data/ext/numo/narray/gen/spec.rb

@@ -64,6 +64,16 @@ else
   def_const "CONTIGUOUS_STRIDE", "INT2FIX(sizeof(dtype))"
 end
 
+if !is_object
+  if is_float
+    def_const "EPSILON", "M_EPSILON"
+  end
+  if is_float || is_int
+    def_const "MAX", "M_MAX"
+    def_const "MIN", "M_MIN"
+  end
+end
+
 # Un-define
 
 if is_object

data/ext/numo/narray/gen/tmpl/qsort.c

@@ -1,7 +1,7 @@
 /*
   qsort.c
   Numerical Array Extension for Ruby
-    (C) Copyright 2007-2017 by Masahiro TANAKA
+    modified by Masahiro TANAKA
 */
 
 /*

data/ext/numo/narray/gen/tmpl/set2.c

@@ -13,14 +13,14 @@ static void
     if (idx1) {
         if (idx2) {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                GET_DATA(p1+*idx1,dtype,x);
                 GET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
                 x = m_<%=name%>(x,y);
                 SET_DATA_INDEX(p1,idx1,dtype,x);
             }
         } else {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                GET_DATA(p1+*idx1,dtype,x);
                 GET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
                 x = m_<%=name%>(x,y);
                 SET_DATA_INDEX(p1,idx1,dtype,x);

data/ext/numo/narray/narray.c

@@ -1448,52 +1448,15 @@ na_test_reduce(VALUE reduce, int dim)
 }
 
 
-VALUE
-na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
-                    ndfunc_t *ndf, na_iter_func_t iter_nan)
+static VALUE
+na_get_reduce_flag_from_narray(int naryc, VALUE *naryv, int *max_arg)
 {
     int ndim, ndim0;
-    int row_major;
-    int i, r;
-    long narg;
+    int rowmaj;
+    int i;
     size_t j;
-    size_t len;
-    ssize_t beg, step;
-    VALUE v;
     narray_t *na;
-    size_t m;
     VALUE reduce;
-    VALUE kw_hash = Qnil;
-    ID kw_table[3] = {id_axis,id_nan,id_keepdims};
-    VALUE opts[3] = {Qundef,Qundef,Qundef};
-    VALUE axes;
-
-    narg = rb_scan_args(argc, argv, "*:", &axes, &kw_hash);
-    rb_get_kwargs(kw_hash, kw_table, 0, 3, opts);
-
-    // option: axis
-    if (opts[0] != Qundef && RTEST(opts[0])) {
-        if (narg > 0) {
-            rb_raise(rb_eArgError,"both axis-arguments and axis-keyword are given");
-        }
-        if (TYPE(opts[0]) == T_ARRAY) {
-            axes = opts[0];
-        } else {
-            axes = rb_ary_new3(1,opts[0]);
-        }
-    }
-    if (ndf) {
-        // option: nan
-        if (iter_nan && opts[1] != Qundef) {
-            if (RTEST(opts[1]))
-                ndf->func = iter_nan; // replace to nan-aware iterator function
-        }
-        // option: keepdims
-        if (opts[2] != Qundef) {
-            if (RTEST(opts[2]))
-                ndf->flag |= NDF_KEEP_DIM;
-        }
-    }
 
     if (naryc<1) {
         rb_raise(rb_eRuntimeError,"must be positive: naryc=%d", naryc);
@@ -1503,32 +1466,47 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
         rb_raise(nary_eShapeError,"cannot reduce empty NArray");
     }
     reduce = na->reduce;
-    if (argc==0) {
-        //printf("pass argc=0 reduce=%d\n",NUM2INT(reduce));
-        return reduce;
-    }
     ndim = ndim0 = na->ndim;
-    row_major = TEST_COLUMN_MAJOR(naryv[0]);
-    for (i=1; i<naryc; i++) {
+    if (max_arg) *max_arg = 0;
+    rowmaj = TEST_COLUMN_MAJOR(naryv[0]);
+    for (i=0; i<naryc; i++) {
         GetNArray(naryv[i],na);
         if (na->size==0) {
             rb_raise(nary_eShapeError,"cannot reduce empty NArray");
         }
-        if (TEST_COLUMN_MAJOR(naryv[i]) != row_major) {
+        if (TEST_COLUMN_MAJOR(naryv[i]) != rowmaj) {
             rb_raise(nary_eDimensionError,"dimension order is different");
         }
-        if (na->ndim > ndim) {
+        if (na->ndim > ndim) { // maximum dimension
             ndim = na->ndim;
+            if (max_arg) *max_arg = i;
         }
     }
     if (ndim != ndim0) {
-        j = FIX2ULONG(reduce) << (ndim-ndim0);
-        reduce = ULONG2NUM(j);
-        if (!FIXNUM_P(reduce)) {
-            rb_raise(nary_eDimensionError,"reduce has too many bits");
-        }
+        j = NUM2SIZET(reduce) << (ndim-ndim0);
+        reduce = SIZET2NUM(j);
     }
-    //printf("argc=%d\n",argc);
+    return reduce;
+}
+
+
+static VALUE
+na_get_reduce_flag_from_axes(VALUE na_obj, VALUE axes)
+{
+    int i, r;
+    int ndim, rowmaj;
+    long narg;
+    size_t j;
+    size_t len;
+    ssize_t beg, step;
+    VALUE v;
+    size_t m;
+    VALUE reduce;
+    narray_t *na;
+
+    GetNArray(na_obj,na);
+    ndim = na->ndim;
+    rowmaj = TEST_COLUMN_MAJOR(na_obj);
 
     m = 0;
     reduce = Qnil;
@@ -1554,8 +1532,9 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
         }
         for (j=0; j<len; j++) {
             r = beg + step*j;
-            if (row_major)
+            if (rowmaj) {
                 r = ndim-1-r;
+            }
             if (reduce==Qnil) {
               if ( r < (ssize_t)sizeof(size_t) ) {
                     m |= ((size_t)1) << r;
@@ -1568,12 +1547,70 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
             reduce = rb_funcall( reduce, '|', 1, v );
         }
     }
-    RB_GC_GUARD(axes);
-    if (reduce==Qnil) reduce = SIZET2NUM(m);
+    if (NIL_P(reduce)) reduce = SIZET2NUM(m);
     return reduce;
 }
 
 
+VALUE
+nary_reduce_options(VALUE axes, VALUE *opts, int naryc, VALUE *naryv,
+                    ndfunc_t *ndf)
+{
+    int  max_arg;
+    VALUE reduce;
+
+    // option: axis
+    if (opts[0] != Qundef && RTEST(opts[0])) {
+        if (!NIL_P(axes)) {
+            rb_raise(rb_eArgError,
+              "cannot specify axis-arguments and axis-keyword simultaneously");
+        }
+        if (TYPE(opts[0]) == T_ARRAY) {
+            axes = opts[0];
+        } else {
+            axes = rb_ary_new3(1,opts[0]);
+        }
+    }
+    if (ndf) {
+        // option: keepdims
+        if (opts[1] != Qundef) {
+            if (RTEST(opts[1]))
+                ndf->flag |= NDF_KEEP_DIM;
+        }
+    }
+
+    reduce = na_get_reduce_flag_from_narray(naryc, naryv, &max_arg);
+
+    if (NIL_P(axes)) return reduce;
+
+    return na_get_reduce_flag_from_axes(naryv[max_arg], axes);
+}
+
+
+VALUE
+nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
+                      ndfunc_t *ndf, na_iter_func_t iter_nan)
+{
+    long narg;
+    VALUE axes;
+    VALUE kw_hash = Qnil;
+    ID kw_table[3] = {id_axis,id_keepdims,id_nan};
+    VALUE opts[3] = {Qundef,Qundef,Qundef};
+
+    narg = rb_scan_args(argc, argv, "*:", &axes, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 3, opts);
+
+    if (ndf) {
+        // option: nan
+        if (iter_nan && opts[2] != Qundef) {
+            if (RTEST(opts[2]))
+                ndf->func = iter_nan; // replace to nan-aware iterator function
+        }
+    }
+
+    return na_reduce_options((narg)?axes:Qnil, opts, naryc, naryv, ndf);
+}
+
 /*
   Return true if column major.
 */

data/ext/numo/narray/ndloop.c

@@ -1205,15 +1205,10 @@ ndfunc_write_back(ndfunc_t *nf, na_md_loop_t *lp, VALUE orig_args, VALUE results
 static VALUE
 ndloop_extract(VALUE results, ndfunc_t *nf)
 {
-    static ID id_extract = 0;
     long n, i;
     VALUE x, y;
     narray_t *na;
 
-    if (id_extract==0) {
-        id_extract = id_extract;
-    }
-
     // extract result objects
     switch(nf->nout) {
     case 0:

data/ext/numo/narray/numo/intern.h

@@ -75,6 +75,10 @@ void na_release_lock(VALUE); // currently do nothing
 VALUE nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
                             ndfunc_t *ndf, na_iter_func_t nan_iter);
 
+#define na_reduce_options nary_reduce_options
+VALUE nary_reduce_options(VALUE axes, VALUE *opts, int naryc, VALUE *naryv,
+                          ndfunc_t *ndf);
+
 // ndloop
 VALUE na_ndloop(ndfunc_t *nf, int argc, ...);
 VALUE na_ndloop2(ndfunc_t *nf, VALUE args);

data/ext/numo/narray/numo/narray.h

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.0.6"
-#define NARRAY_VERSION_CODE 906
+#define NARRAY_VERSION "0.9.0.7"
+#define NARRAY_VERSION_CODE 907
 
 #include <math.h>
 #include "numo/compat.h"

data/ext/numo/narray/numo/template.h

@@ -10,10 +10,11 @@
     {   c = (lp)->n[0]; }
 
 #define NDL_CNT(lp) ((lp)->n[0])
-#define NDL_PTR(lp,i) (((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos)
-#define NDL_STP(lp,i) (((lp)->args[i].iter[0]).step)
-#define NDL_IDX(lp,i) (((lp)->args[i].iter[0]).idx)
-#define NDL_ESZ(lp,i) (((lp)->args[i]).elmsz)
+#define NDL_PTR(lp,i) ((lp)->args[i].ptr + (lp)->args[i].iter[0].pos)
+#define NDL_STEP(lp,i) ((lp)->args[i].iter[0].step)
+#define NDL_IDX(lp,i) ((lp)->args[i].iter[0].idx)
+#define NDL_ESZ(lp,i) ((lp)->args[i].elmsz)
+#define NDL_SHAPE(lp,i) ((lp)->args[i].shape)
 
 #define INIT_PTR( lp, i, pt, st )                               \
     {                                                           \

data/ext/numo/narray/numo/types/dcomplex.h

@@ -10,6 +10,7 @@ static inline bool c_nearly_eq(dtype x, dtype y) {
     return c_abs(c_sub(x,y)) <= (c_abs(x)+c_abs(y))*DBL_EPSILON*2;
 }
 
+#ifdef SFMT_H
 /* generates a random number on [0,1)-real-interval */
 inline static dtype m_rand(dtype max)
 {
@@ -36,3 +37,8 @@ inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
     REAL(*a0) = x1*w * sigma + REAL(mu);
     IMAG(*a0) = x2*w * sigma + IMAG(mu);
 }
+#endif
+
+#define M_EPSILON rb_float_new(2.2204460492503131e-16)
+#define M_MIN     rb_float_new(2.2250738585072014e-308)
+#define M_MAX     rb_float_new(1.7976931348623157e+308)

data/ext/numo/narray/numo/types/dfloat.h

@@ -6,6 +6,7 @@ typedef double rtype;
 
 #include "float_macro.h"
 
+#ifdef SFMT_H
 /* generates a random number on [0,1)-real-interval */
 inline static dtype m_rand(dtype max)
 {
@@ -29,8 +30,13 @@ inline static void m_rand_norm(dtype mu, dtype sigma, dtype *a0, dtype *a1)
     if (a0) {*a0 = x1*w * sigma + mu;}
     if (a1) {*a1 = x2*w * sigma + mu;}
 }
+#endif
 
 #define m_min_init numo_dfloat_new_dim0(0.0/0.0)
 #define m_max_init numo_dfloat_new_dim0(0.0/0.0)
 #define m_extract(x) rb_float_new(*(double*)x)
 #define m_nearly_eq(x,y) (fabs(x-y)<=(fabs(x)+fabs(y))*DBL_EPSILON*2)
+
+#define M_EPSILON rb_float_new(2.2204460492503131e-16)
+#define M_MIN     rb_float_new(2.2250738585072014e-308)
+#define M_MAX     rb_float_new(1.7976931348623157e+308)

data/ext/numo/narray/numo/types/int16.h

@@ -9,3 +9,13 @@ typedef int16_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
 
 #include "int_macro.h"
+
+#ifndef INT16_MIN
+#define INT16_MIN (-32767-1)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+
+#define M_MIN  m_data_to_num(INT16_MIN)
+#define M_MAX  m_data_to_num(INT16_MAX)

data/ext/numo/narray/numo/types/int32.h

@@ -9,3 +9,13 @@ typedef int32_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%"PRId32,(int32_t)(x))
 
 #include "int_macro.h"
+
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647-1)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+
+#define M_MIN  m_data_to_num(INT32_MIN)
+#define M_MAX  m_data_to_num(INT32_MAX)

data/ext/numo/narray/numo/types/int64.h

@@ -9,3 +9,13 @@ typedef int64_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%"PRId64,(int64_t)(x))
 
 #include "int_macro.h"
+
+#ifndef INT64_MIN
+#define INT64_MIN (-9223372036854775807l-1)
+#endif
+#ifndef INT64_MAX
+#define INT64_MAX (9223372036854775807l)
+#endif
+
+#define M_MIN  m_data_to_num(INT64_MIN)
+#define M_MAX  m_data_to_num(INT64_MAX)

data/ext/numo/narray/numo/types/int8.h

@@ -9,3 +9,13 @@ typedef int8_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
 
 #include "int_macro.h"
+
+#ifndef INT8_MIN
+#define INT8_MIN (-127-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+
+#define M_MIN  INT2FIX(INT8_MIN)
+#define M_MAX  INT2FIX(INT8_MAX)

data/ext/numo/narray/numo/types/scomplex.h

@@ -10,6 +10,7 @@ static inline bool c_nearly_eq(dtype x, dtype y) {
     return c_abs(c_sub(x,y)) <= (c_abs(x)+c_abs(y))*FLT_EPSILON*2;
 }
 
+#ifdef SFMT_H
 /* generates a random number on [0,1)-real-interval */
 inline static dtype m_rand(dtype max)
 {
@@ -36,3 +37,8 @@ inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
     REAL(*a0) = x1*w * sigma + REAL(mu);
     IMAG(*a0) = x2*w * sigma + IMAG(mu);
 }
+#endif
+
+#define M_EPSILON rb_float_new(1.1920928955078125e-07)
+#define M_MIN     rb_float_new(1.1754943508222875e-38)
+#define M_MAX     rb_float_new(3.4028234663852886e+38)

data/ext/numo/narray/numo/types/sfloat.h

@@ -1,11 +1,12 @@
 typedef float dtype;
 typedef float rtype;
 #define cT  numo_cSFloat
-#define cRT cT
+#define cRT numo_cSFloat
 #define mTM numo_mSFloatMath
 
 #include "float_macro.h"
 
+#ifdef SFMT_H
 /* generates a random number on [0,1)-real-interval */
 inline static dtype m_rand(dtype max)
 {
@@ -29,9 +30,14 @@ inline static void m_rand_norm(dtype mu, dtype sigma, dtype *a0, dtype *a1)
     if (a0) {*a0 = x1*w * sigma + mu;}
     if (a1) {*a1 = x2*w * sigma + mu;}
 }
+#endif
 
 #define m_min_init numo_sfloat_new_dim0(0.0/0.0)
 #define m_max_init numo_sfloat_new_dim0(0.0/0.0)
 
 #define m_extract(x) rb_float_new(*(float*)x)
 #define m_nearly_eq(x,y) (fabs(x-y)<=(fabs(x)+fabs(y))*FLT_EPSILON*2)
+
+#define M_EPSILON rb_float_new(1.1920928955078125e-07)
+#define M_MIN     rb_float_new(1.1754943508222875e-38)
+#define M_MAX     rb_float_new(3.4028234663852886e+38)

data/ext/numo/narray/numo/types/uint16.h

@@ -9,3 +9,10 @@ typedef u_int16_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%u",(unsigned int)(x))
 
 #include "uint_macro.h"
+
+#ifndef UINT16_MAX
+#define UINT16_MAX (65535)
+#endif
+
+#define M_MIN  INT2FIX(0)
+#define M_MAX  m_data_to_num(UINT16_MAX)

data/ext/numo/narray/numo/types/uint32.h

@@ -9,3 +9,10 @@ typedef u_int32_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%"PRIu32,(u_int32_t)(x))
 
 #include "uint_macro.h"
+
+#ifndef UINT32_MAX
+#define UINT32_MAX (4294967295u)
+#endif
+
+#define M_MIN  INT2FIX(0)
+#define M_MAX  m_data_to_num(UINT32_MAX)

data/ext/numo/narray/numo/types/uint64.h

@@ -9,3 +9,10 @@ typedef u_int64_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%"PRIu64,(u_int64_t)(x))
 
 #include "uint_macro.h"
+
+#ifndef UINT64_MAX
+#define UINT64_MAX (18446744073709551615ul)
+#endif
+
+#define M_MIN  INT2FIX(0)
+#define M_MAX  m_data_to_num(UINT64_MAX)

data/ext/numo/narray/numo/types/uint8.h

@@ -9,3 +9,10 @@ typedef u_int8_t rtype;
 #define m_sprintf(s,x)   sprintf(s,"%u",(unsigned int)(x))
 
 #include "uint_macro.h"
+
+#ifndef UINT8_MAX
+#define UINT8_MAX (255)
+#endif
+
+#define M_MIN  INT2FIX(0)
+#define M_MAX  m_data_to_num(UINT8_MAX)

data/lib/numo/narray/extra.rb

@@ -32,20 +32,20 @@ module Numo
     end
 
     # Flip each row in the left/right direction.
-    # Same as a[true, (-1..0).step(-1), ...].
+    # Same as `a[true, (-1..0).step(-1), ...]`.
     def fliplr
       reverse(1)
     end
 
     # Flip each column in the up/down direction.
-    # Same as a[(-1..0).step(-1), ...].
+    # Same as `a[(-1..0).step(-1), ...]`.
     def flipud
       reverse(0)
     end
 
     # Multi-dimensional array indexing.
     # Same as [] for one-dimensional NArray.
-    # Similar to numpy's tuple indexing, i.e., a[[1,2,..],[3,4,..]]
+    # Similar to numpy's tuple indexing, i.e., `a[[1,2,..],[3,4,..]]`
     # (This method will be rewritten in C)
     # @return [Numo::NArray] one-dimensional view of self.
     # @example
@@ -162,7 +162,7 @@ module Numo
     def self.asarray(a)
       case a
       when NArray
-        a
+        (a.ndim == 0) ? a[:new] : a
       when Numeric,Range
         self[a]
       else
@@ -170,6 +170,44 @@ module Numo
       end
     end
 
+    # parse matrix like matlab, octave
+    # @example
+    #   a = Numo::DFloat.parse %[
+    #    2 -3 5
+    #    4 9 7
+    #    2 -1 6
+    #   ]
+    #   => Numo::DFloat#shape=[3,3]
+    #   [[2, -3, 5],
+    #    [4, 9, 7],
+    #    [2, -1, 6]]
+
+    def self.parse(str, split1d:/\s+/, split2d:/;?$|;/,
+                   split3d:/\s*\n(\s*\n)+/m)
+      a = []
+      str.split(split3d).each do |block|
+        b = []
+        #print "b"; p block
+        block.split(split2d).each do |line|
+          #p line
+          line.strip!
+          if !line.empty?
+            c = []
+            line.split(split1d).each do |item|
+              c << eval(item.strip) if !item.empty?
+            end
+            b << c if !c.empty?
+          end
+        end
+        a << b if !b.empty?
+      end
+      if a.size==1
+        self.cast(a[0])
+      else
+        self.cast(a)
+      end
+    end
+
     # Append values to the end of an narray.
     # @example
     #   a = Numo::DFloat[1, 2, 3]
@@ -919,15 +957,305 @@ module Numo
       return result
     end
 
+
+    # Upper triangular matrix.
+    # Return a copy with the elements below the k-th diagonal filled with zero.
+    def triu(k=0)
+      dup.triu!(k)
+    end
+
+    # Upper triangular matrix.
+    # Fill the self elements below the k-th diagonal with zero.
+    def triu!(k=0)
+      if ndim < 2
+        raise NArray::ShapeError, "must be >= 2-dimensional array"
+      end
+      if contiguous?
+        *shp,m,n = shape
+        idx = tril_indices(k-1)
+        reshape!(*shp,m*n)
+        self[false,idx] = 0
+        reshape!(*shp,m,n)
+      else
+        store(triu(k))
+      end
+    end
+
+    # Return the indices for the uppler-triangle on and above the k-th diagonal.
+    def triu_indices(k=0)
+      if ndim < 2
+        raise NArray::ShapeError, "must be >= 2-dimensional array"
+      end
+      m,n = shape[-2..-1]
+      NArray.triu_indices(m,n,k=0)
+    end
+
+    # Return the indices for the uppler-triangle on and above the k-th diagonal.
+    def self.triu_indices(m,n,k=0)
+      x = Numo::Int64.new(m,1).seq + k
+      y = Numo::Int64.new(1,n).seq
+      (x<=y).where
+    end
+
+    # Lower triangular matrix.
+    # Return a copy with the elements above the k-th diagonal filled with zero.
+    def tril(k=0)
+      dup.tril!(k)
+    end
+
+    # Lower triangular matrix.
+    # Fill the self elements above the k-th diagonal with zero.
+    def tril!(k=0)
+      if ndim < 2
+        raise NArray::ShapeError, "must be >= 2-dimensional array"
+      end
+      if contiguous?
+        idx = triu_indices(k+1)
+        *shp,m,n = shape
+        reshape!(*shp,m*n)
+        self[false,idx] = 0
+        reshape!(*shp,m,n)
+      else
+        store(tril(k))
+      end
+    end
+
+    # Return the indices for the lower-triangle on and below the k-th diagonal.
+    def tril_indices(k=0)
+      if ndim < 2
+        raise NArray::ShapeError, "must be >= 2-dimensional array"
+      end
+      m,n = shape[-2..-1]
+      NArray.tril_indices(m,n,k)
+    end
+
+    # Return the indices for the lower-triangle on and below the k-th diagonal.
+    def self.tril_indices(m,n,k=0)
+      x = Numo::Int64.new(m,1).seq + k
+      y = Numo::Int64.new(1,n).seq
+      (x>=y).where
+    end
+
+    # Return the k-th diagonal indices.
+    def diag_indices(k=0)
+      if ndim < 2
+        raise NArray::ShapeError, "must be >= 2-dimensional array"
+      end
+      m,n = shape[-2..-1]
+      NArray.diag_indices(m,n,k)
+    end
+
+    # Return the k-th diagonal indices.
+    def self.diag_indices(m,n,k=0)
+      x = Numo::Int64.new(m,1).seq + k
+      y = Numo::Int64.new(1,n).seq
+      (x.eq y).where
+    end
+
+    # Return a matrix whose diagonal is constructed by self along the last axis.
+    def diag(k=0)
+      *shp,n = shape
+      n += k.abs
+      a = self.class.zeros(*shp,n,n)
+      a.diagonal(k).store(self)
+      a
+    end
+
+    # Return the sum along diagonals of the array.
+    #
+    # If 2-D array, computes the summation along its diagonal with the
+    # given offset, i.e., sum of `a[i,i+offset]`.
+    # If more than 2-D array, the diagonal is determined from the axes
+    # specified by axis argument. The default is axis=[-2,-1].
+    # @param offset [Integer] (optional, default=0) diagonal offset
+    # @param axis [Array] (optional, default=[-2,-1]) diagonal axis
+    # @param nan [Bool] (optional, default=false) nan-aware algorithm, i.e., if true then it ignores nan.
+
+    def trace(offset=nil,axis=nil,nan:false)
+      diagonal(offset,axis).sum(nan:nan,axis:-1)
+    end
+
+
+    @@warn_slow_dot = false
+
+    # Dot product of two arrays.
+    # @param b [Numo::NArray]
+    # @return [Numo::NArray]  return dot product
+
+    def dot(b)
+      t = self.class::UPCAST[b.class]
+      if defined?(Linalg) && [SFloat,DFloat,SComplex,DComplex].include?(t)
+        Linalg.dot(self,b)
+      else
+        b = self.class.asarray(b)
+        case b.ndim
+        when 1
+          mulsum(b, axis:-1)
+        else
+          case ndim
+          when 0
+            b.mulsum(self, axis:-2)
+          when 1
+            self[true,:new].mulsum(b, axis:-2)
+          else
+            unless @@warn_slow_dot
+              nx = 200
+              ns = 200000
+              am,an = shape[-2..-1]
+              bm,bn = b.shape[-2..-1]
+              if am > nx && an > nx && bm > nx && bn > nx &&
+                  size > ns && b.size > ns
+                @@warn_slow_dot = true
+                warn "\nwarning: Built-in matrix dot is slow. Consider installing Numo::Linalg.\n\n"
+              end
+            end
+            self[false,:new].mulsum(b[false,:new,true,true], axis:-2)
+          end
+        end
+      end
+    end
+
+    # Inner product of two arrays.
+    # Same as `(a*b).sum(axis:-1)`.
+    # @param b [Numo::NArray]
+    # @param axis [Integer] applied axis
+    # @return [Numo::NArray]  return (a*b).sum(axis:axis)
+
+    def inner(b, axis:-1)
+      mulsum(b, axis:axis)
+    end
+
+    # Outer product of two arrays.
+    # Same as `self[false,:new] * b[false,:new,true]`.
+    #
+    # @param b [Numo::NArray]
+    # @param axis [Integer] applied axis (default=-1)
+    # @return [Numo::NArray]  return outer product
+    # @example
+    #   a = Numo::DFloat.ones(5)
+    #   => Numo::DFloat#shape=[5]
+    #   [1, 1, 1, 1, 1]
+    #   b = Numo::DFloat.linspace(-2,2,5)
+    #   => Numo::DFloat#shape=[5]
+    #   [-2, -1, 0, 1, 2]
+    #   a.outer(b)
+    #   => Numo::DFloat#shape=[5,5]
+    #   [[-2, -1, 0, 1, 2],
+    #    [-2, -1, 0, 1, 2],
+    #    [-2, -1, 0, 1, 2],
+    #    [-2, -1, 0, 1, 2],
+    #    [-2, -1, 0, 1, 2]]
+
+    def outer(b, axis:nil)
+      b = NArray.cast(b)
+      if axis.nil?
+        self[false,:new] * ((b.ndim==0) ? b : b[false,:new,true])
+      else
+        md,nd = [ndim,b.ndim].minmax
+        axis = check_axis(axis) - nd
+        if axis < -md
+          raise ArgumentError,"axis=#{axis} is out of range"
+        end
+        adim = [true]*ndim
+        adim[axis+ndim+1,0] = :new
+        bdim = [true]*b.ndim
+        bdim[axis+b.ndim,0] = :new
+        self[*adim] * b[*bdim]
+      end
+    end
+
+    # Kronecker product of two arrays.
+    #
+    #     kron(a,b)[k_0, k_1, ...] = a[i_0, i_1, ...] * b[j_0, j_1, ...]
+    #        where:  k_n = i_n * b.shape[n] + j_n
+    #
+    # @param b [Numo::NArray]
+    # @return [Numo::NArray]  return Kronecker product
+    # @example
+    #   Numo::DFloat[1,10,100].kron([5,6,7])
+    #   => Numo::DFloat#shape=[9]
+    #   [5, 6, 7, 50, 60, 70, 500, 600, 700]
+    #   Numo::DFloat[5,6,7].kron([1,10,100])
+    #   => Numo::DFloat#shape=[9]
+    #   [5, 50, 500, 6, 60, 600, 7, 70, 700]
+    #   Numo::DFloat.eye(2).kron(Numo::DFloat.ones(2,2))
+    #   => Numo::DFloat#shape=[4,4]
+    #   [[1, 1, 0, 0],
+    #    [1, 1, 0, 0],
+    #    [0, 0, 1, 1],
+    #    [0, 0, 1, 1]]
+
+    def kron(b)
+      b = NArray.cast(b)
+      nda = ndim
+      ndb = b.ndim
+      shpa = shape
+      shpb = b.shape
+      adim = [:new]*(2*[ndb-nda,0].max) + [true,:new]*nda
+      bdim = [:new]*(2*[nda-ndb,0].max) + [:new,true]*ndb
+      shpr = (-[nda,ndb].max..-1).map{|i| (shpa[i]||1) * (shpb[i]||1)}
+      (self[*adim] * b[*bdim]).reshape(*shpr)
+    end
+
+
+    # under construction
+    def cov(y=nil, ddof:1, fweights:nil, aweights:nil)
+      if y
+        m = NArray.vstack([self,y])
+      else
+        m = self
+      end
+      w = nil
+      if fweights
+        f = fweights
+        w = f
+      end
+      if aweights
+        a = aweights
+        w = w ? w*a : a
+      end
+      if w
+        w_sum = w.sum(axis:-1, keepdims:true)
+        if ddof == 0
+          fact = w_sum
+        elsif aweights.nil?
+          fact = w_sum - ddof
+        else
+          wa_sum = (w*a).sum(axis:-1, keepdims:true)
+          fact = w_sum - ddof * wa_sum / w_sum
+        end
+        if (fact <= 0).any?
+          raise StandardError,"Degrees of freedom <= 0 for slice"
+        end
+      else
+        fact = m.shape[-1] - ddof
+      end
+      if w
+        m -= (m*w).sum(axis:-1, keepdims:true) / w_sum
+        mw = m*w
+      else
+        m -= m.mean(axis:-1, keepdims:true)
+        mw = m
+      end
+      mt = (m.ndim < 2) ? m : m.swapaxes(-2,-1)
+      mw.dot(mt.conj) / fact
+    end
+
     private
+
+    # @!visibility private
     def check_axis(axis)
-      if axis < 0
-        axis += ndim
+      unless Integer===axis
+        raise ArgumentError,"axis=#{axis} must be Integer"
       end
-      if axis < 0 || axis >= ndim
-        raise ArgumentError,"invalid axis"
+      a = axis
+      if a < 0
+        a += ndim
+      end
+      if a < 0 || a >= ndim
+        raise ArgumentError,"axis=#{axis} is invalid"
       end
-      axis
+      a
     end
 
   end

data/numo-narray.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Numo::NArray - New NArray class library in Ruby/Numo.}
   spec.summary       = %q{alpha release of Numo::NArray - New NArray class library in Ruby/Numo (NUmerical MOdule)}
   spec.homepage      = "https://github.com/ruby-numo/narray"
-  spec.license       = "MIT"
+  spec.license       = "BSD-3-Clause"
   spec.required_ruby_version = '~> 2.1'
 
   spec.files         = `git ls-files Gemfile README.md Rakefile lib ext numo-narray.gemspec spec`.split($/)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-narray
 version: !ruby/object:Gem::Version
-  version: 0.9.0.6
+  version: 0.9.0.7
 platform: ruby
 authors:
 - Masahiro TANAKA
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-27 00:00:00.000000000 Z
+date: 2017-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -204,7 +204,6 @@ files:
 - ext/numo/narray/gen/tmpl_bit/where.c
 - ext/numo/narray/gen/tmpl_bit/where2.c
 - ext/numo/narray/index.c
-- ext/numo/narray/kwarg.c
 - ext/numo/narray/math.c
 - ext/numo/narray/narray.c
 - ext/numo/narray/ndloop.c
@@ -249,7 +248,7 @@ files:
 - spec/narray_spec.rb
 homepage: https://github.com/ruby-numo/narray
 licenses:
-- MIT
+- BSD-3-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []

data/ext/numo/narray/kwarg.c

@@ -1,74 +0,0 @@
-/*
-   kwarg.c : Process keyword arguments for Ruby
-
-   Copyright (c) 2001 Masahiro TANAKA
-*/
-#include <ruby.h>
-#include "numo/compat.h"
-
-/* void rb_scan_kw_args __((VALUE, ...)); */
-
-static VALUE
-kw_hash_i(i, tmp)
-     VALUE i, tmp;
-{
-    VALUE key;
-
-    key = RARRAY_AREF(i,0);
-    if (TYPE(key)==T_SYMBOL) {
-	key = rb_funcall(key, rb_intern("id2name"), 0);
-    } else
-	if (TYPE(key)!=T_STRING) {
-	    rb_raise(rb_eArgError, "keywords must be String or Symbol");
-	}
-
-    rb_hash_aset(tmp, key, RARRAY_AREF(i,1));
-    return Qnil;
-}
-
-#ifdef HAVE_STDARG_PROTOTYPES
-#include <stdarg.h>
-#define va_init_list(a,b) va_start(a,b)
-#else
-#include <varargs.h>
-#define va_init_list(a,b) va_start(a)
-#endif
-
-void
-#ifdef HAVE_STDARG_PROTOTYPES
-rb_scan_kw_args(VALUE hash, ...)
-#else
-rb_scan_kw_args(hash, va_alist)
-    VALUE hash;
-    va_dcl
-#endif
-{
-    va_list vargs;
-    va_init_list(vargs, hash);
-
-    char *key;
-    VALUE *var, val, str, tmp;
-
-    tmp = rb_hash_new();
-    if (TYPE(hash) == T_HASH)
-	rb_iterate(rb_each, hash, kw_hash_i, tmp);
-    else if (hash != Qnil)
-	rb_fatal("rb_san_kw_args: non-hash arg passed");
-
-    for (;;) {
-	key = va_arg(vargs, char*);
-	if (!key) break;
-	var = va_arg(vargs, VALUE*);
-	//printf("i=%d key=%x, val=%x\n",i,key,val);
-	str = rb_str_new2(key);
-	val = rb_funcall(tmp, rb_intern("delete"), 1, str);
-	if (var) *var = val;
-    }
-    va_end(vargs);
-
-    if (rb_funcall(tmp, rb_intern("empty?"), 0)==Qfalse) {
-	val = rb_funcall(tmp, rb_intern("keys"), 0);
-	val = rb_funcall(val, rb_intern("join"), 1, rb_str_new2(","));
-	rb_raise(rb_eArgError, "unknown keywords: %s",StringValueCStr(val));
-    }
-}