carray 2.0.1 → 3.0.1

data/ext/ca_bincmp_dispatch.c

@@ -0,0 +1,76 @@
+/* ---------------------------------------------------------------------------
+
+  CABinCmp dispatch: routes a bincmp op id (`CA_BINCMP_*`) to the
+  per-data_type kernel, and computes the input promotion type for the
+  two operands.
+
+  Sibling of ca_obj_bincmp.c (the CABinCmp view), ca_moncmp_dispatch.c
+  (unary counterpart), and ca_binop_dispatch.c (arithmetic binop
+  family).  Per-data_type kernel tables are declared in
+  ca_bincmp_dispatch.h.
+
+  The bincmp kernels assume both operands already share data_type.  The
+  CABinCmp builder inserts a CAMonOp(`:cast_<common>`) before reaching
+  CABinCmp so both operands arrive at the common (promoted) type.  Use
+  `ca_bincmp_kernel_input_data_types` to obtain that common type.
+
+  Dispatched ops (all kernels return CArray<:bool>):
+    CA_BINCMP_LT       -> ca_bincmp_lt       [dt]   ( <  )
+    CA_BINCMP_GT       -> ca_bincmp_gt       [dt]   ( >  )
+    CA_BINCMP_LE       -> ca_bincmp_le       [dt]   ( <= )
+    CA_BINCMP_GE       -> ca_bincmp_ge       [dt]   ( >= )
+    CA_BINCMP_EQ       -> ca_bincmp_eq       [dt]   ( == )
+    CA_BINCMP_NE       -> ca_bincmp_ne       [dt]   ( != )
+    CA_BINCMP_FEQ      -> ca_bincmp_feq      [dt]   (float equality with
+                                                     a built-in tolerance)
+    CA_BINCMP_IS_CLOSE -> ca_bincmp_is_close [dt]   (|a - b| <= tol)
+    CA_BINCMP_IS_EQUIV -> ca_bincmp_is_equiv [dt]   (is_close with
+                                                     relative tolerance)
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_bincmp_dispatch.h"
+
+/* ------------------------------------------------------------------- */
+/* bincmp kernel lookup                                                 */
+/* ------------------------------------------------------------------- */
+
+ca_bincmp_func_t
+ca_bincmp_kernel_lookup (uint16_t op_id, int8_t common_dt)
+{
+  switch (op_id) {
+    case CA_BINCMP_LT:       return ca_bincmp_lt       [common_dt];
+    case CA_BINCMP_GT:       return ca_bincmp_gt       [common_dt];
+    case CA_BINCMP_LE:       return ca_bincmp_le       [common_dt];
+    case CA_BINCMP_GE:       return ca_bincmp_ge       [common_dt];
+    case CA_BINCMP_EQ:       return ca_bincmp_eq       [common_dt];
+    case CA_BINCMP_NE:       return ca_bincmp_ne       [common_dt];
+    case CA_BINCMP_FEQ:      return ca_bincmp_feq      [common_dt];
+    case CA_BINCMP_IS_CLOSE: return ca_bincmp_is_close [common_dt];
+    case CA_BINCMP_IS_EQUIV: return ca_bincmp_is_equiv [common_dt];
+    default:                 return NULL;
+  }
+}
+
+/* ------------------------------------------------------------------- */
+/* Input promotion: both operands cast to common data_type before the   */
+/* kernel runs.  bincmp output is always boolean and independent of    */
+/* operand types.                                                       */
+/* ------------------------------------------------------------------- */
+
+int8_t
+ca_lazy_bincmp_promote (uint16_t op_id, int8_t l_dt, int8_t r_dt)
+{
+  (void) op_id;
+  return (int8_t) ca_promote_type(l_dt, r_dt);
+}
+
+void
+ca_bincmp_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
+                                int8_t *out_l_in_dt, int8_t *out_r_in_dt)
+{
+  int8_t common = ca_lazy_bincmp_promote(op_id, l_dt, r_dt);
+  if ( out_l_in_dt ) *out_l_in_dt = common;
+  if ( out_r_in_dt ) *out_r_in_dt = common;
+}

data/ext/ca_bincmp_dispatch.h

