narray 0.5.9.4

data/src/speed/mul_int.py

@@ -0,0 +1,12 @@
+from mybench import *
+
+a = arrayrange(ARRSZ) # % 1000
+b = arrayrange(ARRSZ) # / 1000
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating c = a*b ..."
+
+def bench_body(a=a,b=b): c=a*b
+
+bench_time(bench_body)

data/src/speed/mul_int.rb

@@ -0,0 +1,9 @@
+require 'mybench'
+
+a, b = bench_int
+
+print "a = "; p a;
+print "b = "; p b;
+
+print "calculating c = a*b ...\n"
+bench_time{ c=a*b }

data/src/speed/mybench.py

@@ -0,0 +1,15 @@
+from Numeric import *
+import time
+
+REPEAT = 100
+ARRSZ = 1000000
+
+def bench_array(type=Float64):
+  return arrayrange(ARRSZ).astype(type)
+
+def bench_time(func,repeat=REPEAT):
+  start = time.clock()
+  for i in range(repeat):
+    func()
+  stop = time.clock()
+  print "  Time: %7.3f sec" % (stop-start)

data/src/speed/mybench.rb

@@ -0,0 +1,31 @@
+require 'narray'
+
+REPEAT = 100
+ARRSZ = 1_000_0000
+T = (RUBY_VERSION<"1.8.0") ? Time : Process
+
+def bench_array(type=Float)
+  [ NArray.new(type,ARRSZ).indgen!,
+    NArray.new(type,ARRSZ).indgen!  ]
+end
+
+def bench_float
+  bench_array(Float)
+end
+
+def bench_int
+  bench_array(Integer)
+end
+
+def bench_complex
+  bench_array(Complex)
+end
+
+def bench_time(n=REPEAT)
+  t1 = T.times.utime
+   for i in 1..n
+     yield
+   end
+  t2 = T.times.utime 
+  puts " Time: %.2f sec\n\n" % [t2-t1]
+end

data/src/speed/solve.m

@@ -0,0 +1,18 @@
+# mesuring performance of Octave
+n = 500;
+m = linspace(0,n*n-1,n*n);
+m = rem(m, n+1) + 1;
+m = reshape(m,n,n);
+x = reshape(linspace(1,n*n,n*n),n,n);
+
+printf ("solving %ix%i matrix...\n",n,n);
+[t1, u1, s1] = cputime ();
+
+y = m \ x;
+
+[t2, u2, s2] = cputime ();
+printf (" Time: %5.2f sec\n", u2 - u1);
+
+#  Time:  6.87 sec, GNU Octave, version 2.0.16 (sparc-sun-solaris2.7).
+#y
+exit

data/src/speed/solve.py

@@ -0,0 +1,16 @@
+from mybench import *
+from LinearAlgebra import *
+
+n = 500
+
+a = reshape(arrayrange(n*n)%(n+1)+1,(n,n)).astype(Float64)
+
+b = reshape(arrayrange(n*n)+1,(n,n)).astype(Float64)
+#b = arrayrange(n).astype(Float64)+1
+
+print "LU factorize & solve %ix%i matrix ..."%(n,n)
+
+def bench_body(a=a,b=b): c=solve_linear_equations(a,b)
+bench_time(bench_body,1)
+
+# Time:   8.120 sec

data/src/speed/solve.rb

@@ -0,0 +1,21 @@
+require 'mybench'
+
+n = 500
+m = NArray.float(n,n).indgen!
+m = m % (n+1) + 1
+m = NMatrix.ref(m).transpose
+x = NMatrix.float(n,n).indgen!(1).transpose
+#x = NVector.float(n).indgen!(1)
+y = 0
+
+puts 'm ='
+p m
+puts 'x ='
+p x
+
+printf "solving  y=x/m ...\n",n,n
+bench_time(1){ y = x/m }
+#  Time: 5.87 sec
+
+puts 'y='
+p y

data/src/test/statistics.rb

