carray 3.0.3 → 3.0.5

data/ext/carray_partition.c

@@ -14,7 +14,7 @@
 
 #include "ruby.h"
 #include "carray.h"
-#include "carray_internal.h"   /* ca_axis_integer */
+#include "carray_internal.h"   /* ca_normalize_axis_arg */
 #include "ca_kernel_iterator.h"   /* CA_FOR_EACH_FIBER_INOUT */
 #include "ca_obj_face.h"          /* CA_FACE_LIFT_IF_FACE */
 #include "ca_sort_kernels.h"      /* ca_partition_quick_* / ca_partition_nan_* */
@@ -155,7 +155,7 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
   }
 
   /* Normalize axis. */
-  int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis, NULL), cat->ndim, NULL);
+  int axis = ca_normalize_axis_arg(vaxis, cat->ndim, NULL);
 
   ca_size_t fiber_n = cat->dim[axis];
   ca_size_t kth = partition_kth(fiber_n, vkth);
@@ -166,14 +166,9 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
    * but the cost is the per-pair rb_funcall, not an architectural
    * penalty. */
   if ( cat->data_type == CA_OBJECT ) {
-    static ID id_partition_index_ki = 0;
-    static ID id_take_along_axis    = 0;
-    static ID id_axis_sym           = 0;
-    if ( !id_partition_index_ki ) {
-      id_partition_index_ki = rb_intern("partition_index_ki");
-      id_take_along_axis    = rb_intern("take_along_axis");
-      id_axis_sym           = rb_intern("axis");
-    }
+    ID id_partition_index_ki = rb_intern("partition_index_ki");
+    ID id_take_along_axis    = rb_intern("take_along_axis");
+    ID id_axis_sym           = rb_intern("axis");
     VALUE idx = rb_funcall(target, id_partition_index_ki, 2,
                            INT2NUM(axis), SIZET2NUM(kth));
     VALUE kw = rb_hash_new();
@@ -297,8 +292,7 @@ rb_ca_partition_copy_c_mp (VALUE self, VALUE vkth, VALUE vaxis, int masked_last)
   /* Check axis and kth here, so a bad one is reported as partition_copy's
      rather than as the partition this delegates to. */
   {
-    int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis, NULL),
-                                             ca->ndim, NULL);
+    int axis = ca_normalize_axis_arg(vaxis, ca->ndim, NULL);
     partition_kth(ca->dim[axis], vkth);
   }
   /* rb_ca_partitioned_view's rb_scan_args "1:" pattern needs call-frame
@@ -337,26 +331,30 @@ rb_ca_partition_copy_body (int argc, VALUE *argv, VALUE self)
   int masked_last = NIL_P(vmasked_position) ? 1
     : ca_symbol_choice(vmasked_position, "masked_position", "first", "last", NULL);
 
-  /* Face gate, the same policy as the sort family's: a fixlen storage
-     partitions by memcmp, a numeric storage only when ORDERABLE (its order
-     is the surface order).  The selection runs on the storage and the Face
-     is put back on the result.  Without this the surface fixlen bytes were
-     selected by memcmp, which is not the order of a little-endian integer
-     (CATime) and not the label order of a code (CACategorical). */
+  /* Face gate, the same policy as the sort family's.  An ORDERABLE Face
+     is selected on its storage and put back on the result.  A Face that
+     orders by itself (ca_face_orders_by_itself) is partitioned by the view,
+     which orders by that order (ca_order_key), and its copy is the answer.
+     Any other Face raises. */
   volatile VALUE face = Qnil;
   {
     CArray *ca;
     TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
     if ( ca_is_face(ca) ) {
-      VALUE st = rb_ca_strip_face_value(self);
-      CArray *sc;
-      TypedData_Get_Struct(st, CArray, &carray_data_type, sc);
-      if ( sc->data_type != CA_FIXLEN
-           && ! ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-        ca_face_refuse_order("partition_copy", self, "order");
+      if ( ca_face_orders_by_itself(self) ) {
+        VALUE kw = rb_hash_new();
+        VALUE pv_argv[2];
+        rb_hash_aset(kw, ID2SYM(rb_intern("axis")), vaxis);
+        rb_hash_aset(kw, ID2SYM(rb_intern("masked_position")),
+                     masked_last ? ID2SYM(rb_intern("last")) : ID2SYM(rb_intern("first")));
+        pv_argv[0] = vkth;
+        pv_argv[1] = kw;
+        return rb_ca_copy(rb_funcallv_kw(self, rb_intern("partition"), 2, pv_argv,
+                                         RB_PASS_KEYWORDS));
       }
+      ca_face_require_orderable(self, "partition_copy", "order");
       face = self;
-      self = st;
+      self = rb_ca_strip_face_value(self);
     }
   }
 
@@ -418,7 +416,8 @@ rb_ca_partitioned_view (int argc, VALUE *argv, VALUE self)
      suitable for direct ca_remap_new wrap; the remap gather carries
      target's mask bits through so masked cells stay masked at their
      clustered position (no extra output-mask step needed here). */
-  volatile VALUE sigma_addr = rb_ca_partition_addr_ki_mp(target, vaxis, vkth, masked_last);
+  volatile VALUE sigma_addr =
+    rb_ca_partition_addr_ki_mp(target, vaxis, vkth, masked_last);
   {
     VALUE obj = rb_ca_remap_new(target, sigma_addr);
     CA_FACE_LIFT_IF_FACE(obj, self, ca);
@@ -443,7 +442,9 @@ static VALUE
 rb_ca_partition_copy (int argc, VALUE *argv, VALUE self)
 {
   pc_call_t c = { argc, argv, self };
-  return ca_answer_as_caller(pc_answer_body, (VALUE) &c);
+  VALUE out = ca_answer_as_caller(pc_answer_body, (VALUE) &c);
+  rb_ca_inherit_attr(out, self);
+  return out;
 }
 
 void

data/ext/carray_random.c

@@ -88,16 +88,18 @@ typedef struct {
   long           low_long;
   unsigned long  limit;
   int            axis;           /* shuffle!: -1 = all cells */
+  CArray        *mask;           /* shuffle!: self's mask, moved with the values */
 } ca_random_ctx_t;
 
 static void
 ca_random_run (ca_random_ctx_t *c, VALUE rng, VALUE (*fill)(VALUE))
 {
-  CArray *list[2];
+  CArray *list[3];
   ca_rng_resolve(rng, &c->source);
   list[0] = c->ca;
   list[1] = c->source.state;
-  ca_attach_window(2, list, "ww", fill, (VALUE) c);
+  list[2] = c->mask;
+  ca_attach_window(c->mask ? 3 : 2, list, "www", fill, (VALUE) c);
 }
 
 /* The state is attached once the window is open. */
@@ -163,7 +165,7 @@ ca_random_bang_fill (VALUE arg)
   ca_rng_bind(&c->source);
   switch (ca->data_type) {
   case CA_FLOAT64: {
-    double *p = (double *)ca->ptr;
+    CA_U(double) *p = (CA_U(double) *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = ca_random_real(&c->source);
@@ -175,7 +177,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_FLOAT32: {
-    float *p = (float *)ca->ptr;
+    CA_U(float) *p = (CA_U(float) *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = (float)ca_random_real(&c->source);
@@ -187,7 +189,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX128: {
-    double complex *p = (double complex *)ca->ptr;
+    ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = ca_random_real(&c->source) + ca_random_real(&c->source) * I;
@@ -200,7 +202,7 @@ ca_random_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX64: {
-    float complex *p = (float complex *)ca->ptr;
+    ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
     if (is_default) {
       for (i = 0; i < n; i++)
         p[i] = (float)ca_random_real(&c->source) + (float)ca_random_real(&c->source) * I;
@@ -240,37 +242,37 @@ ca_random_bang_fill (VALUE arg)
       break;
     }
     case CA_INT16: {
-      int16_t *p = (int16_t *)ca->ptr;
+      CA_U(int16_t) *p = (CA_U(int16_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int16_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT16: {
-      uint16_t *p = (uint16_t *)ca->ptr;
+      CA_U(uint16_t) *p = (CA_U(uint16_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint16_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_INT32: {
-      int32_t *p = (int32_t *)ca->ptr;
+      CA_U(int32_t) *p = (CA_U(int32_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int32_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT32: {
-      uint32_t *p = (uint32_t *)ca->ptr;
+      CA_U(uint32_t) *p = (CA_U(uint32_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint32_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_INT64: {
-      int64_t *p = (int64_t *)ca->ptr;
+      CA_U(int64_t) *p = (CA_U(int64_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (int64_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
     }
     case CA_UINT64: {
-      uint64_t *p = (uint64_t *)ca->ptr;
+      CA_U(uint64_t) *p = (CA_U(uint64_t) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (uint64_t)(low_long + ca_random_ulong_limited(&c->source, limit));
       break;
@@ -359,19 +361,55 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
     int is_integer_type = (ca->data_type >= CA_INT8
                             && ca->data_type <= CA_UINT64);
     if (is_integer_type) {
-      low_long  = NUM2LONG(low_val);
-      high_long = NUM2LONG(high_val);
-      if (high_is_closed) high_long += 1;
-      if (low_long >= high_long) {
+      /* The bounds stay Ruby Integers until they are known to fit: the
+         last value drawn is high (closed) or high - 1, and every value
+         from low to it must be one of the type's.  The draw is low plus
+         an offset up to last - low, which holds even the whole int64 or
+         uint64 range. */
+      VALUE last, type_min, type_max;
+      if (!RB_INTEGER_TYPE_P(low_val) || !RB_INTEGER_TYPE_P(high_val)) {
+        rb_raise(rb_eTypeError,
+                 "random: an integer array takes Integer bounds "
+                 "(got %"PRIsVALUE", %"PRIsVALUE")",
+                 rb_inspect(low_val), rb_inspect(high_val));
+      }
+      last = high_is_closed ? high_val
+                            : rb_funcall(high_val, '-', 1, INT2FIX(1));
+      if (RTEST(rb_funcall(low_val, '>', 1, last))) {
         rb_raise(rb_eArgError,
                  "random: low must be less than high "
-                 "(got low=%ld, high=%ld)",
-                 low_long, high_long);
+                 "(got low=%"PRIsVALUE", high=%"PRIsVALUE")",
+                 low_val, high_val);
+      }
+      switch (ca->data_type) {
+      case CA_INT8:   type_min = INT2FIX(INT8_MIN);   type_max = INT2FIX(INT8_MAX);   break;
+      case CA_UINT8:  type_min = INT2FIX(0);          type_max = INT2FIX(UINT8_MAX);  break;
+      case CA_INT16:  type_min = INT2FIX(INT16_MIN);  type_max = INT2FIX(INT16_MAX);  break;
+      case CA_UINT16: type_min = INT2FIX(0);          type_max = INT2FIX(UINT16_MAX); break;
+      case CA_INT32:  type_min = LL2NUM(INT32_MIN);   type_max = LL2NUM(INT32_MAX);   break;
+      case CA_UINT32: type_min = INT2FIX(0);          type_max = ULL2NUM(UINT32_MAX); break;
+      case CA_INT64:  type_min = LL2NUM(INT64_MIN);   type_max = LL2NUM(INT64_MAX);   break;
+      default:        type_min = INT2FIX(0);          type_max = ULL2NUM(UINT64_MAX); break;
+      }
+      if (RTEST(rb_funcall(low_val, '<', 1, type_min)) ||
+          RTEST(rb_funcall(last, '>', 1, type_max))) {
+        rb_raise(rb_eRangeError,
+                 "random: the values %"PRIsVALUE"..%"PRIsVALUE" are not all %s "
+                 "(%"PRIsVALUE"..%"PRIsVALUE")",
+                 low_val, last, ca_type_name[ca->data_type], type_min, type_max);
       }
-      limit = (unsigned long)(high_long - low_long) - 1;
+      low_long = RTEST(rb_funcall(low_val, '<', 1, INT2FIX(0)))
+               ? (long) NUM2LL(low_val) : (long) NUM2ULL(low_val);
+      limit = (unsigned long) NUM2ULL(rb_funcall(last, '-', 1, low_val));
+      (void) high_long;
     } else {
       low_dbl  = NUM2DBL(low_val);
       high_dbl = NUM2DBL(high_val);
+      if (!isfinite(low_dbl) || !isfinite(high_dbl)) {
+        rb_raise(rb_eArgError,
+                 "random: the bounds are finite numbers "
+                 "(got low=%g, high=%g)", low_dbl, high_dbl);
+      }
       if (low_dbl >= high_dbl) {
         rb_raise(rb_eArgError,
                  "random: low must be less than high "
@@ -382,7 +420,7 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
   }
 
   {
-    ca_random_ctx_t c;
+    ca_random_ctx_t c = { 0 };
     c.ca         = ca;
     c.n          = ca->elements;
     c.is_default = is_default;
@@ -392,6 +430,8 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
     c.limit      = limit;
     ca_random_run(&c, rng, ca_random_bang_fill);
   }
+  /* Every cell now holds a value, as after seq! or fill. */
+  ca_clear_mask(ca);
   return self;
 }
 
@@ -443,19 +483,19 @@ ca_randomn_bang_fill (VALUE arg)
   if (c->source.kind == CA_RNG_OWN) {
     switch (ca->data_type) {
     case CA_FLOAT64: {
-      double *p = (double *)ca->ptr;
+      CA_U(double) *p = (CA_U(double) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = ca_random_normal(&c->source);
       break;
     }
     case CA_FLOAT32: {
-      float *p = (float *)ca->ptr;
+      CA_U(float) *p = (CA_U(float) *)ca->ptr;
       for (i = 0; i < n; i++)
         p[i] = (float) ca_random_normal(&c->source);
       break;
     }
     case CA_CMPLX128: {
-      double complex *p = (double complex *)ca->ptr;
+      ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
       for (i = 0; i < n; i++) {
         /* Into locals first: C does not say which order a call's
            arguments are evaluated in, and these two advance a state. */
@@ -466,7 +506,7 @@ ca_randomn_bang_fill (VALUE arg)
       break;
     }
     case CA_CMPLX64: {
-      float complex *p = (float complex *)ca->ptr;
+      ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
       for (i = 0; i < n; i++) {
         double re = ca_random_normal(&c->source);
         double im = ca_random_normal(&c->source);
@@ -482,7 +522,7 @@ ca_randomn_bang_fill (VALUE arg)
 
   switch (ca->data_type) {
   case CA_FLOAT64: {
-    double *p = (double *)ca->ptr;
+    CA_U(double) *p = (CA_U(double) *)ca->ptr;
     ca_size_t pairs = n / 2;
     for (i = 0; i < pairs; i++) {
       box_muller_pair(&c->source, &p[2*i], &p[2*i+1]);
@@ -495,7 +535,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_FLOAT32: {
-    float *p = (float *)ca->ptr;
+    CA_U(float) *p = (CA_U(float) *)ca->ptr;
     ca_size_t pairs = n / 2;
     for (i = 0; i < pairs; i++) {
       double r1, r2;
@@ -511,7 +551,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX128: {
-    double complex *p = (double complex *)ca->ptr;
+    ca_u_cmplx128_t *p = (ca_u_cmplx128_t *)ca->ptr;
     for (i = 0; i < n; i++) {
       double r1, r2;
       box_muller_pair(&c->source, &r1, &r2);
@@ -520,7 +560,7 @@ ca_randomn_bang_fill (VALUE arg)
     break;
   }
   case CA_CMPLX64: {
-    float complex *p = (float complex *)ca->ptr;
+    ca_u_cmplx64_t *p = (ca_u_cmplx64_t *)ca->ptr;
     for (i = 0; i < n; i++) {
       double r1, r2;
       box_muller_pair(&c->source, &r1, &r2);
@@ -560,11 +600,13 @@ rb_ca_randomn_bang(int argc, VALUE *argv, VALUE self)
   }
 
   {
-    ca_random_ctx_t c;
+    ca_random_ctx_t c = { 0 };
     c.ca = ca;
     c.n  = ca->elements;
     ca_random_run(&c, rng, ca_randomn_bang_fill);
   }
+  /* Every cell now holds a value, as after seq! or fill. */
+  ca_clear_mask(ca);
   return self;
 }
 
@@ -600,12 +642,16 @@ ca_shuffle_bang_fill (VALUE arg)
     ca_size_t elem_bytes = ca->bytes;
     char *tmp = ALLOCV_N(char, tmp_holder, elem_bytes);
     char *p = ca->ptr;
+    char *m = c->mask ? c->mask->ptr : NULL;
 
     n = ca->elements;
     for (ca_size_t i = n - 1; i > 0; i--) {
       unsigned long j = ca_random_ulong_limited(&c->source, (unsigned long)i);
       if ((ca_size_t)j != i) {
         swap_chunks(p + i * elem_bytes, p + j * elem_bytes, elem_bytes, tmp);
+        if ( m ) {
+          char b = m[i]; m[i] = m[j]; m[j] = b;
+        }
       }
     }
     ALLOCV_END(tmp_holder);
@@ -630,12 +676,16 @@ ca_shuffle_bang_fill (VALUE arg)
 
     for (ca_size_t o = 0; o < outer; o++) {
       char *base = ca->ptr + o * stride;
+      char *mbase = c->mask ? c->mask->ptr + o * n * inner : NULL;
       for (ca_size_t i = n - 1; i > 0; i--) {
         unsigned long j = ca_random_ulong_limited(&c->source, (unsigned long)i);
         if ((ca_size_t)j != i) {
           swap_chunks(base + i * chunk_bytes,
                       base + j * chunk_bytes,
                       chunk_bytes, tmp);
+          if ( mbase ) {
+            swap_chunks(mbase + i * inner, mbase + j * inner, inner, tmp);
+          }
         }
       }
     }
@@ -650,7 +700,7 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
   CArray *ca;
   VALUE opts = Qnil, v_axis = Qnil;
   int axis = -1;
-  ca_random_ctx_t c;
+  ca_random_ctx_t c = { 0 };
 
   rb_scan_args(argc, argv, "0:", &opts);
   VALUE rng = Qnil;
@@ -662,7 +712,7 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
   if (ca->elements <= 1) return self;
 
   if (!NIL_P(v_axis)) {
-    axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(v_axis, NULL), ca->ndim, NULL);
+    axis = ca_normalize_axis_arg(v_axis, ca->ndim, NULL);
     if (ca->dim[axis] <= 1) {
       return self;
     }
@@ -670,6 +720,10 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
 
   c.ca   = ca;
   c.axis = axis;
+  /* The mask moves with the values: a masked cell stays masked wherever
+     it lands. */
+  ca_update_mask(ca);
+  c.mask = ca->mask;
   ca_random_run(&c, rng, ca_shuffle_bang_fill);
   return self;
 }