cumo 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ea033fff4a77a42e911f54418e264dd3467372c41ffebcfb693e45b3f5f6faf
-  data.tar.gz: 7cdc86588d27d4819aaba0b994ed178f9d028cc4441c557c1b403a9570b56b0e
+  metadata.gz: 0aea399ff1a36438f62f47a0a1c0350366971c34000343eb20376e8d3d448297
+  data.tar.gz: 8f8f8fab9df42cf544131dc38ac2a9ff9c2eda218a3be11eb2a887c26e86fac1
 SHA512:
-  metadata.gz: f2ed5c87fcee89596b0ed404169fe82ad514da4cdcb23b3e8b200415d2fe1092d450c88e8a7f109c7ff786b58ffe2a52b12485eb7d0e2844e28fcc18d2303c0c
-  data.tar.gz: 215bbcab440ff133bd13aa9e4f133cddb8da783003dccddfd8546e072adf49a6d68d93ecd9f97221aca4f09348eaf5b5657437f614d94e0c0fc15dbcf924ded9
+  metadata.gz: d57caea8974f8d7c8be8d62c0c5d52004bb414092e178459d29a5e5d3566999ce03899a5cdd82d5b3cdc0d4b690f4c1e9991cdeb40ec8a7eec5f6bd33157ec7b
+  data.tar.gz: 7cb0cd15e20c826806209ed91279694f41cc17f54aade1043ed3defd62fc9a9bdccadc0bc9345d1f802302399b915adc7fac1c2059bded270991644babce6d1a

data/3rd_party/mkmf-cu/lib/mkmf-cu/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "English"
 require "mkmf"
 require "open3"
 require_relative "nvcc"
@@ -28,8 +29,10 @@ module MakeMakefileCuda
     # private
 
     def run_command!(*args)
-      puts colorize(:green, args.join(' '))
-      exit system(*args)
+      command = args.join(' ')
+      puts colorize(:green, command)
+      system(command)
+      exit($CHILD_STATUS.exitstatus)
     end
 
     # TODO(sonots): Make it possible to configure "nvcc" and additional arguments

data/3rd_party/mkmf-cu/lib/mkmf-cu/nvcc.rb

@@ -114,7 +114,7 @@ module MakeMakefileCuda
       if opt_h["--mkmf-cu-ext"][0] == "c"
         " --compiler-bindir " + ENV.fetch("NVCC_CCBIN", RbConfig::CONFIG["CC"])
       elsif opt_h["--mkmf-cu-ext"][0] == "cxx"
