carray 2.0.0 → 3.0.0

data/ext/carray_numeric.c

@@ -1,259 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  carray_numeric.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
-
----------------------------------------------------------------------------- */
-
-#include "ruby.h"
-#include "carray.h"
-
-VALUE CA_NAN, CA_INF;
-
-static ID id___or__;
-static ID id___and__;
-static ID id___xor__;
-static ID id___rshift__;
-static ID id___lshift__;
-
-static ID id_bit_or;
-static ID id_bit_and;
-static ID id_bit_xor;
-static ID id_lshift;
-static ID id_rshift;
-
-static VALUE
-rb_hack_or(VALUE x, VALUE y)
-{
-  if ( rb_obj_is_carray(y) ) {
-    if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, id_bit_or, 1, x);
-    }
-    else {
-#if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, '|');
-#else
-      return rb_num_coerce_bin(x, y);
-#endif
-    }
-  }
-  else {
-    return rb_funcall(x, id___or__, 1, y);
-  }
-}
-
-static VALUE
-rb_hack_and (VALUE x, VALUE y)
-{
-  if ( rb_obj_is_carray(y) ) {
-    if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, id_bit_and, 1, x);
-    }
-    else {
-#if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, '&');
-#else
-      return rb_num_coerce_bin(x, y);
-#endif
-    }
-  }
-  else {
-    return rb_funcall(x, id___and__, 1, y);
-  }
-}
-
-static VALUE
-rb_hack_xor (VALUE x, VALUE y)
-{
-  if ( rb_obj_is_carray(y) ) {
-    if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, id_bit_xor, 1, x);
-    }
-    else {
-#if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, '^');
-#else
-      return rb_num_coerce_bin(x, y);
-#endif
-    }
-  }
-  else {
-    return rb_funcall(x, id___xor__, 1, y);
-  }
-}
-
-static VALUE
-rb_hack_lshift (VALUE x, VALUE y)
-{
-  if ( rb_obj_is_carray(y) ) {
-#if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, id_lshift);
-#else
-      return rb_num_coerce_bin(x, y);
-#endif
-  }
-  else {
-    return rb_funcall(x, id___lshift__, 1, y);
-  }
-}
-
-static VALUE
-rb_hack_rshift (VALUE x, VALUE y)
-{
-  if ( rb_obj_is_carray(y) ) {
-#if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, id_rshift);
-#else
-      return rb_num_coerce_bin(x, y);
-#endif
-  }
-  else {
-    return rb_funcall(x, id___rshift__, 1, y);
-  }
-}
-
-/* ------------------------------------------------------------------- */
-
-#ifdef HAVE_COMPLEX_H
-
-#include <math.h>
-#include <float.h>
-
-#define proc_arg_cmplx(type)                    \
-  {                                             \
-    type *p = (type *) ca->ptr;                 \
-    double *q = (double *) co->ptr;             \
-    boolean8_t *m = (ca->mask) ? (boolean8_t *) ca->mask->ptr : NULL; \
-    ca_size_t i;                                  \
-    if ( m ) {                                  \
-      for (i=ca->elements; i; i--, p++, q++) {  \
-        if ( ! *m++ )                           \
-          *q = carg(*p);                        \
-      }                                         \
-    }                                           \
-    else {                                      \
-      for (i=ca->elements; i; i--, p++, q++) {  \
-        *q = carg(*p);                          \
-      }                                         \
-    }                                           \
-  }
-
-static VALUE
-rb_ca_arg (VALUE self)
-{
-  volatile VALUE obj;
-  CArray *ca, *co;
-
-  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-
-  co = carray_new(CA_FLOAT64, ca->ndim, ca->dim, 0, NULL);
-  obj = ca_wrap_struct(co);
-
-  if ( ca_has_mask(ca) ) {
-    ca_copy_mask_overlay(co, co->elements, 1, ca);
-  }
-
-  ca_attach(ca);
-
-  switch ( ca->data_type ) {
-  case CA_FLOAT32:  proc_arg_cmplx(float32_t);  break;
-  case CA_FLOAT64:  proc_arg_cmplx(float64_t);  break;
-  case CA_FLOAT128: proc_arg_cmplx(float128_t);  break;
-  case CA_CMPLX64:  proc_arg_cmplx(cmplx64_t);   break;
-  case CA_CMPLX128: proc_arg_cmplx(cmplx128_t);  break;
-  case CA_CMPLX256: proc_arg_cmplx(cmplx256_t);  break;
-  default: rb_raise(rb_eRuntimeError, "invalid data type");
-  }
-
-  ca_detach(ca);
-
-  return obj;
-}
-
-#endif
-
-void
-Init_carray_numeric ()
-{
-  /* hack Fixnum and Bignum's "|", "&", "^", "<<", ">>" */
-
-  id___or__     = rb_intern("__or__");
-  id___and__    = rb_intern("__and__");
-  id___xor__    = rb_intern("__xor__");
-  id___rshift__ = rb_intern("__rshift__");
-  id___lshift__ = rb_intern("__lshift__");
-
-  id_bit_or     = rb_intern("bit_or");
-  id_bit_and    = rb_intern("bit_and");
-  id_bit_xor    = rb_intern("bit_xor");
-  id_lshift     = rb_intern("<<");
-  id_rshift     = rb_intern(">>");
-
-  CA_NAN = rb_float_new(0.0/0.0);
-  CA_INF = rb_float_new(1.0/0.0);
-  rb_define_const(rb_cObject, "CA_NAN", CA_NAN);
-  rb_define_const(rb_cObject, "CA_INF", CA_INF);
-
-  rb_define_alias(rb_cTrueClass, "__or__", "|");
-  rb_define_alias(rb_cTrueClass, "__and__", "&");
-  rb_define_alias(rb_cTrueClass, "__xor__", "^");
-
-  rb_define_method(rb_cTrueClass, "|", rb_hack_or, 1);
-  rb_define_method(rb_cTrueClass, "&", rb_hack_and, 1);
-  rb_define_method(rb_cTrueClass, "^", rb_hack_xor, 1);
-
-  rb_define_alias(rb_cFalseClass, "__or__", "|");
-  rb_define_alias(rb_cFalseClass, "__and__", "&");
-  rb_define_alias(rb_cFalseClass, "__xor__", "^");
-
-  rb_define_method(rb_cFalseClass, "|", rb_hack_or, 1);
-  rb_define_method(rb_cFalseClass, "&", rb_hack_and, 1);
-  rb_define_method(rb_cFalseClass, "^", rb_hack_xor, 1);
-
-#if RUBY_VERSION_CODE >= 240
-  rb_define_alias(rb_cInteger, "__or__", "|");
-  rb_define_alias(rb_cInteger, "__and__", "&");
-  rb_define_alias(rb_cInteger, "__xor__", "^");
-  rb_define_alias(rb_cInteger, "__lshift__", "<<");
-  rb_define_alias(rb_cInteger, "__rshift__", ">>");
-
-  rb_define_method(rb_cInteger, "|", rb_hack_or, 1);
-  rb_define_method(rb_cInteger, "&", rb_hack_and, 1);
-  rb_define_method(rb_cInteger, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cInteger, "<<", rb_hack_lshift, 1);
-  rb_define_method(rb_cInteger, ">>", rb_hack_rshift, 1);
-#else
-  rb_define_alias(rb_cFixnum, "__or__", "|");
-  rb_define_alias(rb_cFixnum, "__and__", "&");
-  rb_define_alias(rb_cFixnum, "__xor__", "^");
-  rb_define_alias(rb_cFixnum, "__lshift__", "<<");
-  rb_define_alias(rb_cFixnum, "__rshift__", ">>");
-
-  rb_define_alias(rb_cBignum, "__or__", "|");
-  rb_define_alias(rb_cBignum, "__and__", "&");
-  rb_define_alias(rb_cBignum, "__xor__", "^");
-  rb_define_alias(rb_cBignum, "__lshift__", "<<");
-  rb_define_alias(rb_cBignum, "__rshift__", ">>");
-
-  rb_define_method(rb_cFixnum, "|", rb_hack_or, 1);
-  rb_define_method(rb_cFixnum, "&", rb_hack_and, 1);
-  rb_define_method(rb_cFixnum, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cFixnum, "<<", rb_hack_lshift, 1);
-  rb_define_method(rb_cFixnum, ">>", rb_hack_rshift, 1);
-
-  rb_define_method(rb_cBignum, "|", rb_hack_or, 1);
-  rb_define_method(rb_cBignum, "&", rb_hack_and, 1);
-  rb_define_method(rb_cBignum, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cBignum, "<<", rb_hack_lshift, 1);
-  rb_define_method(rb_cBignum, ">>", rb_hack_rshift, 1);
-#endif
-
-#ifdef HAVE_COMPLEX_H
-  rb_define_method(rb_cCArray, "arg", rb_ca_arg, 0);
-#endif
-
-}
-

