carray 1.5.7 → 1.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53f410eef744cd7d2c38db76556f150cbb1820054bc938fd39d6f45c09dce148
-  data.tar.gz: a3a8994279e0d7b56adbf5a5427390867c6f8fcc4bef5adacdd792a7865efc6b
+  metadata.gz: 536e992ddb82a26f4e24f300892a303306bff88fcd1596b872f418a17879f84c
+  data.tar.gz: e41b0740aaf2319feea6c795a93b1e36c0f4138257429a224e33602c21175b99
 SHA512:
-  metadata.gz: 38a07507ad136d73bc1cbc136853577546187fb5852450471d5ca149d8b8e5edebbd28a688391c0f27666327f90b69421885cea17cbdab6e78cb92ed6ca8844b
-  data.tar.gz: f62fedda0c4d535ed8686cc5a21c96db5e670eb5710eece004d75fc22fcbb89a8dc74b51d412eef65f55454b6885b699ff46b0d8d5c78cdf1413374613218b83
+  metadata.gz: 2ec6a48b80522cd0e583ee0c7feeda490dab810c3c1a8670fd106c654b50c8af3595aaef9dc848082b8d0bd79ee250d7f39d363b123024e93894c385ed93cfd8
+  data.tar.gz: 59e38a1e1d8dc1030b1de81840c7c215df768f1ad15cdaa19e54015ffc6344fc6f2ac381d70509a2f74ba4f1d5dc9588b4b47340ca9e98b8cbb4456c51ce742e

data/NEWS.md

@@ -1,12 +1,23 @@
 ChangeLog of Ruby/CArray
 ========================
 
+1.5.7 -> 1.5.8
+--------------
+
+* [New] Add new method 'CArray#vectorized_section'
+* [New] Add new method 'CArray#fetch_linear_addr'
+* [New] Add new method 'CArray#vectorized_fetch_linear_addr'
+* [New] Add new method 'CArray#str_format'
+* [Fix] Fixed SEGV in loading binary data from the piped input in CArray#load_binary
+
 1.5.6 -> 1.5.7
+--------------
 
 * [Mod] Modify the methods 'CArray#first' and 'CArray#last' to return nil when the number of elements is zero
 * [Fix] Added check of having ArithmeticSeuqence in ruby_carray.c
 
 1.5.5 -> 1.5.6
+--------------
 
 * [Mod] Modify CArray access methods to accept Enumerator::ArithmeticSequence for index, address
 * [Mod] Remove some gem autoloading (io_csv, io_sqlite3, rmagick, cairo, opencv, ffi)
@@ -14,6 +25,7 @@ ChangeLog of Ruby/CArray
 * [Mod] Modify the methods 'CArray#double' etc not to raise error for invalid string in conversion into float
 
 1.5.4 -> 1.5.5
+--------------
 
 * [Fix] Fix recognition of "atan2", ... in "math.h"
 * [Fix] Fix serialize.rb of keyword parameters for Ruby2.7

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification::new do |s|
 
-  version = "1.5.7"
+  version = "1.5.8"
 
   files = Dir.glob("**/*") + [".yardopts"] -
                              [ 

data/ext/carray_attribute.c

@@ -45,7 +45,7 @@ rb_ca_data_type (VALUE self)
 /* @overload ndim
 
 (Attribute) 
-Returns the rank (e.g. 1 for 1D array, 3 for 3D array, ...).
+Returns the number of dimensions (e.g. 1 for 1D array, 3 for 3D array, ...).
 */
 
 VALUE
@@ -60,7 +60,7 @@ rb_ca_ndim (VALUE self)
 
 (Attribute) 
 Returns the byte size of each element (e.g. 4 for CA_INT32, 8 for CA_FLOAT64).
-The byte size can be known using CArray.sizeof(data_type)
+The byte size can be obtained using CArray.sizeof(data_type)
 for the numerical data types, but
 the byte size of fixed-length data type can be known 
 only by this method.

data/ext/carray_conversion.c

@@ -168,7 +168,7 @@ rb_ca_dump_binary (int argc, VALUE *argv, VALUE self)
 #endif
   default:
     if ( rb_respond_to(io, rb_intern("write") ) ) {
-      VALUE buf = rb_str_new(NULL, ca_length(ca));
+      volatile VALUE buf = rb_str_new(NULL, ca_length(ca));
       ca_copy_data(ca, StringValuePtr(buf));
       OBJ_INFECT(buf, self);
       rb_funcall(io, rb_intern("write"), 1, buf);
@@ -210,8 +210,6 @@ rb_ca_load_binary (VALUE self, VALUE io)
     rb_raise(rb_eCADataTypeError, "don't load object array");
   }
 
-  ca_allocate(ca);
-
   switch ( TYPE(io) ) {
   case T_STRING:
     if ( ca_length(ca) > RSTRING_LEN(io) ) {
@@ -219,23 +217,23 @@ rb_ca_load_binary (VALUE self, VALUE io)
                "data size mismatch (%lld for %lld)",
                (ca_size_t) RSTRING_LEN(io), (ca_size_t) ca_length(ca));
     }
+    ca_allocate(ca);
     memcpy(ca->ptr, StringValuePtr(io), ca_length(ca));
+    ca_sync(ca);
+    ca_detach(ca);
     OBJ_INFECT(self, io);
+    return self;
     break;
   default:
     if ( rb_respond_to(io, rb_intern("read") ) ) {
-      VALUE buf = rb_funcall(io, rb_intern("read"), 1, SIZE2NUM(ca_length(ca)));
-      memcpy(ca->ptr, StringValuePtr(buf), ca_length(ca));
-      OBJ_INFECT(self, io);
+      volatile VALUE buf = rb_funcall(io, rb_intern("read"), 1, SIZE2NUM(ca_length(ca)));
+      return rb_ca_load_binary(self, buf);
     }
     else {
       rb_raise(rb_eRuntimeError, "IO like object should have 'read' method");
     }
   }
 