-        " --compiler-bindir " + ENV.fetch("NVCC_CCBIN", RbConfig::CONFIG["CXX"])
+        " --compiler-bindir " + ENV.fetch("NVCC_CCBIN", RbConfig::CONFIG["CXX"]).split.first
       end
     end
 

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+# 0.5.4 (2026/05/30)
+
+Fixes:
+
+* Backport: Fix to use rb_funcallv_kw in Ruby 2.7 and later
+* Backport: define id_pow as "**" for all types except Bit
+* Backport: define id_minus as "-@" for RObject
+* Backport: duplicated id_eq and id_ne for RObject
+* Backport: follow the change of INIT_PTR_BIT_IDX
+* Backport: add test for empty bit array
+* Backport: fix NArray::Bit#count_true/false: empty array should return zero
+* Fix backport error
+* Backport: minor fixes
+* Backport: fix RObject#sum,prod
+* Backport: NArray#from_binary: allow zero dimension
+* Backport: Added test cases
+* Backport: fix NArray#store: drop automatic 'to_a' conversion
+* Backport: Numo::NArray.cast tries to convert to Array when it has to_a method
+* Backport: use rb_respond_to()
+* Backport: improve discrimination between int32/64
+* Backport: missing declaration of id_ge
+* Backport: support casting any object that responds to 'to_a'
+* Backport: fix the range of int32 as -2**31 .. 2**31-1
+* Backport: if int32_max is Bignum, it should be protected from GC
+* fix: handle compiler flags included in RbConfig::CONFIG properly (#157)
+* Backport: Added more percentile tests
+* Backport: Use File.write in cogen to ensure file is closed
+* Backport: Added percentile method
+* Backport: Use INT2FIX to define m_data_to_num for 8 or 16-bit Int.
+* Backport: raise error if compiler does not support  8 or 4-byte integer
+
 # 0.5.3 (2026/04/26)
 
 Fixes:

data/ext/cumo/include/cumo/narray.h

@@ -99,6 +99,8 @@ extern "C" {
 # ifndef PRIu64
 #  define PRIu64 "llu"
 # endif
+#else
+# error ---->> numo/narray requires 8-byte integer. <<----
 #endif
 
 #if   SIZEOF_LONG==4
@@ -139,6 +141,8 @@ extern "C" {
 # ifndef PRIu32
 #  define PRIu32 "u"
 # endif
+#else
+# error ---->> numo/narray requires 4-byte integer. <<----
 #endif
 
 #if SIZEOF_LONG > 4

data/ext/cumo/include/cumo/types/int16.h

@@ -4,8 +4,11 @@ typedef int16_t rtype;
 #define cRT cT
 
 #define m_num_to_data(x) ((dtype)NUM2INT(x))
-#define m_data_to_num(x) INT2NUM((int)(x))
-#define m_extract(x)     INT2NUM((int)*(dtype*)(x))
+#if SIZEOF_INT > 2
+#define m_data_to_num(x) INT2FIX(x)
+#else
+#define m_data_to_num(x) INT2NUM(x)
+#endif
 #define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
 
 #ifndef INT16_MIN

data/ext/cumo/include/cumo/types/int32.h

@@ -5,7 +5,6 @@ typedef int32_t rtype;
 
 #define m_num_to_data(x) ((dtype)NUM2INT32(x))
 #define m_data_to_num(x) INT322NUM((int32_t)(x))
-#define m_extract(x)     INT322NUM((int32_t)*(dtype*)(x))
 #define m_sprintf(s,x)   sprintf(s,"%"PRId32,(int32_t)(x))
 
 #ifndef INT32_MIN

data/ext/cumo/include/cumo/types/int64.h

@@ -5,7 +5,6 @@ typedef int64_t rtype;
 
 #define m_num_to_data(x) ((dtype)NUM2INT64(x))
 #define m_data_to_num(x) INT642NUM((int64_t)(x))
-#define m_extract(x)     INT642NUM((int64_t)*(dtype*)(x))
 #define m_sprintf(s,x)   sprintf(s,"%"PRId64,(int64_t)(x))
 
 #ifndef INT64_MIN

data/ext/cumo/include/cumo/types/int8.h

@@ -4,8 +4,7 @@ typedef int8_t rtype;
 #define cRT cT
 
 #define m_num_to_data(x) ((dtype)NUM2INT(x))
-#define m_data_to_num(x) INT2NUM((int)(x))
-#define m_extract(x)     INT2NUM((int)*(dtype*)(x))
+#define m_data_to_num(x) INT2FIX(x)
 #define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
 
 #ifndef INT8_MIN

data/ext/cumo/include/cumo/types/uint16.h

@@ -4,8 +4,11 @@ typedef u_int16_t rtype;
 #define cRT cT
 
 #define m_num_to_data(x) ((dtype)NUM2UINT(x))
-#define m_data_to_num(x) UINT2NUM((unsigned int)(x))
-#define m_extract(x)     UINT2NUM((unsigned int)*(dtype*)(x))
+#if SIZEOF_INT > 2
+#define m_data_to_num(x) INT2FIX(x)
+#else
+#define m_data_to_num(x) UINT2NUM(x)
+#endif
 #define m_sprintf(s,x)   sprintf(s,"%u",(unsigned int)(x))
 
 #ifndef UINT16_MIN

data/ext/cumo/include/cumo/types/uint32.h

@@ -5,7 +5,6 @@ typedef u_int32_t rtype;
 
 #define m_num_to_data(x) ((dtype)NUM2UINT32(x))
 #define m_data_to_num(x) UINT322NUM((u_int32_t)(x))
-#define m_extract(x)     UINT322NUM((u_int32_t)*(dtype*)(x))
 #define m_sprintf(s,x)   sprintf(s,"%"PRIu32,(u_int32_t)(x))
 
 #ifndef UINT32_MIN

data/ext/cumo/include/cumo/types/uint64.h

@@ -5,7 +5,6 @@ typedef u_int64_t rtype;
 
 #define m_num_to_data(x) ((dtype)NUM2UINT64(x))
 #define m_data_to_num(x) UINT642NUM((u_int64_t)(x))
-#define m_extract(x)     UINT642NUM((u_int64_t)*(dtype*)(x))
 #define m_sprintf(s,x)   sprintf(s,"%"PRIu64,(u_int64_t)(x))
 
 #ifndef UINT64_MIN

data/ext/cumo/include/cumo/types/uint8.h

@@ -4,8 +4,7 @@ typedef u_int8_t rtype;
 #define cRT cT
 
 #define m_num_to_data(x) ((dtype)NUM2UINT(x))
-#define m_data_to_num(x) UINT2NUM((unsigned int)(x))
-#define m_extract(x)     UINT2NUM((unsigned int)*(dtype*)(x))
+#define m_data_to_num(x) INT2FIX(x)
 #define m_sprintf(s,x)   sprintf(s,"%u",(unsigned int)(x))
 
 #ifndef UINT8_MIN

data/ext/cumo/include/cumo/types/xint_macro.h

@@ -1,6 +1,8 @@
 #define m_zero 0
 #define m_one  1
 
+#define m_extract(x)    m_data_to_num(*(dtype*)(x))
+
 /* Handle negative values consistently across platforms for unsigned integer types */
 #define m_from_double(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))
 #define m_from_real(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))

data/ext/cumo/include/cumo.h

@@ -10,7 +10,7 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.5.3"
+#define CUMO_VERSION "0.5.4"
 #define CUMO_VERSION_CODE 51
 
 bool cumo_compatible_mode_enabled_p();

data/ext/cumo/narray/array.c

@@ -25,16 +25,16 @@ static ID cumo_id_step;
 static ID cumo_id_abs;
 static ID cumo_id_cast;
 static ID cumo_id_le;
+#if SIZEOF_LONG <= 4
+static ID cumo_id_ge;
+#endif
 static ID cumo_id_Complex;
-
+static VALUE cumo_int32_max = Qnil;
+static VALUE cumo_int32_min = Qnil;
 
 static VALUE
  cumo_na_object_type(int type, VALUE v)
 {
-    static VALUE int32_max = Qnil;
-    if (NIL_P(int32_max))
-        int32_max = ULONG2NUM(2147483647);
-
     switch(TYPE(v)) {
 
     case T_TRUE:
@@ -43,15 +43,15 @@ static VALUE
             return CUMO_NA_BIT;
         return type;
 
-#if SIZEOF_LONG == 4
+#if SIZEOF_LONG <= 4
     case T_FIXNUM:
         if (type<CUMO_NA_INT32)
             return CUMO_NA_INT32;
         return type;
     case T_BIGNUM:
         if (type<CUMO_NA_INT64) {
-            v = rb_funcall(v,cumo_id_abs,0);
-            if (RTEST(rb_funcall(v,cumo_id_le,1,int32_max))) {
+            if (RTEST(rb_funcall(v,cumo_id_le,1,int32_max)) &&
+                RTEST(rb_funcall(v,cumo_id_ge,1,int32_min))) {
                 if (type<CUMO_NA_INT32)
                     return CUMO_NA_INT32;
             } else {
@@ -59,13 +59,12 @@ static VALUE
             }
         }
         return type;
-
-#elif SIZEOF_LONG == 8
+#else
     case T_FIXNUM:
         if (type<CUMO_NA_INT64) {
             long x = NUM2LONG(v);
             if (x<0) x=-x;
-            if (x<=2147483647) {
+            if (x<=2147483647L && x>=-2147483648L) {
                 if (type<CUMO_NA_INT32)
                     return CUMO_NA_INT32;
             } else {
@@ -77,19 +76,6 @@ static VALUE
         if (type<CUMO_NA_INT64)
             return CUMO_NA_INT64;
         return type;
-#else
-    case T_FIXNUM:
-    case T_BIGNUM:
-        if (type<CUMO_NA_INT64) {
-            v = rb_funcall(v,cumo_id_abs,0);
-            if (RTEST(rb_funcall(v,cumo_id_le,1,int32_max))) {
-                if (type<CUMO_NA_INT32)
-                    return CUMO_NA_INT32;
-            } else {
-                return CUMO_NA_INT64;
-            }
-        }
-        return type;
 #endif
 
     case T_FLOAT:
@@ -642,5 +628,13 @@ Init_cumo_na_array(void)
     cumo_id_cast    = rb_intern("cast");
     cumo_id_abs     = rb_intern("abs");
     cumo_id_le      = rb_intern("<=");
+#if SIZEOF_LONG <= 4
+    cumo_id_ge      = rb_intern(">=");
+#endif
     cumo_id_Complex = rb_intern("Complex");
+
+    rb_global_variable(&cumo_int32_max);
+    cumo_int32_max = INT2NUM(2147483647);
+    rb_global_variable(&cumo_int32_min);
+    cumo_int32_min = INT2NUM(-2147483648);
 }

data/ext/cumo/narray/data.c

@@ -5,9 +5,7 @@
 #include "cumo/narray.h"
 #include "cumo/template.h"
 
-static VALUE cumo_sym_mulsum;
 static ID cumo_id_mulsum;
-static ID cumo_id_respond_to_p;
 static ID cumo_id_store;
 static ID cumo_id_swap_byte;
 
@@ -932,12 +930,10 @@ cumo_na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
 static VALUE
 cumo_na_dot(VALUE self, VALUE other)
 {
-    VALUE test;
     volatile VALUE a1=self, a2=other;
     cumo_narray_t *na1, *na2;
 
-    test = rb_funcall(a1, cumo_id_respond_to_p, 1, cumo_sym_mulsum);
-    if (!RTEST(test)) {
+    if (!rb_respond_to(a1, cumo_id_mulsum)) {
         rb_raise(rb_eNoMethodError,"requires mulsum method for dot method");
     }
     CumoGetNArray(a1,na1);
@@ -994,8 +990,6 @@ Init_cumo_na_data(void)
     //rb_define_method(cNArray, "dot", cumo_na_dot, 1);
 
     cumo_id_mulsum       = rb_intern("mulsum");
-    cumo_sym_mulsum      = ID2SYM(cumo_id_mulsum);
-    cumo_id_respond_to_p = rb_intern("respond_to?");
     cumo_id_store        = rb_intern("store");
     cumo_id_swap_byte    = rb_intern("swap_byte");
 }

data/ext/cumo/narray/gen/cogen.rb

@@ -54,7 +54,7 @@ code = DefLib.new do
 end.result
 
 if $output
-  open($output, "w").write(code)
+  File.write($output, code)
 else
   $stdout.write(code)
 end

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

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 def_id "cast"
-def_id "eq"
-def_id "ne"
-def_id "pow"
 def_id "mulsum"
+def_id "to_a"
 if is_complex
   def_id "real"
   def_id "imag"
@@ -34,7 +32,6 @@ if is_object
   def_id "bit_xor"
   def_id "bit_not"
   def_id "abs"
-  def_id "minus"
   def_id "reciprocal"
   def_id "square"
   def_id "floor"
@@ -44,6 +41,7 @@ if is_object
   def_id "nan?"
   def_id "infinite?"
   def_id "finite?"
+  def_id "-@", "minus"
   def_id "==", "eq"
   def_id "!=", "ne"
   def_id ">" , "gt"
@@ -51,6 +49,9 @@ if is_object
   def_id "<" , "lt"
   def_id "<=", "le"
   def_id "<=>", "ufo"
+else
+  def_id "eq"
+  def_id "ne"
 end
 if (is_float || is_complex) && !is_object
   def_id "gemm"
@@ -203,7 +204,12 @@ if !is_complex
   binary2 "divmod"
 end
 
-pow
+
+if !is_bit
+  pow
+  def_id "**","pow"
+  def_alias "pow","**"
+end
 
 unary "minus", "-@"
 unary "reciprocal"
@@ -297,7 +303,7 @@ if is_float
   cond_unary "isfinite"
 end
 
-if is_int
+if is_int && !is_object
   if is_unsigned
     accum "sum", "u_int64_t", "cumo_cUInt64"
     accum "prod", "u_int64_t", "cumo_cUInt64"

data/ext/cumo/narray/gen/tmpl/accum_binary.c

@@ -115,7 +115,11 @@ static VALUE
         return <%=c_func%>_self(argc, argv, self);
     } else {
         v = rb_funcall(klass, cumo_id_cast, 1, self);
+        //<% if Gem::Version.create(RUBY_VERSION) < Gem::Version.create('2.7.0') %>
         return rb_funcall2(v, rb_intern("<%=name%>"), argc, argv);
+        //<% else %>
+        return rb_funcallv_kw(v, rb_intern("<%=name%>"), argc, argv, RB_PASS_CALLED_KEYWORDS);
+        //<% end %>
     }
     //<% end %>
 }

data/ext/cumo/narray/gen/tmpl/cast.c

@@ -35,6 +35,13 @@ static VALUE
         }
         return v;
     }
+    if (rb_respond_to(obj,cumo_id_to_a)) {
+        obj = rb_funcall(obj,cumo_id_to_a,0);
+        if (TYPE(obj)!=T_ARRAY) {
+            rb_raise(rb_eTypeError, "`to_a' did not return Array");
+        }
+        return <%=find_tmpl("cast_array").c_func%>(obj);
+    }
     <% if is_object %>
     return robject_new_dim0(obj);
     <% else %>

data/ext/cumo/narray/gen/tmpl_bit/binary.c

@@ -25,6 +25,12 @@ static void
             CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, x);
         }
     } else {
+        a1 += p1/CUMO_NB;
+        p1 %= CUMO_NB;
+        a2 += p2/CUMO_NB;
+        p2 %= CUMO_NB;
+        a3 += p3/CUMO_NB;
+        p3 %= CUMO_NB;
         o1 =  p1-p3;
         o2 =  p2-p3;
         l1 =  CUMO_NB+o1;

data/ext/cumo/narray/gen/tmpl_bit/bit_count_cpu.c

@@ -78,10 +78,16 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE v, reduce;
+    cumo_narray_t *na;
+
     cumo_ndfunc_arg_in_t ain[3] = {{cT,0},{cumo_sym_reduce,0},{cumo_sym_init,0}};
     cumo_ndfunc_arg_out_t aout[1] = {{cumo_cInt64,0}};
     cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP_NIP, 3, 1, ain, aout };
 
+    CumoGetNArray(self,na);
+    if (CUMO_NA_SIZE(na)==0) {
+        return INT2FIX(0);
+    }
     reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
     v = cumo_na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
     return rb_funcall(v,rb_intern("extract_cpu"),0);

data/ext/cumo/narray/gen/tmpl_bit/bit_reduce.c

@@ -118,7 +118,7 @@ static VALUE
 
     CumoGetNArray(self,na);
     if (CUMO_NA_SIZE(na)==0) {
-        return INT2FIX(0);
+        return Qfalse;
     }
     reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
     v = cumo_na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));

