carray 1.3.5 → 1.5.1

data/{carray_math.rb → ext/carray_math.rb}

@@ -10,7 +10,7 @@
 #
 # ----------------------------------------------------------------------------
 
-require './mkmath.rb'
+require_relative './mkmath'
 
 HEADERS << <<HERE_END
 /* ---------------------------------------------------------------------------
@@ -228,22 +228,22 @@ binop("pmin", "pmin",
       CMPLX_TYPES => nil,
       OBJ_TYPES =>'(#3) = rb_funcall(rb_assoc_new((#1),(#2)), rb_intern("min"), 0);')
 
-binop("add", "add",
+binop("+", "add",
       ALL_TYPES =>"(#3) = (#1) + (#2);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = (#1) + (#2);" : nil,
       OBJ_TYPES =>'(#3) = rb_funcall((#1), id_plus, 1, (#2));')
 
-binop("sub", "sub",
+binop("-", "sub",
       ALL_TYPES => "(#3) = (#1) - (#2);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = (#1) - (#2);" : nil,
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_minus, 1, (#2));')
 
-binop("mul", "mul",
+binop("*", "mul",
       ALL_TYPES => "(#3) = (#1) * (#2);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = (#1) * (#2);" : nil,
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_star, 1, (#2));')
 
-binop("div", "div",
+binop("/", "div",
       INT_TYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);",
       FLOAT_TYPES => "(#3) = (#1) / (#2);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = (#1) / (#2);" : nil,
@@ -258,21 +258,21 @@ binop("rcp_mul", "rcp_mul",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = (#2) / (#1);" : nil,
       OBJ_TYPES => '(#3) = rb_funcall((#2), id_slash, 1, (#1));')
 
-binop("mod", "mod",
+binop("%", "mod",
       INT_TYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_percent, 1, (#2));')
 
-binop("bit_and", "bit_and_i",
+binop("&", "bit_and_i",
       BOOL_TYPES => "(#3) = (#1) & (#2);",
       INT_TYPES => "(#3) = (#1) & (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_and, 1, (#2));')
 
-binop("bit_or", "bit_or_i",
+binop("|", "bit_or_i",
       BOOL_TYPES => "(#3) = (#1) | (#2);",
       INT_TYPES => "(#3) = (#1) | (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_or, 1, (#2));')
 
-binop("bit_xor", "bit_xor_i",
+binop("^", "bit_xor_i",
       BOOL_TYPES => "(#3) = ((#1) != (#2)) ? 1 : 0;",
       INT_TYPES => "(#3) = (#1) ^ (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_xor, 1, (#2));')
@@ -329,11 +329,11 @@ METHODS << %{
   rb_define_method(rb_cCArray, "bit_xor", rb_ca_bit_xor, 1);
 }
 
-binop("bit_lshift", "bit_lshift",
+binop("<<", "bit_lshift",
       INT_TYPES => "(#3) = (#1) << (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_lshift, 1, (#2));')
 
-binop("bit_rshift", "bit_rshift",
+binop(">>", "bit_rshift",
       INT_TYPES => "(#3) = (#1) >> (#2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_rshift, 1, (#2));')
 
@@ -461,16 +461,16 @@ METHODS << %{
   rb_define_method(rb_cCArray, "xor", rb_ca_xor, 1);
 }
 
-alias_op("+", "add")
-alias_op("-", "sub")
-alias_op("*", "mul")
-alias_op("/", "div")
-alias_op("%", "mod")
-alias_op("&", "bit_and")
-alias_op("|", "bit_or")
-alias_op("^", "bit_xor")
-alias_op("<<", "bit_lshift")
-alias_op(">>", "bit_rshift")
+alias_op("add", "+")
+alias_op("sub", "-")
+alias_op("mul", "*")
+alias_op("div", "/")
+alias_op("mod", "%")
+alias_op("bit_and", "&")
+alias_op("bit_or", "|")
+alias_op("bit_xor", "^")
+alias_op("bit_lshift", "<<")
+alias_op("bit_rshift", ">>")
 
 #alias_op("==", "eq")
 #alias_op("!=", "ne")
@@ -697,7 +697,7 @@ rb_ca_ipower (VALUE self, VALUE other)
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca;
-    obj = rb_ca_ubrep_new(obj, cx->rep_rank, cx->rep_dim);
+    obj = rb_ca_ubrep_new(obj, cx->rep_ndim, cx->rep_dim);
   }
 
   return obj;
@@ -752,7 +752,7 @@ rb_ca_ipower_bang (VALUE self, VALUE other)
 
 }
 
-binop("power", "power",
+binop("**", "power",
       INT_TYPES   => "(#3) = op_powi_<type>((#1), (#2));",
       FLOAT_TYPES => "(#3) = pow((#1), (#2));",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#3) = cpow((#1), (#2));" : nil,
@@ -776,7 +776,7 @@ static VALUE rb_ca_pow (VALUE self, VALUE other)
     /* unresolved unbound repeat array generates unbound repeat array again */
     if ( ca->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
       CAUnboundRepeat *cx = (CAUnboundRepeat *) ca;
-      obj = rb_ca_ubrep_new(obj, cx->rep_rank, cx->rep_dim);
+      obj = rb_ca_ubrep_new(obj, cx->rep_ndim, cx->rep_dim);
     }
 
     return obj;
