numo-narray 0.9.0.1-x86-mingw32

data/ext/numo/narray/kwarg.c

@@ -0,0 +1,79 @@
+/*
+   kwarg.c : Process keyword arguments for Ruby
+
+   Copyright (c) 2001 Masahiro TANAKA <masa@ir.isas.ac.jp>
+
+   This program is free software.
+   You can distribute/modify this program
+   under the same terms as Ruby itself.
+   NO WARRANTY.
+*/
+#include <ruby.h>
+#include "numo/compat.h"
+
+/* void rb_scan_kw_args __((VALUE, ...)); */
+
+static VALUE
+kw_hash_i(i, tmp)
+     VALUE i, tmp;
+{
+    VALUE key;
+
+    key = RARRAY_AREF(i,0);
+    if (TYPE(key)==T_SYMBOL) {
+	key = rb_funcall(key, rb_intern("id2name"), 0);
+    } else
+	if (TYPE(key)!=T_STRING) {
+	    rb_raise(rb_eArgError, "keywords must be String or Symbol");
+	}
+
+    rb_hash_aset(tmp, key, RARRAY_AREF(i,1));
+    return Qnil;
+}
+
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+
+void
+#ifdef HAVE_STDARG_PROTOTYPES
+rb_scan_kw_args(VALUE hash, ...)
+#else
+rb_scan_kw_args(hash, va_alist)
+    VALUE hash;
+    va_dcl
+#endif
+{
+    va_list vargs;
+    va_init_list(vargs, hash);
+
+    char *key;
+    VALUE *var, val, str, tmp;
+
+    tmp = rb_hash_new();
+    if (TYPE(hash) == T_HASH)
+	rb_iterate(rb_each, hash, kw_hash_i, tmp);
+    else if (hash != Qnil)
+	rb_fatal("rb_san_kw_args: non-hash arg passed");
+
+    for (;;) {
+	key = va_arg(vargs, char*);
+	if (!key) break;
+	var = va_arg(vargs, VALUE*);
+	//printf("i=%d key=%x, val=%x\n",i,key,val);
+	str = rb_str_new2(key);
+	val = rb_funcall(tmp, rb_intern("delete"), 1, str);
+	if (var) *var = val;
+    }
+    va_end(vargs);
+
+    if (rb_funcall(tmp, rb_intern("empty?"), 0)==Qfalse) {
+	val = rb_funcall(tmp, rb_intern("keys"), 0);
+	val = rb_funcall(val, rb_intern("join"), 1, rb_str_new2(","));
+	rb_raise(rb_eArgError, "unknown keywords: %s",StringValueCStr(val));
+    }
+}

data/ext/numo/narray/math.c

@@ -0,0 +1,140 @@
+/*
+  math.c
+  Numerical Array Extension for Ruby
+    (C) Copyright 1999-2011 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+#include <ruby.h>
+#include "numo/narray.h"
+
+VALUE numo_mNMath;
+EXTERN VALUE numo_mDFloatMath, numo_mDComplexMath;
+static ID id_send;
+
+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, rb_intern("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, rb_intern("UPCAST"));
+                result_type = rb_hash_aref(upcast_hash, type1);
+            }
+        }
+    }
+    return result_type;
+}
+
+
+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);
+
+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,"%s is unknown for Numo::NMath",
+		     rb_class2name(argv[i]));
+	}
+    }
+    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.
+*/
+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, rb_intern("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,rb_intern("extract"),0);
+	}
+	return ans;
+    }
+    rb_raise(rb_eArgError,"argument or method missing");
+    return Qnil;
+}
+
+
+void
+Init_nary_math()
+{
+    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, rb_cFixnum,  rb_mMath);
+    rb_hash_aset(hCast, rb_cBignum,  rb_mMath);
+    rb_hash_aset(hCast, rb_cInteger, rb_mMath);
+    rb_hash_aset(hCast, rb_cFloat,   rb_mMath);
+    rb_hash_aset(hCast, rb_cComplex, numo_mDComplexMath);
+
+    id_send = rb_intern("send");
+}