carray 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17e4fbee624a609253882db54f549e00916542bf9f98e3b3c42ed4e5d59d66e5
-  data.tar.gz: 482567a72214af98ccd8153b382ac04ea479b0b429831a6a604fb4af5f8d81a1
+  metadata.gz: 0bcafe56b32f0ad6542bab2d0236d82a8b4bf0a30fa94bd595dfad9bde4c4c55
+  data.tar.gz: dbf49a82458355e015b61055dfdede6ef68540baa95677834f65ad39b689acbc
 SHA512:
-  metadata.gz: 2de7c7b26e38aa9b66e050616c69fdb2587d71da4f37e9fa0d1b3022427656260fda644d5eee913c64d8104823f1a34c70a813e15baa04c7fa64b855be202506
-  data.tar.gz: de95a6f88c5408677170014c2e6d1661e9c020bb130d6a22c506483588cd3a1373a44aba427acd0883a1161cfa27ad001dd686747682bef790dde516e2358a33
+  metadata.gz: 36328e14797d232525715cfd635a64e5526cc667168498cb603248b8210de92ab0ad7dbc4ee07c4b586dda1ed2b34e55cdc52d0ca0da7f9dc5984e9600ee8cbc
+  data.tar.gz: 10a03a1938771eda7f821052bac82ecae05496c4ef463530e2160421547b0364cccec09e11bc86f029dcd6ad9233aa13cdae4e322b22513b39263333f1d68804

data/.yardopts

@@ -1,5 +1,5 @@
 --markup markdown
---markup-provider kramdown
+--markup-provider redcarpet
 --no-private
 --exclude lib/carray/obsolete.rb
 --exclude lib/carray/autoload.rb

data/NEWS.md

@@ -1,6 +1,19 @@
 ChangeLog of Ruby/CArray
 ========================
 
+1.5.3 -> 1.5.4
+--------------
+
+* [New] Import method 'CArray#section' from gem 'carray-calculus'
+* [New] Add new method 'CArray#pull', 'CArray#pulled'
+* [New] Add new option 'expand_scalar' to 'CArray.broadcast'
+* [Mod] Modify the method 'CArray.broadcast' to accept block.
+* [Mod] Modify the method 'CArray.meshgrid' to accept block.
+* [Mod] Modify 'CScalar#broadcast_to' to return CArray
+* [Mod] Modify 'CScalar#is_masked' and 'CScalar#is_masked' to return CScalar
+* [Fix] Fix order of repetitive dimensions in 'CArray#meshgrid'
+* [Fix] Fix errors in installing on MinGW+msys2
+
 1.5.2 -> 1.5.3
 --------------
 

data/README.md

@@ -6,16 +6,16 @@ Ruby/CArray is an extension library for the multi-dimensional array class.
 Features
 --------
 
-* Multidimensional array for storing uniform data
-* Various ways to access data elements
-* Masks for each element to handle missing values
-* Element-wise operations and mathematical functions
-* Statistical functions for the elements
-* Indirect data manipulation for original array by virtual array 
+* Collection class for multidimensional array storing the value with uniform data type
+* Element-wise mathematical operations and functions
+* Statistical operation for the elements
+* Various methods for referencing data elements
+* Internally included element-wise mask to handle missing values
+* Indirect data manipulation to referent by virtual array 
 * Special iterators (dimension, block, window, categorical)
-* User-defined array
-* Storing fixed length data with data_class
-* Memory sharing with other objects (Experimental)
+* User-defined array class with same multi-dimensional interfaces as CArray
+* Accessing the partial data in fixed length data via data_class interface
+* Wrapping the memory block owned by the other object (such as NArray).
 
 Requirements
 ------------
@@ -25,16 +25,32 @@ Requirements
   + IEEE754 floating point number
   + C99 complex number
 
-Directories
------------
+What is Ruby/CArray 
+------------------
 
-    lib       - Ruby sorce codes
-    ext       - C extension source codes
-    utils     - support tools for development
-    spec      - rspec files
-    misc      - misc files
+Ruby/CArray is an extension library for the multi-dimensional numerical array class. The name "CArray" comes from a wrapper's meaning to a numerical array handled by the C language. CArray stores integers or floating-point numbers in memory block and treats them collectively to ensure efficient performance. Therefore, Ruby/CArray is suitable for numerical computation and data analysis. 
 