@@ -0,0 +1,22 @@
+require "narray"
+include NMath
+
+x = NArray[65, 63, 67, 64, 68, 62, 70, 66, 68, 67, 69, 71]
+y = NArray[68, 66, 68, 65, 69, 66, 68, 65, 71, 67, 68, 70]
+
+def test str, x, y=nil
+  print str," #=> "
+  p eval(str)
+end
+
+test "x",x,y
+test "y",x,y
+test "covariance(x,y)",x,y
+
+a = covariance(x,y)
+
+test "x.stddev",x
+
+test "x.sort",x
+test "x.median",x
+test "(x+y.newrank!(0)).median(0)",x,y

data/src/test/testarray.rb

@@ -0,0 +1,20 @@
+require 'narray'
+
+a = NArray.float(3,3).indgen
+
+p NArray[a,[100,101]]
+
+b = NArray[ [ [ 0.0, 1.0, 2.0 ], 
+              [ 3.0, 4.0, 5.0 ], 
+              [ 6.0, 7.0, 8.0 ] ],
+            [100,101] ]
+p b
+
+a = NArray.float(2,2).indgen
+
+b = NArray[ a,[a] ]
+p b
+
+b = NArray[ [ 0.0, 1.0 ], 
+            [ [ 0.0, 1.0 ] ] ]
+p b

data/src/test/testbit.rb

@@ -0,0 +1,27 @@
+require "narray"
+
+a = NArray.byte(10).indgen!
+
+def test a, str
+  print str," #=>\n"
+  p eval(str)
+end
+
+test a, "a"
+test a, "a & 1"
+test a, "a & 2"
+test a, "a & -1"
+
+test a, "a | 1"
+test a, "a | 2"
+test a, "a | -1"
+
+test a, "a ^ 1"
+test a, "a ^ 2"
+test a, "a ^ -1"
+
+test a, "~a"
+
+a = NArray.int(10).indgen!
+test a, "a"
+test a, "~a"

data/src/test/testcast.rb

@@ -0,0 +1,14 @@
+require 'narray'
+
+def test a,b
+  print a," #=> "
+  p b
+end
+
+a = NArray.int(3,3).indgen!
+
+test "a",a
+test "a+1.5",a+1.5
+test "1.5+a",1.5+a
+test "a+NArray[1.2,3.4,5.6]",a+NArray[1.2,3.4,5.6]
+test "a+NArray[Complex(0.5,1.5)]",a+NArray[Complex(0.5,1.5)]

data/src/test/testcomplex.rb

@@ -0,0 +1,35 @@
+require 'narray'
+
+def testop(a,b)
+  print "a = "; p a
+  print "b = "; p b
+  print "a+b = "; p a+b
+  print "a-b = "; p a-b
+  print "a*b = "; p a*b
+  print "a/b = "; p a/b
+  print "a**b = "; p a**b
+end
+
+a = NArray.complex(4,1).indgen!.sbt!(-1) + 0.25.im
+b = NArray.complex(1,3).indgen!.add!(-0.5).mul!(0.5.im)
+testop(a,b)
+
+# compare a/b with real-number operation
+# a = NArray(4,1).indgen!.sbt!(-1)
+# b = NArray(1,3).fill!(1)
+# c = b*b + b*b
+# p ( (a*b + 0*b)/c )
+# p ( (0*b - a*b)/c )
+
+def testimag(a)
+  print "a.real = "
+  p a.real
+  print "a.imag = "
+  p a.imag
+  print "a.angle = "
+  p a.angle
+  print "a.conj = "
+  p a.conj
+end
+
+testimag a

data/src/test/testfftw.rb

@@ -0,0 +1,16 @@
+require 'narray'
+
+x = NArray.complex(1024,1024).indgen!
+
+p x
+puts 'executing fftw ...'
+t1 = Time.times.utime
+y = FFTW.fftw( x, 1 )
+t2 = Time.times.utime
+print "time: ",t2 - t1,"\n"
+p y
+
+exit
+
+x = NArray.complex(128,128).indgen!
+10000.times{ x = FFTW.fftw( x, 1 ) }

data/src/test/testindex.rb

