narray-nmatrix 0.6.1.0.pre

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/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/extconf.rb

@@ -0,0 +1,100 @@
+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
+
+#$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("u_int32_t", header)
+have_type("uint32_t", header)
+
+$objs = srcs.collect{|i| i+".o"}
+
+create_conf_h("narray_config.h")
+create_makefile("narray")

data/lib/narray.rb

@@ -0,0 +1,18 @@
+# This file exists for backwards compatibility with earlier versions of NArray
+# that defined all of its classes and modules in the top level namespace rather
+# than just the NArray class at the top level and all other related classes and
+# modules nested within the NArray class.
+#
+# After requiring the 'narray/narray' package to load the top level NArray class
+# and the nested classes and modules it contains, top level aliases are created
+# for the nested classes to provide backwards compatibility.
+
+require 'narray/narray'
+
+# Create top level aliases
+
+NMath        = NArray::NMath
+NVector      = NArray::NVector
+NMatrix      = NArray::NMatrix
+NMatrixLU    = NArray::NMatrixLU
+NArrayScalar = NArray::NArrayScalar

data/lib/narray/narray.rb

@@ -0,0 +1,5 @@
+# Require the NArray shared library that defines the top level "NA" module and
+# all of its contents.  Requiring "narray.so" will load the narray shared
+# library even on systems that use an extension other than ".so" for shared
+# libraries (e.g. ".bundle" or ".dylib" on Mac OS X or ".dll" on Windows).
+require 'narray.so'

data/lib/narray_ext.rb

