narray 0.5.9.4

data/src/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)  na_op.c na_math.c

data/src/extconf.rb

@@ -0,0 +1,111 @@
+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.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(" ")
+
+# configure options:
+#  --with-fftw-dir=path
+#  --with-fftw-include=path
+#  --with-fftw-lib=path
+#dir_config("fftw")
+
+srcs = %w(
+narray
+na_array
+na_func
+na_index
+na_random
+na_op
+na_math
+na_linalg
+)
+
+if have_header("sys/types.h")
+  header = "sys/types.h"
+else
+  header = nil
+end
+
+have_type("u_int8_t", header)
+have_type("int16_t", header)
+have_type("int32_t", header)
+have_type("u_int32_t", header)
+#have_library("m")
+#have_func("sincos")
+#have_func("asinh")
+
+#if have_header("fftw.h")
+#  if have_library("fftw", "fftwnd_create_plan")
+#    srcs.push "na_fftw"
+#  else
+#    $defs.delete "-DHAVE_FFTW_H"
+#  end
+#end
+
+$objs = srcs.collect{|i| i+".o"}
+
+create_conf_h("narray_config.h")
+create_makefile("narray")

data/src/lib/narray_ext.rb

@@ -0,0 +1,211 @@
+#  Numerical Array Extention for Ruby
+#    (C) Copyright 2000-2003 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 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)
+    if other.kind_of?(NArray)
+      (shape == other.shape) && eq(other).all?
+    else
+      false
+    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
+
+# Statistics
+  def mean(*ranks)
+    if integer?
+      a = self.to_f
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    a.sum(*ranks) / (rank_total(*ranks))
+  end
+
+  def stddev(*ranks)
+    if integer?
+      a = self.to_f
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/(n-1) )
+  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
+
+  #SFloatOne = NArray.sfloat(1).fill!(1)
+end
+
+
+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/atanh(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_f if x.integer?
+    y = NArray.to_na(y) unless y.kind_of?(NArray)
+    y = y.to_f 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 :csc,:sec,:cot,:csch,:sech,:coth
+  module_function :acsc,:asec,:acot,:acsch,:asech,:acoth
+  module_function :covariance
+end
+
+
+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'

data/src/lib/nmatrix.rb

@@ -0,0 +1,244 @@
+#  Numerical Array Extention for Ruby
+#    (C) Copyright 2000-2003 by Masahiro TANAKA
+#
+
+#
+# ------ NMatrix ------
+#
+class NMatrix < NArray
+  CLASS_DIMENSION = 2
+
+  def +(other)
+    case other
+    when NMatrix
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :+.to_i )
+      end
+    end
+    raise TypeError,"Illegal operation: NMatrix + %s" % other.class
+  end
+
+  def -(other)
+    case other
+    when NMatrix
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :-.to_i )
+      end
+    end
+    raise TypeError,"Illegal operation: NMatrix - %s" % other.class
+  end
+
+  def *(other)
+    case other
+    when NMatrix
+      NMatrix.mul_add( NArray.refer(self).newdim!(0),other.newdim(2), 1 )
+      #NMatrix.mul_add( NArray.refer(self).newdim!(0),
+      #		       other.transpose(1,0).newdim!(2), 0 )
+    when NVector
+      NVector.mul_add( NArray.refer(self), other.newdim(1), 0 )
+    when NArray
+      if other.instance_of?(NArray)
+	NMatrix.mul( NArray.refer(self), other.newdim(0,0) )
+      else
+	other.coerce_rev( self, :*.to_i )
+      end
+    when Numeric
+      super
+      #NMatrix.mul( NArray.refer(self), other )
+    when Array
+      NMatrix.mul( self, NArray[*other].newdim!(0,0) )
+    else
+      raise TypeError,"Illegal operation: NMatrix * %s" % other.class
+    end
+  end
+
+  def /(other)
+    case other
+    when NMatrix
+      other.lu.solve(self)
+    when NVector
+      raise TypeError,"Illegal operation: NMatrix / %s" % other.class
+    when NArray
+      if other.instance_of?(NArray)
+	NMatrix.div( NArray.refer(self), other.newdim(0,0) )
+      else
+	other.coerce_rev( self, :/.to_i )
+      end
+    when Numeric
+      NMatrix.div( NArray.refer(self), other )
+    when Array
+      NMatrix.div( self, NArray[*other].newdim!(0,0) )
+    else
+      raise TypeError,"Illegal operation: NMatrix / %s" % other.class
+    end
+  end
+
+  def **(n)
+    case n
+    when Integer
+      if n==0
+	return 1.0
+      elsif n<0
+	m = self.inverse
+	n = -n
+      else
+	m = self
+      end
+      (2..n).each{ m *= self }
+      m
+    else
+      raise TypeError,"Illegal operation: NMatrix ** %s" % other.class
+    end
+  end
+
+  def coerce_rev(other,id)
+    case id
+    when :*.to_i
+	if other.instance_of?(NArray)
+	  return NMatrix.mul( other.newdim(0,0), self )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NMatrix.mul( other.newdim(0), self )
+	end
+    when :/.to_i
+	if other.instance_of?(NArray)
+	  return NMatrix.mul( other.newdim(0,0), self.inverse )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NMatrix.mul( other.newdim(0), self.inverse )
+	end
+    end
+    raise TypeError,"Illegal operation: %s %s NMatrix" %
+      [other.class, id.id2name]
+  end
+
+  def inverse
+    self.lu.solve( NMatrix.new(self.typecode, *self.shape).fill!(0).unit )
+  end
+
+  def transpose(*arg)
+    if arg.size==0
+      super(1,0)
+    else
+      super
+    end
+  end
+
+  def diagonal!(val=1)
+    shp = self.shape
+    idx = NArray.int(shp[0..1].min).indgen! * (shp[0]+1)
+    ref = reshape(shp[0]*shp[1],true)
+    val = NArray.to_na(val)
+    raise ArgumentError, "must be 1-d array" if val.dim!=1
+    ref[idx,true] = val.newdim!(-1)
+    self
+  end
+
+  def diagonal(val)
+    self.dup.diagonal!(val)
+  end
+
+  def unit
+    diagonal!
+  end
+  alias identity unit
+  alias I unit
+
+end # class NMatrix
+
+
+#
+# ------ NVector ------
+#
+class NVector < NArray
+  CLASS_DIMENSION = 1
+
+  def +(other)
+    case other
+    when NVector
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :+.to_i )
+      end
+    end
+    raise TypeError,"Illegal operation: NVector + %s" % other.class
+  end
+
+  def -(other)
+    case other
+    when NVector
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :-.to_i )
+      end
+    end
+    raise TypeError,"Illegal operation: NVector - %s" % other.class
+  end
+
+  def *(other)
+    case other
+    when NMatrix
+      NVector.mul_add( NArray.refer(self).newdim!(0), other, 1 )
+    when NVector
+      NArray.mul_add( NArray.refer(self), other, 0 ) # inner product
+    when NArray
+      if other.instance_of?(NArray)
+	NVector.mul( NArray.refer(self), other.newdim(0) )
+      else
+	other.coerce_rev( self, :*.to_i )
+      end
+    when Numeric
+      NVector.mul( NArray.refer(self), other )
+    else
+      raise TypeError,"Illegal operation: NVector * %s" % other.class
+    end
+  end
+
+  def /(other)
+    case other
+    when NMatrix
+      other.lu.solve(self)
+    when NVector
+      raise TypeError,"Illegal operation: NVector / %s" % other.class
+    when NArray
+      if other.instance_of?(NArray)
+	NVector.div( NArray.refer(self), other.newdim(0) )
+      else
+	other.coerce_rev( self, :/.to_i )
+      end
+    when Numeric
+      NVector.div( NArray.refer(self), other )
+    else
+      raise TypeError,"Illegal operation: NVector / %s" % other.class
+    end
+  end
+
+  def **(n)
+    if n==2
+      self*self
+    else
+      raise ArgumentError,"Only v**2 is implemented"
+    end
+  end
+
+  def coerce_rev(other,id)
+    case id
+    when :*.to_i
+	if other.instance_of?(NArray)
+	  return NVector.mul( other.newdim(0), self )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NVector.mul( other, self )
+	end
+    end
+    raise TypeError,"Illegal operation: %s %s NVector" %
+      [other.class, id.id2name]
+  end
+
+end # class NVector