carray 3.0.6 → 3.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7012a2c73c33e52e9b5dd18d5fd0e7c02b4c741bb650a41cefbfea117449da2f
-  data.tar.gz: 5731ca96689f1d87d9c4e1e6a4764893eac0e39f8126f91695b2042581ae198f
+  metadata.gz: dc1e09cd60b311255af53d363b340440aa899193bbe93cd314abc5211dcd81b2
+  data.tar.gz: 3cb15673d7396b64a4fe4ccfa5956862c96b8f7c772194adf4059aff5086c4eb
 SHA512:
-  metadata.gz: 1e05efbfc29639882cc08753c9394400abb707df063025a7ae5bfed6c006979721d8b0030ae17a4eab1397c89c7c3803bf9fa2ec62fa7aa9d8c56e1adb38bd79
-  data.tar.gz: 21baa2d1fac6d2c45a1ed47b4235e9f1832beb4063e93491743470ac77805c266210139d7af834ca1d014ec410ae43191228679a72004c14af6c2fa91eb88eba
+  metadata.gz: 8d1077b9d4602707efa889976e1d60908303d7525b5238faf090aa22dd5b21d7c3b5a534775c7290dd88aa7be0db1ad2472da4a6f73d8d75d5c9fdefafcf7cb5
+  data.tar.gz: 1715c2a8f1dcf6dc16439f2aedde45cae012d6a9cc1713f0b84ed8be1930d1e3114f41c3100c363888fbd8395feeedbf2f96eae7443dba2495cac85dab2fb04e

data/CHANGELOG.md

@@ -34,6 +34,116 @@ and a newer one. The 1.x history, up to the 2.0.0 release, is in
      neighbour ("as well", "the producer above") or leave unnamed the
      method, class or keyword it is about. -->
 