-Licenses
---------
+#### Multi-dimensional uniform array ####
+
+CArray is a collection class that can store the array of values with a uniform data type of one of fixed-width integer (8,16,32,64bits), floating-point number (32,64bits), complex number (64,128bits), fixed-length string, ruby object. These values are stored in memory block as binary data. CArray has multi-dimensional interfaces for the array to access their values. The multi-dimensional array has the attributes of the dimension size (1,2,3,...) and the shape of dimension ([dim0], [dim0,dim1], [dim0,dim1,dim2],...) which define the size of array. 
+
+#### Collective mathematical operations ####
+
+CArray supports the collective calculation for the element-wise arithmetic operations and elementary mathematical functions. Additionally, some basic statistical summarization along specific dimensions are also provided.
+
+#### Referencing data and virtual arrays ####
+
+CArray provides various methods for referencing data, such as addressing, slicing, selection by condition, address mapping, grid reference, transposing, shifting, rolling, data type conversion, reshaping, and so on. These data referencing are realized by the creation of virtual arrays, so-called 'view'. The virtual array doesn't have its data and retrieves the data from the referent only on-demand, including dereferencing, copying, or calculation. Since virtual array classes are sub-class of CArray, it has the same interfaces to access data as CArray. The changes in a virtual array by storing data are also reflected in the referent (if not a read_only array). Multiple heterogeneous chains of reference are also allowed, although the trade-offs with performance must be carefully considered.
+
+#### Built-in element-wise mask handling ####
+
+CArray possesses masked states about each element (so-called "element-wise mask"). By referring the element-wise mask, CArray can perform mathematical and statistical calculations on the data with missing values by appropriate handling of masked elements. , which include the propagation of mask state to result in element-wise arithmetics and ignoring the masked elements in a statistical calculation, and so on.
+
+#### User-defined array ####
+
+Users can define a new virtual array class in Ruby level or C-extension level with TemplateMethod pattern. They are defined as a subclass of CAObject in Ruby level and as a subclass of CAVirtual in C-extension level. In particular, at the Ruby level, you can easily define a CArray-like class by implementing just a few template methods.
+
+License
+-------
 
 MIT (after version 1.5.0)

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification::new do |s|
 
-  version = "1.5.3"
+  version = "1.5.4"
 
   files = Dir.glob("**/*") + [".yardopts"] -
                              [ 
@@ -16,14 +16,11 @@ Gem::Specification::new do |s|
   s.name        = "carray"
   s.summary     = "Multi-dimesional array class for Ruby"
   s.description = <<-HERE
-    Ruby/CArray is an extension library for the multi-dimensional numerical array class.
-    CArray can store integers and floating point numbers to perform calculations
-    efficiently. Therefore, Ruby/CArray is suitable for numerical computation and data
-    analysis. Ruby/CArray has different features from other multidimensional array
-    libraries (narray, numo-narray, nmatrix), such as element-wise masks, 
-    creation of reference arrays that can reflect changes to the referent, 
-    the ability to access memory pointers of other objects, user-defined arrays,
-    and so on.
+    Ruby/CArray is an extension library for the multi-dimensional numerical array
+    class. The name "CArray" comes from the meaning of a wrapper to a numerical array
+    handled by the C language. CArray stores integers or floating-point numbers in
+    memory block and treats them collectively to ensure efficient performance.
+    Therefore, Ruby/CArray is suitable for numerical computation and data analysis.
   HERE
   s.version     = version
   s.author      = "Hiroki Motoyoshi"

data/ext/ca_obj_refer.c

@@ -32,11 +32,11 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   CA_CHECK_BYTES(data_type, bytes);
 
   if ( ca_is_object_type(parent) && data_type != CA_OBJECT ) {
-    rb_raise(rb_eRuntimeError, "object carray can't be referred by other type");
+    rb_raise(rb_eRuntimeError, "object array can't be referred by other data type");
   }
 
   if ( parent->elements && bytes > parent->bytes * parent->elements ) {
-    rb_raise(rb_eRuntimeError, "byte size mismatch");
+    rb_raise(rb_eRuntimeError, "bytes exceeds the data size of referent");
   }
 
   /* calc datanum and check deformation */
@@ -51,27 +51,25 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   }
   if ( bytes < parent->bytes ) {
     if ( parent->bytes % bytes != 0 ) {
-      rb_raise(rb_eArgError, "invalid bytes");
+      rb_raise(rb_eRuntimeError, "bytes of reference array must be a multiple of that of referent");
     }
     is_deformed = -2;
     ratio = parent->bytes / bytes;
   }
   else if ( bytes > parent->bytes ) {
     if ( bytes % parent->bytes != 0 ) {
-      rb_raise(rb_eArgError, "invalid bytes");
+      rb_raise(rb_eRuntimeError, "bytes of reference array must be a multiple of that of referent");
     }
     is_deformed = 2;
     ratio = bytes / parent->bytes;
   }
