numo-narray-alt 0.9.3

data/ext/numo/narray/kwargs.c

@@ -0,0 +1,142 @@
+/**********************************************************************
+
+  Function to extract Keyword argument for ruby-2.1.x
+  Copied from class.c in ruby-2.4.2
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+#include <ruby.h>
+#define rb_hash_tbl_raw(hash) rb_hash_tbl(hash)
+
+/* from internal.h */
+struct RBasicRaw {
+  VALUE flags;
+  VALUE klass;
+};
+
+#define RBASIC_SET_CLASS(obj, cls)                                                                                             \
+  do {                                                                                                                         \
+    VALUE _obj_ = (obj);                                                                                                       \
+    RB_OBJ_WRITE(_obj_, &((struct RBasicRaw*)(_obj_))->klass, cls);                                                            \
+  } while (0)
+
+/* from class.c */
+VALUE
+rb_keyword_error_new(const char* error, VALUE keys) {
+  const char* msg = "";
+  VALUE error_message;
+
+  if (RARRAY_LEN(keys) == 1) {
+    keys = RARRAY_AREF(keys, 0);
+  } else {
+    keys = rb_ary_join(keys, rb_usascii_str_new2(", "));
+    msg = "s";
+  }
+
+  error_message = rb_sprintf("%s keyword%s: %" PRIsVALUE, error, msg, keys);
+
+  return rb_exc_new_str(rb_eArgError, error_message);
+}
+
+NORETURN(static void rb_keyword_error(const char* error, VALUE keys));
+static void rb_keyword_error(const char* error, VALUE keys) {
+  rb_exc_raise(rb_keyword_error_new(error, keys));
+}
+
+NORETURN(static void unknown_keyword_error(VALUE hash, const ID* table, int keywords));
+static void unknown_keyword_error(VALUE hash, const ID* table, int keywords) {
+  st_table* tbl = rb_hash_tbl_raw(hash);
+  VALUE keys;
+  int i;
+  for (i = 0; i < keywords; i++) {
+    st_data_t key = ID2SYM(table[i]);
+    st_delete(tbl, &key, NULL);
+  }
+  keys = rb_funcallv(hash, rb_intern("keys"), 0, 0);
+  if (!RB_TYPE_P(keys, T_ARRAY)) rb_raise(rb_eArgError, "unknown keyword");
+  rb_keyword_error("unknown", keys);
+}
+
+static int separate_symbol(st_data_t key, st_data_t value, st_data_t arg) {
+  VALUE* kwdhash = (VALUE*)arg;
+
+  if (!SYMBOL_P(key)) kwdhash++;
+  if (!*kwdhash) *kwdhash = rb_hash_new();
+  rb_hash_aset(*kwdhash, (VALUE)key, (VALUE)value);
+  return ST_CONTINUE;
+}
+
+VALUE
+rb_extract_keywords(VALUE* orighash) {
+  VALUE parthash[2] = {0, 0};
+  VALUE hash = *orighash;
+
+  if (RHASH_EMPTY_P(hash)) {
+    *orighash = 0;
+    return hash;
+  }
+  st_foreach(rb_hash_tbl_raw(hash), separate_symbol, (st_data_t)&parthash);
+  *orighash = parthash[1];
+  if (parthash[1] && RBASIC_CLASS(hash) != rb_cHash) {
+    RBASIC_SET_CLASS(parthash[1], RBASIC_CLASS(hash));
+  }
+  return parthash[0];
+}
+
+int rb_get_kwargs(VALUE keyword_hash, const ID* table, int required, int optional, VALUE* values) {
+  int i = 0, j;
+  int rest = 0;
+  VALUE missing = Qnil;
+  st_data_t key;
+
+#define extract_kwarg(keyword, val)                                                                                            \
+  (key = (st_data_t)(keyword),                                                                                                 \
+   values ? st_delete(rb_hash_tbl_raw(keyword_hash), &key, (val)) : st_lookup(rb_hash_tbl_raw(keyword_hash), key, (val)))
+
+  if (NIL_P(keyword_hash)) keyword_hash = 0;
+
+  if (optional < 0) {
+    rest = 1;
+    optional = -1 - optional;
+  }
+  if (values) {
+    for (j = 0; j < required + optional; j++) {
+      values[j] = Qundef;
+    }
+  }
+  if (required) {
+    for (; i < required; i++) {
+      VALUE keyword = ID2SYM(table[i]);
+      if (keyword_hash) {
+        st_data_t val;
+        if (extract_kwarg(keyword, &val)) {
+          if (values) values[i] = (VALUE)val;
+          continue;
+        }
+      }
+      if (NIL_P(missing)) missing = rb_ary_tmp_new(1);
+      rb_ary_push(missing, keyword);
+    }
+    if (!NIL_P(missing)) {
+      rb_keyword_error("missing", missing);
+    }
+  }
+  j = i;
+  if (optional && keyword_hash) {
+    for (i = 0; i < optional; i++) {
+      st_data_t val;
+      if (extract_kwarg(ID2SYM(table[required + i]), &val)) {
+        if (values) values[required + i] = (VALUE)val;
+        j++;
+      }
+    }
+  }
+  if (!rest && keyword_hash) {
+    if (RHASH_SIZE(keyword_hash) > (unsigned int)(values ? 0 : j)) {
+      unknown_keyword_error(keyword_hash, table, required + optional);
+    }
+  }
+  return j;
+#undef extract_kwarg
+}