data/ext/carray_sort_addr.c

@@ -1,254 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  carray_sort_addr.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
-
----------------------------------------------------------------------------- */
-
-#include "ruby.h"
-#include "carray.h"
-#include <math.h>
-
-/* ----------------------------------------------------------------- */
-
-typedef int (*ca_qsort_cmp_func)();
-
-#define qcmp_type(type)         \
-static int                      \
-qcmp_## type (type *a, type *b) \
-{                               \
-  if ( *a > *b ) return 1;      \
-  if ( *a < *b ) return -1;     \
-  return 0;                     \
-}
-
-#define qcmp_f_type(type)       \
-static int                      \
-qcmp_## type (type *a, type *b) \
-{                               \
-  if ( isnan(*a) && ( ! isnan(*b) ) ) return 1;    \
-  if ( isnan(*b) && ( ! isnan(*a) ) ) return -1;   \
-  if ( *a > *b ) return 1;      \
-  if ( *a < *b ) return -1;     \
-  return 0;                     \
-}
-
-static int
-qcmp_data (char *a, char *b, ca_size_t bytes)
-{
-  int cmp;
-  cmp = memcmp(a, b, bytes);
-  if ( cmp != 0 ) return cmp;
-  return 0;
-}
-
-static int
-qcmp_VALUE (VALUE *a, VALUE *b)
-{
-  int cmp;
-  cmp = NUM2INT(rb_funcall(*a, rb_intern("<=>"), 1, *b));
-  if ( cmp != 0 ) return cmp;
-  return 0;
-}
-
-qcmp_type(boolean8_t)
-qcmp_type(int8_t)
-qcmp_type(uint8_t)
-qcmp_type(int16_t)
-qcmp_type(uint16_t)
-qcmp_type(int32_t)
-qcmp_type(uint32_t)
-qcmp_type(int64_t)
-qcmp_type(uint64_t)
-qcmp_f_type(float32_t)
-qcmp_f_type(float64_t)
-qcmp_f_type(float128_t)
-
-static int
-qcmp_not_implement (void *a, void *b)
-{
-  rb_raise(rb_eNotImpError,
-           "compare function is not implemented for the data type");
-}
-
-static ca_qsort_cmp_func
-ca_qsort_cmp[CA_NTYPE] = {
-  qcmp_data,
-  qcmp_boolean8_t,
-  qcmp_int8_t,
-  qcmp_uint8_t,
-  qcmp_int16_t,
-  qcmp_uint16_t,
-  qcmp_int32_t,
-  qcmp_uint32_t,
-  qcmp_int64_t,
-  qcmp_uint64_t,
-  qcmp_float32_t,
-  qcmp_float64_t,
-  qcmp_float128_t,
-  qcmp_not_implement,
-  qcmp_not_implement,
-  qcmp_not_implement,
-  qcmp_VALUE,
-};
-
-/* ----------------------------------------------------------------- */
-
-struct cmp_base {
-  int      n;
-  CArray **ca;
-};
-
-struct cmp_data {
-  ca_size_t  i;
-  struct cmp_base *base;
-};
-
-static int
-qcmp_func (struct cmp_data *a, struct cmp_data *b)
-{
-  struct cmp_base *base = a->base;
-  int n = base->n;
-  CArray **ca = base->ca;
-  ca_size_t ia = a->i;
-  ca_size_t ib = b->i;
-  int result;
-  int i;
-  for (i=0; i<n; i++) {
-    int8_t data_type = ca[i]->data_type;
-    char  *ptr = ca[i]->ptr;
-    boolean8_t  *m = ( ca[i]->mask ) ? (boolean8_t *) ca[i]->mask->ptr : NULL;
-    ca_size_t bytes = ca[i]->bytes;
-    if ( ( ! m ) || 
-         ( ( ! m[ia] ) && ( ! m[ib] ) ) ) {
-      if ( data_type == CA_FIXLEN ) {
-        result = ca_qsort_cmp[CA_FIXLEN](ptr + ia*bytes, 
-                                         ptr + ib*bytes, bytes);
-      }
-      else {
-        result = ca_qsort_cmp[data_type](ptr + ia*bytes, 
-                                         ptr + ib*bytes);
-      }
-    }
-    else if ( ( ! m[ia] ) && ( m[ib] ) ) {
-      result = -1;
-    }
-    else if ( ( m[ia] ) && ( ! m[ib] ) ) {
-      result = 1;
-    }
-    else {
-      result = 0;
-    }
-    if ( result ) {
-      return result;
-    }
-  }
-  return ( ia > ib ) ? 1 : -1; /* for stable sort */
-}
-
-/* @overload sort_addr (*args)
-
-(Sort) Returns index table for index sort
-
-     idx = CA.sort_addr(a, b, c)  ### priority a > b > c
-     a[idx]
-     b[idx]
-     c[idx]
-*/
-
-static VALUE
-rb_ca_s_sort_addr (int argc, VALUE *argv, VALUE self)
-{
-  volatile VALUE out;
-  CArray *co;
-  struct cmp_base *base;
-  struct cmp_data *data;
-  ca_size_t elements;
-  ca_size_t *q;
-  int j;
-  ca_size_t i;
-  
-  if ( argc <= 0 ) {
-    rb_raise(rb_eArgError, "no arg given");
-  }
-
-  rb_check_carray_object(argv[0]);
-  elements = NUM2SIZE(rb_ca_elements(argv[0]));
-  
-  for (j=0; j<argc; j++) {
-    rb_check_carray_object(argv[j]);
-    if ( elements != NUM2SIZE(rb_ca_elements(argv[j])) ) {
-      rb_raise(rb_eArgError, "elements mismatch");
-    }
-  }
-
-  base = malloc_with_check(sizeof(struct cmp_base));
-  base->n = argc;
-  base->ca = malloc_with_check(sizeof(CArray *)*base->n);
-
-  for (j=0; j<argc; j++) {
-    CArray *ca;
-    TypedData_Get_Struct(argv[j], CArray, &carray_data_type, ca);
-    base->ca[j] = ca;
-    ca_attach(ca);
-  }
-
-  data = malloc_with_check(sizeof(struct cmp_data)*elements);
-  for (i=0; i<elements; i++) {
-    data[i].i = i;
-    data[i].base = base;
-  }
-
-#ifdef HAVE_MERGESORT
-  mergesort(data, elements, sizeof(struct cmp_data), 
-            (int (*)(const void*,const void*)) qcmp_func);
-#else
-  qsort(data, elements, sizeof(struct cmp_data),
-            (int (*)(const void*,const void*)) qcmp_func);
-#endif
-
-  out = rb_ca_template_with_type(argv[0], INT2NUM(CA_SIZE), INT2NUM(0));
-  TypedData_Get_Struct(out, CArray, &carray_data_type, co);
-  q = (ca_size_t *) co->ptr;
-  
-  for (i=0; i<elements; i++) {
-    *q = data[i].i;
-    q++;
-  }
-
-  for (j=0; j<argc; j++) {
-    ca_detach(base->ca[j]);
-  }
-
-  free(data);
-  free(base->ca);  
-  free(base);        
-
-  return out;
-}
-
-/* @overload sort_addr (*args)
-
-(Sort) Returns index table for index sort
- This method same as,
-
-     idx = CA.sort_addr(self, *args) 
-*/
-
-static VALUE
-rb_ca_sort_addr (int argc, VALUE *argv, VALUE self)
-{
-  VALUE list = rb_ary_new4(argc, argv);
-  rb_ary_unshift(list, self);
-  return rb_apply(rb_mCA, rb_intern("sort_addr"), list);
-}
-
-void
-Init_carray_sort_addr ()
-{
-  rb_define_singleton_method(rb_mCA, "sort_addr", rb_ca_s_sort_addr, -1);
-  rb_define_method(rb_cCArray, "sort_addr", rb_ca_sort_addr, -1);
-}