carray 1.5.1 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9609f31c4eacaf87ca9881eff5e29e30cfde413086a30b0ee99e02d9142b105f
-  data.tar.gz: 68c4a6919c28b78ee9c9fd7a469b65ef8069a6ceba880f37a1a32f37f3de24d2
+  metadata.gz: baf289b957e96d1df3156ea74f06a7bb44cbd856005f42a9f7531367413c9cff
+  data.tar.gz: 06feaeef398f1e130e658df742d370d54b003cd6af67bac47a2ae40b58e40007
 SHA512:
-  metadata.gz: 910d317c356accdc8852490a209991443f964e2e9e3896b41b62456104699049fa99d59341a176eba752d83b49765044c1282b9b1a439f8ba949c661b2950689
-  data.tar.gz: 7036c72836edf32445979d8d72312da7b2c8a68e9a15101f75caa4a6ea804d97254ba9cc76c99b8bde691d0049ca8474ab88924c0acfdc6e73b84d9098077d37
+  metadata.gz: 0f62fb53d5344bdc400c211d6938460f136215e0a629c60d047bef313e053d3500c2b0c02e30a77810fa4b6ed7e67ab52edbc93f7ebc264d3441a20bc01b4207
+  data.tar.gz: acb0098036a13fff4a483aa6fb5fe5fc0dc65bd0e8d356b6037a44b4aa285f231e98d39687090de73b225a540c3b946c3be5a75746e68194ca9b0d7bfdd823e4

data/.yardopts

@@ -0,0 +1,32 @@
+--markup markdown
+--markup-provider redcarpet
+--no-private
+--exclude lib/carray/obsolete.rb
+--exclude lib/carray/autoload.rb
+--exclude 'lib/carray/autoload/'
+--readme README.md
+--files NEWS.md,TODO.md 
+lib/carray.rb 
+ext/ruby_carray.c 
+ext/ca_obj_array.c 
+ext/ca_obj_bitarray.c 
+ext/ca_obj_bitfield.c 
+ext/ca_obj_block.c 
+ext/carray_attribute.c 
+ext/carray_call_cfunc.c 
+ext/carray_cast.c 
+ext/carray_class.c 
+ext/carray_conversion.c 
+ext/carray_copy.c 
+ext/carray_core.c 
+ext/carray_data_type.c 
+ext/carray_element.c 
+ext/carray_generate.c 
+ext/carray_loop.c
+ext/carray_mask.c 
+ext/carray_operator.c 
+ext/carray_order.c 
+ext/carray_sort_addr.c 
+ext/carray_test.c 
+ext/carray_utils.c 
+

data/NEWS.md

