carray 1.1.4 → 1.1.5

data/carray_undef.c

@@ -0,0 +1,69 @@
+/* ---------------------------------------------------------------------------
+
+  carray_undef.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include "ruby.h"
+
+static VALUE rb_cUNDEF;
+
+VALUE CA_UNDEF;
+
+static VALUE rb_ud_inspect (VALUE self) 
+{
+  return rb_str_new2("UNDEF");
+}
+
+static VALUE rb_ud_to_s (VALUE self) 
+{
+  /* rb_raise(rb_eTypeError, "can't coerce UNDEF into String"); */
+  return rb_str_new2("UNDEF");
+}
+
+static VALUE rb_ud_to_f (VALUE self) 
+{
+  rb_raise(rb_eTypeError, "can't coerce UNDEF into Float");
+  /* return rb_float_new(0.0/0.0); */
+}
+
+static VALUE rb_ud_to_i (VALUE self) 
+{
+  rb_raise(rb_eTypeError, "can't coerce UNDEF into Integer");
+}
+
+static VALUE rb_ud_equal (VALUE self, VALUE other) 
+{
+  return ( self == other ) ? Qtrue : Qfalse;
+}
+
+
+static VALUE rb_obj_is_undef (VALUE self)
+{
+  return ( self == CA_UNDEF ) ? Qtrue : Qfalse;
+}
+
+void
+Init_carray_undef ()
+{
+  rb_cUNDEF = rb_define_class("UndefClass", rb_cObject);
+  rb_define_method(rb_cUNDEF, "inspect", rb_ud_inspect, 0);
+  rb_define_method(rb_cUNDEF, "to_s", rb_ud_to_s, 0);
+  rb_define_method(rb_cUNDEF, "to_f", rb_ud_to_f, 0);
+  rb_define_method(rb_cUNDEF, "to_i", rb_ud_to_i, 0);
+  rb_define_method(rb_cUNDEF, "to_int", rb_ud_to_i, 0);
+  rb_define_method(rb_cUNDEF, "==", rb_ud_equal, 1);
+
+  CA_UNDEF  = rb_funcall(rb_cUNDEF, rb_intern("new"), 0);
+  rb_undef_method(CLASS_OF(rb_cUNDEF), "new");
+  rb_const_set(rb_cObject, rb_intern("UNDEF"), CA_UNDEF);
+
+  rb_define_method(rb_cObject, "undef?", rb_obj_is_undef, 0);
+}
+

data/carray_utils.c

