carray 3.0.0 → 3.0.1

data/ext/carray_operator.c

@@ -12,6 +12,22 @@
 
 #include "carray.h"
 #include "carray_internal.h"   /* ca_lazy_arena_* */
+
+/* Operand scratch for a chunked / gathered kernel run.
+
+   For CA_OBJECT the scratch holds VALUEs, and an object-lane kernel
+   calls rb_funcall per cell -- a collection in the middle would free
+   whatever the gather pulled in from a lazy operand, since those cells
+   exist nowhere else.  The object form of the arena acquire keeps the
+   slot marked until it is released. */
+static void *
+ca_op_acquire_operand_scratch (CArray *ca, ca_size_t n_elements)
+{
+  return ( ca->data_type == CA_OBJECT )
+           ? ca_lazy_arena_acquire_object(n_elements)
+           : ca_lazy_arena_acquire(n_elements * ca->bytes);
+}
+
 #include "ca_obj_face.h"   /* ca_face_reconcile_comparison (comparison Face gate) */
 
 VALUE rb_mCAMath;
@@ -324,8 +340,6 @@ rb_ca_call_monop (VALUE self, ca_monop_func_t func[])
     }
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self, out);
-
   return out;
 }
 
@@ -479,8 +493,6 @@ rb_ca_call_monop_typed (VALUE self, ca_monop_func_t func[],
     }
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self, out);
-
   return out;
 }
 
@@ -543,7 +555,7 @@ kleene_gather_bool (CArray *ca, boolean8_t *vbuf, boolean8_t *mbuf, ca_size_t n)
    undetermined cells (U|U, U&U, U|F, U&T) keep the blind mask.  All other
    cells were already correct from the value kernel.
 
-   Gate: boolean dtype + output has a mask (else no-op -- the hot path is
+   Gate: boolean data type + output has a mask (else no-op -- the hot path is
    untouched, integer bitwise stays blind).  `out` is a fresh entity, so
    out->ptr / out->mask->ptr are writable without attach. */
 VALUE
@@ -870,8 +882,6 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
           }
         }
 
-        out = rb_ca_rewrap_unbound_repeat(self, out);
-        out = rb_ca_rewrap_unbound_repeat(other, out);
         return out;
       }
       /* else fall through to the use_chunked / ALLOCV path */
@@ -907,8 +917,6 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
       if ( a2 ) { ca_detach(ca2); } else { ALLOCV_END(h2); }
       if ( a1 ) { ca_detach(ca1); } else { ALLOCV_END(h1); }
 
-      out = rb_ca_rewrap_unbound_repeat(self, out);
-      out = rb_ca_rewrap_unbound_repeat(other, out);
       return out;
     }
 
@@ -936,7 +944,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
         p1_src = (char *) ca1->ptr;
         attached1 = 1;
       } else {
-        s1_arena = ca_lazy_arena_acquire(ca1->bytes);
+        s1_arena = ca_op_acquire_operand_scratch(ca1, 1);
         ca_xfer_all(ca1, s1_arena, CA_XFER_GET);
         p1_src = (char *) s1_arena;
       }
@@ -945,7 +953,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
       p1_src = (char *) ca1->ptr;
       attached1 = 1;
     } else {
-      s1_arena = ca_lazy_arena_acquire(chunk_n * ca1->bytes);
+      s1_arena = ca_op_acquire_operand_scratch(ca1, chunk_n);
       p1_src = (char *) s1_arena;
       gather_per_chunk1 = 1;
     }
@@ -957,7 +965,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
         p2_src = (char *) ca2->ptr;
         attached2 = 1;
       } else {
-        s2_arena = ca_lazy_arena_acquire(ca2->bytes);
+        s2_arena = ca_op_acquire_operand_scratch(ca2, 1);
         ca_xfer_all(ca2, s2_arena, CA_XFER_GET);
         p2_src = (char *) s2_arena;
       }
@@ -966,7 +974,7 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
       p2_src = (char *) ca2->ptr;
       attached2 = 1;
     } else {
-      s2_arena = ca_lazy_arena_acquire(chunk_n * ca2->bytes);
+      s2_arena = ca_op_acquire_operand_scratch(ca2, chunk_n);
       p2_src = (char *) s2_arena;
       gather_per_chunk2 = 1;
     }
