carray 1.5.2 → 1.5.7

data/ext/carray_order.c

@@ -869,6 +869,162 @@ rb_ca_linear_search_nearest_index (VALUE self, VALUE value)
   return ( NIL_P(raddr) ) ? Qnil : rb_ca_addr2index(self, raddr);
 }
 
+/* ----------------------------------------------------------------- */
+
+static ca_size_t
+linear_index (ca_size_t n, double *y, double yy, double *idx)
+{
+  ca_size_t a, b, c, x1;
+  double ya, yb, yc;
+  double y1, y2;
+  double rest;
+
+  if ( yy <= y[0] ) {
+    x1 = 0;
+    goto found;
+  }
+
+  if ( yy >= y[n-1] ) {
+    x1 = n-2;
+    goto found;
+  }
+
+  /* check for equally spaced scale */
+
+  a = (ca_size_t)((yy-y[0])/(y[n-1]-y[0])*(n-1));
+
+  if ( a >= 0 && a < n-1 ) {
+    if ( (y[a] - yy) * (y[a+1] - yy) <= 0 ) { /* lucky case */
+      x1 = a;
+      goto found; 
+    }
+  }
+
+  /* binary section method */
+
+  a = 0;
+  b = n-1;
+
+  ya = y[a];
+  yb = y[b];
+
+  if ( ya > yb ) {
+    return -1; /* input scale array should have accending order */
+  }
+
+  while ( (b - a) >= 1 ) {
+
+    c  = (a + b)/2;
+    yc = y[c];
+    if ( a == c ) {
+      break;
+    }
+
+    if ( yc == yy ) {
+      a = c;
+      break;
+    }
+    else if ( (ya - yy) * (yc - yy) <= 0 ) {
+      b = c;
+      yb = yc;
+    }
+    else {
+      a = c;
+      ya = yc;
+    }
+
+    if ( ya > yb ) {
+      return -1; /* input scale array should have accending order */
+    }
+  }
+
+  x1 = a;
+
+ found:
+
+  y1 = y[x1];
+  y2 = y[x1+1];
+  rest = (yy-y1)/(y2-y1);
+
+  if ( fabs(y2-yy)/fabs(y2) < DBL_EPSILON*100 ) {
+    *idx = (double) (x1 + 1);
+  }
+  else if ( fabs(y1-yy)/fabs(y1) < DBL_EPSILON*100 ) {
+    *idx = (double) x1;
+  }
+  else {
+    *idx = rest + (double) x1;
+  }
+
+  return 0;
+}
+
+static VALUE
+rb_ca_binary_search_linear_index (volatile VALUE self, volatile VALUE vx)
+{
+  volatile VALUE out, out0;
+  CArray *ca, *sc, *cx, *co0, *co;
+  ca_size_t n;
+  double *x;
+  double *px;
+  double *po;
+  ca_size_t i;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( rb_ca_is_any_masked(self) ) {
+    rb_raise(rb_eRuntimeError, "self should not have any masked elements");
+  }
+
+  sc = ca_wrap_readonly(self, CA_FLOAT64);
+  cx = ca_wrap_readonly(vx, CA_FLOAT64);
+
+  co0 = carray_new(ca->data_type, cx->ndim, cx->dim, 0, NULL);
+  out = out0 = ca_wrap_struct(co0);
+  co = ca_wrap_writable(out, CA_FLOAT64);
+
+  ca_attach_n(3, sc, cx, co);
+
+  n = sc->elements;
+  x  = (double*) sc->ptr;
+  px = (double*) cx->ptr;
+  po = (double*) co->ptr;
+
+  ca_update_mask(cx);
+  if ( cx->mask ) {
+    boolean8_t *mx, *mo;
+    ca_create_mask(co);
+    mx = (boolean8_t *) cx->mask->ptr;
+    mo = (boolean8_t *) co->mask->ptr;
+    for (i=0; i<cx->elements; i++) {
+      if ( ! *mx ) {
+        linear_index(n, x, *px, po);
+      }
+      else {
+        *mo = 1;
+      }
+      mx++; mo++; px++, po++;
+    }
+  }
+  else {
+    for (i=0; i<cx->elements; i++) {
+      linear_index(n, x, *px, po);
+      px++, po++;
+    }
+  }
+
+  ca_sync(co);
+  ca_detach_n(3, sc, cx, co);
+
+  if ( rb_ca_is_scalar(vx) ) {
+    return rb_funcall(out0, rb_intern("[]"), 1, INT2NUM(0));
+  }
+  else {
+    return out0;
+  }
+}
+
+
 void
 Init_carray_order ()
 {
@@ -893,4 +1049,7 @@ Init_carray_order ()
   rb_define_method(rb_cCArray,  "search_nearest_index",
                                 rb_ca_linear_search_nearest_index, 1);
 
+  rb_define_method(rb_cCArray,  "section",
+                                rb_ca_binary_search_linear_index, 1);
+
 }

