carray 1.3.6 → 1.5.3

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

@@ -3,10 +3,8 @@
   carray_order.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
+  Copyright (C) 2005-2020 Hiroki Motoyoshi
 
 ---------------------------------------------------------------------------- */
 
@@ -132,7 +130,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 */
@@ -140,26 +138,24 @@ ca_project (CArray *ca, CArray *ci, char *lfill, char *ufill)
   return co;
 }
 
-/* rdoc:
-  class CArray
-    def project (idx,lval=nil,uval=nil)
-    end
-  end
+/* @overload project (idx, lval=nil, uval=nil)
+
+[TBD]. Creates new array the element of the object as address.
 */
 
 VALUE
 rb_ca_project (int argc, VALUE *argv, VALUE self)
 {
-  volatile VALUE obj, rindex, vlfval, vufval;
+  volatile VALUE obj, ridx, vlfval, vufval;
   CArray *ca, *ci, *co;
   char *lfval, *ufval;
 
-  rb_scan_args(argc, argv, "12", (VALUE *) &rindex, (VALUE *) &vlfval, (VALUE *) &vufval);
+  rb_scan_args(argc, argv, "12", (VALUE *)&ridx, (VALUE *) &vlfval, (VALUE *) &vufval);
 
   Data_Get_Struct(self, CArray, ca);
 
-  rb_check_carray_object(rindex);
-  ci = ca_wrap_readonly(rindex, CA_SIZE);
+  rb_check_carray_object(ridx);
+  ci = ca_wrap_readonly(ridx, CA_SIZE);
 
   lfval = malloc_with_check(ca->bytes);
   ufval = malloc_with_check(ca->bytes);
@@ -227,12 +223,9 @@ rb_ca_project (int argc, VALUE *argv, VALUE self)
     free(v);                                            \
   }
 
-/* rdoc:
-  class CArray
-    # Reverses the elements of +ca+ in place.
-    def reverse!
-    end
-  end
+/* @overload reverse!
+
+Reverses the elements of +ca+ in place.
 */
 
 static VALUE
@@ -279,13 +272,10 @@ rb_ca_reverse_bang (VALUE self)
   return self;
 }
 
-/* rdoc:
-  class CArray
-    # Returns a new CArray object containing <i>ca</i>'s elements in
-    # reverse order.
-    def reverse
-    end
-  end
+/* @overload reverse
+
+Returns a new CArray object containing <i>ca</i>'s elements in
+reverse order.
 */
 
 static VALUE
@@ -384,12 +374,9 @@ ca_qsort_cmp[CA_NTYPE] = {
   qcmp_VALUE,
 };
 
-/* rdoc:
-  class CArray
-    # Sorts <i>ca</i>'s elements in place.
-    def sort!
-    end
-  end
+/* @overload sort!
+
+Sorts <i>ca</i>'s elements in place.
 */
 
 static VALUE
@@ -433,12 +420,9 @@ rb_ca_sort_bang (VALUE self)
   return self;
 }
 
-/* rdoc:
-  class CArray
-    # Returns a new CArray object containing <i>ca</i>'s elements sorted.
-    def sort
-    end
-  end
+/* @overload sort
+
+Returns a new CArray object containing <i>ca</i>'s elements sorted.
 */
 
 static VALUE
@@ -449,162 +433,12 @@ 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);
-}
 
 /* --------------------------------------------------------------- */
 
-/* rdoc:
-  class CArray
-    def bsearch
-    end
-  end
+/* @overload bsearch
+
+Returns a new CArray object containing <i>ca</i>'s elements sorted.
 */
 
 static VALUE
@@ -641,7 +475,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) ) {
@@ -709,11 +543,9 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
   return out;
 }
 
-/* rdoc:
-  class CArray
-    def bsearch_index
-    end
-  end
+/* @overload bsearch_index
+
+[TBD]. 
 */
 
 static VALUE
@@ -778,6 +610,33 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
     }                                                        \
   }
 
+#define proc_find_value_float128(type, defeps)                  \
+  {                                                          \
+    type *ptr = (type *) ca->ptr;                            \
+    boolean8_t *m = (ca->mask) ? (boolean8_t*) ca->mask->ptr : NULL; \
+    type val  = (type) NUM2DBL(value);                       \
+    float128_t eps  = (NIL_P(veps)) ? defeps*fabsl(val) : NUM2DBL(veps); \
+    ca_size_t i;                                               \
+    if ( m ) {                                               \
+      for (i=0; i<ca->elements; i++, ptr++) {                \
+        if ( ! *m++ ) {                                      \
+          if ( fabsl(*ptr - val) <= eps ) {                   \
+            addr = i;                                        \
+            break;                                           \
+          }                                                  \
+        }                                                    \
+      }                                                      \
+    }                                                        \
+    else {                                                   \
+      for (i=0; i<ca->elements; i++, ptr++) {                \
+        if ( fabsl(*ptr - val) <= eps ) {                     \
+          addr = i;                                          \
+          break;                                             \
+        }                                                    \
+      }                                                      \
+    }                                                        \
+  }
+
 #define proc_find_value_cmplx(type, defeps)                  \
   {                                                          \
     type *ptr = (type *) ca->ptr;                            \
@@ -831,11 +690,9 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
   }
 
 