+## 3.0.7
+
+- New: `CATime` and `CATimedelta` take the word forms of their operators
+  (`add`, `sub`; on a duration also `mul`, `div`, `neg`). A duration array
+  divided by one duration gives the ratios as numbers, a number may stand
+  left of a duration (`2 * d`), a duration element has `-@` and `abs`, and
+  a duration array has `to_seconds`. A duration's comparisons and stores
+  take a String such as `"3 days"`.
+
+- New: `pmax` and `pmin` (with `maximum`, `minimum`, `fmax`, `fmin`) on
+  `CATimedelta`, `CAFixlenString` and `CAConstString`. `CAConstString`
+  also has `match`, `bsearch`, `bsearch_addr`, `search_addr`, `min_addr`
+  and `max_addr`.
+
+- New: a `CAFixlenString` carries the encoding of its text
+  (`a.encoding`), and its cells read in that encoding: UTF-8 when the
+  strings were ASCII, `BINARY` when they disagreed. `to_const_string`
+  keeps it, so non-ASCII text comes back from `to_fixlen_string`. Two
+  arrays of different text encodings no longer stack.
+
+- New: `CAFrame#resample` takes a `CArray` as `by:`, and a windowed
+  reduction takes a Hash of column name to value as `fill_value:`.
+  `CACategorical#count` takes the keywords of `CArray#count`, and the
+  `all` and `any` of a categorical iterator take `axis:`.
+
+- New: `CArray.from_memory_view` and `wrap_memory_view` take an item of
+  several members (a record) as raw bytes, a `fixlen` array of the item's
+  size.
+
+- Change: a Float is refused as a shape, a size or a count
+  (`CArray.int32(2.5)`, `blocks(2.5)`, the counts of `repeat`), whole or
+  not; it was cut down to an Integer. A Float key of `[]` still reads as a
+  position.
+
+- Change: a data type name must match whole. `:complex128`, `:float16` or
+  `:int128` raise `ArgumentError`; they were read as the type whose name
+  they begin with (`:complex128` gave `cmplx64`). Write `:cmplx128`.
+  `CArray::Complex64::TypeSymbol` and `CArray::Complex128::TypeSymbol` are
+  `:cmplx64` and `:cmplx128`.
+
+- Change: a keyword given with a String key (`a.sum("axis" => 0)`) raises
+  `ArgumentError`; it was ignored. Write `axis: 0`.
+
+- Change: storing complex cells into a real array raises; the imaginary
+  parts were dropped. Convert with `to_type` first.
+
+- Change: an object or boolean array given where addresses are expected
+  (`project`, `scatter_add!` and the other `scatter_*!`, `addr2index`)
+  raises `IndexError`. A boolean array still selects in `[]`.
+
+- Change: a value a numeric or boolean array cannot hold (`nil`, a String,
+  a Symbol, another object) is answered alike for every data type: an
+  operator raises `TypeError`, an ordering (`<`, `pmax` and its kin)
+  raises `ArgumentError`, and `eq`, `ne`, `count`, `search` and `is_in`
+  find no cell. `search("2")` on a numeric array used to read the text.
+  `true` and `false` are 1 and 0, so `count(true)` counts the cells
+  holding 1. An object array still looks such values up as values.
+
+- Change: `UNDEF` beside an array in an operation is a masked scalar of the
+  array's own type, so `CA_INT32([1, 2]) + UNDEF` is an all-masked `int32`
+  array; integer, boolean and fixlen arrays gave an object array.
+
+- Change: `to_type` to an integer type gives `UNDEF` for an object Float,
+  Rational, BigDecimal or Complex the type cannot hold, and keeps the low
+  bytes of an object Integer wider than 64 bits, as `int64` to `int8` does.
+  A store and a view still refuse such values.
+
+- Change: `x ** k` with an Integer `k` from -2 to 4 is computed by at most
+  two multiplications or divisions (`x ** 2` is `x * x`), and other Integer
+  exponents through `pow`, for a scalar and an array exponent alike,
+  eagerly and lazily. Float and complex results can differ from 3.0.6 in
+  the last bit.
+
+- Change: a time or a date with a year past four digits is written with
+  its sign (`"+12345-01-01"`), in `to_s` and in CSV, so it reads back.
+
+- Change: `join`, `join_asof`, `align`, `CAFrame.concatenate`, `stack` and
+  `stack_columns` refuse integers that the float type they meet would
+  round (past 2**53 beside `float64`), in a key or in the pieces of a
+  column; such integers matched or merged with neighbouring values. Cast
+  one side to the other's type first.
+
+- Change: the frames that `GroupedFrame`, the windows and a frame's own
+  verbs return hold a copy of the index, so a write to the result's index
+  does not reach the source frame.
+
+- Change: `CAFrame` refuses, with an `ArgumentError` that names the verb,
+  a `GroupedFrame#table` or `#filter` without a block, a `lag` step that is
+  not an Integer, a `columns:` Range that selects no column, a
+  `fill_value:` Hash naming no column, a row-wise group verb with no column
+  left to compute, and a splice of a frame without an index into one with
+  an index.
+
+- Change: CSV type inference reads a column as text when a float would
+  round one of its integers, and an object column of Integers past 2**53
+  beside a Float is not inferred as `float64`.
+
+- Change: a walk into object cells (`unique`, `hash`, `Marshal.dump`,
+  computations over the cells) raises past 256 levels of nesting. A cell
+  holding a lazy expression over the array that holds the cell made these
+  run without end.
+
+- Change: a String Face (`CAString`, `CAFixlenString`, `CAConstString`)
+  refuses an ordering with a value that is not a String, and a Face
+  refuses a single Ruby object as the operand of an operator the Face does
+  not define.
+
+- Change (C extensions and carray-jit): `CArray::AddressBasis.sweep` and
+  the sweep bridge refuse a `CScalar` output beside an array operand.
+
 ## 3.0.6
 
 - New: `CAFrame` answers the column reductions itself, as a frame of one

