carray 3.0.3 → 3.0.5

data/ext/carray_round.c

@@ -0,0 +1,273 @@
+/* ---------------------------------------------------------------------------
+
+  CArray#round(ndigits) and #round!(ndigits): each element rounded as Ruby's
+  Float#round(ndigits) and Integer#round(ndigits) round it, half away from
+  zero.  The argument-free forms are the generated monop kernels; this file
+  takes over the method and hands them the calls without an argument.
+
+---------------------------------------------------------------------------- */
+
+#include <math.h>
+#include <float.h>
+
+#include "carray.h"
+#include "carray_internal.h"
+#include "ca_obj_face.h"
+
+VALUE rb_ca_round (VALUE self);        /* generated: round without digits */
+VALUE rb_ca_round_bang (VALUE self);
+
+static ID id_round;
+
+/* The rounding of Float#round for ndigits > 0 (numeric.c, round_half_up
+   with its check for a product that came out one short). */
+static double
+ca_round_half_up (double x, double s)
+{
+  double f, xs = x * s;
+
+  f = round(xs);
+  if ( x > 0 ) {
+    if ( (double)((f + 0.5) / s) <= x ) f += 1;
+    x = f;
+  }
+  else {
+    if ( (double)((f - 0.5) / s) >= x ) f -= 1;
+    x = f;
+  }
+  return x;
+}
+
+/* numeric.c: float_round_overflow / float_round_underflow.  When the first
+   holds, number * 10**ndigits is already an integer and the number is its
+   own answer; when the second holds, the answer is 0. */
+static int
+ca_round_overflow (long ndigits, int binexp)
+{
+  enum { float_dig = DBL_DIG + 2 };
+  return ndigits >= float_dig - (binexp > 0 ? binexp / 4 : binexp / 3 - 1);
+}
+
+static int
+ca_round_underflow (long ndigits, int binexp)
+{
+  return ndigits < - (binexp > 0 ? binexp / 3 + 1 : binexp / 4);
+}
+
+/* An integer |x| rounded to a multiple of 10**k (k >= 1), half away from
+   zero, as Integer#round(-k).  Returns 0 when the answer does not fit in
+   64 bits, and sets *overflow. */
+static uint64_t
+ca_round_uint64 (uint64_t ax, long k, int *overflow)
+{
+  uint64_t y = 1, q, rem, r;
+  long i;
+
+  *overflow = 0;
+  if ( k > 19 ) {          /* 10**20 / 2 exceeds every 64-bit value */
+    return 0;
+  }
+  for (i = 0; i < k; i++) {
+    y *= 10;
+  }
+  q   = ax / y;
+  rem = ax % y;
+  r   = q * y;
+  if ( rem >= y - y / 2 ) {       /* rem * 2 >= y, without overflow */
+    if ( r > UINT64_MAX - y ) {
+      *overflow = 1;
+      return 0;
+    }
+    r += y;
+  }
+  return r;
+}
+
+/* x rounded as Float#round(ndigits) rounds it, for ndigits != 0.  NaN and
+   the infinities are their own answer (Float#round raises for them when
+   ndigits <= 0; an array of floats keeps them as values). */
+static double
+ca_round_double (double x, long ndigits)
+{
+  int binexp;
+
+  if ( x == 0.0 || ! isfinite(x) ) {
+    return x;
+  }
+  if ( ndigits > 0 ) {
+    frexp(x, &binexp);
+    if ( ca_round_overflow(ndigits, binexp) ) {
+      return x;
+    }
+    if ( ca_round_underflow(ndigits, binexp) ) {
+      return 0.0;
+    }
+    if ( ndigits > 14 ) {
+      /* pow(10, ndigits) may not be exact; Ruby rounds through a Rational. */
+      return NUM2DBL(rb_funcall(DBL2NUM(x), id_round, 1, LONG2NUM(ndigits)));
+    }
+    {
+      double f = pow(10, (double) ndigits);
+      return ca_round_half_up(x, f) / f;
+    }
+  }
+  else {
+    /* Ruby truncates to an Integer, then rounds the Integer. */
+    double t = trunc(x);
+    if ( fabs(t) < 18446744073709551616.0 ) {          /* 2**64 */
+      int overflow;
+      uint64_t r = ca_round_uint64((uint64_t) fabs(t), -ndigits, &overflow);
+      if ( ! overflow ) {
+        return ( t < 0 ) ? -(double) r : (double) r;
+      }
+    }
+    return NUM2DBL(rb_funcall(DBL2NUM(x), id_round, 1, LONG2NUM(ndigits)));
+  }
+}
+
+#define ROUND_INT_LOOP(type, lo, hi, is_signed)                               \
+  {                                                                           \
+    type *p = (type *) ca->ptr;                                               \
+    for (i = 0; i < ca->elements; i++) {                                      \
+      int neg, overflow;                                                      \
+      uint64_t ax, r;                                                         \
+      if ( m && m[i] ) continue;                                              \
+      neg = ( is_signed ) && ( (int64_t) p[i] < 0 );                          \
+      ax  = neg ? (uint64_t) 0 - (uint64_t)(int64_t) p[i] : (uint64_t) p[i];  \
+      r   = ca_round_uint64(ax, -ndigits, &overflow);                         \
+      if ( overflow || ( neg ? r > (uint64_t) 0 - (uint64_t)(int64_t)(lo)     \
+                             : r > (uint64_t)(hi) ) ) {                       \
+        rb_raise(rb_eRangeError,                                              \
+                 "round: a value rounded to %ld digits does not fit "         \
+                 "data_type %s", ndigits, ca_type_name[ca->data_type]);       \
+      }                                                                       \
+      p[i] = neg ? (type)((uint64_t) 0 - r) : (type) r;                       \
+    }                                                                         \
+  }
+
+/* Rounds the cells of the entity `ca` in place; masked cells are left. */
+static void
+ca_round_entity (CArray *ca, long ndigits)
+{
+  boolean8_t *m = NULL;
+  ca_size_t i;
+
+  if ( ca->mask ) {
+    m = (boolean8_t *) ca->mask->ptr;
+  }
+
+  switch ( ca->data_type ) {
+  case CA_INT8:   ROUND_INT_LOOP(int8_t,   INT8_MIN,  INT8_MAX,  1); break;
+  case CA_UINT8:  ROUND_INT_LOOP(uint8_t,  0,         UINT8_MAX, 0); break;
+  case CA_INT16:  ROUND_INT_LOOP(int16_t,  INT16_MIN, INT16_MAX, 1); break;
+  case CA_UINT16: ROUND_INT_LOOP(uint16_t, 0,         UINT16_MAX, 0); break;
+  case CA_INT32:  ROUND_INT_LOOP(int32_t,  INT32_MIN, INT32_MAX, 1); break;
+  case CA_UINT32: ROUND_INT_LOOP(uint32_t, 0,         UINT32_MAX, 0); break;
+  case CA_INT64:  ROUND_INT_LOOP(int64_t,  INT64_MIN, INT64_MAX, 1); break;
+  case CA_UINT64: ROUND_INT_LOOP(uint64_t, 0,         UINT64_MAX, 0); break;
+  case CA_FLOAT32: {
+    float32_t *p = (float32_t *) ca->ptr;
+    for (i = 0; i < ca->elements; i++) {
+      if ( m && m[i] ) continue;
+      p[i] = (float32_t) ca_round_double((double) p[i], ndigits);
+    }
+    break;
+  }
+  case CA_FLOAT64: {
+    float64_t *p = (float64_t *) ca->ptr;
+    for (i = 0; i < ca->elements; i++) {
+      if ( m && m[i] ) continue;
+      p[i] = ca_round_double(p[i], ndigits);
+    }
+    break;
+  }
+  case CA_OBJECT: {
+    VALUE *p = (VALUE *) ca->ptr;
+    volatile VALUE nd = LONG2NUM(ndigits);
+    for (i = 0; i < ca->elements; i++) {
+      if ( m && m[i] ) continue;
+      p[i] = rb_funcall(p[i], id_round, 1, nd);
+    }
+    break;
+  }
+  default:
+    rb_raise(rb_eCADataTypeError, "round: not defined for data_type %s",
+             ca_type_name[ca->data_type]);
+  }
+}
+
+/* The array to round: a boolean is rounded as its 0/1 int64 values, as
+   round without digits does. */
+static VALUE
+ca_round_source (VALUE self, VALUE vdigits, long *ndigits)
+{
+  CArray *ca;
+  *ndigits = ca_integer_arg(vdigits, "ndigits", "round");
+  ca_face_refuse_numeric(self, "round", rb_eCADataTypeError);
+  GetCArray(self, ca);
+  if ( ca->data_type == CA_BOOLEAN ) {
+    self = rb_ca_wrap_readonly(self, INT2NUM(CA_INT64));
+  }
+  return self;
+}
+
+/* A copy of `src` rounded to `ndigits`.  Rounding to 0 digits is what round
+   without digits does (except for objects, which are asked with the digits);
+   an integer has no digits below 10**0 to round. */
+static VALUE
+ca_round_copy (VALUE src, long ndigits)
+{
+  volatile VALUE out;
+  CArray *ca, *co;
+  GetCArray(src, ca);
+  if ( ndigits == 0 && ca->data_type != CA_OBJECT ) {
+    return rb_ca_round(src);
+  }
+  out = rb_ca_copy(src);
+  GetCArray(out, co);
+  if ( ndigits > 0 && ca_is_integer_type(co) ) {
+    return out;
+  }
+  ca_round_entity(co, ndigits);
+  return out;
+}
+
+static VALUE
+rb_ca_round_digits (int argc, VALUE *argv, VALUE self)
+{
+  long ndigits;
+  rb_check_arity(argc, 0, 1);
+  if ( argc == 0 ) {
+    return rb_ca_round(self);
+  }
+  self = ca_round_source(self, argv[0], &ndigits);
+  return ca_round_copy(self, ndigits);
+}
+
+static VALUE
+rb_ca_round_digits_bang (int argc, VALUE *argv, VALUE self)
+{
+  long ndigits;
+  volatile VALUE src, out;
+  rb_check_arity(argc, 0, 1);
+  if ( argc == 0 ) {
+    return rb_ca_round_bang(self);
+  }
+  rb_ca_modify(self);
+  src = ca_round_source(self, argv[0], &ndigits);
+  if ( src != self ) {
+    rb_raise(rb_eCADataTypeError,
+             "round!: a boolean array can not hold the rounded int64 values");
+  }
+  out = ca_round_copy(self, ndigits);
+  rb_ca_store_all(self, out);
+  return self;
+}
+
+void
+Init_carray_round (void)
+{
+  id_round = rb_intern("round");
+  rb_define_method(rb_cCArray, "round",  rb_ca_round_digits, -1);
+  rb_define_method(rb_cCArray, "round!", rb_ca_round_digits_bang, -1);
+}

