numo-narray-alt 0.10.6 → 0.10.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad0c7d628c79e849dab290f3143d45bd4a1f755b1abd62851937f7ed7d894e93
-  data.tar.gz: 3643e1b645a95a1815237599543aa73735d0e19afa4ad7c10d4b95a902bd2df9
+  metadata.gz: cf8873637141f0256dbedbc1ada30646faef0f119af6a5a70e69676581bf610f
+  data.tar.gz: 7c9f38d861bcfa39ad544265ac205b33552c4139e5740524165d7cc057f0ccf2
 SHA512:
-  metadata.gz: e46752c80f12517f896253dbf2756b1b170c25032d4680fb71806f5157e00a565590118b31ea91208b10654fe68699acaf3e93b85adb174e35e03e83cadcc753
-  data.tar.gz: 646d182241adac8f628de8c18611cce09c44b1800737d9a1df10548ad99978ab96208f7efd5bb2ab57ba07f961785a1b42118ff7498b4a66f1fc6ea2838b5b8f
+  metadata.gz: afe8bb36cbf569f121565d952b4a0f7120f65b3f9b566d438747f17777cb2e28b66b268e4400866a69fd8009b7215c7f2501fef66ebaa5af32c2cf49060363d5
+  data.tar.gz: af4a5b9071ae98832f48e038134a9d658531bada286fefc312f9d08c3eba9752b1937eaeba6643e89d82295fa31222e705de76deb58be5841e24c9044ef685e5

data/ext/numo/narray/data.c

@@ -8,6 +8,7 @@
 #include "numo/narray.h"
 #include "numo/template.h"
 
+static ID id_copy;
 static ID id_mulsum;
 static ID id_store;
 static ID id_swap_byte;
