carray 1.1.4 → 1.1.5

data/LEGAL

@@ -0,0 +1,50 @@
+LEGAL NOTICE INFORMATION
+========================
+
+All the files in this distribution are covered under 
+the Ruby Licence except some files under public-domain mentioned below.
+
+mt19937ar.c, mt19937ar.h:
+-------------------------
+
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+
+   Before using, initialize the state by using init_genrand(seed)
+   or init_by_array(init_key, key_length).
+
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.
+   Copyright (C) 2005, Mutsuo Saito,
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
+        permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER O
+R
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)

data/NOTE

@@ -0,0 +1,73 @@
+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
+---------------
+
+### check version.h
+
+    ruby version.rb
+
+### check installed ruby-carray environment
+
+    ruby -v -e "require 'carray/info'"
+    
+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
+
+  * Avoid the exposition of raw VALUE data in object array
+
+    + CArray#refer, CArray#member, CArray#bitarray, CArray#bitfield
+    + CArray#transform, CArray#load, CArray#dump
+    + CArray#swap_bytes!, CArray#swap_bytes
+
+  * inherit data_class when copy
+
+    + rb_ca_copy, rb_ca_template
+    + rb_ca_unmask_copy
+
+OpenMP
+------
+
+  * '--with-cc="gcc -fopenmp"' ... and so on.

data/Rakefile

@@ -0,0 +1,20 @@
+#
+#
+#
+
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+task :default => :test
+
+desc "Run the tests"
+Rake::TestTask::new(:test) do |t|
+  t.test_files = FileList['test/test_ALL.rb']
+  t.verbose = true
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = ["-c", "-fs"]
+end

data/TODO

@@ -0,0 +1,5 @@
+- CArray#section should treat mask (-> currently CArray#bin uses inherit_mask)
+- CArray#differentiate should treat mask 
+* CArray#search should permit a CArray argument (use lfind ?)
+* append API ca_get_range(vrange, size, *first, *last)
+* ca_cast_self_or_other should treat NArray directly

data/ca_iter_block.c

