carray 3.0.4 → 3.0.5

data/ext/ca_obj_tile.c

@@ -108,6 +108,8 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->reps      = NULL;               /* set before either allocation can raise */
+  ca->dim       = NULL;
   ca->reps      = ALLOC_N(ca_size_t, ndim);
   ca->dim       = ALLOC_N(ca_size_t, ndim);
 
@@ -120,15 +122,33 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
   return 0;
 }
 
+typedef struct {
+  CATile    *ca;
+  CArray    *parent;
+  ca_size_t *reps;
+} ca_tile_new_arg;
+
+static VALUE
+ca_tile_new_setup (VALUE varg)
+{
+  ca_tile_new_arg *a = (ca_tile_new_arg *) varg;
+  ca_tile_setup(a->ca, a->parent, a->reps);
+  return Qnil;
+}
+
+/* The setup allocates reps and dim after the struct: when either fails,
+   the struct goes too. */
 CATile *
 ca_tile_new (CArray *parent, ca_size_t *reps)
 {
-  CATile *ca;
+  ca_tile_new_arg a;
   ca_tile_setup(NULL, parent, reps);
-  ca = ALLOC(CATile);
-  ca_tile_setup(ca, parent, reps);
-  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
-  return ca;
+  a.ca     = ALLOC(CATile);
+  a.parent = parent;
+  a.reps = reps;
+  ca_fill_or_free((CArray *) a.ca, ca_tile_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_view_inherit_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -548,7 +568,7 @@ rb_ca_tile (int argc, VALUE *argv, VALUE self)
                len, ca->ndim);
     }
     for ( i = 0; i < ca->ndim; i++ ) {
-      reps[i] = NUM2SIZE(rb_ary_entry(ary, i));
+      reps[i] = ca_integer_arg(rb_ary_entry(ary, i), "a repeat count", NULL);
     }
   }
   else {
@@ -559,7 +579,7 @@ rb_ca_tile (int argc, VALUE *argv, VALUE self)
                ca->ndim, argc);
     }
     for ( i = 0; i < ca->ndim; i++ ) {
-      reps[i] = NUM2SIZE(argv[i]);
+      reps[i] = ca_integer_arg(argv[i], "a repeat count", NULL);
     }
   }
 

data/ext/ca_obj_transpose.c

@@ -42,8 +42,8 @@ ca_trans_setup (CAStride *ca, CArray *parent, ca_size_t *imap)
                "specified %i-th dimension number out of range", i);
     }
     if (map[idim] != -1) {
-      rb_raise(rb_eArgError,
-               "specified %i-th dimension number is duplicated", i);
+      rb_raise(rb_eArgError, "%s: axis %" PRId64 " is given twice",
+               ca_calling_method_name(), (int64_t) idim);
     }
     map[idim] = i;
     newdim[i] = dim0[idim];
@@ -120,10 +120,14 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
     for (i = 0; i < ca->ndim; i++) imap[i] = ca->ndim - i - 1;
   }
   else if (argc == ca->ndim) {
-    for (i = 0; i < ca->ndim; i++) imap[i] = NUM2SIZE(argv[i]);
+    /* Each axis read as every axis argument is: negative from the end. */
+    for (i = 0; i < ca->ndim; i++) {
+      imap[i] = ca_normalize_axis_arg(argv[i], ca->ndim, NULL);
+    }
   }
   else {
-    rb_raise(rb_eArgError, "# of arguments should be equal to ndim");
+    rb_raise(rb_eArgError, "%s: %d axes given for ndim %d",
+             ca_calling_method_name(), argc, (int) ca->ndim);
   }
 
   obj = rb_ca_trans_new(self, imap);

data/ext/ca_obj_triop.c

@@ -542,6 +542,9 @@ rb_ca_triop_build (VALUE cary1, VALUE cary2, VALUE cary3, uint16_t op_id)
     r3 = ca_lazy_settle_scalar(r3, r3_scalar);
   }
 