data/ext/carray_scatter.c

@@ -13,8 +13,11 @@
                min / max: real numeric only (complex has no order)
                (boolean / object / fixlen → CADataTypeError; the bang
                cannot widen self, same rationale as fma! / fms!)
-               replace: numeric or boolean (assignment, no widening)
-    scalar     Integer / Float, and Complex when self is complex
+               replace: any type (assignment, no widening); an object or
+               fixlen array is written through the indexer
+    scalar     any Numeric, true / false, or UNDEF; converted to self's
+               type as the indexer's store converts it (a value that does
+               not fit raises, as `self[i] = v` does)
 
 --------------------------------------------------------------------------- */
 
@@ -44,17 +47,24 @@
 #define OP_MIN_INT(qp, v) do { if ((v) < *(qp)) *(qp) = (v); } while (0)
 #define OP_MAX_INT(qp, v) do { if ((v) > *(qp)) *(qp) = (v); } while (0)
 
-/* The scalar operand as T.  An Integer goes to T directly, not through
-   double, so an int64 above 2**53 is exact.  A complex self also takes a
-   Ruby Complex scalar, whose parts sit in vd / vi; an Integer or Float
-   scalar leaves vi at 0. */
-#define SCALAR_REAL(T)  (v_is_float ? (T) vd : (T) vl)
-#define SCALAR_CMPLX(T) ((T) ((v_is_float ? (double)vd : (double)vl) + vi * I))
+/* The scalar operand, already converted to self's type by rb_ca_obj2ptr
+   (the indexer's store conversion) and held as one cell in vcell. */
+typedef union {
+  char       bytes[16];
+  double     d;
+  int64_t    l;
+#ifdef HAVE_COMPLEX_H
+  cmplx128_t z;
+#endif
+} ca_scatter_cell_t;
+
+#define SCALAR_REAL(T)  (*(const T *) vcell.bytes)
+#define SCALAR_CMPLX(T) (*(const T *) vcell.bytes)
 
 #define LOOP_SCALAR(T, APPLY) LOOP_SCALAR_V(T, APPLY, SCALAR_REAL(T))
 
 #define LOOP_SCALAR_V(T, APPLY, VS) do { \
