carray 3.0.3 → 3.0.4

data/ext/carray_partition.c

@@ -14,7 +14,7 @@
 
 #include "ruby.h"
 #include "carray.h"
-#include "carray_internal.h"   /* ca_axis_integer */
+#include "carray_internal.h"   /* ca_normalize_axis_arg */
 #include "ca_kernel_iterator.h"   /* CA_FOR_EACH_FIBER_INOUT */
 #include "ca_obj_face.h"          /* CA_FACE_LIFT_IF_FACE */
 #include "ca_sort_kernels.h"      /* ca_partition_quick_* / ca_partition_nan_* */
@@ -155,7 +155,7 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
   }
 
   /* Normalize axis. */
-  int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis, NULL), cat->ndim, NULL);
+  int axis = ca_normalize_axis_arg(vaxis, cat->ndim, NULL);
 
   ca_size_t fiber_n = cat->dim[axis];
   ca_size_t kth = partition_kth(fiber_n, vkth);
@@ -166,14 +166,9 @@ rb_ca_partition_copy_c (VALUE self, VALUE vkth, VALUE vaxis)
    * but the cost is the per-pair rb_funcall, not an architectural
    * penalty. */
   if ( cat->data_type == CA_OBJECT ) {
-    static ID id_partition_index_ki = 0;
-    static ID id_take_along_axis    = 0;
-    static ID id_axis_sym           = 0;
-    if ( !id_partition_index_ki ) {
-      id_partition_index_ki = rb_intern("partition_index_ki");
-      id_take_along_axis    = rb_intern("take_along_axis");
-      id_axis_sym           = rb_intern("axis");
-    }
+    ID id_partition_index_ki = rb_intern("partition_index_ki");
+    ID id_take_along_axis    = rb_intern("take_along_axis");
+    ID id_axis_sym           = rb_intern("axis");
     VALUE idx = rb_funcall(target, id_partition_index_ki, 2,
                            INT2NUM(axis), SIZET2NUM(kth));
     VALUE kw = rb_hash_new();
@@ -297,8 +292,7 @@ rb_ca_partition_copy_c_mp (VALUE self, VALUE vkth, VALUE vaxis, int masked_last)
   /* Check axis and kth here, so a bad one is reported as partition_copy's
      rather than as the partition this delegates to. */
   {
-    int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis, NULL),
-                                             ca->ndim, NULL);
+    int axis = ca_normalize_axis_arg(vaxis, ca->ndim, NULL);
     partition_kth(ca->dim[axis], vkth);
   }
   /* rb_ca_partitioned_view's rb_scan_args "1:" pattern needs call-frame
@@ -337,26 +331,30 @@ rb_ca_partition_copy_body (int argc, VALUE *argv, VALUE self)
   int masked_last = NIL_P(vmasked_position) ? 1
     : ca_symbol_choice(vmasked_position, "masked_position", "first", "last", NULL);
 
-  /* Face gate, the same policy as the sort family's: a fixlen storage
-     partitions by memcmp, a numeric storage only when ORDERABLE (its order
-     is the surface order).  The selection runs on the storage and the Face
-     is put back on the result.  Without this the surface fixlen bytes were
-     selected by memcmp, which is not the order of a little-endian integer
-     (CATime) and not the label order of a code (CACategorical). */
+  /* Face gate, the same policy as the sort family's.  An ORDERABLE Face
+     is selected on its storage and put back on the result.  A Face that
+     orders by itself (ca_face_orders_by_itself) is partitioned by the view,
+     which orders by that order (ca_order_key), and its copy is the answer.
+     Any other Face raises. */
   volatile VALUE face = Qnil;
   {
     CArray *ca;
     TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
     if ( ca_is_face(ca) ) {
-      VALUE st = rb_ca_strip_face_value(self);
-      CArray *sc;
-      TypedData_Get_Struct(st, CArray, &carray_data_type, sc);
-      if ( sc->data_type != CA_FIXLEN
-           && ! ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-        ca_face_refuse_order("partition_copy", self, "order");
+      if ( ca_face_orders_by_itself(self) ) {
+        VALUE kw = rb_hash_new();
+        VALUE pv_argv[2];
+        rb_hash_aset(kw, ID2SYM(rb_intern("axis")), vaxis);
+        rb_hash_aset(kw, ID2SYM(rb_intern("masked_position")),
+                     masked_last ? ID2SYM(rb_intern("last")) : ID2SYM(rb_intern("first")));
+        pv_argv[0] = vkth;
+        pv_argv[1] = kw;
+        return rb_ca_copy(rb_funcallv_kw(self, rb_intern("partition"), 2, pv_argv,
+                                         RB_PASS_KEYWORDS));
       }
+      ca_face_require_orderable(self, "partition_copy", "order");
       face = self;
-      self = st;
+      self = rb_ca_strip_face_value(self);
     }
   }
 
@@ -418,7 +416,8 @@ rb_ca_partitioned_view (int argc, VALUE *argv, VALUE self)
      suitable for direct ca_remap_new wrap; the remap gather carries
      target's mask bits through so masked cells stay masked at their
      clustered position (no extra output-mask step needed here). */
-  volatile VALUE sigma_addr = rb_ca_partition_addr_ki_mp(target, vaxis, vkth, masked_last);
+  volatile VALUE sigma_addr =
+    rb_ca_partition_addr_ki_mp(target, vaxis, vkth, masked_last);
   {
     VALUE obj = rb_ca_remap_new(target, sigma_addr);
     CA_FACE_LIFT_IF_FACE(obj, self, ca);
@@ -443,7 +442,9 @@ static VALUE
 rb_ca_partition_copy (int argc, VALUE *argv, VALUE self)
 {
   pc_call_t c = { argc, argv, self };
-  return ca_answer_as_caller(pc_answer_body, (VALUE) &c);
+  VALUE out = ca_answer_as_caller(pc_answer_body, (VALUE) &c);
+  rb_ca_inherit_attr(out, self);
+  return out;
 }
 
 void

data/ext/carray_random.c

@@ -88,16 +88,18 @@ typedef struct {
   long           low_long;
   unsigned long  limit;
   int            axis;           /* shuffle!: -1 = all cells */
+  CArray        *mask;           /* shuffle!: self's mask, moved with the values */
 } ca_random_ctx_t;
 
 static void
 ca_random_run (ca_random_ctx_t *c, VALUE rng, VALUE (*fill)(VALUE))
 {
-  CArray *list[2];
+  CArray *list[3];
   ca_rng_resolve(rng, &c->source);
   list[0] = c->ca;
   list[1] = c->source.state;
-  ca_attach_window(2, list, "ww", fill, (VALUE) c);
+  list[2] = c->mask;
+  ca_attach_window(c->mask ? 3 : 2, list, "www", fill, (VALUE) c);
 }
 
 /* The state is attached once the window is open. */
@@ -359,19 +361,55 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
     int is_integer_type = (ca->data_type >= CA_INT8
                             && ca->data_type <= CA_UINT64);
     if (is_integer_type) {
-      low_long  = NUM2LONG(low_val);
-      high_long = NUM2LONG(high_val);
-      if (high_is_closed) high_long += 1;
-      if (low_long >= high_long) {
+      /* The bounds stay Ruby Integers until they are known to fit: the
+         last value drawn is high (closed) or high - 1, and every value
+         from low to it must be one of the type's.  The draw is low plus
+         an offset up to last - low, which holds even the whole int64 or
+         uint64 range. */
+      VALUE last, type_min, type_max;
+      if (!RB_INTEGER_TYPE_P(low_val) || !RB_INTEGER_TYPE_P(high_val)) {
+        rb_raise(rb_eTypeError,
+                 "random: an integer array takes Integer bounds "
+                 "(got %"PRIsVALUE", %"PRIsVALUE")",
+                 rb_inspect(low_val), rb_inspect(high_val));
+      }
+      last = high_is_closed ? high_val
+                            : rb_funcall(high_val, '-', 1, INT2FIX(1));
+      if (RTEST(rb_funcall(low_val, '>', 1, last))) {
         rb_raise(rb_eArgError,
                  "random: low must be less than high "
-                 "(got low=%ld, high=%ld)",
-                 low_long, high_long);
+                 "(got low=%"PRIsVALUE", high=%"PRIsVALUE")",
+                 low_val, high_val);
+      }
+      switch (ca->data_type) {
+      case CA_INT8:   type_min = INT2FIX(INT8_MIN);   type_max = INT2FIX(INT8_MAX);   break;
+      case CA_UINT8:  type_min = INT2FIX(0);          type_max = INT2FIX(UINT8_MAX);  break;
+      case CA_INT16:  type_min = INT2FIX(INT16_MIN);  type_max = INT2FIX(INT16_MAX);  break;
+      case CA_UINT16: type_min = INT2FIX(0);          type_max = INT2FIX(UINT16_MAX); break;
+      case CA_INT32:  type_min = LL2NUM(INT32_MIN);   type_max = LL2NUM(INT32_MAX);   break;
+      case CA_UINT32: type_min = INT2FIX(0);          type_max = ULL2NUM(UINT32_MAX); break;
+      case CA_INT64:  type_min = LL2NUM(INT64_MIN);   type_max = LL2NUM(INT64_MAX);   break;
+      default:        type_min = INT2FIX(0);          type_max = ULL2NUM(UINT64_MAX); break;
+      }
+      if (RTEST(rb_funcall(low_val, '<', 1, type_min)) ||
+          RTEST(rb_funcall(last, '>', 1, type_max))) {
+        rb_raise(rb_eRangeError,
+                 "random: the values %"PRIsVALUE"..%"PRIsVALUE" are not all %s "
+                 "(%"PRIsVALUE"..%"PRIsVALUE")",
+                 low_val, last, ca_type_name[ca->data_type], type_min, type_max);
       }
-      limit = (unsigned long)(high_long - low_long) - 1;
+      low_long = RTEST(rb_funcall(low_val, '<', 1, INT2FIX(0)))
+               ? (long) NUM2LL(low_val) : (long) NUM2ULL(low_val);
+      limit = (unsigned long) NUM2ULL(rb_funcall(last, '-', 1, low_val));
+      (void) high_long;
     } else {
       low_dbl  = NUM2DBL(low_val);
       high_dbl = NUM2DBL(high_val);
+      if (!isfinite(low_dbl) || !isfinite(high_dbl)) {
+        rb_raise(rb_eArgError,
+                 "random: the bounds are finite numbers "
+                 "(got low=%g, high=%g)", low_dbl, high_dbl);
+      }
       if (low_dbl >= high_dbl) {
         rb_raise(rb_eArgError,
                  "random: low must be less than high "
@@ -382,7 +420,7 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
   }
 
   {
-    ca_random_ctx_t c;
+    ca_random_ctx_t c = { 0 };
     c.ca         = ca;
     c.n          = ca->elements;
     c.is_default = is_default;
@@ -392,6 +430,8 @@ rb_ca_random_bang(int argc, VALUE *argv, VALUE self)
     c.limit      = limit;
     ca_random_run(&c, rng, ca_random_bang_fill);
   }
+  /* Every cell now holds a value, as after seq! or fill. */
+  ca_clear_mask(ca);
   return self;
 }
 
@@ -560,11 +600,13 @@ rb_ca_randomn_bang(int argc, VALUE *argv, VALUE self)
   }
 
   {
-    ca_random_ctx_t c;
+    ca_random_ctx_t c = { 0 };
     c.ca = ca;
     c.n  = ca->elements;
     ca_random_run(&c, rng, ca_randomn_bang_fill);
   }
+  /* Every cell now holds a value, as after seq! or fill. */
+  ca_clear_mask(ca);
   return self;
 }
 
@@ -600,12 +642,16 @@ ca_shuffle_bang_fill (VALUE arg)
     ca_size_t elem_bytes = ca->bytes;
     char *tmp = ALLOCV_N(char, tmp_holder, elem_bytes);
     char *p = ca->ptr;
+    char *m = c->mask ? c->mask->ptr : NULL;
 
     n = ca->elements;
     for (ca_size_t i = n - 1; i > 0; i--) {
       unsigned long j = ca_random_ulong_limited(&c->source, (unsigned long)i);
       if ((ca_size_t)j != i) {
         swap_chunks(p + i * elem_bytes, p + j * elem_bytes, elem_bytes, tmp);
+        if ( m ) {
+          char b = m[i]; m[i] = m[j]; m[j] = b;
+        }
       }
     }
     ALLOCV_END(tmp_holder);
@@ -630,12 +676,16 @@ ca_shuffle_bang_fill (VALUE arg)
 
     for (ca_size_t o = 0; o < outer; o++) {
       char *base = ca->ptr + o * stride;
+      char *mbase = c->mask ? c->mask->ptr + o * n * inner : NULL;
       for (ca_size_t i = n - 1; i > 0; i--) {
         unsigned long j = ca_random_ulong_limited(&c->source, (unsigned long)i);
         if ((ca_size_t)j != i) {
           swap_chunks(base + i * chunk_bytes,
                       base + j * chunk_bytes,
                       chunk_bytes, tmp);
+          if ( mbase ) {
+            swap_chunks(mbase + i * inner, mbase + j * inner, inner, tmp);
+          }
         }
       }
     }
@@ -650,7 +700,7 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
   CArray *ca;
   VALUE opts = Qnil, v_axis = Qnil;
   int axis = -1;
-  ca_random_ctx_t c;
+  ca_random_ctx_t c = { 0 };
 
   rb_scan_args(argc, argv, "0:", &opts);
   VALUE rng = Qnil;
@@ -662,7 +712,7 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
   if (ca->elements <= 1) return self;
 
   if (!NIL_P(v_axis)) {
-    axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(v_axis, NULL), ca->ndim, NULL);
+    axis = ca_normalize_axis_arg(v_axis, ca->ndim, NULL);
     if (ca->dim[axis] <= 1) {
       return self;
     }
@@ -670,6 +720,10 @@ rb_ca_shuffle_bang(int argc, VALUE *argv, VALUE self)
 
   c.ca   = ca;
   c.axis = axis;
+  /* The mask moves with the values: a masked cell stays masked wherever
+     it lands. */
+  ca_update_mask(ca);
+  c.mask = ca->mask;
   ca_random_run(&c, rng, ca_shuffle_bang_fill);
   return self;
 }

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);
+}