@@ -0,0 +1,11 @@
+require 'narray'
+
+a = NArray.float(3,3).indgen!
+
+print "a #=> "; p a
+print "a[1, -1] #=> "; p a[1, -1]
+print "a[1, 2..0] #=> "; p a[1, 2..0]
+print "a[1...2, 0..1] #=> "; p a[1...2, 0..1]  # without rank-reduce
+print "a[true, 0..1] #=> "; p a[true, 0..1]
+print "a[0..5] #=> "; p a[0..5]
+

data/src/test/testindexary.rb

@@ -0,0 +1,26 @@
+require 'narray'
+
+a = NArray.new(NArray::DFLOAT,5,5).indgen!
+print "a #=> "; p a
+
+idx = [2,0,1]
+print "\nidx #=> "
+ p idx
+
+print "\na[idx,idx]  # Index Array\n #=> "
+ p a[idx,idx]
+
+idx = NArray.to_na(idx)
+idx += 10
+print "\nidx #=> "
+ p idx
+
+print "\na[idx] #=> "
+ p a[idx]
+
+print "\na[1,[]]  # Empty Array\n #=> "
+ p a[1,[]]
+
+print "\nFollowing will fail...\n\n"
+print "a[idx,0] #=> \n"
+p a[idx,0]

data/src/test/testindexset.rb

@@ -0,0 +1,55 @@
+require 'narray'
+
+a = NArray.float(3,3).indgen!
+
+print "a #=> "; p a
+
+print "\na[[]] = []  # Do nothing \na #=> ";
+a[[]] = []; p a
+
+print "\na[1,1] = 0  # 1-element replace\na #=> ";
+b=a.dup; b[1,1] = 0
+p b
+
+print "\na[0..-1, 1] = 0  # Range replace\na #=> ";
+b=a.dup; b[0..-1, 1] = 0
+p b
+
+print "\na[1,2..0] = [100,101,102]  # Array replace\na #=> ";
+b=a.dup; b[1,2..0] = [100,101,102]
+p b
+
+print "\na[0,1] = [100,101,102]  # Specifing Starting point \na #=> ";
+b=a.dup; b[0,1] = [100,101,102]
+p b
+
+print "\na[1,0] = [[100],[101],[102]]  # Specifing Starting point \na #=> ";
+b=a.dup; b[1,0] = [[100],[101],[102]]
+p b
+
+print "\na[true,1] = [100,101,102]  # `true' means entire range\na #=> ";
+b=a.dup; b[true,1] = [100,101,102]
+p b
+
+print "\na[true,true] = [[100,101,102]] \na #=> ";
+b=a.dup; b[true,true] = [[100,101,102]]
+p b
+
+
+print "\nFollowing will fail ...\n"
+
+print "\na[true,1] = [[100,101,102]] \na #=> ";
+b=a.dup; b[true,1] = [[100,101,102]]
+p b
+
+print "\na[true,1] = [[100],[101],[102]] \na #=> ";
+b=a.dup; b[true,1] = [[100],[101],[102]]
+p b
+
+print "\na[true,true] = [100,101,102] \na #=> ";
+b=a.dup; b[true,true] = [100,101,102]
+p b
+
+print "\na[1,0] = [100,101,102] \na #=> ";
+b=a.dup; b[1,0] = [100,101,102]
+p b

data/src/test/testmask.rb

@@ -0,0 +1,40 @@
+require "narray"
+
+a = NArray.byte(10)
+a[2..4] = 1
+p a.type, a.count_true, a.count_false
+
+begin
+   a = NArray.float(10)
+   a[2..4] = 1
+   p a.type, a.count_true, a.count_false
+rescue
+   print a.type," -- Exception raised as expected. The message was: ", $!,"\n"
+end
+
+#-------------------
+print "\n--- test masking (float) ---\n"
+
+a = NArray.float(5,3).indgen!
+b = (a-2)*2
+c = a.lt(b)
+p c, c.typecode
+
+p a, b, a.mask( c ), a[c]
+
+#a[c] = ( NArray.int(c.length).indgen!+100 )
+#p a
+
+a[c] = 10000
+p a
+
+#-------------------
+print "\n--- test masking (complex) ---\n"
+p a = NArray.complex(5).indgen! + Complex::I
+
+m = NArray.byte(5)
+m[true] = [0,0,1,1,0]
+
+p a[m]
+a[m] = 100.0
+p a