@@ -803,7 +803,7 @@ METHODS << %{
   rb_define_method(rb_cCArray, "pow!", rb_ca_pow_bang, 1);
 }
 
-alias_op("**", "pow")
+alias_op("pow", "**")
 
 METHODS << %{
   id_equal = rb_intern("==");

data/{carray_numeric.c → ext/carray_numeric.c}

@@ -168,7 +168,7 @@ rb_ca_arg (VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  co = carray_new(CA_FLOAT64, ca->rank, ca->dim, 0, NULL);
+  co = carray_new(CA_FLOAT64, ca->ndim, ca->dim, 0, NULL);
   obj = ca_wrap_struct(co);
 
   if ( ca_has_mask(ca) ) {

data/{carray_operator.c → ext/carray_operator.c}

@@ -58,7 +58,7 @@ rb_ca_call_monop (VALUE self, ca_monop_func_t func[])
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca1->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca1;
-    out = rb_ca_ubrep_new(out, cx->rep_rank, cx->rep_dim);
+    out = rb_ca_ubrep_new(out, cx->rep_ndim, cx->rep_dim);
   }
 
   return out;
@@ -84,6 +84,29 @@ rb_ca_call_monop_bang (VALUE self, ca_monop_func_t func[])
   return self;
 }
 
+int
+rb_ca_test_castable (VALUE other)
+{
+  volatile VALUE retval;
+  if ( rb_respond_to(other, rb_intern("castable_to_carray?")) ) {
+    retval = rb_funcall(other, rb_intern("castable_to_carray?"), 0);
+    return RTEST(retval); 
+  }
+  else {
+    return 1;
+  }
+}
+
+VALUE 
+rb_ca_binop_pass_to_other (VALUE self, VALUE other, ID method)
+{
+  volatile VALUE pair;
+  pair = rb_funcall(other, rb_intern("coerce"), 1, self);
+  self  = rb_ary_entry(pair, 0);
+  other = rb_ary_entry(pair, 1);
+  return rb_funcall(self, method, 1, other);
+}
+
 VALUE
 rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
                                          ca_binop_func_t func[])
@@ -174,13 +197,13 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca1->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca1;
-    out = rb_ca_ubrep_new(out, cx->rep_rank, cx->rep_dim);
+    out = rb_ca_ubrep_new(out, cx->rep_ndim, cx->rep_dim);
   }
 
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca2->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca2;
-    out = rb_ca_ubrep_new(out, cx->rep_rank, cx->rep_dim);
+    out = rb_ca_ubrep_new(out, cx->rep_ndim, cx->rep_dim);
   }
 
   return out;
