cumo 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ea033fff4a77a42e911f54418e264dd3467372c41ffebcfb693e45b3f5f6faf
-  data.tar.gz: 7cdc86588d27d4819aaba0b994ed178f9d028cc4441c557c1b403a9570b56b0e
+  metadata.gz: 96a38fa0ad4be223020cef21720e30e9a32fcd2901798279293924df8bfd0f92
+  data.tar.gz: c826e49bea46001d6764c7d0f8ad124e5b6072543eb97a07990a26453dd71bf7
 SHA512:
-  metadata.gz: f2ed5c87fcee89596b0ed404169fe82ad514da4cdcb23b3e8b200415d2fe1092d450c88e8a7f109c7ff786b58ffe2a52b12485eb7d0e2844e28fcc18d2303c0c
-  data.tar.gz: 215bbcab440ff133bd13aa9e4f133cddb8da783003dccddfd8546e072adf49a6d68d93ecd9f97221aca4f09348eaf5b5657437f614d94e0c0fc15dbcf924ded9
+  metadata.gz: 1dba1ea3cb5a9c93044d222a9d03c975809c5b03d7925702aa3357a0244752d532cb9421b0632e71808944685c3ca44e7a0fc6032ca8c39d8083c279596dce61
+  data.tar.gz: 81c933a8f07f862b22a0c6be5e397000d4ea9476139203353907ba7de21a7aae418264fa8425b197d6302861a2788d262af2d2ecd2e34100900d2293706439f4

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,42 @@
+# 0.5.5 (2026/07/11)
+
+Fixes:
+
+* Backport: rename method: min_arg, max_arg => argmin, argmax
+* Backport: fix NArray#concatenate: avoid exception when concatenating empty arrays
+* Backport: fix boolean indexing in each axis
+
+# 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/reduce_kernel.h

@@ -86,6 +86,67 @@ __global__ static void reduction_kernel(cumo_na_reduction_arg_t arg, int out_blo
     }
 }
 
+// Variant of reduction_kernel for arg-reductions (argmax/argmin).
+//
+// Unlike reduction_kernel, which passes the flat 1-d index of an input element
+// (i.e. index of input elements, same as (min|max)_index), this passes the
+// index along the reduction axis (i_reduce) to the reduction impl. This matches
+// the spec of arg(min|max) which returns indices along the axis.
+template <typename TypeIn, typename TypeOut, typename ReductionImpl>
+__global__ static void reduction_arg_kernel(cumo_na_reduction_arg_t arg, int out_block_size, int reduce_block_size, ReductionImpl impl) {
+    cumo_na_iarray_t& in_iarray = arg.in;
+    cumo_na_iarray_t& out_iarray = arg.out;
+    cumo_na_indexer_t& in_indexer = arg.in_indexer;
+    cumo_na_indexer_t& out_indexer = arg.out_indexer;
+
+    using TypeReduce = decltype(impl.Identity(0));
+
+    extern __shared__ __align__(8) char sdata_raw[];
+    TypeReduce* sdata = reinterpret_cast<TypeReduce*>(sdata_raw);
+    unsigned int tid = threadIdx.x;
+
+    int64_t reduce_indexer_total_size = in_indexer.total_size / out_indexer.total_size;
+    int64_t reduce_offset = tid / out_block_size; // # of cols == # of elems
+
+    int64_t out_offset = tid % out_block_size; // # of rows
+    int64_t out_base = blockIdx.x * out_block_size; // # of rows
+    int64_t out_stride = gridDim.x * out_block_size; // # of rows
+
+    for (int64_t i_out = out_base + out_offset; i_out < out_indexer.total_size; i_out += out_stride) {
+        cumo_na_indexer_set_dim(&out_indexer, i_out);
+        int64_t i_in = i_out * reduce_indexer_total_size + reduce_offset;
+
+        // Note that arg(min|max) returns the index along the reduction axis.
+        TypeReduce accum = impl.Identity(reduce_offset);
+
+        for (int64_t i_reduce = reduce_offset; i_reduce < reduce_indexer_total_size; i_reduce += reduce_block_size, i_in += reduce_block_size) {
+            cumo_na_indexer_set_dim(&in_indexer, i_in);
+            TypeIn* in_ptr = reinterpret_cast<TypeIn*>(cumo_na_iarray_at_dim(&in_iarray, &in_indexer));
+            impl.Reduce(impl.MapIn(*in_ptr, i_reduce), accum);
+        }
+
+        if (out_block_size <= max_block_size / 2) {
+            sdata[tid] = accum;
+            __syncthreads();
+            // NOTE: Compiler optimizes to unroll this loop
+            for (int stride = max_block_size / 2; stride > 0; stride >>= 1) {
+                if (out_block_size <= stride) {
+                    if (tid < stride) {
+                        impl.Reduce(sdata[tid + stride], sdata[tid]);
+                    }
+                    __syncthreads();
+                }
+            }
+            accum = sdata[tid];
+            __syncthreads();
+        }
+        if (reduce_offset == 0 && i_out < out_indexer.total_size) {
+            TypeOut* out_ptr = reinterpret_cast<TypeOut*>(cumo_na_iarray_at_dim(&out_iarray, &out_indexer));
+            *out_ptr = impl.MapOut(accum);
+        }
+    }
+}
+
 }  // cumo_detail
 
 // TODO(sonots): Optimize indexer by squashing (or reducing) dimensions