-
   if ( offset < 0 ) {
-    rb_raise(rb_eRuntimeError, 
-             "negative offset for CARefer");
+    rb_raise(rb_eRuntimeError, "negative offset is not permitted for CARefer");
   }
 
   if ( ( bytes * elements + parent->bytes * offset ) >
                                      ( parent->bytes * parent->elements ) ) {
-    rb_raise(rb_eRuntimeError, "data size too large for CARefer");
+    rb_raise(rb_eRuntimeError, "data size of reference array must not exceed that of referent");
   }
 
   ca->obj_type  = CA_OBJ_REFER;

data/ext/carray_conversion.c

@@ -342,6 +342,8 @@ rb_ca_format (int argc, VALUE *argv, VALUE self)
 
 #include <time.h>
 
+#ifdef HAVE_STRPTIME
+
 /* @overload str_strptime (fmt)
 
 (Conversion) 
@@ -404,7 +406,9 @@ rb_ca_strptime (VALUE self, VALUE rfmt)
   return obj;
 }
 
-/* @overload time_strptime (fmt)
+#endif
+
+/* @overload time_strftime (fmt)
 
 (Conversion) 
 Creates object type array consist of strings
@@ -498,7 +502,10 @@ Init_carray_conversion ()
 
   rb_define_method(rb_cCArray, "str_format", rb_ca_format, -1); 
 
+#ifdef HAVE_STRPTIME
   rb_define_method(rb_cCArray, "str_strptime", rb_ca_strptime, 1);
+#endif
+  
   rb_define_method(rb_cCArray, "time_strftime", rb_ca_strftime, 1);
 
   rb_define_method(rb_cCArray, "test_ca_to_cptr", rb_test_ca_to_cptr, 0);

data/ext/carray_mask.c

@@ -757,7 +757,12 @@ rb_ca_is_masked (VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);
+  if ( ca_is_scalar(ca) ) {
+    co = cscalar_new(CA_BOOLEAN, ca->bytes, NULL);        
+  }
+  else {
+    co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);    
+  }
 
   ca_update_mask(ca);
   if ( ! ca->mask ) {
@@ -798,7 +803,12 @@ rb_ca_is_not_masked (VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);
+  if ( ca_is_scalar(ca) ) {
+    co = cscalar_new(CA_BOOLEAN, ca->bytes, NULL);        
+  }
+  else {
+    co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);    
+  }
 
   ca_update_mask(ca);
   if ( ! ca->mask ) {

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/extconf.rb

@@ -140,6 +140,10 @@ have_header("tgmath.h")
 
 have_func("mergesort", "stdlib.h")
 
+# --- check mergesort routine
+
+have_func("strptime", "time.h")
+
 # --- setup install files
 
 $INSTALLFILES = []
@@ -153,7 +157,7 @@ $INSTALLFILES << ['carray_config.h', '$(archdir)']
 #
 
 if /cygwin|mingw/ =~ RUBY_PLATFORM
-  sitearchdir = Config::CONFIG["sitearchdir"]
+  sitearchdir = RbConfig::CONFIG["sitearchdir"]
   $DLDFLAGS << " -L#{sitearchdir} -Wl,--out-implib=libcarray.a "
   unless File.exist? "libcarray.a"
     $TOUCHED_LIBCARRAY_A = true

data/ext/mkmath.rb

@@ -385,7 +385,7 @@ ca_moncmp_#{name}_#{type} (ca_size_t n, boolean8_t *m, char *ptr1, ca_size_t i1,
   io.puts "};"
   io.puts
   io.print %{
-static VALUE rb_ca_#{name} (VALUE self, VALUE other)
+static VALUE rb_ca_#{name} (VALUE self)
 { return rb_ca_call_moncmp(self, ca_moncmp_#{name}); }
   }
   DEFINITIONS << io.string

data/ext/ruby_ccomplex.c

@@ -460,7 +460,7 @@ Init_ccomplex ()
   rb_define_method(rb_cCComplex, "coerce", rb_cc_coerce, 1);
 
   rb_define_method(rb_cCComplex, "==", rb_cc_equal, 1);
-  rb_define_method(rb_cCComplex, "-@", rb_cc_uminus, 1);
+  rb_define_method(rb_cCComplex, "-@", rb_cc_uminus, 0);
   rb_define_method(rb_cCComplex, "+", rb_cc_plus, 1);
   rb_define_method(rb_cCComplex, "-", rb_cc_minus, 1);
   rb_define_method(rb_cCComplex, "*", rb_cc_asterisk, 1);

data/ext/version.h

@@ -8,9 +8,9 @@
 
 ---------------------------------------------------------------------------- */
 