@@ -0,0 +1,362 @@
+#  Numerical Array Extention for Ruby
+#    (C) Copyright 2000-2008 by Masahiro TANAKA
+#
+#  This program is free software.
+#  You can distribute/modify this program
+#  under the same terms as Ruby itself.
+#  NO WARRANTY.
+#
+class NArray
+
+  def self.cast(array,type=nil)
+    case array
+    when NArray
+    when Array
+      array = NArray.to_na(array)
+    else
+      raise ArgumentError, "1st argument must be NArray or Array"
+    end
+    type = array.typecode if type.nil?
+    shape = array.shape
+    na = self.new(type,*shape)
+    na[] = array
+    na
+  end
+
+  def integer?
+    self.typecode==NArray::BYTE ||
+    self.typecode==NArray::SINT ||
+    self.typecode==NArray::LINT
+  end
+  def complex?
+    self.typecode==NArray::DCOMPLEX ||
+    self.typecode==NArray::SCOMPLEX
+  end
+
+  def all?
+    where.size == size
+  end
+
+  def any?
+    where.size > 0
+  end
+
+  def none?
+    where.size == 0
+  end
+
+  def ==(other)
+    other.kind_of?(NArray) &&
+      shape == other.shape && 
+      eq(other).all?
+  end
+
+  def eql?(other)
+    self.class == other.class &&
+      typecode == other.typecode &&
+      shape == other.shape &&
+      case typecode
+      when NArray::OBJECT
+  to_a.eql? other.to_a
+      else
+  to_s.eql? other.to_s
+      end
+  end
+
+  def hash
+    case typecode
+    when NArray::OBJECT
+      [self.class, to_a].hash
+    else
+      [self.class, typecode, shape, to_s].hash
+    end
+  end
+
+  def rank_total(*ranks)
+    if ranks.size>0
+      idx = []
+      ranks.each{|i| idx.push(*i)}
+      # ranks is expected to be, e.g., [1, 3..5, 7]
+      a = self.shape
+      n = 1
+      idx.each{|i| n *= a[i]}
+      n
+    else
+      self.total
+    end
+  end
+
+  # delete rows/columns
+  def delete_at(*args)
+    if args.size > self.rank
+      raise ArgumentError, "too many arguments"
+    end
+    shp = self.shape
+    ind = []
+    self.rank.times do |i|
+      n = shp[i]
+      case a=args[i]
+      when Integer
+        a = n+a if a<0
+        raise IndexError, "index(%d) out of range"%[a] if a<0
+        x = [0...a,a+1...n]
+      when Range
+        b = a.first
+        b = n+b if b<0
+        raise IndexError, "index(%s) out of range"%[a] if b<0
+        e = a.last
+        e = n+e if e<0
+        e -= 1 if a.exclude_end?
+        raise IndexError, "index(%s) out of range"%[a] if e<0
+        x = [0...b,e+1...n]
+      when Array
+        x = (0...n).to_a
+        x -= a.map do |j|
+          raise IndexError, "contains non-integer" unless Integer===j
+          (j<0) ? n+j : j
+        end
+      else
+        if a
+          raise ArgumentError, "invalid argument"
+        else
+          x = true
+        end
+      end
+      ind << x
+    end
+    self[*ind]
+  end
+
+# Statistics
+  def mean(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    a.sum(*ranks) / (rank_total(*ranks))
+  end
+
+  def stddev(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/(n-1) )
+    else
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/(n-1) )
+    end
+  end
+
+  def rms(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (a.abs**2).sum(*ranks)/n )
+    else
+      NMath::sqrt( (a**2).sum(*ranks)/n )
+    end
+  end
+
+  def rmsdev(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/n )
+    else
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/n )
+    end
+  end
+
+  def median(rank=nil)
+    shape = self.shape
+    rank = shape.size-1 if rank==nil
+    s = sort(rank).reshape!(true,*shape[rank+1..-1])
+    n = s.shape[0]
+    if n%2==1
+      s[n/2,false]
+    else
+      s[n/2-1..n/2,false].sum(0)/2
+    end
+  end
+
+
+# Normal distributed random number;  valid for floating point types
+  def randomn
+    size = self.size
+    case type = self.typecode
+    when COMPLEX; type=FLOAT
+    when SCOMPLEX; type=SFLOAT
+    when FLOAT
+    when SFLOAT
+    else
+      raise TypeError, "NArray type must be (S)FLOAT or (S)COMPLEX."
+    end
+    rr = NArray.new(type,size)
+    xx = NArray.new(type,size)
+    i = 0
+    while i < size
+      n = size-i
+      m = ((n+Math::sqrt(n))*1.27).to_i
+      x = NArray.new(type,m).random!(1) * 2 - 1
+      y = NArray.new(type,m).random!(1) * 2 - 1
+      r = x**2 + y**2
+      idx = (r<1).where
+      idx = idx[0...n] if idx.size > n
+      if idx.size>0
+  rr[i] = r[idx]
+  xx[i] = x[idx]
+  i += idx.size
+      end
+    end
+    # Box-Muller transform
+    rr = ( xx * NMath::sqrt( -2 * NMath::log(rr) / rr ) )
+    # finish
+    rr.reshape!(*self.shape) if self.rank > 1
+    rr = rr.to_type(self.typecode) if type!=self.typecode
+    if RUBY_VERSION < "1.8.0"
+      self.type.refer(rr)
+    else
+      self.class.refer(rr)
+    end
+  end
+  #alias randomn! randomn
+
+  def randomn!
+    self[]= randomn
+    self
+  end
+
+  def reverse(*ranks)
+    if self.rank==0
+      return self.dup
+    elsif ranks.size==0
+      idx = (0...self.rank).map{-1..0}
+    else
+      idx = [true]*self.rank
+      ranks.each do |i|
+        if !i.kind_of?(Integer)
+          raise ArgumentError, "Argument must be Integer"
+        end
+        if i >= self.rank
+          raise ArgumentError, "dimension(%s) out of range"%[i]
+        end
+        idx[i] = -1..0
+      end
+    end
+    self[*idx]
+  end
+
+  def rot90(n_times=1)
+    if self.rank < 2
+      raise "must be >= 2 dimensional array"
+    end
+    case n_times%4
+    when 0
+      self.dup
+    when 1
+      self.transpose(1,0).reverse(0)
+    when 2
+      self.reverse(0,1)
+    when 3
+      self.transpose(1,0).reverse(1)
+    end
+  end
+
+  #SFloatOne = NArray.sfloat(1).fill!(1)
+
+  module NMath
+    PI = Math::PI
+    E = Math::E
+
+    def recip x
+      1/x.to_f
+    end
+
+  # Trigonometric function
+    def csc x
+      1/sin(x)
+    end
+    def csch x
+      1/sinh(x)
+    end
+    def acsc x
+      asin(1/x.to_f)
+    end
+    def acsch x
+      asinh(1/x.to_f)
+    end
+
+    def sec x
+      1/cos(x)
+    end
+    def sech x
+      1/cosh(x)
+    end
+    def asec x
+      acos(1/x.to_f)
+    end
+    def asech x
+      acosh(1/x.to_f)
+    end
+
+    def cot x
+      1/tan(x)
+    end
+    def coth x
+      1/tanh(x)
+    end
+    def acot x
+      atan(1/x.to_f)
+    end
+    def acoth x
+      atanh(1/x.to_f)
+    end
+
+  # Statistics
+    def covariance(x,y,*ranks)
+      x = NArray.to_na(x) unless x.kind_of?(NArray)
+      x = x.to_type(NArray::DFLOAT) if x.integer?
+      y = NArray.to_na(y) unless y.kind_of?(NArray)
+      y = y.to_type(NArray::DFLOAT) if y.integer?
+      n = x.rank_total(*ranks)
+      xm = x.accum(*ranks).div!(n)
+      ym = y.accum(*ranks).div!(n)
+      ((x-xm)*(y-ym)).sum(*ranks) / (n-1)
+    end
+
+    module_function :recip
+    module_function :csc,:sec,:cot,:csch,:sech,:coth
+    module_function :acsc,:asec,:acot,:acsch,:asech,:acoth
+    module_function :covariance
+  end
+
+end # class NArray
+
+
+module FFTW
+  def convol(a1,a2)
+    n1x,n1y = a1.shape
+    n2x,n2y = a2.shape
+    raise "arrays must have same shape" if n1x!=n2x || n1y!=n2y
+    (FFTW.fftw( FFTW.fftw(a1,-1) * FFTW.fftw(a2,-1), 1).real) / (n1x*n1y)
+  end
+  module_function :convol
+end
+
+require 'nmatrix'