-  T *q = (T *) qbase; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
   T  vs = VS; \
   if ( mself ) { \
     for (i = 0; i < n; i++) { \
@@ -76,8 +86,8 @@
 } while (0)
 
 #define LOOP_VEC(T, APPLY) do { \
-  T *q = (T *) qbase; \
-  T *r = (T *) cv->ptr; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
+  CA_U(T) *r = (CA_U(T) *) cv->ptr; \
   if ( mself ) { \
     for (i = 0; i < n; i++) { \
       if ( maddrs && maddrs[i] ) continue; \
@@ -105,26 +115,30 @@
        both value and mask (indexer contract, `self[addrs] = vals`).
      - masked vals[i] flips target to masked (writes UNDEF); valid
        vals[i] writes value and clears the target's mask bit.
-   Scalar vals is always valid (Fixnum / Float), so scalar path just
-   writes and clears target mask. */
+   A scalar UNDEF masks every target (self's mask exists by then); any
+   other scalar writes and clears the target's mask. */
 
 #define LOOP_SCALAR_REPLACE(T) LOOP_SCALAR_REPLACE_V(T, SCALAR_REAL(T))
 
 #define LOOP_SCALAR_REPLACE_V(T, VS) do { \
-  T *q = (T *) qbase; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
   T  vs = VS; \
   for (i = 0; i < n; i++) { \
     if ( maddrs && maddrs[i] ) continue; \
     addr = p[i]; \
     CA_CHECK_INDEX(addr, elements); \
+    if ( vals_undef ) { \
+      mself[addr] = 1; \
+      continue; \
+    } \
     q[addr] = vs; \
     if ( mself ) mself[addr] = 0; \
   } \
 } while (0)
 
 #define LOOP_VEC_REPLACE(T) do { \
-  T *q = (T *) qbase; \
-  T *r = (T *) cv->ptr; \
+  CA_U(T) *q = (CA_U(T) *) qbase; \
+  CA_U(T) *r = (CA_U(T) *) cv->ptr; \
   for (i = 0; i < n; i++) { \
     if ( maddrs && maddrs[i] ) continue; \
     addr = p[i]; \
@@ -204,11 +218,21 @@
   } \
 } while (0)
 
+/* A value that is one cell for every address: a Numeric, true / false,
+   or UNDEF.  Anything else (a CArray, an Array, ...) is coerced to an
+   array of values. */
+static int
+ca_scatter_is_scalar (VALUE v)
+{
+  return v == CA_UNDEF || v == Qtrue || v == Qfalse
+      || rb_obj_is_kind_of(v, rb_cNumeric);
+}
+
 /* Setup boilerplate: parse args and wrap addrs/vals.
 
    Outputs into caller's locals:
      ca, ci, cv (CArray*), n (ca_size_t),
-     vals_scalar (int), v_is_float (int), vd, vi (double), vl (long).
+     vals_scalar, vals_undef (int), vcell (the scalar as one cell).
 
    The kernel then runs through AT_RUN, and an address out of range
    raising part way still leaves the cells already written.
@@ -218,9 +242,12 @@
 */
 /* Body shared by arithmetic and replace setups.  Caller precondition:
    the data_type gate has already run (arithmetic = numeric only, replace
-   = numeric or boolean).  For the replace variant, `true` / `false`
-   scalars are accepted as vals (bridged as vl = 1 / 0). */
-#define AT_SETUP_BODY(name, allow_bool_scalar) \
+   = numeric or boolean).  A scalar is converted the way `self[i] = v`
+   converts it, so true / false reach only a boolean self and a value that
+   does not fit raises.  A scalar UNDEF is a masked value: the arithmetic
+   family skips every pair, replace masks every target. */
+#define AT_SETUP_BODY(name) \
+  ca_check_index_array(raddrs); \
   raddrs = rb_ca_wrap_readonly(raddrs, INT2NUM(CA_SIZE)); \
   TypedData_Get_Struct(raddrs, CArray, &carray_data_type, ci); \
   if ( ca_shares_root(ci, ca) ) { \
@@ -229,20 +256,17 @@
   } \
   n = ci->elements; \
   if ( n == 0 ) return self; \
-  vals_scalar = (RB_FLOAT_TYPE_P(rvals) || FIXNUM_P(rvals) \
-                 || ((allow_bool_scalar) && (rvals == Qtrue || rvals == Qfalse)) \
-                 || (ca_is_complex_type(ca) && RB_TYPE_P(rvals, T_COMPLEX))); \
+  vals_scalar = ca_scatter_is_scalar(rvals); \
   if ( vals_scalar ) { \
-    if ( RB_TYPE_P(rvals, T_COMPLEX) ) { \
-      vd = NUM2DBL(rb_complex_real(rvals)); \
-      vi = NUM2DBL(rb_complex_imag(rvals)); \
-      v_is_float = 1; \
+    if ( rvals == CA_UNDEF ) { \
+      vals_undef = 1; \
+    } \
+    else { \
+      rb_ca_obj2ptr(self, rvals, vcell.bytes); \
     } \
-    else if ( RB_FLOAT_TYPE_P(rvals) ) { vd = RFLOAT_VALUE(rvals); v_is_float = 1; } \
-    else if ( FIXNUM_P(rvals) )   { vl = FIX2LONG(rvals);     v_is_float = 0; } \
-    else                          { vl = (rvals == Qtrue) ? 1 : 0; v_is_float = 0; } \
   } \
   else { \
+    /* coerce: a store into the receiver */ \
     rvals = rb_ca_wrap_readonly(rvals, INT2NUM(ca->data_type)); \
     TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv); \
     if ( ca_shares_root(cv, ca) ) { \
@@ -259,8 +283,8 @@
 #define AT_SETUP_LOCALS \
   CArray  *ca, *ci, *cv = NULL; \
   ca_size_t n; \
-  int vals_scalar, v_is_float = 0; \
-  double vd = 0.0, vi = 0.0; long vl = 0;
+  int vals_scalar, vals_undef = 0; \
+  ca_scatter_cell_t vcell = {{0}};
 
 #define AT_SETUP_OR_RETURN(name, ordered) \
   AT_SETUP_LOCALS \
@@ -273,7 +297,8 @@
     rb_raise(rb_eCADataTypeError, \
       name " requires a real array (complex values have no order)"); \
   } \
-  AT_SETUP_BODY(name, 0)
+  AT_SETUP_BODY(name) \
+  if ( vals_undef ) return self;
 
 /* replace variant: accepts boolean self (assignment, no widening) and
    Ruby true / false as scalar vals. */
@@ -285,7 +310,8 @@
     rb_raise(rb_eCADataTypeError, \
       name " requires a numeric or boolean array"); \
   } \
-  AT_SETUP_BODY(name, 1)
+  AT_SETUP_BODY(name) \
+  if ( vals_undef ) ca_create_mask(ca);
 
 /* The kernel works either on self's own memory or on a compact region:
    the distinct cells the addresses touch, read out of self and written
@@ -305,9 +331,8 @@ typedef struct {
 typedef struct {
   CArray    *ca, *ci, *cv;
   ca_size_t  n;
-  int        vals_scalar, v_is_float;
-  double     vd, vi;
-  long       vl;
+  int        vals_scalar, vals_undef;
+  ca_scatter_cell_t vcell;
   ca_scatter_region_t *region;
 } ca_scatter_ctx_t;
 
@@ -330,10 +355,9 @@ fname (VALUE arg) \
   boolean8_t *mvals    = (cv && cv->mask) ? (boolean8_t *) cv->mask->ptr : NULL; \
   boolean8_t *mself    = rg_ ? rg_->mask \
                              : (ca->mask ? (boolean8_t *) ca->mask->ptr : NULL); \
-  int         vals_scalar = c_->vals_scalar, v_is_float = c_->v_is_float; \
-  double      vd = c_->vd, vi = c_->vi; \
-  long        vl = c_->vl; \
-  (void) cv; (void) mvals; (void) v_is_float; (void) vd; (void) vi; (void) vl; \
+  int         vals_scalar = c_->vals_scalar, vals_undef = c_->vals_undef; \
+  ca_scatter_cell_t vcell = c_->vcell; \
+  (void) cv; (void) mvals; (void) vals_undef; (void) vcell; \
   DISPATCH; \
   return Qnil; \
 }
@@ -460,8 +484,8 @@ ca_scatter_region_body (VALUE varg)
   ca_scatter_ctx_t c_; \
   CArray *list_[3]; \
   c_.ca = ca; c_.ci = ci; c_.cv = cv; c_.n = n; \
-  c_.vals_scalar = vals_scalar; c_.v_is_float = v_is_float; \
-  c_.vd = vd; c_.vi = vi; c_.vl = vl; \
+  c_.vals_scalar = vals_scalar; c_.vals_undef = vals_undef; \
+  c_.vcell = vcell; \
   c_.region = NULL; \
   if ( ca_attach_is_alias(ca) ) { \
     list_[0] = ca; list_[1] = ci; list_[2] = cv; \
@@ -474,6 +498,9 @@ ca_scatter_region_body (VALUE varg)
     ca_attach_window(vals_scalar ? 1 : 2, list_, "rr", \
                      ca_scatter_region_body, (VALUE) &ra_); \
   } \
+  /* the views AT_SETUP_BODY made are reached only through ci and cv */ \
+  RB_GC_GUARD(raddrs); \
+  RB_GC_GUARD(rvals); \
 } while (0)
 
 /* --------------------------------------------------------------- */
