carray 2.0.0 → 3.0.0

data/ext/carray_math_kernel.h

@@ -0,0 +1,120 @@
+/* ---------------------------------------------------------------------------
+
+  ---------------------------------------------------------------------------
+
+  PROPOSAL_CARRAY_H_REORG (H.3): the ext-author / math-backend surface.
+
+  This header carries the element-wise kernel calling-convention typedefs
+  (ca_monop_func_t / ca_binop_func_t / ...), the rb_ca_call_* drivers, and
+  (via the per-family dispatch headers it pulls in) the per-data_type kernel
+  dispatch tables (ca_monop_sin[CA_NTYPE], ...).
+
+  It is included by carray.h (the public umbrella), so an external gem that
+  does `#include "carray.h"` reaches the whole math-kernel surface with no
+  hand-declared externs — e.g. a vector-math backend gem can swap
+  `ca_monop_sin[CA_FLOAT64] = my_vector_sin;`.
+
+  Ordering invariant: the func typedefs below MUST precede the dispatch-header
+  includes (the tables are typed with them).
+
+---------------------------------------------------------------------------- */
+
+#ifndef CARRAY_MATH_KERNEL_H
+#define CARRAY_MATH_KERNEL_H
+
+#include "carray.h"
+
+/* -------------------------------------------------------------------- */
+/* Element-wise kernel calling-convention typedefs                      */
+/* -------------------------------------------------------------------- */
+
+typedef void (*ca_monop_func_t)(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2);
+typedef void (*ca_binop_func_t)(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2,
+                                char *ptr3, ca_size_t i3);
+typedef void (*ca_triop_func_t)(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2,
+                                char *ptr3, ca_size_t i3,
+                                char *ptr4, ca_size_t i4);
+typedef void (*ca_moncmp_func_t)(ca_size_t n, boolean8_t *m,
+                                 char *ptr1, ca_size_t i1,
+                                 boolean8_t *ptr2, ca_size_t i2);
+/* IC.1 (PROPOSAL_IS_CLOSE_BINCMP_MIGRATION rev1): runtime `double tol`
+   slot added uniformly.  Non-tolerance ops (eq/ne/lt/gt/le/ge/feq, etc.)
+   ignore it via `(void) tol;`.  Tolerance ops (is_close, is_equiv) read
+   it in the comparison expression.  See PROPOSAL §3.1 Option A. */
+typedef void (*ca_bincmp_func_t)(ca_size_t n, boolean8_t *m,
+                                 char *ptr1, ca_size_t b1, ca_size_t i1,
+                                 char *ptr2, ca_size_t b2, ca_size_t i2,
+                                 char *ptr3, ca_size_t b3, ca_size_t i3,
+                                 double tol);
+
+/* -------------------------------------------------------------------- */
+/* Kernel drivers (attach / cast / mask / output-alloc are handled here, */
+/* so a kernel receives a contig stride-resolved buffer + element count) */
+/* -------------------------------------------------------------------- */
+
+VALUE rb_ca_call_monop (VALUE self, ca_monop_func_t func[]);
+VALUE rb_ca_call_monop_bang (VALUE self, ca_monop_func_t func[]);
+/* Dtype-changing monop dispatch: out_data_types[in_data_type] gives the output
+   data_type for each input data_type (= -1 if not implemented).  Used by
+   monops with output: { numeric: ..., complex: ... } Hash form (e.g. abs
+   cmplx128 -> f64).  Allocates output array of out_data_types[in_data_type]. */
+VALUE rb_ca_call_monop_typed (VALUE self, ca_monop_func_t func[], int8_t out_data_types[]);
+VALUE rb_ca_call_binop (VALUE self, VALUE other, ca_binop_func_t func[]);
+VALUE rb_ca_call_binop_bang (VALUE self, VALUE other, ca_binop_func_t func[]);
+
+/* Kleene three-valued mask fixup for boolean AND (is_or=0) / OR (is_or=1),
+   applied by the generated `&`/`|` wrappers after rb_ca_call_binop.  No-op
+   unless the output is boolean with a mask. */
+VALUE ca_kleene_bool_fixup (VALUE vout, VALUE vself, VALUE vother, int is_or);
+
+/* Triop driver: applies a 3-input / 1-output kernel.  Operand 1 = self,
+   operands 2/3 are passed in.  Common data_type promotion via
+   rb_ca_cast_self_or_other applied pairwise.  Scalar / array
+   combinations (= 2^3 = 8 cases) are handled uniformly via
+   ca_set_iterator(3, ...) which collapses scalar operands to stride 0.  */
+VALUE rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
+                        ca_triop_func_t func[]);
+VALUE rb_ca_call_triop_bang (VALUE self, VALUE other2, VALUE other3,
+                             ca_triop_func_t func[]);
+VALUE rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[]);
+VALUE rb_ca_call_bincmp (VALUE self, VALUE other, ca_bincmp_func_t func[], double tol);
+void  ca_monop_not_implement(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2) __attribute__((noreturn));
+void  ca_binop_not_implement(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2,
+                                char *ptr3, ca_size_t i3) __attribute__((noreturn));
+void  ca_triop_not_implement(ca_size_t n, boolean8_t *m,
+                                char *ptr1, ca_size_t i1,
+                                char *ptr2, ca_size_t i2,
+                                char *ptr3, ca_size_t i3,
+                                char *ptr4, ca_size_t i4) __attribute__((noreturn));
+void  ca_moncmp_not_implement(ca_size_t n, boolean8_t *m,
+                                 char *ptr1, ca_size_t i1,
+                                 boolean8_t *ptr2, ca_size_t i2) __attribute__((noreturn));
+void  ca_bincmp_not_implement(ca_size_t n, boolean8_t *m,
+                                 char *ptr1, ca_size_t b1, ca_size_t i1,
+                                 char *ptr2, ca_size_t b2, ca_size_t i2,
+                                 char *ptr3, ca_size_t b3, ca_size_t i3,
+                                 double tol) __attribute__((noreturn));
+VALUE ca_math_call (VALUE mod, VALUE arg, ID id);
+
+/* -------------------------------------------------------------------- */
+/* Per-data_type kernel dispatch tables + op_id enums + lookup APIs      */
+/* (must come after the func typedefs above — the tables are typed       */
+/* with them).                                                           */
+/* -------------------------------------------------------------------- */
+
+#include "ca_monop_dispatch.h"
+#include "ca_binop_dispatch.h"
+#include "ca_bincmp_dispatch.h"
+#include "ca_moncmp_dispatch.h"
+
+#endif /* CARRAY_MATH_KERNEL_H */