@@ -110,4 +171,27 @@ void cumo_reduce(cumo_na_reduction_arg_t arg, ReductionImpl&& impl) {
     cumo_detail::reduction_kernel<TypeIn,TypeOut,ReductionImpl><<<grid_size, block_size, shared_mem_size>>>(arg, out_block_size, reduce_block_size, impl);
 }
 
+// Variant of cumo_reduce for arg-reductions (argmax/argmin), which returns
+// indices along the reduction axis. See reduction_arg_kernel above.
+template <typename TypeIn, typename TypeOut, typename ReductionImpl>
+void cumo_reduce_arg(cumo_na_reduction_arg_t arg, ReductionImpl&& impl) {
+    cumo_na_indexer_t& in_indexer = arg.in_indexer;
+    cumo_na_indexer_t& out_indexer = arg.out_indexer;
+
+    if (out_indexer.total_size == 0) {
+        return;
+    }
+
+    int64_t reduce_total_size_pow2 = cumo_detail::round_up_to_power_of_2(std::max(size_t{1}, in_indexer.total_size / out_indexer.total_size));
+    int64_t reduce_block_size = std::min(cumo_detail::max_block_size, reduce_total_size_pow2);
+    int64_t out_block_size = cumo_detail::max_block_size / reduce_block_size;
+    int64_t out_block_num = (out_indexer.total_size + out_block_size - 1) / out_block_size;
+
+    int64_t block_size = cumo_detail::max_block_size;
+    int64_t grid_size = std::min(cumo_detail::max_grid_size, out_block_num);
+    int64_t shared_mem_size = sizeof(decltype(impl.Identity(0))) * block_size;
+
+    cumo_detail::reduction_arg_kernel<TypeIn,TypeOut,ReductionImpl><<<grid_size, block_size, shared_mem_size>>>(arg, out_block_size, reduce_block_size, impl);
+}
+
 #endif // CUMO_REDUCE_KERNEL_H

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.5"
 #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/narray_def.rb

@@ -63,6 +63,10 @@ module NArrayMethod
     def_method(meth, "accum_index")
   end
 
+  def accum_arg(meth)
+    def_method(meth, "accum_arg")
+  end
+
   def cum(meth, cmacro)
     def_method(meth, "cum", cmacro:cmacro)
   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"
@@ -327,6 +333,8 @@ if is_comparable
   accum "ptp", "dtype", "cT"
   accum_index "max_index"
   accum_index "min_index"
+  accum_arg   "argmax"
+  accum_arg   "argmin"
   def_method "minmax"
   def_module_function "maximum", "ewcomp", n_arg:2
   def_module_function "minimum", "ewcomp", n_arg:2

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

