carray 1.4.0 → 1.5.1

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

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

@@ -1383,7 +1383,7 @@ ca_stat_nd_contig_loop (CArray *ca, CArray *co, ca_size_t mc,
   void *p;
   boolean8_t *m;
   ca_size_t i, n;
-  if ( level == co->rank ) {
+  if ( level == co->ndim ) {
     CAStatIterator it;
     n = ca->elements/co->elements;
     idx[level] = 0;
@@ -1421,8 +1421,8 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
              ca_type_name[ca->data_type]);
   }
 
-  ndim = ca->rank - RARRAY_LEN(vaxis);
-  if ( ndim <= 0 || ndim > ca->rank ) {
+  ndim = ca->ndim - RARRAY_LEN(vaxis);
+  if ( ndim <= 0 || ndim > ca->ndim ) {
     rb_raise(rb_eRuntimeError, "invalid dimension specified");
   }
 
@@ -1449,7 +1449,7 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
     char *op;
     boolean8_t *om;
     int8_t i;
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       idx[i] = 0;
     }
     ca_attach_n(2, ca, co);
@@ -1474,7 +1474,7 @@ ca_stat_get_offset_loop (CArray *ca, ca_size_t *dm,
                         CArray *offset)
 {
   ca_size_t i;
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( dm[level] == 0 ) {
       idx[level] = 0;
       *(ca_size_t *)ca_ptr_at_index(offset, idx1) = ca_index2addr(ca, idx);
@@ -1513,13 +1513,13 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
   ca_size_t loop_dim[CA_RANK_MAX];
   ca_size_t dm[CA_RANK_MAX], dn[CA_RANK_MAX];
   CArray *ca, *co, *first, *offset;
-  ca_size_t out_rank, loop_rank;
+  ca_size_t out_ndim, loop_ndim;
   ca_size_t mc;
   ca_size_t i, k;
 
   Data_Get_Struct(self, CArray, ca);
 
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     dm[i] = 0;
     dn[i] = 1;
   }
@@ -1530,26 +1530,26 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
     dn[k] = 0;
   }
 
-  out_rank  = 0;
-  loop_rank = 0;
-  for (i=0; i<ca->rank; i++) {
+  out_ndim  = 0;
+  loop_ndim = 0;
+  for (i=0; i<ca->ndim; i++) {
     if ( dm[i] ) {
-      loop_dim[loop_rank] = ca->dim[i];
-      loop_rank += 1;
+      loop_dim[loop_ndim] = ca->dim[i];
+      loop_ndim += 1;
     }
     else {
-      out_dim[out_rank] = ca->dim[i];
-      out_rank += 1;
+      out_dim[out_ndim] = ca->dim[i];
+      out_ndim += 1;
     }
   }
 
-  out    = rb_carray_new(data_type, out_rank, out_dim, 0, NULL);
+  out    = rb_carray_new(data_type, out_ndim, out_dim, 0, NULL);
   Data_Get_Struct(out, CArray, co);
   
-  first  = carray_new(CA_SIZE, out_rank, out_dim, 0, NULL);
+  first  = carray_new(CA_SIZE, out_ndim, out_dim, 0, NULL);
   first->ptr = realloc(first->ptr, first->bytes*(first->elements+1));
 
-  offset = carray_new(CA_SIZE, loop_rank, loop_dim, 0, NULL);
+  offset = carray_new(CA_SIZE, loop_ndim, loop_dim, 0, NULL);
   offset->ptr = realloc(offset->ptr, offset->bytes*(offset->elements+1));
 
   ca_stat_get_offset_loop(ca, dn, 0, idx, 0, idx1, first);
@@ -1673,14 +1673,14 @@ rb_ca_stat_general (int argc, VALUE *argv, VALUE self,
 
     for (i=0; i<RARRAY_LEN(vaxis); i++) {
       k = NUM2SIZE(rb_ary_entry(vaxis, RARRAY_LEN(vaxis)-1-i));
-      CA_CHECK_INDEX(k, ca->rank);
-      if ( k != ca->rank-1-i ) {
+      CA_CHECK_INDEX(k, ca->ndim);
+      if ( k != ca->ndim-1-i ) {
         is_contig = 0;
       }
     }
 
     if ( is_contig ) {
-      if ( RARRAY_LEN(vaxis) == ca->rank ) {
+      if ( RARRAY_LEN(vaxis) == ca->ndim ) {
         return rb_ca_stat_1d(self, rmc, vfval, ca_proc);
       }
       else {
@@ -1841,7 +1841,7 @@ ca_dimstat_type2_loop (CArray *ca, CArray *co, ca_size_t mc,
   void *p;
   boolean8_t *m;
   ca_size_t i, n;
-  if ( level == co->rank ) {
+  if ( level == co->ndim ) {
     CAStatIterator it;
     n = ca->elements/co->elements;
     idx[level] = 0;
@@ -1871,7 +1871,7 @@ ca_dimstat_type2 (CArray *ca, CArray *co, ca_size_t mc, ca_stat_proc_t *ca_proc)
   char *op;
   boolean8_t *om;
   int8_t i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx[i] = 0;
   }
   ca_attach_n(2, ca, co);
@@ -1904,7 +1904,7 @@ rb_ca_dimstat_type2 (int argc, VALUE *argv, VALUE self,
   }
 
   ndim = NUM2SIZE(rndim);
-  if ( ndim <= 0 || ndim > ca->rank ) {
+  if ( ndim <= 0 || ndim > ca->ndim ) {
     rb_raise(rb_eRuntimeError, "invalid dimension specified");
   }
 

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

@@ -34,26 +34,26 @@ ca_check_type (void *ap, int8_t data_type)
 }
 
 void
-ca_check_rank (void *ap, int rank)
+ca_check_ndim (void *ap, int ndim)
 {
   CArray *ca = (CArray *) ap;
   if ( ! ca_is_scalar(ca) ) {
-    if ( ca->rank != rank ) {
-      rb_raise(rb_eRuntimeError, "rank mismatch");
+    if ( ca->ndim != ndim ) {
+      rb_raise(rb_eRuntimeError, "ndim mismatch");
     }
   }
 }
 
 void
-ca_check_shape (void *ap, int rank, ca_size_t *dim)
+ca_check_shape (void *ap, int ndim, ca_size_t *dim)
 {
   CArray *ca = (CArray *) ap;
   int i;
   if ( ! ca_is_scalar(ca) ) {
-    if ( ca->rank != rank ) {
+    if ( ca->ndim != ndim ) {
       rb_raise(rb_eRuntimeError, "shape mismatch");
     }
-    for (i=0; i<rank; i++) {
+    for (i=0; i<ndim; i++) {
       if ( ca->dim[i] != dim[i] ) {
         rb_raise(rb_eRuntimeError, "shape mismatch");
       }
@@ -72,12 +72,12 @@ ca_check_same_data_type (void *ap1, void *ap2)
 }
 
 void
-ca_check_same_rank (void *ap1, void *ap2)
+ca_check_same_ndim (void *ap1, void *ap2)
 {
   CArray *ca1 = (CArray *) ap1;
   CArray *ca2 = (CArray *) ap2;
-  if ( ca1->rank != ca2->rank ) {
-    rb_raise(rb_eRuntimeError, "rank mismatch");
+  if ( ca1->ndim != ca2->ndim ) {
+    rb_raise(rb_eRuntimeError, "ndim mismatch");
   }
 }
 
@@ -98,10 +98,10 @@ ca_check_same_shape (void *ap1, void *ap2)
   CArray *ca2 = (CArray *) ap2;
   int i;
   if ( ( ! ca_is_scalar(ca1) ) && ( ! ca_is_scalar(ca2) ) ) {
-    if ( ca1->rank != ca2->rank ) {
+    if ( ca1->ndim != ca2->ndim ) {
       rb_raise(rb_eRuntimeError, "shape mismatch");
     }
-    for (i=0; i<ca1->rank; i++) {
+    for (i=0; i<ca1->ndim; i++) {
       if ( ca1->dim[i] != ca2->dim[i] ) {
         rb_raise(rb_eRuntimeError, "shape mismatch");
       }
@@ -114,7 +114,7 @@ ca_check_index (void *ap, ca_size_t *idx)
 {
   CArray *ca = (CArray *) ap;
   int i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     if ( idx[i] < 0 || idx[i] >= ca->dim[i] ) {
       rb_raise(rb_eRuntimeError, "invalid index");
     }
@@ -140,11 +140,11 @@ ca_has_same_shape (void *ap1, void *ap2)
   if ( ca_is_scalar(ca1) || ca_is_scalar(ca2) ) {
     return 1;
   }
-  else if ( ca1->rank != ca2->rank ) {
+  else if ( ca1->ndim != ca2->ndim ) {
     return 0;
   }
   else {
-    for (i=0; i<ca1->rank; i++) {
+    for (i=0; i<ca1->ndim; i++) {
       if ( ca1->dim[i] != ca2->dim[i] ) {
         return 0;
       }
@@ -158,7 +158,7 @@ ca_is_valid_index (void *ap, ca_size_t *idx)
 {
   CArray *ca = (CArray *) ap;
   int8_t i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     if ( idx[i] < 0 || idx[i] >= ca->dim[i] ) {
       return 0;
     }
@@ -236,11 +236,11 @@ rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  if ( argc != ca->rank ) {
+  if ( argc != ca->ndim ) {
     rb_raise(rb_eArgError,
-             "invalid # of arguments (%i for %i)", argc, ca->rank);
+             "invalid # of arguments (%i for %i)", argc, ca->ndim);
   }
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx = NUM2SIZE(argv[i]);
     if ( idx < 0 ) {
       idx += ca->dim[i];
@@ -381,7 +381,7 @@ ca_equal (void *ap, void *bp)
     return 0;
   }
 
-  if ( ca->rank != cb->rank )  {          /* rank comparison */
+  if ( ca->ndim != cb->ndim )  {          /* ndim comparison */
     return 0;
   }
 
@@ -389,7 +389,7 @@ ca_equal (void *ap, void *bp)
     return 0;
   }
 
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     if ( ca->dim[i] != cb->dim[i] ) {     /* dimensional shape comparison */
       return 0;
     }
@@ -571,9 +571,11 @@ rb_ca_modify (VALUE self)
   if ( OBJ_FROZEN(self) ) {
     rb_error_frozen("CArray object");
   }
+  /*
   if ( ( ! OBJ_TAINTED(self) ) && rb_safe_level() >= 4 ) {
     rb_raise(rb_eSecurityError, "Insecure: can't modify carray");
   }
+  */
 }
 
 VALUE
@@ -585,7 +587,6 @@ rb_ca_freeze (VALUE self)
   return rb_obj_freeze(self);
 }
 
-
 void
 Init_carray_test ()
 {