carray 2.0.0 → 3.0.0

data/ext/ca_iter_block.c

@@ -1,257 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  ca_iter_block.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
-
----------------------------------------------------------------------------- */
-
-#include "carray.h"
-
-extern const rb_data_type_t cablockiterator_data_type;
-
-const rb_data_type_t cablockiterator_data_type = {
-    .parent = &caiterator_data_type,
-    .wrap_struct_name = "CABlockIterator",
-    .function = {
-        .dmark = NULL,
-        .dfree = free,
-        .dsize = NULL,
-        .dcompact = NULL
-    },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
-/* yard:
-  class CABlockIterator < CAIterator # :nodoc: 
-  end
-*/
-
-
-VALUE rb_cCABlockIterator;
-
-/*
-typedef struct {
-  int16_t   obj_type;
-  int8_t    data_type;
-  int8_t    ndim;
-  int32_t   flags;
-  ca_size_t   bytes;
-  ca_size_t   elements;
-  ca_size_t  *dim;
-  char     *ptr;
-  CArray   *mask;
-  CArray   *parent;
-  uint32_t  attach;
-  uint8_t   nosync;
-  // ---------- 
-  int8_t    maxdim_index;
-  ca_size_t   maxdim_step;
-  ca_size_t   maxdim_step0;
-  ca_size_t   offset;
-  ca_size_t  *start;
-  ca_size_t  *step;
-  ca_size_t  *count;
-  ca_size_t  *size0;
-} CABlock;                  // 68 + 20*(ndim) (bytes) 
-*/
-
-typedef struct {
-  int8_t  ndim;
-  ca_size_t dim[CA_RANK_MAX];
-  CArray *reference;
-  CArray * (*kernel_at_addr)(void *, ca_size_t, CArray *);
-  CArray * (*kernel_at_index)(void *, ca_size_t *, CArray *);
-  CArray * (*kernel_move_to_addr)(void *, ca_size_t, CArray *);
-  CArray * (*kernel_move_to_index)(void *, ca_size_t *, CArray *);
-  /* ----------- */
-  CABlock *kernel;
-} CABlockIterator;
-
-/* ----------------------------------------------------------------- */
-
-static CArray *
-ca_bi_kernel_at_index (void *it, ca_size_t *idx, CArray *ref)
-{
-  CABlockIterator *bit = (CABlockIterator *) it;
-  CABlock *kernel;
-  int8_t  i;
-  ca_size_t j;
-
-  if ( ref == bit->reference ) {
-    kernel = (CABlock *)ca_clone(bit->kernel);
-  }
-  else {
-    CABlock *ck = (CABlock *)bit->kernel;
-    kernel = ca_block_new(ref,
-                          ck->ndim, ck->size0,
-                          ck->start, ck->step, ck->count,
-                          ck->offset);
-  }
-
-  ca_update_mask(kernel);
-
-  for (i=0; i<kernel->ndim; 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, ca_size_t addr, CArray *ref)
-{
-  CABlockIterator *bit = (CABlockIterator *) it;
-  ca_size_t *dim = bit->dim;
-  ca_size_t idx[CA_RANK_MAX];
-  int8_t i;
-  for (i=bit->ndim-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, ca_size_t *idx, CArray *kern)
-{
-  CABlockIterator *bit = (CABlockIterator *) it;
-  CABlock *kernel = (CABlock *) kern;
-  int8_t  i;
-  ca_size_t j;
-
-  ca_update_mask(kernel);
-
-  for (i=0; i<kernel->ndim; 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, ca_size_t addr, CArray *ref)
-{
-  CABlockIterator *bit = (CABlockIterator *) it;
-  ca_size_t *dim = bit->dim;
-  ca_size_t idx[CA_RANK_MAX];
-  int8_t i;
-  for (i=bit->ndim-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;
-  ca_size_t dim[CA_RANK_MAX];
-  int8_t i;
-
-  rker = rb_obj_clone(rker);
-
-  TypedData_Get_Struct(self, CABlockIterator, &cablockiterator_data_type, it);
-  TypedData_Get_Struct(rref, CArray, &carray_data_type, ref);
-  TypedData_Get_Struct(rker, CABlock, &cablock_data_type, ker);
-
-  if ( ref->ndim != ker->ndim ) {
-    rb_raise(rb_eRuntimeError, "ndim mismatch between reference and kernel");
-  }
-
-  for (i=0; i<ref->ndim; 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->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;
-  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 TypedData_Make_Struct(klass, CABlockIterator, &cablockiterator_data_type, 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;
-}
-
-/* yard:
-  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);
-  TypedData_Get_Struct(rker, CArray, &carray_data_type, 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/ext/ca_iter_dimension.c

@@ -1,299 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  ca_iter_dimension.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
-
----------------------------------------------------------------------------- */
-
-#include "ruby.h"
-#include "carray.h"
-
-VALUE rb_cCADimIterator;
-
-/* yard: 
-  class CADimensionIterator < CAIterator # :nodoc:
-  end
-*/
-
-typedef struct {
-  int8_t  ndim;
-  ca_size_t dim[CA_RANK_MAX];
-  CArray *reference;
-  CArray * (*kernel_at_addr)(void *, ca_size_t, CArray *);
-  CArray * (*kernel_at_index)(void *, ca_size_t *, CArray *);
-  CArray * (*kernel_move_to_addr)(void *, ca_size_t, CArray *);
-  CArray * (*kernel_move_to_index)(void *, ca_size_t *, CArray *);
-  /* ----------- */
-  CArray  *kernel;
-  int8_t   symflag[CA_RANK_MAX];
-  int8_t   symindex[CA_RANK_MAX];
-} CADimIterator;
-
-const rb_data_type_t cadimiterator_data_type = {
-    .parent = &caiterator_data_type,
-    .wrap_struct_name = "CADimIterator",
-    .function = {
-        .dmark = NULL,
-        .dfree = free,
-        .dsize = NULL,
-        .dcompact = NULL
-    },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
-/* -------------------------------------------------------------------- */
-
-static CArray *
-ca_di_kernel_at_index (void *it, ca_size_t *idx, CArray *ref)
-{
-  CADimIterator *dit = (CADimIterator *)it;
-  CABlock *kernel;
-  int8_t i;
-  ca_size_t val;
-
-  if ( ref == dit->reference ) {
-    kernel = ca_clone(dit->kernel);
-  }
-  else {
-    CABlock *ck = (CABlock *)dit->kernel;
-    kernel = ca_block_new(ref,
-                          ck->ndim, ck->size0,
-                          ck->start, ck->step, ck->count,
-                          ck->offset);
-  }
-
-  ca_update_mask(kernel);
-
-  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]];
-    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, ca_size_t addr, CArray *ref)
-{
-  CADimIterator *dit = (CADimIterator *) it;
-  ca_size_t *dim = dit->dim;
-  ca_size_t idx[CA_RANK_MAX];
-  int8_t i;
-  for (i=dit->ndim-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, ca_size_t *idx, CArray *kern)
-{
-  CADimIterator *dit = (CADimIterator *)it;
-  CABlock *kernel = (CABlock *) kern;
-  int8_t i;
-  ca_size_t val;
-
-  ca_update_mask(kernel);
-
-  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]];
-    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, ca_size_t addr, CArray *ref)
-{
-  CADimIterator *dit = (CADimIterator *) it;
-  ca_size_t *dim = dit->dim;
-  ca_size_t idx[CA_RANK_MAX];
-  int8_t i;
-  for (i=dit->ndim-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 ndim;
-  int i, j;
-
-  TypedData_Get_Struct(self, CADimIterator, &cadimiterator_data_type, 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->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));
-    }
-  }
-
-  rref = rb_ca_ref_block(rref, &blk_spec);
-
-  rindex = rb_ary_new2(info->ndim);
-  ndim = 0;
-
-  j = 0;
-
-  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++ */
-    }
-    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[ndim] = j;
-      ndim++;
-    }
-    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, SIZE2NUM(0),
-                               SIZE2NUM(info->index[i].block.count),
-                               SIZE2NUM(1)));
-      it->symflag[j] = 0;
-    }
-    j++;
-  }
-
-  rker = rb_apply(rref, rb_intern("[]"), rindex);
-
-  it->ndim = ndim;
-  TypedData_Get_Struct(rref, CArray, &carray_data_type, it->reference);
-  TypedData_Get_Struct(rker, CArray, &carray_data_type, 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->ndim; 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 TypedData_Make_Struct(klass, CADimIterator, &cadimiterator_data_type, it);
-}
-
-static VALUE
-rb_di_initialize_copy (VALUE self, VALUE other)
-{
-  volatile VALUE rref, rker;
-  CADimIterator *is, *io;
-
-  TypedData_Get_Struct(self, CADimIterator, &cadimiterator_data_type, is);
-  TypedData_Get_Struct(other, CADimIterator, &cadimiterator_data_type, io);
-
-  rref = rb_ivar_get(self, rb_intern("@reference"));
-  rker = rb_obj_clone(rb_ivar_get(self, rb_intern("@kernel")));
-
-  *io = *is;
-
-  TypedData_Get_Struct(rker, CArray, &carray_data_type, 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;
-
-  TypedData_Get_Struct(self, CArray, &carray_data_type, 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);
-  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;
-}
-
-/* yard:
-  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);
-}
-