data/README.md

@@ -109,18 +109,39 @@ b.strip_mask(Float::NAN).sum(axis: 0)
 
 ## Documentation
 
+#### Basics
+
 * [Introduction](guides/users/introduction.md) — what Ruby/CArray is
 * [Getting started](guides/users/00_getting_started.md) — install, and a first array
 * [Creating arrays](guides/users/01_creating_arrays.md) — constructors, data types, filling
 * [Indexing and slicing](guides/users/02_indexing_and_slicing.md) — elements, rows, blocks, conditions
-* [Indexer reference](guides/users/16_indexer_reference.md) — every form `[]` accepts
 * [Element-wise operations](guides/users/03_elementwise.md) — arithmetic and mathematical functions
-* [Broadcasting](guides/users/07_broadcasting.md) — shapes that differ
-* [Views](guides/users/06_views.md) — referring to data without copying
 * [Reduction and statistics](guides/users/04_reduction_and_statistics.md) — summaries, whole or per axis
 * [Masks and missing values](guides/users/05_masks.md) — undefined elements, and how calculations treat them
+* [Views](guides/users/06_views.md) — referring to data without copying
+* [Broadcasting](guides/users/07_broadcasting.md) — shapes that differ
+
+#### Using arrays
+
+* [Indexer reference](guides/users/16_indexer_reference.md) — every form `[]` accepts
+
+#### Data that is not plain numbers
+
+* [Object arrays](guides/users/13_object_arrays.md) — arrays whose cells hold Ruby objects
+* [Faces](guides/users/12_faces.md) — arrays that read their data as times, categories or strings
+
+#### Processing along axes
+
+* [Slab iteration](guides/users/11_slab_iteration.md) — running a Ruby block on each slab along an axis
+
+#### Data frames
+
 * [Data frames](guides/dataframe/README.md) — tables of named columns, each column a CArray
 
+#### Appendix
+
+* [Vocabulary](guides/users/08_vocabulary.md) — the terms used in these documents
+
 ## Contributing
 
 Bug reports and feature requests are welcome — please open an issue.

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "carray"
-  s.version     = "3.0.6"
+  s.version     = "3.0.7"
   s.authors      = ["himotoyoshi"]
   s.email       = ["himotoyoshi@users.noreply.github.com"]
   s.summary     = "Multi-dimensional numerical array class for Ruby"

data/ext/ca_axis_group.c

@@ -377,8 +377,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     ca_size_t k  = (ca_size_t) NUM2LONG(RARRAY_AREF(bundle, 1));
     VALUE vbaxes = RARRAY_AREF(bundle, 2);
     Check_Type(vbaxes, T_ARRAY);
