numo-narray-alt 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62b615bb540e3a9d9783fa984943437f42ad5bbcf93041dead8d770317d8fcf6
-  data.tar.gz: 895c80b9b6544f09d04412a6a96439999752a9636d1b243127d96007f2574ba5
+  metadata.gz: 49f4c26235333f8e467b493aa8dda971e62599966dc12c0d81a5a0fae939bb6d
+  data.tar.gz: 134d4eafee1f7b1165c8700c3fb2038ed018c7e36043926ed382cc3f8d1e94c6
 SHA512:
-  metadata.gz: d6b5ac1dbfd8bb0f448a8c073de8f7951a9f571b20c9f88b864549f31dd828209cd67c4e7b629f2756ece9e98de6ad26a5b37a8f6131f836de259e25895bfd23
-  data.tar.gz: eea7716214274464d8e4fb4874d4415cf49a97ad7e0f15c15211257cb531604c7822913cf15d7a5ebba49df58de845b788a8558b04ac98ec3d5540fc62b527b3
+  metadata.gz: f9d2b83363362f38302ed35d4c3dba6807bdc90a343c0814adb78a0bd1055d7c0dd9690bbd4a69cab32b802d57f4c602f82405a17a0a5371a74d31602988165c
+  data.tar.gz: edd47b6629ca041b3db6b843cb15887ae0a8d64d2be53d0fd683009108091a4ea679cd2c41e030a31e67548d931fa328aa724cdd1c548ec6bda808fbe40ae773

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.11.2"
+#define NARRAY_VERSION "0.11.3"
 #define NARRAY_VERSION_MAJOR 0
 #define NARRAY_VERSION_MINOR 11
-#define NARRAY_VERSION_PATCH 2
+#define NARRAY_VERSION_PATCH 3
 #define NARRAY_VERSION_CODE                                                                    \
   (NARRAY_VERSION_MAJOR * 10000 + NARRAY_VERSION_MINOR * 100 + NARRAY_VERSION_PATCH)
 

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/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"
 
@@ -129,7 +130,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;
@@ -302,8 +305,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;
@@ -575,7 +581,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)
@@ -1252,7 +1258,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;
@@ -1269,8 +1275,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 {
@@ -1280,12 +1291,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;
@@ -1295,8 +1303,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++) {
@@ -1305,17 +1313,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++) {
@@ -1324,11 +1332,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++;
       }
     }
   }
@@ -1688,7 +1696,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)
@@ -1782,7 +1790,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)
@@ -1882,7 +1890,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)
@@ -2011,7 +2019,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)
@@ -2140,7 +2148,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)
@@ -2269,7 +2277,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

@@ -283,7 +283,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

@@ -390,7 +390,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

@@ -265,7 +265,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

@@ -266,7 +266,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

@@ -265,7 +265,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

@@ -265,7 +265,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

@@ -304,7 +304,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;

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

@@ -281,7 +281,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

@@ -388,7 +388,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

@@ -265,7 +265,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

@@ -265,7 +265,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

@@ -265,7 +265,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

@@ -265,7 +265,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;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-narray-alt
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.11.3
 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.11.2/
+  documentation_uri: https://gemdocs.org/gems/numo-narray-alt/0.11.3/
   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: []