-#define CA_VERSION "1.5.3"
-#define CA_VERSION_CODE 153
+#define CA_VERSION "1.5.4"
+#define CA_VERSION_CODE 154
 #define CA_VERSION_MAJOR 1
 #define CA_VERSION_MINOR 5
-#define CA_VERSION_TEENY 3
-#define CA_VERSION_DATE "2020/07/31"
+#define CA_VERSION_TEENY 4
+#define CA_VERSION_DATE "2020/09/06"

data/lib/carray/broadcast.rb

@@ -56,7 +56,9 @@ end
 class CScalar
   
   def broadcast_to (*newdim)
-    self
+    out = CArray.new(data_type, newdim, bytes: bytes)
+    out[] = self
+    out
   end
 
 end
@@ -67,7 +69,8 @@ class CAUnboundRepeat
 
 end
 
-def CArray.broadcast (*argv)
+def CArray.broadcast (*argv, expand_scalar: false, &block)
+  
   sel = argv.select { |arg| arg.is_a?(CArray) }
   return argv if sel.empty?
   
@@ -77,6 +80,22 @@ def CArray.broadcast (*argv)
     dim[k] = sel.map { |arg| arg.dim[k] || 1 }.max
   end
 
-  argv.map { |arg| arg.is_a?(CArray) ? arg.broadcast_to(*dim) : arg }
+  if not expand_scalar
+    list = argv.map { |arg| 
+      case arg
+      when CScalar
+        arg
+      when CArray
+        arg.broadcast_to(*dim)
+      else
+        arg
+      end
+    }
+  else
+    list = argv.map { |arg| arg.is_a?(CArray) ? arg.broadcast_to(*dim) : arg }
+  end
+  
+  return block.call(*list) if block
+  return list
 end
 

data/lib/carray/construct.rb

@@ -395,7 +395,7 @@ class CArray
     def eye (n, m = nil, k = 0)
       m ||= n
       mat = CArray.new(self::DataType || CA_FLOAT64, [n, m])
-      start = k > 0 ? k : m - k - 1
+      start = ( k == 0 ) ? k : ( k > 0 ? k : m - k - 1 )
       mat[[start..-1,m+1]] = 1
       mat
     end
@@ -430,7 +430,7 @@ class CArray
       end
       data_type = self::DataType
       data_type ||= guess_data_type_from_values(start, stop, step)
-      CArray.__new__(data_type, start..stop, step)
+      CArray.__new__(data_type, start..stop-step, step)
     end
   
     def full (shape, fill_value)
@@ -445,16 +445,40 @@ class CArray
 end
 
 class CArray
-  
-  def self.meshgrid (*args)
-    dim = args.map(&:size)
-    out = []
-    args.each_with_index do |arg, i|
-      newdim = dim.dup
-      newdim[i] = :%
-      out[i] = arg[*newdim].to_ca
+
+  def self.meshgrid (*axes, indexing: "xy", copy: true, sparse: false, &block)
+    case indexing 
+    when "xy"
+      ### no operation
+    when "ij"
+      axes = axes.map{|axis| axis.seq }
+    else
+      raise ArgumentError, %{indexing option should be one of "xy" and "ij"}
+    end
+    shape = axes.map(&:size).reverse
+    if sparse                           ### => CAUnboundRepeat
+      list = axes.map.with_index do |axis, k|
+        extended_shape = (shape.size-1).downto(0).map { |i| ( i == k ) ? nil : :* }
+        if copy
+          axis[*extended_shape].to_ca
+        else
+          axis[*extended_shape]
+        end
+      end
+    else                                ### => CARepeat
+      naxes = shape.size
+      list = axes.map.with_index do |axis, k|
+        extended_shape = shape.dup
+        extended_shape[naxes - k - 1] = :%
+        if copy
+          axis[*extended_shape].to_ca
+        else
+          axis[*extended_shape]
+        end
+      end
     end