-    if ( k <= 0 ) {
-      rb_raise(rb_eArgError, "axis_group_reduce: bundle k must be positive");
+    if ( k < 0 ) {
+      rb_raise(rb_eArgError, "axis_group_reduce: bundle k must not be negative");
     }
 
     /* The code table is copied out and the source let go of at once, rather
@@ -390,7 +390,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        that the unwind collects. Not a String: a String held only by `keep`
        can be moved by compaction, taking the bytes under bundle_codes with
        it. */
-    VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
+    volatile VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
     h_codes[bi] = 0;
@@ -1212,8 +1212,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     ca_size_t k  = (ca_size_t) NUM2LONG(RARRAY_AREF(bundle, 1));
     VALUE vbaxes = RARRAY_AREF(bundle, 2);
     Check_Type(vbaxes, T_ARRAY);
-    if ( k <= 0 ) {
-      rb_raise(rb_eArgError, "axis_group_scan: bundle k must be positive");
+    if ( k < 0 ) {
+      rb_raise(rb_eArgError, "axis_group_scan: bundle k must not be negative");
     }
 
     /* The code table is copied out and the source let go of at once, rather
@@ -1225,7 +1225,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        that the unwind collects. Not a String: a String held only by `keep`
        can be moved by compaction, taking the bytes under bundle_codes with
        it. */
-    VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
+    volatile VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
     h_codes[bi] = 0;

data/ext/ca_binop_dispatch.c

@@ -79,6 +79,14 @@ ca_binop_op_id_of_table (ca_binop_func_t table[])
   return -1;
 }
 
+/* pmax, pmin, maximum and minimum pick one operand by order. */
+int
+ca_binop_picks_by_order (int op_id)
+{
+  return op_id == CA_BINOP_PMAX    || op_id == CA_BINOP_PMIN ||
+         op_id == CA_BINOP_MAXIMUM || op_id == CA_BINOP_MINIMUM;
+}
+
 /* ------------------------------------------------------------------- */
 /* output data_type rule                                                    */
 /* ------------------------------------------------------------------- */

data/ext/ca_binop_dispatch.h

@@ -148,5 +148,6 @@ void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
    a slab mask to the kernel so masked cells are skipped (otherwise
    masked-zero divisors crash with SIGFPE).  See §3.4 rev3.            */
 int ca_binop_op_id_of_table (ca_binop_func_t table[]);
+int ca_binop_picks_by_order (int op_id);
 
 #endif /* CA_BINOP_DISPATCH_H */

data/ext/ca_categorical_iterator.c

@@ -46,7 +46,7 @@
   } while (0)
 
 static VALUE
-rb_ca_addresses_by_category (VALUE self, VALUE rcursor, VALUE rk, VALUE rnvalid)
+rb_ca_addresses_by_category (VALUE self, volatile VALUE rcursor, VALUE rk, VALUE rnvalid)
 {
   CArray     *codes, *cursor, *result;
   VALUE       rresult;
@@ -264,7 +264,7 @@ rb_ca_addresses_by_category (VALUE self, VALUE rcursor, VALUE rk, VALUE rnvalid)
 
 static VALUE
 rb_ca_reduceat_moments (VALUE self, VALUE roffsets, VALUE rcounts,
-                        VALUE rsums, VALUE rmins, VALUE rmaxs)
+                        VALUE rsums, volatile VALUE rmins, volatile VALUE rmaxs)
 {
   CArray     *grouped, *offsets, *counts, *sums, *mins, *maxs;
   int64_t     k, *offs, *countp;
@@ -397,7 +397,7 @@ ca_nth_element_double (double *a, ca_size_t n, ca_size_t kth)
   } while (0)
 
 static VALUE
-rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
+rb_ca_reduceat_percentile (VALUE self, volatile VALUE roffsets, VALUE rp, volatile VALUE rout)
 {
   CArray     *grouped, *offsets, *out;
   int64_t     k, *offs;
@@ -503,7 +503,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
 
 static VALUE
 rb_ca_reduceat_variance (VALUE self, VALUE roffsets, VALUE rmeans,
-                         VALUE rcounts, VALUE rout, VALUE rddof)
+                         VALUE rcounts, volatile VALUE rout, VALUE rddof)
 {
   int64_t     ddof = NUM2LL(rddof);
   CArray     *grouped, *offsets, *means, *counts, *out;
@@ -649,7 +649,7 @@ rb_ca_reduceat_prod (VALUE self, VALUE roffsets, VALUE rout)
   } while (0)
 
 static VALUE