@@ -264,7 +287,7 @@ rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[])
     out = rb_cscalar_new(CA_BOOLEAN, 0, NULL);
   }
   else {
-    out = rb_carray_new(CA_BOOLEAN, ca1->rank, ca1->dim, 0, NULL);
+    out = rb_carray_new(CA_BOOLEAN, ca1->ndim, ca1->dim, 0, NULL);
   }
 
   Data_Get_Struct(out, CArray, ca2);
@@ -279,7 +302,7 @@ rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[])
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca1->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca1;
-    out = rb_ca_ubrep_new(out, cx->rep_rank, cx->rep_dim);
+    out = rb_ca_ubrep_new(out, cx->rep_ndim, cx->rep_dim);
   }
 
   return out;
@@ -330,7 +353,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
                            ca3->ptr, ca3->bytes, 0);
     }
     else {                                          /* scalar vs array */
-      out = rb_carray_new(CA_BOOLEAN, ca2->rank, ca2->dim, 0, NULL);
+      out = rb_carray_new(CA_BOOLEAN, ca2->ndim, ca2->dim, 0, NULL);
       Data_Get_Struct(out, CArray, ca3);
 
       ca_copy_mask_overlay(ca3, ca3->elements, 2, ca1, ca2);
@@ -342,7 +365,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
   }
   else {
     if ( rb_obj_is_cscalar(other) ) {  /* array vs scalar */
-      out = rb_carray_new(CA_BOOLEAN, ca1->rank, ca1->dim, 0, NULL);
+      out = rb_carray_new(CA_BOOLEAN, ca1->ndim, ca1->dim, 0, NULL);
       Data_Get_Struct(out, CArray, ca3);
 
       ca_copy_mask_overlay(ca3, ca3->elements, 2, ca1, ca2);
@@ -356,7 +379,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
         rb_raise(rb_eRuntimeError, "elements mismatch in bincmp (%lld <-> %lld)",
                                  (ca_size_t) ca1->elements, (ca_size_t) ca2->elements);
       }
-      out = rb_carray_new(CA_BOOLEAN, ca1->rank, ca1->dim, 0, NULL);
+      out = rb_carray_new(CA_BOOLEAN, ca1->ndim, ca1->dim, 0, NULL);
       Data_Get_Struct(out, CArray, ca3);
 
       ca_copy_mask_overlay(ca3, ca3->elements, 2, ca1, ca2);
@@ -372,7 +395,7 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
   /* unresolved unbound repeat array generates unbound repeat array again */
   if ( ca1->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     CAUnboundRepeat *cx = (CAUnboundRepeat *) ca1;
-    out = rb_ca_ubrep_new(out, cx->rep_rank, cx->rep_dim);
+    out = rb_ca_ubrep_new(out, cx->rep_ndim, cx->rep_dim);
   }
 
   return out;

data/{carray_order.c → ext/carray_order.c}

@@ -132,7 +132,7 @@ ca_project (CArray *ca, CArray *ci, char *lfill, char *ufill)
 
   ca_attach_n(2, ca, ci); /* ATTACH */
 
-  co = carray_new(ca->data_type, ci->rank, ci->dim, ca->bytes, NULL);
+  co = carray_new(ca->data_type, ci->ndim, ci->dim, ca->bytes, NULL);
   ca_project_loop(co, ca, ci, lfill, ufill);
 
   ca_detach_n(2, ca, ci); /* DETACH */
@@ -449,154 +449,6 @@ rb_ca_sorted_copy (VALUE self)
   return rb_ca_sort_bang(out);
 }
 