@@ -566,11 +593,26 @@ AT_BODY(ca_scatter_replace_body, DISPATCH_NUMERIC_REPLACE())
 static VALUE
 rb_ca_scatter_replace_bang (VALUE self, VALUE raddrs, VALUE rvals)
 {
+  /* An object or fixlen array takes the assignment through the indexer,
+     which reads and writes its cells by their own rules (a VALUE kept
+     visible to the GC, a fixlen value fitted to the cell); the kernel
+     below is for the numeric and boolean cells. */
+  {
+    CArray *cs;
+    TypedData_Get_Struct(self, CArray, &carray_data_type, cs);
+    if ( cs->data_type == CA_OBJECT || cs->data_type == CA_FIXLEN ) {
+      rb_ca_modify(self);
+      if ( RB_TYPE_P(raddrs, T_ARRAY) ) {     /* a list of addresses */
+        raddrs = rb_ca_wrap_readonly(raddrs, INT2NUM(CA_SIZE));
+      }
+      rb_funcall(rb_ca_flatten(self), rb_intern("[]="), 2, raddrs, rvals);
+      return self;
+    }
+  }
   /* Pre-scan: if vals is a masked CArray and self isn't yet masked,
      promote self so the kernel can flip target cells to masked (indexer
      `self[addrs] = vals` establishes self.mask lazily the same way). */
-  if ( ! (RB_FLOAT_TYPE_P(rvals) || FIXNUM_P(rvals))
-       && rb_obj_is_carray(rvals) ) {
+  if ( rb_obj_is_carray(rvals) ) {
     CArray *cv_pre;
     TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv_pre);
     if ( ca_has_mask(cv_pre) ) {

data/ext/carray_segment.c

@@ -228,7 +228,7 @@ rb_ca_s_segment_index (int argc, VALUE *argv, VALUE klass)
   return rout;
 }
 
-/* CArray.__segment_bounds__(name, lengths: l | offsets: o) -> int64[k+1]
+/* CArray.__segment_boundaries_from_lengths_or_offsets__(name, lengths: l | offsets: o) -> int64[k+1]
 
    Internal: the validated boundaries, for a Ruby caller that takes the same
    two keywords (CArray#segments).  `name` heads the error messages. */
@@ -239,7 +239,7 @@ rb_ca_s_segment_bounds (int argc, VALUE *argv, VALUE klass)
   ca_size_t k;
   VALUE rname;
   if ( argc < 1 ) {
-    rb_raise(rb_eArgError, "__segment_bounds__: the caller's name is required");
+    rb_raise(rb_eArgError, "__segment_boundaries_from_lengths_or_offsets__: the caller's name is required");
   }
   rname = argv[0];
   StringValue(rname);
@@ -253,5 +253,5 @@ Init_carray_segment (void)
   id_offsets = rb_intern("offsets");
   rb_define_singleton_method(rb_cCArray, "segment_offsets", rb_ca_s_segment_offsets, -1);
   rb_define_singleton_method(rb_cCArray, "segment_index",   rb_ca_s_segment_index,   -1);
-  rb_define_singleton_method(rb_cCArray, "__segment_bounds__", rb_ca_s_segment_bounds, -1);
+  rb_define_singleton_method(rb_cCArray, "__segment_boundaries_from_lengths_or_offsets__", rb_ca_s_segment_bounds, -1);
 }