@@ -0,0 +1,83 @@
+ChangeLog of Ruby/CArray
+========================
+
+1.5.4 -> 1.5.5
+
+* [Fix] Fix recognition of "atan2", ... in "math.h"
+* [Fix] Fix serialize.rb of keyword parameters for Ruby2.7
+
+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
+--------------
+
+* [New] Add new method 'CArray#exp2'
+* [New] Add new method 'CArray#log2'
+* [New] Add new method 'CArray#logb'
+* [New] Add new method 'CArray#remainder'
+* [New] Add new method 'CArray.guard_undef'
+* [New] Add new method 'CArray#data_class='
+* [New] Add new method 'CArray.data_class?'
+* [Mod] Modify 'CArray#pmax' to use 'fmax' for float type
+* [Mod] Modify 'CArray#pmin' to use 'fmin' for float type
+* [Mod] Remove method 'Object#undef?'
+* [Mod] Remove method '::nan', '::inf'
+* [Mod] Remove method 'TrueClass#*', 'FalseClass#*' (unknown origin)
+* [Fix] Fix invalid access for CAUnboundRepeat using index
+* [Fix] Fix treatment of extra :* in operation between CAUnboundRepeat objects
+* [Fix] Fix to accept Symbol for the name of data_class member
+* [Fix] Fix 'CArray#uniq' to accept the array with the dimension more than 2.
+* [Fix] Fix for CArray serialization to include data_class
+* [Fix] Fix data_class inheritance in some methods in which new CArray is created.
+* [Fix] Fix 'CArray#broadcast_to' to accept the case of dimension extension.
+
+1.5.1 -> 1.5.2
+--------------
+
+* [New] Add new method 'CArray#sorted_with'
+* [New] Add new method 'CArray#sort_with'
+* [New] Add new method 'CArray#max_with'
+* [New] Add new method 'CArray#min_with'
+* [New] Add new method 'CArray.broadcast'
+* [New] Add new method 'CArray#broadcast_to', 'CScalar#broadcast_to'
+* [New] Add new API function `rb_ca_wrap_new`
+* [Mod] Modify 'CArray#linspace' to return float64 array for integer arguments
+* [Mod] Modify CAUnboundRepeat to have `ndim` same as the bounded array (before `ndim` same as parent array)
+* [Mod] Remove the obsolete mothod 'CArray#dump'.
+* [Mod] Remove the obsolete mothod 'CArray#load'.
+* [Mod] Modify CArray.wrap_readonly to wrap string as array.
+* [Fix] Add support for Integer (same as for Fixnum, Bignum)
+
+1.5.0 -> 1.5.1
+--------------
+
+* [New] Add data type classes like 'Float64' ... to provide the methods like 'CArray::Float64.linspace'
+* [Mod] Modify 'CArray.float64' ... without aruguments to return the corresponding data type class 
+* [Mod] Set obsolete flag to 'CAIterator#sort_with'
+* [Fix] Move C extension files into 'ext/'
+* [Fix] Rename member 'rank' to 'ndim' in struct CArray in C extension
+* [Fix] Remove 'CArray#shuffle' (gone to 'carray-random' gem)
+* [Fix] Remove dependencies on 'rb_secure()' and 'rb_safe_level()'
+* [Fix] Modify 'CArray#span' to handle fractional step for integer array
+
+1.4.0 -> 1.5.0
+--------------
+
+* [Mod] Remove 'Carray#random!' (gone to 'carray-random' gem)
+* [Mod] Relocate file 'lib/carray/io/table.rb' to 'lib/carray/table.rb'
+* [Mod] Rename class 'CA::TableMethods' to 'CArray::TableMethods'
+* [Mod] Rename method 'CArray#cast_other' to 'CArray#cast_with'
+* [Mod] Change license from "Ruby's" to "MIT"
+* [Mod] Remove files 'COPYING', 'LEGAL'(for MT), 'GPL'
+* [Fix] Fix bug lib/carray/struct.rb

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 
+------------------
 
-    .         - Ruby/CArray extension source codes
-    lib       - Ruby/CArray standard library in Ruby
-    test      - some unit tests (incomplete)
-    spec      - some rspec (incomplete)
-    utils     - support tools for development.
+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/Rakefile

@@ -15,7 +15,7 @@ task :install do
     exit(1)
   end
   system %{
-    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem --no-document
   }
 end
 

data/TODO.md

@@ -0,0 +1,17 @@
+ToDo List
+=========
+
+ToDo
+-------
+ * Implement CArray.broadcast in C
+ * Implement Integer#{|,&,^,<<,>>} with Refinement (remove monkey patch)
+ * Remove RSTRUCT hack in carray_access.c for handling of Range object.
+ * Solve abs probrems
+ * Create spec
+   - str_format (cyclic format)
+   - CA_SIZE
+   - serialization of carray which has data_class
+
+Done
+-------
+

data/carray.gemspec

@@ -1,28 +1,31 @@
 Gem::Specification::new do |s|
 
-  version = "1.5.1"
+  version = "1.5.6"
 
-  files = Dir.glob("**/*") - [ 
+  files = Dir.glob("**/*") + [".yardopts"] -
+                             [ 
                                Dir.glob("carray-*.gem"), 
                                Dir.glob("ext/**/{Makefile,mkmf.log}"),
                                Dir.glob("**/*.{o,so,bundle}"),
                                Dir.glob("**/*~"),
                                Dir.glob("doc/**/*"),
+                               Dir.glob("test/**/*"),
                              ].flatten
 
   s.platform    = Gem::Platform::RUBY
   s.name        = "carray"
   s.summary     = "Multi-dimesional array class for Ruby"
   s.description = <<-HERE
-    CArray is a uniform multi-dimensional rectangular array class.
-    It provides the various types of sub-arrays and references
-    pointing the data elements of original array (slice, grid, selection ...).
-    Element-wise masking and mathematical operations are natively supported.
+    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"
   s.email       = ""
-  s.licenses    = ['MIT']
+  s.license     = 'MIT'
   s.homepage    = 'https://github.com/himotoyoshi/carray'
   s.files       = files
   s.extensions  = [ "ext/extconf.rb" ] 

data/ext/ca_iter_block.c

@@ -3,16 +3,14 @@
   ca_iter_block.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
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
 
-/* rdoc:
+/* yard:
   class CABlockIterator < CAIterator # :nodoc: 
   end
 */
@@ -202,7 +200,7 @@ rb_bi_initialize_copy (VALUE self, VALUE other)
   return self;
 }
 
-/* rdoc:
+/* yard:
   class CArray
     # Create block iterator.
     def blocks (*args)

data/ext/ca_iter_dimension.c

@@ -3,10 +3,8 @@
   ca_iter_dimension.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
 
 ---------------------------------------------------------------------------- */
 
@@ -15,7 +13,7 @@
 
 VALUE rb_cCADimIterator;
 
-/* rdoc: 
+/* yard: 
   class CADimensionIterator < CAIterator # :nodoc:
   end
 */
@@ -239,6 +237,7 @@ rb_ca_dim_iterator (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
+  info.range_check = 1;
   rb_ca_scan_index(ca->ndim, ca->dim, ca->elements, argc, argv, &info);
 
   obj = rb_di_s_allocate(rb_cCADimIterator);
@@ -258,7 +257,7 @@ rb_dim_iter_new (VALUE rref, CAIndexInfo *info)
   return obj;
 }
 
-/* rdoc:
+/* yard:
   class CADimensionIterator
     def sym2dim (sym)
     end

data/ext/ca_iter_window.c

@@ -3,10 +3,8 @@
   ca_iter_window.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
 
 ---------------------------------------------------------------------------- */
 
@@ -27,7 +25,7 @@ typedef struct {
 
 VALUE rb_cCAWindowIterator;
 
-/* rdoc:
+/* yard:
   class CAWindowIterator < CAIterator # :nodoc:
   end
 */

data/ext/ca_obj_array.c

@@ -3,10 +3,8 @@
   ca_obj_array.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
 
 ---------------------------------------------------------------------------- */
 
@@ -19,7 +17,7 @@
 
 VALUE rb_cCArray, rb_cCAWrap, rb_cCScalar, rb_cCAVirtual;
 
-/* rdoc:
+/* yard:
   class CArray
   end
   class CAWrap < CArray   # :nodoc:
@@ -60,27 +58,22 @@ ca_check_mem_count()
   }
 }
 
-/* rdoc:
-  # returns the threshold of incremented memory (MB) used by carray object 
-  # until start GC.
-  def CArray.gc_interval ()
-  end
-  # set the threshold of incremented memory (MB) used by carray object
-  # until start GC.
-  def CArray.gc_interval= (val)
-  end
-  # reset the counter for the GC start when the incremented memory 
-  # get larger than `CArray.gc_interval`.
-  def CArray.reset_gc_interval ()
-  end
-*/
+/* @private gc_interval
 
+Returns the threshold of incremented memory (MB) used by carray object 
+until start GC.
+*/
 static VALUE
 rb_ca_get_gc_interval (VALUE self)
 {
   return rb_float_new(ca_gc_interval);
 }
 
+/* @private gc_interval= (val)
+
+Sets the threshold of incremented memory (MB) used by carray object
+until start GC.
+*/
 static VALUE
 rb_ca_set_gc_interval (VALUE self, VALUE rth)
 {
@@ -92,6 +85,11 @@ rb_ca_set_gc_interval (VALUE self, VALUE rth)
   return rb_float_new(ca_gc_interval);
 }
 
+/* @private reset_gc_inverval
+
+Reset the counter for the GC start when the incremented memory 
+get larger than `CArray.gc_interval`.
+*/
 static VALUE
 rb_ca_reset_gc_interval (VALUE self)
 {
@@ -669,6 +667,15 @@ rb_carray_new_safe (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t byt
   return ca_wrap_struct(ca);
 }
 
+
+VALUE
+rb_ca_wrap_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
+               CArray *mask, char *ptr)
+{
+  CAWrap *ca = ca_wrap_new(data_type, ndim, dim, bytes, mask, ptr);
+  return ca_wrap_struct(ca);
+}
+
 VALUE
 rb_cscalar_new (int8_t data_type, ca_size_t bytes, CArray *mask)
 {
@@ -699,20 +706,16 @@ rb_ca_s_allocate (VALUE klass)
   return Data_Make_Struct(klass, CArray, ca_mark, ca_free, ca);
 }
 
-/* rdoc:
-  #  call-seq:
-  #     CArray.new(data_type, dim, bytes=0) { ... }
-  #
-  #  Constructs a new CArray object of <i>data_type</i>, which has the
-  #  ndim and the dimensions specified by an <code>Array</code> of
-  #  <code>Integer</code> or an argument list of <code>Integer</code>.
-  #  The byte size of each element for the fixed length data type
-  #  (<code>data_type == CA_FIXLEN</code>) is specified optional argument
-  #  <i>bytes</i>. Otherwise, this optional argument has no
-  #  effect. If the block is given, the new CArray
-  #  object will be initialized by the value returned from the block.
-  def CArray.new(data_type, dim, bytes=0)
-  end
+/* @overload  initialize(data_type, dim, bytes=0) { ... }
+
+Constructs a new CArray object of <i>data_type</i>, which has the
+ndim and the dimensions specified by an <code>Array</code> of
+<code>Integer</code> or an argument list of <code>Integer</code>.
+The byte size of each element for the fixed length data type
+(<code>data_type == CA_FIXLEN</code>) is specified optional argument
+<i>bytes</i>. Otherwise, this optional argument has no
+effect. If the block is given, the new CArray
+object will be initialized by the value returned from the block.
 */
 
 static VALUE
@@ -750,6 +753,12 @@ rb_ca_initialize (int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+/* @overload  fixlen(*dim, bytes: ) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:fixlen, dim, bytes: ) { ... }`
+*/
+
 static VALUE
 rb_ca_s_fixlen (int argc, VALUE *argv, VALUE klass)  
 {                                                     
@@ -759,8 +768,7 @@ rb_ca_s_fixlen (int argc, VALUE *argv, VALUE klass)
   return rb_class_new_instance(3, args, klass);       
 }
 
-#define rb_ca_s_type(type, code)                        \
-rb_ca_s_## type (int argc, VALUE *argv, VALUE klass)    \
+#define rb_ca_s_body(code)                              \
 {                                                       \
   if ( argc == 0 ) {                                    \
     return ca_data_type_class(code);                    \
@@ -773,47 +781,171 @@ rb_ca_s_## type (int argc, VALUE *argv, VALUE klass)    \
   }                                                     \
 }
 
-/*
- *  call-seq:
- *     CArray.int8(dim0, dim1, ...) { ... }     -> CArray
- *     CArray.uint8(dim0, dim1, ...) { ... }    -> CArray
- *     CArray.int16(dim0, dim1, ...) { ... }    -> CArray
- *     CArray.uint16(dim0, dim1, ...) { ... }   -> CArray
- *     CArray.int32(dim0, dim1, ...) { ... }    -> CArray
- *     CArray.uint32(dim0, dim1, ...) { ... }   -> CArray
- *     CArray.int64(dim0, dim1, ...) { ... }    -> CArray
- *     CArray.uint64(dim0, dim1, ...) { ... }   -> CArray
- *     CArray.float32(dim0, dim1, ...) { ... }  -> CArray
- *     CArray.float64(dim0, dim1, ...) { ... }  -> CArray
- *     CArray.float128(dim0, dim1, ...) { ... } -> CArray
- *     CArray.cmplx64(dim0, dim1, ...) { ... }  -> CArray
- *     CArray.cmplx128(dim0, dim1, ...) { ... } -> CArray
- *     CArray.cmplx256(dim0, dim1, ...) { ... } -> CArray
- *     CArray.object(dim0, dim1, ...) { ... }   -> CArray
- *
- */
+/* @overload  boolean(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:boolean, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_boolean (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_BOOLEAN);
+}
+
+/* @overload  int8(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:int8, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_int8 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_INT8);
+}
+
+/* @overload  uint8(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:uint8, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_uint8 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_UINT8);
+}
+
+/* @overload  int16(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:int16, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_int16 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_INT16);
+}
+
+/* @overload  uint16(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:uint16, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_uint16 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_UINT16);
+}
+
+/* @overload  int32(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:int32, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_int32 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_INT32);
+}
+
+/* @overload  uint32(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:uint32, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_uint32 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_UINT32);
+}
+
+/* @overload  int64(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:int64, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_int64 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_INT64);
+}
+
+/* @overload  uint64(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:uint64, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_uint64 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_UINT64);
+}
+
+/* @overload  float32(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:float32, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_float32 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_FLOAT32);
+}
+
+/* @overload  float64(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:float64, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_float64 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_FLOAT64);
+}
+
+/* @overload  float128(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:float128, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_float128 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_FLOAT128);
+}
 
-static VALUE rb_ca_s_VALUE();
-
-static VALUE rb_ca_s_type(boolean,  CA_BOOLEAN);
-static VALUE rb_ca_s_type(int8,     CA_INT8);
-static VALUE rb_ca_s_type(uint8,    CA_UINT8);
-static VALUE rb_ca_s_type(int16,    CA_INT16);
-static VALUE rb_ca_s_type(uint16,   CA_UINT16);
-static VALUE rb_ca_s_type(int32,    CA_INT32);
-static VALUE rb_ca_s_type(uint32,   CA_UINT32);
-static VALUE rb_ca_s_type(int64,    CA_INT64);
-static VALUE rb_ca_s_type(uint64,   CA_UINT64);
-static VALUE rb_ca_s_type(float32,  CA_FLOAT32);
-static VALUE rb_ca_s_type(float64,  CA_FLOAT64);
-static VALUE rb_ca_s_type(float128, CA_FLOAT128);
 #ifdef HAVE_COMPLEX_H
-static VALUE rb_ca_s_type(cmplx64,  CA_CMPLX64);
-static VALUE rb_ca_s_type(cmplx128, CA_CMPLX128);
-static VALUE rb_ca_s_type(cmplx256, CA_CMPLX256);
+/* @overload  cmplx64(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:cmplx64, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_cmplx64 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_CMPLX64);
+}
+
+/* @overload  cmplx128(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:cmplx128, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_cmplx128 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_CMPLX128);
+}
+
+/* @overload  cmplx256(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:cmplx256, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_cmplx256 (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_CMPLX256);
+}
 #endif
-static VALUE rb_ca_s_type(VALUE,    CA_OBJECT);
 
+/* @overload  object(*dim) { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:object, dim, bytes: bytes) { ... }`
+*/
+static VALUE rb_ca_s_VALUE (int argc, VALUE *argv, VALUE klass)
+{
+  rb_ca_s_body(CA_OBJECT);
+}
+
+/* @overload  initialize_copy(other)
+
+*/
 static VALUE
 rb_ca_initialize_copy (VALUE self, VALUE other)
 {
@@ -832,9 +964,10 @@ rb_ca_initialize_copy (VALUE self, VALUE other)
   return self;
 }
 
-/* rdoc:
-   def CArray.wrap (data_type, dim, bytes=0) # { wrapped_object }
-   end
+/* @overload wrap (data_type, dim, bytes=0) { target }
+
+[TBD] (Construction)
+target should have method "wrap_as_carray(obj)"
 */
 
 static VALUE
@@ -893,16 +1026,16 @@ rb_cs_s_allocate (VALUE klass)
   return Data_Make_Struct(klass, CScalar, ca_mark, ca_free, ca);
 }
 
-/* rdoc:
-  #  call-seq:
-  #     CScalar.new(data_type, bytes=0) { ... }
-  #
-  #  Constructs a new CScalar object of <i>data_type</i>.
-  #  The byte size of each element for the fixed length data type
-  #  (<code>data_type == CA_FIXLEN</code>) is specified optional argument
-  #  <i>bytes</i>. Otherwise, this optional argument has no
-  #  effect. If the block is given, the new CScalar
-  #  object will be initialized by the value returned from the block.
+/* 
+ call-seq:
+     CScalar.new(data_type, bytes=0) { ... }
+
+  Constructs a new CScalar object of <i>data_type</i>.
+  The byte size of each element for the fixed length data type
+  (<code>data_type == CA_FIXLEN</code>) is specified optional argument
+  <i>bytes</i>. Otherwise, this optional argument has no
+  effect. If the block is given, the new CScalar
+  object will be initialized by the value returned from the block.
   def CScalar.new(data_type,bytes=0)
   end
 */
@@ -934,6 +1067,12 @@ rb_cs_initialize (int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+/* @overload  fixlen(*dim, bytes: ) { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:fixlen, bytes: ) { ... }`
+*/
+
 static VALUE
 rb_cs_s_fixlen (int argc, VALUE *argv, VALUE klass)  
 {                                                     
@@ -945,8 +1084,7 @@ rb_cs_s_fixlen (int argc, VALUE *argv, VALUE klass)
   return rb_class_new_instance(2, args, klass);       
 }
 
-#define rb_cs_s_type(type, code)                      \
-rb_cs_s_## type (int argc, VALUE *argv, VALUE klass)  \
+#define rb_cs_s_body(code)                      \
 {                                                     \
   volatile VALUE ropt = rb_pop_options(&argc, &argv); \
   VALUE args[2] = { INT2NUM(code), ropt };            \
@@ -956,47 +1094,172 @@ rb_cs_s_## type (int argc, VALUE *argv, VALUE klass)  \
   return rb_class_new_instance(2, args, klass);       \
 }
 
-static VALUE rb_cs_s_type(boolean,  CA_BOOLEAN);
-static VALUE rb_cs_s_type(int8,     CA_INT8);
-static VALUE rb_cs_s_type(uint8,    CA_UINT8);
-static VALUE rb_cs_s_type(int16,    CA_INT16);
-static VALUE rb_cs_s_type(uint16,   CA_UINT16);
-static VALUE rb_cs_s_type(int32,    CA_INT32);
-static VALUE rb_cs_s_type(uint32,   CA_UINT32);
-static VALUE rb_cs_s_type(int64,    CA_INT64);
-static VALUE rb_cs_s_type(uint64,   CA_UINT64);
-static VALUE rb_cs_s_type(float32,  CA_FLOAT32);
-static VALUE rb_cs_s_type(float64,  CA_FLOAT64);
-static VALUE rb_cs_s_type(float128, CA_FLOAT128);
+/* @overload  boolean() { ... } 
+
+(Construction)
+Short-Hand of `CArray.new(:boolean) { ... }`
+*/
+static VALUE 
+rb_cs_s_boolean (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_BOOLEAN);
+}
+
+/* @overload  int8() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:int8) { ... }`
+*/
+static VALUE 
+rb_cs_s_int8 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_INT8);
+}
+
+/* @overload uint8() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:uint8) { ... }`
+*/
+static VALUE 
+rb_cs_s_uint8 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_UINT8);
+}
+
+
+/* @overload int16() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:int16) { ... }`
+*/
+static VALUE 
+rb_cs_s_int16 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_INT16);
+}
+
+/* @overload uint16() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:uint16) { ... }`
+*/
+static VALUE 
+rb_cs_s_uint16 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_UINT16);
+}
+
+/* @overload int32() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:int32) { ... }`
+*/
+static VALUE 
+rb_cs_s_int32 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_INT32);
+}
+
+/* @overload uint32() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:uint32) { ... }`
+*/
+static VALUE 
+rb_cs_s_uint32 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_UINT32);
+}
+
+/* @overload int64() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:int64) { ... }`
+*/
+static VALUE 
+rb_cs_s_int64 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_INT64);
+}
+
+/* @overload uint64() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:uint64) { ... }`
+*/
+static VALUE 
+rb_cs_s_uint64 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_UINT64);
+}
+
+/* @overload float32() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:float32) { ... }`
+*/
+static VALUE 
+rb_cs_s_float32 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_FLOAT32);
+}
+
+/* @overload float64() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:float64) { ... }`
+*/
+static VALUE 
+rb_cs_s_float64 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_FLOAT64);
+}
+
+/* @overload float128() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:float128) { ... }`
+*/
+static VALUE 
+rb_cs_s_float128 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_FLOAT128);
+}
+
 #ifdef HAVE_COMPLEX_H
-static VALUE rb_cs_s_type(cmplx64,  CA_CMPLX64);
-static VALUE rb_cs_s_type(cmplx128, CA_CMPLX128);
-static VALUE rb_cs_s_type(cmplx256, CA_CMPLX256);
+/* @overload cmplx64() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:cmplx64) { ... }`
+*/
+static VALUE 
+rb_cs_s_cmplx64 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_CMPLX64);
+}
+
+/* @overload cmplx128() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:cmplx128) { ... }`
+*/
+static VALUE 
+rb_cs_s_cmplx128 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_CMPLX128);
+}
+
+/* @overload cmplx256() { ... } 
+
+(Construction)
+Short-Hand of `CScalar.new(:cmplx256) { ... }`
+*/
+static VALUE 
+rb_cs_s_cmplx256 (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_CMPLX256);
+}
 #endif
-static VALUE rb_cs_s_type(VALUE,    CA_OBJECT);
 
-/*
- *  call-seq:
- *     CScalar.int8() { ... }     -> CScalar
- *     CScalar.uint8() { ... }    -> CScalar
- *     CScalar.int16() { ... }    -> CScalar
- *     CScalar.uint16() { ... }   -> CScalar
- *     CScalar.int32() { ... }    -> CScalar
- *     CScalar.uint32() { ... }   -> CScalar
- *     CScalar.int64() { ... }    -> CScalar
- *     CScalar.uint64() { ... }   -> CScalar
- *     CScalar.float32() { ... }  -> CScalar
- *     CScalar.float64() { ... }  -> CScalar
- *     CScalar.float128() { ... } -> CScalar
- *     CScalar.cmplx64() { ... }  -> CScalar
- *     CScalar.cmplx128() { ... } -> CScalar
- *     CScalar.cmplx256() { ... } -> CScalar
- *     CScalar.object() { ... }   -> CScalar
- *
- */
+/* @overload object() { ... } 
 
-static VALUE
-rb_cs_s_VALUE();
+(Construction)
+Short-Hand of `CScalar.new(:object) { ... }`
+*/
+static VALUE 
+rb_cs_s_VALUE (int argc, VALUE *argv, VALUE klass) {
+  rb_cs_s_body(CA_OBJECT);
+}
+
+/* @overload  initialize_copy(other)
+
+*/
 
 static VALUE
 rb_cs_initialize_copy (VALUE self, VALUE other)
@@ -1031,6 +1294,10 @@ rb_cs_coerce (VALUE self, VALUE other)
 }
 */
 
+/* @private
+@overload mem_usage
+*/
+
 static VALUE
 rb_ca_mem_usage (VALUE self)
 {
@@ -1046,7 +1313,10 @@ Init_ca_obj_array ()
 
   /* ------------------------------------------------------------------- */
   ca_gc_interval = ca_default_gc_interval;
+
+  /* @private */
   rb_define_const(rb_cCArray, "DEFAULT_GC_INTERVAL", rb_float_new(ca_default_gc_interval));
+
   rb_define_singleton_method(rb_cCArray, "gc_interval", rb_ca_get_gc_interval, 0);
   rb_define_singleton_method(rb_cCArray, "gc_interval=", rb_ca_set_gc_interval, 1);
   rb_define_singleton_method(rb_cCArray, "reset_gc_interval", rb_ca_reset_gc_interval, 0);
@@ -1135,7 +1405,7 @@ Init_ca_obj_array ()
 }
 
 
-/* rdoc:
+/* yard:
   # call-seq:
   #    CArray.boolean(...) { init_value }
   #    CArray.int8(...) { init_value }