-  ca_sync(ca);
-  ca_detach(ca);
-
   return self;
 }
 

data/ext/carray_iterator.c

@@ -371,7 +371,7 @@ rb_ca_iter_prepare_output (int argc, VALUE *argv, VALUE self)
 
 /* yard:
   class CAIterator
-    def calculate
+    def calculate (data_type=nil, )
     end
   end
 */

data/ext/carray_order.c

@@ -1009,7 +1009,7 @@ rb_ca_binary_search_linear_index (volatile VALUE self, volatile VALUE vx)
   else {
     for (i=0; i<cx->elements; i++) {
       linear_index(n, x, *px, po);
-      px++, po++;
+      px++; po++;
     }
   }
 
@@ -1025,6 +1025,320 @@ rb_ca_binary_search_linear_index (volatile VALUE self, volatile VALUE vx)
 }
 
 
+static VALUE
+rb_ca_binary_search_linear_index_vectorized (volatile VALUE self, volatile VALUE vx)
+{
+  volatile VALUE out, out0;
+  CArray *ca, *sc, *cx, *co0, *co;
+  double *x;
+  double *px;
+  double *po;
+  ca_size_t nseri, nlist;
+  ca_size_t odim[CA_DIM_MAX];
+  ca_size_t i, k;
+
+  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);
+
+  if ( sc->ndim < 2 ) {
+    rb_raise(rb_eRuntimeError, "ndim of self should be larger than 2");
+  }
+
+  if ( cx->ndim > CA_DIM_MAX ) {
+     rb_raise(rb_eRuntimeError, "2nd argument carray has too large dimension");  	
+  }
+
+  nseri = 1;
+  for (i=0; i<sc->ndim-1; i++) {
+		nseri *= sc->dim[i];
+	}
+	nlist = sc->dim[sc->ndim-1];
+
+  if ( rb_ca_is_scalar(vx) ) {
+	  for (i=0; i<sc->ndim-1; i++) {
+	    odim[i] = sc->dim[i];
+		}
+    co0 = carray_new(ca->data_type, sc->ndim-1, odim, 0, NULL);
+	}
+	else {
+	  for (i=0; i<sc->ndim-1; i++) {
+	    odim[i] = sc->dim[i];
+		}
+    memcpy(&odim[sc->ndim], cx->dim, cx->ndim*sizeof(ca_size_t));
+    co0 = carray_new(ca->data_type, sc->ndim-1 + cx->ndim, odim, 0, NULL);
+	}
+	
+  out = out0 = ca_wrap_struct(co0);
+  co = ca_wrap_writable(out, CA_FLOAT64);
+
+  ca_attach_n(3, sc, cx, co);
+
+  x  = (double*) sc->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 (k=0; k<nseri; k++) {
+		  px = (double*) cx->ptr;
+	    for (i=0; i<cx->elements; i++) {
+	      if ( ! *mx ) {
+	        linear_index(nlist, x, *px, po);
+	      }
+	      else {
+	        *mo = 1;
+	      }
+	      mx++; mo++; px++, po++;
+	    }
+			x += nlist;
+    }		
+  }
+  else {
+		for (k=0; k<nseri; k++) {
+		  px = (double*) cx->ptr;
+	    for (i=0; i<cx->elements; i++) {
+	      linear_index(nlist, x, *px, po);
+	      px++; po++;
+	    }
+			x += nlist;
+		}
+  }
+
+  ca_sync(co);
+  ca_detach_n(3, sc, cx, co);
+
+  return out0;
+}
+
+/* ----------------------------------------------------------------- */
+
+static int
+fetch_linear_addr (ca_size_t n, double *y, double idx, double *val)
+{
+  ca_size_t il, iu;
+	double w;
+
+	if ( idx < 0 || idx > n - 1 ) {
+		return -1;
+	}
+	
+	il = (ca_size_t) floor(idx);
+	iu = (ca_size_t) ceil(idx);
+	w  = idx - floor(idx);
+
+	*val = y[iu]*w + y[il]*(1.0-w);
+
+	/* printf("%g %i %i %g %g\n", idx, il, iu, w, *val);  */
+
+  return 0;
+}
+
+static VALUE
+rb_ca_fetch_linear_addr (volatile VALUE self, volatile VALUE vx)
+{
+  volatile VALUE out, out0;
+  CArray *ca, *sc, *cx, *co0, *co;
+  double *x;
+  double *px;
+  double *po;
+  ca_size_t nlist, nreq;
+  ca_size_t i;
+  boolean8_t *mx, *mo;
+
+  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);
+
+  if ( sc->ndim != 1 ) {
+    rb_raise(rb_eRuntimeError, "ndim of self should be 1");
+  }
+	
+	nlist = sc->dim[0];
+
+  nreq = 1;
+  for (i=1; i<cx->ndim; i++) {
+		nreq *= cx->dim[i];
+	}
+
+  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);
+
+  x  = (double*) sc->ptr;
+  px = (double*) cx->ptr;
+  po = (double*) co->ptr;
+
+  ca_create_mask(co);
+  ca_update_mask(cx);
+
+  if ( cx->mask ) {
+    mx = (boolean8_t *) cx->mask->ptr;
+    mo = (boolean8_t *) co->mask->ptr;
+    for (i=0; i<nreq; i++) {
+      if ( ! *mx ) {
+        if ( fetch_linear_addr(nlist, x, *px, po) ) {
+        	*mo = 1;
+        }
+      }
+      else {
+        *mo = 1;
+      }
+      mx++; mo++; px++, po++;
+    }
+  }
+  else {
+    mo = (boolean8_t *) co->mask->ptr;
+    for (i=0; i<nreq; i++) {
+      if ( fetch_linear_addr(nlist, x, *px, po) ) {
+      	*mo = 1;
+      }
+      mo++; 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;
+  }
+}
+
+
+/*
+
+
+  self: ndim >= 2
+        0...ndim :  prev dimensions are vectorized elements
+        -1:         last dimension is used for fetch_addr (as self)
+
+  vx: ndim >= 2
+        0...ndim :  prev dimensions are vectorized elements should be equal to self's
+        -1:        last dimension is used for fetch_addr (as addr)
+
+*/
+
+
+static VALUE
+rb_ca_fetch_linear_addr_vectorized (volatile VALUE self, volatile VALUE vx)
+{
+  volatile VALUE out, out0;
+  CArray *ca, *sc, *cx, *co0, *co;
+  double *x;
+  double *px;
+  double *po;
+  ca_size_t nseri, nlist, nreq, xnseri;
+  ca_size_t i, k;
+  boolean8_t *mx, *mo;
+
+  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);
+
+  if ( sc->ndim < 2 ) {
+    rb_raise(rb_eRuntimeError, "ndim of self should be larger than 2");
+  }
+
+  nseri = 1;
+  for (i=0; i<sc->ndim-1; i++) {
+		nseri *= sc->dim[i];
+	}
+	nlist = sc->dim[sc->ndim-1];
+
+  if ( cx->ndim < sc->ndim - 1 ) {
+    rb_raise(rb_eRuntimeError, "ndim of first argument should be larger than (ndim - 1) of self");  	
+  }
+
+	xnseri = 1;
+  for (i=0; i<sc->ndim-1; i++) {
+		xnseri *= cx->dim[i];
+	}
+	
+	if ( xnseri != nseri ) {
+    rb_raise(rb_eRuntimeError, "1st dimension should be same between self and 1st argument");  			
+	}
+
+	if ( cx->ndim == sc->ndim - 1 ) {
+		nreq = 1;
+	}
+	else {
+	  nreq = cx->dim[cx->ndim-1];
+	}
+
+  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);
+
+  x  = (double*) sc->ptr;
+  px = (double*) cx->ptr;
+  po = (double*) co->ptr;
+
+  ca_create_mask(co);
+  ca_update_mask(cx);
+
+  if ( cx->mask ) {
+    mx = (boolean8_t *) cx->mask->ptr;
+    mo = (boolean8_t *) co->mask->ptr;
+		for (k=0; k<nseri; k++) {
+	    for (i=0; i<nreq; i++) {
+	      if ( ! *mx ) {
+	        if ( fetch_linear_addr(nlist, x, *px, po) ) {
+	        	*mo = 1;
+	        }
+	      }
+	      else {
+	        *mo = 1;
+	      }
+	      mx++; mo++; px++, po++;
+	    }
+			x += nlist;
+    }		
+  }
+  else {
+    mo = (boolean8_t *) co->mask->ptr;
+		for (k=0; k<nseri; k++) {
+	    for (i=0; i<nreq; i++) {
+        if ( fetch_linear_addr(nlist, x, *px, po) ) {
+        	*mo = 1;
+        }
+	      mo++; px++; po++; 
+	    }
+			x += nlist;
+		}
+  }
+
+  ca_sync(co);
+  ca_detach_n(3, sc, cx, co);
+
+  return out0;		
+}
+
 void
 Init_carray_order ()
 {
@@ -1052,4 +1366,13 @@ Init_carray_order ()
   rb_define_method(rb_cCArray,  "section",
                                 rb_ca_binary_search_linear_index, 1);
 
+  rb_define_method(rb_cCArray,  "vectorized_section",
+                                rb_ca_binary_search_linear_index_vectorized, 1);
+
+  rb_define_method(rb_cCArray,  "fetch_linear_addr",
+                                rb_ca_fetch_linear_addr, 1);
+
+  rb_define_method(rb_cCArray,  "vectorized_fetch_linear_addr",
+                                rb_ca_fetch_linear_addr_vectorized, 1);
+
 }