@@ -0,0 +1,242 @@
+/* ---------------------------------------------------------------------------
+
+  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
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+
+/* rdoc:
+  class CABlockIterator < CAIterator # :nodoc: 
+  end
+*/
+
+VALUE rb_cCABlockIterator;
+
+/*
+typedef struct {
+  int16_t   obj_type;
+  int8_t    data_type;
+  int8_t    rank;
+  int32_t   flags;
+  int32_t   bytes;
+  int32_t   elements;
+  int32_t  *dim;
+  char     *ptr;
+  CArray   *mask;
+  CArray   *parent;
+  uint32_t  attach;
+  uint8_t   nosync;
+  // ---------- 
+  int8_t    maxdim_index;
+  int32_t   maxdim_step;
+  int32_t   maxdim_step0;
+  int32_t   offset;
+  int32_t  *start;
+  int32_t  *step;
+  int32_t  *count;
+  int32_t  *size0;
+} CABlock;                  // 68 + 20*(rank) (bytes) 
+*/
+
+typedef struct {
+  int8_t  rank;
+  int32_t dim[CA_RANK_MAX];
+  CArray *reference;
+  CArray * (*kernel_at_addr)(void *, int32_t, CArray *);
+  CArray * (*kernel_at_index)(void *, int32_t *, CArray *);
+  CArray * (*kernel_move_to_addr)(void *, int32_t, CArray *);
+  CArray * (*kernel_move_to_index)(void *, int32_t *, CArray *);
+  /* ----------- */
+  CABlock *kernel;
+} CABlockIterator;
+
+/* ----------------------------------------------------------------- */
+
+static CArray *
+ca_bi_kernel_at_index (void *it, int32_t *idx, CArray *ref)
+{
+  CABlockIterator *bit = (CABlockIterator *) it;
+  CABlock *kernel;
+  int32_t i, j;
+
+  if ( ref == bit->reference ) {
+    kernel = (CABlock *)ca_clone(bit->kernel);
+  }
+  else {
+    CABlock *ck = (CABlock *)bit->kernel;
+    kernel = ca_block_new(ref,
+                          ck->rank, ck->size0,
+                          ck->start, ck->step, ck->count,
+                          ck->offset);
+  }
+
+  ca_update_mask(kernel);
+
+  for (i=0; i<kernel->rank; i++) {
+    j = idx[i];
+    CA_CHECK_INDEX(j, bit->dim[i]);
+    kernel->start[i] += j * kernel->dim[i];
+    if ( kernel->mask ) {
+      ((CABlock*)(kernel->mask))->start[i] += j * kernel->dim[i];
+    }
+  }
+
+  return (CArray*) kernel;
+}
+
+static CArray *
+ca_bi_kernel_at_addr (void *it, int32_t addr, CArray *ref)
+{
+  CABlockIterator *bit = (CABlockIterator *) it;
+  int32_t *dim = bit->dim;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  for (i=bit->rank-1; i>=0; i--) {
+    idx[i] = addr % dim[i];
+    addr  /= dim[i];
+  }
+  return ca_bi_kernel_at_index(it, idx, ref);
+}
+
+
+static CArray *
+ca_bi_kernel_move_to_index (void *it, int32_t *idx, CArray *kern)
+{
+  CABlockIterator *bit = (CABlockIterator *) it;
+  CABlock *kernel = (CABlock *) kern;
+  int32_t i, j;
+
+  ca_update_mask(kernel);
+
+  for (i=0; i<kernel->rank; i++) {
+    j = idx[i];
+    CA_CHECK_INDEX(j, bit->dim[i]);
+    kernel->start[i] = j * kernel->dim[i];
+    if ( kernel->mask ) {
+      ((CABlock*)(kernel->mask))->start[i] = j * kernel->dim[i];
+    }
+  }
+
+  return (CArray*) kernel;
+}
+
+static CArray *
+ca_bi_kernel_move_to_addr (void *it, int32_t addr, CArray *ref)
+{
+  CABlockIterator *bit = (CABlockIterator *) it;
+  int32_t *dim = bit->dim;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  for (i=bit->rank-1; i>=0; i--) {
+    idx[i] = addr % dim[i];
+    addr  /= dim[i];
+  }
+  return ca_bi_kernel_move_to_index(it, idx, ref);
+}
+
+void
+ca_bi_setup (VALUE self, VALUE rref, VALUE rker)
+{
+  CABlockIterator *it;
+  CArray *ref;
+  CABlock *ker;
+  int32_t dim[CA_RANK_MAX];
+  int32_t i;
+
+  rker = rb_obj_clone(rker);
+
+  Data_Get_Struct(self, CABlockIterator, it);
+  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");
+  }
+
+  for (i=0; i<ref->rank; i++) {
+    if ( ker->step[i] != 1 ) {
+      rb_raise(rb_eRuntimeError, "block should be contiguous");
+    }
+    dim[i] = ( ref->dim[i] - ker->start[i] ) / ker->dim[i];
+    /*
+    if ( ref->dim[i] % ker->dim[i] != 0 ) {
+      rb_raise(rb_eRuntimeError, "invalid block size");
+    }
+    */
+  }
+
+  it->rank      = ref->rank;
+  memcpy(it->dim, dim, it->rank * sizeof(int32_t));
+  it->reference = ref;
+  it->kernel    = ker;
+  it->kernel_at_addr  = ca_bi_kernel_at_addr;
+  it->kernel_at_index = ca_bi_kernel_at_index;
+  it->kernel_move_to_addr  = ca_bi_kernel_move_to_addr;
+  it->kernel_move_to_index = ca_bi_kernel_move_to_index;
+
+  rb_ivar_set(self, rb_intern("@reference"), rref); /* required ivar */
+  rb_ivar_set(self, rb_intern("@kernel"), rker);
+}
+
+static VALUE
+rb_bi_s_allocate (VALUE klass)
+{
+  CABlockIterator *it;
+  return Data_Make_Struct(klass, CABlockIterator, 0, free, it);
+}
+
+static VALUE
+rb_bi_initialize_copy (VALUE self, VALUE other)
+{
+  ca_bi_setup(other, rb_ivar_get(self, rb_intern("@reference")),
+        rb_ivar_get(self, rb_intern("@kernel")));
+  return self;
+}
+
+/* rdoc:
+  class CArray
+    # Create block iterator.
+    def blocks (*args)
+    end
+  end
+*/
+
+static VALUE
+rb_ca_block_iterator (int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, rker;
+  CArray *ker;
+
+  rker = rb_ca_fetch2(self, argc, argv);
+
+  rb_check_carray_object(rker);
+  Data_Get_Struct(rker, CArray, ker);
+
+  if ( ker->obj_type != CA_OBJ_BLOCK ) {
+    rb_raise(rb_eRuntimeError, "kernel must be CABlock object");
+  }
+
+  obj = rb_bi_s_allocate(rb_cCABlockIterator);
+  ca_bi_setup(obj, self, rker);
+
+  return obj;
+}
+
+void
+Init_ca_iter_block ()
+{
+  rb_cCABlockIterator = rb_define_class("CABlockIterator", rb_cCAIterator);
+  rb_define_const(rb_cCABlockIterator, "UNIFORM_KERNEL", Qtrue);
+  rb_define_alloc_func(rb_cCABlockIterator, rb_bi_s_allocate);
+  rb_define_method(rb_cCABlockIterator, "initialize_copy",
+                            rb_bi_initialize_copy, 1);
+  rb_define_method(rb_cCArray, "blocks", rb_ca_block_iterator, -1);
+}
+