@@ -1005,10 +1013,6 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
     ca_lazy_arena_exit();
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self, out);
-
-  out = rb_ca_rewrap_unbound_repeat(other, out);
-
   return out;
 }
 
@@ -1035,13 +1039,13 @@ rb_ca_call_binop_bang (VALUE self, VALUE other, ca_binop_func_t func[])
   self_is_scalar  = RTEST(rb_obj_is_cscalar(self));
   other_is_scalar = RTEST(rb_obj_is_cscalar(other));
 
-  /* shape compat: non-scalar self vs non-scalar other → elements must match.
-     scalar self vs array other historically raises (mismatch). */
-  if ( !self_is_scalar && !other_is_scalar &&
-       ca1->elements != ca2->elements ) {
-    rb_raise(rb_eRuntimeError, "elements mismatch in binop (%" PRId64 " <-> %" PRId64 ")",
-                               (ca_size_t) ca1->elements,
-                               (ca_size_t) ca2->elements);
+  /* self is the write target, so its shape is the result's by definition
+     and the destination rule applies (the same one assignment uses), not
+     the symmetric one a binary operation is held to. */
+  if ( !self_is_scalar && !other_is_scalar ) {
+    ca_broadcast_to_destination(self, &other);
+    TypedData_Get_Struct(other, CArray, &carray_data_type, ca2);
+    other_is_scalar = RTEST(rb_obj_is_cscalar(other));
   }
   if ( self_is_scalar && !other_is_scalar &&
        ca1->elements != ca2->elements ) {
@@ -1291,14 +1295,14 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
         if ( ca_attach_is_alias(ca1) ) {
           ca_attach(ca1);  p1_src = (char *) ca1->ptr;  att1 = 1;
         } else {
-          s1_arena = ca_lazy_arena_acquire(ca1->bytes);
+          s1_arena = ca_op_acquire_operand_scratch(ca1, 1);
           ca_xfer_all(ca1, s1_arena, CA_XFER_GET);
           p1_src = (char *) s1_arena;
         }
       } else if ( ca_attach_is_alias(ca1) ) {
         ca_attach(ca1);  p1_src = (char *) ca1->ptr;  att1 = 1;
       } else {
-        s1_arena = ca_lazy_arena_acquire(chunk_n * ca1->bytes);
+        s1_arena = ca_op_acquire_operand_scratch(ca1, chunk_n);
         p1_src = (char *) s1_arena;  gpc1 = 1;
       }
       /* ca2 acquire (mirror) */
@@ -1306,14 +1310,14 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
         if ( ca_attach_is_alias(ca2) ) {
           ca_attach(ca2);  p2_src = (char *) ca2->ptr;  att2 = 1;
         } else {
-          s2_arena = ca_lazy_arena_acquire(ca2->bytes);
+          s2_arena = ca_op_acquire_operand_scratch(ca2, 1);
           ca_xfer_all(ca2, s2_arena, CA_XFER_GET);
           p2_src = (char *) s2_arena;
         }
       } else if ( ca_attach_is_alias(ca2) ) {
         ca_attach(ca2);  p2_src = (char *) ca2->ptr;  att2 = 1;
       } else {
-        s2_arena = ca_lazy_arena_acquire(chunk_n * ca2->bytes);
+        s2_arena = ca_op_acquire_operand_scratch(ca2, chunk_n);
         p2_src = (char *) s2_arena;  gpc2 = 1;
       }
       /* ca3 acquire (mirror) */
@@ -1321,14 +1325,14 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
         if ( ca_attach_is_alias(ca3) ) {
           ca_attach(ca3);  p3_src = (char *) ca3->ptr;  att3 = 1;
         } else {
-          s3_arena = ca_lazy_arena_acquire(ca3->bytes);
+          s3_arena = ca_op_acquire_operand_scratch(ca3, 1);
           ca_xfer_all(ca3, s3_arena, CA_XFER_GET);
           p3_src = (char *) s3_arena;
         }
       } else if ( ca_attach_is_alias(ca3) ) {
         ca_attach(ca3);  p3_src = (char *) ca3->ptr;  att3 = 1;
       } else {
-        s3_arena = ca_lazy_arena_acquire(chunk_n * ca3->bytes);
+        s3_arena = ca_op_acquire_operand_scratch(ca3, chunk_n);
         p3_src = (char *) s3_arena;  gpc3 = 1;
       }
 