-/* --------------------------------------------------------------- */
-
-/*
-  Fisher-Yates method
-
-  # [ruby-list:41356]
-  # From: Shin-ichiro HARA <sinara blade.nagaokaut.ac.jp>
-  def shuffle!
-    array = self
-    array.each_index do |idx|
-      jdx = rand(idx + 1)
-      array[idx], array[jdx] = array[jdx], array[idx]
-    end
-    self
-  end
-*/
-
-#define proc_shuffle(type)                      \
-  {                                             \
-    ca_size_t idx, jdx;                           \
-    type *ptr, *p, *q;                          \
-    type t1;                                    \
-    ptr = (type *) ca->ptr;                     \
-    if ( ca->mask ) {                           \
-      boolean8_t *mptr, *mp, *mq;                \
-      boolean8_t mt1;                            \
-      mptr = (boolean8_t *)ca->mask->ptr;        \
-      for (idx=0; idx<ca->elements; idx++) {    \
-        jdx = ca_rand((double)(idx+1));         \
-        p = ptr + idx;                          \
-        q = ptr + jdx;                          \
-        mp = mptr + idx;                        \
-        mq = mptr + jdx;                        \
-        t1 = *p; *p = *q; *q = t1;              \
-        mt1 = *mp; *mp = *mq; *mq = mt1;        \
-      }                                         \
-    }                                           \
-    else {                                      \
-      for (idx=0; idx<ca->elements; idx++) {    \
-        jdx = ca_rand((double)(idx+1));         \
-        p = ptr + idx;                          \
-        q = ptr + jdx;                          \
-        t1 = *p; *p = *q; *q = t1;              \
-      }                                         \
-    }                                           \
-  }
-
-#define proc_shuffle_fixlen()                   \
-  {                                             \
-    ca_size_t idx, jdx;                           \
-    char *ptr, *p, *q;                          \
-    char *t = (char*) malloc_with_check(ca->bytes); \
-    ca_size_t bytes = ca->bytes;                  \
-    ptr = ca->ptr;                              \
-    if ( ca->mask ) {                           \
-      boolean8_t *mptr, *mp, *mq;                \
-      boolean8_t mt1;                            \
-      mptr = (boolean8_t *)ca->mask->ptr;        \
-      for (idx=0; idx<ca->elements; idx++) {    \
-        jdx = ca_rand((double)(idx+1));         \
-        p = ca->ptr + idx*bytes;                \
-        q = ca->ptr + jdx*bytes;                \
-        mp = mptr + idx;                        \
-        mq = mptr + jdx;                        \
-        memcpy(t, p, bytes); memcpy(p, q, bytes); memcpy(q, t, bytes);  \
-        mt1 = *mp; *mp = *mq; *mq = mt1;        \
-      }                                                                 \
-      free(t);                                                          \
-    }                                                                   \
-    else {                                      \
-      for (idx=0; idx<ca->elements; idx++) {    \
-        jdx = ca_rand((double)(idx+1));         \
-        p = ca->ptr + idx*bytes;                \
-        q = ca->ptr + jdx*bytes;                                     \
-        memcpy(t, p, bytes); memcpy(p, q, bytes); memcpy(q, t, bytes);  \
-      }                                                                 \
-      free(t);                                                          \
-    }                                                                   \
-  }
-
-void ca_check_rand_init ();
-
-/* rdoc:
-  class CArray
-    # shuffles the elements.
-    # If `self` has mask, the masked elements are also moved by shuffling.
-    def shuffle!
-    end
-  end
-*/
-
-static VALUE
-rb_ca_shuffle_bang (VALUE self)
-{
-  CArray *ca;
-
-  rb_ca_modify(self);
-
-  Data_Get_Struct(self, CArray, ca);
-
-  ca_check_rand_init();
-
-  ca_attach(ca);
-
-  switch ( ca->data_type ) {
-  case CA_BOOLEAN:
-  case CA_INT8:     proc_shuffle(int8_t);     break;
-  case CA_UINT8:    proc_shuffle(uint8_t);   break;
-  case CA_INT16:    proc_shuffle(int16_t);    break;
-  case CA_UINT16:   proc_shuffle(uint16_t);  break;
-  case CA_INT32:    proc_shuffle(int32_t);    break;
-  case CA_UINT32:   proc_shuffle(uint32_t);  break;
-  case CA_INT64:    proc_shuffle(int64_t);    break;
-  case CA_UINT64:   proc_shuffle(uint64_t);  break;
-  case CA_FLOAT32:  proc_shuffle(float32_t);  break;
-  case CA_FLOAT64:  proc_shuffle(float64_t);  break;
-  case CA_FLOAT128: proc_shuffle(float128_t); break;
-#ifdef HAVE_COMPLEX_H
-  case CA_CMPLX64:  proc_shuffle(cmplx64_t);  break;
-  case CA_CMPLX128: proc_shuffle(cmplx128_t); break;
-  case CA_CMPLX256: proc_shuffle(cmplx256_t); break;
-#endif
-  case CA_FIXLEN: proc_shuffle_fixlen();  break;
-  case CA_OBJECT:   proc_shuffle(VALUE);      break;
-  default:
-    rb_raise(rb_eCADataTypeError, "[BUG] array has an unknown data type");
-  }
-
-  ca_sync(ca);
-  ca_detach(ca);
-
-  return self;
-}
-
-/* rdoc:
-  class CArray
-    def shuffle
-    end
-  end
-*/
-
-static VALUE
-rb_ca_shuffled_copy (VALUE self)
-{
-  volatile VALUE out = rb_ca_copy(self);
-  rb_ca_data_type_inherit(out, self);
-  return rb_ca_shuffle_bang(out);
-}
 
 /* --------------------------------------------------------------- */
 