data/ext/carray_mathfunc.c

@@ -1,10 +1,10 @@
 /* ---------------------------------------------------------------------------
 
-  carray/mathfunc/carray_mathfunc.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
+  CAMath module functions whose semantics are not a 1-arg/1-arg
+  numeric kernel (= multi-input / multi-output cartesian conversions,
+  hand-written lgamma).  Single-arg numeric ops (deg_360 / rad_pi /
+  atan2 / hypot / expm1 / etc.) live in ext/mkkernel.rb and are
+  registered via Init_carray_kernels.
 
 ---------------------------------------------------------------------------- */
 
@@ -18,166 +18,6 @@
 
 /* ----------------------------------------------------------------------- */
 
-static void
-mathfunc_deg_360 (void *p0, void *p1)
-{
-  double a = *(double*) p1;
-  double fa = a / 360.0;
-  if ( a >= 0 ) {
-    *(double*) p0 = (fa - floor(fa)) * 360.0;
-  }
-  else {
-    *(double*) p0 = (fa - ceil(fa) + 1) * 360.0;
-  }
-}
-
-static VALUE 
-rb_ca_deg_360 (VALUE self)
-{
-  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_360, self);
-}
-
-static VALUE 
-rb_ca_deg_360_bang (VALUE self)
-{
-  volatile VALUE out;
-  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_360, self);
-  rb_funcall(self, rb_intern("[]="), 1, out);
-  return self;
-}
-
-static VALUE
-rb_num_deg_360 (VALUE self)
-{
-  double v0, v1 = NUM2DBL(self);
-  mathfunc_deg_360(&v0, &v1);
-  return rb_float_new(v0);
-}
-
-/* ----------------------------------------------------------------------- */
-
-static void
-mathfunc_deg_180 (void *p0, void *p1)
-{
-  double a = *(double*) p1, b;
-  double fa = (a+180.0) / 360.0;
-  if ( a >= 0 ) {
-    b = (fa - floor(fa)) * 360.0 - 180;
-  }
-  else {
-    b = (fa - ceil(fa)) * 360.0 - 180;
-  }
-  if ( b <= -180 ) {
-    b += 360.0;
-  }
-  *(double*) p0 = b;
-}
-
-static VALUE 
-rb_ca_deg_180 (VALUE self)
-{
-  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_180, self);
-}
-
-static VALUE 
-rb_ca_deg_180_bang (VALUE self)
-{
-  volatile VALUE out;
-  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_180, self);
-  rb_funcall(self, rb_intern("[]="), 1, out);
-  return self;
-}
-
-static VALUE
-rb_num_deg_180 (VALUE self)
-{
-  double v0, v1 = NUM2DBL(self);
-  mathfunc_deg_180(&v0, &v1);
-  return rb_float_new(v0);
-}
-
-/* ----------------------------------------------------------------------- */
-
-static void
-mathfunc_rad_2pi (void *p0, void *p1)
-{
-  double a = *(double*) p1;
-  double fa = a / (2*M_PI);
-  if ( a >= 0 ) {
-    *(double*) p0 = (fa - floor(fa)) * 2*M_PI;
-  }
-  else {
-    *(double*) p0 = (fa - ceil(fa) + 1) * 2*M_PI;
-  }
-}
-
-static VALUE 
-rb_ca_rad_2pi (VALUE self)
-{
-  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_2pi, self);
-}
-
-static VALUE 
-rb_ca_rad_2pi_bang (VALUE self)
-{
-  volatile VALUE out;
-  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_2pi, self);
-  rb_funcall(self, rb_intern("[]="), 1, out);
-  return self;
-}
-
-static VALUE
-rb_num_rad_2pi (VALUE self)
-{
-  double v0, v1 = NUM2DBL(self);
-  mathfunc_rad_2pi(&v0, &v1);
-  return rb_float_new(v0);
-}
-
-/* ----------------------------------------------------------------------- */
-
-static void
-mathfunc_rad_pi (void *p0, void *p1)
-{
-  double a = *(double*) p1, b;
-  double fa = (a+M_PI) / (2*M_PI);
-  if ( a >= 0 ) {
-    b = (fa - floor(fa)) * 2*M_PI - M_PI;
-  }
-  else {
-    b = (fa - ceil(fa)) * 2*M_PI - M_PI;
-  }
-  if ( b <= -M_PI ) {
-    b += 2*M_PI;
-  }
-  *(double*) p0 = b;
-}
-
-static VALUE 
-rb_ca_rad_pi (VALUE self)
-{
-  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_pi, self);
-}
-
-static VALUE 
-rb_ca_rad_pi_bang (VALUE self)
-{
-  volatile VALUE out;
-  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_pi, self);
-  rb_funcall(self, rb_intern("[]="), 1, out);
-  return self;
-}
-
-static VALUE
-rb_num_rad_pi (VALUE self)
-{
-  double v0, v1 = NUM2DBL(self);
-  mathfunc_rad_pi(&v0, &v1);
-  return rb_float_new(v0);
-}
-
-/* ----------------------------------------------------------------------- */
-
 static void
 mathfunc_sph_to_xyz (void *p0, void *p1, void *p2, void *p3, void *p4, void *p5)
 {
@@ -219,43 +59,9 @@ rb_camath_xyz_to_sph (VALUE mod, VALUE rx1, VALUE rx2, VALUE rx3)
 
 /* ----------------------------------------------------------------------- */
 
-static void
-mathfunc_atan2 (void *p0, void *p1, void *p2)
-{
-#ifdef HAVE_ATAN2
-  *(double*)p0 = atan2(*(double*)p1, *(double*)p2);
-#else
-  rb_raise(rb_eRuntimeError, "atan2 is not defined");
-#endif
-}
-
-static VALUE 
-rb_camath_atan2 (VALUE mod, VALUE rx1, VALUE rx2)
-{
-  return ca_call_cfunc_1_2(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, 
-                             mathfunc_atan2, rx1, rx2);
-}
-
-/* ----------------------------------------------------------------------- */
-
-static void
-mathfunc_hypot (void *p0, void *p1, void *p2)
-{
-#ifdef HAVE_HYPOT
-  *(double *)p0 = hypot(*(double*)p1, *(double*)p2);
-#else
-  rb_raise(rb_eRuntimeError, "hypot is not defined");
-#endif
-}
-
-static VALUE 
-rb_camath_hypot (VALUE mod, VALUE rx1, VALUE rx2)
-{
-  return ca_call_cfunc_1_2(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, 
-                             mathfunc_hypot, rx1, rx2);
-}
-
-/* ----------------------------------------------------------------------- */
+/* [MOVED] atan2 / hypot / expm1 -> ext/mkkernel.rb (binop / monfunc
+   tables); their CAMath wrappers live in lib/carray/math.rb.  lgamma
+   stays hand-written here because no mkkernel slot exists for it. */
 
 static void
 mathfunc_lgamma (void *p0, void *p1)
@@ -273,47 +79,10 @@ rb_camath_lgamma (VALUE mod, VALUE rx1)
   return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_lgamma, rx1);
 }
 