data/src/test/testmath.rb

@@ -0,0 +1,48 @@
+require 'narray'
+include NMath
+
+def pr x
+  x.each{|i|
+    if i.kind_of?(Complex)
+      printf("%.3f%+.3fi ",i.real,i.image)
+    else
+      printf("%.3f ",i)
+    end      
+  }
+  print "\n"
+end
+
+def testmath(x)
+  print "x = "
+  pr x
+  print "sqrt(x) = "
+  pr sqrt(x)
+  print "sin(x) = "
+  pr sin(x)
+  print "cos(x) = "
+  pr cos(x)
+  print "tan(x) = "
+  pr tan(x)
+  print "sinh(x) = "
+  pr sinh(x)
+  print "cosh(x) = "
+  pr cosh(x)
+  print "tanh(x) = "
+  pr tanh(x)
+  print "exp(x) = "
+  pr exp(x)
+  print "log(x) = "
+  pr log(x)
+  print "log10(x) = "
+  pr log10(x)
+  print "atan(x) = "
+  pr atan(x)
+  print "atan(tan(x)) = "
+  pr atan(tan(x))
+end
+
+testmath NArray.sfloat(6).indgen.div!(2)
+testmath NArray.float(6).indgen.div!(2)
+
+testmath NArray.scomplex(6).indgen.div!(2)-2 - 1.im
+testmath NArray.complex(6).indgen!/5-0.5# - 0.3.im

data/src/test/testmath2.rb

@@ -0,0 +1,46 @@
+require "narray"
+include NMath
+
+def testm x,name
+  f = "a#{name}(#{name}(x))"
+  print "\n### #{f} ###\n"
+  y = eval(f)
+  p y
+  #d = x-y
+  #p d.abs
+end
+
+PI=Math::PI
+
+i = NArray.complex(1)
+i.imag=1
+
+n=7
+x = NArray.complex(n).random!(1)
+x.imag= NArray.float(n).random!(1)
+
+p x
+testm x,"sin"
+testm x,"cos"
+testm x,"tan"
+testm x,"sinh"
+testm x,"cosh"
+testm x,"tanh"
+testm x,"sec"
+testm x,"sech"
+
+p cot(1)
+
+exit
+
+a= -i * log( sqrt(1-x**2)*i + x )
+b= -i * log( sqrt(x**2-1) + x )
+p a
+p b
+p a-b
+
+a= -i * log( sqrt(1-x**2) + x*i )
+b= -i * log( (-sqrt(x**2-1) + x)*i )
+p a
+p b
+p a-b

data/src/test/testmatrix.rb

@@ -0,0 +1,13 @@
+require "narray"
+
+m = NMatrix.float(3,3,3).indgen!
+
+puts
+puts 'm  #=>'
+p m			#=> NMatrix.float(3,3,3):
+puts
+puts 'm[1,1,true]  #=>'
+p m[1,1,true]		#=> NArray.float(3): 
+puts
+puts 'm[0..1,2,true]  #=>'
+p m[0..1,2,true]	#=> NMatrix.float(2,1,3): 

data/src/test/testmatrix2.rb

@@ -0,0 +1,33 @@
+require 'narray'
+require 'irb/xmp'
+# xmp :: http://www.ruby-lang.org/en/raa-list.rhtml?name=xmp
+
+m1 = NMatrix.float(2,2).indgen!
+m2 = NMatrix[[0,1.2],[1.5,0]]
+
+v1 = NVector[0.5,1.5]
+v2 = NVector.float(2,2).indgen!
+
+a  = NArray.float(2,2).indgen!
+
+xmp 'm1'
+xmp 'm1.inverse'
+xmp 'm2'
+xmp 'm1*m2'
+xmp 'm2*m1'
+xmp 'm1+m2'
+xmp '3.14*m1'
+xmp 'm2*1.25'
+xmp 'v1'
+xmp 'v2'
+xmp '1.25*v1'
+xmp 'NMath.sqrt(v2**2)'
+xmp 'v1*v2'
+xmp 'm1*v1'
+xmp 'v2*m2'
+xmp 'm1.diagonal([98,99])'
+xmp 'NMatrix.float(4,3).unit'
+
+puts "\n=== following will fail ...\n"
+xmp 'm1+v1'
+xmp 'm1+1'