-rb_ca_reduceat_argminmax (VALUE self, VALUE roffsets, VALUE rminidx, VALUE rmaxidx)
+rb_ca_reduceat_argminmax (VALUE self, VALUE roffsets, volatile VALUE rminidx, volatile VALUE rmaxidx)
 {
   CArray     *grouped, *offsets, *minidx, *maxidx;
   int64_t     k, *offs, *minp, *maxp;
@@ -871,8 +871,8 @@ rb_ca_reduceat_quantile (VALUE self, VALUE roffsets, VALUE rp0, VALUE rp25,
   } while (0)
 
 static VALUE
-rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, VALUE rwg,
-                           VALUE rwsum, VALUE rwmean)
+rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, volatile VALUE rwg,
+                           VALUE rwsum, volatile VALUE rwmean)
 {
   CArray     *grouped, *offsets, *wg, *wsum, *wmean;
   int64_t     k, *offs;

data/ext/ca_kernel_iterator.h

@@ -1792,10 +1792,12 @@ ca_slab_is_flat (const ca_iter_state *st, const ca_size_t *strides,
  * producing the value to reduce (typically `((ACC_T)(x))`), so the
  * caller controls the per-src cast without embedding it in a REDUCE
  * statement.  Reassoc across the 8 lanes is the same ε-close license
- * as _MIN_EX / _MAX_EX / _STAR_EX (bit-exact not guaranteed; min/max
- * are strictly associative + commutative so the 8-way tree gives the
- * same result modulo NaN handling which stays identical to the
- * single-accumulator case).
+ * as _MIN_EX / _MAX_EX / _STAR_EX (bit-exact not guaranteed).  min / max
+ * pick the same value as the single-accumulator walk, and handle NaN
+ * alike, but of two values equal under `<` (0.0 and -0.0) the one kept
+ * depends on the lane it fell in: the sign of a zero answer can differ
+ * from the single-accumulator walk and between a contiguous and a
+ * strided fiber.  Which of the two min / max answers is not specified.
  */
 #define CA_SLAB_REDUCE_MIN8_EX(T, ACC_T, st, p, m, acc, INIT, EXPR, masked_cnt) do { \
     typedef T __ca_u_T CA_UNALIGNED;                                         \

data/ext/ca_obj_array.c

@@ -958,7 +958,7 @@ ca_scan_construct_args (int argc, VALUE *argv, int8_t *data_type,
   CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));     /* before dim[] is filled */
   *ndim = RARRAY_LEN(rdim);
   for (i=0; i<*ndim; i++) {
-    dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
+    dim[i] = ca_integer_arg(rb_ary_entry(rdim, i), "a dimension", NULL);
   }
 }
 
@@ -1244,7 +1244,7 @@ rb_ca_initialize_copy (VALUE self, VALUE other)
    a copy of a mask is still a mask (its class, CArrayMask, says so) and
    can no more hold a mask of its own than the original. */
 static void
-ca_dup_keep_state (VALUE self, VALUE other)
+ca_dup_keep_state (VALUE self, volatile VALUE other)
 {
   CArray *ca, *cs;
   if ( ! rb_obj_is_kind_of(other, rb_cCArray) ) {
@@ -1356,7 +1356,7 @@ rb_ca_s_wrap (int argc, VALUE *argv, VALUE self)
   CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));     /* before dim[] is filled */
   ndim = RARRAY_LEN(rdim);
   for (i=0; i<ndim; i++) {
-    dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
+    dim[i] = ca_integer_arg(rb_ary_entry(rdim, i), "a dimension", NULL);
   }
 
   target = rb_yield_values(0);
@@ -1661,7 +1661,7 @@ rb_ca_s_alloc_uninit (VALUE klass, VALUE rtype, VALUE rshape)
   Check_Type(rshape, T_ARRAY);
   CA_CHECK_RANK_GIVEN(RARRAY_LEN(rshape));   /* before dim[] is filled */
   ndim = (int8_t) RARRAY_LEN(rshape);
-  for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rshape, i));
+  for (i = 0; i < ndim; i++) dim[i] = ca_integer_arg(rb_ary_entry(rshape, i), "a dimension", NULL);
   return rb_carray_new(data_type, ndim, dim, bytes, NULL);
 }
 

data/ext/ca_obj_bincmp.c

