[Pkg-ruby-extras-maintainers] r572 - in
packages/libnarray-ruby/trunk: . debian
Daigo Moriwaki
daigo-guest at costa.debian.org
Sat Jun 3 13:41:33 UTC 2006
Author: daigo-guest
Date: 2006-06-03 13:41:32 +0000 (Sat, 03 Jun 2006)
New Revision: 572
Added:
packages/libnarray-ruby/trunk/debian/
packages/libnarray-ruby/trunk/debian/changelog
packages/libnarray-ruby/trunk/debian/compat
packages/libnarray-ruby/trunk/debian/control
packages/libnarray-ruby/trunk/debian/control.in
packages/libnarray-ruby/trunk/debian/copyright
packages/libnarray-ruby/trunk/debian/dirs
packages/libnarray-ruby/trunk/debian/docs
packages/libnarray-ruby/trunk/debian/rules
packages/libnarray-ruby/trunk/debian/watch
packages/libnarray-ruby/trunk/na_math.c
packages/libnarray-ruby/trunk/na_op.c
packages/libnarray-ruby/trunk/narray_config.h
Log:
Load newtrunk into packages/libnarray-ruby/trunk.
Added: packages/libnarray-ruby/trunk/debian/changelog
===================================================================
--- packages/libnarray-ruby/trunk/debian/changelog 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/changelog 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,6 @@
+libnarray-ruby (0.5.8-1) unstable; urgency=low
+
+ * Initial release. (Closes: #370120)
+
+ -- Daigo Moriwaki <daigo at debian.org> Sat, 3 Jun 2006 20:45:57 +0900
+
Added: packages/libnarray-ruby/trunk/debian/compat
===================================================================
--- packages/libnarray-ruby/trunk/debian/compat 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/compat 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1 @@
+4
Added: packages/libnarray-ruby/trunk/debian/control
===================================================================
--- packages/libnarray-ruby/trunk/debian/control 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/control 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,35 @@
+Source: libnarray-ruby
+Section: interpreters
+Priority: optional
+Maintainer: Daigo Moriwaki <daigo at debian.org>
+Uploaders: Debian Ruby Extras Maintainers <pkg-ruby-extras-maintainers at lists.alioth.debian.org>, Antonio S. de A. Terceiro <asaterceiro at inf.ufrgs.br>, David Moreno Garza <damog at debian.org>, David Nusinow <dnusinow at debian.org>, Paul van Tilburg <paulvt at debian.org>, Esteban Manchado Velázquez <zoso at debian.org>, Arnaud Cornet <arnaud.cornet at gmail.com>, Lucas Nussbaum <lucas at lucas-nussbaum.net>, Thierry Reding <thierry at doppeltgemoppelt.de>, Marc Dequènes (Duck) <Duck at DuckCorp.org>, Ari Pollak <ari at debian.org>
+Build-Depends: cdbs, debhelper (>> 5), ruby-pkg-tools, ruby1.8, ruby1.8-dev
+Standards-Version: 3.7.2
+
+Package: libnarray-ruby
+Architecture: all
+Depends: libnarray-ruby1.8
+Description: Numerical N-dimensional Array library for Ruby
+ NArray is an extension library for Ruby that provides fast calculation and
+ easy manipulation of large numerical arrays with the Ruby language. It has
+ numerical n-dimensional array class as well as vector and matrix subclasses,
+ which can contain 1/2/4-byte Integer, single/double-precision Real/Complex and
+ Ruby Object.
+ .
+ Homepage http://narray.rubyforge.org/index.html.en
+ .
+ This is a dependency package which depends on Debian's default Ruby version
+ (currently 1.8.x).
+
+Package: libnarray-ruby1.8
+Architecture: any
+Depends: ruby1.8, ${shlibs:Depends}, ${misc:Depends}
+Description: Numerical N-dimensional Array library for Ruby
+ NArray is an extension library for Ruby that provides fast calculation and
+ easy manipulation of large numerical arrays with the Ruby language. It has
+ numerical n-dimensional array class as well as vector and matrix subclasses,
+ which can contain 1/2/4-byte Integer, single/double-precision Real/Complex and
+ Ruby Object.
+ .
+ Homepage http://narray.rubyforge.org/index.html.en
+
Added: packages/libnarray-ruby/trunk/debian/control.in
===================================================================
--- packages/libnarray-ruby/trunk/debian/control.in 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/control.in 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,35 @@
+Source: libnarray-ruby
+Section: interpreters
+Priority: optional
+Maintainer: Daigo Moriwaki <daigo at debian.org>
+Uploaders: @RUBY_EXTRAS_TEAM@
+Build-Depends: cdbs, debhelper (>> 5), ruby-pkg-tools, ruby1.8, ruby1.8-dev
+Standards-Version: 3.7.2
+
+Package: libnarray-ruby
+Architecture: all
+Depends: libnarray-ruby1.8
+Description: Numerical N-dimensional Array library for Ruby
+ NArray is an extension library for Ruby that provides fast calculation and
+ easy manipulation of large numerical arrays with the Ruby language. It has
+ numerical n-dimensional array class as well as vector and matrix subclasses,
+ which can contain 1/2/4-byte Integer, single/double-precision Real/Complex and
+ Ruby Object.
+ .
+ Homepage http://narray.rubyforge.org/index.html.en
+ .
+ This is a dependency package which depends on Debian's default Ruby version
+ (currently 1.8.x).
+
+Package: libnarray-ruby1.8
+Architecture: any
+Depends: ruby1.8, ${shlibs:Depends}, ${misc:Depends}
+Description: Numerical N-dimensional Array library for Ruby
+ NArray is an extension library for Ruby that provides fast calculation and
+ easy manipulation of large numerical arrays with the Ruby language. It has
+ numerical n-dimensional array class as well as vector and matrix subclasses,
+ which can contain 1/2/4-byte Integer, single/double-precision Real/Complex and
+ Ruby Object.
+ .
+ Homepage http://narray.rubyforge.org/index.html.en
+
Added: packages/libnarray-ruby/trunk/debian/copyright
===================================================================
--- packages/libnarray-ruby/trunk/debian/copyright 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/copyright 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,66 @@
+This package was debianized by Daigo Moriwaki <daigo at debian.org> on
+Sat, 3 Jun 2006 20:45:57 +0900.
+
+It was downloaded from http://narray.rubyforge.org/index.html.en.
+
+Copyright Holder: Masahiro TANAKA <masa at ir.isas.ac.jp>
+
+License:
+
+You can redistribute it and/or modify it under either the terms of the GPL
+(on Debian systems, the complete text of the GPL License can be found in
+/usr/share/common-licenses/GPL), or the conditions below:
+
+ 1. You may make and give away verbatim copies of the source form of the
+ software without restriction, provided that you duplicate all of the
+ original copyright notices and associated disclaimers.
+
+ 2. You may modify your copy of the software in any way, provided that
+ you do at least ONE of the following:
+
+ a) place your modifications in the Public Domain or otherwise
+ make them Freely Available, such as by posting said
+ modifications to Usenet or an equivalent medium, or by allowing
+ the author to include your modifications in the software.
+
+ b) use the modified software only within your corporation or
+ organization.
+
+ c) give non-standard binaries non-standard names, with
+ instructions on where to get the original software distribution.
+
+ d) make other distribution arrangements with the author.
+
+ 3. You may distribute the software in object code or binary form,
+ provided that you do at least ONE of the following:
+
+ a) distribute the binaries and library files of the software,
+ together with instructions (in the manual page or equivalent)
+ on where to get the original distribution.
+
+ b) accompany the distribution with the machine-readable source of
+ the software.
+
+ c) give non-standard binaries non-standard names, with
+ instructions on where to get the original software distribution.
+
+ d) make other distribution arrangements with the author.
+
+ 4. You may modify and include the part of the software into any other
+ software (possibly commercial). But some files in the distribution
+ are not written by the author, so that they are not under these terms.
+
+ For the list of those files and their copying conditions, see the
+ file LEGAL.
+
+ 5. The scripts and library files supplied as input to or produced as
+ output from the software do not automatically fall under the
+ copyright of the software, but belong to whomever generated them,
+ and may be sold commercially, and may be aggregated with this
+ software.
+
+ 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE.
+
Added: packages/libnarray-ruby/trunk/debian/dirs
===================================================================
--- packages/libnarray-ruby/trunk/debian/dirs 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/dirs 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,2 @@
+usr/bin
+usr/sbin
Added: packages/libnarray-ruby/trunk/debian/docs
===================================================================
--- packages/libnarray-ruby/trunk/debian/docs 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/docs 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,2 @@
+README.en
+README.ja
Added: packages/libnarray-ruby/trunk/debian/rules
===================================================================
--- packages/libnarray-ruby/trunk/debian/rules 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/rules 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,12 @@
+#!/usr/bin/make -f
+# Sample debian/rules that uses cdbs. Originaly written by Robert Millan.
+# This file is public domain.
+
+DEB_TAR_SRCDIR := libnarray-ruby-0.5.8
+DEB_AUTO_CLEANUP_RCS := yes
+
+# Add here any variable or target overrides you need
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/ruby-pkg-tools/1/rules/uploaders.mk
+include /usr/share/ruby-pkg-tools/1/class/ruby-extconf-rb.mk
Property changes on: packages/libnarray-ruby/trunk/debian/rules
___________________________________________________________________
Name: svn:executable
+ *
Added: packages/libnarray-ruby/trunk/debian/watch
===================================================================
--- packages/libnarray-ruby/trunk/debian/watch 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/debian/watch 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,23 @@
+# Example watch control file for uscan
+# Rename this file to "watch" and then you can run the "uscan" command
+# to check for upstream updates and more.
+# See uscan(1) for format
+
+# Compulsory line, this is a version 3 file
+version=3
+
+# Uncomment to examine a Webpage
+# <Webpage URL> <string match>
+http://narray.rubyforge.org/index.html.en \
+http://rubyforge.org/frs/download.php/7658/narray-([\d\.]*)\.tar\.gz
+
+# Uncomment to examine a Webserver directory
+#http://www.example.com/pub/libnarray-ruby-(.*)\.tar\.gz
+
+# Uncommment to examine a FTP server
+#ftp://ftp.example.com/pub/libnarray-ruby-(.*)\.tar\.gz debian uupdate
+
+# Uncomment to find new files on sourceforge, for debscripts >= 2.9
+# http://sf.net/libnarray-ruby/libnarray-ruby-(.*)\.tar\.gz
+
+
Added: packages/libnarray-ruby/trunk/na_math.c
===================================================================
--- packages/libnarray-ruby/trunk/na_math.c 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/na_math.c 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,1204 @@
+/*
+ na_math.c
+ Automatically generated code
+ Numerical Array Extention for Ruby
+ (C) Copyright 1999-2002 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 "narray.h"
+#include "narray_local.h"
+
+#ifndef M_LOG2E
+#define M_LOG2E 1.4426950408889634074
+#endif
+#ifndef M_LOG10E
+#define M_LOG10E 0.43429448190325182765
+#endif
+
+VALUE rb_mNMath;
+
+static void TpErr(void) {
+ rb_raise(rb_eTypeError,"illegal operation with this type");
+}
+
+#if 0
+void sincos(double x, double *s, double *c)
+{
+ *s=sin(x); *c=cos(x);
+}
+#endif
+
+#ifndef HAVE_ASINH
+static double rb_log1p (const double x)
+{
+ double y;
+ y = 1+x;
+
+ if (y==1)
+ return x;
+ else
+ return log(y)*(x/(y-1));
+}
+
+static double zero=0;
+
+double acosh(double x)
+{
+ /* acosh(x) = log(x+sqrt(x*x-1)) */
+ if (x>2) {
+ return log(2*x-1/(sqrt(x*x-1)+x));
+ } else if (x>=1) {
+ x-=1;
+ return rb_log1p(x+sqrt(2*x+x*x));
+ }
+ return zero/(x-x); /* x<1: NaN */
+}
+
+double asinh(double x)
+{
+ double a, x2;
+ int neg;
+
+ /* asinh(x) = log(x+sqrt(x*x+1)) */
+ neg = x<0;
+ if (neg) {x=-x;}
+ x2 = x*x;
+
+ if (x>2) {
+ a = log(2*x+1/(x+sqrt(x2+1)));
+ } else {
+ a = rb_log1p(x+x2/(1+sqrt(x2+1)));
+ }
+ if (neg) {a=-a;}
+ return a;
+}
+
+double atanh(double x)
+{
+ double a, x2;
+ int neg;
+
+ /* atanh(x) = 0.5*log((1+x)/(1-x)) */
+ neg = x<0;
+ if (neg) {x=-x;}
+ x2 = x*2;
+
+ if (x<0.5) {
+ a = 0.5*rb_log1p(x2+x2*x/(1-x));
+ } else if (x<1) {
+ a = 0.5*rb_log1p(x2/(1-x));
+ } else if (x==1) {
+ a = 1/zero; /* Infinity */
+ } else {
+ return zero/(x-x); /* x>1: NaN */
+ }
+ if (neg) {a=-a;}
+ return a;
+}
+#endif
+
+static void squareX(scomplex *x) {
+ float r=x->r;
+ x->r = r*r - x->i*x->i;
+ x->i = 2*r*x->i;
+}
+
+static void squareC(dcomplex *x) {
+ double r=x->r;
+ x->r = r*r - x->i*x->i;
+ x->i = 2*r*x->i;
+}
+
+
+static void mulX(scomplex *x, scomplex *y) {
+ scomplex z=*x;
+ x->r = z.r*y->r - z.i*y->i;
+ x->i = z.r*y->i + z.i*y->r;
+}
+
+static void mulC(dcomplex *x, dcomplex *y) {
+ dcomplex z=*x;
+ x->r = z.r*y->r - z.i*y->i;
+ x->i = z.r*y->i + z.i*y->r;
+}
+
+
+static void divX(scomplex *p1, scomplex *p2) {
+ scomplex x = *p1;
+ float a = p2->r*p2->r + p2->i*p2->i;
+ p1->r = (x.r*p2->r + x.i*p2->i)/a;
+ p1->i = (x.i*p2->r - x.r*p2->i)/a;
+}
+
+static void divC(dcomplex *p1, dcomplex *p2) {
+ dcomplex x = *p1;
+ double a = p2->r*p2->r + p2->i*p2->i;
+ p1->r = (x.r*p2->r + x.i*p2->i)/a;
+ p1->i = (x.i*p2->r - x.r*p2->i)/a;
+}
+
+
+static scomplex recipX(scomplex *z)
+{
+ scomplex r;
+ float n;
+
+ if ( (z->r<0 ? -z->r:z->r) > (z->i<0 ? -z->i:z->i) ) {
+ r.i = z->i/z->r;
+ n = (1+r.i*r.i)*z->r;
+ r.r = 1/n;
+ r.i /= -n;
+ } else {
+ r.r = z->r/z->i;
+ n = (1+r.r*r.r)*z->i;
+ r.r /= n;
+ r.i = -1/n;
+ }
+ return r;
+}
+
+static dcomplex recipC(dcomplex *z)
+{
+ dcomplex r;
+ double n;
+
+ if ( (z->r<0 ? -z->r:z->r) > (z->i<0 ? -z->i:z->i) ) {
+ r.i = z->i/z->r;
+ n = (1+r.i*r.i)*z->r;
+ r.r = 1/n;
+ r.i /= -n;
+ } else {
+ r.r = z->r/z->i;
+ n = (1+r.r*r.r)*z->i;
+ r.r /= n;
+ r.i = -1/n;
+ }
+ return r;
+}
+
+
+static int powInt(int x, int p)
+{
+ int r=1;
+
+ switch(p) {
+ case 2: return x*x;
+ case 3: return x*x*x;
+ case 1: return x;
+ case 0: return 1;
+ }
+ if (p<0) return 0;
+ /* if(p>3) */
+ while (p) {
+ if ( (p%2) == 1 ) r *= x;
+ x *= x;
+ p /= 2;
+ }
+ return r;
+}
+
+
+static float powFi(float x, int p)
+{
+ float r=1;
+
+ switch(p) {
+ case 2: return x*x;
+ case 3: return x*x*x;
+ case 1: return x;
+ case 0: return 1;
+ }
+ if (p<0) return 1/powFi(x,-p);
+ /* if(p>3) */
+ while (p) {
+ if ( (p%2) == 1 ) r *= x;
+ x *= x;
+ p /= 2;
+ }
+ return r;
+}
+
+
+static double powDi(double x, int p)
+{
+ double r=1;
+
+ switch(p) {
+ case 2: return x*x;
+ case 3: return x*x*x;
+ case 1: return x;
+ case 0: return 1;
+ }
+ if (p<0) return 1/powDi(x,-p);
+ /* if(p>3) */
+ while (p) {
+ if ( (p%2) == 1 ) r *= x;
+ x *= x;
+ p /= 2;
+ }
+ return r;
+}
+
+
+static scomplex powXi(scomplex *x, int p)
+{
+ scomplex y=*x, r={1,0};
+
+ if (p==2) { squareX(&y); return y; }
+ if (p==1) { return y; }
+ if (p==0) { return r; }
+ if (p<0) {
+ y = powXi(x,-p);
+ return recipX(&y);
+ }
+ /* if (p>2) */
+ while (p) {
+ if ( (p%2) == 1 ) mulX(&r,&y);
+ squareX(&y);
+ p /= 2;
+ }
+ return r;
+}
+
+static dcomplex powCi(dcomplex *x, int p)
+{
+ dcomplex y=*x, r={1,0};
+
+ if (p==2) { squareC(&y); return y; }
+ if (p==1) { return y; }
+ if (p==0) { return r; }
+ if (p<0) {
+ y = powCi(x,-p);
+ return recipC(&y);
+ }
+ /* if (p>2) */
+ while (p) {
+ if ( (p%2) == 1 ) mulC(&r,&y);
+ squareC(&y);
+ p /= 2;
+ }
+ return r;
+}
+
+
+
+/* ------------------------- sqrt --------------------------- */
+static void sqrtF(void *p1, void *p2){ *(float*)p1 = sqrt(*(float*)p2); }
+static void sqrtD(void *p1, void *p2){ *(double*)p1 = sqrt(*(double*)p2); }
+static void sqrtX(void *p1, void *p2){
+ float xr=((scomplex*)p2)->r/2, xi=((scomplex*)p2)->i/2, r=hypot(xr,xi);
+ if (xr>0) {
+ ((scomplex*)p1)->r = sqrt(r+xr);
+ ((scomplex*)p1)->i = xi/((scomplex*)p1)->r;
+ } else if ( (r-=xr) ) {
+ ((scomplex*)p1)->i = (xi>=0) ? sqrt(r):-sqrt(r);
+ ((scomplex*)p1)->r = xi/((scomplex*)p1)->i;
+ } else {
+ ((scomplex*)p1)->r = ((scomplex*)p1)->i = 0;
+ }
+}
+static void sqrtC(void *p1, void *p2){
+ double xr=((dcomplex*)p2)->r/2, xi=((dcomplex*)p2)->i/2, r=hypot(xr,xi);
+ if (xr>0) {
+ ((dcomplex*)p1)->r = sqrt(r+xr);
+ ((dcomplex*)p1)->i = xi/((dcomplex*)p1)->r;
+ } else if ( (r-=xr) ) {
+ ((dcomplex*)p1)->i = (xi>=0) ? sqrt(r):-sqrt(r);
+ ((dcomplex*)p1)->r = xi/((dcomplex*)p1)->i;
+ } else {
+ ((dcomplex*)p1)->r = ((dcomplex*)p1)->i = 0;
+ }
+}
+
+na_mathfunc_t sqrtFuncs =
+{ TpErr, TpErr, TpErr, TpErr, sqrtF, sqrtD, sqrtX, sqrtC, TpErr };
+
+/* ------------------------- sin --------------------------- */
+static void sinF(void *p1, void *p2){ *(float*)p1 = sin(*(float*)p2); }
+static void sinD(void *p1, void *p2){ *(double*)p1 = sin(*(double*)p2); }
+static void sinX(void *p1, void *p2){
+ ((scomplex*)p1)->r = sin(((scomplex*)p2)->r)*cosh(((scomplex*)p2)->i);
+ ((scomplex*)p1)->i = cos(((scomplex*)p2)->r)*sinh(((scomplex*)p2)->i); }
+static void sinC(void *p1, void *p2){
+ ((dcomplex*)p1)->r = sin(((dcomplex*)p2)->r)*cosh(((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->i = cos(((dcomplex*)p2)->r)*sinh(((dcomplex*)p2)->i); }
+
+na_mathfunc_t sinFuncs =
+{ TpErr, TpErr, TpErr, TpErr, sinF, sinD, sinX, sinC, TpErr };
+
+/* ------------------------- cos --------------------------- */
+static void cosF(void *p1, void *p2){ *(float*)p1 = cos(*(float*)p2); }
+static void cosD(void *p1, void *p2){ *(double*)p1 = cos(*(double*)p2); }
+static void cosX(void *p1, void *p2){
+ ((scomplex*)p1)->r = cos(((scomplex*)p2)->r)*cosh(((scomplex*)p2)->i);
+ ((scomplex*)p1)->i = -sin(((scomplex*)p2)->r)*sinh(((scomplex*)p2)->i); }
+static void cosC(void *p1, void *p2){
+ ((dcomplex*)p1)->r = cos(((dcomplex*)p2)->r)*cosh(((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->i = -sin(((dcomplex*)p2)->r)*sinh(((dcomplex*)p2)->i); }
+
+na_mathfunc_t cosFuncs =
+{ TpErr, TpErr, TpErr, TpErr, cosF, cosD, cosX, cosC, TpErr };
+
+/* ------------------------- tan --------------------------- */
+static void tanF(void *p1, void *p2){ *(float*)p1 = tan(*(float*)p2); }
+static void tanD(void *p1, void *p2){ *(double*)p1 = tan(*(double*)p2); }
+static void tanX(void *p1, void *p2){
+ float d, th;
+ ((scomplex*)p1)->i = th = tanh(2*((scomplex*)p2)->i);
+ ((scomplex*)p1)->r = sqrt(1-th*th); /* sech */
+ d = 1 + cos(2*((scomplex*)p2)->r) * ((scomplex*)p1)->r;
+ ((scomplex*)p1)->r *= sin(2*((scomplex*)p2)->r)/d;
+ ((scomplex*)p1)->i /= d;
+}
+static void tanC(void *p1, void *p2){
+ double d, th;
+ ((dcomplex*)p1)->i = th = tanh(2*((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->r = sqrt(1-th*th); /* sech */
+ d = 1 + cos(2*((dcomplex*)p2)->r) * ((dcomplex*)p1)->r;
+ ((dcomplex*)p1)->r *= sin(2*((dcomplex*)p2)->r)/d;
+ ((dcomplex*)p1)->i /= d;
+}
+
+na_mathfunc_t tanFuncs =
+{ TpErr, TpErr, TpErr, TpErr, tanF, tanD, tanX, tanC, TpErr };
+
+/* ------------------------- sinh --------------------------- */
+static void sinhF(void *p1, void *p2){ *(float*)p1 = sinh(*(float*)p2); }
+static void sinhD(void *p1, void *p2){ *(double*)p1 = sinh(*(double*)p2); }
+static void sinhX(void *p1, void *p2){
+ ((scomplex*)p1)->r = sinh(((scomplex*)p2)->r)*cos(((scomplex*)p2)->i);
+ ((scomplex*)p1)->i = cosh(((scomplex*)p2)->r)*sin(((scomplex*)p2)->i);
+}
+static void sinhC(void *p1, void *p2){
+ ((dcomplex*)p1)->r = sinh(((dcomplex*)p2)->r)*cos(((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->i = cosh(((dcomplex*)p2)->r)*sin(((dcomplex*)p2)->i);
+}
+
+na_mathfunc_t sinhFuncs =
+{ TpErr, TpErr, TpErr, TpErr, sinhF, sinhD, sinhX, sinhC, TpErr };
+
+/* ------------------------- cosh --------------------------- */
+static void coshF(void *p1, void *p2){ *(float*)p1 = cosh(*(float*)p2); }
+static void coshD(void *p1, void *p2){ *(double*)p1 = cosh(*(double*)p2); }
+static void coshX(void *p1, void *p2){
+ ((scomplex*)p1)->r = cosh(((scomplex*)p2)->r)*cos(((scomplex*)p2)->i);
+ ((scomplex*)p1)->i = sinh(((scomplex*)p2)->r)*sin(((scomplex*)p2)->i);
+}
+static void coshC(void *p1, void *p2){
+ ((dcomplex*)p1)->r = cosh(((dcomplex*)p2)->r)*cos(((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->i = sinh(((dcomplex*)p2)->r)*sin(((dcomplex*)p2)->i);
+}
+
+na_mathfunc_t coshFuncs =
+{ TpErr, TpErr, TpErr, TpErr, coshF, coshD, coshX, coshC, TpErr };
+
+/* ------------------------- tanh --------------------------- */
+static void tanhF(void *p1, void *p2){ *(float*)p1 = tanh(*(float*)p2); }
+static void tanhD(void *p1, void *p2){ *(double*)p1 = tanh(*(double*)p2); }
+static void tanhX(void *p1, void *p2){
+ float d, th;
+ ((scomplex*)p1)->r = th = tanh(2*((scomplex*)p2)->r);
+ ((scomplex*)p1)->i = sqrt(1-th*th); /* sech */
+ d = 1 + cos(2*((scomplex*)p2)->i) * ((scomplex*)p1)->i;
+ ((scomplex*)p1)->r /= d;
+ ((scomplex*)p1)->i *= sin(2*((scomplex*)p2)->i)/d;
+}
+static void tanhC(void *p1, void *p2){
+ double d, th;
+ ((dcomplex*)p1)->r = th = tanh(2*((dcomplex*)p2)->r);
+ ((dcomplex*)p1)->i = sqrt(1-th*th); /* sech */
+ d = 1 + cos(2*((dcomplex*)p2)->i) * ((dcomplex*)p1)->i;
+ ((dcomplex*)p1)->r /= d;
+ ((dcomplex*)p1)->i *= sin(2*((dcomplex*)p2)->i)/d;
+}
+
+na_mathfunc_t tanhFuncs =
+{ TpErr, TpErr, TpErr, TpErr, tanhF, tanhD, tanhX, tanhC, TpErr };
+
+/* ------------------------- exp --------------------------- */
+static void expF(void *p1, void *p2){ *(float*)p1 = exp(*(float*)p2); }
+static void expD(void *p1, void *p2){ *(double*)p1 = exp(*(double*)p2); }
+static void expX(void *p1, void *p2){
+ float a = exp(((scomplex*)p2)->r);
+ ((scomplex*)p1)->r = a*cos(((scomplex*)p2)->i);
+ ((scomplex*)p1)->i = a*sin(((scomplex*)p2)->i);
+}
+static void expC(void *p1, void *p2){
+ double a = exp(((dcomplex*)p2)->r);
+ ((dcomplex*)p1)->r = a*cos(((dcomplex*)p2)->i);
+ ((dcomplex*)p1)->i = a*sin(((dcomplex*)p2)->i);
+}
+
+na_mathfunc_t expFuncs =
+{ TpErr, TpErr, TpErr, TpErr, expF, expD, expX, expC, TpErr };
+
+/* ------------------------- log --------------------------- */
+static void logF(void *p1, void *p2){ *(float*)p1 = log(*(float*)p2); }
+static void logD(void *p1, void *p2){ *(double*)p1 = log(*(double*)p2); }
+static void logX(void *p1, void *p2){
+ scomplex x = *(scomplex*)p2;
+ ((scomplex*)p1)->r = log(hypot(x.r, x.i));
+ ((scomplex*)p1)->i = atan2(x.i, x.r);
+}
+static void logC(void *p1, void *p2){
+ dcomplex x = *(dcomplex*)p2;
+ ((dcomplex*)p1)->r = log(hypot(x.r, x.i));
+ ((dcomplex*)p1)->i = atan2(x.i, x.r);
+}
+
+na_mathfunc_t logFuncs =
+{ TpErr, TpErr, TpErr, TpErr, logF, logD, logX, logC, TpErr };
+
+/* ------------------------- log10 --------------------------- */
+static void log10F(void *p1, void *p2){ *(float*)p1 = log10(*(float*)p2); }
+static void log10D(void *p1, void *p2){ *(double*)p1 = log10(*(double*)p2); }
+static void log10X(void *p1, void *p2){
+ logX(p1,p2);
+ ((scomplex*)p1)->r *= M_LOG10E;
+ ((scomplex*)p1)->i *= M_LOG10E;
+}
+static void log10C(void *p1, void *p2){
+ logC(p1,p2);
+ ((dcomplex*)p1)->r *= M_LOG10E;
+ ((dcomplex*)p1)->i *= M_LOG10E;
+}
+
+na_mathfunc_t log10Funcs =
+{ TpErr, TpErr, TpErr, TpErr, log10F, log10D, log10X, log10C, TpErr };
+
+/* ------------------------- log2 --------------------------- */
+static void log2F(void *p1, void *p2){ *(float*)p1 = log(*(float*)p2)*M_LOG2E; }
+static void log2D(void *p1, void *p2){ *(double*)p1 = log(*(double*)p2)*M_LOG2E; }
+static void log2X(void *p1, void *p2){
+ logX(p1,p2);
+ ((scomplex*)p1)->r *= M_LOG2E;
+ ((scomplex*)p1)->i *= M_LOG2E;
+}
+static void log2C(void *p1, void *p2){
+ logC(p1,p2);
+ ((dcomplex*)p1)->r *= M_LOG2E;
+ ((dcomplex*)p1)->i *= M_LOG2E;
+}
+
+na_mathfunc_t log2Funcs =
+{ TpErr, TpErr, TpErr, TpErr, log2F, log2D, log2X, log2C, TpErr };
+
+/* ------------------------- asin --------------------------- */
+static void asinF(void *p1, void *p2){ *(float*)p1 = asin(*(float*)p2); }
+static void asinD(void *p1, void *p2){ *(double*)p1 = asin(*(double*)p2); }
+static void asinX(void *p1, void *p2){
+ scomplex x = *(scomplex*)p2;
+ squareX(&x);
+ x.r = 1 - x.r;
+ x.i = - x.i;
+ sqrtX(&x,&x);
+ x.r -= ((scomplex*)p2)->i;
+ x.i += ((scomplex*)p2)->r;
+ logX(&x,&x);
+ ((scomplex*)p1)->r = x.i;
+ ((scomplex*)p1)->i = -x.r;
+}
+static void asinC(void *p1, void *p2){
+ dcomplex x = *(dcomplex*)p2;
+ squareC(&x);
+ x.r = 1 - x.r;
+ x.i = - x.i;
+ sqrtC(&x,&x);
+ x.r -= ((dcomplex*)p2)->i;
+ x.i += ((dcomplex*)p2)->r;
+ logC(&x,&x);
+ ((dcomplex*)p1)->r = x.i;
+ ((dcomplex*)p1)->i = -x.r;
+}
+
+na_mathfunc_t asinFuncs =
+{ TpErr, TpErr, TpErr, TpErr, asinF, asinD, asinX, asinC, TpErr };
+
+/* ------------------------- asinh --------------------------- */
+static void asinhF(void *p1, void *p2){ *(float*)p1 = asinh(*(float*)p2); }
+static void asinhD(void *p1, void *p2){ *(double*)p1 = asinh(*(double*)p2); }
+static void asinhX(void *p1, void *p2){
+ scomplex x = *(scomplex*)p2;
+ squareX(&x);
+ x.r += 1;
+ sqrtX(&x,&x);
+ x.r += ((scomplex*)p2)->r;
+ x.i += ((scomplex*)p2)->i;
+ logX(p1,&x);
+}
+static void asinhC(void *p1, void *p2){
+ dcomplex x = *(dcomplex*)p2;
+ squareC(&x);
+ x.r += 1;
+ sqrtC(&x,&x);
+ x.r += ((dcomplex*)p2)->r;
+ x.i += ((dcomplex*)p2)->i;
+ logC(p1,&x);
+}
+
+na_mathfunc_t asinhFuncs =
+{ TpErr, TpErr, TpErr, TpErr, asinhF, asinhD, asinhX, asinhC, TpErr };
+
+/* ------------------------- acos --------------------------- */
+static void acosF(void *p1, void *p2){ *(float*)p1 = acos(*(float*)p2); }
+static void acosD(void *p1, void *p2){ *(double*)p1 = acos(*(double*)p2); }
+static void acosX(void *p1, void *p2){
+ scomplex x = *(scomplex*)p2;
+ float tmp;
+ squareX(&x);
+ x.r = 1 - x.r;
+ x.i = - x.i;
+ sqrtX(&x,&x);
+ tmp = x.r + ((scomplex*)p2)->i;
+ x.r = -x.i + ((scomplex*)p2)->r;
+ x.i = tmp;
+ logX(&x,&x);
+ ((scomplex*)p1)->r = x.i;
+ ((scomplex*)p1)->i = -x.r;
+}
+static void acosC(void *p1, void *p2){
+ dcomplex x = *(dcomplex*)p2;
+ double tmp;
+ squareC(&x);
+ x.r = 1 - x.r;
+ x.i = - x.i;
+ sqrtC(&x,&x);
+ tmp = x.r + ((dcomplex*)p2)->i;
+ x.r = -x.i + ((dcomplex*)p2)->r;
+ x.i = tmp;
+ logC(&x,&x);
+ ((dcomplex*)p1)->r = x.i;
+ ((dcomplex*)p1)->i = -x.r;
+}
+
+na_mathfunc_t acosFuncs =
+{ TpErr, TpErr, TpErr, TpErr, acosF, acosD, acosX, acosC, TpErr };
+
+/* ------------------------- acosh --------------------------- */
+static void acoshF(void *p1, void *p2){ *(float*)p1 = acosh(*(float*)p2); }
+static void acoshD(void *p1, void *p2){ *(double*)p1 = acosh(*(double*)p2); }
+static void acoshX(void *p1, void *p2){
+ scomplex x = *(scomplex*)p2;
+ squareX(&x);
+ x.r -= 1;
+ sqrtX(&x,&x);
+ x.r += ((scomplex*)p2)->r;
+ x.i += ((scomplex*)p2)->i;
+ logX(p1,&x);
+}
+static void acoshC(void *p1, void *p2){
+ dcomplex x = *(dcomplex*)p2;
+ squareC(&x);
+ x.r -= 1;
+ sqrtC(&x,&x);
+ x.r += ((dcomplex*)p2)->r;
+ x.i += ((dcomplex*)p2)->i;
+ logC(p1,&x);
+}
+
+na_mathfunc_t acoshFuncs =
+{ TpErr, TpErr, TpErr, TpErr, acoshF, acoshD, acoshX, acoshC, TpErr };
+
+/* ------------------------- atan --------------------------- */
+static void atanF(void *p1, void *p2){ *(float*)p1 = atan(*(float*)p2); }
+static void atanD(void *p1, void *p2){ *(double*)p1 = atan(*(double*)p2); }
+static void atanX(void *p1, void *p2){
+ scomplex x,y;
+ x.r=-((scomplex*)p2)->r; x.i=1-((scomplex*)p2)->i;
+ y.r= ((scomplex*)p2)->r; y.i=1+((scomplex*)p2)->i;
+ divX((void*)&y,(void*)&x);
+ logX((void*)&x,(void*)&y);
+ ((scomplex*)p1)->r = -x.i/2;
+ ((scomplex*)p1)->i = x.r/2;
+}
+static void atanC(void *p1, void *p2){
+ dcomplex x,y;
+ x.r=-((dcomplex*)p2)->r; x.i=1-((dcomplex*)p2)->i;
+ y.r= ((dcomplex*)p2)->r; y.i=1+((dcomplex*)p2)->i;
+ divC((void*)&y,(void*)&x);
+ logC((void*)&x,(void*)&y);
+ ((dcomplex*)p1)->r = -x.i/2;
+ ((dcomplex*)p1)->i = x.r/2;
+}
+
+na_mathfunc_t atanFuncs =
+{ TpErr, TpErr, TpErr, TpErr, atanF, atanD, atanX, atanC, TpErr };
+
+/* ------------------------- atanh --------------------------- */
+static void atanhF(void *p1, void *p2){ *(float*)p1 = atanh(*(float*)p2); }
+static void atanhD(void *p1, void *p2){ *(double*)p1 = atanh(*(double*)p2); }
+static void atanhX(void *p1, void *p2){
+ scomplex x,y;
+ x.r=1-((scomplex*)p2)->r; x.i=-((scomplex*)p2)->i;
+ y.r=1+((scomplex*)p2)->r; y.i= ((scomplex*)p2)->i;
+ divX((void*)&y,(void*)&x);
+ logX((void*)&x,(void*)&y);
+ ((scomplex*)p1)->r = x.r/2;
+ ((scomplex*)p1)->i = x.i/2;
+}
+static void atanhC(void *p1, void *p2){
+ dcomplex x,y;
+ x.r=1-((dcomplex*)p2)->r; x.i=-((dcomplex*)p2)->i;
+ y.r=1+((dcomplex*)p2)->r; y.i= ((dcomplex*)p2)->i;
+ divC((void*)&y,(void*)&x);
+ logC((void*)&x,(void*)&y);
+ ((dcomplex*)p1)->r = x.r/2;
+ ((dcomplex*)p1)->i = x.i/2;
+}
+
+na_mathfunc_t atanhFuncs =
+{ TpErr, TpErr, TpErr, TpErr, atanhF, atanhD, atanhX, atanhC, TpErr };
+
+/* ------------------------- Rcp --------------------------- */
+static void RcpB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = 1/(*(u_int8_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = 1/(*(int16_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = 1/(*(int32_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = 1/(*(float*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = 1/(*(double*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(scomplex*)p1 = recipX((scomplex*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(dcomplex*)p1 = recipC((dcomplex*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RcpO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(INT2FIX(1),na_id_div,1,*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t RcpFuncs =
+{ TpErr, RcpB, RcpI, RcpL, RcpF, RcpD, RcpX, RcpC, RcpO };
+
+/* ------------------------- Pow --------------------------- */
+static void PowBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = powInt(*(u_int8_t*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = powInt(*(u_int8_t*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = powInt(*(u_int8_t*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = pow(*(u_int8_t*)p2,*(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(u_int8_t*)p2,*(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowIB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = powInt(*(int16_t*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowII(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = powInt(*(int16_t*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowIL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = powInt(*(int16_t*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowIF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = pow(*(int16_t*)p2,*(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowID(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(int16_t*)p2,*(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowLB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = powInt(*(int32_t*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowLI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = powInt(*(int32_t*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowLL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = powInt(*(int32_t*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowLF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = pow(*(int32_t*)p2,*(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowLD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(int32_t*)p2,*(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowFB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = powFi(*(float*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowFI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = powFi(*(float*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowFL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = powFi(*(float*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowFF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = pow(*(float*)p2,*(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowFD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(float*)p2,*(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowDB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = powDi(*(double*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowDI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = powDi(*(double*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowDL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = powDi(*(double*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowDF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(double*)p2,*(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowDD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = pow(*(double*)p2,*(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(scomplex*)p1 = powXi((scomplex*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(scomplex*)p1 = powXi((scomplex*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(scomplex*)p1 = powXi((scomplex*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex r;
+ if (*(float*)p3==0)
+ { ((scomplex*)p1)->r=1; ((scomplex*)p1)->i=0; } else
+ if (((scomplex*)p2)->r==0 && ((scomplex*)p2)->i==0 && *(float*)p3>0)
+ { ((scomplex*)p1)->r=0; ((scomplex*)p1)->i=0; } else {
+ logX(&r, p2);
+ r.r *= *(float*)p3;
+ r.i *= *(float*)p3;
+ expX(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex r;
+ if (*(double*)p3==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((scomplex*)p2)->r==0 && ((scomplex*)p2)->i==0 && *(double*)p3>0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logX(&r, p2);
+ r.r *= *(double*)p3;
+ r.i *= *(double*)p3;
+ expX(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex l, r;
+ if (((scomplex*)p3)->r==0 && ((scomplex*)p3)->i==0)
+ { ((scomplex*)p1)->r=1; ((scomplex*)p1)->i=0; } else
+ if (((scomplex*)p2)->r==0 && ((scomplex*)p2)->i==0 && ((scomplex*)p3)->r>0 && ((scomplex*)p3)->i==0)
+ { ((scomplex*)p1)->r=0; ((scomplex*)p1)->i=0; } else {
+ logX(&l, p2);
+ r.r = ((scomplex*)p3)->r * l.r - ((scomplex*)p3)->i * l.i;
+ r.i = ((scomplex*)p3)->r * l.i + ((scomplex*)p3)->i * l.r;
+ expX(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowXC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex l, r;
+ if (((dcomplex*)p3)->r==0 && ((dcomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((scomplex*)p2)->r==0 && ((scomplex*)p2)->i==0 && ((dcomplex*)p3)->r>0 && ((dcomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logX(&l, p2);
+ r.r = ((dcomplex*)p3)->r * l.r - ((dcomplex*)p3)->i * l.i;
+ r.i = ((dcomplex*)p3)->r * l.i + ((dcomplex*)p3)->i * l.r;
+ expX(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(dcomplex*)p1 = powCi((dcomplex*)p2,*(u_int8_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(dcomplex*)p1 = powCi((dcomplex*)p2,*(int16_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(dcomplex*)p1 = powCi((dcomplex*)p2,*(int32_t*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex r;
+ if (*(float*)p3==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((dcomplex*)p2)->r==0 && ((dcomplex*)p2)->i==0 && *(float*)p3>0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logC(&r, p2);
+ r.r *= *(float*)p3;
+ r.i *= *(float*)p3;
+ expC(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex r;
+ if (*(double*)p3==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((dcomplex*)p2)->r==0 && ((dcomplex*)p2)->i==0 && *(double*)p3>0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logC(&r, p2);
+ r.r *= *(double*)p3;
+ r.i *= *(double*)p3;
+ expC(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex l, r;
+ if (((scomplex*)p3)->r==0 && ((scomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((dcomplex*)p2)->r==0 && ((dcomplex*)p2)->i==0 && ((scomplex*)p3)->r>0 && ((scomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logC(&l, p2);
+ r.r = ((scomplex*)p3)->r * l.r - ((scomplex*)p3)->i * l.i;
+ r.i = ((scomplex*)p3)->r * l.i + ((scomplex*)p3)->i * l.r;
+ expC(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowCC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex l, r;
+ if (((dcomplex*)p3)->r==0 && ((dcomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=1; ((dcomplex*)p1)->i=0; } else
+ if (((dcomplex*)p2)->r==0 && ((dcomplex*)p2)->i==0 && ((dcomplex*)p3)->r>0 && ((dcomplex*)p3)->i==0)
+ { ((dcomplex*)p1)->r=0; ((dcomplex*)p1)->i=0; } else {
+ logC(&l, p2);
+ r.r = ((dcomplex*)p3)->r * l.r - ((dcomplex*)p3)->i * l.i;
+ r.i = ((dcomplex*)p3)->r * l.i + ((dcomplex*)p3)->i * l.r;
+ expC(p1, &r); }
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void PowOO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,na_id_power,1,*(VALUE*)p2);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_setfunc_t PowFuncs = {
+ { TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr },
+ { TpErr, PowBB, PowBI, PowBL, PowBF, PowBD, TpErr, TpErr, TpErr },
+ { TpErr, PowIB, PowII, PowIL, PowIF, PowID, TpErr, TpErr, TpErr },
+ { TpErr, PowLB, PowLI, PowLL, PowLF, PowLD, TpErr, TpErr, TpErr },
+ { TpErr, PowFB, PowFI, PowFL, PowFF, PowFD, TpErr, TpErr, TpErr },
+ { TpErr, PowDB, PowDI, PowDL, PowDF, PowDD, TpErr, TpErr, TpErr },
+ { TpErr, PowXB, PowXI, PowXL, PowXF, PowXD, PowXX, PowXC, TpErr },
+ { TpErr, PowCB, PowCI, PowCL, PowCF, PowCD, PowCX, PowCC, TpErr },
+ { TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, PowOO }
+};
+
+
+/* ------------------------- Execution -------------------------- */
+
+static void
+ na_exec_math(struct NARRAY *a1, struct NARRAY *a2, void (*func)())
+{
+ int i, s1, s2;
+ char *p1, *p2;
+
+ s1 = na_sizeof[a1->type];
+ s2 = na_sizeof[a2->type];
+ p1 = a1->ptr;
+ p2 = a2->ptr;
+ for (i=a1->total; i ; i--) {
+ (*func)( p1, p2 );
+ p1 += s1;
+ p2 += s2;
+ }
+}
+
+
+static VALUE
+ na_math_func(volatile VALUE self, na_mathfunc_t funcs)
+{
+ struct NARRAY *a1, *a2;
+ VALUE ans;
+
+ if (TYPE(self) == T_ARRAY) {
+ self = na_ary_to_nary(self,cNArray);
+ } else
+ if (!IsNArray(self)) {
+ self = na_make_scalar(self,na_object_type(self));
+ }
+
+ GetNArray(self,a2);
+ if (NA_IsINTEGER(a2)) {
+ self = na_upcast_type(self,NA_DFLOAT);
+ GetNArray(self,a2);
+ }
+ ans = na_make_object(a2->type, a2->rank, a2->shape, CLASS_OF(self));
+ GetNArray(ans,a1);
+
+ na_exec_math(a1, a2, funcs[a2->type]);
+
+ if (CLASS_OF(self) == cNArrayScalar)
+ SetFuncs[NA_ROBJ][a1->type](1,&ans,0,a1->ptr,0);
+
+ return ans;
+}
+
+/* ------------------------- Module Methods -------------------------- */
+
+static VALUE na_math_sqrt(VALUE obj, VALUE x)
+{ return na_math_func(x,sqrtFuncs); }
+
+static VALUE na_math_sin(VALUE obj, VALUE x)
+{ return na_math_func(x,sinFuncs); }
+
+static VALUE na_math_cos(VALUE obj, VALUE x)
+{ return na_math_func(x,cosFuncs); }
+
+static VALUE na_math_tan(VALUE obj, VALUE x)
+{ return na_math_func(x,tanFuncs); }
+
+static VALUE na_math_sinh(VALUE obj, VALUE x)
+{ return na_math_func(x,sinhFuncs); }
+
+static VALUE na_math_cosh(VALUE obj, VALUE x)
+{ return na_math_func(x,coshFuncs); }
+
+static VALUE na_math_tanh(VALUE obj, VALUE x)
+{ return na_math_func(x,tanhFuncs); }
+
+static VALUE na_math_exp(VALUE obj, VALUE x)
+{ return na_math_func(x,expFuncs); }
+
+static VALUE na_math_log(VALUE obj, VALUE x)
+{ return na_math_func(x,logFuncs); }
+
+static VALUE na_math_log10(VALUE obj, VALUE x)
+{ return na_math_func(x,log10Funcs); }
+
+static VALUE na_math_log2(VALUE obj, VALUE x)
+{ return na_math_func(x,log2Funcs); }
+
+static VALUE na_math_asin(VALUE obj, VALUE x)
+{ return na_math_func(x,asinFuncs); }
+
+static VALUE na_math_asinh(VALUE obj, VALUE x)
+{ return na_math_func(x,asinhFuncs); }
+
+static VALUE na_math_acos(VALUE obj, VALUE x)
+{ return na_math_func(x,acosFuncs); }
+
+static VALUE na_math_acosh(VALUE obj, VALUE x)
+{ return na_math_func(x,acoshFuncs); }
+
+static VALUE na_math_atan(VALUE obj, VALUE x)
+{ return na_math_func(x,atanFuncs); }
+
+static VALUE na_math_atanh(VALUE obj, VALUE x)
+{ return na_math_func(x,atanhFuncs); }
+
+
+/* Initialization of NMath module */
+void Init_nmath(void)
+{
+ /* define ExtMath module */
+ rb_mNMath = rb_define_module("NMath");
+
+ /* methods */
+ rb_define_module_function(rb_mNMath,"sqrt",na_math_sqrt,1);
+ rb_define_module_function(rb_mNMath,"sin",na_math_sin,1);
+ rb_define_module_function(rb_mNMath,"cos",na_math_cos,1);
+ rb_define_module_function(rb_mNMath,"tan",na_math_tan,1);
+ rb_define_module_function(rb_mNMath,"sinh",na_math_sinh,1);
+ rb_define_module_function(rb_mNMath,"cosh",na_math_cosh,1);
+ rb_define_module_function(rb_mNMath,"tanh",na_math_tanh,1);
+ rb_define_module_function(rb_mNMath,"exp",na_math_exp,1);
+ rb_define_module_function(rb_mNMath,"log",na_math_log,1);
+ rb_define_module_function(rb_mNMath,"log10",na_math_log10,1);
+ rb_define_module_function(rb_mNMath,"log2",na_math_log2,1);
+ rb_define_module_function(rb_mNMath,"asin",na_math_asin,1);
+ rb_define_module_function(rb_mNMath,"asinh",na_math_asinh,1);
+ rb_define_module_function(rb_mNMath,"acos",na_math_acos,1);
+ rb_define_module_function(rb_mNMath,"acosh",na_math_acosh,1);
+ rb_define_module_function(rb_mNMath,"atan",na_math_atan,1);
+ rb_define_module_function(rb_mNMath,"atanh",na_math_atanh,1);
+}
Added: packages/libnarray-ruby/trunk/na_op.c
===================================================================
--- packages/libnarray-ruby/trunk/na_op.c 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/na_op.c 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,2581 @@
+/*
+ na_op.c
+ Automatically generated code
+ Numerical Array Extention for Ruby
+ (C) Copyright 1999-2003 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 "narray.h"
+#include "narray_local.h"
+/* isalpha(3) etc. */
+#include <ctype.h>
+
+const int na_upcast[NA_NTYPES][NA_NTYPES] = {
+ {0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 3, 4, 5, 6, 7, 8},
+ {0, 2, 2, 3, 4, 5, 6, 7, 8},
+ {0, 3, 3, 3, 4, 5, 6, 7, 8},
+ {0, 4, 4, 4, 4, 5, 6, 7, 8},
+ {0, 5, 5, 5, 5, 5, 7, 7, 8},
+ {0, 6, 6, 6, 6, 7, 6, 7, 8},
+ {0, 7, 7, 7, 7, 7, 7, 7, 8},
+ {0, 8, 8, 8, 8, 8, 8, 8, 8} };
+
+const int na_no_cast[NA_NTYPES] =
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+const int na_cast_real[NA_NTYPES] =
+ { 0, 1, 2, 3, 4, 5, 4, 5, 8 };
+const int na_cast_comp[NA_NTYPES] =
+ { 0, 6, 6, 6, 6, 7, 6, 7, 8 };
+const int na_cast_round[NA_NTYPES] =
+ { 0, 1, 2, 3, 3, 3, 6, 7, 8 };
+const int na_cast_byte[NA_NTYPES] =
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1 };
+
+
+static void TpErr(void) {
+ rb_raise(rb_eTypeError,"illegal operation with this type");
+}
+static int TpErrI(void) {
+ rb_raise(rb_eTypeError,"illegal operation with this type");
+ return 0;
+}
+static void na_zerodiv() {
+ rb_raise(rb_eZeroDivError, "divided by 0");
+}
+
+static int notnanF(float *n)
+{
+ return *n == *n;
+}
+static int notnanD(double *n)
+{
+ return *n == *n;
+}
+
+/* ------------------------- Set --------------------------- */
+static void SetBB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetBO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = NUM2INT(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetII(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetID(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetIO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = NUM2INT(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetLO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = NUM2INT(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetFO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = NUM2DBL(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetDO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = NUM2DBL(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = *(u_int8_t*)p2; ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = *(int16_t*)p2; ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = *(int32_t*)p2; ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = *(float*)p2; ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = *(double*)p2; ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = ((scomplex*)p2)->r; ((scomplex*)p1)->i = ((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = ((dcomplex*)p2)->r; ((scomplex*)p1)->i = ((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetXO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = NUM2REAL(*(VALUE*)p2); ((scomplex*)p1)->i = NUM2IMAG(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = *(u_int8_t*)p2; ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = *(int16_t*)p2; ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = *(int32_t*)p2; ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = *(float*)p2; ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = *(double*)p2; ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = ((scomplex*)p2)->r; ((dcomplex*)p1)->i = ((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = ((dcomplex*)p2)->r; ((dcomplex*)p1)->i = ((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetCO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = NUM2REAL(*(VALUE*)p2); ((dcomplex*)p1)->i = NUM2IMAG(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = INT2FIX(*(u_int8_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = INT2FIX(*(int16_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = INT2NUM(*(int32_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_float_new(*(float*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_float_new(*(double*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_complex_new(((scomplex*)p2)->r,((scomplex*)p2)->i);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_complex_new(((dcomplex*)p2)->r,((dcomplex*)p2)->i);
+ p1+=i1; p2+=i2;
+ }
+}
+static void SetOO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = *(VALUE*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_setfunc_t SetFuncs = {
+ { TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, TpErr },
+ { TpErr, SetBB, SetBI, SetBL, SetBF, SetBD, SetBX, SetBC, SetBO },
+ { TpErr, SetIB, SetII, SetIL, SetIF, SetID, SetIX, SetIC, SetIO },
+ { TpErr, SetLB, SetLI, SetLL, SetLF, SetLD, SetLX, SetLC, SetLO },
+ { TpErr, SetFB, SetFI, SetFL, SetFF, SetFD, SetFX, SetFC, SetFO },
+ { TpErr, SetDB, SetDI, SetDL, SetDF, SetDD, SetDX, SetDC, SetDO },
+ { TpErr, SetXB, SetXI, SetXL, SetXF, SetXD, SetXX, SetXC, SetXO },
+ { TpErr, SetCB, SetCI, SetCL, SetCF, SetCD, SetCX, SetCC, SetCO },
+ { TpErr, SetOB, SetOI, SetOL, SetOF, SetOD, SetOX, SetOC, SetOO }
+};
+
+/* ------------------------- Swp --------------------------- */
+static void SwpB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size16_t x; swap16(x,*(na_size16_t*)p2); *(na_size16_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size32_t x; swap32(x,*(na_size32_t*)p2); *(na_size32_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size32_t x; swap32(x,*(na_size32_t*)p2); *(na_size32_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size64_t x; swap64(x,*(na_size64_t*)p2); *(na_size64_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size64_t x; swap64c(x,*(na_size64_t*)p2); *(na_size64_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ na_size128_t x; swap128c(x,*(na_size128_t*)p2); *(na_size128_t*)p1 = x;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SwpO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = *(VALUE*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t SwpFuncs =
+{ TpErr, SwpB, SwpI, SwpL, SwpF, SwpD, SwpX, SwpC, SwpO };
+
+/* ------------------------- H2N --------------------------- */
+#ifdef WORDS_BIGENDIAN
+
+na_func_t H2NFuncs =
+{ TpErr, SetBB, SetII, SetLL, SetFF, SetDD, SetXX, SetCC, SetOO };
+
+na_func_t H2VFuncs =
+{ TpErr, SetBB, SwpI, SwpL, SwpF, SwpD, SwpX, SwpC, SetOO };
+
+#else
+#ifdef DYNAMIC_ENDIAN /* not supported yet */
+#else /* LITTLE ENDIAN */
+
+na_func_t H2NFuncs =
+{ TpErr, SetBB, SwpI, SwpL, SwpF, SwpD, SwpX, SwpC, SetOO };
+
+na_func_t H2VFuncs =
+{ TpErr, SetBB, SetII, SetLL, SetFF, SetDD, SetXX, SetCC, SetOO };
+
+#endif
+#endif
+
+/* ------------------------- Neg --------------------------- */
+static void NegB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = -*(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = -*(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = -*(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = -*(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = -*(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = -((scomplex*)p2)->r;
+ ((scomplex*)p1)->i = -((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = -((dcomplex*)p2)->r;
+ ((dcomplex*)p1)->i = -((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NegO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,na_id_minus,0);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t NegFuncs =
+{ TpErr, NegB, NegI, NegL, NegF, NegD, NegX, NegC, NegO };
+
+/* ------------------------- AddU --------------------------- */
+static void AddUB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 += *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 += *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 += *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 += *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 += *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r += ((scomplex*)p2)->r;
+ ((scomplex*)p1)->i += ((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r += ((dcomplex*)p2)->r;
+ ((dcomplex*)p1)->i += ((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AddUO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'+',1,*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t AddUFuncs =
+{ TpErr, AddUB, AddUI, AddUL, AddUF, AddUD, AddUX, AddUC, AddUO };
+
+/* ------------------------- SbtU --------------------------- */
+static void SbtUB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 -= *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 -= *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 -= *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 -= *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 -= *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r -= ((scomplex*)p2)->r;
+ ((scomplex*)p1)->i -= ((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r -= ((dcomplex*)p2)->r;
+ ((dcomplex*)p1)->i -= ((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void SbtUO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'-',1,*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t SbtUFuncs =
+{ TpErr, SbtUB, SbtUI, SbtUL, SbtUF, SbtUD, SbtUX, SbtUC, SbtUO };
+
+/* ------------------------- MulU --------------------------- */
+static void MulUB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 *= *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 *= *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 *= *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 *= *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 *= *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p1;
+ ((scomplex*)p1)->r = x.r*((scomplex*)p2)->r - x.i*((scomplex*)p2)->i;
+ ((scomplex*)p1)->i = x.r*((scomplex*)p2)->i + x.i*((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p1;
+ ((dcomplex*)p1)->r = x.r*((dcomplex*)p2)->r - x.i*((dcomplex*)p2)->i;
+ ((dcomplex*)p1)->i = x.r*((dcomplex*)p2)->i + x.i*((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MulUO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'*',1,*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t MulUFuncs =
+{ TpErr, MulUB, MulUI, MulUL, MulUF, MulUD, MulUX, MulUC, MulUO };
+
+/* ------------------------- DivU --------------------------- */
+static void DivUB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p2==0) {na_zerodiv();}
+ *(u_int8_t*)p1 /= *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int16_t*)p2==0) {na_zerodiv();}
+ *(int16_t*)p1 /= *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int32_t*)p2==0) {na_zerodiv();}
+ *(int32_t*)p1 /= *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 /= *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 /= *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p1;
+ float a = ((scomplex*)p2)->r*((scomplex*)p2)->r + ((scomplex*)p2)->i*((scomplex*)p2)->i;
+ ((scomplex*)p1)->r = (x.r*((scomplex*)p2)->r + x.i*((scomplex*)p2)->i)/a;
+ ((scomplex*)p1)->i = (x.i*((scomplex*)p2)->r - x.r*((scomplex*)p2)->i)/a;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p1;
+ double a = ((dcomplex*)p2)->r*((dcomplex*)p2)->r + ((dcomplex*)p2)->i*((dcomplex*)p2)->i;
+ ((dcomplex*)p1)->r = (x.r*((dcomplex*)p2)->r + x.i*((dcomplex*)p2)->i)/a;
+ ((dcomplex*)p1)->i = (x.i*((dcomplex*)p2)->r - x.r*((dcomplex*)p2)->i)/a;
+ p1+=i1; p2+=i2;
+ }
+}
+static void DivUO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'/',1,*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t DivUFuncs =
+{ TpErr, DivUB, DivUI, DivUL, DivUF, DivUD, DivUX, DivUC, DivUO };
+
+/* ------------------------- ImgSet --------------------------- */
+static void ImgSetX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->i = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImgSetC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->i = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t ImgSetFuncs =
+{ TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, ImgSetX, ImgSetC, TpErr };
+
+/* ------------------------- Floor --------------------------- */
+static void FloorF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = floor(*(float*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void FloorD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = floor(*(double*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t FloorFuncs =
+{ TpErr, SetBB, SetII, SetLL, FloorF, FloorD, TpErr, TpErr, TpErr };
+
+/* ------------------------- Ceil --------------------------- */
+static void CeilF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = ceil(*(float*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void CeilD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = ceil(*(double*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t CeilFuncs =
+{ TpErr, SetBB, SetII, SetLL, CeilF, CeilD, TpErr, TpErr, TpErr };
+
+/* ------------------------- Round --------------------------- */
+static void RoundF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(float*)p2 >= 0) *(int32_t*)p1 = floor(*(float*)p2+0.5);
+ else *(int32_t*)p1 = ceil(*(float*)p2-0.5);
+ p1+=i1; p2+=i2;
+ }
+}
+static void RoundD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(double*)p2 >= 0) *(int32_t*)p1 = floor(*(double*)p2+0.5);
+ else *(int32_t*)p1 = ceil(*(double*)p2-0.5);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t RoundFuncs =
+{ TpErr, SetBB, SetII, SetLL, RoundF, RoundD, TpErr, TpErr, TpErr };
+
+/* ------------------------- Abs --------------------------- */
+static void AbsB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = (*(int16_t*)p2<0) ? -*(int16_t*)p2 : *(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = (*(int32_t*)p2<0) ? -*(int32_t*)p2 : *(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = (*(float*)p2<0) ? -*(float*)p2 : *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = (*(double*)p2<0) ? -*(double*)p2 : *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = hypot(((scomplex*)p2)->r, ((scomplex*)p2)->i);
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = hypot(((dcomplex*)p2)->r, ((dcomplex*)p2)->i);
+ p1+=i1; p2+=i2;
+ }
+}
+static void AbsO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,na_id_abs,0);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t AbsFuncs =
+{ TpErr, AbsB, AbsI, AbsL, AbsF, AbsD, AbsX, AbsC, AbsO };
+
+/* ------------------------- Real --------------------------- */
+
+na_func_t RealFuncs =
+{ TpErr, SetBB, SetII, SetLL, SetFF, SetDD, SetFX, SetDC, TpErr };
+
+/* ------------------------- Imag --------------------------- */
+static void ImagB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = ((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = ((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t ImagFuncs =
+{ TpErr, ImagB, ImagI, ImagL, ImagF, ImagD, ImagX, ImagC, TpErr };
+
+/* ------------------------- Angl --------------------------- */
+static void AnglX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = atan2(((scomplex*)p2)->i,((scomplex*)p2)->r);
+ p1+=i1; p2+=i2;
+ }
+}
+static void AnglC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = atan2(((dcomplex*)p2)->i,((dcomplex*)p2)->r);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t AnglFuncs =
+{ TpErr, TpErr, TpErr, TpErr, TpErr, TpErr, AnglX, AnglC, TpErr };
+
+/* ------------------------- ImagMul --------------------------- */
+static void ImagMulF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = 0; ((scomplex*)p1)->i = *(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagMulD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = 0; ((dcomplex*)p1)->i = *(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagMulX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = -((scomplex*)p2)->i; ((scomplex*)p1)->i = ((scomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ImagMulC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = -((dcomplex*)p2)->i; ((dcomplex*)p1)->i = ((dcomplex*)p2)->r;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t ImagMulFuncs =
+{ TpErr, TpErr, TpErr, TpErr, ImagMulF, ImagMulD, ImagMulX, ImagMulC, TpErr };
+
+/* ------------------------- Conj --------------------------- */
+static void ConjX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = ((scomplex*)p2)->r; ((scomplex*)p1)->i = -((scomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+static void ConjC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = ((dcomplex*)p2)->r; ((dcomplex*)p1)->i = -((dcomplex*)p2)->i;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t ConjFuncs =
+{ TpErr, SetBB, SetII, SetLL, SetFF, SetDD, ConjX, ConjC, TpErr };
+
+/* ------------------------- Not --------------------------- */
+static void NotB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(u_int8_t*)p2==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int16_t*)p2==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int32_t*)p2==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(float*)p2==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(double*)p2==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotX(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (((scomplex*)p2)->r==0 && ((scomplex*)p2)->i==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotC(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (((dcomplex*)p2)->r==0 && ((dcomplex*)p2)->i==0) ? 1:0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void NotO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = RTEST(*(VALUE*)p2) ? 0:1;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t NotFuncs =
+{ TpErr, NotB, NotI, NotL, NotF, NotD, NotX, NotC, NotO };
+
+/* ------------------------- BRv --------------------------- */
+static void BRvB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ~(*(u_int8_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void BRvI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = ~(*(int16_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void BRvL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = ~(*(int32_t*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+static void BRvO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'~',0);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t BRvFuncs =
+{ TpErr, BRvB, BRvI, BRvL, TpErr, TpErr, TpErr, TpErr, BRvO };
+
+/* ------------------------- Min --------------------------- */
+static void MinB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p1>*(u_int8_t*)p2) *(u_int8_t*)p1=*(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MinI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int16_t*)p1>*(int16_t*)p2) *(int16_t*)p1=*(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MinL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int32_t*)p1>*(int32_t*)p2) *(int32_t*)p1=*(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MinF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (notnanF((float*)p2) && *(float*)p1>*(float*)p2) *(float*)p1=*(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MinD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (notnanD((double*)p2) && *(double*)p1>*(double*)p2) *(double*)p1=*(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MinO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (FIX2INT(rb_funcall(*(VALUE*)p1,na_id_compare,1,*(VALUE*)p2))>0) *(VALUE*)p1=*(VALUE*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t MinFuncs =
+{ TpErr, MinB, MinI, MinL, MinF, MinD, TpErr, TpErr, MinO };
+
+/* ------------------------- Max --------------------------- */
+static void MaxB(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p1<*(u_int8_t*)p2) *(u_int8_t*)p1=*(u_int8_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MaxI(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int16_t*)p1<*(int16_t*)p2) *(int16_t*)p1=*(int16_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MaxL(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (*(int32_t*)p1<*(int32_t*)p2) *(int32_t*)p1=*(int32_t*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MaxF(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (notnanF((float*)p2) && *(float*)p1<*(float*)p2) *(float*)p1=*(float*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MaxD(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (notnanD((double*)p2) && *(double*)p1<*(double*)p2) *(double*)p1=*(double*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void MaxO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ if (FIX2INT(rb_funcall(*(VALUE*)p1,na_id_compare,1,*(VALUE*)p2))<0) *(VALUE*)p1=*(VALUE*)p2;
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t MaxFuncs =
+{ TpErr, MaxB, MaxI, MaxL, MaxF, MaxD, TpErr, TpErr, MaxO };
+
+/* ------------------------- Sort --------------------------- */
+static int SortB(void *p1, void *p2)
+{ if (*(u_int8_t*)p1 > *(u_int8_t*)p2) return 1;
+ if (*(u_int8_t*)p1 < *(u_int8_t*)p2) return -1;
+ return 0; }
+static int SortI(void *p1, void *p2)
+{ if (*(int16_t*)p1 > *(int16_t*)p2) return 1;
+ if (*(int16_t*)p1 < *(int16_t*)p2) return -1;
+ return 0; }
+static int SortL(void *p1, void *p2)
+{ if (*(int32_t*)p1 > *(int32_t*)p2) return 1;
+ if (*(int32_t*)p1 < *(int32_t*)p2) return -1;
+ return 0; }
+static int SortF(void *p1, void *p2)
+{ if (*(float*)p1 > *(float*)p2) return 1;
+ if (*(float*)p1 < *(float*)p2) return -1;
+ return 0; }
+static int SortD(void *p1, void *p2)
+{ if (*(double*)p1 > *(double*)p2) return 1;
+ if (*(double*)p1 < *(double*)p2) return -1;
+ return 0; }
+static int SortO(void *p1, void *p2)
+{ VALUE r = rb_funcall(*(VALUE*)p1, na_id_compare, 1, *(VALUE*)p2);
+ return NUM2INT(r); }
+
+na_sortfunc_t SortFuncs =
+{ TpErrI, SortB, SortI, SortL, SortF, SortD, TpErrI, TpErrI, SortO };
+
+/* ------------------------- SortIdx --------------------------- */
+static int SortIdxB(void *p1, void *p2)
+{ if (**(u_int8_t**)p1 > **(u_int8_t**)p2) return 1;
+ if (**(u_int8_t**)p1 < **(u_int8_t**)p2) return -1;
+ return 0; }
+static int SortIdxI(void *p1, void *p2)
+{ if (**(int16_t**)p1 > **(int16_t**)p2) return 1;
+ if (**(int16_t**)p1 < **(int16_t**)p2) return -1;
+ return 0; }
+static int SortIdxL(void *p1, void *p2)
+{ if (**(int32_t**)p1 > **(int32_t**)p2) return 1;
+ if (**(int32_t**)p1 < **(int32_t**)p2) return -1;
+ return 0; }
+static int SortIdxF(void *p1, void *p2)
+{ if (**(float**)p1 > **(float**)p2) return 1;
+ if (**(float**)p1 < **(float**)p2) return -1;
+ return 0; }
+static int SortIdxD(void *p1, void *p2)
+{ if (**(double**)p1 > **(double**)p2) return 1;
+ if (**(double**)p1 < **(double**)p2) return -1;
+ return 0; }
+static int SortIdxO(void *p1, void *p2)
+{ VALUE r = rb_funcall(**(VALUE**)p1, na_id_compare, 1, **(VALUE**)p2);
+ return NUM2INT(r); }
+
+na_sortfunc_t SortIdxFuncs =
+{ TpErrI, SortIdxB, SortIdxI, SortIdxL, SortIdxF, SortIdxD, TpErrI, TpErrI, SortIdxO };
+
+/* ------------------------- IndGen --------------------------- */
+static void IndGenB(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenI(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenL(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenF(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(float*)p1 = p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenD(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(double*)p1 = p2;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenX(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = p2;
+ ((scomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenC(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = p2;
+ ((dcomplex*)p1)->i = 0;
+ p1+=i1; p2+=i2;
+ }
+}
+static void IndGenO(int n, char *p1, int i1, int p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = INT2FIX(p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t IndGenFuncs =
+{ TpErr, IndGenB, IndGenI, IndGenL, IndGenF, IndGenD, IndGenX, IndGenC, IndGenO };
+
+/* ------------------------- ToStr --------------------------- */
+static void ToStrB(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[22];
+ for (; n; n--) {
+ sprintf(buf,"%i",(int)*(u_int8_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrI(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[22];
+ for (; n; n--) {
+ sprintf(buf,"%i",(int)*(int16_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrL(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[22];
+ for (; n; n--) {
+ sprintf(buf,"%i",(int)*(int32_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrF(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[24];
+ for (; n; n--) {
+ sprintf(buf,"%.5g",(double)*(float*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrD(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[24];
+ for (; n; n--) {
+ sprintf(buf,"%.8g",(double)*(double*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrX(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[50];
+ for (; n; n--) {
+ sprintf(buf,"%.5g%+.5gi",(double)((scomplex*)p2)->r,(double)((scomplex*)p2)->i);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrC(int n, char *p1, int i1, char *p2, int i2)
+{
+ char buf[50];
+ for (; n; n--) {
+ sprintf(buf,"%.8g%+.8gi",(double)((dcomplex*)p2)->r,(double)((dcomplex*)p2)->i);
+ *(VALUE*)p1 = rb_str_new2(buf);
+ p1+=i1; p2+=i2;
+ }
+}
+static void ToStrO(int n, char *p1, int i1, char *p2, int i2)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_obj_as_string(*(VALUE*)p2);
+ p1+=i1; p2+=i2;
+ }
+}
+
+na_func_t ToStrFuncs =
+{ TpErr, ToStrB, ToStrI, ToStrL, ToStrF, ToStrD, ToStrX, ToStrC, ToStrO };
+
+/* from numeric.c */
+static void na_str_append_fp(char *buf)
+{
+ if (buf[0]=='-' || buf[0]=='+') buf++;
+ if (ISALPHA(buf[0])) return; /* NaN or Inf */
+ if (strchr(buf, '.') == 0) {
+ int len = strlen(buf);
+ char *ind = strchr(buf, 'e');
+ if (ind) {
+ memmove(ind+2, ind, len-(ind-buf)+1);
+ ind[0] = '.';
+ ind[1] = '0';
+ } else {
+ strcat(buf, ".0");
+ }
+ }
+}
+
+/* ------------------------- Insp --------------------------- */
+static void InspB(char *p1, char *p2)
+{
+ char buf[22];
+ sprintf(buf,"%i",(int)*(u_int8_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspI(char *p1, char *p2)
+{
+ char buf[22];
+ sprintf(buf,"%i",(int)*(int16_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspL(char *p1, char *p2)
+{
+ char buf[22];
+ sprintf(buf,"%i",(int)*(int32_t*)p2);
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspF(char *p1, char *p2)
+{
+ char buf[24];
+ sprintf(buf,"%.4g",(double)*(float*)p2);
+ na_str_append_fp(buf);
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspD(char *p1, char *p2)
+{
+ char buf[24];
+ sprintf(buf,"%.6g",(double)*(double*)p2);
+ na_str_append_fp(buf);
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspX(char *p1, char *p2)
+{
+ char buf[50], *b;
+ sprintf(buf,"%.4g",(double)((scomplex*)p2)->r);
+ na_str_append_fp(buf);
+ b = buf+strlen(buf);
+ sprintf(b,"%+.4gi",(double)((scomplex*)p2)->i);
+ na_str_append_fp(b);
+ strcat(buf,"i");
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspC(char *p1, char *p2)
+{
+ char buf[50], *b;
+ sprintf(buf,"%.6g",(double)((dcomplex*)p2)->r);
+ na_str_append_fp(buf);
+ b = buf+strlen(buf);
+ sprintf(b,"%+.6g",(double)((dcomplex*)p2)->i);
+ na_str_append_fp(b);
+ strcat(buf,"i");
+ *(VALUE*)p1 = rb_str_new2(buf);
+}
+static void InspO(char *p1, char *p2)
+{
+ *(VALUE*)p1 = rb_inspect(*(VALUE*)p2);
+}
+
+na_func_t InspFuncs =
+{ TpErr, InspB, InspI, InspL, InspF, InspD, InspX, InspC, InspO };
+
+/* ------------------------- AddB --------------------------- */
+static void AddBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 + *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 + *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 + *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(float*)p2 + *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(double*)p2 + *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = ((scomplex*)p2)->r + ((scomplex*)p3)->r;
+ ((scomplex*)p1)->i = ((scomplex*)p2)->i + ((scomplex*)p3)->i;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = ((dcomplex*)p2)->r + ((dcomplex*)p3)->r;
+ ((dcomplex*)p1)->i = ((dcomplex*)p2)->i + ((dcomplex*)p3)->i;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AddBO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'+',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t AddBFuncs =
+{ TpErr, AddBB, AddBI, AddBL, AddBF, AddBD, AddBX, AddBC, AddBO };
+
+/* ------------------------- SbtB --------------------------- */
+static void SbtBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 - *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 - *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 - *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(float*)p2 - *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(double*)p2 - *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ ((scomplex*)p1)->r = ((scomplex*)p2)->r - ((scomplex*)p3)->r;
+ ((scomplex*)p1)->i = ((scomplex*)p2)->i - ((scomplex*)p3)->i;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ ((dcomplex*)p1)->r = ((dcomplex*)p2)->r - ((dcomplex*)p3)->r;
+ ((dcomplex*)p1)->i = ((dcomplex*)p2)->i - ((dcomplex*)p3)->i;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void SbtBO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'-',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t SbtBFuncs =
+{ TpErr, SbtBB, SbtBI, SbtBL, SbtBF, SbtBD, SbtBX, SbtBC, SbtBO };
+
+/* ------------------------- MulB --------------------------- */
+static void MulBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 * *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 * *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 * *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(float*)p2 * *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(double*)p2 * *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p2;
+ ((scomplex*)p1)->r = x.r*((scomplex*)p3)->r - x.i*((scomplex*)p3)->i;
+ ((scomplex*)p1)->i = x.r*((scomplex*)p3)->i + x.i*((scomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p2;
+ ((dcomplex*)p1)->r = x.r*((dcomplex*)p3)->r - x.i*((dcomplex*)p3)->i;
+ ((dcomplex*)p1)->i = x.r*((dcomplex*)p3)->i + x.i*((dcomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulBO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'*',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t MulBFuncs =
+{ TpErr, MulBB, MulBI, MulBL, MulBF, MulBD, MulBX, MulBC, MulBO };
+
+/* ------------------------- DivB --------------------------- */
+static void DivBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3==0) {na_zerodiv();};
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 / *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(int16_t*)p3==0) {na_zerodiv();};
+ *(int16_t*)p1 = *(int16_t*)p2 / *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(int32_t*)p3==0) {na_zerodiv();};
+ *(int32_t*)p1 = *(int32_t*)p2 / *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = *(float*)p2 / *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = *(double*)p2 / *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p2;
+ float a = ((scomplex*)p3)->r*((scomplex*)p3)->r + ((scomplex*)p3)->i*((scomplex*)p3)->i;
+ ((scomplex*)p1)->r = (x.r*((scomplex*)p3)->r + x.i*((scomplex*)p3)->i)/a;
+ ((scomplex*)p1)->i = (x.i*((scomplex*)p3)->r - x.r*((scomplex*)p3)->i)/a;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p2;
+ double a = ((dcomplex*)p3)->r*((dcomplex*)p3)->r + ((dcomplex*)p3)->i*((dcomplex*)p3)->i;
+ ((dcomplex*)p1)->r = (x.r*((dcomplex*)p3)->r + x.i*((dcomplex*)p3)->i)/a;
+ ((dcomplex*)p1)->i = (x.i*((dcomplex*)p3)->r - x.r*((dcomplex*)p3)->i)/a;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void DivBO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'/',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t DivBFuncs =
+{ TpErr, DivBB, DivBI, DivBL, DivBF, DivBD, DivBX, DivBC, DivBO };
+
+/* ------------------------- ModB --------------------------- */
+static void ModBB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 % *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void ModBI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 % *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void ModBL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 % *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void ModBF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = fmod(*(float*)p2, *(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void ModBD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = fmod(*(double*)p2, *(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void ModBO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'%',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t ModBFuncs =
+{ TpErr, ModBB, ModBI, ModBL, ModBF, ModBD, TpErr, TpErr, ModBO };
+
+/* ------------------------- MulAdd --------------------------- */
+static void MulAddB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 += *(u_int8_t*)p2 * *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 += *(int16_t*)p2 * *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 += *(int32_t*)p2 * *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 += *(float*)p2 * *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 += *(double*)p2 * *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p2;
+ ((scomplex*)p1)->r += x.r*((scomplex*)p3)->r - x.i*((scomplex*)p3)->i;
+ ((scomplex*)p1)->i += x.r*((scomplex*)p3)->i + x.i*((scomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p2;
+ ((dcomplex*)p1)->r += x.r*((dcomplex*)p3)->r - x.i*((dcomplex*)p3)->i;
+ ((dcomplex*)p1)->i += x.r*((dcomplex*)p3)->i + x.i*((dcomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulAddO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'+',1,
+ rb_funcall(*(VALUE*)p2,'*',1,*(VALUE*)p3));
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t MulAddFuncs =
+{ TpErr, MulAddB, MulAddI, MulAddL, MulAddF, MulAddD, MulAddX, MulAddC, MulAddO };
+
+/* ------------------------- MulSbt --------------------------- */
+static void MulSbtB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 -= *(u_int8_t*)p2 * *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 -= *(int16_t*)p2 * *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 -= *(int32_t*)p2 * *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 -= *(float*)p2 * *(float*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 -= *(double*)p2 * *(double*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ scomplex x = *(scomplex*)p2;
+ ((scomplex*)p1)->r -= x.r*((scomplex*)p3)->r - x.i*((scomplex*)p3)->i;
+ ((scomplex*)p1)->i -= x.r*((scomplex*)p3)->i + x.i*((scomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ dcomplex x = *(dcomplex*)p2;
+ ((dcomplex*)p1)->r -= x.r*((dcomplex*)p3)->r - x.i*((dcomplex*)p3)->i;
+ ((dcomplex*)p1)->i -= x.r*((dcomplex*)p3)->i + x.i*((dcomplex*)p3)->r;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void MulSbtO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p1,'-',1,
+ rb_funcall(*(VALUE*)p2,'*',1,*(VALUE*)p3));
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t MulSbtFuncs =
+{ TpErr, MulSbtB, MulSbtI, MulSbtL, MulSbtF, MulSbtD, MulSbtX, MulSbtC, MulSbtO };
+
+/* ------------------------- BAn --------------------------- */
+static void BAnB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 & *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BAnI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 & *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BAnL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 & *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BAnO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'&',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t BAnFuncs =
+{ TpErr, BAnB, BAnI, BAnL, TpErr, TpErr, TpErr, TpErr, BAnO };
+
+/* ------------------------- BOr --------------------------- */
+static void BOrB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 | *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BOrI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 | *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BOrL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 | *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BOrO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'|',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t BOrFuncs =
+{ TpErr, BOrB, BOrI, BOrL, TpErr, TpErr, TpErr, TpErr, BOrO };
+
+/* ------------------------- BXo --------------------------- */
+static void BXoB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = *(u_int8_t*)p2 ^ *(u_int8_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BXoI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int16_t*)p1 = *(int16_t*)p2 ^ *(int16_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BXoL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(int32_t*)p1 = *(int32_t*)p2 ^ *(int32_t*)p3;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void BXoO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(VALUE*)p1 = rb_funcall(*(VALUE*)p2,'^',1,*(VALUE*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t BXoFuncs =
+{ TpErr, BXoB, BXoI, BXoL, TpErr, TpErr, TpErr, TpErr, BXoO };
+
+/* ------------------------- Cmp --------------------------- */
+static void CmpB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p2>*(u_int8_t*)p3) *(u_int8_t*)p1=1;
+ else if (*(u_int8_t*)p2<*(u_int8_t*)p3) *(u_int8_t*)p1=2;
+ else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void CmpI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(int16_t*)p2>*(int16_t*)p3) *(u_int8_t*)p1=1;
+ else if (*(int16_t*)p2<*(int16_t*)p3) *(u_int8_t*)p1=2;
+ else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void CmpL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(int32_t*)p2>*(int32_t*)p3) *(u_int8_t*)p1=1;
+ else if (*(int32_t*)p2<*(int32_t*)p3) *(u_int8_t*)p1=2;
+ else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void CmpF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(float*)p2>*(float*)p3) *(u_int8_t*)p1=1;
+ else if (*(float*)p2<*(float*)p3) *(u_int8_t*)p1=2;
+ else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void CmpD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(double*)p2>*(double*)p3) *(u_int8_t*)p1=1;
+ else if (*(double*)p2<*(double*)p3) *(u_int8_t*)p1=2;
+ else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void CmpO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ int v = NUM2INT(rb_funcall(*(VALUE*)p2,na_id_compare,1,*(VALUE*)p3));
+ if (v>0) *(u_int8_t*)p1=1; else if (v<0) *(u_int8_t*)p1=2; else *(u_int8_t*)p1=0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t CmpFuncs =
+{ TpErr, CmpB, CmpI, CmpL, CmpF, CmpD, TpErr, TpErr, CmpO };
+
+/* ------------------------- And --------------------------- */
+static void AndB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(u_int8_t*)p2!=0 && *(u_int8_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int16_t*)p2!=0 && *(int16_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int32_t*)p2!=0 && *(int32_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(float*)p2!=0 && *(float*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(double*)p2!=0 && *(double*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((scomplex*)p2)->r!=0||((scomplex*)p2)->i!=0) && (((scomplex*)p3)->r!=0||((scomplex*)p3)->i!=0)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((dcomplex*)p2)->r!=0||((dcomplex*)p2)->i!=0) && (((dcomplex*)p3)->r!=0||((dcomplex*)p3)->i!=0)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void AndO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (RTEST(*(VALUE*)p2) && RTEST(*(VALUE*)p3)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t AndFuncs =
+{ TpErr, AndB, AndI, AndL, AndF, AndD, AndX, AndC, AndO };
+
+/* ------------------------- Or_ --------------------------- */
+static void Or_B(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(u_int8_t*)p2!=0 || *(u_int8_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_I(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int16_t*)p2!=0 || *(int16_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_L(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(int32_t*)p2!=0 || *(int32_t*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_F(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(float*)p2!=0 || *(float*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_D(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (*(double*)p2!=0 || *(double*)p3!=0) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_X(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((scomplex*)p2)->r!=0||((scomplex*)p2)->i!=0) || (((scomplex*)p3)->r!=0||((scomplex*)p3)->i!=0)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_C(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((dcomplex*)p2)->r!=0||((dcomplex*)p2)->i!=0) || (((dcomplex*)p3)->r!=0||((dcomplex*)p3)->i!=0)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void Or_O(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (RTEST(*(VALUE*)p2) || RTEST(*(VALUE*)p3)) ? 1:0;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t Or_Funcs =
+{ TpErr, Or_B, Or_I, Or_L, Or_F, Or_D, Or_X, Or_C, Or_O };
+
+/* ------------------------- Xor --------------------------- */
+static void XorB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((*(u_int8_t*)p2!=0) == (*(u_int8_t*)p3!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((*(int16_t*)p2!=0) == (*(int16_t*)p3!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((*(int32_t*)p2!=0) == (*(int32_t*)p3!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((*(float*)p2!=0) == (*(float*)p3!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((*(double*)p2!=0) == (*(double*)p3!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((scomplex*)p2)->r!=0||((scomplex*)p2)->i!=0) == (((scomplex*)p3)->r!=0||((scomplex*)p3)->i!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = ((((dcomplex*)p2)->r!=0||((dcomplex*)p2)->i!=0) == (((dcomplex*)p3)->r!=0||((dcomplex*)p3)->i!=0)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void XorO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(u_int8_t*)p1 = (RTEST(*(VALUE*)p2) == RTEST(*(VALUE*)p3)) ? 0:1;
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t XorFuncs =
+{ TpErr, XorB, XorI, XorL, XorF, XorD, XorX, XorC, XorO };
+
+/* ------------------------- atan2 --------------------------- */
+static void atan2F(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(float*)p1 = atan2(*(float*)p2, *(float*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+static void atan2D(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ *(double*)p1 = atan2(*(double*)p2, *(double*)p3);
+ p1+=i1; p2+=i2; p3+=i3;
+ }
+}
+
+na_func_t atan2Funcs =
+{ TpErr, TpErr, TpErr, TpErr, atan2F, atan2D, TpErr, TpErr, TpErr };
+
+/* ------------------------- RefMask --------------------------- */
+static void RefMaskB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(u_int8_t*)p1=*(u_int8_t*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(int16_t*)p1=*(int16_t*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(int32_t*)p1=*(int32_t*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(float*)p1=*(float*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(double*)p1=*(double*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(scomplex*)p1=*(scomplex*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(dcomplex*)p1=*(dcomplex*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+static void RefMaskO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(VALUE*)p1=*(VALUE*)p2; p1+=i1; }
+ p3+=i3; p2+=i2;
+ }
+}
+
+na_func_t RefMaskFuncs =
+{ TpErr, RefMaskB, RefMaskI, RefMaskL, RefMaskF, RefMaskD, RefMaskX, RefMaskC, RefMaskO };
+
+/* ------------------------- SetMask --------------------------- */
+static void SetMaskB(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(u_int8_t*)p1=*(u_int8_t*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskI(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(int16_t*)p1=*(int16_t*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskL(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(int32_t*)p1=*(int32_t*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskF(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(float*)p1=*(float*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskD(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(double*)p1=*(double*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskX(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(scomplex*)p1=*(scomplex*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(dcomplex*)p1=*(dcomplex*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+static void SetMaskO(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+ for (; n; n--) {
+ if (*(u_int8_t*)p3) { *(VALUE*)p1=*(VALUE*)p2; p2+=i2; }
+ p3+=i3; p1+=i1;
+ }
+}
+
+na_func_t SetMaskFuncs =
+{ TpErr, SetMaskB, SetMaskI, SetMaskL, SetMaskF, SetMaskD, SetMaskX, SetMaskC, SetMaskO };
Added: packages/libnarray-ruby/trunk/narray_config.h
===================================================================
--- packages/libnarray-ruby/trunk/narray_config.h 2006-06-03 13:40:37 UTC (rev 571)
+++ packages/libnarray-ruby/trunk/narray_config.h 2006-06-03 13:41:32 UTC (rev 572)
@@ -0,0 +1,5 @@
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_U_INT8_T 1
+#define HAVE_INT16_T 1
+#define HAVE_INT32_T 1
+#define HAVE_U_INT32_T 1
More information about the pkg-ruby-extras-maintainers
mailing list