data/ext/carray_test.c

@@ -216,6 +216,12 @@ rb_obj_is_data_class (VALUE rtype)
   return Qfalse;
 }
 
+static VALUE
+rb_ca_s_is_data_class (VALUE self, VALUE rklass)
+{
+  return rb_obj_is_data_class(rklass);
+}
+
 /* ------------------------------------------------------------- */
 
 /* @overload valid_index? (*idx)
@@ -239,9 +245,11 @@ rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
   }
   for (i=0; i<ca->ndim; i++) {
     idx = NUM2SIZE(argv[i]);
+		/*
     if ( idx < 0 ) {
       idx += ca->dim[i];
     }
+		*/
     if ( idx < 0 || idx >= ca->dim[i] ) {
       return Qfalse;
     }
@@ -264,9 +272,11 @@ rb_ca_is_valid_addr (VALUE self, VALUE raddr)
 
   Data_Get_Struct(self, CArray, ca);
   addr = NUM2SIZE(raddr);
+	/*
   if ( addr < 0 ) {
     addr += ca->elements;
   }
+	*/
   if ( addr < 0 || addr >= ca->elements ) {
     return Qfalse;
   }
@@ -598,4 +608,7 @@ Init_carray_test ()
   rb_define_method(rb_cCArray, "==", rb_ca_equal, 1);
   rb_define_alias(rb_cCArray, "eql?", "==");
   rb_define_method(rb_cCArray, "hash", rb_ca_hash, 0);
+
+  rb_define_singleton_method(rb_cCArray, "data_class?", rb_ca_s_is_data_class, 1);
+
 }

data/ext/carray_undef.c