@@ -1367,10 +1371,6 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
     }
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self,   out);
-  out = rb_ca_rewrap_unbound_repeat(other2, out);
-  out = rb_ca_rewrap_unbound_repeat(other3, out);
-
   return out;
 }
 
@@ -1392,14 +1392,15 @@ rb_ca_call_triop_bang (VALUE self, VALUE other2, VALUE other3,
   TypedData_Get_Struct(other2, CArray, &carray_data_type, ca2);
   TypedData_Get_Struct(other3, CArray, &carray_data_type, ca3);
 
-  /* element-count check (self is the destination)                       */
-  if ( ! rb_obj_is_cscalar(other2) && ca2->elements != ca1->elements ) {
-    rb_raise(rb_eRuntimeError, "elements mismatch in triop! (op2: %" PRId64 " != %" PRId64 ")",
-             (ca_size_t) ca2->elements, (ca_size_t) ca1->elements);
+  /* self is the write target, so the destination rule applies to each
+     input operand in turn (the same one assignment uses). */
+  if ( ! rb_obj_is_cscalar(other2) ) {
+    ca_broadcast_to_destination(self, &other2);
+    TypedData_Get_Struct(other2, CArray, &carray_data_type, ca2);
   }
-  if ( ! rb_obj_is_cscalar(other3) && ca3->elements != ca1->elements ) {
-    rb_raise(rb_eRuntimeError, "elements mismatch in triop! (op3: %" PRId64 " != %" PRId64 ")",
-             (ca_size_t) ca3->elements, (ca_size_t) ca1->elements);
+  if ( ! rb_obj_is_cscalar(other3) ) {
+    ca_broadcast_to_destination(self, &other3);
+    TypedData_Get_Struct(other3, CArray, &carray_data_type, ca3);
   }
 
   /* self IS the output (= write target; attach legit per refined invariant) */
@@ -1462,8 +1463,8 @@ rb_ca_call_triop_bang (VALUE self, VALUE other2, VALUE other3,
       }
 
       ca_lazy_arena_enter();
-      s2_arena = ca_lazy_arena_acquire(chunk_n * ca2->bytes);
-      s3_arena = ca_lazy_arena_acquire(chunk_n * ca3->bytes);
+      s2_arena = ca_op_acquire_operand_scratch(ca2, chunk_n);
+      s3_arena = ca_op_acquire_operand_scratch(ca3, chunk_n);
 
       for ( off = 0; off < n_total; off += chunk_n ) {
         ca_size_t n_done = (off + chunk_n > n_total) ? n_total - off
@@ -1535,8 +1536,6 @@ rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[])
     EAGER_RELEASE_INPUT(ca1, h1, attached1);
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self, out);
-
   return out;
 }
 
@@ -1683,8 +1682,8 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
         }
 
         ca_lazy_arena_enter();
-        s1_arena = ca_lazy_arena_acquire(chunk_n * b1);
-        s2_arena = ca_lazy_arena_acquire(chunk_n * b2);
+        s1_arena = ca_op_acquire_operand_scratch(ca1, chunk_n);
+        s2_arena = ca_op_acquire_operand_scratch(ca2, chunk_n);
 
         for ( off = 0; off < n_kernel; off += chunk_n ) {
           ca_size_t n_done = (off + chunk_n > n_kernel) ? n_kernel - off
@@ -1708,8 +1707,6 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
     }
   }
 
-  out = rb_ca_rewrap_unbound_repeat(self, out);
-
   return out;
 }
 

data/ext/carray_partition.c