@@ -0,0 +1,85 @@
+/* ---------------------------------------------------------------------------
+
+  ca_bincmp_dispatch.h
+
+  PROPOSAL_LAZY_ELEMENTWISE_VIEW Phase 4 (P.4.1) — CABinCmp dispatch API.
+
+  rev2 §0.5 #1 model: comparison output is always CA_BOOLEAN (boolean8_t,
+  1 byte/cell).  Operands are cast to the common data_type via
+  ca_promote_type, the kernel reads both operands and writes boolean
+  output.  The binop in-place trick (= pull left into output buffer)
+  does NOT work for comparison because output data_type != operand data_type.
+
+  rev2 §0.5 #4: bitwise on boolean output is handled by Phase 2 CABinOp
+  (= ca_binop_bit_and_i_boolean8_t exists).  This file is comparison-
+  only.
+
+  P.4.1 scope: only :lt wired with a kernel; other 6 op constants
+  reserved and lookup returns NULL (caller detects not-implemented).
+  P.4.2 expands to 7 ops (= eq / ne / lt / gt / le / ge / feq).
+
+---------------------------------------------------------------------------- */
+
+#ifndef CA_BINCMP_DISPATCH_H
+#define CA_BINCMP_DISPATCH_H
+
+#include "carray.h"
+
+/* ------------------------------------------------------------------- */
+/* op_id enum                                                           */
+/* ------------------------------------------------------------------- */
+
+enum {
+  CA_BINCMP_LT       = 0,
+  CA_BINCMP_GT       = 1,
+  CA_BINCMP_LE       = 2,
+  CA_BINCMP_GE       = 3,
+  CA_BINCMP_EQ       = 4,
+  CA_BINCMP_NE       = 5,
+  CA_BINCMP_FEQ      = 6,   /* float ε-equal, eps stored in CABinCmp.tol tail */
+  /* IC.2: tolerance-bearing predicates, tol stored in CABinCmp.tol tail */
+  CA_BINCMP_IS_CLOSE = 7,   /* |a - b| <= tol (absolute) */
+  CA_BINCMP_IS_EQUIV = 8,   /* |a - b| / max(|a|, |b|) <= tol (relative) */
+
+  CA_BINCMP_COUNT
+};
+
+/* ------------------------------------------------------------------- */
+/* Kernel dispatch tables (per-data_type)                               */
+/* ------------------------------------------------------------------- */
+
+/* The per-data_type bincmp kernel tables (mkkernel-generated, write
+   boolean8_t output).  Made public here (PROPOSAL_CARRAY_H_REORG H.2)
+   so external math-backend gems can swap a slot through the carray.h
+   umbrella with no hand-declared externs.  */
+extern ca_bincmp_func_t ca_bincmp_lt       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_gt       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_le       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_ge       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_eq       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_ne       [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_feq      [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_is_close [CA_NTYPE];
+extern ca_bincmp_func_t ca_bincmp_is_equiv [CA_NTYPE];
+
+/* ------------------------------------------------------------------- */
+/* Dispatch API                                                         */
+/* ------------------------------------------------------------------- */
+
+/* Look up the bincmp kernel for (op_id, common_dt).  Returns NULL if
+   not implemented at the requested data_type.  All bincmp kernels write
+   boolean8_t to ptr3.                                                  */
+ca_bincmp_func_t ca_bincmp_kernel_lookup (uint16_t op_id, int8_t common_dt);
+
+/* Compute input common data_type via ca_promote_type.  Output data_type is
+   always CA_BOOLEAN (NOT returned here; CABinCmp.data_type is set
+   directly).                                                           */
+int8_t ca_lazy_bincmp_promote (uint16_t op_id, int8_t l_dt, int8_t r_dt);
+
+/* What data_type does each operand need to be cast to before reaching the
+   kernel?  Returns common data_type for both (= cast-before route, same as
+   Phase 2 CABinOp).                                                    */
+void ca_bincmp_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
+                                     int8_t *out_l_in_dt, int8_t *out_r_in_dt);
+
+#endif /* CA_BINCMP_DISPATCH_H */

data/ext/ca_binop_dispatch.c

@@ -0,0 +1,124 @@
+/* ---------------------------------------------------------------------------
+
+  CABinOp dispatch: routes a binop op id (`CA_BINOP_*`) to the per-
+  data_type kernel, computes the input promotion + output data_type
+  rule, and tags ops that can trap on integer zero divisor.
+
+  Sibling of ca_obj_binop.c (the CABinOp view), ca_bincmp_dispatch.c
+  (comparison binop family), and ca_monop_dispatch.c (unary
+  counterpart).  Per-data_type kernel tables are declared in
+  ca_binop_dispatch.h.
+
+  The binop kernels assume both operands already share data_type.  The
+  CABinOp builder inserts CAMonOp(`:cast_<common>`) nodes so both
+  operands arrive at the common type.  Two ops break the uniform rule:
+
+    QUO    -- only has a CA_OBJECT kernel; both operands promoted to
+              CA_OBJECT regardless of input data types
+    IPOWER -- heterogeneous (left: float/cmplx preserved, right: int64);
+              output preserves left data type.  See ca_op_ipower.c.
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_binop_dispatch.h"
+
+/* ------------------------------------------------------------------- */
+/* vv kernel lookup                                                     */
+/* ------------------------------------------------------------------- */
+
+ca_binop_func_t
+ca_binop_kernel_lookup_vv (uint16_t op_id, int8_t common_dt)
+{
+  switch (op_id) {
+    case CA_BINOP_ADD:        return ca_binop_add        [common_dt];
+    case CA_BINOP_SUB:        return ca_binop_sub        [common_dt];
+    case CA_BINOP_MUL:        return ca_binop_mul        [common_dt];
+    case CA_BINOP_DIV:        return ca_binop_div        [common_dt];
+    case CA_BINOP_POW:        return ca_binop_power      [common_dt];
+    case CA_BINOP_BIT_AND:    return ca_binop_bit_and_i  [common_dt];
+    case CA_BINOP_BIT_OR:     return ca_binop_bit_or_i   [common_dt];
+    case CA_BINOP_BIT_XOR:    return ca_binop_bit_xor_i  [common_dt];
+    case CA_BINOP_BIT_LSHIFT: return ca_binop_bit_lshift [common_dt];
+    case CA_BINOP_BIT_RSHIFT: return ca_binop_bit_rshift [common_dt];
+    case CA_BINOP_MOD:        return ca_binop_mod        [common_dt];
+    case CA_BINOP_QUO:        return ca_binop_quo_i      [common_dt];
+    case CA_BINOP_RCP_MUL:    return ca_binop_rcp_mul    [common_dt];
+    case CA_BINOP_IPOWER:     return ca_binop_ipower     [common_dt];
+    case CA_BINOP_COPYSIGN:   return ca_binop_copysign   [common_dt];
+    case CA_BINOP_LOGADDEXP:  return ca_binop_logaddexp  [common_dt];
+    case CA_BINOP_NEXTAFTER:  return ca_binop_nextafter  [common_dt];
+    case CA_BINOP_FMOD:       return ca_binop_fmod       [common_dt];
+    case CA_BINOP_ATAN2:      return ca_binop_atan2      [common_dt];
+    case CA_BINOP_HYPOT:      return ca_binop_hypot      [common_dt];
+    case CA_BINOP_PMAX:       return ca_binop_pmax       [common_dt];
+    case CA_BINOP_PMIN:       return ca_binop_pmin       [common_dt];
+    case CA_BINOP_MAXIMUM:    return ca_binop_maximum    [common_dt];
+    case CA_BINOP_MINIMUM:    return ca_binop_minimum    [common_dt];
+    case CA_BINOP_AND:        return ca_binop_and        [common_dt];
+    case CA_BINOP_OR:         return ca_binop_or         [common_dt];
+    case CA_BINOP_XOR:        return ca_binop_xor        [common_dt];
+    default:                  return NULL;
+  }
+}
+
+/* ------------------------------------------------------------------- */
+/* output data_type rule                                                    */
+/* ------------------------------------------------------------------- */
+
+/* Returns the output data_type for op_id applied to operands of types
+   (l_dt, r_dt).  For most ops this is ca_promote_type(l_dt, r_dt) (=
+   the common promoted type).  Broadcast / scalar wrap are handled by
+   the caller, not here.                                              */
+int8_t
+ca_lazy_promote_binop (uint16_t op_id, int8_t l_dt, int8_t r_dt)
+{
+  /* QUO has only a CA_OBJECT kernel: force both operands to CA_OBJECT
+     so the rb_funcall dispatch path runs (matches eager behaviour). */
+  if ( op_id == CA_BINOP_QUO ) return CA_OBJECT;
+  /* IPOWER preserves the left data_type as output (right is coerced
+     to int64 separately by ca_binop_kernel_input_data_types below). */
+  if ( op_id == CA_BINOP_IPOWER ) return l_dt;
+  return (int8_t) ca_promote_type(l_dt, r_dt);
+}
+
+void
+ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
+                              int8_t *out_l_in_dt, int8_t *out_r_in_dt)
+{
+  /* IPOWER: heterogeneous (left preserves, right -> int64).  Skip the
+     cast-before common-data_type unification.                              */
+  if ( op_id == CA_BINOP_IPOWER ) {
+    if ( out_l_in_dt ) *out_l_in_dt = l_dt;
+    if ( out_r_in_dt ) *out_r_in_dt = CA_INT64;
+    (void) r_dt;
+    return;
+  }
+  int8_t common = ca_lazy_promote_binop(op_id, l_dt, r_dt);
+  if ( out_l_in_dt ) *out_l_in_dt = common;
+  if ( out_r_in_dt ) *out_r_in_dt = common;
+}
+
+/* ------------------------------------------------------------------- */
+/* trapping-op predicate                                                */
+/* ------------------------------------------------------------------- */
+
+int
+ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
+{
+  /* Integer DIV / MOD / QUO / FMOD can SIGFPE on a zero divisor.  Float
+     DIV returns NaN/Inf and does NOT trap, so it is not classified
+     trapping.                                                          */
+  int is_integer = ( common_dt >= CA_INT8 && common_dt <= CA_UINT64 );
+  if ( ! is_integer ) return 0;
+
+  switch (op_id) {
+    case CA_BINOP_DIV:
+    case CA_BINOP_MOD:
+    case CA_BINOP_QUO:
+    case CA_BINOP_FMOD:
+      return 1;
+    default:
+      return 0;
+  }
+}