@@ -0,0 +1,120 @@
+<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+<%   [64,32].each do |i| %>
+<% unless type_name == 'robject' %>
+void cumo_<%=type_name%>_<%=name%>_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg);
+<% end %>
+
+#define idx_t int<%=i%>_t
+static void
+<%=c_iter%>_arg<%=i%><%=nan%>(cumo_na_loop_t *const lp)
+{
+    // TODO(sonots): Support nan in CUDA
+    <% if type_name == 'robject' || nan == '_nan' %>
+    {
+        size_t   n, idx;
+        char    *d_ptr, *o_ptr;
+        ssize_t  d_step;
+
+        CUMO_INIT_COUNTER(lp, n);
+        CUMO_INIT_PTR(lp, 0, d_ptr, d_step);
+        o_ptr = CUMO_NDL_PTR(lp,1);
+
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        idx = f_<%=name[3..5]%>_index<%=nan%>(n,d_ptr,d_step);
+        *(idx_t*)o_ptr = (idx_t)idx;
+    }
+    <% else %>
+    {
+        cumo_na_reduction_arg_t arg = cumo_na_make_reduction_arg(lp);
+        cumo_<%=type_name%>_<%=name%>_int<%=i%>_kernel_launch(&arg);
+    }
+    <% end %>
+}
+#undef idx_t
+<% end;end %>
+
+/*
+  <%=name%>. Returns an index of the <%=name[3..5]%>imum value along the axis. See also `<%=name[3..5]%>_index`.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Finds <%=name[3..5]%>imum values along the axis and returns indices along the axis.
+  @return [Integer,Cumo::Int] returns result indices.
+  @example
+      Cumo::NArray[3,4,1,2].<%=name%> => <% if name == 'argmin' %>2<% else %>1<% end %>
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    <% if type_name == 'robject' %>
+    {
+        cumo_narray_t *na;
+        VALUE reduce;
+        cumo_ndfunc_arg_in_t ain[2] = {{Qnil,0},{cumo_sym_reduce,0}};
+        cumo_ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        cumo_ndfunc_t ndf = {0, CUMO_STRIDE_LOOP_NIP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_EXTRACT, 2,1, ain,aout};
+
+        CumoGetNArray(self,na);
+        if (na->ndim==0) {
+            return INT2FIX(0);
+        }
+        if (na->size > (~(u_int32_t)0)) {
+            aout[0].type = cumo_cInt64;
+            ndf.func = <%=c_iter%>_arg64;
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+        } else {
+            aout[0].type = cumo_cInt32;
+            ndf.func = <%=c_iter%>_arg32;
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+        }
+
+        return cumo_na_ndloop(&ndf, 2, self, reduce);
+    }
+    <% else %>
+    {
+        cumo_narray_t *na;
+        VALUE reduce, ret;
+        cumo_ndfunc_arg_in_t ain[2] = {{Qnil,0},{cumo_sym_reduce,0}};
+        cumo_ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        cumo_ndfunc_t ndf = {0, CUMO_STRIDE_LOOP_NIP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_EXTRACT|CUMO_NDF_INDEXER_LOOP, 2,1, ain,aout};
+
+        CumoGetNArray(self,na);
+        if (na->ndim==0) {
+            return INT2FIX(0);
+        }
+        if (na->size > (~(u_int32_t)0)) {
+            aout[0].type = cumo_cInt64;
+            ndf.func = <%=c_iter%>_arg64;
+            <% if is_float %>
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_arg64_nan);
+            <% else %>
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        } else {
+            aout[0].type = cumo_cInt32;
+            ndf.func = <%=c_iter%>_arg32;
+            <% if is_float %>
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_arg32_nan);
+            <% else %>
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        }
+
+        if (cumo_na_has_idx_p(self)) {
+            VALUE copy = cumo_na_copy(self); // reduction does not support idx, make contiguous
+            ret = cumo_na_ndloop(&ndf, 2, copy, reduce);
+        } else {
+            ret = cumo_na_ndloop(&ndf, 2, self, reduce);
+        }
+        if (cumo_compatible_mode_enabled_p()) {
+            return rb_funcall(ret, rb_intern("extract_cpu"), 0);
+        } else {
+            return ret;
+        }
+    }
+    <% end %>
+}

data/ext/cumo/narray/gen/tmpl/accum_arg_kernel.cu

@@ -0,0 +1,66 @@
+<% unless defined?($cumo_narray_gen_tmpl_accum_arg_kernel_included) %>
+<% $cumo_narray_gen_tmpl_accum_arg_kernel_included = 1 %>
+<% unless type_name == 'robject' %>
+
+<%   [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+struct cumo_<%=type_name%>_argmin_int<%=i%>_impl {
+    struct MinAndArgMin {
+        dtype min;
+        idx_t argmin;
+    };
+    __device__ MinAndArgMin Identity(idx_t index) { return {DATA_MAX, index}; }
+    __device__ MinAndArgMin MapIn(dtype in, idx_t index) { return {in, index}; }
+    __device__ void Reduce(MinAndArgMin next, MinAndArgMin& accum) {
+        if (accum.min > next.min) {
+            accum = next;
+        }
+    }
+    __device__ idx_t MapOut(MinAndArgMin accum) { return accum.argmin; }
+};
+
+struct cumo_<%=type_name%>_argmax_int<%=i%>_impl {
+    struct MaxAndArgMax {
+        dtype max;
+        idx_t argmax;
+    };
+    __device__ MaxAndArgMax Identity(idx_t index) { return {DATA_MIN, index}; }
+    __device__ MaxAndArgMax MapIn(dtype in, idx_t index) { return {in, index}; }
+    __device__ void Reduce(MaxAndArgMax next, MaxAndArgMax& accum) {
+        if (accum.max < next.max) {
+            accum = next;
+        }
+    }
+    __device__ idx_t MapOut(MaxAndArgMax accum) { return accum.argmax; }
+};
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void cumo_<%=type_name%>_argmin_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
+{
+    cumo_reduce_arg<dtype, idx_t, cumo_<%=type_name%>_argmin_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_argmin_int<%=i%>_impl{});
+}
+
+void cumo_<%=type_name%>_argmax_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
+{
+    cumo_reduce_arg<dtype, idx_t, cumo_<%=type_name%>_argmax_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_argmax_int<%=i%>_impl{});
+}
+
+#undef idx_t
+<% end %>
+
+<% end %>
+<% end %>

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/index.c

@@ -63,6 +63,7 @@ static ID cumo_id_dup;
 static ID cumo_id_bracket;
 static ID cumo_id_shift_left;
 static ID cumo_id_mask;
+static ID cumo_id_where;
 
 
 static void
@@ -159,6 +160,13 @@ cumo_na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, cumo_na_index_ar
     if (CUMO_NA_NDIM(na) != 1) {
         rb_raise(rb_eIndexError, "should be 1-d NArray");
     }
+    if (rb_obj_class(a) == cumo_cBit) {
+        if (CUMO_NA_SIZE(na) != (size_t)size) {
+            rb_raise(rb_eIndexError, "Bit-NArray size mismatch");
+        }
+        a = rb_funcall(a, cumo_id_where, 0);
+        CumoGetNArray(a,na);
+    }
     n = CUMO_NA_SIZE(na);
     idx = cumo_na_new(cIndex,1,&n);
     cumo_na_store(idx,a);
@@ -1138,4 +1146,5 @@ Init_cumo_na_index()
     cumo_id_bracket     = rb_intern("[]");
     cumo_id_shift_left  = rb_intern("<<");
     cumo_id_mask        = rb_intern("mask");
+    cumo_id_where       = rb_intern("where");
 }

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)
@@ -461,8 +473,10 @@ module Cumo
       arrays.each do |a|
         fst = lst
         lst = fst + (a.shape[axis - nd] || 1)
-        refs[axis] = fst...lst
-        result[*refs] = a
+        if lst > fst
+          refs[axis] = fst...lst
+          result[*refs] = a
+        end
       end
       result
     end
@@ -642,13 +656,17 @@ module Cumo
       result = self.class.zeros(*self_shape)
       lst = shape[axis]
       refs = [true] * ndim
-      refs[axis] = 0...lst
-      result[*refs] = self
+      if lst > 0
+        refs[axis] = 0...lst
+        result[*refs] = self
+      end
       arrays.each do |a|
         fst = lst
         lst = fst + (a.shape[axis - ndim] || 1)
-        refs[axis] = fst...lst
-        result[*refs] = a
+        if lst > fst
+          refs[axis] = fst...lst
+          result[*refs] = a
+        end
       end
       result
     end
@@ -1186,6 +1204,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

@@ -344,13 +344,35 @@ class NArrayTest < Test::Unit::TestCase
           assert { a.min_index(axis: 0) == [0, 1, 2] }
           assert { a.max_index(axis: 1) == [2, 5] }
           assert { a.max_index(axis: 0) == [3, 4, 5] }
+          assert { a.argmin == 0 }
+          assert { a.argmax == 5 }
+          assert { a.argmin(axis: 1) == [0, 0] }
+          assert { a.argmin(axis: 0) == [0, 0, 0] }
+          assert { a.argmax(axis: 1) == [2, 2] }
+          assert { a.argmax(axis: 0) == [1, 1, 1] }
           assert { (a >= 3) == [[0, 0, 1], [1, 1, 1]] }
           assert { (a >  3) == [[0, 0, 0], [1, 1, 1]] }
           assert { (a <= 3) == [[1, 1, 1], [0, 0, 0]] }
           assert { (a <  3) == [[1, 1, 0], [0, 0, 0]] }
           assert { (a.eq 3) == [[0, 0, 1], [0, 0, 0]] }
+          assert { a[a.ne 3] == [1, 2, 5, 7, 11] }
+          assert { a[a[true, 2] < 5, true] == [[1, 2, 3]] }
+          assert { a[true, a[1, true] > 5] == [[2, 3], [7, 11]] }
+          assert { a[:*, (a[0, :*] % 2).eq(1)] == [[1, 3], [5, 11]] }
           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]] }
@@ -704,6 +726,8 @@ class NArrayTest < Test::Unit::TestCase
                    [4, 1, 6]]]
         assert { a.max_index(2) == [[1, 5, 8], [9, 12, 17]] }
         assert { a.max(2) == [[8, 6, 5], [7, 9, 6]] }
+        assert { a.argmax(2) == [[1, 2, 2], [0, 0, 2]] }
+        assert { a.argmin(2) == [[2, 0, 0], [2, 2, 1]] }
 
         unless [Cumo::UInt64, Cumo::UInt32, Cumo::UInt16, Cumo::UInt8].include?(dtype)
           a = dtype[[[-6, -8, -5],
@@ -796,6 +820,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)
@@ -822,4 +851,40 @@ class NArrayTest < Test::Unit::TestCase
     assert { Cumo::SComplex[1].rms == 1.0 }
     assert { Cumo::DComplex[1].rms == 1.0 }
   end
+
+  test "concatenate with empty arrays" do
+    a = Cumo::DFloat[1, 2, 3]
+    empty = Cumo::DFloat[]
+    assert { Cumo::NArray.concatenate([empty, a]) == [1, 2, 3] }
+    assert { Cumo::NArray.concatenate([a, empty]) == [1, 2, 3] }
+    assert { Cumo::NArray.concatenate([empty, empty]) == [] }
+    assert { a.concatenate(empty) == [1, 2, 3] }
+    assert { empty.concatenate(a) == [1, 2, 3] }
+    assert { empty.concatenate(empty) == [] }
+  end
+
+  test "argmax/argmin" do
+    [Cumo::DFloat, Cumo::Int32, Cumo::UInt8].each do |dtype|
+      a = dtype[3, 4, 1, 2]
+      assert { a.argmax == 1 }
+      assert { a.argmin == 2 }
+
+      b = dtype[[3, 4, 1], [2, 0, 5]]
+      assert { b.argmax == 5 }
+      assert { b.argmin == 4 }
+      assert { b.argmax(axis: 1) == [1, 2] }
+      assert { b.argmax(axis: 0) == [0, 0, 1] }
+      assert { b.argmin(axis: 1) == [2, 1] }
+      assert { b.argmin(axis: 0) == [1, 1, 0] }
+      assert { b.at(b.argmax(axis: 0), 0..-1) == [3, 4, 5] }
+      assert { b.at(b.argmin(axis: 0), 0..-1) == [2, 0, 1] }
+    end
+
+    # NaN-aware (nan:true returns the NaN position; nan:false ignores NaN)
+    c = Cumo::DFloat[3.0, Float::NAN, 1.0, 5.0]
+    assert { c.argmax == 3 }
+    assert { c.argmax(nan: true) == 1 }
+    assert { c.argmin == 2 }
+    assert { c.argmin(nan: true) == 1 }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.5
 platform: ruby
 authors:
 - Naotoshi Seo
@@ -157,6 +157,8 @@ files:
 - ext/cumo/narray/gen/narray_def.rb
 - ext/cumo/narray/gen/spec.rb
 - ext/cumo/narray/gen/tmpl/accum.c
+- ext/cumo/narray/gen/tmpl/accum_arg.c
+- ext/cumo/narray/gen/tmpl/accum_arg_kernel.cu
 - ext/cumo/narray/gen/tmpl/accum_binary.c
 - ext/cumo/narray/gen/tmpl/accum_binary_kernel.cu
 - ext/cumo/narray/gen/tmpl/accum_index.c
@@ -331,7 +333,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Cumo is CUDA aware numerical library whose interface is highly compatible
   with Ruby Numo