@@ -105,7 +106,11 @@ static VALUE nary_swap_byte(VALUE self) {
   ndfunc_arg_out_t aout[1] = { { INT2FIX(0), 0 } };
   ndfunc_t ndf = { iter_swap_byte, FULL_LOOP | NDF_ACCEPT_BYTESWAP, 1, 1, ain, aout };
 
-  v = na_ndloop(&ndf, 1, self);
+  if (RTEST(rb_obj_is_kind_of(self, numo_cBit))) {
+    v = TEST_INPLACE(self) ? self : rb_funcall(self, id_copy, 0);
+  } else {
+    v = na_ndloop(&ndf, 1, self);
+  }
   if (self != v) {
     na_copy_flags(self, v);
   }
@@ -359,6 +364,10 @@ static void na_check_reshape(int argc, VALUE* argv, VALUE self, size_t* shape) {
   } else if (total != NA_SIZE(na)) {
     rb_raise(rb_eArgError, "Total size must be same");
   }
+
+  if (argc > NA_MAX_DIMENSION) {
+    rb_raise(nary_eDimensionError, "ndim=%d is too many", argc);
+  }
 }
 
 /*
@@ -376,11 +385,15 @@ static VALUE na_reshape_bang(int argc, VALUE* argv, VALUE self) {
   ssize_t stride;
   stridx_t* stridx;
   int i;
+  VALUE tmp;
 
+  if (OBJ_FROZEN(self)) {
+    rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
+  }
   if (na_check_contiguous(self) == Qfalse) {
     rb_raise(rb_eStandardError, "cannot change shape of non-contiguous NArray");
   }
-  shape = ALLOCA_N(size_t, argc);
+  shape = RB_ALLOCV_N(size_t, tmp, argc);
   na_check_reshape(argc, argv, self, shape);
 
   GetNArray(self, na);
@@ -391,7 +404,11 @@ static VALUE na_reshape_bang(int argc, VALUE* argv, VALUE self) {
     } else {
       stridx = na2->stridx;
     }
-    stride = SDX_GET_STRIDE(na2->stridx[na->ndim - 1]);
+    if (na->ndim == 0) {
+      stride = nary_element_stride(self);
+    } else {
+      stride = SDX_GET_STRIDE(na2->stridx[na->ndim - 1]);
+    }
     for (i = argc; i--;) {
       SDX_SET_STRIDE(stridx[i], stride);
       stride *= shape[i];
@@ -402,6 +419,7 @@ static VALUE na_reshape_bang(int argc, VALUE* argv, VALUE self) {
     }
   }
   na_setup_shape(na, argc, shape);
+  RB_ALLOCV_END(tmp);
   return self;
 }
 
@@ -416,14 +434,15 @@ static VALUE na_reshape_bang(int argc, VALUE* argv, VALUE self) {
 static VALUE na_reshape(int argc, VALUE* argv, VALUE self) {
   size_t* shape;
   narray_t* na;
-  VALUE copy;
+  VALUE copy, tmp;
 
-  shape = ALLOCA_N(size_t, argc);
+  shape = RB_ALLOCV_N(size_t, tmp, 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);
+  RB_ALLOCV_END(tmp);
   return copy;
 }
 
@@ -505,6 +524,9 @@ na_flatten_dim(VALUE self, int sd) {
       // set index
       idx2 = ALLOC_N(size_t, (shape[sd] == 0) ? 1 : shape[sd]);
       SDX_SET_INDEX(na2->stridx[sd], idx2);
+      if (shape[sd] == 0) {
+        return view;
+      }
       // init for md-loop
       fd = nd - sd;
       c = ALLOCA_N(size_t, fd);
@@ -965,6 +987,7 @@ void Init_nary_data(void) {
 
   // rb_define_method(cNArray, "dot", numo_na_dot, 1);
 
+  id_copy = rb_intern("copy");
   id_mulsum = rb_intern("mulsum");
   id_store = rb_intern("store");
   id_swap_byte = rb_intern("swap_byte");

data/ext/numo/narray/index.c

@@ -439,7 +439,9 @@ static size_t na_index_parse_args(VALUE args, narray_t* na, na_index_arg_t* q, i
     }
     // new dimension
     else if (v == sym_new) {
-      na_index_parse_each(v, 1, k, &q[j]);
+      // Past the last dimension, which is how the aref functions below tell
+      // a new axis from a real one.
+      na_index_parse_each(v, 1, na->ndim, &q[j]);
       j++;
     }
     // other dimension
@@ -465,6 +467,25 @@ static void na_get_strides_nadata(const narray_data_t* na, ssize_t* strides, ssi
   }
 }
 
+// A new axis holds one element, so any stride addresses it. Give it the size of
+// the block below it, to keep the chain na_check_ladder() walks: a break there
+// costs contiguous?, and na_flatten_dim() takes the last dimension's stride as
+// the flat one on the strength of that same chain.
+static void na_index_set_newaxis_strides(
+  narray_view_t* na2, const int* newaxis, int n_newaxes, int ndim_new
+) {
+  int i, j;
+
+  for (i = n_newaxes - 1; i >= 0; i--) {
+    j = newaxis[i];
+    if (j + 1 < ndim_new && SDX_IS_STRIDE(na2->stridx[j + 1])) {
+      SDX_SET_STRIDE(
+        na2->stridx[j], SDX_GET_STRIDE(na2->stridx[j + 1]) * (ssize_t)na2->base.shape[j + 1]
+      );
+    }
+  }
+}
+
 static void na_index_aref_nadata(
   narray_data_t* na1, narray_view_t* na2, na_index_arg_t* q, ssize_t elmsz, int ndim,
   int keep_dim
@@ -475,8 +496,11 @@ static void na_index_aref_nadata(
   ssize_t* strides_na1;
   size_t* index;
   ssize_t beg, step;
+  int* newaxis;
+  int n_newaxes = 0;
   VALUE m;
 
+  newaxis = ALLOCA_N(int, ndim);
   strides_na1 = ALLOCA_N(ssize_t, na1->base.ndim);
   na_get_strides_nadata(na1, strides_na1, elmsz);
 
@@ -503,6 +527,7 @@ static void na_index_aref_nadata(
 
     if (qi_orig_dim >= na1->base.ndim) {
       // new dimension
+      newaxis[n_newaxes++] = j;
       SDX_SET_STRIDE(na2->stridx[j], elmsz);
     } else if (q[i].idx != NULL) {
       // array index
@@ -521,6 +546,7 @@ static void na_index_aref_nadata(
     j++;
     total *= size;
   }
+  na_index_set_newaxis_strides(na2, newaxis, n_newaxes, j);
   na2->base.size = total;
 }
 
@@ -530,6 +556,10 @@ static void na_index_aref_naview(
 ) {
   int i, j;
   ssize_t total = 1;
+  int* newaxis;
+  int n_newaxes = 0;
+
+  newaxis = ALLOCA_N(int, ndim);
 
   for (i = j = 0; i < ndim; i++) {
     stridx_t sdx1;
@@ -560,6 +590,7 @@ static void na_index_aref_naview(
 
     if (qi_orig_dim >= na1->base.ndim) {
       // new dimension
+      newaxis[n_newaxes++] = j;
       SDX_SET_STRIDE(na2->stridx[j], elmsz);
     } else if (q[i].idx != NULL && SDX_IS_INDEX(sdx1)) {
       // index <- index
@@ -618,6 +649,7 @@ static void na_index_aref_naview(
     j++;
     total *= size;
   }
+  na_index_set_newaxis_strides(na2, newaxis, n_newaxes, j);
   na2->base.size = total;
 }
 
@@ -838,7 +870,10 @@ int na_get_result_dimension(
   }
 
   if (j != argc) {
-    return check_index_count(argc, na->ndim, count_new, count_rest);
+    int nd = check_index_count(argc, na->ndim, count_new, count_rest);
+    if (nd != 0) {
+      return nd;
+    }
   }
 
   switch (na->type) {

data/ext/numo/narray/narray.c

@@ -275,7 +275,18 @@ void na_array_to_internal_shape(VALUE self, VALUE ary, size_t* shape) {
   }
 }
 
+static void na_check_ndim(int ndim) {
+  if (ndim < 0) {
+    rb_raise(nary_eDimensionError, "ndim=%d is negative", ndim);
+  }
+  if (ndim > NA_MAX_DIMENSION) {
+    rb_raise(nary_eDimensionError, "ndim=%d is too many", ndim);
+  }
+}
+
 void na_alloc_shape(narray_t* na, int ndim) {
+  na_check_ndim(ndim);
+
   na->ndim = ndim;
   na->size = 0;
   if (na->shape != NULL && na->shape != &(na->size)) {
@@ -288,12 +299,6 @@ void na_alloc_shape(narray_t* na, int ndim) {
     na->shape = &(na->size);
     break;
   default:
-    if (ndim < 0) {
-      rb_raise(nary_eDimensionError, "ndim=%d is negative", ndim);
-    }
-    if (ndim > NA_MAX_DIMENSION) {
-      rb_raise(nary_eDimensionError, "ndim=%d is too many", ndim);
-    }
     na->shape = ALLOC_N(size_t, ndim);
   }
 }
@@ -302,19 +307,23 @@ void na_setup_shape(narray_t* na, int ndim, size_t* shape) {
   int i;
   size_t size;
 
+  na_check_ndim(ndim);
+
+  for (i = 0, size = 1; i < ndim; i++) {
+    if (shape[i] != 0 && size > SIZE_MAX / shape[i]) {
+      rb_raise(rb_eRangeError, "total number of elements is too large");
+    }
+    size *= shape[i];
+  }
+
   na_alloc_shape(na, ndim);
 
-  if (ndim == 0) {
-    na->size = 1;
-  } else if (ndim == 1) {
-    na->size = shape[0];
-  } else {
-    for (i = 0, size = 1; i < ndim; i++) {
+  if (ndim > 1) {
+    for (i = 0; i < ndim; i++) {
       na->shape[i] = shape[i];
-      size *= shape[i];
     }
-    na->size = size;
   }
+  na->size = (ndim == 0) ? 1 : size;
 }
 
 static void na_setup(VALUE self, int ndim, size_t* shape) {
@@ -876,6 +885,9 @@ na_check_ladder(VALUE self, int start_dim) {
   narray_t* na;
   GetNArray(self, na);
 
+  if (na->ndim == 0) {
+    return Qtrue;
+  }
   if (start_dim < -na->ndim || start_dim >= na->ndim) {
     rb_bug("start_dim (%d) out of range", start_dim);
   }
@@ -920,6 +932,9 @@ na_check_contiguous(VALUE self) {
     if (NA_VIEW_STRIDX(na) == 0) {
       return Qtrue;
     }
+    if (NA_NDIM(na) == 0) {
+      return Qtrue;
+    }
     if (na_check_ladder(self, 0) == Qtrue) {
       elmsz = nary_element_stride(self);
       if (elmsz == NA_STRIDE_AT(na, NA_NDIM(na) - 1)) {
@@ -1043,6 +1058,7 @@ static VALUE na_expand_dims(VALUE self, VALUE vdim) {
 
   GetNArray(self, na);
   nd = na->ndim;
+  na_check_ndim(nd + 1);
 
   dim = NUM2INT(vdim);
   if (dim < -nd - 1 || dim > nd) {
@@ -1272,7 +1288,11 @@ static VALUE nary_s_from_binary(int argc, VALUE* argv, VALUE type) {
       rb_raise(rb_eArgError, "second argument must be size or shape");
     }
     if (FIXNUM_P(velmsz)) {
-      byte_size = len * NUM2SIZET(velmsz);
+      size_t elmsz = NUM2SIZET(velmsz);
+      if (elmsz != 0 && len > SIZE_MAX / elmsz) {
+        rb_raise(rb_eArgError, "specified size is too large");
+      }
+      byte_size = len * elmsz;
     } else {
       byte_size = ceil(len * NUM2DBL(velmsz));
     }
@@ -1315,7 +1335,7 @@ static VALUE nary_s_from_binary(int argc, VALUE* argv, VALUE type) {
     @return [Integer] stored length.
  */
 static VALUE nary_store_binary(int argc, VALUE* argv, VALUE self) {
-  size_t size, str_len, byte_size, offset;
+  size_t size, str_len, byte_size, offset, view_offset = 0;
   int narg;
   VALUE vstr, voffset;
   VALUE velmsz;
@@ -1338,7 +1358,11 @@ static VALUE nary_store_binary(int argc, VALUE* argv, VALUE self) {
   size = NA_SIZE(na);
   velmsz = rb_const_get(rb_obj_class(self), id_element_byte_size);
   if (FIXNUM_P(velmsz)) {
-    byte_size = size * NUM2SIZET(velmsz);
+    size_t elmsz = NUM2SIZET(velmsz);
+    if (elmsz != 0 && size > SIZE_MAX / elmsz) {
+      rb_raise(rb_eArgError, "string is too short to store");
+    }
+    byte_size = size * elmsz;
   } else {
     byte_size = ceil(size * NUM2DBL(velmsz));
   }
@@ -1346,12 +1370,34 @@ static VALUE nary_store_binary(int argc, VALUE* argv, VALUE self) {
     rb_raise(rb_eArgError, "string is too short to store");
   }
 
-  if (OBJ_FROZEN(vstr)) {
+  if (na->type == NARRAY_VIEW_T) {
+    narray_t* nab;
+    size_t data_byte_size;
+
+    if (na_check_contiguous(self) == Qfalse) {
+      rb_raise(rb_eStandardError, "cannot store binary data to non-contiguous NArray");
+    }
+    view_offset = NA_VIEW_OFFSET(na);
+    if (!FIXNUM_P(velmsz) && view_offset != 0) {
+      rb_raise(rb_eStandardError, "cannot store binary data to NArray view offset in bits");
+    }
+    GetNArray(NA_VIEW_DATA(na), nab);
+    if (FIXNUM_P(velmsz)) {
+      data_byte_size = NA_SIZE(nab) * NUM2SIZET(velmsz);
+    } else {
+      data_byte_size = ceil(NA_SIZE(nab) * NUM2DBL(velmsz));
+    }
+    if (view_offset > data_byte_size || byte_size > data_byte_size - view_offset) {
+      rb_raise(rb_eArgError, "string is too long to store");
+    }
+  }
+
+  if (OBJ_FROZEN(vstr) && na->type != NARRAY_VIEW_T) {
     na_set_pointer(self, RSTRING_PTR(vstr) + offset, byte_size);
     rb_ivar_set(self, id_source, vstr);
   } else {
-    void* ptr = na_get_pointer_for_write(self);
-    memcpy(ptr, RSTRING_PTR(vstr) + offset, byte_size);
+    char* ptr = na_get_pointer_for_write(self);
+    memcpy(ptr + view_offset, RSTRING_PTR(vstr) + offset, byte_size);
   }
 
   return SIZET2NUM(byte_size);
@@ -1367,10 +1413,12 @@ static VALUE nary_to_binary(VALUE self) {
   char* ptr;
   VALUE str;
   narray_t* na;
+  int offset_in_bits;
 
   GetNArray(self, na);
   if (na->type == NARRAY_VIEW_T) {
-    if (na_check_contiguous(self) == Qtrue) {
+    offset_in_bits = RTEST(rb_obj_is_kind_of(self, numo_cBit)) && NA_VIEW_OFFSET(na) != 0;
+    if (!offset_in_bits && na_check_contiguous(self) == Qtrue) {
       offset = NA_VIEW_OFFSET(na);
     } else {
       self = rb_funcall(self, id_dup, 0);
@@ -1402,7 +1450,7 @@ static VALUE nary_marshal_dump(VALUE self) {
     GetNArray(self, na);
     if (na->type == NARRAY_VIEW_T) {
       if (na_check_contiguous(self) == Qtrue) {
-        offset = NA_VIEW_OFFSET(na);
+        offset = NA_VIEW_OFFSET(na) / sizeof(VALUE);
       } else {
         self = rb_funcall(self, id_dup, 0);
       }
@@ -1426,6 +1474,9 @@ static VALUE na_inplace(VALUE self);
 static VALUE nary_marshal_load(VALUE self, VALUE a) {
   VALUE v;
 
+  if (OBJ_FROZEN(self)) {
+    rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
+  }
   if (TYPE(a) != T_ARRAY) {
     rb_raise(rb_eArgError, "marshal argument should be array");
   }
@@ -1440,6 +1491,9 @@ static VALUE nary_marshal_load(VALUE self, VALUE a) {
       NUM2INT(RARRAY_AREF(a, 0))
     );
   }
+  if (TYPE(RARRAY_AREF(a, 1)) != T_ARRAY) {
+    rb_raise(rb_eArgError, "marshal shape should be array");
+  }
   na_initialize(self, RARRAY_AREF(a, 1));
   NA_FL0_SET(self, FIX2INT(RARRAY_AREF(a, 2)));
   v = RARRAY_AREF(a, 3);
@@ -1456,6 +1510,7 @@ static VALUE nary_marshal_load(VALUE self, VALUE a) {
     ptr = na_get_pointer_for_write(self);
     memcpy(ptr, RARRAY_PTR(v), NA_SIZE(na) * sizeof(VALUE));
   } else {
+    Check_Type(v, T_STRING);
     rb_str_freeze(v);
     nary_store_binary(1, &v, self);
     if (TEST_BYTE_SWAPPED(self)) {

data/ext/numo/narray/ndloop.c

@@ -520,7 +520,7 @@ static void ndloop_set_stepidx(na_md_loop_t* lp, int j, VALUE vna, int* dim_map,
       if (n > 1 || nd > 0) {
         i = dim_map[k];
         LITER(lp, i, j).step = s;
-        // LITER(lp,i,j).idx = NULL;
+        LITER(lp, i, j).idx = NULL;
       }
       s *= n;
       nd--;
@@ -539,7 +539,7 @@ static void ndloop_set_stepidx(na_md_loop_t* lp, int j, VALUE vna, int* dim_map,
           LITER(lp, i, j).idx = SDX_GET_INDEX(sdx);
         } else {
           LITER(lp, i, j).step = SDX_GET_STRIDE(sdx);
-          // LITER(lp,i,j).idx = NULL;
+          LITER(lp, i, j).idx = NULL;
         }
       } else if (n == 1) {
         if (SDX_IS_INDEX(sdx)) {
@@ -1540,6 +1540,7 @@ static void loop_store_subnarray(ndfunc_t* nf, na_md_loop_t* lp, int i0, size_t*
     dim_map[i] = lp->trans_map[i + i0];
   }
   ndloop_set_stepidx(lp, 1, a, dim_map, NDL_READ);
+  LITER(lp, i0, 1).pos = LITER(lp, 0, 1).pos;
   LARG(lp, 1).shape = &(na->shape[na->ndim - 1]);
 
   // loop body

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

@@ -13,10 +13,10 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.10.6"
+#define NARRAY_VERSION "0.10.8"
 #define NARRAY_VERSION_MAJOR 0
 #define NARRAY_VERSION_MINOR 10
-#define NARRAY_VERSION_PATCH 6
+#define NARRAY_VERSION_PATCH 8
 #define NARRAY_VERSION_CODE                                                                    \
   (NARRAY_VERSION_MAJOR * 10000 + NARRAY_VERSION_MINOR * 100 + NARRAY_VERSION_PATCH)
 

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

@@ -68,13 +68,6 @@
 
 #define m_mulsum_init INT2FIX(0)
 
-#define m_sprintf(s, x) robj_sprintf(s, x)
-
-static inline int robj_sprintf(char* s, VALUE x) {
-  VALUE v = rb_funcall(x, rb_intern("to_s"), 0);
-  return sprintf(s, "%s", StringValuePtr(v));
-}
-
 #define m_sqrt(x)                                                                              \
   rb_funcall(rb_const_get(rb_mKernel, rb_intern("Math")), rb_intern("sqrt"), 1, x);
 

data/ext/numo/narray/src/mh/bincount.h

@@ -1,6 +1,16 @@
 #ifndef NUMO_NARRAY_MH_BINCOUNT_H
 #define NUMO_NARRAY_MH_BINCOUNT_H 1
 
+/* The items below index the output, whose size was fixed by an earlier scan of
+   the same array. Ruby code can run in between, so the bound is rechecked. */
+static inline void na_bincount_check_item(size_t x, size_t n) {
+  if (x >= n) {
+    rb_raise(
+      rb_eIndexError, "item %" SZF "u is out of range of the output(size:%" SZF "u)", x, n
+    );
+  }
+}
+
 #define DEF_BINCOUNT_FUNCS(tDType, tNAryClass)                                                 \
   static void iter_##tDType##_bincount_32(na_loop_t* const lp) {                               \
     char* p1;                                                                                  \
@@ -21,11 +31,13 @@
     if (idx1) {                                                                                \
       for (size_t i = 0; i < m; i++) {                                                         \
         GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        na_bincount_check_item(x, n);                                                          \
         (*(u_int32_t*)(p2 + s2 * x))++;                                                        \
       }                                                                                        \
     } else {                                                                                   \
       for (size_t i = 0; i < m; i++) {                                                         \
         GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        na_bincount_check_item(x, n);                                                          \
         (*(u_int32_t*)(p2 + s2 * x))++;                                                        \
       }                                                                                        \
     }                                                                                          \
@@ -60,11 +72,13 @@
     if (idx1) {                                                                                \
       for (size_t i = 0; i < m; i++) {                                                         \
         GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        na_bincount_check_item(x, n);                                                          \
         (*(u_int64_t*)(p2 + s2 * x))++;                                                        \
       }                                                                                        \
     } else {                                                                                   \
       for (size_t i = 0; i < m; i++) {                                                         \
         GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        na_bincount_check_item(x, n);                                                          \
         (*(u_int64_t*)(p2 + s2 * x))++;                                                        \
       }                                                                                        \
     }                                                                                          \
@@ -106,6 +120,7 @@
     for (size_t i = 0; i < l; i++) {                                                           \
       GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
       GET_DATA_STRIDE(p2, s2, float, w);                                                       \
+      na_bincount_check_item(x, n);                                                            \
       (*(float*)(p3 + s3 * x)) += w;                                                           \
     }                                                                                          \
   }                                                                                            \
@@ -146,6 +161,7 @@
     for (size_t i = 0; i < l; i++) {                                                           \
       GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
       GET_DATA_STRIDE(p2, s2, double, w);                                                      \
+      na_bincount_check_item(x, n);                                                            \
       (*(double*)(p3 + s3 * x)) += w;                                                          \
     }                                                                                          \
   }                                                                                            \
@@ -170,6 +186,14 @@
     rb_scan_args(argc, argv, "01:", &weight, &kw);                                             \
     rb_get_kwargs(kw, table, 0, 1, opts);                                                      \
                                                                                                \
+    size_t minlength = 0;                                                                      \
+    if (opts[0] != Qundef) {                                                                   \
+      minlength = NUM2SIZET(opts[0]);                                                          \
+    }                                                                                          \
+    if (!NIL_P(weight) && rb_obj_class(weight) != numo_cSFloat) {                              \
+      weight = rb_funcall(numo_cDFloat, id_cast, 1, weight);                                   \
+    }                                                                                          \
+                                                                                               \
     VALUE v = tDType##_minmax(0, 0, self);                                                     \
     if (m_num_to_data(RARRAY_AREF(v, 0)) < 0) {                                                \
       rb_raise(rb_eArgError, "array items must be non-netagive");                              \
@@ -177,11 +201,8 @@
     v = RARRAY_AREF(v, 1);                                                                     \
                                                                                                \
     size_t length = NUM2SIZET(v) + 1;                                                          \
-    if (opts[0] != Qundef) {                                                                   \
-      const size_t minlength = NUM2SIZET(opts[0]);                                             \
-      if (minlength > length) {                                                                \
-        length = minlength;                                                                    \
-      }                                                                                        \
+    if (minlength > length) {                                                                  \
+      length = minlength;                                                                      \
     }                                                                                          \
                                                                                                \
     if (NIL_P(weight)) {                                                                       \
@@ -207,14 +228,23 @@
     rb_scan_args(argc, argv, "01:", &weight, &kw);                                             \
     rb_get_kwargs(kw, table, 0, 1, opts);                                                      \
                                                                                                \
+    size_t minlength = 0;                                                                      \
+    if (opts[0] != Qundef) {                                                                   \
+      minlength = NUM2SIZET(opts[0]);                                                          \
+    }                                                                                          \
+    if (!NIL_P(weight) && rb_obj_class(weight) != numo_cSFloat) {                              \
+      weight = rb_funcall(numo_cDFloat, id_cast, 1, weight);                                   \
+    }                                                                                          \
+                                                                                               \
     VALUE v = tDType##_max(0, 0, self);                                                        \
                                                                                                \
-    size_t length = NUM2SIZET(v) + 1;                                                          \
-    if (opts[0] != Qundef) {                                                                   \
-      const size_t minlength = NUM2SIZET(opts[0]);                                             \
-      if (minlength > length) {                                                                \
-        length = minlength;                                                                    \
-      }                                                                                        \
+    const size_t max = NUM2SIZET(v);                                                           \
+    if (max == SIZE_MAX) {                                                                     \
+      rb_raise(rb_eRangeError, "maximum item %" SZF "u is too large to size the output", max); \
+    }                                                                                          \
+    size_t length = max + 1;                                                                   \
+    if (minlength > length) {                                                                  \
+      length = minlength;                                                                      \
     }                                                                                          \
                                                                                                \
     if (NIL_P(weight)) {                                                                       \

data/ext/numo/narray/src/mh/format.h

@@ -1,7 +1,7 @@
 #ifndef NUMO_NARRAY_MH_FORMAT_H
 #define NUMO_NARRAY_MH_FORMAT_H 1
 
-#define DEF_NARRAY_FORMAT_METHOD_FUNC(tDType)                                                  \
+#define DEF_NARRAY_FORMAT_ELEMENT_FUNC(tDType)                                                 \
   static VALUE format_##tDType(VALUE fmt, tDType* x) {                                         \
     if (NIL_P(fmt)) {                                                                          \
       char s[48];                                                                              \
@@ -9,8 +9,22 @@
       return rb_str_new(s, n);                                                                 \
     }                                                                                          \
     return rb_funcall(fmt, '%', 1, m_data_to_num(*x));                                         \
-  }                                                                                            \
-                                                                                               \
+  }
+
+/* robject formats its element without the fixed buffer above: the element is an
+   arbitrary Ruby object, so the length of its to_s is not bounded by anything
+   this side controls. */
+#define DEF_NARRAY_ROBJ_FORMAT_ELEMENT_FUNC()                                                  \
+  static VALUE format_robject(VALUE fmt, robject* x) {                                         \
+    if (NIL_P(fmt)) {                                                                          \
+      VALUE v = rb_funcall(*x, id_to_s, 0);                                                    \
+      StringValue(v);                                                                          \
+      return rb_str_new(RSTRING_PTR(v), RSTRING_LEN(v));                                       \
+    }                                                                                          \
+    return rb_funcall(fmt, '%', 1, m_data_to_num(*x));                                         \
+  }
+
+#define DEF_NARRAY_FORMAT_LOOP_METHOD_FUNC(tDType)                                             \
   static void iter_##tDType##_format(na_loop_t* const lp) {                                    \
     size_t n;                                                                                  \
     char* p1;                                                                                  \
@@ -52,4 +66,12 @@
     return na_ndloop(&ndf, 2, self, fmt);                                                      \
   }
 
+#define DEF_NARRAY_FORMAT_METHOD_FUNC(tDType)                                                  \
+  DEF_NARRAY_FORMAT_ELEMENT_FUNC(tDType)                                                       \
+  DEF_NARRAY_FORMAT_LOOP_METHOD_FUNC(tDType)
+
+#define DEF_NARRAY_ROBJ_FORMAT_METHOD_FUNC()                                                   \
+  DEF_NARRAY_ROBJ_FORMAT_ELEMENT_FUNC()                                                        \
+  DEF_NARRAY_FORMAT_LOOP_METHOD_FUNC(robject)
+
 #endif /* NUMO_NARRAY_MH_FORMAT_H */

data/ext/numo/narray/src/mh/sort.h

@@ -321,9 +321,9 @@ static inline void swapfunc(char* a, char* b, size_t n, int swaptype) {
     rb_funcall(idx, rb_intern("seq"), 0);                                                      \
     size_t size = na->size * sizeof(void*);                                                    \
     VALUE tmp;                                                                                 \
-    char* buf = rb_alloc_tmp_buffer(&tmp, size);                                               \
+    char* buf = RB_ALLOCV(tmp, size);                                                          \
     VALUE res = na_ndloop3(&ndf, buf, 3, self, idx, reduce);                                   \
-    rb_free_tmp_buffer(&tmp);                                                                  \
+    RB_ALLOCV_END(tmp);                                                                        \
     return res;                                                                                \
   }
 
@@ -475,9 +475,9 @@ static inline void swapfunc(char* a, char* b, size_t n, int swaptype) {
     rb_funcall(idx, rb_intern("seq"), 0);                                                      \
     size_t size = na->size * sizeof(void*);                                                    \
     VALUE tmp;                                                                                 \
-    char* buf = rb_alloc_tmp_buffer(&tmp, size);                                               \
+    char* buf = RB_ALLOCV(tmp, size);                                                          \
     VALUE res = na_ndloop3(&ndf, buf, 3, self, idx, reduce);                                   \
-    rb_free_tmp_buffer(&tmp);                                                                  \
+    RB_ALLOCV_END(tmp);                                                                        \
     return res;                                                                                \
   }
 

data/ext/numo/narray/src/mh/store.h

@@ -1,6 +1,20 @@
 #ifndef NUMO_NARRAY_MH_STORE_H
 #define NUMO_NARRAY_MH_STORE_H 1
 
+/* The store loops below run Ruby code for every element, which can reallocate or
+   shrink the array being read: its buffer and length do not survive one. */
+static inline bool na_store_rary_fetch(VALUE ary, size_t i, VALUE* x) {
+  if (!RB_TYPE_P(ary, T_ARRAY)) {
+    *x = ary;
+    return true;
+  }
+  if (i >= (size_t)RARRAY_LEN(ary)) {
+    return false;
+  }
+  *x = RARRAY_AREF(ary, (long)i);
+  return true;
+}
+
 #define DEF_STORE_NUMERIC_FUNC(tDType, tNAryClass)                                             \
   static VALUE tDType##_store(VALUE, VALUE);                                                   \
                                                                                                \
@@ -134,7 +148,6 @@
     size_t i1;                                                                                 \
     size_t n1;                                                                                 \
     VALUE v1;                                                                                  \
-    VALUE* ptr;                                                                                \
     VALUE x;                                                                                   \
     double y;                                                                                  \
     tDType z;                                                                                  \
@@ -152,8 +165,13 @@
     i = 0;                                                                                     \
     if (lp->args[1].ptr) {                                                                     \
       if (v1 == Qtrue) {                                                                       \
-        iter_##tDType##_store_##tDType(lp);                                                    \
         i = lp->args[1].shape[0];                                                              \
+        if (i > n) {                                                                           \
+          i = n;                                                                               \
+        }                                                                                      \
+        NDL_CNT(lp) = i;                                                                       \
+        iter_##tDType##_store_##tDType(lp);                                                    \
+        NDL_CNT(lp) = n;                                                                       \
         if (idx1) {                                                                            \
           idx1 += i;                                                                           \
         } else {                                                                               \
@@ -162,11 +180,9 @@
       }                                                                                        \
       goto loop_end;                                                                           \
     }                                                                                          \
-    ptr = &v1;                                                                                 \
     switch (TYPE(v1)) {                                                                        \
     case T_ARRAY:                                                                              \
       n1 = RARRAY_LEN(v1);                                                                     \
-      ptr = RARRAY_PTR(v1);                                                                    \
       break;                                                                                   \
     case T_NIL:                                                                                \
       n1 = 0;                                                                                  \
@@ -175,8 +191,8 @@
       n1 = 1;                                                                                  \
     }                                                                                          \
     if (idx1) {                                                                                \
-      for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {                                          \
-        x = ptr[i1];                                                                           \
+      for (i = i1 = 0; i1 < n1 && i < n; i1++) {                                               \
+        if (!na_store_rary_fetch(v1, i1, &x)) break;                                           \
         if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {           \
           nary_step_sequence(x, &len, &beg, &step);                                            \
           for (c = 0; c < len && i < n; c++, i++) {                                            \
@@ -187,11 +203,12 @@
         } else if (TYPE(x) != T_ARRAY) {                                                       \
           z = m_num_to_data(x);                                                                \
           SET_DATA_INDEX(p1, idx1, tDType, z);                                                 \
+          i++;                                                                                 \
         }                                                                                      \
       }                                                                                        \
     } else {                                                                                   \
-      for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {                                          \
-        x = ptr[i1];                                                                           \
+      for (i = i1 = 0; i1 < n1 && i < n; i1++) {                                               \
+        if (!na_store_rary_fetch(v1, i1, &x)) break;                                           \
         if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {           \
           nary_step_sequence(x, &len, &beg, &step);                                            \
           for (c = 0; c < len && i < n; c++, i++) {                                            \
@@ -202,6 +219,7 @@
         } else if (TYPE(x) != T_ARRAY) {                                                       \
           z = m_num_to_data(x);                                                                \
           SET_DATA_STRIDE(p1, s1, tDType, z);                                                  \
+          i++;                                                                                 \
         }                                                                                      \
       }                                                                                        \
     }                                                                                          \
@@ -474,7 +492,7 @@
       robject_store_uint8(self, obj);                                                          \
       return self;                                                                             \
     }                                                                                          \
-    if (klass == numo_cRObject) {                                                              \
+    if (RTEST(rb_obj_is_kind_of(obj, numo_cRObject))) {                                        \
       robject_store_robject(self, obj);                                                        \
       return self;                                                                             \
     }                                                                                          \

data/ext/numo/narray/src/t_bit.c

@@ -9,6 +9,7 @@
 #include <ruby.h>
 
 #include "SFMT.h"
+#include "mh/store.h"
 #include "numo/narray.h"
 #include "numo/template.h"
 
@@ -134,7 +135,9 @@ static void iter_bit_fill(na_loop_t* const lp) {
       p3 += s3;
     }
   } else {
-    if (p3 > 0 || n < NB) {
+    a3 += p3 / NB;
+    p3 %= NB;
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) {
         len = (int)n;
@@ -307,8 +310,11 @@ static inline void yield_each_with_index(BIT_DIGIT x, size_t* c, VALUE* a, int n
 
 static void iter_bit_each_with_index(na_loop_t* const lp) {
   size_t* c = (size_t*)(lp->opt_ptr);
-  int nd = lp->ndim - 1;
-  int md = lp->ndim + 1;
+  int nd = lp->ndim;
+  if (nd > 0) {
+    nd--;
+  }
+  int md = nd + 2;
   VALUE* a = ALLOCA_N(VALUE, md);
   size_t n;
   BIT_DIGIT* a1;
@@ -580,7 +586,7 @@ static void iter_bit_store_bit(na_loop_t* const lp) {
     o1 = (int)(p1 - p3);
     l1 = NB + o1;
     r1 = NB - o1;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -1257,7 +1263,7 @@ static VALUE bit_store_robject(VALUE self, VALUE obj) {
 static void iter_bit_store_array(na_loop_t* const lp) {
   size_t i, n;
   size_t i1, n1;
-  VALUE v1, *ptr;
+  VALUE v1;
   BIT_DIGIT* a1;
   size_t p1;
   size_t s1, *idx1;
@@ -1274,8 +1280,13 @@ static void iter_bit_store_array(na_loop_t* const lp) {
 
   if (lp->args[1].ptr) {
     if (v1 == Qtrue) {
-      iter_bit_store_bit(lp);
       i = lp->args[1].shape[0];
+      if (i > n) {
+        i = n;
+      }
+      NDL_CNT(lp) = i;
+      iter_bit_store_bit(lp);
+      NDL_CNT(lp) = n;
       if (idx1) {
         idx1 += i;
       } else {
@@ -1285,12 +1296,9 @@ static void iter_bit_store_array(na_loop_t* const lp) {
     goto loop_end;
   }
 
-  ptr = &v1;
-
   switch (TYPE(v1)) {
   case T_ARRAY:
     n1 = RARRAY_LEN(v1);
-    ptr = RARRAY_PTR(v1);
     break;
   case T_NIL:
     n1 = 0;
@@ -1300,8 +1308,8 @@ static void iter_bit_store_array(na_loop_t* const lp) {
   }
 
   if (idx1) {
-    for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {
-      x = ptr[i1];
+    for (i = i1 = 0; i1 < n1 && i < n; i1++) {
+      if (!na_store_rary_fetch(v1, i1, &x)) break;
       if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
         nary_step_sequence(x, &len, &beg, &step);
         for (c = 0; c < len && i < n; c++, i++) {
@@ -1310,17 +1318,17 @@ static void iter_bit_store_array(na_loop_t* const lp) {
           STORE_BIT(a1, p1 + *idx1, z);
           idx1++;
         }
-      }
-      if (TYPE(x) != T_ARRAY) {
+      } else if (TYPE(x) != T_ARRAY) {
         if (x == Qnil) x = INT2FIX(0);
         z = m_num_to_data(x);
         STORE_BIT(a1, p1 + *idx1, z);
         idx1++;
+        i++;
       }
     }
   } else {
-    for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {
-      x = ptr[i1];
+    for (i = i1 = 0; i1 < n1 && i < n; i1++) {
+      if (!na_store_rary_fetch(v1, i1, &x)) break;
       if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
         nary_step_sequence(x, &len, &beg, &step);
         for (c = 0; c < len && i < n; c++, i++) {
@@ -1329,11 +1337,11 @@ static void iter_bit_store_array(na_loop_t* const lp) {
           STORE_BIT(a1, p1, z);
           p1 += s1;
         }
-      }
-      if (TYPE(x) != T_ARRAY) {
+      } else if (TYPE(x) != T_ARRAY) {
         z = m_num_to_data(x);
         STORE_BIT(a1, p1, z);
         p1 += s1;
+        i++;
       }
     }
   }
@@ -1693,7 +1701,7 @@ static void iter_bit_copy(na_loop_t* const lp) {
     o1 = (int)(p1 - p3);
     l1 = NB + o1;
     r1 = NB - o1;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -1787,7 +1795,7 @@ static void iter_bit_not(na_loop_t* const lp) {
     o1 = (int)(p1 - p3);
     l1 = NB + o1;
     r1 = NB - o1;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -1887,7 +1895,7 @@ static void iter_bit_and(na_loop_t* const lp) {
     r1 = NB - o1;
     l2 = NB + o2;
     r2 = NB - o2;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -2016,7 +2024,7 @@ static void iter_bit_or(na_loop_t* const lp) {
     r1 = NB - o1;
     l2 = NB + o2;
     r2 = NB - o2;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -2145,7 +2153,7 @@ static void iter_bit_xor(na_loop_t* const lp) {
     r1 = NB - o1;
     l2 = NB + o2;
     r2 = NB - o2;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)
@@ -2274,7 +2282,7 @@ static void iter_bit_eq(na_loop_t* const lp) {
     r1 = NB - o1;
     l2 = NB + o2;
     r2 = NB - o2;
-    if (p3 > 0 || n < NB) {
+    if (n > 0 && (p3 > 0 || n < NB)) {
       len = (int)(NB - p3);
       if ((int)n < len) len = (int)n;
       if (o1 >= 0)

data/ext/numo/narray/src/t_dcomplex.c

@@ -288,7 +288,7 @@ static VALUE dcomplex_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_dfloat.c

@@ -358,7 +358,7 @@ static VALUE dfloat_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_int16.c

@@ -270,7 +270,7 @@ static VALUE int16_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_int32.c

@@ -271,7 +271,7 @@ static VALUE int32_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_int64.c

@@ -270,7 +270,7 @@ static VALUE int64_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_int8.c

@@ -270,7 +270,7 @@ static VALUE int8_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_robject.c

@@ -50,6 +50,7 @@ static ID id_reciprocal;
 static ID id_round;
 static ID id_square;
 static ID id_to_a;
+static ID id_to_s;
 static ID id_truncate;
 
 #include <numo/types/robject.h>
@@ -146,7 +147,7 @@ DEF_NARRAY_ASET_METHOD_FUNC(robject)
 DEF_NARRAY_COERCE_CAST_METHOD_FUNC(robject)
 DEF_NARRAY_TO_A_METHOD_FUNC(robject)
 DEF_NARRAY_FILL_METHOD_FUNC(robject)
-DEF_NARRAY_FORMAT_METHOD_FUNC(robject)
+DEF_NARRAY_ROBJ_FORMAT_METHOD_FUNC()
 DEF_NARRAY_FORMAT_TO_A_METHOD_FUNC(robject)
 DEF_NARRAY_ROBJ_INSPECT_METHOD_FUNC()
 DEF_NARRAY_EACH_METHOD_FUNC(robject)
@@ -308,7 +309,7 @@ static VALUE robject_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       {
         size_t i;
@@ -370,6 +371,7 @@ void Init_numo_robject(void) {
   id_round = rb_intern("round");
   id_square = rb_intern("square");
   id_to_a = rb_intern("to_a");
+  id_to_s = rb_intern("to_s");
   id_truncate = rb_intern("truncate");
 
   /**

data/ext/numo/narray/src/t_scomplex.c

@@ -286,7 +286,7 @@ static VALUE scomplex_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_sfloat.c

@@ -356,7 +356,7 @@ static VALUE sfloat_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_uint16.c

@@ -270,7 +270,7 @@ static VALUE uint16_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_uint32.c

@@ -270,7 +270,7 @@ static VALUE uint32_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_uint64.c

@@ -270,7 +270,7 @@ static VALUE uint64_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/ext/numo/narray/src/t_uint8.c

@@ -270,7 +270,7 @@ static VALUE uint8_allocate(VALUE self) {
   case NARRAY_DATA_T:
     ptr = NA_DATA_PTR(na);
     if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
+      ptr = xmalloc2(na->size, sizeof(dtype));
 
       NA_DATA_PTR(na) = ptr;
       NA_DATA_OWNED(na) = TRUE;

data/lib/numo/narray/extra.rb

@@ -137,6 +137,10 @@ module Numo
     #   # [[2, -3, 5],
     #   #  [4, 9, 7],
     #   #  [2, -1, 6]]
+    # @example
+    #   a = Numo::NArray.parse('true false nil')
+    #   # => Numo::Bit#shape=[1,3]
+    #   # [[1, 0, 0]]
 
     def self.parse(str, split1d: /\s+/, split2d: /;?$|;/,
                    split3d: /\s*\n(\s*\n)+/m)
@@ -151,7 +155,8 @@ module Numo
 
           c = []
           line.split(split1d).each do |item|
-            c << eval(item.strip) unless item.empty? # rubocop:disable Security/Eval
+            item = item.strip
+            c << parse_token(item) unless item.empty?
           end
           b << c unless c.empty?
         end
@@ -164,6 +169,42 @@ module Numo
       end
     end
 
+    # Convert one token of {parse} input into a value.
+    #
+    # Only the literals that describe an element are accepted: integer, float
+    # and complex numbers, and +true+, +false+ and +nil+, which {cast} turns
+    # into a {Numo::Bit}. Anything else -- an expression, a method call, a bare
+    # word -- raises ArgumentError, so text handed to {parse} is never executed
+    # as Ruby code.
+    #
+    # @param item [String] one whitespace-delimited token, already stripped
+    # @return [Integer, Float, Complex, true, false, nil] the parsed value
+    # @raise [ArgumentError] if the token is not one of those literals
+    def self.parse_token(item)
+      case item
+      when 'true' then return true
+      when 'false' then return false
+      when 'nil' then return nil
+      end
+
+      v = Integer(item, exception: false)
+      return v if v
+
+      v = Float(item, exception: false)
+      return v if v
+
+      if item.end_with?('i')
+        begin
+          return Complex(item)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      raise ArgumentError, "invalid literal: #{item.inspect}"
+    end
+    private_class_method :parse_token
+
     # Iterate over an axis
     # @example
     #   > a = Numo::DFloat.new(2,2,2).seq

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-narray-alt
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.10.8
 platform: ruby
 authors:
 - yoshoku
@@ -214,7 +214,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/yoshoku/numo-narray-alt
   changelog_uri: https://github.com/yoshoku/numo-narray-alt/blob/main/CHANGELOG.md
-  documentation_uri: https://gemdocs.org/gems/numo-narray-alt/0.10.6/
+  documentation_uri: https://gemdocs.org/gems/numo-narray-alt/0.10.8/
   rubygems_mfa_required: 'true'
 post_install_message: |
   ===
@@ -238,7 +238,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Numo::NArray Alternative is a project forked from Numo::NArray.
 test_files: []