carray 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19670c9fa370952b777655dbbfc938a93deecbbe62452559f572951d8a083078
-  data.tar.gz: bc7dae442eee84400725a45c804332426f72a0405299d785ecccb3cae27f1d2b
+  metadata.gz: 9609f31c4eacaf87ca9881eff5e29e30cfde413086a30b0ee99e02d9142b105f
+  data.tar.gz: 68c4a6919c28b78ee9c9fd7a469b65ef8069a6ceba880f37a1a32f37f3de24d2
 SHA512:
-  metadata.gz: d1f76a7cdc3448844557c05c0375b01221a2d7a6d9d48ed36223cbc3a39b379e3dab966a48c8a6aaa57d0d6521e4222f2849dca8749e7137e693ec9379d12b9f
-  data.tar.gz: 82b3ff4f50775df6f6699533826e8494a29a34f15256d2874b271dc6cd64f1c24878d4639185c4837a66ee15daf33fa25c1ec3f0bf80c487b80553c353939cbd
+  metadata.gz: 910d317c356accdc8852490a209991443f964e2e9e3896b41b62456104699049fa99d59341a176eba752d83b49765044c1282b9b1a439f8ba949c661b2950689
+  data.tar.gz: 7036c72836edf32445979d8d72312da7b2c8a68e9a15101f75caa4a6ea804d97254ba9cc76c99b8bde691d0049ca8474ab88924c0acfdc6e73b84d9098077d37

data/LICENSES

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Hiroki Motoyoshi.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -3,34 +3,38 @@ Ruby/CArray
 
 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 
+* Special iterators (dimension, block, window, categorical)
+* User-defined array
+* Storing fixed length data with data_class
+* Memory sharing with other objects (Experimental)
+
 Requirements
 ------------
 
-* Ruby 2.2.0 or later
+* Ruby 2.4.0 or later
 * C compiler 
   + IEEE754 floating point number
   + C99 complex number
-* Optional command
-  + ImageMagick (stream, convert, display, identify)
 
 Directories
 -----------
 
     .         - Ruby/CArray extension source codes
     lib       - Ruby/CArray standard library in Ruby
-    ext       - optional extension libraries for Ruby/CArray
-    examples  - some examples
     test      - some unit tests (incomplete)
     spec      - some rspec (incomplete)
     utils     - support tools for development.
 
-Author
-------
-
-Hiroki Motoyoshi 
-
-Copying
--------
+Licenses
+--------
 
-You can redistribute this library package and/or modify it under the terms of
-the Ruby Licence. See the file 'COPYING' in this directory.
+MIT (after version 1.5.0)

data/Rakefile

@@ -6,7 +6,7 @@ GEMSPEC = "carray.gemspec"
 
 task :install do
   spec = eval File.read(GEMSPEC)
-  version_h = `ruby version.rb`.chomp
+  version_h = `ruby ext/version.rb`.chomp
   if spec.version.to_s != version_h
     STDERR.puts "Mismatch in version between carray.gemspec and version.h"
     STDERR.puts "  carray.gemspec - #{spec.version.to_s }"

data/carray.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification::new do |s|
 