-/* ----------------------------------------------------------------------- */
-
-static void
-mathfunc_expm1 (void *p0, void *p1)
-{
-#ifdef HAVE_EXP1M
-  *(double *)p0 = expm1(*(double*)p1);
-#else
-  rb_raise(rb_eRuntimeError, "expm1 is not defined ");
-#endif
-}
-
-static VALUE
-rb_camath_expm1 (VALUE mod, VALUE rx1)
-{
-  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_expm1, rx1);
-}
-
 void
-Init_carray_mathfunc ()
+Init_carray_mathfunc (void)
 {
-  rb_define_method(rb_cCArray, "deg_360", rb_ca_deg_360, 0);
-  rb_define_method(rb_cCArray, "deg_360!", rb_ca_deg_360_bang, 0);
-  rb_define_method(rb_cCArray, "deg_180", rb_ca_deg_180, 0);
-  rb_define_method(rb_cCArray, "deg_180!", rb_ca_deg_180_bang, 0);
-  rb_define_method(rb_cCArray, "rad_2pi", rb_ca_rad_2pi, 0);
-  rb_define_method(rb_cCArray, "rad_2pi!", rb_ca_rad_2pi_bang, 0);
-  rb_define_method(rb_cCArray, "rad_pi", rb_ca_rad_pi, 0);
-  rb_define_method(rb_cCArray, "rad_pi!", rb_ca_rad_pi_bang, 0);
-
   rb_define_module_function(rb_mCAMath, "spherical_to_xyz", rb_camath_sph_to_xyz, 3);
   rb_define_module_function(rb_mCAMath, "xyz_to_spherical", rb_camath_xyz_to_sph, 3);
-
-  rb_define_module_function(rb_mCAMath, "atan2", rb_camath_atan2, 2);
-  rb_define_module_function(rb_mCAMath, "hypot", rb_camath_hypot, 2);
-
-  rb_define_module_function(rb_mCAMath, "lgamma",  rb_camath_lgamma, 1);
-  rb_define_module_function(rb_mCAMath, "expm1",   rb_camath_expm1, 1);
-
-  rb_define_method(rb_cNumeric, "deg_360", rb_num_deg_360, 0);
-  rb_define_method(rb_cNumeric, "deg_180", rb_num_deg_180, 0);
-  rb_define_method(rb_cNumeric, "rad_2pi", rb_num_rad_2pi, 0);
-  rb_define_method(rb_cNumeric, "rad_pi", rb_num_rad_pi, 0);
+  rb_define_module_function(rb_mCAMath, "lgamma",            rb_camath_lgamma,    1);
 }