carray 2.0.0 → 3.0.0

data/ext/carray_cast_func.rb

@@ -1,16 +1,3 @@
-# ----------------------------------------------------------------------------
-#
-#  carray_cast_func.rb
-#
-#  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
-#
-# ----------------------------------------------------------------------------
-
-
 data_type = []
 %w[
   CA_FIXLEN
@@ -48,10 +35,8 @@ ctype = {
   CA_UINT64   => "uint64_t",
   CA_FLOAT32  => "float32_t",
   CA_FLOAT64  => "float64_t",
-  CA_FLOAT128 => "float128_t",
   CA_CMPLX64  => "cmplx64_t",
   CA_CMPLX128 => "cmplx128_t",
-  CA_CMPLX256 => "cmplx256_t",
   CA_OBJECT   => "VALUE"
 }
 
@@ -68,10 +53,8 @@ obj2cval = {
   CA_UINT64   => "OBJ2ULL",
   CA_FLOAT32  => "OBJ2DBL",
   CA_FLOAT64  => "OBJ2DBL",
-  CA_FLOAT128 => "OBJ2DBL", ### upcast
   CA_CMPLX64  => "NUM2CC",
   CA_CMPLX128 => "NUM2CC",
-  CA_CMPLX256 => "NUM2CC", ### upcast
   CA_OBJECT   => ""
 }
 
@@ -88,10 +71,8 @@ cval2obj = {
   CA_UINT64   => "ULL2NUM",
   CA_FLOAT32  => "rb_float_new",
   CA_FLOAT64  => "rb_float_new",
-  CA_FLOAT128 => "rb_float_new", ### downcast
-  CA_CMPLX64  => "rb_ccomplex_new",
-  CA_CMPLX128 => "rb_ccomplex_new",
-  CA_CMPLX256 => "rb_ccomplex_new", ### downcast
+  CA_CMPLX64  => "CC2NUM",
+  CA_CMPLX128 => "CC2NUM",
   CA_OBJECT   => ""
 }
 
@@ -106,10 +87,8 @@ NUMERIC = [
   CA_UINT64   ,
   CA_FLOAT32  ,
   CA_FLOAT64  ,
-  CA_FLOAT128 ,
   CA_CMPLX64  ,
   CA_CMPLX128 ,
-  CA_CMPLX256 ,
 ]
 
 INTEGER = [
@@ -123,6 +102,40 @@ INTEGER = [
   CA_UINT64   ,
 ]
 
+FLOAT = [
+  CA_FLOAT32  ,
+  CA_FLOAT64  ,
+]
+
+# object -> int/float cast: a parse failure masks the output cell (UNDEF)
+# instead of a silent 0.0 (float) or a raise (int).  These parsers report
+# failure through an out-param whose C type is `oktype`.
+obj2cval_ok = {
+  CA_INT8     => "rb_obj2long_ok",
+  CA_UINT8    => "rb_obj2ulong_ok",
+  CA_INT16    => "rb_obj2long_ok",
+  CA_UINT16   => "rb_obj2ulong_ok",
+  CA_INT32    => "rb_obj2long_ok",
+  CA_UINT32   => "rb_obj2ulong_ok",
+  CA_INT64    => "rb_obj2ll_ok",
+  CA_UINT64   => "rb_obj2ull_ok",
+  CA_FLOAT32  => "ca_obj2dbl_ok",
+  CA_FLOAT64  => "ca_obj2dbl_ok",
+}
+
+oktype = {
+  CA_INT8     => "long",
+  CA_UINT8    => "unsigned long",
+  CA_INT16    => "long",
+  CA_UINT16   => "unsigned long",
+  CA_INT32    => "long",
+  CA_UINT32   => "unsigned long",
+  CA_INT64    => "long long",
+  CA_UINT64   => "unsigned long long",
+  CA_FLOAT32  => "double",
+  CA_FLOAT64  => "double",
+}
+
 BOOLEAN = [
   CA_BOOLEAN
 ]
@@ -154,20 +167,13 @@ end
 puts %{
 /* ---------------------------------------------------------------------------
 
-  carray_cast_func.c
-
-  This file is part of Ruby/CArray extension library.
-  You can redistribute it and/or modify it under the terms of
-  the Ruby\'s licence.
-
-  This file is automatically generated from carray_math.rb.
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
+  carray_cast_func.c -- GENERATED by ext/carray_cast_func.rb -- DO NOT EDIT
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
 
-static void
+static void __attribute__((noreturn))
 ca_cast_not_implemented(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
 {
   rb_raise(rb_eCADataTypeError, 
@@ -332,9 +338,6 @@ puts
          ca_size_t k;
          if ( m ) {
            boolean8_t *pm = m;
-           #ifdef _OPENMP
-           #pragma omp parallel for private(pm,p1,p2)
-           #endif
            for (k=0; k<n; k++) {
              pm = m + k;
              if ( ! *pm ) { 
@@ -345,9 +348,6 @@ puts
            }
          }
          else {
-           #ifdef _OPENMP
-           #pragma omp parallel for private(p1,p2)
-           #endif
            for (k=0; k<n; k++) {
              p1 = q1 + k;
              p2 = q2 + k;
@@ -455,10 +455,51 @@ OBJECT.each do |type1|
   (BOOLEAN+NUMERIC+OBJECT).each do |type2|
     ctype1 = ctype[type1]
     ctype2 = ctype[type2]
+    CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
+    if (INTEGER+FLOAT).include?(type2)
+      # object -> int/float: parse failure -> masked (UNDEF) output cell.
+      # The mask-aware loop runs only when a mask buffer is supplied (m);
+      # #to_type always supplies one for these targets so the whole
+      # user-facing object->numeric surface gets the masking semantics.
+      # With no mask buffer (internal single-cell / view paths) the legacy
+      # value parser keeps its old behaviour (lenient 0.0 float / raising
+      # int), leaving those paths byte-identical.
+      conv_ok = obj2cval_ok[type2]
+      conv    = obj2cval[type2]
+      oktype2 = oktype[type2]
+      puts <<-END_DEF  .gsub(/^ {6}/, '')
+        static void
+        ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+        {
+           VALUE *p1 = ptr1;
+           #{ctype2} *p2 = ptr2;
+           #{oktype2} tmp;
+           if ( m ) {
+             while ( n-- ) {
+               if ( !*m ) {
+                 if ( #{conv_ok}(*p1, &tmp) ) {
+                   *p2 = (#{ctype2}) tmp;
+                 }
+                 else {
+                   *m = 1;
+                   *p2 = 0;
+                 }
+               }
+               p1++; p2++; m++;
+             }
+           }
+           else {
+             while ( n-- ) { *p2 = (#{ctype2}) #{conv}(*p1); p1++; p2++; }
+           }
+           return;
+        }
+      END_DEF
+      puts
+      next
+    end
     unless conv = obj2cval[type2]
       next
     end
-    CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
       ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
@@ -466,7 +507,7 @@ OBJECT.each do |type1|
          VALUE *p1 = ptr1;
          #{ctype2} *p2 = ptr2;
          if ( m ) {
-           while ( n-- ) { 
+           while ( n-- ) {
              if ( !*m ) { *p2 = (#{ctype2}) #{conv}(*p1); }
              p1++; p2++; m++;
            }

data/ext/carray_class.c

@@ -1,65 +1,58 @@
 /* ---------------------------------------------------------------------------
 
-  carray_class.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
+  CArray class-level inquiries: host endianness, sizeof(data_type),
+  data_type ↔ name / code conversion.
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
 
-/* @overload endian 
-
-(Inquiry) 
-Returns the machine endianness.
-   0 (CA_LITTLE_ENDIAN)
-   1 (CA_BIG_ENDIAN)
-*/
+/* ------------------------------------------------------------------- */
+/* Symbol cache for data_type code → Symbol lookup.
+ *
+ * Pre-computed at Init time so `ca.data_type` can return
+ * `ID2SYM(ca_data_type_sym[ca->data_type])` with no rb_intern call
+ * per access.
+ *
+ * Indexed by data_type code (0 = CA_FIXLEN ... CA_NTYPE-1 = CA_OBJECT).
+ * Symbol name = ca_type_name[i] ("fixlen" / "int8" / ... / "object").
+ * Unused slots (CA_FLOAT128 = 12, CA_CMPLX256 = 15) are populated but
+ * never reached at runtime because ca_valid[] is 0 there.
+ * ------------------------------------------------------------------- */
+
+ID ca_data_type_sym[CA_NTYPE];
+
+VALUE
+rb_ca_data_type_to_sym (int8_t data_type)
+{
+  CA_CHECK_DATA_TYPE(data_type);
+  return ID2SYM(ca_data_type_sym[data_type]);
+}
 
+/* Returns the machine endianness as an integer
+   (0 = CA_LITTLE_ENDIAN, 1 = CA_BIG_ENDIAN). */
 static VALUE
 rb_ca_s_endian (VALUE klass)
 {
   return INT2NUM(ca_endian);
 }
 
-/* @overload big_endian?
-  
-(Inquiry) 
-Returns true if the byte order of the architecture is big endian.
-*/
-
+/* Returns true if the host byte order is big-endian. */
 static VALUE
 rb_ca_s_big_endian_p (VALUE klass)
 {
   return ( ca_endian == CA_BIG_ENDIAN ) ? Qtrue : Qfalse;
 }
 
-/* @overload little_endian?
-
-(Inquiry) 
-Returns true if the byte order of the architecture is
-little endian.
-*/
-
+/* Returns true if the host byte order is little-endian. */
 static VALUE
 rb_ca_s_little_endian_p (VALUE klass)
 {
   return ( ca_endian == CA_LITTLE_ENDIAN ) ? Qtrue : Qfalse;
 }
 
-/* @overload sizeof (data_type)
-
-(Inquiry) 
-Returns the byte length of an element of the given data type.
-Retruns <code>0</code> if data_type is equal to CA_FIXLEN.
-     CArray.sizeof(CA_INT32)  #=> 4
-     CArray.sizeof(CA_DOUBLE) #=> 8
-     CArray.sizeof(CA_FIXLEN)   #=> 0
-
-*/
-
+/* Returns the byte length of one element of the given data_type.
+   Returns 0 for CA_FIXLEN (whose width is per-instance, not per-type). */
 static VALUE
 rb_ca_s_sizeof (VALUE klass, VALUE rtype)
 {
@@ -69,44 +62,41 @@ rb_ca_s_sizeof (VALUE klass, VALUE rtype)
   return SIZE2NUM(bytes);
 }
 
-
-/* @overload data_type?(data_type)
-
-(Inquiry) 
-Returns true if the given data_type indicate the valid data_type.
-*/
-
+/* Returns the string representation of a data_type specifier.
+   Accepts Symbol, Integer code, Class, or String uniformly via
+   rb_ca_guess_type. */
 static VALUE
-rb_ca_s_data_type (VALUE klass, VALUE rtype)
+rb_ca_s_data_type_name (VALUE klass, VALUE type)
 {
-  int8_t data_type = rb_ca_guess_type(rtype);
-  if ( data_type <= CA_NONE || data_type >= CA_NTYPE ) {
-    rb_raise(rb_eArgError,
-            "data type is out of range (%i..%i)", CA_NONE+1, CA_NTYPE-1);
-  }
-  return ca_valid[data_type] == 1 ? Qtrue : Qfalse;
+  int8_t data_type = rb_ca_guess_type(type);
+  CA_CHECK_DATA_TYPE(data_type);
+  return rb_str_new2(ca_type_name[data_type]);
 }
 
-/* @overload data_type_name(data_type)
-
-(Inquiry) 
-Returns string representaion of the data_type specifier.
-*/
-
-
+/* Returns the internal int8_t data_type code (e.g. 8 for :int64,
+   11 for :float64).  Inverse of rb_ca_s_data_type_name (which returns
+   a String).  Accepts the same representations.
+   Used by Ruby-side code that needs to compute kernel op_ids from a
+   data_type (e.g. CAMonOp::CAST_BASE + code in lib/carray/lazy.rb).
+   End users normally do not need this -- use Symbol comparison or
+   the CA_* constants. */
 static VALUE
-rb_ca_s_data_type_name (VALUE klass, VALUE type)
+rb_ca_s_data_type_code (VALUE klass, VALUE type)
 {
-  int8_t data_type = NUM2INT(type);
+  int8_t data_type = rb_ca_guess_type(type);
   CA_CHECK_DATA_TYPE(data_type);
-  return rb_str_new2(ca_type_name[data_type]);
+  return INT2NUM(data_type);
 }
 
 /* ------------------------------------------------------------------- */
 
 void
-Init_carray_class ()
+Init_carray_class (void)
 {
+  /* NOTE: ca_data_type_sym[] cache is initialized earlier in
+     Init_carray_ext (ruby_carray.c) before the CA_* data_type constants
+     are defined.  Don't re-initialize here. */
+
   rb_define_const(rb_cObject, "CA_BIG_ENDIAN", INT2NUM(CA_BIG_ENDIAN));
   rb_define_const(rb_cObject, "CA_LITTLE_ENDIAN", INT2NUM(CA_LITTLE_ENDIAN));
 
@@ -116,9 +106,9 @@ Init_carray_class ()
   rb_define_singleton_method(rb_cCArray, "little_endian?",
                              rb_ca_s_little_endian_p, 0);
   rb_define_singleton_method(rb_cCArray, "sizeof", rb_ca_s_sizeof, 1);
-  rb_define_singleton_method(rb_cCArray, "data_type?",
-                             rb_ca_s_data_type, 1);
   rb_define_singleton_method(rb_cCArray, "data_type_name",
                              rb_ca_s_data_type_name, 1);
+  rb_define_singleton_method(rb_cCArray, "data_type_code",
+                             rb_ca_s_data_type_code, 1);
 }
 

data/ext/carray_config.h

@@ -0,0 +1,28 @@
+#ifndef CARRAY_CONFIG_H
+#define CARRAY_CONFIG_H
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_TYPE_INT8_T 1
+#define HAVE_TYPE_UINT8_T 1
+#define HAVE_TYPE_INT16_T 1
+#define HAVE_TYPE_UINT16_T 1
+#define HAVE_TYPE_INT32_T 1
+#define HAVE_TYPE_UINT32_T 1
+#define HAVE_TYPE_INT64_T 1
+#define HAVE_TYPE_UINT64_T 1
+#define HAVE_TYPE_LONG_LONG 1
+#define HAVE_TYPE_FLOAT 1
+#define HAVE_TYPE_DOUBLE 1
+#define HAVE_COMPLEX_H 1
+#define HAVE_TYPE_FLOAT_COMPLEX 1
+#define HAVE_TYPE_DOUBLE_COMPLEX 1
+#define HAVE_TGMATH_H 1
+#define HAVE_ATAN2 1
+#define HAVE_HYPOT 1
+#define HAVE_LGAMMA 1
+#define HAVE_EXPM1 1
+#define HAVE_MERGESORT 1
+#define HAVE_STRPTIME 1
+#define HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT 1
+#define HAVE_RUBY_MEMORY_VIEW_H 1
+#endif