-  version = "1.4.0"
+  version = "1.5.1"
 
   files = Dir.glob("**/*") - [ 
                                Dir.glob("carray-*.gem"), 
@@ -12,7 +12,7 @@ Gem::Specification::new do |s|
 
   s.platform    = Gem::Platform::RUBY
   s.name        = "carray"
-  s.summary     = "Multi-dimesional array class"
+  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
@@ -22,18 +22,10 @@ Gem::Specification::new do |s|
   s.version     = version
   s.author      = "Hiroki Motoyoshi"
   s.email       = ""
+  s.licenses    = ['MIT']
   s.homepage    = 'https://github.com/himotoyoshi/carray'
   s.files       = files
-  s.extensions  = [ "extconf.rb" ] + 
-                     Dir["ext/*/extconf.rb"].select{|f| File.exist?(f) }
-  s.rdoc_options = [
-		"-m rdoc_main.rb", 
-		"rdoc_main.rb", 
-		"rdoc_ext.rb",
-		"rdoc_math.rb", 
-		"rdoc_stat.rb", 
-		Dir.glob("lib/carray/**/*.rb"),
-	].flatten
-  s.required_ruby_version = ">= 1.8.1"
+  s.extensions  = [ "ext/extconf.rb" ] 
+  s.required_ruby_version = ">= 2.4.0"
 end
 

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

@@ -23,7 +23,7 @@ VALUE rb_cCABlockIterator;
 typedef struct {
   int16_t   obj_type;
   int8_t    data_type;
-  int8_t    rank;
+  int8_t    ndim;
   int32_t   flags;
   ca_size_t   bytes;
   ca_size_t   elements;
@@ -42,11 +42,11 @@ typedef struct {
   ca_size_t  *step;
   ca_size_t  *count;
   ca_size_t  *size0;
-} CABlock;                  // 68 + 20*(rank) (bytes) 
+} CABlock;                  // 68 + 20*(ndim) (bytes) 
 */
 
 typedef struct {
-  int8_t  rank;
+  int8_t  ndim;
   ca_size_t dim[CA_RANK_MAX];
   CArray *reference;
   CArray * (*kernel_at_addr)(void *, ca_size_t, CArray *);
@@ -73,14 +73,14 @@ ca_bi_kernel_at_index (void *it, ca_size_t *idx, CArray *ref)
   else {
     CABlock *ck = (CABlock *)bit->kernel;
     kernel = ca_block_new(ref,
-                          ck->rank, ck->size0,
+                          ck->ndim, ck->size0,
                           ck->start, ck->step, ck->count,
                           ck->offset);
   }
 
   ca_update_mask(kernel);
 
-  for (i=0; i<kernel->rank; i++) {
+  for (i=0; i<kernel->ndim; i++) {
     j = idx[i];
     CA_CHECK_INDEX(j, bit->dim[i]);
     kernel->start[i] += j * kernel->dim[i];
@@ -99,7 +99,7 @@ ca_bi_kernel_at_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = bit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=bit->rank-1; i>=0; i--) {
+  for (i=bit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -117,7 +117,7 @@ ca_bi_kernel_move_to_index (void *it, ca_size_t *idx, CArray *kern)
 
   ca_update_mask(kernel);
 
-  for (i=0; i<kernel->rank; i++) {
+  for (i=0; i<kernel->ndim; i++) {
     j = idx[i];
     CA_CHECK_INDEX(j, bit->dim[i]);
     kernel->start[i] = j * kernel->dim[i];
@@ -136,7 +136,7 @@ ca_bi_kernel_move_to_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = bit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=bit->rank-1; i>=0; i--) {
+  for (i=bit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -158,11 +158,11 @@ ca_bi_setup (VALUE self, VALUE rref, VALUE rker)
   Data_Get_Struct(rref, CArray, ref);
   Data_Get_Struct(rker, CABlock, ker);
 
-  if ( ref->rank != ker->rank ) {
-    rb_raise(rb_eRuntimeError, "rank mismatch between reference and kernel");
+  if ( ref->ndim != ker->ndim ) {
+    rb_raise(rb_eRuntimeError, "ndim mismatch between reference and kernel");
   }
 
-  for (i=0; i<ref->rank; i++) {
+  for (i=0; i<ref->ndim; i++) {
     if ( ker->step[i] != 1 ) {
       rb_raise(rb_eRuntimeError, "block should be contiguous");
     }
@@ -174,8 +174,8 @@ ca_bi_setup (VALUE self, VALUE rref, VALUE rker)
     */
   }
 
-  it->rank      = ref->rank;
-  memcpy(it->dim, dim, it->rank * sizeof(ca_size_t));
+  it->ndim      = ref->ndim;
+  memcpy(it->dim, dim, it->ndim * sizeof(ca_size_t));
   it->reference = ref;
   it->kernel    = ker;
   it->kernel_at_addr  = ca_bi_kernel_at_addr;

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

@@ -21,7 +21,7 @@ VALUE rb_cCADimIterator;
 */
 
 typedef struct {
-  int8_t  rank;
+  int8_t  ndim;
   ca_size_t dim[CA_RANK_MAX];
   CArray *reference;
   CArray * (*kernel_at_addr)(void *, ca_size_t, CArray *);
@@ -50,14 +50,14 @@ ca_di_kernel_at_index (void *it, ca_size_t *idx, CArray *ref)
   else {
     CABlock *ck = (CABlock *)dit->kernel;
     kernel = ca_block_new(ref,
-                          ck->rank, ck->size0,
+                          ck->ndim, ck->size0,
                           ck->start, ck->step, ck->count,
                           ck->offset);
   }
 
   ca_update_mask(kernel);
 
-  for (i=0; i<dit->rank; i++) {
+  for (i=0; i<dit->ndim; i++) {
     val = idx[i];
     CA_CHECK_INDEX(val, dit->dim[i]);
     kernel->start[dit->symindex[i]] = val * kernel->step[dit->symindex[i]];
@@ -77,7 +77,7 @@ ca_di_kernel_at_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = dit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=dit->rank-1; i>=0; i--) {
+  for (i=dit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -94,7 +94,7 @@ ca_di_kernel_move_to_index (void *it, ca_size_t *idx, CArray *kern)
 
   ca_update_mask(kernel);
 
-  for (i=0; i<dit->rank; i++) {
+  for (i=0; i<dit->ndim; i++) {
     val = idx[i];
     CA_CHECK_INDEX(val, dit->dim[i]);
     kernel->start[dit->symindex[i]] = val * kernel->step[dit->symindex[i]];
@@ -114,7 +114,7 @@ ca_di_kernel_move_to_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = dit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=dit->rank-1; i>=0; i--) {
+  for (i=dit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -129,7 +129,7 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
   volatile VALUE rindex, rker, rsymtbl;
   CADimIterator *it;
   CAIndexInfo blk_spec;
-  int8_t rank;
+  int8_t ndim;
   int i, j, k;
 
   Data_Get_Struct(self, CADimIterator, it);
@@ -142,7 +142,7 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
 
   blk_spec      = *info;
   blk_spec.type = CA_REG_BLOCK;
-  for (i=0; i<info->rank; i++) {
+  for (i=0; i<info->ndim; i++) {
     if ( info->index_type[i] == CA_IDX_SYMBOL ) {
       blk_spec.index_type[i] = CA_IDX_ALL;
       rb_hash_aset(rsymtbl, ID2SYM(blk_spec.index[i].symbol.id), INT2NUM(i));
@@ -151,13 +151,13 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
 
   rref = rb_ca_ref_block(rref, &blk_spec);
 
-  rindex = rb_ary_new2(info->rank);
-  rank = 0;
+  rindex = rb_ary_new2(info->ndim);
+  ndim = 0;
 
   j = 0;
   k = 0;
 
-  for (i=0; i<info->rank; i++) {
+  for (i=0; i<info->ndim; i++) {
     if ( info->index_type[i] == CA_IDX_SCALAR ) {
       rb_ary_store(rindex, i, SIZE2NUM(info->index[i].scalar));
       continue; /* escape from j++ */
@@ -165,8 +165,8 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
     else if ( info->index_type[i] == CA_IDX_SYMBOL ) {
       rb_ary_store(rindex, i, rb_ary_new3(1, SIZE2NUM(0)));
       it->symflag[j]       = 1;
-      it->symindex[rank] = j;
-      rank++;
+      it->symindex[ndim] = j;
+      ndim++;
     }
     else if ( info->index_type[i] == CA_IDX_ALL ) {
       rb_ary_store(rindex, i, Qnil);
@@ -184,7 +184,7 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
 
   rker = rb_apply(rref, rb_intern("[]"), rindex);
 
-  it->rank = rank;
+  it->ndim = ndim;
   Data_Get_Struct(rref, CArray, it->reference);
   Data_Get_Struct(rker, CArray, it->kernel);
   it->kernel_at_addr  = ca_di_kernel_at_addr;
@@ -192,7 +192,7 @@ ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
   it->kernel_move_to_addr  = ca_di_kernel_move_to_addr;
   it->kernel_move_to_index = ca_di_kernel_move_to_index;
 
-  for (i=0; i<it->rank; i++) {
+  for (i=0; i<it->ndim; i++) {
     it->dim[i] = it->reference->dim[it->symindex[i]];
   }
 
@@ -239,7 +239,7 @@ rb_ca_dim_iterator (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  rb_ca_scan_index(ca->rank, ca->dim, ca->elements, argc, argv, &info);
+  rb_ca_scan_index(ca->ndim, ca->dim, ca->elements, argc, argv, &info);
 
   obj = rb_di_s_allocate(rb_cCADimIterator);
   ca_di_setup(obj, self, &info);

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

@@ -13,7 +13,7 @@
 #include "carray.h"
 
 typedef struct {
-  int8_t  rank;
+  int8_t  ndim;
   ca_size_t dim[CA_RANK_MAX];
   CArray *reference;
   CArray * (*kernel_at_addr)(void *, ca_size_t, CArray *);
@@ -59,7 +59,7 @@ ca_vi_kernel_at_index (void *it, ca_size_t *idx, CArray *ref)
 
   ca_update_mask(kernel);
 
-  for (i=0; i<kernel->rank; i++) {
+  for (i=0; i<kernel->ndim; i++) {
     j = idx[i];
     CA_CHECK_INDEX(j, vit->dim[i]);
     kernel->start[i] = j - vit->offset[i];
@@ -78,7 +78,7 @@ ca_vi_kernel_at_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = vit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=vit->rank-1; i>=0; i--) {
+  for (i=vit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -97,7 +97,7 @@ ca_vi_kernel_move_to_index (void *it, ca_size_t *idx, CArray *kern)
 
   ca_update_mask(kernel);
 
-  for (i=0; i<kernel->rank; i++) {
+  for (i=0; i<kernel->ndim; i++) {
     j = idx[i];
     CA_CHECK_INDEX(j, dim[i]);
     kernel->start[i] = j - offset[i];
@@ -116,7 +116,7 @@ ca_vi_kernel_move_to_addr (void *it, ca_size_t addr, CArray *ref)
   ca_size_t *dim = vit->dim;
   ca_size_t idx[CA_RANK_MAX];
   int8_t i;
-  for (i=vit->rank-1; i>=0; i--) {
+  for (i=vit->ndim-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
   }
@@ -136,12 +136,12 @@ ca_vi_setup (VALUE self, VALUE rref, VALUE rker)
   Data_Get_Struct(rref, CArray, ref);
   Data_Get_Struct(rker, CArray, ker);
 
-  if ( ref->rank != ker->rank ) {
-    rb_raise(rb_eRuntimeError, "rank mismatch between reference and kernel");
+  if ( ref->ndim != ker->ndim ) {
+    rb_raise(rb_eRuntimeError, "ndim mismatch between reference and kernel");
   }
 
-  it->rank      = ref->rank;
-  memcpy(it->dim, ref->dim, it->rank * sizeof(ca_size_t));
+  it->ndim      = ref->ndim;
+  memcpy(it->dim, ref->dim, it->ndim * sizeof(ca_size_t));
   it->reference = ref;
   it->kernel    = ker;
   it->kernel_at_addr  = ca_vi_kernel_at_addr;
@@ -149,7 +149,7 @@ ca_vi_setup (VALUE self, VALUE rref, VALUE rker)
   it->kernel_move_to_addr  = ca_vi_kernel_move_to_addr;
   it->kernel_move_to_index = ca_vi_kernel_move_to_index;
 
-  for (i=0; i<it->rank; i++) {
+  for (i=0; i<it->ndim; i++) {
     it->offset[i] = -(((CAWindow*)ker)->start[i]);
   }
 

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

@@ -42,7 +42,7 @@ double ca_mem_count = 0.0;
 
 /* Threshold for forced garbage collection and its default value */
 double ca_gc_interval; 
-const double ca_default_gc_interval = 40.0; /* 40MB */
+const double ca_default_gc_interval = 100.0; /* 100MB */
 
 #define MB (1024*1024)
 
@@ -117,7 +117,7 @@ rb_ca_reset_gc_interval (VALUE self)
 
 static int
 carray_setup_i (CArray *ca,
-                int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                 CArray *mask, int allocate, int use_calloc)
 {
   ca_size_t elements;
@@ -127,14 +127,14 @@ carray_setup_i (CArray *ca,
 
   /* check arguments */
   CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(rank);
-  CA_CHECK_DIM(rank, dim);
+  CA_CHECK_RANK(ndim);
+  CA_CHECK_DIM(ndim, dim);
   CA_CHECK_BYTES(data_type, bytes);
 
   /* calculate total number of elements */
   elements = 1;
   length = bytes;
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     elements *= dim[i];
     length *= dim[i];
   }
@@ -153,11 +153,11 @@ carray_setup_i (CArray *ca,
 
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = bytes;
   ca->elements  = elements;
-  ca->dim       = ALLOC_N(ca_size_t, rank);
-  memcpy(ca->dim, dim, rank*sizeof(ca_size_t));
+  ca->dim       = ALLOC_N(ca_size_t, ndim);
+  memcpy(ca->dim, dim, ndim*sizeof(ca_size_t));
 
   if ( allocate ) {                                      /* allocate == true */
 
@@ -201,26 +201,26 @@ carray_setup_i (CArray *ca,
 
 int
 carray_setup (CArray *ca,
-  int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes, CArray *mask)
+  int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes, CArray *mask)
 {
-  return carray_setup_i(ca, data_type, rank, dim, bytes, mask, 1, 0);
+  return carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 1, 0);
 }
 
 int
 carray_safe_setup (CArray *ca,
-  int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes, CArray *mask)
+  int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes, CArray *mask)
 {
-  return carray_setup_i(ca, data_type, rank, dim, bytes, mask, 1, 1);
+  return carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 1, 1);
 }
 
 int
 ca_wrap_setup (CArray *ca,
-               int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+               int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                CArray *mask, char *ptr)
 {
   int ret;
 
-  ret = carray_setup_i(ca, data_type, rank, dim, bytes, mask, 0, 0);
+  ret = carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 0, 0);
   if ( (!ptr) && (ca->elements != 0) ) {
     rb_raise(rb_eRuntimeError, "wrapping NULL pointer with an non-empty array");
   }
@@ -230,49 +230,49 @@ ca_wrap_setup (CArray *ca,
 
 int
 ca_wrap_setup_null (CArray *ca,
-                    int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                    int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                     CArray *mask)
 {
   int ret;
 
-  ret = carray_setup_i(ca, data_type, rank, dim, bytes, mask, 0, 0);
+  ret = carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 0, 0);
   ca->ptr = NULL;
   return ret;
 }
 
 CArray *
-carray_new (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+carray_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
   CArray *ca  = ALLOC(CArray);
-  carray_setup(ca, data_type, rank, dim, bytes, mask);
+  carray_setup(ca, data_type, ndim, dim, bytes, mask);
   return ca;
 }
 
 CArray *
-carray_new_safe (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+carray_new_safe (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
   CArray *ca  = ALLOC(CArray);
-  carray_safe_setup(ca, data_type, rank, dim, bytes, mask);
+  carray_safe_setup(ca, data_type, ndim, dim, bytes, mask);
   return ca;
 }
 
 CAWrap *
-ca_wrap_new (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+ca_wrap_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask, char *ptr)
 {
   CAWrap *ca  = ALLOC(CAWrap);
-  ca_wrap_setup(ca, data_type, rank, dim, bytes, mask, ptr);
+  ca_wrap_setup(ca, data_type, ndim, dim, bytes, mask, ptr);
   return ca;
 }
 
 CAWrap *
-ca_wrap_new_null (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+ca_wrap_new_null (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                   CArray *mask)
 {
   CAWrap *ca  = ALLOC(CAWrap);
-  ca_wrap_setup_null(ca, data_type, rank, dim, bytes, mask);
+  ca_wrap_setup_null(ca, data_type, ndim, dim, bytes, mask);
   return ca;
 }
 
@@ -313,7 +313,7 @@ cscalar_setup (CScalar *ca,
   ca->obj_type  = CA_OBJ_SCALAR;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = 1;
+  ca->ndim      = 1;
   ca->bytes     = bytes;
   ca->elements  = 1;
   ca->dim       = &(ca->_dim);
@@ -388,7 +388,7 @@ ca_array_func_clone (void *ap)
 {
   CArray *ca = (CArray *) ap;
   CArray *co;
-  co = carray_new(ca->data_type, ca->rank, ca->dim, ca->bytes, ca->mask);
+  co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, ca->mask);
   memcpy(co->ptr, ca->ptr, ca_length(ca));
   return co;
 }
@@ -407,9 +407,9 @@ ca_array_func_ptr_at_index (void *ap, ca_size_t *idx)
   ca_size_t *dim = ca->dim;
   int8_t     i;
   ca_size_t  n;
-  n = idx[0];                  /* n = idx[0]*dim[1]*dim[2]*...*dim[rank-1] */
-  for (i=1; i<ca->rank; i++) { /*    + idx[1]*dim[1]*dim[2]*...*dim[rank-1] */
-    n = dim[i]*n+idx[i];       /*    ... + idx[rank-2]*dim[1] + idx[rank-1] */
+  n = idx[0];                  /* n = idx[0]*dim[1]*dim[2]*...*dim[ndim-1] */
+  for (i=1; i<ca->ndim; i++) { /*    + idx[1]*dim[1]*dim[2]*...*dim[ndim-1] */
+    n = dim[i]*n+idx[i];       /*    ... + idx[ndim-2]*dim[1] + idx[ndim-1] */
   }
   return ca->ptr + ca->bytes * n;
 }
@@ -429,7 +429,7 @@ ca_array_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t     i;
   ca_size_t  n;
   n = idx[0];
-  for (i=1; i<ca->rank; i++) {
+  for (i=1; i<ca->ndim; i++) {
     n = dim[i]*n+idx[i];
   }
   memcpy(ptr, ca->ptr + ca->bytes * n, ca->bytes);
@@ -450,7 +450,7 @@ ca_array_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t     i;
   ca_size_t  n;
   n = idx[0];
-  for (i=1; i<ca->rank; i++) {
+  for (i=1; i<ca->ndim; i++) {
     n = dim[i]*n+idx[i];
   }
   memcpy(ca->ptr + ca->bytes * n, ptr, ca->bytes);
@@ -547,7 +547,7 @@ void
 ca_array_func_create_mask (void *ap)
 {
   CArray *ca = (CArray *) ap;
-  ca->mask = carray_new_safe(CA_BOOLEAN, ca->rank, ca->dim, 0, NULL);
+  ca->mask = carray_new_safe(CA_BOOLEAN, ca->ndim, ca->dim, 0, NULL);
 }
 
 ca_operation_function_t ca_array_func = {
@@ -654,18 +654,18 @@ ca_operation_function_t ca_scalar_func = {
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_carray_new (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+rb_carray_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                CArray *mask)
 {
-  CArray *ca = carray_new(data_type, rank, dim, bytes, mask);
+  CArray *ca = carray_new(data_type, ndim, dim, bytes, mask);
   return ca_wrap_struct(ca);
 }
 
 VALUE
-rb_carray_new_safe (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+rb_carray_new_safe (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                     CArray *mask)
 {
-  CArray *ca = carray_new_safe(data_type, rank, dim, bytes, mask);
+  CArray *ca = carray_new_safe(data_type, ndim, dim, bytes, mask);
   return ca_wrap_struct(ca);
 }
 
@@ -704,7 +704,7 @@ rb_ca_s_allocate (VALUE klass)
   #     CArray.new(data_type, dim, bytes=0) { ... }
   #
   #  Constructs a new CArray object of <i>data_type</i>, which has the
-  #  rank and the dimensions specified by an <code>Array</code> of
+  #  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
@@ -720,7 +720,7 @@ rb_ca_initialize (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE rtype, rdim, ropt, rbytes = Qnil;
   CArray *ca;
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t dim[CA_RANK_MAX];
   ca_size_t bytes;
   int8_t i;
@@ -732,13 +732,13 @@ rb_ca_initialize (int argc, VALUE *argv, VALUE self)
   rb_ca_data_type_import(self, rtype);
 
   Check_Type(rdim, T_ARRAY);
-  rank = RARRAY_LEN(rdim);
-  for (i=0; i<rank; i++) {
+  ndim = RARRAY_LEN(rdim);
+  for (i=0; i<ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
   }
 
   Data_Get_Struct(self, CArray, ca);
-  carray_safe_setup(ca, data_type, rank, dim, bytes, NULL);
+  carray_safe_setup(ca, data_type, ndim, dim, bytes, NULL);
 
   if ( rb_block_given_p() ) {
     volatile VALUE rval = rb_yield(self);
@@ -759,13 +759,18 @@ 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)  \
-{                                                     \
-  volatile VALUE ropt = rb_pop_options(&argc, &argv); \
-  volatile VALUE rdim = rb_ary_new4(argc, argv);      \
-  VALUE args[3] = { INT2NUM(code), rdim, ropt };      \
-  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)    \
+{                                                       \
+  if ( argc == 0 ) {                                    \
+    return ca_data_type_class(code);                    \
+  }                                                     \
+  else {                                                \
+    volatile VALUE ropt = rb_pop_options(&argc, &argv); \
+    volatile VALUE rdim = rb_ary_new4(argc, argv);      \
+    VALUE args[3] = { INT2NUM(code), rdim, ropt };      \
+    return rb_class_new_instance(3, args, klass);       \
+  }                                                     \
 }
 
 /*
@@ -820,7 +825,7 @@ rb_ca_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(other, CArray, cs);
 
   ca_update_mask(cs);
-  carray_setup(ca, cs->data_type, cs->rank, cs->dim, cs->bytes, cs->mask);
+  carray_setup(ca, cs->data_type, cs->ndim, cs->dim, cs->bytes, cs->mask);
 
   memcpy(ca->ptr, cs->ptr, ca_length(cs));
 
@@ -837,7 +842,7 @@ rb_ca_s_wrap (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj, target, rtype, rdim, ropt, rbytes = Qnil;
   CArray *ca;
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t dim[CA_RANK_MAX];
   ca_size_t bytes;
   int8_t i;
@@ -848,15 +853,15 @@ rb_ca_s_wrap (int argc, VALUE *argv, VALUE self)
   rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
 
   Check_Type(rdim, T_ARRAY);
-  rank = RARRAY_LEN(rdim);
-  for (i=0; i<rank; i++) {
+  ndim = RARRAY_LEN(rdim);
+  for (i=0; i<ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
   }
 
   target = rb_yield_values(0);
 
   obj = Data_Make_Struct(rb_cCAWrap, CAWrap, ca_mark, ca_free, ca);
-  ca_wrap_setup_null(ca, data_type, rank, dim, bytes, NULL);
+  ca_wrap_setup_null(ca, data_type, ndim, dim, bytes, NULL);
 
   rb_funcall(target, rb_intern("wrap_as_carray"), 1, obj);
   rb_ivar_set(obj, rb_intern("referred_object"), target);
@@ -865,13 +870,13 @@ rb_ca_s_wrap (int argc, VALUE *argv, VALUE self)
 }
 
 VALUE
-rb_carray_wrap_ptr (int8_t data_type, int8_t rank, ca_size_t *dim,
+rb_carray_wrap_ptr (int8_t data_type, int8_t ndim, ca_size_t *dim,
         ca_size_t bytes, CArray *mask, char *ptr, VALUE refer)
 {
   volatile VALUE obj;
   CArray *ca;
 
-  ca  = ca_wrap_new(data_type, rank, dim, bytes, mask, ptr);
+  ca  = ca_wrap_new(data_type, ndim, dim, bytes, mask, ptr);
   obj = ca_wrap_struct(ca);
 
   rb_ivar_set(obj, rb_intern("referred_object"), refer);