@@ -0,0 +1,740 @@
+/* ---------------------------------------------------------------------------
+
+  carray_utils.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include <stdarg.h>
+#include "ruby.h"
+#include "carray.h"
+
+#if RUBY_VERSION_CODE >= 190
+#include "ruby/st.h"
+#else
+#include "st.h"
+#endif
+
+#if RUBY_VERSION_CODE >= 190
+#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
+#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
+#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
+#else
+static ID id_beg, id_end, id_excl;
+#define RANGE_BEG(r) (rb_ivar_get(r, id_beg))
+#define RANGE_END(r) (rb_ivar_get(r, id_end))
+#define RANGE_EXCL(r) (rb_ivar_get(r, id_excl))
+#endif
+
+
+/* ------------------------------------------------------------------- */
+
+void *
+malloc_with_check (size_t size)
+{
+  void *ptr;
+  ptr = xmalloc(size);
+  if ( !ptr ) {
+    rb_memerror();
+  }
+  return ptr;
+}
+
+/* ------------------------------------------------------------------- */
+
+void
+ca_debug () {}
+
+/* ------------------------------------------------------------------- */
+
+int32_t
+ca_set_iterator (int n, ...)
+{
+  CArray *ca;
+  char   **p;
+  int    *s;
+  int32_t max = -1;
+  int     all_scalar = 1;
+  va_list args;
+  va_start(args, n);
+  while ( n-- ) {
+    ca = va_arg(args, CArray *);
+    p  = va_arg(args, char **);
+    s  = va_arg(args, int *);
+    *p = ca->ptr;
+    if ( ca_is_scalar(ca) ) {
+      *s = 0;
+      all_scalar &= 1;
+    }
+    else {
+      *s = 1;
+      all_scalar = 0;
+      if ( max < 0 ) {
+        max = ca->elements;
+      }
+      else if ( max != ca->elements ) {
+        rb_raise(rb_eRuntimeError, "data size mismatch in operation");
+      }
+    }
+  }
+  va_end(args);
+
+  if ( all_scalar && max < 0 ) {
+    max = 1;
+  }
+
+  return max;
+}
+
+/* ------------------------------------------------------------------- */
+
+int32_t
+ca_get_loop_count (int n, ...)
+{
+  CArray *ca;
+  int32_t elements = -1;
+  int32_t is_scalar = 1;
+  va_list args;
+  va_start(args, n);
+  while ( n-- ) {
+    ca = va_arg(args, CArray*);
+    if ( ca_is_scalar(ca) ) {
+      continue;
+    }
+    is_scalar = 0;
+    if ( elements == -1 || ca->elements < elements ) {
+      elements = ca->elements;
+    }
+  }
+  va_end(args);
+  if ( elements == -1 && is_scalar ) {
+    elements = 1;
+  }
+
+  if ( elements == -1 ) {
+    rb_raise(rb_eRuntimeError, "no data to process");
+  }
+  return elements;
+}
+
+/*
+  ca_parse_range and ca_parse_range_without_check parse the following
+  types of range specifications
+
+   i
+
+   nil
+   i..j
+
+   [nil]
+   [i..j]
+
+   [nil, k]
+   [i..j, k]
+
+   [i]
+   [i,n]
+   [i,n,k]
+*/
+
+void
+ca_parse_range (VALUE arg, int size, int *poffset, int *pcount, int *pstep)
+{
+  int32_t first, start, last, count, step, bound, excl;
+
+ retry:
+
+  if ( NIL_P(arg) ) {                /* nil */
+    *poffset = 0;
+    *pcount  = size;
+    *pstep   = 1;
+  }
+  else if ( rb_obj_is_kind_of(arg, rb_cInteger) ) {
+                                     /* i */
+    start = FIX2INT(arg);
+    CA_CHECK_INDEX(start, size);
+    *poffset = start;
+    *pcount  = 1;
+    *pstep   = 1;
+  }
+  else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
+                                     /* i..j */
+    first = NUM2INT(RANGE_BEG(arg));
+    last  = NUM2INT(RANGE_END(arg));
+    excl  = RTEST(RANGE_EXCL(arg));
+    CA_CHECK_INDEX(first, size);
+    if ( last < 0 ) {
+      last += size;
+    }
+    if ( excl ) {
+      last += ( (last>=first) ? -1 : 1 );
+    }
+    if ( last < 0 || last >= size ) {
+      rb_raise(rb_eIndexError,
+               "invalid index range");
+    }
+    *poffset = first;
+    *pcount  = abs(last - first) + 1;
+    *pstep   = 1;
+  }
+  else if ( TYPE(arg) == T_ARRAY ) {
+    if ( RARRAY_LEN(arg) == 1 ) {     /* [nil] or [i..j] or [i] */
+      arg = rb_ary_entry(arg, 0);
+      goto retry;
+    }
+    else if ( RARRAY_LEN(arg) == 2 ) {
+      VALUE arg0 = rb_ary_entry(arg, 0);
+      VALUE arg1 = rb_ary_entry(arg, 1);
+      if ( NIL_P(arg0) ) {              /* [nil,k] */
+        step  = NUM2INT(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eRuntimeError, "step should not be 0");
+        }
+        start = 0;
+        count = (size-1)/abs(step) + 1;
+        bound = start + (count - 1)*step;
+        CA_CHECK_INDEX(start, size);
+        CA_CHECK_INDEX(bound, size);
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+      else if ( rb_obj_is_kind_of(arg0, rb_cRange) ) { /* [i..j,k] */
+        start = NUM2INT(RANGE_BEG(arg0));
+        last  = NUM2INT(RANGE_END(arg0));
+        excl  = RTEST(RANGE_EXCL(arg0));
+        step  = NUM2INT(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eRuntimeError, "step should not be 0");
+        }
+        if ( last < 0 ) {
+          last += size;
+        }
+        if ( excl ) {
+          last += ( (last>=start) ? -1 : 1 );
+        }
+        if ( last < 0 || last >= size ) {
+          rb_raise(rb_eIndexError, "index out of range");
+        }
+        CA_CHECK_INDEX(start, size);
+        if ( (last - start) * step < 0 ) {
+          count = 1;
+        }
+        else {
+          count = abs(last - start)/abs(step) + 1;
+        }
+        bound = start + (count - 1)*step;
+        CA_CHECK_INDEX(bound, size);
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+      else {                            /* [i,n] */
+        start = NUM2INT(arg0);
+        count = NUM2INT(arg1);
+        bound = start + (count - 1);
+        CA_CHECK_INDEX(start, size);
+        CA_CHECK_INDEX(bound, size);
+        *poffset = start;
+        *pcount  = count;
+        *pstep    = 1;
+      }
+    }
+    else if ( RARRAY_LEN(arg) == 3 ) { /* [i,n,k] */
+      start = NUM2INT(rb_ary_entry(arg, 0));
+      count = NUM2INT(rb_ary_entry(arg, 1));
+      step  = NUM2INT(rb_ary_entry(arg, 2));
+      if ( step == 0 ) {
+        rb_raise(rb_eRuntimeError, "step should not be 0");
+      }
+      bound = start + (count - 1)*step;
+      CA_CHECK_INDEX(start, size);
+      CA_CHECK_INDEX(bound, size);
+      *poffset = start;
+      *pcount  = count;
+      *pstep   = step;
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "unknown range specification");
+    }
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "unknown range specification");
+  }
+}
+
+void
+ca_parse_range_without_check (VALUE arg, int size,
+                              int *poffset, int *pcount, int *pstep)
+{
+  int32_t first, start, last, count, step, bound, excl;
+
+ retry:
+
+  if ( NIL_P(arg) ) {                /* nil */
+    *poffset = 0;
+    *pcount  = size;
+    *pstep   = 1;
+  }
+  else if ( rb_obj_is_kind_of(arg, rb_cInteger) ) {
+                                     /* i */
+    start = FIX2INT(arg);
+    *poffset = start;
+    *pcount  = 1;
+    *pstep   = 1;
+  }
+  else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
+                                     /* i..j */
+    first = NUM2INT(RANGE_BEG(arg));
+    last  = NUM2INT(RANGE_END(arg));
+    excl  = RTEST(RANGE_EXCL(arg));
+    if ( excl ) {
+      last += ( (last>=first) ? -1 : 1 );
+    }
+    *poffset = first;
+    *pcount  = last - first + 1;
+    *pstep   = 1;
+  }
+  else if ( TYPE(arg) == T_ARRAY ) {
+    if ( RARRAY_LEN(arg) == 1 ) {   /* [nil] or [i..j] or [i] */
+      arg = rb_ary_entry(arg, 0);
+      goto retry;
+    }
+    else if ( RARRAY_LEN(arg) == 2 ) {
+      VALUE arg0 = rb_ary_entry(arg, 0);
+      VALUE arg1 = rb_ary_entry(arg, 1);
+      if ( NIL_P(arg0) ) {              /* [nil,k] */
+        start = 0;
+        step  = NUM2INT(arg1);
+        count = (size-1)/abs(step) + 1;
+        bound = start + (count - 1)*step;
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+      else if ( rb_obj_is_kind_of(arg0, rb_cRange) ) { /* [i..j,k] */
+        start = NUM2INT(RANGE_BEG(arg0));
+        last  = NUM2INT(RANGE_END(arg0));
+        excl  = RTEST(RANGE_EXCL(arg0));
+        step  = NUM2INT(arg1);
+        if ( excl ) {
+          last += ( (last>=start) ? -1 : 1 );
+        }
+        count = (last - start)/abs(step) + 1;
+        bound = start + (count - 1)*step;
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+      else {                            /* [i,n] */
+        start = NUM2INT(arg0);
+        count = NUM2INT(arg1);
+        bound = start + (count - 1);
+        *poffset = start;
+        *pcount  = count;
+        *pstep    = 1;
+      }
+    }
+    else if ( RARRAY_LEN(arg) == 3 ) { /* [i,n,k] */
+      start = NUM2INT(rb_ary_entry(arg, 0));
+      count = NUM2INT(rb_ary_entry(arg, 1));
+      step  = NUM2INT(rb_ary_entry(arg, 2));
+      bound = start + (count - 1)*step;
+      *poffset = start;
+      *pcount  = count;
+      *pstep   = step;
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "unknown range specification");
+    }
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "unknown range specification");
+  }
+}
+
+int32_t
+ca_bounds_normalize_index (int8_t bounds, int32_t size0, int32_t k)
+{
+  switch ( bounds ) {
+  case CA_BOUNDS_MASK:
+  case CA_BOUNDS_FILL:
+    return k;
+  case CA_BOUNDS_PERIODIC:
+    if ( k >= 0 ) {
+      return k % size0;
+    }
+    else {
+      k = (-k) % size0;
+      return ( ! k ) ? 0 : size0 - k;
+    }
+  case CA_BOUNDS_RUBY:
+    if ( k < 0 ) {
+      k += size0;
+    }
+    if ( k < 0 || k >= size0 ) {
+      rb_raise(rb_eRuntimeError,
+               "window index out of range");
+    }
+    return k;
+  case CA_BOUNDS_STRICT:
+    if ( k < 0 || k >= size0 ) {
+      rb_raise(rb_eRuntimeError,
+               "window index out of range");
+    }
+    return k;
+  case CA_BOUNDS_NEAREST:
+    return ( k < 0 ) ? 0 : ( k >= size0 ) ? size0 - 1 : k;
+  case CA_BOUNDS_REFLECT:
+    if ( k < 0 ) {
+      k = -k - 1;
+    }
+    k = k % (2*size0);
+    return ( k < size0 ) ? k : 2*size0-1-k;
+  default:
+    rb_raise(rb_eRuntimeError,
+             "unknown window boundary specified (%i)", bounds);
+  }
+}
+
+static VALUE
+rb_ca_s_scan_float (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE rstr, rfval;
+  double value;
+  int count;
+
+  rb_scan_args(argc, argv, "11", &rstr, &rfval);
+
+  if ( NIL_P(rstr) ) {
+    return ( NIL_P(rfval) ) ? rb_float_new(0.0/0.0) : rfval;
+  }
+
+  Check_Type(rstr, T_STRING);
+
+  count = sscanf(StringValuePtr(rstr), "%lf", &value);
+
+  if ( count == 1 ) {
+    return rb_float_new(value);
+  }
+  else {
+    return ( NIL_P(rfval) ) ? rb_float_new(0.0/0.0) : rfval;
+  }
+}
+
+static VALUE
+rb_ca_s_scan_int (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE rstr, rfval;
+  long value;
+  int count;
+
+  rb_scan_args(argc, argv, "11", &rstr, &rfval);
+
+  if ( NIL_P(rstr) ) {
+    return ( NIL_P(rfval) ) ? INT2FIX(0) : rfval;
+  }
+
+  Check_Type(rstr, T_STRING);
+
+  count = sscanf(StringValuePtr(rstr), "%li", &value);
+
+  if ( count == 1 ) {
+    return LONG2NUM(value);
+  }
+  else {
+    return ( NIL_P(rfval) ) ? INT2FIX(0) : rfval;
+  }
+}
+
+static const struct {
+  char *name;
+  int  data_type;
+} ca_name_to_type[] = {
+  { "fixlen", CA_FIXLEN },
+  { "boolean", CA_BOOLEAN },
+  { "int8", CA_INT8 },
+  { "uint8", CA_UINT8 },
+  { "int16", CA_INT16 },
+  { "uint16", CA_UINT16 },
+  { "int32", CA_INT32 },
+  { "uint32", CA_UINT32 },
+  { "int64", CA_INT64 },
+  { "uint64", CA_UINT64 },
+  { "float32", CA_FLOAT32 },
+  { "float64", CA_FLOAT64 },
+  { "float128", CA_FLOAT128 },
+  { "cmplx64", CA_CMPLX64 },
+  { "cmplx128", CA_CMPLX128 },
+  { "cmplx256", CA_CMPLX256 },
+  { "object", CA_OBJECT },
+  { "byte", CA_UINT8 },
+  { "short", CA_INT16 },
+  { "int", CA_INT32 },
+  { "float", CA_FLOAT32 },
+  { "double", CA_FLOAT64 },
+  { "complex", CA_CMPLX64 },
+  { "dcomplex", CA_CMPLX128 },
+  { NULL, CA_NONE },
+};
+
+
+
+int8_t
+rb_ca_guess_type (VALUE obj)
+{
+  VALUE inspect;
+
+  if ( TYPE(obj) == T_FIXNUM ) {
+    return NUM2INT(obj);
+  }
+  else if ( TYPE(obj) == T_STRING ) {
+    char *name0, *name = StringValuePtr(obj);
+    int i;
+    i = 0;
+    while ( ( name0 = ca_name_to_type[i].name ) ) {
+      name0 = ca_name_to_type[i].name;
+      if ( ! strncmp(name, name0, strlen(name0)) ) {
+        return ca_name_to_type[i].data_type;
+      }
+      i++;
+    }
+  }
+  else if ( TYPE(obj) == T_SYMBOL ) {
+    return rb_ca_guess_type(rb_str_new2(rb_id2name(SYM2ID(obj))));
+  }
+  else if ( TYPE(obj) == T_CLASS ) {
+    ca_check_data_class(obj);
+    return CA_FIXLEN;
+  }
+
+  inspect = rb_inspect(obj);
+  rb_raise(rb_eRuntimeError,
+           "<%s> is unknown data_type representation", StringValuePtr(inspect));
+}
+
+void
+rb_ca_guess_type_and_bytes (VALUE rtype, VALUE rbytes,
+                            int8_t *data_type, int32_t *bytes)
+{
+  *data_type = rb_ca_guess_type(rtype);
+
+  if ( *data_type == CA_FIXLEN ) {
+    if ( TYPE(rtype) == T_CLASS ) {
+      *bytes = NUM2INT(rb_const_get(rtype, rb_intern("DATA_SIZE")));
+    }
+    else {
+      if ( NIL_P(rbytes) ) {
+        *bytes = 0;
+      }
+      else {
+        *bytes = NUM2INT(rbytes);
+      }
+    }
+  }
+  else {
+    CA_CHECK_DATA_TYPE(*data_type);
+    *bytes = ca_sizeof[*data_type];
+  }
+}
+
+/* rdoc:
+  def CArray.guess_type_and_bytes (type, bytes=0)
+  end
+*/
+
+static VALUE
+rb_ca_s_guess_type_and_bytes (int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rtype, rbytes;
+  int8_t data_type;
+  int32_t bytes;
+  rb_scan_args(argc, argv, "11", &rtype, &rbytes);
+  rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
+  return rb_assoc_new(INT2FIX(data_type), LONG2NUM(bytes));
+}
+
+VALUE
+rb_pop_options (int *argc, VALUE **argv)
+{
+  VALUE ropt;
+  if ( ( *argc > 0 ) && ( TYPE( (*argv)[*argc-1] ) == T_HASH ) ) {
+    ropt = (*argv)[*argc-1];
+    (*argc) -= 1;
+  }
+  else {
+    ropt = Qnil;
+  }
+  return ropt;
+}
+
+
+char *
+strsep1(char **sp, const char sep)
+{
+  char *p  = *sp;
+  char *p0 = *sp;
+
+  if ( p == NULL ) {
+    return NULL;
+  }
+
+  while ( *p != '\0' ) {
+    if ( *p == sep ) {
+      *p  = '\0';
+      *sp = p+1;
+      return p0;
+    }
+    else {
+      p++;
+    }
+  }
+
+  *sp = NULL;
+  return p0;
+}
+
+#if RUBY_VERSION_CODE >= 220
+static VALUE
+rb_hash_has_key(VALUE hash, VALUE key)
+{
+  if ( RHASH_EMPTY_P(hash) ) {
+    return Qfalse;
+  }
+  if (st_lookup(RHASH_TBL(hash), key, 0)) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+#else
+#if RUBY_VERSION_CODE >= 190
+static VALUE
+rb_hash_has_key(VALUE hash, VALUE key)
+{
+  if (!RHASH(hash)->ntbl) {
+    return Qfalse;
+  }
+  if (st_lookup(RHASH(hash)->ntbl, key, 0)) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+#else
+static VALUE
+rb_hash_has_key (VALUE hash, VALUE key)
+{
+  if (st_lookup(RHASH(hash)->tbl, key, 0) ) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+#endif
+#endif
+
+void
+rb_scan_options (VALUE ropt, const char *spec_in, ...)
+{
+  VALUE *vp;
+  char *sp, *tok, *spec;
+  int has_option = 0;
+  va_list vals;
+
+  if ( TYPE(ropt) == T_HASH ) {
+    has_option = 1;
+  }
+  else if ( ! NIL_P(ropt) ) {
+    VALUE inspect = rb_inspect(ropt);
+    rb_raise(rb_eArgError,
+             "<%s> is invalid option specifier",
+             StringValuePtr(inspect));
+  }
+
+  va_start(vals, spec_in);
+  sp = spec = strdup(spec_in);
+  tok = strsep1(&sp, ',');
+  while ( tok != NULL ) {
+    vp = va_arg(vals, VALUE*);
+    if ( has_option ) {
+      VALUE key = ID2SYM(rb_intern(tok));
+      if ( rb_hash_has_key(ropt, key) ) {
+        *vp = rb_hash_aref(ropt, key);
+      }
+      else {
+        if ( *vp != CA_NIL ) {
+          *vp = Qnil;
+        }
+      }
+    }
+    else {
+      if ( *vp != CA_NIL ) {
+        *vp = Qnil;
+      }
+    }
+    tok = strsep1(&sp, ',');
+  }
+  va_end(vals);
+  free(spec);
+
+  return;
+}
+
+void
+rb_set_options (VALUE ropt, const char *spec_in, ...)
+{
+  VALUE rval;
+  char *sp, *tok, *spec;
+  int has_option = 0;
+  va_list vals;
+
+  if ( TYPE(ropt) == T_HASH ) {
+    has_option = 1;
+  }
+  else if ( ! NIL_P(ropt) ) {
+    VALUE inspect = rb_inspect(ropt);
+    rb_raise(rb_eArgError,
+             "<%s> is invalid option specifier",
+             StringValuePtr(inspect));
+  }
+
+  va_start(vals, spec_in);
+  sp = spec = strdup(spec_in);
+  tok = strsep1(&sp, ',');
+  while ( tok != NULL ) {
+    rval = va_arg(vals, VALUE);
+    if ( has_option ) {
+      rb_hash_aset(ropt, ID2SYM(rb_intern(tok)), rval);
+    }
+    tok = strsep1(&sp, ',');
+  }
+  va_end(vals);
+  free(spec);
+
+  return;
+}
+
+
+void
+Init_carray_utils ()
+{
+#if RUBY_VERSION_CODE >= 190
+#else
+  id_beg   = rb_intern("begin");
+  id_end   = rb_intern("end");
+  id_excl  = rb_intern("excl");
+#endif
+
+  rb_define_singleton_method(rb_cCArray, "_scan_float",
+           rb_ca_s_scan_float, -1);
+  rb_define_singleton_method(rb_cCArray, "_scan_int",
+           rb_ca_s_scan_int, -1);
+
+  rb_define_singleton_method(rb_cCArray, "guess_type_and_bytes",
+                             rb_ca_s_guess_type_and_bytes, -1);
+
+}
+