narray-bigmem 0.0.0

data/SPEC.ja

@@ -0,0 +1,307 @@
+
+	Ruby/NArray  ver 0.6.0.7 (2013-02-01)	by Masahiro TANAKA
+
+
+クラスメソッド:
+    NArray.new(typecode, size, ...)	配列を生成する。要素は0で初期化。
+
+    NArray.byte(size,...)		1 byte unsigned integer
+    NArray.sint(size,...)		2 byte signed integer
+    NArray.int(size,...)		4 byte signed integer
+    NArray.sfloat(size,...)		single precision float
+    NArray.float(size,...)		double precision float
+    NArray.scomplex(size,...)		single precision complex
+    NArray.complex(size,...)		double precision complex
+    NArray.object(size,...)		Ruby object
+					以上要素は0またはnilで初期化。
+
+    NArray.to_na(array)			NArrayに変換
+    NArray.to_na(string,type[,size,..])
+    NArray[...]
+      NArray[1,5,10.0]  #=>  NArray.float(3):[1.0, 5.0, 10.0]
+      NArray[1..10]     #=>  NArray.int(10):[1,2,3,4,5,6,7,8,9,10]
+
+
+クラス変数:
+    CLASS_DIMENSION	データとして扱われる次元。
+			NArrayは0。NVectorは1。NMatrixは2。
+
+配列情報参照
+    self.dim	    次元(インデックスの数)を返す。
+    self.rank	    次元(インデックスの数)を返す。
+    self.shape	    次元ごとのサイズを返す。
+    self.total	    全要素数を返す。
+
+インデックス参照
+    self[ dim0, dim1, ... ]
+
+  -- インデックス引数に指定できるもの:  数値、範囲、配列、true, false
+  -- インデックスの順序:		FORTRAN 型
+  -- 添字引数が1つの場合、多次元配列はflattenされた1次元配列とみなされる。
+     例: a が 3x3 配列のとき、a[3] は a[0,1] の要素を指す。
+
+    a[ 1, 2, -1 ]	要素の取り出し。負数は最後から数える(-1が最後)
+			要素指定の次元は縮約される。
+    a[ 0..3, 4..1 ]	範囲取り出し。範囲の最後が最初より前ならば逆順になる。
+    a[ [1,4,2] ]	インデックス配列。要素が[a[1],a[4],a[2]]のNArrayが返る。
+    a[]			a.dup と同じ。
+    a[ 0, true ]	a[0, 0..-1] と同じ。
+    a[ 0, false ]	aが3次元のとき、a[0,true,true] と同じ。
+			省略された次元すべてにtrueを指定したのと同じ。
+    a[ mask ]		マスキング. mask は長さが a と等しい byte 型
+			NArray. mask の各要素の値に応じて、a のそれぞ
+			れは落される(0の場合)か、保持される(0以外の場合)。
+			例:
+				a=NArray.float(2,2).indgen!
+				p a[ a.lt 3 ]
+				--> [ 0.0, 1.0, 2.0 ]
+				(a.lt 3 は byte 型 NArray を返す)
+				(同じことは a[ (a.lt 3).where ] でも出来る)
+
+  -- self.slice(...)	self[...] と同じだが、長さが１になった次元を落
+			さず(self[]は落す)、もとのランクを保つ。但し、
+			1次元インデックス付けとマスキングは例外([]と同
+			じ)。
+
+インデックス代入。-- 取出しとほぼ同じルール。
+
+    a[ 1, 2, 3 ] = 1
+    a[ 0..3, 1..4, 2..5 ] = 2
+    a[ [1,3,2,4], true ] = 3
+    a[] = 4			a.fill!(4) と同じ。
+
+    a[0..2]  = b[1..5]		--> 要素数が異なるのでエラー。
+    a[1,2]   = b[0..2,1..3]	[1,2]を始点として代入。
+    a[0..2,0..3]  = b[0..2,1]	繰り返し代入。
+				( a[0,0]=b[0,1],..,a[0,3]=b[0,1] )
+
+行・列の削除 -- インデックス取り出しの逆
+
+    self.delete_at(...)	  引数はインデクス参照と同じ。
+			  参照: https://github.com/masa16/narray/issues/5
+
+値のセット。
+    self.indgen!([start[,step]]) startからstepづつ増加した値をセット。
+    self.fill!(value)		 すべての要素にvalueをセット。
+    self.random!(max)		 0<=x<max の一様なランダム値を生成。
+				 using MT19337
+    self.randomn		 平均0、分散1の正規分布のランダム値を生成。
+				 (Box-Muller)
+    NArray.srand([seed])	 乱数のシードを設定。
+				 省略時は時刻から自動生成。
+
+演算: 要素ごとにおこなう。
+    a = NArray.float(3,3).indgen
+    b = NArray.float(3,3).fill(10)
+    c = a*b	# --> NArray.float(3,3)
+
+    a = NArray.float(3,1).indgen
+    b = NArray.float(1,3).fill(10)
+    c = a*b	# --> NArray.float(3,3) -- size=1の次元は拡張する。
+
+算術演算子
+    -self
+    self + other
+    self - other
+    self * other
+    self / other
+    self % other
+    self ** other
+    self.abs
+
+    self.add! other
+    self.sbt! other
+    self.mul! other
+    self.div! other
+    self.mod! other
+
+    self.mul_add(other,dim,...)   (self * other).sum(dim,...)とほぼ同じ。
+				  ただし途中で配列を作らない。
+
+ビット演算子(整数のみ可能)
+    ~self
+    self & other
+    self | other
+    self ^ other
+
+比較
+  -- 要素ごとに値を比較し、結果をBYTE型 NArrayを返す。
+     true/falseでないことに注意。
+    self.eq other ( == とは異なることに注意)
+    self.ne other
+    self.gt other
+    self >  other
+    self.ge other
+    self >= other
+    self.lt other
+    self <  other
+    self.le other
+    self <= other
+
+    self.and other  要素ごとの条件比較。
+    self.or  other
+    self.xor other
+    self.not other
+
+    self.all?     要素がすべて真ならば真。
+    self.any?     要素のどれかが真ならば真。
+    self.none?    要素のどれかが真ならば真。
+    self.where	  要素が真のインデックス配列を返す。
+    self.where2	  要素が真と偽のインデックス配列を含む(Ruby)配列を返す。
+
+	例: idx_t,idx_f = (a>12).where2
+
+同値性
+    NArray[1] == NArray[1]      #=> true
+    NArray[1] == NArray[1.0]    #=> true
+    NArray[1].eql? NArray[1]    #=> true
+    NArray[1].eql? NArray[1.0]  #=> false
+    NArray[1].equal? NArray[1]  #=> false
+    a=b=NArray[1]; a.equal? b   #=> true
+
+統計
+    self.sum(dim,..)	    指定した次元の和
+    self.cumsum	            累積和(1次元配列のみ)
+    self.prod(dim,..)	    指定した次元の積
+    self.cumprod	    累積積(1次元配列のみ)
+    self.mean(dim,..)       指定した次元の平均。
+    self.stddev(dim,..)     指定した次元の標準偏差(標本標準偏差)。
+    self.rms(dim,..)        指定した次元のroot mean square。
+    self.rmsdev(dim,..)     指定した次元のroot mean square deviation。
+    self.min(dim,..)        指定した次元の最小。
+    self.max(dim,..)        指定した次元の最大。
+			    (省略時は全ての次元。Range指定可。)
+    self.median(dim)	    0..dimの次元の中央値。省略時はすべての次元。
+
+ソート
+    self.sort(dim)	     0..dimの次元でソート。省略時はすべての次元。
+    self.sort_index(dim)     ソートしたインデックスを返す。
+			     self[self.sort_index] は self.sort と同等。
+
+転置
+    self.transpose( dim0, dim1, .. )
+	配列の転置。selfの第(dim0)次元が新しい配列の第0次元になる。
+	負数は後からの順番。
+	transpose(-1,1..-2,0) で最初と最後を入れ換え。
+
+インデックスの変更 (要素数は不変)
+    self.reshape!(size,...)
+    self.shape= size,...
+    self.newdim!(dim,...)	指定位置にサイズ1の次元を挿入する。
+
+データの参照
+    self.refer			selfのデータを参照する別のオブジェクトを作成。
+    self.reshape(size,...)	self.refer.reshape! と同様。
+    self.newdim(dim,...)	self.refer.newdim! と同様。
+
+反転・回転
+    self.reverse([dim,...])	指定した次元を逆順にする
+    self.rot90([k])		2次元配列の90度の回転をk回行う
+
+型変換
+    self.floor selfより小さい最大の整数を返す。
+    self.ceil  selfより大きい最小の整数を返す。
+    self.round selfにもっとも近い整数を返す。
+    self.to_f  値を浮動小数点数に変換する。
+    self.to_i  値を整数に変換する。
+    self.to_a  値をRubyの配列に変換する。
+    self.to_s  バイナリデータをそのままRubyの文字列データに変換する。
+    self.to_string  各要素を文字列に変換する。
+
+イテレータ
+    self.each {|i| ...}
+    self.collect {|i| ...}
+    self.collect! {|i| ...}
+
+バイトスワップ
+    self.swap_byte	バイトスワップ
+    self.hton		ネットワークバイトオーダーに変換
+    self.ntoh
+    self.htov		VAXバイトオーダーに変換
+    self.vtoh
+
+Boolean / マスク関係
+    self.count_false	値 == 0 の要素数 (byte型のみ)
+    self.count_true	値 == 1 の要素数 (byte型のみ)
+    self.mask( mask )	self[ mask ] と同じだかマスキング専用.
+			[] と違い int, sint のマスクも使える.
+
+複素数
+    self.real
+    self.imag
+    self.conj
+    self.conj!
+    self.angle		atan2(self.imag, self.real)
+    self.imag= other	虚数部分にotherをセット。
+    self.im		虚数倍。
+
+NMath モジュール
+    sqrt(x)
+    exp(x)
+    log(x)
+    log10(x)
+    log2(x)
+    atan2(x,y)
+    sin,cos,tan
+    sinh,cosh,tanh
+    asin,acos,atan
+    asinh,acosh,atanh
+    csc,sec,cot
+    csch,sech,coth
+    acsc,asec,acot
+    acsch,asech,acoth
+    covariance
+
+
+FFTW モジュール (fftw-2.1.3をshared libでコンパイルしたもので確認)
+ (別モジュール)
+    fftw(x,[1|-1])
+    convol(a,b)		FFTWを用いた畳み込み。
+
+
+NMatrix
+
+  NArrayのサブクラス。最初の2次元をMatrixとして用いる。
+  残りの次元は多次元配列として扱われる。
+  次元の順序は、数学での表記とは逆:  a_ij => a[j,i]
+
+  メソッド:
+    +,-	 相手が NMatrix のときに演算可。
+    *	 相手が NMatrix または NVector のときは Matrix積。
+	 相手が Numeric または NArray のときは Scalar積。
+	 例: NMatrix[[1,2],[3,4]] * [1,10]
+	       == NMatrix[ [[1,2],[3,4]], [[10,20],[30,40]] ]
+    /	 相手が Numeric または NArray のときはScalar除算。
+	 相手が square NMatrix のときはLUにより線形方程式を解く。
+	 a/b == b.lu.solve(a)
+
+    transpose		引数を省略した場合は、最初のMatrix次元を交換。
+    diagonal(other)
+    diagonal!(other)	対角要素に値をセット。引数省略時は1をセット。
+    I			対角要素に値に1をセット。
+    inverse		逆行列
+    lu			LU分解を計算。NMatrixLU クラスのインスタンスを返す。
+
+
+NVector
+
+  NArrayのサブクラス。最初の1次元をVectorとして用いる。
+  残りの次元は多次元配列として扱われる。
+
+  メソッド:
+    +,-	 相手が NVector のときに演算可。
+    *	 相手が NMatrix のときは Matrix積。
+    	 相手が NVector のときは 内積。
+	 相手が Numeric または NArray のときは Scalar積。
+    /	 相手が Numeric または NArray のときは Scalar除算。
+	 相手が square NMatrix のときはLUにより線形方程式を解く。
+	 v/m == m.lu.solve(v)
+
+NMatrixLU
+
+  NMatrix#lu メソッドにより作られる。
+  LU (NMatrix) と pivot (NVector) を含む。
+
+  メソッド:
+    solve(other)	LU分解の結果を使って other を解く。
+			other は NMatrix または NVector のインスタンス。

