carray 3.0.2 → 3.0.4

data/ext/ca_op_ipower.c

@@ -168,6 +168,19 @@ ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
     while (n--) { (*p2) = op_powi_cmplx128_t(*p1, ipow); p1++; p2++; }
 }
 
+/* The data types the ipower kernels cover; checked before any window
+   opens, so the switches inside cannot fall through to a raise. */
+static int
+ca_ipower_type_ok (CArray *ca)
+{
+  switch ( ca->data_type ) {
+  case CA_FLOAT32: case CA_FLOAT64: case CA_CMPLX64: case CA_CMPLX128:
+    return 1;
+  default:
+    return 0;
+  }
+}
+
 /* Eager Float/Complex ** Integer producing a fresh entity output.
  * ca is input-only, co is the write target.  Mirrors rb_ca_call_monop
  * (see carray_math* / carray_kernels.c) so operand attach is elided:
@@ -189,6 +202,10 @@ rb_ca_ipower (VALUE self, VALUE other)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
+  if ( ! ca_ipower_type_ok(ca) ) {
+    rb_raise(rb_eCADataTypeError, "invalid data type for ipower");
+  }
+
   co = ca_has_mask(ca) ? ca_template_safe(ca) : ca_template(ca);
   obj = ca_wrap_struct(co);
 
@@ -196,7 +213,7 @@ rb_ca_ipower (VALUE self, VALUE other)
   m = ( co->mask ) ? (boolean8_t *)co->mask->ptr : NULL;
 
   if ( ca_attach_is_alias(ca) ) {
-    ca_attach(ca);
+    ca_attach(ca);   /* window: nothing raises inside */
     switch ( ca->data_type ) {
     case CA_FLOAT32:
       ca_ipower_float32_t(ca->elements, m, ca->ptr, ipow, co->ptr);  break;
@@ -206,8 +223,6 @@ rb_ca_ipower (VALUE self, VALUE other)
       ca_ipower_cmplx64_t(ca->elements, m, ca->ptr, ipow, co->ptr);  break;
     case CA_CMPLX128:
       ca_ipower_cmplx128_t(ca->elements, m, ca->ptr, ipow, co->ptr); break;
-    default:
-      rb_raise(rb_eCADataTypeError, "invalid data type for ipower");
     }
     ca_detach(ca);
   }
@@ -226,9 +241,6 @@ rb_ca_ipower (VALUE self, VALUE other)
       ca_ipower_cmplx64_t(ca->elements, m, p1, ipow, co->ptr);  break;
     case CA_CMPLX128:
       ca_ipower_cmplx128_t(ca->elements, m, p1, ipow, co->ptr); break;
-    default:
-      ALLOCV_END(h1);
-      rb_raise(rb_eCADataTypeError, "invalid data type for ipower");
     }
     ALLOCV_END(h1);
   }
@@ -247,7 +259,11 @@ rb_ca_ipower_bang (VALUE self, VALUE other)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  ca_attach(ca);
+  if ( ! ca_ipower_type_ok(ca) ) {
+    rb_raise(rb_eRuntimeError, "invalid data type for ipower");
+  }
+
+  ca_attach(ca);   /* window: nothing raises inside until ca_sync_detach */
 
   m = ( ca->mask ) ? (boolean8_t *)ca->mask->ptr : NULL;
 
@@ -260,12 +276,9 @@ rb_ca_ipower_bang (VALUE self, VALUE other)
     ca_ipower_cmplx64_t(ca->elements, m, ca->ptr, ipow, ca->ptr);  break;
   case CA_CMPLX128:
     ca_ipower_cmplx128_t(ca->elements, m, ca->ptr, ipow, ca->ptr); break;
-  default:
-    rb_raise(rb_eRuntimeError, "invalid data type for ipower");
   }
 
-  ca_sync(ca);
-  ca_detach(ca);
+  ca_sync_detach(ca);
 
   return self;
 }

data/ext/ca_op_powi.h

@@ -23,9 +23,19 @@
 #include "carray.h"
 #include <stdint.h>
 