@@ -41,12 +41,6 @@ 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 ()
 {
@@ -61,7 +55,5 @@ Init_carray_undef ()
   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/ext/carray_utils.c

@@ -18,36 +18,10 @@
 #include "st.h"
 #endif
 
-#if RUBY_VERSION_CODE >= 240
-#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
-enum {
-  RSTRUCT_EMBED_LEN_MAX = 3,
-  RSTRUCT_ENUM_END
-};
-struct RStruct {
-    struct RBasic basic;
-    union {
-        struct {
-            long len;
-            const VALUE *ptr;
-        } heap;
-        const VALUE ary[RSTRUCT_EMBED_LEN_MAX];
-    } as;
-};
-#define RSTRUCT(obj) (R_CAST(RStruct)(obj))
-#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
-
+static ID id_begin, id_end, id_excl_end;
+#define RANGE_BEG(r)  (rb_funcall(r, id_begin, 0))
+#define RANGE_END(r)  (rb_funcall(r, id_end, 0))
+#define RANGE_EXCL(r) (rb_funcall(r, id_excl_end, 0))
 
 /* ------------------------------------------------------------------- */
 
@@ -163,7 +137,7 @@ void
 ca_parse_range (VALUE arg, ca_size_t size, 
                 ca_size_t *poffset, ca_size_t *pcount, ca_size_t *pstep)
 {
-  ca_size_t first, start, last, count, step, bound, excl;
+  ca_size_t start, last, count, step, bound, excl;
 
  retry:
 
@@ -182,24 +156,59 @@ ca_parse_range (VALUE arg, ca_size_t size,
   }
   else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
                                      /* i..j */
-    first = NUM2SIZE(RANGE_BEG(arg));
+    start = NUM2SIZE(RANGE_BEG(arg));
     last  = NUM2SIZE(RANGE_END(arg));
     excl  = RTEST(RANGE_EXCL(arg));
-    CA_CHECK_INDEX(first, size);
+    CA_CHECK_INDEX(start, size);
     if ( last < 0 ) {
       last += size;
     }
     if ( excl ) {
-      last += ( (last>=first) ? -1 : 1 );
+      last += ( (last>=start) ? -1 : 1 );
     }
     if ( last < 0 || last >= size ) {
       rb_raise(rb_eIndexError,
                "invalid index range");
     }
-    *poffset = first;
-    *pcount  = llabs(last - first) + 1;
+    *poffset = start;
+    *pcount  = llabs(last - start) + 1;
     *pstep   = 1;
   }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+  else if ( rb_obj_is_kind_of(arg, rb_cArithSeq) ) { /* ca[--,ArithSeq,--]*/
+    rb_arithmetic_sequence_components_t x;
+    rb_arithmetic_sequence_extract(arg, &x);
+
+    start = NUM2SIZE(x.begin);
+    last  = NUM2SIZE(x.end);
+    excl  = RTEST(x.exclude_end);
+    step  = NUM2SIZE(x.step);
+    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 = llabs(last - start)/llabs(step) + 1;
+    }
+    bound = start + (count - 1)*step;
+    CA_CHECK_INDEX(bound, size);
+    *poffset = start;
+    *pcount  = count;
+    *pstep   = step;
+  }
+#endif
   else if ( TYPE(arg) == T_ARRAY ) {
     if ( RARRAY_LEN(arg) == 1 ) {     /* [nil] or [i..j] or [i] */
       arg = rb_ary_entry(arg, 0);
@@ -252,6 +261,41 @@ ca_parse_range (VALUE arg, ca_size_t size,
         *pcount  = count;
         *pstep   = step;
       }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+      else if ( rb_obj_is_kind_of(arg0, rb_cArithSeq) ) { /* ca[--,ArithSeq,--]*/
+        rb_arithmetic_sequence_components_t x;
+        rb_arithmetic_sequence_extract(arg0, &x);
+
+        start = NUM2SIZE(x.begin);
+        last  = NUM2SIZE(x.end);
+        excl  = RTEST(x.exclude_end);
+        step  = NUM2SIZE(x.step);
+        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 = llabs(last - start)/llabs(step) + 1;
+        }
+        bound = start + (count - 1)*step;
+        CA_CHECK_INDEX(bound, size);
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+#endif      
       else {                            /* [i,n] */
         start = NUM2SIZE(arg0);
         count = NUM2SIZE(arg1);
@@ -290,7 +334,7 @@ void
 ca_parse_range_without_check (VALUE arg, ca_size_t size,
                               ca_size_t *poffset, ca_size_t *pcount, ca_size_t *pstep)
 {
-  ca_size_t first, start, last, count, step, bound, excl;
+  ca_size_t start, last, count, step, bound, excl;
 
  retry:
 
@@ -308,16 +352,35 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
   }
   else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
                                      /* i..j */
-    first = NUM2SIZE(RANGE_BEG(arg));
+    start = NUM2SIZE(RANGE_BEG(arg));
     last  = NUM2SIZE(RANGE_END(arg));
     excl  = RTEST(RANGE_EXCL(arg));
     if ( excl ) {
-      last += ( (last>=first) ? -1 : 1 );
+      last += ( (last>=start) ? -1 : 1 );
     }
-    *poffset = first;
-    *pcount  = last - first + 1;
+    *poffset = start;
+    *pcount  = last - start + 1;
     *pstep   = 1;
   }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+  else if ( rb_obj_is_kind_of(arg, rb_cArithSeq) ) { /* ca[--,ArithSeq,--]*/
+    rb_arithmetic_sequence_components_t x;
+    rb_arithmetic_sequence_extract(arg, &x);
+
+    start = NUM2SIZE(x.begin);
+    last  = NUM2SIZE(x.end);
+    excl  = RTEST(x.exclude_end);
+    step  = NUM2SIZE(x.step);
+    if ( excl ) {
+      last += ( (last>=start) ? -1 : 1 );
+    }
+    count = (last - start)/llabs(step) + 1;
+    bound = start + (count - 1)*step;
+    *poffset = start;
+    *pcount  = count;
+    *pstep   = step;
+  }
+#endif
   else if ( TYPE(arg) == T_ARRAY ) {
     if ( RARRAY_LEN(arg) == 1 ) {   /* [nil] or [i..j] or [i] */
       arg = rb_ary_entry(arg, 0);
@@ -349,6 +412,25 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
         *pcount  = count;
         *pstep   = step;
       }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+      else if ( rb_obj_is_kind_of(arg0, rb_cArithSeq) ) { /* ca[--,ArithSeq,--]*/
+        rb_arithmetic_sequence_components_t x;
+        rb_arithmetic_sequence_extract(arg0, &x);
+
+        start = NUM2SIZE(x.begin);
+        last  = NUM2SIZE(x.end);
+        excl  = RTEST(x.exclude_end);
+        step  = NUM2SIZE(x.step);
+        if ( excl ) {
+          last += ( (last>=start) ? -1 : 1 );
+        }
+        count = (last - start)/llabs(step) + 1;
+        bound = start + (count - 1)*step;
+        *poffset = start;
+        *pcount  = count;
+        *pstep   = step;
+      }
+#endif
       else {                            /* [i,n] */
         start = NUM2SIZE(arg0);
         count = NUM2SIZE(arg1);
@@ -750,12 +832,9 @@ rb_set_options (VALUE ropt, const char *spec_in, ...)
 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
+  id_begin    = rb_intern("begin");
+  id_end      = rb_intern("end");
+  id_excl_end = rb_intern("exclude_end?");
 
   rb_define_singleton_method(rb_cCArray, "_scan_float",
            rb_ca_s_scan_float, -1);