[Pkg-ruby-extras-maintainers] r575 - packages/libnarray-ruby/trunk

Daigo Moriwaki daigo-guest at costa.debian.org
Sat Jun 3 13:46:49 UTC 2006


Author: daigo-guest
Date: 2006-06-03 13:46:48 +0000 (Sat, 03 Jun 2006)
New Revision: 575

Removed:
   packages/libnarray-ruby/trunk/na_math.c
   packages/libnarray-ruby/trunk/na_op.c
   packages/libnarray-ruby/trunk/narray_config.h
Log:
Remove files that are automatically generated.

Deleted: packages/libnarray-ruby/trunk/na_math.c
===================================================================
--- packages/libnarray-ruby/trunk/na_math.c	2006-06-03 13:44:05 UTC (rev 574)
+++ packages/libnarray-ruby/trunk/na_math.c	2006-06-03 13:46:48 UTC (rev 575)
@@ -1,1204 +0,0 @@
-/*
-  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);
-}

Deleted: packages/libnarray-ruby/trunk/na_op.c
===================================================================
--- packages/libnarray-ruby/trunk/na_op.c	2006-06-03 13:44:05 UTC (rev 574)
+++ packages/libnarray-ruby/trunk/na_op.c	2006-06-03 13:46:48 UTC (rev 575)
@@ -1,2581 +0,0 @@
-/*
-  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 };

Deleted: packages/libnarray-ruby/trunk/narray_config.h
===================================================================
--- packages/libnarray-ruby/trunk/narray_config.h	2006-06-03 13:44:05 UTC (rev 574)
+++ packages/libnarray-ruby/trunk/narray_config.h	2006-06-03 13:46:48 UTC (rev 575)
@@ -1,5 +0,0 @@
-#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