data/ext/cumo/narray/gen/tmpl_bit/store_bit.c

@@ -1,8 +1,9 @@
+#include <stdio.h>
 static void
 <%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  n;
-    size_t  p1, p3;
+    ssize_t p1, p3;
     ssize_t s1, s3;
     size_t *idx1, *idx3;
     int     o1, l1, r1, len;
@@ -22,6 +23,10 @@ static void
             CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, x);
         }
     } else {
+        a1 += p1/CUMO_NB;
+        p1 %= CUMO_NB;
+        a3 += p3/CUMO_NB;
+        p3 %= CUMO_NB;
         o1 =  p1-p3;
         l1 =  CUMO_NB+o1;
         r1 =  CUMO_NB-o1;
@@ -30,7 +35,7 @@ static void
             if ((int)n<len) len=n;
             if (o1>=0) x = *a1>>o1;
             else       x = *a1<<-o1;
-            if (p1+len>CUMO_NB)  x |= *(a1+1)<<r1;
+            if (p1+len>(ssize_t)CUMO_NB)  x |= *(a1+1)<<r1;
             a1++;
             *a3 = (x & (CUMO_SLB(len)<<p3)) | (*a3 & ~(CUMO_SLB(len)<<p3));
             a3++;

data/ext/cumo/narray/gen/tmpl_bit/unary.c

@@ -24,6 +24,10 @@ static void
             CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, y);
         }
     } else {
+        a1 += p1/CUMO_NB;
+        p1 %= CUMO_NB;
+        a3 += p3/CUMO_NB;
+        p3 %= CUMO_NB;
         o1 =  p1-p3;
         l1 =  CUMO_NB+o1;
         r1 =  CUMO_NB-o1;

data/ext/cumo/narray/narray.c

@@ -1346,8 +1346,8 @@ cumo_na_s_from_binary(int argc, VALUE *argv, VALUE type)
             break;
         case T_ARRAY:
             nd = RARRAY_LEN(vshape);
-            if (nd == 0 || nd > CUMO_NA_MAX_DIMENSION) {
-                rb_raise(cumo_na_eDimensionError,"too long or empty shape (%d)", nd);
+            if (nd > CUMO_NA_MAX_DIMENSION) {
+              rb_raise(cumo_na_eDimensionError,"shape exceeds max dimension");
             }
             shape = ALLOCA_N(size_t,nd);
             len = 1;

data/ext/cumo/narray/ndloop.c

@@ -164,7 +164,7 @@ print_ndloop(cumo_na_md_loop_t *lp) {
             for (i=0; i<lp->user.ndim; i++) {
                 printf(" &user.args[%d].iter[%d] = 0x%"SZF"x\n", j,i, (size_t)&lp->user.args[j].iter[i]);
                 printf("  user.args[%d].iter[%d].pos = %"SZF"u\n", j,i, lp->user.args[j].iter[i].pos);
-                printf("  user.args[%d].iter[%d].step = %"SZF"u\n", j,i, lp->user.args[j].iter[i].step);
+                printf("  user.args[%d].iter[%d].step = %"SZF"d\n", j,i, lp->user.args[j].iter[i].step);
                 printf("  user.args[%d].iter[%d].idx = 0x%"SZF"x (cuda:%d)\n", j,i, (size_t)lp->user.args[j].iter[i].idx, cumo_cuda_runtime_is_device_memory(lp->user.args[j].iter[i].idx));
                 // printf("  user.args[%d].iter[%d].idx = 0x%"SZF"x\n", j,i, (size_t)lp->user.args[j].iter[i].idx);
             }
@@ -175,7 +175,7 @@ print_ndloop(cumo_na_md_loop_t *lp) {
         for (i=0; i<=nd; i++) {
             printf(" &xargs[%d].iter[%d] = 0x%"SZF"x\n", j,i, (size_t)&LITER(lp,i,j));
             printf("  xargs[%d].iter[%d].pos = %"SZF"u\n", j,i, LITER(lp,i,j).pos);
-            printf("  xargs[%d].iter[%d].step = %"SZF"u\n", j,i, LITER(lp,i,j).step);
+            printf("  xargs[%d].iter[%d].step = %"SZF"d\n", j,i, LITER(lp,i,j).step);
             printf("  xargs[%d].iter[%d].idx = 0x%"SZF"x (cuda:%d)\n", j,i, (size_t)LITER(lp,i,j).idx, cumo_cuda_runtime_is_device_memory(LITER(lp,i,j).idx));
             // printf("  xargs[%d].iter[%d].idx = 0x%"SZF"x\n", j,i, (size_t)LITER(lp,i,j).idx);
         }

data/lib/cumo/narray/extra.rb

@@ -108,7 +108,19 @@ module Cumo
 
     # Convert the argument to an narray if not an narray.
     def self.cast(a)
-      a.kind_of?(NArray) ? a : NArray.array_type(a).cast(a)
+      case a
+      when NArray
+        a
+      when Array,Numeric
+        NArray.array_type(a).cast(a)
+      else
+        if a.respond_to?(:to_a)
+          a = a.to_a
+          NArray.array_type(a).cast(a)
+        else
+          raise TypeError,"invalid type for NArray"
+        end
+      end
     end
 
     def self.asarray(a)
@@ -1186,6 +1198,35 @@ module Cumo
       end
     end
 
+    # Percentile
+    #
+    # @param q [Numo::NArray]
+    # @param axis [Integer] applied axis
+    # @return [Numo::NArray]  return percentile
+    def percentile(q, axis: nil)
+      raise ArgumentError, "q is out of range" if q < 0 || q > 100
+
+      x = self
+      unless axis
+        axis = 0
+        x = x.flatten
+      end
+
+      sorted = x.sort(axis: axis)
+      x = q / 100.0 * (sorted.shape[axis] - 1)
+      r = x % 1
+      i = x.floor
+      refs = [true] * sorted.ndim
+      refs[axis] = i
+      if i == sorted.shape[axis] - 1
+        sorted[*refs]
+      else
+        refs_upper = refs.dup
+        refs_upper[axis] = i + 1
+        sorted[*refs] + r * (sorted[*refs_upper] - sorted[*refs])
+      end
+    end
+
     # Kronecker product of two arrays.
     #
     #     kron(a,b)[k_0, k_1, ...] = a[i_0, i_1, ...] * b[j_0, j_1, ...]

data/test/bit_test.rb

@@ -139,6 +139,37 @@ class BitTest < Test::Unit::TestCase
     end
   end
 
+  procs = [
+    [proc{|tp,a| tp[*a] },""],
+  ]
+  procs.each do |init, ref|
+
+    test "#{dtype},[]#{ref}" do
+      src = []
+      n = src.size
+      a = init.call(dtype, src)
+
+      assert { a == src }
+      assert { (a & 0) == [0] * n }
+      assert { (a & 1) == src }
+      assert { (a | 0) == src }
+      assert { (a | 1) == [1] * n }
+      assert { (a ^ 0) == src.map {|x| x ^ 0 } }
+      assert { (a ^ 1) == src.map {|x| x ^ 1 } }
+      assert { ~a == src.map {|x| 1 - x } }
+
+      assert { a.count_true == 0 }
+      assert { a.count_false == 0 }
+      assert { a.where == [] }
+      assert { a.where2 == [[], []] }
+      assert { a.mask(Cumo::DFloat[]) == [] }
+      assert { !a.all? }
+      assert { !a.any? }
+      assert { a.none? }
+    end
+
+  end
+
   test "store to view" do
     n = 14
     x = Cumo::Bit.zeros(n + 2, n + 2, 3)
@@ -154,4 +185,10 @@ class BitTest < Test::Unit::TestCase
     assert { (~y[1..-2, 1..-2, 0]).where.size == 0 }
     assert { y[true, true, 1].where.size == 0 }
   end
+
+  test "assign nil" do
+    x = Cumo::RObject.cast([1, 2, 3])
+    x[Cumo::Bit.cast([0, 1, 0])] = nil
+    assert { x.to_a == [1, nil, 3] }
+  end
 end

data/test/narray_test.rb

@@ -351,6 +351,18 @@ class NArrayTest < Test::Unit::TestCase
           assert { (a.eq 3) == [[0, 0, 1], [0, 0, 0]] }
           assert { a.sort == src }
           assert { a.sort_index == [[0, 1, 2], [3, 4, 5]] }
+          assert { a.percentile(0) == 1.0 }
+          assert { a.percentile(50) == 4.0 }
+          assert { a.percentile(90) == 9.0 }
+          assert { a.percentile(100) == 11.0 }
+          assert { a.percentile(0, axis: 0) == [1, 2, 3] }
+          assert { a.percentile(50, axis: 0) == [3, 4.5, 7] }
+          assert { a.percentile(90, axis: 0) == [4.6, 6.5, 10.2] }
+          assert { a.percentile(100, axis: 0) == [5, 7, 11] }
+          assert { a.percentile(0, axis: 1) == [1, 5] }
+          assert { a.percentile(50, axis: 1) == [2, 7] }
+          assert { a.percentile(90, axis: 1) == [2.8, 10.2] }
+          assert { a.percentile(100, axis: 1) == [3, 11] }
         end
         assert { a.dup.fill(12) == [[12] * 3] * 2 }
         assert { (a + 1) == [[2, 3, 4], [6, 8, 12]] }
@@ -796,6 +808,11 @@ class NArrayTest < Test::Unit::TestCase
     end
   end
 
+  test "cast any object that responds to to_a" do
+    object = Struct.new(:to_a).new([1, 2, 3])
+    assert { Cumo::NArray.cast(object) == [1, 2, 3] }
+  end
+
   test "Cumo::DFloat.cast(Cumo::RObject[1, nil, 3])" do
     assert_equal(Cumo::DFloat[1, Float::NAN, 3].format_to_a,
                  Cumo::DFloat.cast(Cumo::RObject[1, nil, 3]).format_to_a)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Naotoshi Seo
@@ -331,7 +331,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Cumo is CUDA aware numerical library whose interface is highly compatible
   with Ruby Numo