data/src/test/testmatrix3.rb

@@ -0,0 +1,19 @@
+require 'narray'
+require 'rational'
+
+class Rational
+  def inspect
+    @numerator.to_s+"/"+@denominator.to_s
+  end
+end
+
+srand(1)
+n=5
+
+m = NMatrix.object(n,n).collect{Rational(rand(10))}
+
+puts 'm  #=>'
+p m
+
+puts 'm/m  #=>'
+p m/m

data/src/test/testminmax.rb

@@ -0,0 +1,46 @@
+require 'narray'
+
+def test a
+  print "a = "
+  p a
+  print "a.min = "
+  p a.min
+  print "a.max = "
+  p a.max
+  print "a.sum = "
+  p a.sum
+  print "a.mean = "
+  p a.mean
+  print "a.stddev = "
+  p a.stddev
+end
+
+a = NArray[0,2,-2.5,3,1.4]
+
+test a
+
+a = NArray.float(5,1).indgen!(1)
+b = NArray.float(1,3).indgen!(1)
+a *= b
+test a
+
+print "a.min(0) = "
+p a.min(0)
+print "a.max(0) = "
+p a.max(0)
+print "a.min(1) = "
+p a.min(1)
+print "a.max(1) = "
+p a.max(1)
+print "a.sum(0) = "
+p a.sum(0)
+print "a.sum(1) = "
+p a.sum(1)
+print "a.mean(0) = "
+p a.mean(0)
+print "a.mean(1) = "
+p a.mean(1)
+print "a.stddev(0) = "
+p a.stddev(0)
+print "a.stddev(1) = "
+p a.stddev(1)

data/src/test/testobject.rb

@@ -0,0 +1,29 @@
+require 'narray'
+require 'rational'
+
+n = 4
+a = NArray.object(4,4).fill!(Rational(1))
+b = NArray.object(4,4).indgen!(1).collect{|i| Rational(i)}
+
+print 'a #=> '
+p a
+
+print 'b #=> '
+p b
+
+
+class Rational
+  def inspect
+    self.to_s
+  end
+end
+
+print 'a+b #=> '
+p a+b
+
+
+print 'a/b #=> '
+p a/b
+
+print 'a/b - b #=> '
+p a/b - b

data/src/test/testpow.rb

@@ -0,0 +1,19 @@
+require "narray"
+
+def test a
+  puts 'a = '
+  p  a
+  puts 'a**[[-3],[0],[7]] = '
+  p  a**[[-3],[0],[7]]
+  puts 'a**[[-3.0],[0],[7.0]] = '
+  p  a**[[-3.0],[0],[7.0]]
+  puts 'a**(1+0.im) = '
+  p  a**(1+0.im)
+  puts 'a**1.0 = '
+  p  a**1.0
+  puts
+end
+
+test NArray.int(4).indgen!*2-2
+test NArray.float(4).indgen!*2-2
+test NArray.complex(4).indgen!*2-2

data/src/test/testrandom.rb

@@ -0,0 +1,23 @@
+require 'narray'
+
+def test a
+  print a," #=> "
+  p eval(a)
+  print "\n"
+end
+
+test "NArray.float(5).random(10)"
+
+test "NArray.float(5).random"
+
+test "NArray.int(5).random(10)"
+
+test "NArray.int(1000).random(10)"
+
+a = NArray.int(1000).random(10)
+
+idx = (a.eq 0).where
+print "a.eq 0  :: n=", idx.size, "\n"
+
+idx = (a.eq 10).where
+print "a.eq 10 :: "; p idx