@@ -142,7 +142,7 @@ ca_bincmp_setup (CABinCmp *ca, CArray *left, CArray *right, uint16_t op_id,
   ca->nosync    = 0;
   ca->right     = right;
   ca->op_id     = op_id;
-  ca->right_is_scalar = ( right->elements == 1 && left->elements > 1 ) ? 1 : 0;
+  ca->right_is_scalar = ( right->elements == 1 ) ? 1 : 0;
   /* Builder has already cast both operands to common data_type.  */
   ca->common_dt = left->data_type;
   ca->sign_fix  = 0;
@@ -622,6 +622,7 @@ rb_ca_bincmp_build (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
 {
   CArray *l, *r;
   int8_t  l_in_dt, r_in_dt;
+  int     left_scalar;
   int     signed_side = 0;
   volatile VALUE l_resolved, r_resolved;
 
@@ -642,6 +643,20 @@ rb_ca_bincmp_build (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
     break;
   }
 
+  /* A value the array can not hold matches no cell in eq / ne, and an
+     ordering with it is refused, as the eager comparison answers. */
+  if ( ! rb_obj_is_carray(r_resolved) && rb_obj_is_carray(l_resolved) ) {
+    CArray *lc;
+    GetCArray(l_resolved, lc);
+    if ( ( op_id == CA_BINCMP_EQ || op_id == CA_BINCMP_NE ) &&
+         ca_query_matches_nothing(lc, r_resolved) ) {
+      return ca_bincmp_no_match(l_resolved, op_id == CA_BINCMP_NE);
+    }
+    if ( op_id <= CA_BINCMP_GE && ! ca_is_complex_type(lc) ) {
+      ca_refuse_foreign_order(r_resolved, l_resolved);
+    }
+  }
+
   /* A scalar beside the array (a Ruby value or a CScalar) is wrapped and
      promoted as the eager comparison does it. */
   if ( ! rb_obj_is_carray(l_resolved) || ! rb_obj_is_carray(r_resolved) ||
@@ -687,8 +702,9 @@ rb_ca_bincmp_build (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
   TypedData_Get_Struct(l_resolved, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_resolved, CArray, &carray_data_type, r);
 
-  if ( l->elements != r->elements ) {
-    if ( r->elements == 1 ) {
+  left_scalar = ca_is_scalar(l) && ! ca_is_scalar(r);
+  if ( l->elements != r->elements || left_scalar ) {
+    if ( r->elements == 1 && ! left_scalar ) {
       /* CScalar right: handled via right_is_scalar */
     }
     else if ( l->elements == 1 ) {

data/ext/ca_obj_binop.c

@@ -153,12 +153,13 @@ ca_binop_setup (CABinOp *ca, CArray *left, CArray *right, uint16_t op_id)
   ca->operands[1] = right;
   ca->parents     = ca->operands;
   ca->n_parents   = 2;
-  /* right_is_scalar fast path: when right holds a single element,
-     xfer_stride pulls only that cell into scratch and walks the
-     kernel with element-stride 0 (broadcast).  The symmetric
+  /* right_is_scalar: a right of one cell is pulled once and walked with
+     element-stride 0, also when left has one cell too -- a view over this
+     node can ask for that one cell several times, and a CScalar right has
+     fewer axes than the request.  The symmetric
      left_is_scalar case is currently handled by wrapping left in
      a broadcast view of right's shape (correct but slower). */
-  ca->right_is_scalar = ( right->elements == 1 && left->elements > 1 ) ? 1 : 0;
+  ca->right_is_scalar = ( right->elements == 1 ) ? 1 : 0;
 
   memcpy(ca->dim, left->dim, left->ndim * sizeof(ca_size_t));
 
@@ -454,9 +455,10 @@ ca_binop_func_fill_data (void *ap, void *ptr)
 
    Boolean AND / OR are three-valued (Kleene): a masked cell is resolved by
    the *known* side (`unknown | true = true`, `unknown & false = false`), so
-   it is NOT masked in the result.  The blind value the value kernel writes
-   is already correct on a resolved cell because the absorbing element (true
-   for OR, false for AND) dominates whatever sits on the masked side. */
+   it is NOT masked in the result.  The value the kernel writes is already
+   right on a resolved cell: the absorbing element (true for OR, false for
+   AND) decides it whatever byte sits on the masked side, and the boolean
+   OR kernel writes 1, not the OR of the bytes. */
 static void
 ca_binop_func_create_mask (void *ap)
 {
@@ -554,6 +556,7 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
 {
   CArray *l, *r;
   int8_t  l_in_dt, r_in_dt;
+  int     left_scalar;
   volatile VALUE l_resolved, r_resolved;
 
   /* Collapse markers on both sides. */
@@ -568,6 +571,22 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
      data_type the eager binop gives it, and the pair is promoted as the
      eager binop promotes it.  An integer power keeps its int64 exponent
      (ca_binop_kernel_input_data_types). */
+  if ( ! rb_obj_is_carray(r_resolved) && rb_obj_is_carray(l_resolved) &&
+       ca_binop_picks_by_order(op_id) ) {
+    CArray *lc;
+    GetCArray(l_resolved, lc);
+    /* a boolean array picks as its 0 / 1 int64 numbers */
+    if ( ca_binop_kernel_lookup_vv(op_id,
+           lc->data_type == CA_BOOLEAN ? CA_INT64 : lc->data_type)
+         != ca_binop_not_implement ) {
+      ca_refuse_foreign_order(r_resolved, l_resolved);
+    }
+    else {
+      /* an array the op is not defined for says so, whatever the operand */
+      ca_op_refuse_unimplemented(l_resolved, lc->data_type, rb_eCADataTypeError);
+    }
+  }
+
   if ( op_id != CA_BINOP_IPOWER &&
        ( ! rb_obj_is_carray(l_resolved) || ! rb_obj_is_carray(r_resolved) ||
          rb_obj_is_cscalar(l_resolved) || rb_obj_is_cscalar(r_resolved) ) ) {
@@ -633,14 +652,20 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
            op commutes (ADD / MUL / BIT_*).  Non-commutative +
            left scalar wraps left in a broadcast view of right's
            shape so the kernel sees matched shapes; cost is N
-           reads of the scalar cell with stride 0. */
-  if ( l->elements != r->elements ) {
-    if ( r->elements == 1 ) {
+           reads of the scalar cell with stride 0.
+       A left CScalar is taken here also beside a one-cell array, whose
+       shape is the answer's. */
+  left_scalar = ca_is_scalar(l) && ! ca_is_scalar(r);
+  if ( l->elements != r->elements || left_scalar ) {
+    if ( r->elements == 1 && ! left_scalar ) {
       /* CScalar-vs-array, right.  xfer_stride handles this with
          right_step = 0. */
     }
     else if ( l->elements == 1 ) {
-      int commutes = ( op_id == CA_BINOP_ADD     ||
+      /* An object cell answers an operator for itself, so which operand
+         receives it is part of the expression. */
+      int commutes = l->data_type != CA_OBJECT &&
+                     ( op_id == CA_BINOP_ADD     ||
                        op_id == CA_BINOP_MUL     ||
                        op_id == CA_BINOP_BIT_AND ||
                        op_id == CA_BINOP_BIT_OR  ||

data/ext/ca_obj_bitarray.c

@@ -399,16 +399,14 @@ static void
 ca_bitarray_func_allocate (void *ap)
 {
   CABitarray *ca = (CABitarray *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_bitarray_func_attach (void *ap)
 {
   CABitarray *ca = (CABitarray *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_bitarray_attach(ca);
 }
 

data/ext/ca_obj_bitfield.c

@@ -290,6 +290,90 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   return 0;
 }
 
+/* The bit field view whose cells `ca` is, of the same data type: ca itself,
+   or the bit field at the end of a chain of single-parent views that keep
+   the type (a slice, a grid, a mask selection of the field).  A view of
+   several parents (a stack or a meld) has one when every parent has a field
+   of the same width and sign beneath it, so that a value is kept the same
+   way whichever parent its cell lands in.  NULL when there is none. */
+CArray *
+ca_bitfield_beneath (CArray *ca)
+{
+  while ( ca && ! ca_is_entity(ca) ) {
+    CArray *parent;
+    if ( ca->obj_type == CA_OBJ_BITFIELD ) {
+      return ca;
+    }
+    if ( ca_test_flag(ca, CA_FLAG_MULTI_PARENTS) ) {
+      CAMultiParent *mp = (CAMultiParent *) ca;
+      CABitfield *first = NULL;
+      int32_t k;
+      for (k=0; k<mp->n_parents; k++) {
+        CArray *p = mp->parents[k];
+        CABitfield *f;
+        if ( ! p || p->data_type != ca->data_type ) {
+          return NULL;
+        }
+        f = (CABitfield *) ca_bitfield_beneath(p);
+        if ( ! f || ( first && ( f->bit_length != first->bit_length ||
+                                 f->sign_extend != first->sign_extend ) ) ) {
+          return NULL;
+        }
+        if ( ! first ) {
+          first = f;
+        }
+      }
+      return (CArray *) first;
+    }
+    parent = ((CAView *) ca)->parent;
+    if ( ! parent || parent->data_type != ca->data_type ) {
+      return NULL;
+    }
+    ca = parent;
+  }
+  return NULL;
+}
+
+/* A value stored into a field keeps its low `bits` bits, as the bits of a
+   wider integer written into the field would. */
+VALUE
+ca_integer_wrap_bits (VALUE v, int bits, int sign_extend)
+{
+  VALUE integer, modulus;
+  if ( RB_TYPE_P(v, T_STRING) ) {
+    int64_t x;
+    ca_decimal_string_store(v, CA_INT64, &x);
+    integer = LL2NUM(x);
+  }
+  else {
+    integer = RB_INTEGER_TYPE_P(v) ? v : rb_Integer(v);
+  }
+  if ( FIXNUM_P(integer) && bits < 62 ) {
+    long x = FIX2LONG(integer);
+    long m = 1L << bits;
+    x &= m - 1;
+    if ( sign_extend && x >= ( m >> 1 ) ) {
+      x -= m;
+    }
+    return LONG2FIX(x);
+  }
+  modulus = rb_funcall(INT2FIX(1), rb_intern("<<"), 1, INT2FIX(bits));
+  integer = rb_funcall(integer, '%', 1, modulus);
+  if ( sign_extend &&
+       RTEST(rb_funcall(rb_funcall(integer, '*', 1, INT2FIX(2)),
+                        rb_intern(">="), 1, modulus)) ) {
+    integer = rb_funcall(integer, '-', 1, modulus);
+  }
+  return integer;
+}
+
+VALUE
+ca_bitfield_wrap_integer (CArray *ca, VALUE v)
+{
+  CABitfield *cb = (CABitfield *) ca;
+  return ca_integer_wrap_bits(v, (int) cb->bit_length, cb->sign_extend);
+}
+
 CABitfield *
 ca_bitfield_new (CArray *parent, ca_size_t offset, ca_size_t bitlen,
                  int8_t data_type)
@@ -462,16 +546,14 @@ static void
 ca_bitfield_func_allocate (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_bitfield_func_attach (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_bitfield_attach(ca);
 }
 

data/ext/ca_obj_byte_swap.c

@@ -462,16 +462,14 @@ static void
 ca_byte_swap_func_allocate (void *ap)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_byte_swap_func_attach (void *ap)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   memcpy(ca->ptr, ca->parent->ptr, ca_length(ca));
   ca_byte_swap_apply(ca, ca->ptr);
 }