-    return *out
+    return block.call(*list) if block
+    return list
   end
   
 end

data/lib/carray/obsolete.rb

@@ -23,20 +23,6 @@ class CArray
     self
   end
 
-  # pulled
-
-  def pulled (*args)
-    warn "CArray#pulled will be obsolete"
-    idx = args.map{|s| s.nil? ? :% : s}
-    return self[*idx]
-  end
-  
-  def pull (*args)
-    warn "CArray#pull will be obsolete"
-    idx = args.map{|s| s.nil? ? :% : s}
-    return self[*idx].to_ca
-  end
-
   # Returns the array eliminated all the duplicated elements.
   def duplicated_values
     warn "CArray#duplicated_values will be obsolete"

data/lib/carray/transform.rb

@@ -94,5 +94,16 @@ class CArray
     return self[:%,1]
   end
 
+  # pulled
+
+  def pulled (*args)
+    idx = args.map{|s| s.nil? ? :% : s}
+    return self[*idx]
+  end
   
+  def pull (*args)
+    idx = args.map{|s| s.nil? ? :% : s}
+    return self[*idx].to_ca
+  end
+
 end

data/misc/NOTE

@@ -1,42 +1,6 @@
 Note for developper
 ===================
 
-Make targets
-------------
-
-### create Makefile
-
-    ruby extconf.rb
-
-### build extensions
-
-    make all
-    
-### install via RubyGems
-
-    make build-gem
-    make install-gem
-    make uninstall-gem  ### for uninstall this version
-
-### install via extconf.rb
-
-    ruby extconf.rb
-    make all
-    make install
-
-### cleaning temporary files
-
-    make clean
-    make distclean
-
-### create gem package
-
-    make package        ### -> rake package
-    
-### run test
-
-    make test           ### -> rake test
-
 Utility scripts
 ---------------
 
@@ -53,8 +17,11 @@ Check Points for Debug
 
   * 'elements' should be checked with double float number
 
-  * ca_update_mask/ca_attach/ca_create_mask/ca_has_mask should be called 
-    before ca->mask refered
+  * One of the following methods should be called before ca->mask refered
+    + ca_attach
+    + ca_has_mask 
+    + ca_update_mask
+    + ca_create_mask
 
   * Avoid the exposition of raw VALUE data in object array
 
@@ -71,3 +38,14 @@ OpenMP
 ------
 
   * '--with-cc="gcc -fopenmp"' ... and so on.
+
+Range
+-----
+
+ int rb_arithmetic_sequence_extract(VALUE, VALUE *, VALUE *, VALUE *, int *);
+
+ /* range.c */
+ #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])
+ 

metadata

@@ -1,23 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.4
 platform: ruby
 authors:
 - Hiroki Motoyoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-31 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies: []
-description: "    Ruby/CArray is an extension library for the multi-dimensional numerical
-  array class.\n    CArray can store integers and floating point numbers to perform
-  calculations\n    efficiently. Therefore, Ruby/CArray is suitable for numerical
-  computation and data\n    analysis. Ruby/CArray has different features from other
-  multidimensional array\n    libraries (narray, numo-narray, nmatrix), such as element-wise
-  masks, \n    creation of reference arrays that can reflect changes to the referent,
-  \n    the ability to access memory pointers of other objects, user-defined arrays,\n
-  \   and so on.\n"
+description: |2
+      Ruby/CArray is an extension library for the multi-dimensional numerical array
+      class. The name "CArray" comes from the meaning of a wrapper to a numerical array
+      handled by the C language. CArray stores integers or floating-point numbers in
+      memory block and treats them collectively to ensure efficient performance.
+      Therefore, Ruby/CArray is suitable for numerical computation and data analysis.
 email: ''
 executables: []
 extensions:
@@ -223,8 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Multi-dimesional array class for Ruby