@@ -641,7 +493,7 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
     if ( ca->data_type != cv->data_type ) {
       cv = ca_wrap_readonly(rval, ca->data_type);
     }
-    co = carray_new(CA_SIZE, cv->rank, cv->dim, 0, NULL);
+    co = carray_new(CA_SIZE, cv->ndim, cv->dim, 0, NULL);
     out = ca_wrap_struct(co);
     ca_attach(cv);
     if ( ca_is_fixlen_type(ca) ) {
@@ -1024,9 +876,6 @@ Init_carray_order ()
   rb_define_method(rb_cCArray,  "sort!", rb_ca_sort_bang, 0);
   rb_define_method(rb_cCArray,  "sort", rb_ca_sorted_copy, 0);
 
-  rb_define_method(rb_cCArray,  "shuffle!", rb_ca_shuffle_bang, 0);
-  rb_define_method(rb_cCArray,  "shuffle", rb_ca_shuffled_copy, 0);
-
   rb_define_method(rb_cCArray,  "search", rb_ca_linear_search, -1);
   rb_define_method(rb_cCArray,  "search_index", rb_ca_linear_search_index, -1);
 

data/{carray_stat.c → ext/carray_stat.c}

@@ -293,10 +293,10 @@ rb_ca_cumprod (int argc, VALUE *argv, VALUE self)
   Data_Get_Struct(self, CArray, ca);
 
   if ( ca_is_complex_type(ca) ) {
-    co = carray_new(CA_CMPLX128, ca->rank, ca->dim, 0, NULL);
+    co = carray_new(CA_CMPLX128, ca->ndim, ca->dim, 0, NULL);
   }
   else {
-    co = carray_new(CA_FLOAT64, ca->rank, ca->dim, 0, NULL);
+    co = carray_new(CA_FLOAT64, ca->ndim, ca->dim, 0, NULL);
   }
 
   min_count = ( NIL_P(rmin_count) || ! ca_has_mask(ca) ) ?
@@ -504,10 +504,10 @@ rb_ca_cumwsum (int argc, VALUE *argv, VALUE self)
   }
 
   if ( ca_is_complex_type(ca) ) {
-    co = carray_new(CA_CMPLX128, ca->rank, ca->dim, 0, NULL);
+    co = carray_new(CA_CMPLX128, ca->ndim, ca->dim, 0, NULL);
   }
   else {
-    co = carray_new(CA_FLOAT64, ca->rank, ca->dim, 0, NULL);
+    co = carray_new(CA_FLOAT64, ca->ndim, ca->dim, 0, NULL);
   }
 
   min_count = ( NIL_P(rmin_count) || ( ! ca_has_mask(ca) ) ) ?
@@ -2029,7 +2029,7 @@ rb_ca_grade (int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eArgError, "bin number must be larger than 1");
   }
 
-  out = rb_carray_new_safe(CA_SIZE, ca->rank, ca->dim, 0, NULL);
+  out = rb_carray_new_safe(CA_SIZE, ca->ndim, ca->dim, 0, NULL);
   Data_Get_Struct(out, CArray, sa);
 
   ca_attach(ca);