-#define op_powi(type) \
+/* The text between the two markers below is also handed, as it stands, to
+   an evaluator that compiles a kernel body calling op_powi_<type>
+   (CArray.__kernel_helpers__, written into the build by mkkernel.rb).  It
+   may use only <stdint.h>, float32_t / float64_t and ca_zerodiv: what such
+   an evaluator's C declares.  The complex instantiations stay outside. */
+
+/* BEGIN kernel helpers */
+
+/* x raised to a non-negative power, by binary exponentiation.  The power
+   is unsigned so that the magnitude of INT64_MIN is representable. */
+#define op_powi_magnitude(type) \
 static inline type \
-op_powi_## type (type x, int64_t p) \
+op_powi_mag_## type (type x, uint64_t p) \
 { \
   type r=1; \
 \
@@ -35,53 +45,70 @@ op_powi_## type (type x, int64_t p) \
   case 0: return 1; \
   case 1: return x; \
   } \
-  if (p<0) { \
-    type den = op_powi_## type(x, -p); \
-    if (den==0) ca_zerodiv(); \
-    return 1/den; \
-  }\
   while (p) { \
-    if ( (p%2) == 1 ) r *= x; \
+    if ( p & 1 ) r *= x; \
     x *= x; \
-    p /= 2; \
+    p >>= 1; \
   } \
   return r; \
 }
 
-#define op_powi_fc(type) \
+/* An integer to a negative power is 1/x^|p| in integer division, which is
+   decided by x alone: 0 has no reciprocal, 1 and -1 keep their magnitude,
+   anything larger truncates to 0.  Answering it that way, rather than by
+   computing x^|p|, keeps a power that overflows -- 2 ** -64 -- from wrapping
+   to a zero divisor. */
+#define op_powi(type) \
+op_powi_magnitude(type) \
 static inline type \
 op_powi_## type (type x, int64_t p) \
 { \
-  type r=1; \
-\
-  switch(p) { \
-  case 2: return x*x; \
-  case 3: return x*x*x; \
-  case 0: return 1; \
-  case 1: return x; \
+  if ( p < 0 ) { \
+    if ( x == 0 ) ca_zerodiv(); \
+    if ( x == 1 ) return 1; \
+    if ( x == (type) -1 ) return ( p % 2 ) ? x : 1; \
+    return 0; \
   } \
-  if (p<0) { \
-    type den = op_powi_## type(x, -p); \
-    return 1/den; \
-  }\
-  while (p) { \
-    if ( (p%2) == 1 ) r *= x; \
-    x *= x; \
-    p /= 2; \
+  return op_powi_mag_## type(x, (uint64_t) p); \
+}
+
+/* An unsigned x is never -1; (type) -1 is its largest value. */
+#define op_powi_u(type) \
+op_powi_magnitude(type) \
+static inline type \
+op_powi_## type (type x, int64_t p) \
+{ \
+  if ( p < 0 ) { \
+    if ( x == 0 ) ca_zerodiv(); \
+    return ( x == 1 ) ? 1 : 0; \
   } \
-  return r; \
+  return op_powi_mag_## type(x, (uint64_t) p); \
+}
+
+#define op_powi_fc(type) \
+op_powi_magnitude(type) \
+static inline type \
+op_powi_## type (type x, int64_t p) \
+{ \
+  if ( p < 0 ) { \
+    return 1 / op_powi_mag_## type(x, (uint64_t) 0 - (uint64_t) p); \
+  } \
+  return op_powi_mag_## type(x, (uint64_t) p); \
 }
 
 op_powi(int8_t)
-op_powi(uint8_t)
+op_powi_u(uint8_t)
 op_powi(int16_t)
-op_powi(uint16_t)
+op_powi_u(uint16_t)
 op_powi(int32_t)
-op_powi(uint32_t)
+op_powi_u(uint32_t)
 op_powi(int64_t)
-op_powi(uint64_t)
+op_powi_u(uint64_t)
 op_powi_fc(float32_t)
 op_powi_fc(float64_t)
+
+/* END kernel helpers */
+
 op_powi_fc(cmplx64_t)
 op_powi_fc(cmplx128_t)