@@ -41,7 +41,7 @@ extern VALUE rb_ca_partition_addr_ki_mp (VALUE self, VALUE vaxis, VALUE vkth, in
  * Comparator-based dispatch keeps this routine data_type-generic (used
  * by the CA_FIXLEN partition_copy path); the mkkernel-generated
  * partition_index_quickselect_* functions inline the comparator per
- * dtype for the numeric paths.
+ * data type for the numeric paths.
  *
  * `swap_tmp` and `pivot` must be caller-provided scratch buffers of size
  * `bytes` (used for cell swaps via memcpy; avoids alloca / per-swap
@@ -222,7 +222,7 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
   CArray *cao;
   TypedData_Get_Struct(vout, CArray, &carray_data_type, cao);
 
-  /* Numeric path: per-dtype quickselect with inline cmp via the typed
+  /* Numeric path: per-type quickselect with inline cmp via the typed
      ca_partition_quick_* kernels (avoids the function-pointer
      indirection of the comparator-based ca_quickselect_bytes).
      Float NaN policy = pre-partition NaN to tail (same convention as
@@ -271,7 +271,7 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
 
 /* masked_position: -aware twin of {rb_ca_partition_copy_c}.  Masked
  * cells are an incomparable sentinel (same role NaN plays for float
- * dtypes): unmasked input takes the fast rb_ca_partition_copy_c path
+ * data types): unmasked input takes the fast rb_ca_partition_copy_c path
  * unchanged; masked input delegates to {partition} (which handles the
  * masked_position split via partition_addr_ki_mp) + copy, mirroring the
  * CA_FIXLEN / CA_OBJECT delegation pattern already used by sort_copy.
@@ -381,7 +381,7 @@ rb_ca_partitioned_view (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   /* CA_FIXLEN flows through the same partition_addr_ki fixlen dialect
-     as numeric; masked_position: applies uniformly across dtypes. */
+     as numeric; masked_position: applies uniformly across data types. */
   VALUE target = self;
 
   /* partition_addr_ki_mp validates axis + kth, splits masked cells to

data/ext/carray_random.c

@@ -9,7 +9,7 @@
   (rb_random_*).
 
   Dispatch:
-    random!       -> uniform fill (per-dtype branch below)
+    random!       -> uniform fill (per-type branch below)
     randomn!      -> standard normal via Box-Muller (float / complex only)
     shuffle!      -> Fisher-Yates over the flat buffer, or per-slice
                      when axis: is given (byte-chunk swap)
@@ -109,13 +109,13 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
   }
 
   /* Materialize (low, high) as the correct scalar type and validate.
-   * For integer dtypes, `..` closed adds 1 to high (turns into half-open
-   * for the sampler); for float dtypes, closed and half-open are
+   * For integer data types, `..` closed adds 1 to high (turns into half-open
+   * for the sampler); for float data types, closed and half-open are
    * equivalent so no adjustment. */
   if (!is_default) {
-    int is_integer_dtype = (ca->data_type >= CA_INT8
+    int is_integer_type = (ca->data_type >= CA_INT8
                             && ca->data_type <= CA_UINT64);
-    if (is_integer_dtype) {
+    if (is_integer_type) {
       low_long  = NUM2LONG(low_val);
       high_long = NUM2LONG(high_val);
       if (high_is_closed) high_long += 1;
@@ -290,7 +290,7 @@ box_muller_pair(VALUE rng, double *r1, double *r2)
 /* CArray#randomn!(rng:) — fill self with standard normal N(0, 1)
  * samples in-place via Box-Muller, returning self.
  *
- * Restricted to float / complex dtypes.  Complex fills real + imag as
+ * Restricted to float / complex data types.  Complex fills real + imag as
  * two independent normals per cell. */
 static VALUE
 rb_ca_randomn_bang(int argc, VALUE *argv, VALUE self)
@@ -484,7 +484,7 @@ rb_ca_shuffle(int argc, VALUE *argv, VALUE self)
 /* ---- random (copy) ----------------------------------------------------- */
 
 /* CArray#random([low,] [high], rng:) — non-bang variant: return a
- * newly templated array filled uniformly.  Shape and dtype come from
+ * newly templated array filled uniformly.  Shape and data type come from
  * CArray#template, so the receiver is only consulted for those.
  * Accepts the same argument forms as {rb_ca_random_bang}. */
 static VALUE

data/ext/carray_scatter.c

@@ -9,7 +9,7 @@
     duplicates unbuffered (sequential) — collisions accumulate
     mask       pair skipped when any of addrs[i] / vals[i] / self[addrs[i]] is masked
     cast       vals silently cast to self.data_type
-    dtype      arithmetic (add / sub / mul / min / max): numeric only
+    data type      arithmetic (add / sub / mul / min / max): numeric only
                (boolean / object / fixlen → CADataTypeError; the bang
                cannot widen self, same rationale as fma! / fms!)
                replace: numeric or boolean (assignment, no widening)

data/ext/carray_sort.c

@@ -46,7 +46,7 @@ struct sort_addr_key {
 /* Multi-key comparator for CArray.sort_addr: compares keys in priority
  * order, original index breaks ties (stable).  Masked cells are an
  * incomparable sentinel clustered at base->masked_last's end (same
- * role NaN plays for float dtypes, and the same masked_position:
+ * role NaN plays for float data types, and the same masked_position:
  * contract as the sort/partition family's :sentinel kernel mode --
  * see MASKED_POSITION rev1 in mkkernel.rb's MkKernel.sort doc).
  *
@@ -531,7 +531,7 @@ rb_ca_axis2addr (int argc, VALUE *argv, VALUE self)
  *                       worst case.
  *
  * Mask handling: masked cells are an incomparable sentinel, the same
- * role NaN plays for float dtypes.  They are excluded from the value
+ * role NaN plays for float data types.  They are excluded from the value
  * comparison and clustered at one end of each fiber; masked_position:
  * picks which end (:last, default, or :first).  Relative order within
  * the masked cluster is unspecified (same contract as the < / > regions
@@ -678,7 +678,7 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   /* CA_FIXLEN and masked input: the per-fiber path below covers
-     unmasked numeric dtypes only.  Delegate to {sort} (which handles
+     unmasked numeric data types only.  Delegate to {sort} (which handles
      both the fixlen dialect and the masked_position split) + copy to
      get the same shape/class contract as the fast path. */
   if ( ca_is_fixlen_type(ca) || ca_has_mask(ca) ) {

data/ext/carray_sort_kernel.c

@@ -1,8 +1,8 @@
 /* ---------------------------------------------------------------------------
 
-   Portable textbook sort kernels: per-dtype quicksort + bottom-up
+   Portable textbook sort kernels: per-type quicksort + bottom-up
    mergesort with inline comparison (no function-pointer indirection
-   like libc qsort / mergesort).  All 10 numeric dtypes plus paired
+   like libc qsort / mergesort).  All 10 numeric data types plus paired
    forms for argsort.
 
    Internal C API only (no Ruby surface, no Init function).  Declared
@@ -12,13 +12,13 @@
 
    Algorithms:
 
-   * quicksort (ca_sort_quick_<dtype>)
+   * quicksort (ca_sort_quick_<type>)
        median-of-3 pivot, Hoare partition, strict `<`, insertion-sort
        base (threshold 16), smaller-side recursion / larger-side
        iterate (stack O(log n)).  Depth-limit escape to mergesort for
        worst-case O(n log n).
 
-   * mergesort (ca_sort_merge_<dtype>)
+   * mergesort (ca_sort_merge_<type>)
        Bottom-up, ping-pong (cur / next) per pass with no inter-pass
        memcpy.  Strict `<` (stable: equal -> take-left).  Insertion-
        sort pre-pass that converts the input into R=16-wide sorted
@@ -27,18 +27,18 @@
        skip the merge loop; no run-state machine, distinct from
        Timsort galloping).
 
-   * paired forms (ca_sort_quick_pair_<dtype> / ca_sort_merge_pair_<dtype>)
+   * paired forms (ca_sort_quick_pair_<type> / ca_sort_merge_pair_<type>)
        Same algorithms over (value, index) pairs for argsort
        (sort_index / sort_addr).  Stable tie-break by index is built
        into the comparison, so quicksort is effectively stable for
        argsort even though the algorithm itself is not.
 
-   * NaN partitioning (ca_partition_nan_<dtype> + _pair_<dtype>)
+   * NaN partitioning (ca_partition_nan_<type> + _pair_<type>)
        float32 / float64 only.  One-pass Hoare-style partition that
        separates `[finite | NaN]` regions so the downstream sort
        kernel can operate on the finite slice with plain `<`.
 
-   * value-level quickselect (ca_partition_quick_<dtype>)
+   * value-level quickselect (ca_partition_quick_<type>)
        median-of-3 + Hoare + insertion base + one-sided recursion
        into the side containing kth (quickselect property, expected
        O(n)).  Depth-limit escape to mergesort matches the sort
@@ -402,13 +402,13 @@ ca_sort_quick_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)              \
 struct ca_sort_pair_##SUFFIX##_eat_semicolon
 
 
-/* ===== Per-dtype instantiations ===========================================
+/* ===== Per-type instantiations ===========================================
    `<` is well-defined and IEEE-stable for all numeric C types used
    here; NaN handling for f32 / f64 lives in the pre-partition pass
    below. */
 
 /* ---------------------------------------------------------------------------
-   NaN pre-partition (float dtypes only).
+   NaN pre-partition (float data types only).
 
    One-pass Hoare-style partition that separates `a[0..n)` into
    `[finite | NaN]` regions in place, returning the finite count k
@@ -447,7 +447,7 @@ struct ca_partition_nan_##SUFFIX##_eat_semicolon
 DEFINE_PARTITION_NAN(float32_t, f32);
 DEFINE_PARTITION_NAN(double,    f64);
 
-/* Pair variant for argsort: separates ca_pair_<dtype> by
+/* Pair variant for argsort: separates ca_pair_<type> by
    isnan(v.value).  Returns the finite count.
 
    Stable within both finite and NaN regions (original order

data/ext/carray_test.c

@@ -4,7 +4,7 @@
     - internal check_* / has_same_* helpers used across ext/ sources
     - Ruby surface: valid_index? / valid_addr? / same_shape? / == /
       eql? / hash / freeze (docs in yard-stubs/carray_test.rb)
-    - per-dtype element-equality table `ca_eql[CA_NTYPE]`
+    - per-type element-equality table `ca_eql[CA_NTYPE]`
     - `ca_compare_common` shared body for `==` and `eql?`
 
 ---------------------------------------------------------------------------- */

data/ext/extconf.rb

@@ -63,6 +63,17 @@ end
 
 $CFLAGS += " -Wall"
 
+# --- the flags that decide the numbers
+#
+# Two compilations of the same C do not have to agree on the last bit: what
+# the compiler is allowed to fuse or reorder is decided by the flags it was
+# given.  Anything computing what these kernels compute, somewhere other
+# than in them, has to be built the same way to arrive at the same answer,
+# so the flags that bear on it are recorded and handed out as
+# CArray::BUILD_FLAGS.  Optimisation and architecture only -- warnings,
+# defines and link options change nothing about the arithmetic.
+$carray_build_flags = [RbConfig::CONFIG["optflags"].to_s.strip]
+
 # --- in-build flag (CARRAY_BUILD)
 #
 # Marks a translation unit as part of carray itself, i.e. recompiled whenever
@@ -121,6 +132,7 @@ simd_probe = <<~C
 C
 if try_compile(simd_probe, "-fopenmp-simd")
   $CFLAGS += " -fopenmp-simd"
+  $carray_build_flags << "-fopenmp-simd"
   $stderr.puts "carray: -fopenmp-simd enabled (SIMD reduction license)"
 end
 
@@ -151,11 +163,17 @@ if enable_config("march-native", default_on)
   arch_probe = "int main(void) { return 0; }\n"
   if try_compile(arch_probe, "-march=native")
     $CFLAGS += " -march=native"
+    $carray_build_flags << "-march=native"
     $stderr.puts "carray: -march=native enabled (build-machine ISA extensions)"
   else
     $stderr.puts "carray: -march=native probe FAILED, keeping baseline SIMD"
   end
 end
+File.write("carray_build_flags.h",
+           "/* GENERATED by extconf.rb: the flags this build's arithmetic\n" \
+           "   was compiled with.  See CArray::BUILD_FLAGS. */\n" \
+           "#define CA_BUILD_FLAGS #{$carray_build_flags.join(" ").inspect}\n")
+
 # $CFLAGS += " -m128bit-long-double"  ### gcc only
 # $CFLAGS += " -Wno-absolute-value"
 # $LDFLAGS += " -L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib"