carray 1.5.1 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9609f31c4eacaf87ca9881eff5e29e30cfde413086a30b0ee99e02d9142b105f
-  data.tar.gz: 68c4a6919c28b78ee9c9fd7a469b65ef8069a6ceba880f37a1a32f37f3de24d2
+  metadata.gz: 519ed0ddc6f3cf2268a644428085e86ab3926aba4798400586e33e33b21a27e3
+  data.tar.gz: ea59dd3b333f4d707db96ce2a4f945a9c4508baa32a70bfbd1882a250b4279e3
 SHA512:
-  metadata.gz: 910d317c356accdc8852490a209991443f964e2e9e3896b41b62456104699049fa99d59341a176eba752d83b49765044c1282b9b1a439f8ba949c661b2950689
-  data.tar.gz: 7036c72836edf32445979d8d72312da7b2c8a68e9a15101f75caa4a6ea804d97254ba9cc76c99b8bde691d0049ca8474ab88924c0acfdc6e73b84d9098077d37
+  metadata.gz: 6fcf6cd610bbeaf160396ff553ea2ed8f0a4faff97836824b13f1e5d426b13bc068c7ae3c938b4f426a95a0e7928f58ae7c9af83d79b713f069ddbec4ab85cf7
+  data.tar.gz: d9bc322d676d67ea423ac9f370230d72c8331392b0fba7b77ee34712bf8e1b5d7b337dfdcfe79bf0b0fce374f88e78dcb197da433b46dc866d7142f358a1b0d9

data/NEWS.md

@@ -0,0 +1,42 @@
+ChangeLog of Ruby/CArray
+========================
+
+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] Depret the obsolete mothod 'CArray#dump'.
+* [Mod] Depret 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 
+* [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
+* [Obsolete] Set obsolete flag to 'CAIterator#sort_with'
+
+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

@@ -28,11 +28,11 @@ Requirements
 Directories
 -----------
 
-    .         - 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.
+    lib       - Ruby sorce codes
+    ext       - C extension source codes
+    utils     - support tools for development
+    spec      - rspec files
+    misc      - misc files
 
 Licenses
 --------

data/TODO.md

@@ -0,0 +1,16 @@
+ToDo List
+=========
+
+ToDo
+-------
+
+ * Create spec
+   - str_format (cyclic format)
+   - CA_SIZE
+ * Remove RSTRUCT hack in carray_access.c for handling of Range object.
+ * Implement CArray.broadcast in C
+ * Solve abs probrems
+
+Done
+-------
+

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification::new do |s|
 
-  version = "1.5.1"
+  version = "1.5.2"
 
   files = Dir.glob("**/*") - [ 
                                Dir.glob("carray-*.gem"), 
@@ -14,10 +14,14 @@ Gem::Specification::new do |s|
   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 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-specific 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.
   HERE
   s.version     = version
   s.author      = "Hiroki Motoyoshi"

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 }