data/ca_iter_dimension.c

@@ -0,0 +1,287 @@
+/* ---------------------------------------------------------------------------
+
+  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
+
+---------------------------------------------------------------------------- */
+
+#include "ruby.h"
+#include "carray.h"
+
+VALUE rb_cCADimIterator;
+
+/* rdoc: 
+  class CADimensionIterator < CAIterator # :nodoc:
+  end
+*/
+
+typedef struct {
+  int8_t  rank;
+  int32_t dim[CA_RANK_MAX];
+  CArray *reference;
+  CArray * (*kernel_at_addr)(void *, int32_t, CArray *);
+  CArray * (*kernel_at_index)(void *, int32_t *, CArray *);
+  CArray * (*kernel_move_to_addr)(void *, int32_t, CArray *);
+  CArray * (*kernel_move_to_index)(void *, int32_t *, CArray *);
+  /* ----------- */
+  CArray  *kernel;
+  int8_t   symflag[CA_RANK_MAX];
+  int8_t   symindex[CA_RANK_MAX];
+} CADimIterator;
+
+/* -------------------------------------------------------------------- */
+
+static CArray *
+ca_di_kernel_at_index (void *it, int32_t *idx, CArray *ref)
+{
+  CADimIterator *dit = (CADimIterator *)it;
+  CABlock *kernel;
+  int32_t i, val;
+
+  if ( ref == dit->reference ) {
+    kernel = ca_clone(dit->kernel);
+  }
+  else {
+    CABlock *ck = (CABlock *)dit->kernel;
+    kernel = ca_block_new(ref,
+                          ck->rank, ck->size0,
+                          ck->start, ck->step, ck->count,
+                          ck->offset);
+  }
+
+  ca_update_mask(kernel);
+
+  for (i=0; i<dit->rank; i++) {
+    val = idx[i];
+    CA_CHECK_INDEX(val, dit->dim[i]);
+    kernel->start[dit->symindex[i]] = val * kernel->step[dit->symindex[i]];
+    if ( kernel->mask ) {
+      ((CABlock*)(kernel->mask))->start[dit->symindex[i]] =
+        val * kernel->step[dit->symindex[i]];
+    }
+  }
+
+  return (CArray*) kernel;
+}
+
+static CArray *
+ca_di_kernel_at_addr (void *it, int32_t addr, CArray *ref)
+{
+  CADimIterator *dit = (CADimIterator *) it;
+  int32_t *dim = dit->dim;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  for (i=dit->rank-1; i>=0; i--) {
+    idx[i] = addr % dim[i];
+    addr  /= dim[i];
+  }
+  return ca_di_kernel_at_index(it, idx, ref);
+}
+
+static CArray *
+ca_di_kernel_move_to_index (void *it, int32_t *idx, CArray *kern)
+{
+  CADimIterator *dit = (CADimIterator *)it;
+  CABlock *kernel = (CABlock *) kern;
+  int32_t i, val;
+
+  ca_update_mask(kernel);
+
+  for (i=0; i<dit->rank; i++) {
+    val = idx[i];
+    CA_CHECK_INDEX(val, dit->dim[i]);
+    kernel->start[dit->symindex[i]] = val * kernel->step[dit->symindex[i]];
+    if ( kernel->mask ) {
+      ((CABlock*)(kernel->mask))->start[dit->symindex[i]] =
+        val * kernel->step[dit->symindex[i]];
+    }
+  }
+
+  return (CArray*) kernel;
+}
+
+static CArray *
+ca_di_kernel_move_to_addr (void *it, int32_t addr, CArray *ref)
+{
+  CADimIterator *dit = (CADimIterator *) it;
+  int32_t *dim = dit->dim;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  for (i=dit->rank-1; i>=0; i--) {
+    idx[i] = addr % dim[i];
+    addr  /= dim[i];
+  }
+  return ca_di_kernel_move_to_index(it, idx, ref);
+}
+
+VALUE rb_ca_ref_block (VALUE self, CAIndexInfo *info);
+
+void
+ca_di_setup (VALUE self, VALUE rref, CAIndexInfo *info)
+{
+  volatile VALUE rindex, rker, rsymtbl;
+  CADimIterator *it;
+  CAIndexInfo blk_spec;
+  int8_t rank;
+  int i, j, k;
+
+  Data_Get_Struct(self, CADimIterator, it);
+
+  if ( info->type != CA_REG_ITERATOR ) {
+    rb_raise(rb_eRuntimeError, "given spec is not for dim iteratror");
+  }
+
+  rsymtbl = rb_hash_new();
+
+  blk_spec      = *info;
+  blk_spec.type = CA_REG_BLOCK;
+  for (i=0; i<info->rank; 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));
+    }
+  }
+
+  rref = rb_ca_ref_block(rref, &blk_spec);
+
+  rindex = rb_ary_new2(info->rank);
+  rank = 0;
+
+  j = 0;
+  k = 0;
+
+  for (i=0; i<info->rank; i++) {
+    if ( info->index_type[i] == CA_IDX_SCALAR ) {
+      rb_ary_store(rindex, i, INT2NUM(info->index[i].scalar));
+      continue; /* escape from j++ */
+    }
+    else if ( info->index_type[i] == CA_IDX_SYMBOL ) {
+      rb_ary_store(rindex, i, rb_ary_new3(1,INT2NUM(0)));
+      it->symflag[j]       = 1;
+      it->symindex[rank] = j;
+      rank++;
+    }
+    else if ( info->index_type[i] == CA_IDX_ALL ) {
+      rb_ary_store(rindex, i, Qnil);
+      it->symflag[j] = 0;
+    }
+    else if ( info->index_type[i] == CA_IDX_BLOCK ) {
+      rb_ary_store(rindex, i,
+                   rb_ary_new3(3, INT2NUM(0),
+                               INT2NUM(info->index[i].block.count),
+                               INT2NUM(1)));
+      it->symflag[j] = 0;
+    }
+    j++;
+  }
+
+  rker = rb_apply(rref, rb_intern("[]"), rindex);
+
+  it->rank = rank;
+  Data_Get_Struct(rref, CArray, it->reference);
+  Data_Get_Struct(rker, CArray, it->kernel);
+  it->kernel_at_addr  = ca_di_kernel_at_addr;
+  it->kernel_at_index = ca_di_kernel_at_index;
+  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++) {
+    it->dim[i] = it->reference->dim[it->symindex[i]];
+  }
+
+  rb_ivar_set(self, rb_intern("@reference"), rref); /* required ivar */
+  rb_ivar_set(self, rb_intern("@kernel"), rker);
+  rb_ivar_set(self, rb_intern("@symtbl"), rsymtbl);
+}
+
+static VALUE
+rb_di_s_allocate (VALUE klass)
+{
+  CADimIterator *it;
+  return Data_Make_Struct(klass, CADimIterator, 0, free, it);
+}
+
+static VALUE
+rb_di_initialize_copy (VALUE self, VALUE other)
+{
+  volatile VALUE rref, rker;
+  CADimIterator *is, *io;
+
+  Data_Get_Struct(self, CADimIterator, is);
+  Data_Get_Struct(other, CADimIterator, io);
+
+  rref = rb_ivar_get(self, rb_intern("@reference"));
+  rker = rb_obj_clone(rb_ivar_get(self, rb_intern("@kernel")));
+
+  *io = *is;
+
+  Data_Get_Struct(rker, CArray, io->kernel);
+
+  rb_ivar_set(self, rb_intern("@reference"), rref); /* required ivar */
+  rb_ivar_set(self, rb_intern("@kernel"), rker);
+
+  return self;
+}
+
+VALUE
+rb_ca_dim_iterator (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE obj;
+  CAIndexInfo info;
+  CArray *ca;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  rb_ca_scan_index(ca->rank, ca->dim, ca->elements, argc, argv, &info);
+
+  obj = rb_di_s_allocate(rb_cCADimIterator);
+  ca_di_setup(obj, self, &info);
+
+  return obj;
+}
+
+VALUE
+rb_dim_iter_new (VALUE rref, CAIndexInfo *info)
+{
+  volatile VALUE obj;
+
+  obj = rb_di_s_allocate(rb_cCADimIterator);
+  ca_di_setup(obj, rref, info);
+
+  return obj;
+}
+
+/* rdoc:
+  class CADimensionIterator
+    def sym2dim (sym)
+    end
+  end
+*/
+
+
+VALUE
+rb_dim_iter_sym2dim (VALUE self, VALUE sym)
+{
+  volatile VALUE rsymtbl;
+  rsymtbl = rb_ivar_get(self, rb_intern("@symtbl"));
+  return rb_hash_aref(rsymtbl, sym);
+}
+
+void
+Init_ca_iter_dimension ()
+{
+  rb_cCADimIterator = rb_define_class("CADimensionIterator", rb_cCAIterator);
+  rb_define_const(rb_cCADimIterator, "UNIFORM_KERNEL", Qtrue);
+
+  rb_define_alloc_func(rb_cCADimIterator, rb_di_s_allocate);
+  rb_define_method(rb_cCADimIterator, "initialize_copy",
+                                        rb_di_initialize_copy, 1);
+  /* rb_define_method(rb_cCArray, "dimension_iterator", rb_ca_dim_iterator, -1); */
+  rb_define_method(rb_cCADimIterator, "sym2dim", rb_dim_iter_sym2dim, 1);
+}
+