data/ext/ca_binop_dispatch.h

@@ -0,0 +1,152 @@
+/* ---------------------------------------------------------------------------
+
+  ca_binop_dispatch.h
+
+  PROPOSAL_LAZY_ELEMENTWISE_VIEW Phase 2 (P.2.1) — CABinOp dispatch API.
+
+  rev3 §3.2: 1-D same-type table + cast-before route.  No 2-D mixed-type
+  dispatch (= existing eager `ca_binop_<op>[CA_NTYPE]` is 1-D same-type,
+  promotion handled by inserting CAMonOp(:cast_<common>) nodes before
+  reaching CABinOp).
+
+  P.2.1 scope: ADD only, vv only.  P.2.2 expands to 13 ops.
+
+---------------------------------------------------------------------------- */
+
+#ifndef CA_BINOP_DISPATCH_H
+#define CA_BINOP_DISPATCH_H
+
+#include "carray.h"
+
+/* ------------------------------------------------------------------- */
+/* op_id enum                                                           */
+/* ------------------------------------------------------------------- */
+
+enum {
+  /* Arithmetic binop (5) — variants: vv/vs/sv (P.2.3 gate)            */
+  CA_BINOP_ADD = 0,
+  CA_BINOP_SUB = 1,
+  CA_BINOP_MUL = 2,
+  CA_BINOP_DIV = 3,
+  CA_BINOP_POW = 4,
+
+  /* Bitwise / logical (Q1 (b) verdict: 13 op total; full scope flesh
+     out in P.2.2)                                                      */
+  CA_BINOP_BIT_AND   = 5,
+  CA_BINOP_BIT_OR    = 6,
+  CA_BINOP_BIT_XOR   = 7,
+  CA_BINOP_BIT_LSHIFT= 8,
+  CA_BINOP_BIT_RSHIFT= 9,
+  CA_BINOP_MOD       = 10,
+  CA_BINOP_QUO       = 11,
+  CA_BINOP_RCP_MUL   = 12,
+
+  /* Float/Complex ** Integer fast path (binary exponentiation, O(log p)).
+     Heterogeneous binop: left data_type is float32/float64/cmplx64/cmplx128,
+     right is always int64 (CScalar carrying the exponent), output data_type
+     = left data_type (preserve).  Bypasses the standard cast-before route
+     (= no common-data_type promotion) since the integer semantics of the
+     right operand is load-bearing.  See ext/ca_op_ipower.c for the
+     hand-written kernel table.                                          */
+  CA_BINOP_IPOWER    = 13,
+
+  /* M.2 (PyTorch alignment): float-only binop family.  Integer input
+     unsupported at this layer — caller must cast operands explicitly.
+     ATAN2 / HYPOT migrate from hand-written CAMath wrappers (M.3).  */
+  CA_BINOP_COPYSIGN  = 14,
+  CA_BINOP_LOGADDEXP = 15,
+  CA_BINOP_NEXTAFTER = 16,
+  CA_BINOP_FMOD      = 17,
+  CA_BINOP_ATAN2     = 18,
+  CA_BINOP_HYPOT     = 19,
+
+  /* Pair-wise max / min (NaN-skip semantics via C99 fmax / fmin on the
+     float branch; comparison form on integer / object).  All numeric +
+     object.  Ruby aliases `fmax` / `fmin` share the same kernel.       */
+  CA_BINOP_PMAX      = 20,
+  CA_BINOP_PMIN      = 21,
+
+  /* Pair-wise max / min, NaN-propagate variant (if either operand is
+     NaN the result is NaN).  Distinct kernel from PMAX/PMIN — the
+     float branch short-circuits on isnan.  All numeric + object.       */
+  CA_BINOP_MAXIMUM   = 22,
+  CA_BINOP_MINIMUM   = 23,
+
+  /* Boolean 3-value logic word forms (bool + object only, no numeric).
+     Distinct from BIT_AND / BIT_OR / BIT_XOR: those carry the Kleene
+     3-valued fixup on masked cells (see ca_obj_binop.c ~line 515);
+     these word forms use plain mask-propagate semantics.              */
+  CA_BINOP_AND       = 24,
+  CA_BINOP_OR        = 25,
+  CA_BINOP_XOR       = 26,
+
+  CA_BINOP_COUNT
+};
+
+/* ------------------------------------------------------------------- */
+/* Kernel dispatch tables (per-data_type)                               */
+/* ------------------------------------------------------------------- */
+
+/* The per-data_type binop kernel tables.  Defined in carray_kernels.c
+   (mkkernel-generated), ext/ca_op_ipower.c (ipower).  Made public here
+   (PROPOSAL_CARRAY_H_REORG H.2) so external math-backend gems can swap
+   a slot through the carray.h umbrella with no hand-declared externs.  */
+extern ca_binop_func_t ca_binop_add        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_sub        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_mul        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_div        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_power      [CA_NTYPE];
+extern ca_binop_func_t ca_binop_bit_and_i  [CA_NTYPE];
+extern ca_binop_func_t ca_binop_bit_or_i   [CA_NTYPE];
+extern ca_binop_func_t ca_binop_bit_xor_i  [CA_NTYPE];
+extern ca_binop_func_t ca_binop_bit_lshift [CA_NTYPE];
+extern ca_binop_func_t ca_binop_bit_rshift [CA_NTYPE];
+extern ca_binop_func_t ca_binop_mod        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_quo_i      [CA_NTYPE];
+extern ca_binop_func_t ca_binop_rcp_mul    [CA_NTYPE];
+/* Hand-written heterogeneous binop (left: float/cmplx, right: int64,
+   output: left data_type).  Defined in ext/ca_op_ipower.c.  */
+extern ca_binop_func_t ca_binop_ipower     [CA_NTYPE];
+/* M.2 + M.3: PyTorch alignment additions (mkkernel-generated, float-only). */
+extern ca_binop_func_t ca_binop_copysign   [CA_NTYPE];
+extern ca_binop_func_t ca_binop_logaddexp  [CA_NTYPE];
+extern ca_binop_func_t ca_binop_nextafter  [CA_NTYPE];
+extern ca_binop_func_t ca_binop_fmod       [CA_NTYPE];
+extern ca_binop_func_t ca_binop_atan2      [CA_NTYPE];
+extern ca_binop_func_t ca_binop_hypot      [CA_NTYPE];
+extern ca_binop_func_t ca_binop_pmax       [CA_NTYPE];
+extern ca_binop_func_t ca_binop_pmin       [CA_NTYPE];
+extern ca_binop_func_t ca_binop_maximum    [CA_NTYPE];
+extern ca_binop_func_t ca_binop_minimum    [CA_NTYPE];
+extern ca_binop_func_t ca_binop_and        [CA_NTYPE];
+extern ca_binop_func_t ca_binop_or         [CA_NTYPE];
+extern ca_binop_func_t ca_binop_xor        [CA_NTYPE];
+
+/* ------------------------------------------------------------------- */
+/* Dispatch API                                                         */
+/* ------------------------------------------------------------------- */
+
+/* Look up the same-type vv kernel for (op_id, common_dt).  Returns NULL
+   if not implemented.  P.2.1: only ADD wired up; others NULL until P.2.2.  */
+ca_binop_func_t ca_binop_kernel_lookup_vv (uint16_t op_id, int8_t common_dt);
+
+/* Compute output (= common) data_type via the existing eager promotion rule
+   (ca_promote_type).  Phase 0 audit landed extern visibility.            */
+int8_t ca_lazy_promote_binop (uint16_t op_id, int8_t l_dt, int8_t r_dt);
+
+/* What data_type does each operand need to be cast to before reaching the
+   kernel?  Returns common data_type for both (= cast-before route).  When
+   common != operand.data_type, caller inserts CAMonOp(:cast_<common>).      */
+void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
+                                    int8_t *out_l_in_dt, int8_t *out_r_in_dt);
+
+/* True iff op_id is a trapping op for the given common_dt (= integer
+   DIV / MOD on integer data_types).  Float DIV returns NaN/Inf and does
+   not trap, so it is NOT classified trapping.
+
+   When trapping AND either operand has a mask, xfer_stride must pass
+   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_is_trapping (uint16_t op_id, int8_t common_dt);
+
+#endif /* CA_BINOP_DISPATCH_H */