data/ext/narray/depend

@@ -0,0 +1,14 @@
+na_op.c: mknafunc.rb mkop.rb
+	$(RUBY) -I$(srcdir) $(srcdir)/mkop.rb
+
+na_op.o: na_op.c narray.h $(hdrdir)/ruby.h
+
+
+na_math.c: mknafunc.rb mkmath.rb
+	$(RUBY) -I$(srcdir) $(srcdir)/mkmath.rb
+
+na_math.o: na_math.c narray.h $(hdrdir)/ruby.h
+
+
+cleanall:  clean
+	@$(RM) -r Makefile narray_config.h na_op.c na_math.c src pkg

data/ext/narray/extconf.rb

@@ -0,0 +1,123 @@
+require "mkmf"
+
+def have_type(type, header=nil)
+  printf "checking for %s... ", type
+  STDOUT.flush
+  src = <<"SRC"
+#include <ruby.h>
+SRC
+  unless header.nil?
+  src << <<"SRC"
+#include <#{header}>
+SRC
+  end
+  r = try_link(src + <<"SRC")
+  int main() { return 0; }
+  int t() { #{type} a; return 0; }
+SRC
+  unless r
+    print "no\n"
+    return false
+  end
+  $defs.push(format("-DHAVE_%s", type.upcase))
+  print "yes\n"
+  return true
+end
+
+def create_conf_h(file)
+  print "creating #{file}\n"
+  hfile = open(file, "w")
+  for line in $defs
+    line =~ /^-D(.*)/
+    hfile.printf "#define %s 1\n", $1
+  end
+  hfile.close
+end
+
+if RUBY_VERSION < '1.8'
+  alias __install_rb :install_rb
+  def install_rb(mfile, dest, srcdir = nil)
+    __install_rb(mfile, dest, srcdir)
+    archdir = dest.sub(/sitelibdir/,"sitearchdir").sub(/rubylibdir/,"archdir")
+    path = ['$(srcdir)/narray.h','narray_config.h']
+    path << ['libnarray.a'] if /cygwin|mingw/ =~ RUBY_PLATFORM
+    for f in path
+      mfile.printf "\t@$(RUBY) -r ftools -e 'File::install(ARGV[0], ARGV[1], 0644, true)' %s %s\n", f, archdir
+    end
+  end
+else
+  $INSTALLFILES = [['narray.h', '$(archdir)'], ['narray_config.h', '$(archdir)']]
+  if /cygwin|mingw/ =~ RUBY_PLATFORM
+	 $INSTALLFILES << ['libnarray.a', '$(archdir)']
+  end
+end
+
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  if RUBY_VERSION >= '1.9.0'
+    $DLDFLAGS << " -Wl,--export-all,--out-implib=libnarray.a"
+  elsif RUBY_VERSION > '1.8.0'
+    $DLDFLAGS << ",--out-implib=libnarray.a"
+  elsif RUBY_VERSION > '1.8'
+    CONFIG["DLDFLAGS"] << ",--out-implib=libnarray.a"
+    system("touch libnarray.a")
+  else
+    CONFIG["DLDFLAGS"] << " --output-lib libnarray.a"
+  end
+end
+
+
+case RbConfig::CONFIG["CC"]
+when "gcc"
+  omp_opt = "-fopenmp"
+else
+  omp_opt = nil
+end
+omp_opt = arg_config("--openmp", omp_opt)
+
+omp_opt = nil if omp_opt.to_s.empty?
+
+if omp_opt
+  $CFLAGS << " " << omp_opt
+  $DLDFLAGS << " " << omp_opt
+  warn "OpenMP support: ON"
+else
+  warn "OpenMP support: OFF"
+  warn "if you want to enable openmp, set --openmp=compile_option"
+end
+
+#$DEBUG = true
+#$CFLAGS = ["-Wall",$CFLAGS].join(" ")
+
+srcs = %w(
+narray
+na_array
+na_func
+na_index
+na_random
+na_op
+na_math
+na_linalg
+)
+
+header = "stdint.h"
+unless have_header(header)
+  header = "sys/types.h"
+  unless have_header(header)
+    header = nil
+  end
+end
+
+have_type("u_int8_t", header)
+have_type("uint8_t", header)
+have_type("int16_t", header)
+have_type("int32_t", header)
+have_type("int64_t", header)
+have_type("u_int32_t", header)
+have_type("uint32_t", header)
+have_type("u_int64_t", header)
+have_type("uint64_t", header)
+
+$objs = srcs.collect{|i| i+".o"}
+
+create_conf_h("narray_config.h")
+create_makefile("narray/narray")

data/ext/narray/mkmath.rb

@@ -0,0 +1,792 @@
+require "mknafunc"
+
+# File name
+fname = "na_math.c"
+$> = open(fname,"w")
+
+print <<EOM
+/*
+  #{fname}
+  Automatically generated code
+  Numerical Array Extention for Ruby
+    (C) Copyright 1999-2008 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);
+}
+
+#ifndef HAVE_ACOSH
+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;
+
+static 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 */
+}
+
+static 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;
+}
+
+static 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
+#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;
+}
+
+
+EOM
+
+data = [
+['sqrt',
+[nil]*5 +
+["{ *p1 = sqrt(*p2); }"]*2 +
+["{
+  typer xr=p2->r/2, xi=p2->i/2, r=hypot(xr,xi);
+  if (xr>0) {
+    p1->r = sqrt(r+xr);
+    p1->i = xi/p1->r;
+  } else if ( (r-=xr) ) {
+    p1->i = (xi>=0) ? sqrt(r):-sqrt(r);
+    p1->r = xi/p1->i;
+  } else {
+    p1->r = p1->i = 0;
+  }
+}"]*2 +
+[nil] ],
+
+['sin',
+[nil]*5 +
+["{ *p1 = sin(*p2); }"]*2 +
+["{
+  p1->r = sin(p2->r)*cosh(p2->i);
+  p1->i = cos(p2->r)*sinh(p2->i); }"]*2 +
+[nil] ],
+
+['cos',
+[nil]*5 +
+["{ *p1 = cos(*p2); }"]*2 +
+["{
+  p1->r = cos(p2->r)*cosh(p2->i);
+  p1->i = -sin(p2->r)*sinh(p2->i); }"]*2 +
+[nil] ],
+
+['tan',
+[nil]*5 +
+["{ *p1 = tan(*p2); }"]*2 +
+["{
+  typer d, th;
+  p1->i = th = tanh(2*p2->i);
+  p1->r = sqrt(1-th*th); /* sech */
+  d  = 1 + cos(2*p2->r) * p1->r;
+  p1->r *= sin(2*p2->r)/d;
+  p1->i /= d;
+}"]*2 +
+[nil] ],
+
+['sinh',
+[nil]*5 +
+["{ *p1 = sinh(*p2); }"]*2 +
+["{
+  p1->r = sinh(p2->r)*cos(p2->i);
+  p1->i = cosh(p2->r)*sin(p2->i);
+}"]*2 +
+[nil] ],
+
+['cosh',
+[nil]*5 +
+["{ *p1 = cosh(*p2); }"]*2 +
+["{
+  p1->r = cosh(p2->r)*cos(p2->i);
+  p1->i = sinh(p2->r)*sin(p2->i);
+}"]*2 +
+[nil] ],
+
+['tanh',
+[nil]*5 +
+["{ *p1 = tanh(*p2); }"]*2 +
+["{
+  typer d, th;
+  p1->r = th = tanh(2*p2->r);
+  p1->i = sqrt(1-th*th); /* sech */
+  d  = 1 + cos(2*p2->i) * p1->i;
+  p1->r /= d;
+  p1->i *= sin(2*p2->i)/d;
+}"]*2 +
+[nil] ],
+
+['exp',
+[nil]*5 +
+["{ *p1 = exp(*p2); }"]*2 +
+["{
+  typer a = exp(p2->r);
+  p1->r = a*cos(p2->i);
+  p1->i = a*sin(p2->i);
+}"]*2 +
+[nil] ],
+
+['log',
+[nil]*5 +
+["{ *p1 = log(*p2); }"]*2 +
+["{
+  typed x = *p2;
+  p1->r = log(hypot(x.r, x.i));
+  p1->i = atan2(x.i, x.r);
+}"]*2 +
+[nil] ],
+
+['log10',
+[nil]*5 +
+["{ *p1 = log10(*p2); }"]*2 +
+["{
+  log#code(p1,p2);
+  p1->r *= (typer)M_LOG10E;
+  p1->i *= (typer)M_LOG10E;
+}"]*2 +
+[nil] ],
+
+
+['log2',
+[nil]*5 +
+["{ *p1 = log(*p2)*M_LOG2E; }"]*2 +
+["{
+  log#code(p1,p2);
+  p1->r *= (typer)M_LOG2E;
+  p1->i *= (typer)M_LOG2E;
+}"]*2 +
+[nil] ],
+
+
+['asin',
+[nil]*5 +
+["{ *p1 = asin(*p2); }"]*2 +
+# -i * log( sqrt(1-x**2) + x*i )
+["{
+  typed x = *p2;
+  square#code(&x);
+  x.r = 1 - x.r;
+  x.i =   - x.i;
+  sqrt#code(&x,&x);
+  x.r -= p2->i;
+  x.i += p2->r;
+  log#code(&x,&x);
+  p1->r =  x.i;
+  p1->i = -x.r;
+}"]*2 +
+[nil]*1 ],
+
+['asinh',
+[nil]*5 +
+["{ *p1 = asinh(*p2); }"]*2 +
+# log(sqrt(x**2+1)+x)
+["{
+  typed x = *p2;
+  square#code(&x);
+  x.r += 1;
+  sqrt#code(&x,&x);
+  x.r += p2->r;
+  x.i += p2->i;
+  log#code(p1,&x);
+}"]*2 +
+[nil]*1 ],
+
+['acos',
+[nil]*5 +
+["{ *p1 = acos(*p2); }"]*2 +
+# -i * log( sqrt(1-x**2)*i + x )
+["{
+  typed x = *p2;
+  typer tmp;
+  square#code(&x);
+  x.r = 1 - x.r;
+  x.i =   - x.i;
+  sqrt#code(&x,&x);
+  tmp =  x.r + p2->i;
+  x.r = -x.i + p2->r;
+  x.i = tmp;
+  log#code(&x,&x);
+  p1->r =  x.i;
+  p1->i = -x.r;
+}"]*2 +
+[nil]*1 ],
+
+['acosh',
+[nil]*5 +
+["{ *p1 = acosh(*p2); }"]*2 +
+# log(x+sqrt(x**2-1))
+["{
+  typed x = *p2;
+  square#code(&x);
+  x.r -= 1;
+  sqrt#code(&x,&x);
+  x.r += p2->r;
+  x.i += p2->i;
+  log#code(p1,&x);
+}"]*2 +
+[nil]*1 ],
+
+['atan',
+[nil]*5 +
+["{ *p1 = atan(*p2); }"]*2 +
+# i/2 * log((i+x)/(i-x))
+["{
+  typed x,y;
+  x.r=-p2->r; x.i=1-p2->i;
+  y.r= p2->r; y.i=1+p2->i;
+  div#code((void*)&y,(void*)&x);
+  log#code((void*)&x,(void*)&y);
+  p1->r = -x.i/2;
+  p1->i =  x.r/2;
+}"]*2 +
+[nil]*1 ],
+
+['atanh',
+[nil]*5 +
+["{ *p1 = atanh(*p2); }"]*2 +
+# 1/2 * log((1+x)/(1-x))
+["{
+  typed x,y;
+  x.r=1-p2->r; x.i=-p2->i;
+  y.r=1+p2->r; y.i= p2->i;
+  div#code((void*)&y,(void*)&x);
+  log#code((void*)&x,(void*)&y);
+  p1->r = x.r/2;
+  p1->i = x.i/2;
+}"]*2 +
+[nil]*1 ] ]
+
+
+
+def mkmathfuncs(bsname,func)
+
+  print "
+/* ------------------------- #{bsname} --------------------------- */\n"
+  c  = $type_codes
+  tr = $real_types
+  td = $data_types
+  name = bsname
+
+  # Function Definition
+  head = "static void #{name}#code(void *p1, void *p2)"
+  for i in 0...c.size
+    if func[i] != nil && func[i]=~/^\{/
+      f = func[i].
+	gsub(/p1->/,"((#{td[i]}*)p1)->").
+	gsub(/p2->/,"((#{td[i]}*)p2)->").
+	gsub(/\*p1/,"*(#{td[i]}*)p1").
+	gsub(/\*p2/,"*(#{td[i]}*)p2").
+	gsub(/typer/, tr[i]).
+	gsub(/typed/, td[i])
+      puts( (head+f).gsub(/#code/,c[i]) )
+    end
+  end
+
+  # Function Array
+
+  print "\nna_mathfunc_t #{name}Funcs =\n{ "
+  m = []
+  for i in 0...c.size
+    if func[i] == nil
+      m += ['TpErr']
+    elsif func[i]=='copy'
+      m += ['Set'+c[i]*2]
+    elsif !( func[i] =~ /^\{/ )
+      m += [func[i]]
+    else
+      m += [name+c[i]]
+    end
+  end
+  print m.join(", ")+" };\n"
+
+end
+
+
+# Function Definitions
+for i in data
+  mkmathfuncs( i[0], i[1] )
+end
+
+
+#
+#  Recip
+#
+$func_body = 
+  "static void #name#C(int n, char *p1_0, int i1, char *p2_0, int i2)
+{
+  type1* p1 = (type1*) p1_0;
+  typec* p2 = (typec*) p2_0;
+  int i;
+
+  #pragma omp parallel for
+  for (i=0; i<n; i++) {
+    OPERATION
+  }
+}
+"
+mkfuncs('Rcp', $data_types, $data_types,
+ [nil] +
+ ["p1[i] = 1/(p2[i]);"]*6 + 
+ ["p1[i] = recip#C(p2[i]);"]*2 +
+ ["p1[i] = rb_funcall(INT2FIX(1),na_id_div,1,p2[i]);"]
+)
+
+
+#
+#   Power
+#
+def mkpowfuncs(name,funcs)
+
+  print "
+/* ------------------------- #{name} --------------------------- */\n"
+  c  = $type_codes
+  n  = $type_codes.size
+  td = $data_types
+  tr = $real_types
+
+  # Function Definition
+
+  for i in 0...n
+    for j in 0...n
+      funcs.each do |k|
+	if c[i]=~k[0] && c[j]=~k[1]
+	  tu = $data_types[$upcast[i][j]]
+	  f = k[2].
+	    gsub(/p1->/,"((#{tu}*)p1)->").
+	    gsub(/p2->/,"((#{td[i]}*)p2)->").
+	    gsub(/p3->/,"((#{td[j]}*)p3)->").
+	    gsub(/\*p1/,"*(#{tu}*)p1").
+	    gsub(/\*p2/,"*(#{td[i]}*)p2").
+	    gsub(/\*p3/,"*(#{td[j]}*)p3").
+	    gsub(/typed/,td[i]).
+            gsub(/typef/,tr[i])
+	  puts $func_body.
+            gsub(/#t1/,tu).
+            gsub(/#t2/,td[i]).
+            gsub(/#t3/,td[j]).
+	    gsub(/#name/,name).
+	    sub(/OPERATION/,f).
+	    gsub(/#CC/,c[i]+c[j]).
+	    gsub(/#C/, c[i])
+	end
+      end
+    end
+  end
+
+  # function pointer array
+  print "\nna_setfunc_t "+name+"Funcs = {\n"
+  m = []
+  for i in 0...n
+    l = []
+    for j in 0...n
+      f = true
+      for k in funcs
+	if c[i]=~k[0] && c[j]=~k[1]
+	  l += [name+c[i]+c[j]]
+	  f = false
+	  break
+	end
+      end
+      if f
+	l += ['TpErr']
+      end
+    end
+    m += ['  { '+l.join(', ')+' }']
+  end
+  print m.join(",\n")+"\n};\n"
+
+end
+
+$func_body = 
+"static void #name#CC(int n, char *p1, int i1, char *p2, int i2, char *p3, int i3)
+{
+  for (; n; --n) {
+    OPERATION
+    p1+=i1; p2+=i2; p3+=i3;
+  }
+}
+"
+mkpowfuncs('Pow',
+[
+[/[O]/,/[O]/,      "*p1 = rb_funcall(*p2,na_id_power,1,*p3);"],
+[/[BILG]/,/[BILG]/,"*p1 = powInt(*p2,*p3);"],
+[/[FD]/,/[BILG]/,  "*p1 = pow#Ci(*p2,*p3);"],
+[/[BILGFD]/,/[FD]/,"*p1 = pow(*p2,*p3);"],
+[/[XC]/,/[BILG]/,  "*p1 = pow#Ci((typed*)p2,*p3);"],
+[/[XC]/,/[FD]/,
+   "typed r;
+    if (*p3==0)
+    { p1->r=1; p1->i=0; } else
+    if (p2->r==0 && p2->i==0 && *p3>0)
+    { p1->r=0; p1->i=0; } else {
+    log#C(&r, p2);
+    r.r *= *p3;
+    r.i *= *p3;
+    exp#C(p1, &r); }"],
+[/[XC]/,/[XC]/,
+   "typed l, r;
+    if (p3->r==0 && p3->i==0)
+    { p1->r=1; p1->i=0; } else
+    if (p2->r==0 && p2->i==0 && p3->r>0 && p3->i==0)
+    { p1->r=0; p1->i=0; } else {
+    log#C(&l, p2);
+    r.r = p3->r * l.r - p3->i * l.i;
+    r.i = p3->r * l.i + p3->i * l.r;
+    exp#C(p1, &r); }"]
+])
+
+
+# Execution
+print <<EOM
+
+
+/* ------------------------- Execution -------------------------- */
+
+static void
+ na_exec_math(struct NARRAY *a1, struct NARRAY *a2, void (*func)())
+{
+  na_shape_t i;
+  int s1, s2;
+  char *p1, *p2;
+
+  s1 = na_sizeof[a1->type];
+  s2 = na_sizeof[a2->type];
+  p1 = a1->ptr;
+  p2 = a2->ptr;
+
+  #pragma omp parallel for
+  for (i=0;i<a1->total; i++) {
+    (*func)( p1+s1*i, p2+s2*i );
+  }
+}
+
+
+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;
+}
+EOM
+
+
+# Module Methods
+print <<EOM
+
+/* ------------------------- Module Methods -------------------------- */
+EOM
+for i in data
+  bsname=i[0]
+  name=bsname
+  print <<EOM
+
+/*
+ *  call-seq:
+ *     NMath.#{name}(arg)  -> narray
+ */
+static VALUE na_math_#{bsname}(VALUE obj, VALUE x)
+{ return na_math_func(x,#{name}Funcs); }
+EOM
+end
+
+
+
+# Initializer
+print <<EOM
+
+
+/* Initialization of NMath module */
+void Init_nmath(void)
+{
+  /* define ExtMath module */
+  rb_mNMath = rb_define_module("NMath");
+
+  /* methods */
+EOM
+
+for i in data
+  print "  rb_define_module_function(rb_mNMath,\"#{i[0]}\",na_math_#{i[0]},1);\n"
+end
+
+print <<EOM
+}
+EOM