data/ext/numo/narray/math.c

@@ -0,0 +1,133 @@
+/*
+  math.c
+  Ruby/Numo::NArray - Numerical Array class for Ruby
+    Copyright (C) 1999-2020 Masahiro TANAKA
+*/
+#include <ruby.h>
+
+#include "numo/narray.h"
+
+VALUE numo_mNMath;
+extern VALUE numo_mDFloatMath, numo_mDComplexMath;
+extern VALUE numo_mSFloatMath, numo_mSComplexMath;
+static ID id_send;
+static ID id_UPCAST;
+static ID id_DISPATCH;
+static ID id_extract;
+
+static VALUE nary_type_s_upcast(VALUE type1, VALUE type2) {
+  VALUE upcast_hash;
+  VALUE result_type;
+
+  if (type1 == type2) return type1;
+  upcast_hash = rb_const_get(type1, id_UPCAST);
+  result_type = rb_hash_aref(upcast_hash, type2);
+  if (NIL_P(result_type)) {
+    if (TYPE(type2) == T_CLASS) {
+      if (RTEST(rb_class_inherited_p(type2, cNArray))) {
+        upcast_hash = rb_const_get(type2, id_UPCAST);
+        result_type = rb_hash_aref(upcast_hash, type1);
+      }
+    }
+  }
+  return result_type;
+}
+
+static VALUE nary_math_cast2(VALUE type1, VALUE type2) {
+  if (RTEST(rb_class_inherited_p(type1, cNArray))) {
+    return nary_type_s_upcast(type1, type2);
+  }
+  if (RTEST(rb_class_inherited_p(type2, cNArray))) {
+    return nary_type_s_upcast(type2, type1);
+  }
+  if (RTEST(rb_class_inherited_p(type1, rb_cNumeric)) && RTEST(rb_class_inherited_p(type2, rb_cNumeric))) {
+    if (RTEST(rb_class_inherited_p(type1, rb_cComplex)) || RTEST(rb_class_inherited_p(type2, rb_cComplex))) {
+      return rb_cComplex;
+    }
+    return rb_cFloat;
+  }
+  return type2;
+}
+
+VALUE na_ary_composition_dtype(VALUE);
+
+static VALUE nary_mathcast(int argc, VALUE* argv) {
+  VALUE type, type2;
+  int i;
+
+  type = na_ary_composition_dtype(argv[0]);
+  for (i = 1; i < argc; i++) {
+    type2 = na_ary_composition_dtype(argv[i]);
+    type = nary_math_cast2(type, type2);
+    if (NIL_P(type)) {
+      rb_raise(rb_eTypeError, "includes unknown DataType for upcast");
+    }
+  }
+  return type;
+}
+
+/*
+  Dispatches method to Math module of upcasted type,
+  eg, Numo::DFloat::Math.
+  @overload method_missing(name,x,...)
+  @param [Symbol] name  method name.
+  @param [NArray,Numeric] x  input array.
+  @return [NArray] result.
+*/
+static VALUE nary_math_method_missing(int argc, VALUE* argv, VALUE mod) {
+  VALUE type, ans, typemod, hash;
+  if (argc > 1) {
+    type = nary_mathcast(argc - 1, argv + 1);
+
+    hash = rb_const_get(mod, id_DISPATCH);
+    typemod = rb_hash_aref(hash, type);
+    if (NIL_P(typemod)) {
+      rb_raise(rb_eTypeError, "%s is unknown for Numo::NMath", rb_class2name(type));
+    }
+
+    ans = rb_funcall2(typemod, id_send, argc, argv);
+
+    if (!RTEST(rb_class_inherited_p(type, cNArray)) && IsNArray(ans)) {
+      ans = rb_funcall(ans, id_extract, 0);
+    }
+    return ans;
+  }
+  rb_raise(rb_eArgError, "argument or method missing");
+  return Qnil;
+}
+
+void Init_nary_math(void) {
+  VALUE hCast;
+
+  numo_mNMath = rb_define_module_under(mNumo, "NMath");
+  rb_define_singleton_method(numo_mNMath, "method_missing", nary_math_method_missing, -1);
+
+  hCast = rb_hash_new();
+  rb_define_const(numo_mNMath, "DISPATCH", hCast);
+  rb_hash_aset(hCast, numo_cInt64, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cInt32, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cInt16, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cInt8, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cUInt64, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cUInt32, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cUInt16, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cUInt8, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cDFloat, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cDFloat, numo_mDFloatMath);
+  rb_hash_aset(hCast, numo_cDComplex, numo_mDComplexMath);
+  rb_hash_aset(hCast, numo_cSFloat, numo_mSFloatMath);
+  rb_hash_aset(hCast, numo_cSComplex, numo_mSComplexMath);
+#ifdef RUBY_INTEGER_UNIFICATION
+  rb_hash_aset(hCast, rb_cInteger, rb_mMath);
+#else
+  rb_hash_aset(hCast, rb_cFixnum, rb_mMath);
+  rb_hash_aset(hCast, rb_cBignum, rb_mMath);
+#endif
+  rb_hash_aset(hCast, rb_cFloat, rb_mMath);
+  rb_hash_aset(hCast, rb_cComplex, numo_mDComplexMath);
+
+  id_send = rb_intern("send");
+  id_UPCAST = rb_intern("UPCAST");
+  id_DISPATCH = rb_intern("DISPATCH");
+  id_extract = rb_intern("extract");
+}