-/* rdoc:
-  class CArray
-    def search
-    end
-  end
+/* @overload search
+
+[TBD]. 
 */
 
 static VALUE
@@ -865,7 +722,7 @@ rb_ca_linear_search (int argc, VALUE *argv, VALUE self)
   case CA_UINT64:   proc_find_value(uint64_t); break;
   case CA_FLOAT32:  proc_find_value_float(float32_t, FLT_EPSILON); break;
   case CA_FLOAT64:  proc_find_value_float(float64_t, DBL_EPSILON); break;
-  case CA_FLOAT128: proc_find_value_float(float128_t, DBL_EPSILON); break;
+  case CA_FLOAT128: proc_find_value_float128(float128_t, DBL_EPSILON); break;
 #ifdef HAVE_COMPLEX_H
   case CA_CMPLX64:  proc_find_value_cmplx(cmplx64_t, FLT_EPSILON); break;
   case CA_CMPLX128: proc_find_value_cmplx(cmplx128_t, DBL_EPSILON); break;
@@ -881,11 +738,9 @@ rb_ca_linear_search (int argc, VALUE *argv, VALUE self)
   return ( addr == -1 ) ? Qnil : SIZE2NUM(addr);
 }
 
-/* rdoc:
-  class CArray
-    def search_index
-    end
-  end
+/* @overload search_index
+
+[TBD]. 
 */
 
 static VALUE
@@ -959,11 +814,9 @@ rb_ca_linear_search_index (int argc, VALUE *argv, VALUE self)
     }                                                   \
   }
 
-/* rdoc:
-  class CArray
-    def search_nearest
-    end
-  end
+/* @overload search_nearest
+
+[TBD]. 
 */
 
 static VALUE
@@ -1004,6 +857,11 @@ rb_ca_linear_search_nearest (VALUE self, VALUE value)
   return ( addr == -1 ) ? Qnil : SIZE2NUM(addr);
 }
 
+/* @overload search_nearest_index
+
+[TBD]. 
+*/
+
 static VALUE
 rb_ca_linear_search_nearest_index (VALUE self, VALUE value)
 {
@@ -1024,8 +882,8 @@ 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,  "bsearch", rb_ca_binary_search, 1);
+  rb_define_method(rb_cCArray,  "bsearch_index", rb_ca_binary_search_index, 1);
 
   rb_define_method(rb_cCArray,  "search", rb_ca_linear_search, -1);
   rb_define_method(rb_cCArray,  "search_index", rb_ca_linear_search_index, -1);
@@ -1035,6 +893,4 @@ Init_carray_order ()
   rb_define_method(rb_cCArray,  "search_nearest_index",
                                 rb_ca_linear_search_nearest_index, 1);
 
-  rb_define_method(rb_cCArray,  "bsearch", rb_ca_binary_search, 1);
-  rb_define_method(rb_cCArray,  "bsearch_index", rb_ca_binary_search_index, 1);
 }

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

@@ -3,10 +3,8 @@
   carray_sort_addr.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
+  Copyright (C) 2005-2020 Hiroki Motoyoshi
 
 ---------------------------------------------------------------------------- */
 
@@ -151,16 +149,14 @@ qcmp_func (struct cmp_data *a, struct cmp_data *b)
   return ( ia > ib ) ? 1 : -1; /* for stable sort */
 }
 
-/* rdoc:
-  # returns index table for index sort
-  #
-  #   idx = CA.sort_addr(a, b, c)  ### priority a > b > c
-  #   a[idx]
-  #   b[idx]
-  #   c[idx]
+/* @overload sort_addr (*args)
 
-  def CA.sort_addr (*args)
-  end
+(Sort) Returns index table for index sort
+
+     idx = CA.sort_addr(a, b, c)  ### priority a > b > c
+     a[idx]
+     b[idx]
+     c[idx]
 */
 
 static VALUE
@@ -234,15 +230,12 @@ rb_ca_s_sort_addr (int argc, VALUE *argv, VALUE self)
   return out;
 }
 
-/* rdoc:
-  class CArray
-    # returns index table for index sort
-    # This method same as,
-    #
-    #   idx = CA.sort_addr(self, *args) 
-    def sort_addr (*args)
-    end
-  end
+/* @overload sort_addr (*args)
+
+(Sort) Returns index table for index sort
+ This method same as,
+
+     idx = CA.sort_addr(self, *args) 
 */
 
 static VALUE