+  ca_refuse_without_common_type(r1, r2);
+  ca_refuse_without_common_type(r1, r3);
+  ca_refuse_without_common_type(r2, r3);
   TypedData_Get_Struct(r1, CArray, &carray_data_type, op1);
   TypedData_Get_Struct(r2, CArray, &carray_data_type, op2);
   TypedData_Get_Struct(r3, CArray, &carray_data_type, op3);

data/ext/ca_obj_window.c

@@ -801,16 +801,40 @@ ca_window_create_bounds_mask (VALUE view)
   return Qnil;
 }
 
+typedef struct {
+  CAWindow  *ca;
+  CArray    *parent;
+  ca_size_t *start;
+  ca_size_t *count;
+  uint8_t   *bounds;
+  char      *fill;
+} ca_window_new_arg;
+
+static VALUE
+ca_window_new_setup (VALUE varg)
+{
+  ca_window_new_arg *a = (ca_window_new_arg *) varg;
+  ca_window_setup(a->ca, a->parent, a->start, a->count, a->bounds, a->fill);
+  return Qnil;
+}
+
+/* The setup allocates the fill value after the struct and its pool: when
+   that fails, the struct goes too. */
 CAWindow *
 ca_window_new (CArray *parent,
                ca_size_t *start, ca_size_t *count, uint8_t *bounds, char *fill)
 {
-  CAWindow *ca;
+  ca_window_new_arg a;
   ca_window_setup(NULL, parent, start, count, bounds, fill);
-  ca = (CAWindow *) ca_array_alloc(CA_OBJ_WINDOW, parent->ndim);
-  ca_window_setup(ca, parent, start, count, bounds, fill);
-  ca_fill_or_free((CArray *) ca, ca_window_create_bounds_mask, (VALUE) ca);
-  return ca;
+  a.ca     = (CAWindow *) ca_array_alloc(CA_OBJ_WINDOW, parent->ndim);
+  a.parent = parent;
+  a.start  = start;
+  a.count  = count;
+  a.bounds = bounds;
+  a.fill   = fill;
+  ca_fill_or_free((CArray *) a.ca, ca_window_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_window_create_bounds_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -1674,51 +1698,56 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
     if ( SYMBOL_P(rbounds) ) {
       rbounds = rb_sym2str(rbounds);
     }
-    switch ( TYPE(rbounds) ) {
-    case T_STRING:
-      cbounds = StringValuePtr(rbounds);
-      if ( rfval == CA_UNDEF && strncmp(cbounds, "fill", 4) 
-                             && strncmp(cbounds, "mask", 4) ) {
-        rb_raise(rb_eArgError, "conflicted bounds and fill_value");
-      }
-      if ( ! strncmp(cbounds, "ruby", 4) ) {
-        bounds = CA_BOUNDS_RUBY;
-      }
-      else if ( ! strncmp(cbounds, "strict", 6) ) {
-        bounds = CA_BOUNDS_STRICT;
-      }
-      else if ( ! strncmp(cbounds, "nearest", 7) ) {
-        bounds = CA_BOUNDS_NEAREST;
-      }
-      else if ( ! strncmp(cbounds, "periodic", 8) ) {
-        rb_raise(rb_eArgError,
-                 "bounds=>'periodic' removed in 3.0; "
-                 "use CArray#roll(...) for cyclic shift "
-                 "(returns a CARoll view)");
-      }
-      else if ( ! strncmp(cbounds, "reflect", 7) ) {
-        rb_raise(rb_eArgError,
-                 "bounds=>'reflect' removed in 3.0; "
-                 "there is no view-based alternative");
-      }
-      else if ( ! strncmp(cbounds, "mask", 4) ) {
-        rb_warn("CAWindow option :bounds=>\"mask\" will be obsolete");
-        rb_warn("use ca.window(..., fill_value: UNDEF)");
-        bounds = CA_BOUNDS_MASK;
-      }
-      else if ( ! strncmp(cbounds, "fill", 4) ) {
-        bounds = CA_BOUNDS_FILL;
-      }
-      else {
-        rb_raise(rb_eArgError, 
-                 "unknown option value '%s' for :bounds", cbounds);        
-      }
-      break;
-    case T_FIXNUM:
-      bounds = NUM2INT(rbounds);
-      break;
-    default:
-      rb_raise(rb_eArgError, "invalid option value for :bounds");
+    if ( ! RB_TYPE_P(rbounds, T_STRING) ) {
+      rb_raise(rb_eTypeError,
+               "window: bounds: must be a Symbol or a String (got %s)",
+               rb_obj_classname(rbounds));
+    }
+    cbounds = StringValueCStr(rbounds);
+    if ( ! strcmp(cbounds, "ruby") ) {
+      bounds = CA_BOUNDS_RUBY;
+    }
+    else if ( ! strcmp(cbounds, "strict") ) {
+      bounds = CA_BOUNDS_STRICT;
+    }
+    else if ( ! strcmp(cbounds, "nearest") ) {
+      bounds = CA_BOUNDS_NEAREST;
+    }
+    else if ( ! strcmp(cbounds, "periodic") ) {
+      rb_raise(rb_eArgError,
+               "bounds=>'periodic' removed in 3.0; "
+               "use CArray#roll(...) for cyclic shift "
+               "(returns a CARoll view)");
+    }
+    else if ( ! strcmp(cbounds, "reflect") ) {
+      rb_raise(rb_eArgError,
+               "bounds=>'reflect' removed in 3.0; "
+               "there is no view-based alternative");
+    }
+    else if ( ! strcmp(cbounds, "mask") ) {
+      rb_warn("CAWindow option :bounds=>\"mask\" will be obsolete");
+      rb_warn("use ca.window(..., fill_value: UNDEF)");
+      bounds = CA_BOUNDS_MASK;
+    }
+    else if ( ! strcmp(cbounds, "fill") ) {
+      bounds = ( rfval == CA_UNDEF ) ? CA_BOUNDS_MASK : CA_BOUNDS_FILL;
+    }
+    else {
+      rb_raise(rb_eArgError,
+               "window: unknown bounds: '%s'", cbounds);
+    }
+    /* A fill value says what the cells outside the array are; the other
+       policies say something else about them. */
+    if ( rfval != CA_UNSPECIFIED
+         && bounds != CA_BOUNDS_FILL && bounds != CA_BOUNDS_MASK ) {
+      rb_raise(rb_eArgError,
+               "window: fill_value: is for bounds: :fill, not :%s", cbounds);
+    }
+    if ( rfval != CA_UNSPECIFIED && rfval != CA_UNDEF
+         && bounds == CA_BOUNDS_MASK ) {
+      rb_raise(rb_eArgError,
+               "window: fill_value: %+"PRIsVALUE" conflicts with bounds: :mask "
+               "(use fill_value: UNDEF to mask the cells outside)", rfval);
     }
   }
 

data/ext/ca_op_ipower.c

@@ -112,7 +112,7 @@ static void
 ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
-  float32_t *p1 = (float32_t *) ptr1, *p2 = (float32_t *) ptr2;
+  ca_u_float32_t *p1 = (ca_u_float32_t *) ptr1, *p2 = (ca_u_float32_t *) ptr2;
   if ( m ) {
     while (n--) {
       if ( ! *m++ ) { *p2 = op_powi_float32_t(*p1, ipow); }
@@ -127,7 +127,7 @@ static void
 ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
-  float64_t *p1 = (float64_t *) ptr1, *p2 = (float64_t *) ptr2;
+  ca_u_float64_t *p1 = (ca_u_float64_t *) ptr1, *p2 = (ca_u_float64_t *) ptr2;
   if ( m ) {
     while (n--) {
       if ( ! *m++ ) { *p2 = op_powi_float64_t(*p1, ipow); }
@@ -142,7 +142,7 @@ static void
 ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
-  cmplx64_t *p1 = (cmplx64_t *) ptr1, *p2 = (cmplx64_t *) ptr2;
+  ca_u_cmplx64_t *p1 = (ca_u_cmplx64_t *) ptr1, *p2 = (ca_u_cmplx64_t *) ptr2;
   if ( m ) {
     while (n--) {
       if ( ! *m++ ) { *p2 = op_powi_cmplx64_t(*p1, ipow); }
@@ -157,7 +157,7 @@ static void
 ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
-  cmplx128_t *p1 = (cmplx128_t *) ptr1, *p2 = (cmplx128_t *) ptr2;
+  ca_u_cmplx128_t *p1 = (ca_u_cmplx128_t *) ptr1, *p2 = (ca_u_cmplx128_t *) ptr2;
   if ( m ) {
     while (n--) {
       if ( ! *m++ ) { *p2 = op_powi_cmplx128_t(*p1, ipow); }

data/ext/ca_sort_kernels.h

@@ -62,11 +62,14 @@ void ca_sort_merge_f64 (double    *a, double    *aux, ca_size_t n);
 ca_size_t ca_partition_nan_f32 (float32_t *a, ca_size_t n);
 ca_size_t ca_partition_nan_f64 (double    *a, ca_size_t n);
 
-/* P.4: pair variant of NaN pre-partition for float argsort kernels. */
+/* Pair variant of NaN pre-partition for float argsort kernels.  scratch
+   holds n pairs; its contents on return are unspecified. */
 struct ca_pair_f32;
 struct ca_pair_f64;
-ca_size_t ca_partition_nan_pair_f32 (struct ca_pair_f32 *a, ca_size_t n);
-ca_size_t ca_partition_nan_pair_f64 (struct ca_pair_f64 *a, ca_size_t n);
+ca_size_t ca_partition_nan_pair_f32 (struct ca_pair_f32 *a, ca_size_t n,
+                                     struct ca_pair_f32 *scratch);
+ca_size_t ca_partition_nan_pair_f64 (struct ca_pair_f64 *a, ca_size_t n,
+                                     struct ca_pair_f64 *scratch);
 
 /* P.9: value-level quickselect for partition_copy.
    Reorders a[0..n) so that a[kth] is exact + left/right regions

data/ext/carray.h

@@ -173,6 +173,39 @@ typedef int8_t boolean8_t;
 #define CA_ALIGN_CMPLX128 offsetof(struct { char c; cmplx128_t x; }, x)
 #define CA_ALIGN_OBJECT   offsetof(struct { char c; VALUE      x; }, x)
 
+/* Cell types that may sit at any byte.  A view's cells need not be aligned
+   to their size: a struct member at offset 1, a refer with a byte offset,
+   a wrapped external buffer.  Reading a cell through a plain `double *`
+   there is undefined (x86 vector code may assume the alignment), so a
+   kernel reads and writes cells through these.  Same size and value as the
+   plain type; only the alignment the compiler may assume is 1. */
+#if defined(__GNUC__) || defined(__clang__)
+#  define CA_UNALIGNED __attribute__((aligned(1)))
+#else
+#  define CA_UNALIGNED
+#endif
+typedef boolean8_t ca_u_boolean8_t;
+typedef int8_t     ca_u_int8_t;
+typedef uint8_t    ca_u_uint8_t;
+typedef int16_t    ca_u_int16_t    CA_UNALIGNED;
+typedef uint16_t   ca_u_uint16_t   CA_UNALIGNED;
+typedef int32_t    ca_u_int32_t    CA_UNALIGNED;
+typedef uint32_t   ca_u_uint32_t   CA_UNALIGNED;
+typedef int64_t    ca_u_int64_t    CA_UNALIGNED;
+typedef uint64_t   ca_u_uint64_t   CA_UNALIGNED;
+typedef float32_t  ca_u_float32_t  CA_UNALIGNED;
+typedef float64_t  ca_u_float64_t  CA_UNALIGNED;
+typedef cmplx64_t  ca_u_cmplx64_t  CA_UNALIGNED;
+typedef cmplx128_t ca_u_cmplx128_t CA_UNALIGNED;
+typedef VALUE      ca_u_VALUE      CA_UNALIGNED;
+
+typedef ca_u_float32_t ca_u_float;
+typedef ca_u_float64_t ca_u_double;
+
+/* CA_U(float64_t) is ca_u_float64_t (and CA_U(double) ca_u_double): for a
+   macro that takes the cell type. */
+#define CA_U(type) ca_u_##type
+
 /* -------------------------------------------------------------------- */
 
 #define CA_OBJ_TYPE_MAX  256

data/ext/carray_access.c

@@ -193,6 +193,14 @@ rb_ca_fill (VALUE self, VALUE rval)
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   if ( ca_is_empty(ca) ) {
+    /* No cell to fill, but a value no cell could hold is refused, as an
+       assignment to the empty array refuses it. */
+    if ( rval != CA_UNDEF && ca->bytes > 0 ) {
+      volatile VALUE holder;
+      char *fval = ALLOCV_N(char, holder, ca->bytes);
+      rb_ca_obj2ptr(self, rval, fval);
+      ALLOCV_END(holder);
+    }
     return self;                /* empty = no-op fill; return self for chaining */
   }
 
@@ -884,9 +892,9 @@ rb_ca_index_restruct_block (int16_t *ndimp, ca_size_t *shrink, ca_size_t *dim,
 
   offset = 0;
 
-  if ( idx[0] == -1 ) {
-    j = 0;
-    while ( idx[++j] ) {
+  if ( ndim0 > 0 && idx[0] == -1 ) {
+    /* j = the number of leading axes collapsed by a scalar index */
+    for (j=1; j<ndim0 && idx[j] == -1; j++) {
       ;
     }
 
@@ -1365,6 +1373,7 @@ rb_ca_fetch_newaxis (int argc, VALUE *argv, VALUE self, CArray *ca)
      element, which is what the shape rules then hold it to. */
   if ( nscalar == nclean ) {
     VALUE blocks[CA_RANK_MAX];
+    ca_check_rank_fits(nunder, NULL);   /* the result has the :_ axes only */
     for (i = 0; i < nclean; i++) {
       blocks[i] = rb_assoc_new(clean[i], INT2FIX(1));
     }
@@ -1379,6 +1388,10 @@ rb_ca_fetch_newaxis (int argc, VALUE *argv, VALUE self, CArray *ca)
 
   TypedData_Get_Struct(base, CArray, &carray_data_type, cb);
 
+  /* The result has the base's axes and one for each :_, before any is
+     written into final_dims. */
+  ca_check_rank_fits((long) nunder + cb->ndim, NULL);
+
   /* Reconstruct final shape: walk original argv.  :_ -> size-1, scalar
      (Integer) -> dropped (skip), else -> base.dim[cursor].  A key gives one
      axis, except an integer CArray read alone (a mapping), which gives as

data/ext/carray_attribute.c

@@ -520,10 +520,34 @@ rb_ca_inherit_attr (VALUE dst, VALUE src)
    it up after this (an ivar, a lift that moves it onto another parent), and
    writes through it are refused by ca_is_readonly, which walks to the
    frozen root and finds CA_FLAG_READ_ONLY there. */
+static void
+ca_note_view_of_lent (CArray *p)
+{
+  if ( ca_test_flag(p, CA_FLAG_LENT) ) {
+    ca_set_flag(p, CA_FLAG_LENT_VIEWED);
+  }
+}
+
 VALUE
 rb_ca_set_parent (VALUE self, VALUE obj)
 {
   rb_ivar_set(self, id_parent, obj);
+  /* A view of an array lent to a CAObject hook outlives the hook: tell the
+     array, so that it keeps its cells when the hook returns.  A view of
+     several arrays names one here and holds the rest in parents[]. */
+  if ( rb_obj_is_carray(obj) ) {
+    ca_note_view_of_lent((CArray *) DATA_PTR(obj));
+  }
+  if ( rb_obj_is_carray(self) ) {
+    CArray *ca = (CArray *) DATA_PTR(self);
+    if ( ca_test_flag(ca, CA_FLAG_MULTI_PARENTS) ) {
+      CAMultiParent *mp = (CAMultiParent *) ca;
+      int32_t k;
+      for ( k = 0; k < mp->n_parents; k++ ) {
+        ca_note_view_of_lent(mp->parents[k]);
+      }
+    }
+  }
   return obj;
 }