data/ext/ruby_carray.c

@@ -78,6 +78,10 @@ void
 Init_carray_ext ()
 {
 
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
+		
   /* Classes and Modules */
 
 #ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT

data/ext/version.h

@@ -8,9 +8,9 @@
 
 ---------------------------------------------------------------------------- */
 
-#define CA_VERSION "1.5.7"
-#define CA_VERSION_CODE 157
+#define CA_VERSION "1.5.8"
+#define CA_VERSION_CODE 158
 #define CA_VERSION_MAJOR 1
 #define CA_VERSION_MINOR 5
-#define CA_VERSION_TEENY 7
-#define CA_VERSION_DATE "2021/06/16"
+#define CA_VERSION_TEENY 8
+#define CA_VERSION_DATE "2023/01/13"

data/lib/carray/array.rb

@@ -0,0 +1,8 @@
+
+class CArray
+  
+  def zip (*others)
+    return to_a.zip(*others.map(&:to_a))
+  end
+  
+end

data/lib/carray/string.rb

@@ -12,6 +12,11 @@ require "date"
 
 class CArray
 
+  def self.format (fmt, *argv)
+    raise "no parameters given" if argv.empty?
+    return argv.shift.zip(*argv).map { |params| Kernel::format(fmt, *params) }.to_ca
+  end
+
   def str_len ()
     return convert(:int, &:length)
   end

data/lib/carray/time.rb

@@ -30,7 +30,7 @@ class CArray
 
   def time_format (template = nil)
     if template
-      return str_strftime(template)
+      return time_strftime(template)
     else
       return convert(&:to_s)
     end    

data/lib/carray.rb

@@ -36,7 +36,9 @@ require 'carray/math'
 require 'carray/iterator'
 require 'carray/struct'
 require 'carray/table'
+require 'carray/array'
 require 'carray/string'
+require 'carray/time'
 
 # obsolete methods
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 1.5.7
+  version: 1.5.8
 platform: ruby
 authors:
 - Hiroki Motoyoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-16 00:00:00.000000000 Z
+date: 2023-01-13 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Ruby/CArray is an extension library for the multi-dimensional numerical array
@@ -85,6 +85,7 @@ files:
 - ext/version.h
 - ext/version.rb
 - lib/carray.rb
+- lib/carray/array.rb
 - lib/carray/autoload.rb
 - lib/carray/autoload/autoload_base.rb
 - lib/carray/autoload/autoload_gem_cairo.rb
@@ -221,7 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Multi-dimesional array class for Ruby