carray 1.4.0 → 1.5.5

data/spec/Features/method_ref_spec.rb

@@ -0,0 +1,27 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#[]" do
+
+  example "should return one element array with [nil,-1]" do
+    ca = CArray.int(4,4).seq!
+    is_asserted_by { ca[[nil,-1]].elements == 1 }
+    is_asserted_by { ca[[nil,-1]] == ca[[0]] }
+  end
+
+  example "should return self[[0],nil] with [nil,-1], nil" do
+    ca = CArray.int(4,4).seq!
+    is_asserted_by { ca[[nil,-1],nil] == ca[[0],nil] }
+  end
+
+  example "should return self[[0],nil] with nil, [nil,-1]" do
+    ca = CArray.int(4,4).seq!
+    is_asserted_by { ca[nil,[nil,-1]] == ca[nil,[0]] }
+  end
+
+  example "should return self[[0],nil] with [nil,-1], [nil,-1]" do
+    ca = CArray.int(4,4).seq!
+    is_asserted_by { ca[[nil,-1],[nil,-1]] == ca[[0],[0]] }
+  end
+
+end

data/spec/Features/method_round_spec.rb

@@ -0,0 +1,11 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#round" do
+  example "returns the nearest Integer" do
+    is_asserted_by { CA_DOUBLE(5.5).round[0] == 6 }
+    is_asserted_by { CA_DOUBLE(0.4).round[0] == 0 }
+    is_asserted_by { CA_DOUBLE(-2.8).round[0] == -3 }
+    is_asserted_by { CA_DOUBLE(0.0).round[0] == 0 }
+  end
+end

data/spec/Features/method_s_linspace_spec.rb

@@ -0,0 +1,48 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray.linspace" do
+
+  # 2020-07-10
+  example "float range" do
+
+    a = CArray.linspace(0.0,1.0)
+    b = CArray.double(100).span(0.0..1.0)
+    
+    is_asserted_by { a == b }
+
+  end
+
+  # 2020-07-10
+  example "integer range -> float array" do
+
+    a = CArray.linspace(0,1)
+    b = CArray.double(100).span(0.0..1.0)
+    
+    is_asserted_by { a == b }
+
+  end
+
+  # 2020-07-10
+  example "specify number" do
+
+    a = CArray.linspace(0.0,1.0,5)
+    b = CArray.double(5).span(0.0..1.0)
+    
+    is_asserted_by { a == b }
+
+  end
+
+  # 2020-07-10
+  example "integer array" do
+
+    a = CArray::Int32.linspace(0.0,1.0)
+    b = CArray.int32(100).span(0.0..1.0)
+    
+    is_asserted_by { a == b }
+
+  end
+
+  
+end
+  

data/spec/Features/method_s_span_spec.rb

@@ -0,0 +1,14 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CArray.span" do
+
+  # 2020-07-22
+  example "s_span" do
+    a = CArray.span(CA_FLOAT32, 0..2, 0.5)
+    is_asserted_by { a == CA_FLOAT32([0, 0.5, 1, 1.5, 2]) }
+    a = CArray.span(CA_FLOAT32, 0...2, 0.5)
+    is_asserted_by { a == CA_FLOAT32([0, 0.5, 1, 1.5]) }
+  end
+
+end

data/spec/Features/method_seq_spec.rb

@@ -0,0 +1,47 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#seq" do
+  
+  example "basic" do
+    res = CA_INT32([[0, 1, 2],
+                    [3, 4, 5],
+                    [6, 7, 8]])
+    a = CArray.int32(3, 3)
+    is_asserted_by { a.seq(0,1) == res }
+    is_asserted_by { a.seq(0) == res }
+    is_asserted_by { a.seq() == res }
+  end
+
+  example "offset" do
+    res = CA_INT32([[3, 4, 5],
+                    [6, 7, 8],
+                    [9, 10, 11]])
+    a = CArray.int32(3, 3)
+    is_asserted_by { a.seq(3,1) == res }
+    is_asserted_by { a.seq(3) == res }
+  end
+
+  example "step" do
+    res = CA_INT32([[0, 3, 6],
+                    [9, 12, 15],
+                    [18, 21, 24]])
+    a = CArray.int32(3, 3)
+    is_asserted_by { a.seq(0,3) == res }
+  end
+
+  example "fractional step for integer" do
+    res = CA_INT32([0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5])
+    a = CArray.int32(11)
+    is_asserted_by { a.seq(0,0.5) == res }
+
+    res = CA_INT32([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2])
+    a = CArray.int32(11)
+    is_asserted_by { a.seq(0,0.2) == res }
+
+    res = CA_INT32([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+    a = CArray.int32(11)
+    is_asserted_by { a.seq(0,0.1) == res }
+  end
+
+end

data/spec/Features/method_sort_with.rb

@@ -0,0 +1,43 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#sort_with" do
+
+  # 2020-07-09
+  example "basic" do
+   
+    a1 = CA_INT([3,2,4,1])
+    b1 = CA_INT([13,12,14,11])
+    c1 = CA_INT([23,22,24,21])
+    
+    a2,b2,c2 = a1.sort_with(b1,c1)
+    
+    is_asserted_by { a2 == CA_INT([1,2,3,4]) }
+    is_asserted_by { b2 == CA_INT([11,12,13,14]) }
+    is_asserted_by { c2 == CA_INT([21,22,23,24]) }
+
+    a2[0] = -999    
+    b2[0] = -999    
+    c2[0] = -999    
+    is_asserted_by { a1[3] != -999 }
+    is_asserted_by { b1[3] != -999 }
+    is_asserted_by { c1[3] != -999 }
+    
+  end
+
+  example "technique: reverse sort" do
+   
+    a1 = CA_INT([3,2,4,1])
+    b1 = CA_INT([13,12,14,11])
+    c1 = CA_INT([23,22,24,21])
+    
+    _,a2,b2,c2 = (-a1).sort_with(a1,b1,c1)
+    
+    is_asserted_by { a2 == CA_INT([1,2,3,4]).reverse }
+    is_asserted_by { b2 == CA_INT([11,12,13,14]).reverse }
+    is_asserted_by { c2 == CA_INT([21,22,23,24]).reverse }
+
+  end
+  
+end
+

data/spec/Features/method_sorted_with.rb

@@ -0,0 +1,29 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#sorted_with" do
+
+  # 2020-07-09
+  example "basic" do
+   
+    a1 = CA_INT([3,2,4,1])
+    b1 = CA_INT([13,12,14,11])
+    c1 = CA_INT([23,22,24,21])
+    
+    a2,b2,c2 = a1.sorted_with(b1,c1)
+    
+    is_asserted_by { a2 == CA_INT([1,2,3,4]) }
+    is_asserted_by { b2 == CA_INT([11,12,13,14]) }
+    is_asserted_by { c2 == CA_INT([21,22,23,24]) }
+    
+    a2[0] = -999    
+    b2[0] = -999    
+    c2[0] = -999    
+    is_asserted_by { a1[3] == -999 }
+    is_asserted_by { b1[3] == -999 }
+    is_asserted_by { c1[3] == -999 }
+    
+  end
+  
+end
+

data/spec/Features/method_span_spec.rb

@@ -0,0 +1,42 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#span" do
+
+  # 2020-07-10
+  example "integer range (integer steps)" do
+
+    a = CArray.int(10).span(1..10)
+    
+    is_asserted_by { a == CA_INT([1,2,3,4,5,6,7,8,9,10]) }
+
+    b = CArray.int(10).span(1...11)
+    
+    is_asserted_by { b == CA_INT([1,2,3,4,5,6,7,8,9,10]) }
+
+  end
+
+  # 2020-07-10
+  example "integer range (fraction steps)" do
+
+    a = CArray.int(10).span(1..5)
+    
+    is_asserted_by { a == CA_INT([1,1,2,2,3,3,4,4,5,5]) }
+
+    b = CArray.int(10).span(1...6)
+    
+    is_asserted_by { b == CA_INT([1,1,2,2,3,3,4,4,5,5]) }
+
+  end
+
+  # 2020-07-10
+  example "float range" do
+
+    a = CArray.double(11).span(0..5)
+    
+    is_asserted_by { a == CA_DOUBLE([0.0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0]) }
+
+  end
+  
+end
+  

data/spec/Features/method_wrap_readonly_spec.rb

@@ -0,0 +1,43 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CArray#wrap_readonly" do
+
+  # 2020-07-22
+  example "array" do
+    ary = [[1,2,3], 
+           [4,5,6],
+           [7,8,9]]
+    a = CArray.wrap_readonly(ary, CA_INT32)
+    is_asserted_by { a.class == CAFake }
+    is_asserted_by { a.entity? == false }
+    is_asserted_by { a.data_type == CA_INT32 }
+    is_asserted_by { a.shape == [3,3] }
+    is_asserted_by { a == CA_INT32(ary) }
+  end
+
+  # 2020-07-22
+  example "string" do
+    a = CA_UINT8([0,1,2,3,4,5,6,7])
+    b = CArray.wrap_readonly(a.to_s, CA_UINT8)
+    is_asserted_by { b == a }
+
+    c = CArray.wrap_readonly(a.to_s, CA_OBJECT)
+    is_asserted_by { c == CA_OBJECT(a.to_s) }
+  end
+
+  # 2020-07-22
+  example "nil" do
+    a = CA_INT(0)
+    b = CArray.wrap_readonly(nil, CA_INT)
+    is_asserted_by { b == a }
+  end
+
+  # 2020-07-22
+  example "object" do
+    a = CA_FLOAT64(1.5)
+    b = CArray.wrap_readonly(1.5, CA_FLOAT64)
+    is_asserted_by { b == a }
+  end
+
+end

data/spec/spec_all.rb

@@ -1,7 +1,6 @@
 dirname = File.dirname(__FILE__)
 $:.unshift(File.join(dirname, "..", "lib"))
 
-
 require "carray"
   
 Dir.chdir(File.dirname(__FILE__)) {

data/utils/convert_test.rb

@@ -0,0 +1,73 @@
+require 'parser/current'
+require 'unparser'
+
+module YourHelper
+  def s(type, *children)
+    Parser::AST::Node.new(type, children)
+  end
+end
+
+include YourHelper
+
+while line = gets
+  if line =~ /require .test\/unit./ or line =~ /\$\:\.unshift/
+    next
+  end
+  line.gsub!(/(require .carray.\s*$)/, %{\\1require "rspec-power_assert"})
+  line.gsub!(/class (Test.*)\s*<\s*Test::Unit::TestCase/, 'describe "\1" do')
+  line.gsub!(/def test_(.*)/, 'example "\1" do')
+  line.gsub!(/\A(\s*)(assert_raise\((.*)\))\s*{(.*)}/, "\\1expect {\\4}.to raise_error(\\3)")
+  line.gsub!(/\A(\s*)assert_nothing_raised\s*{(.*)}/, "\\1expect {\\2}.not_to raise_error()")
+
+  if line =~ /\A(\s*)(assert_equal\(.*\))\s*\z/
+    prespc = $1
+    body   = $2
+    ast = Unparser.parse(body)
+    newast = s(:block,
+                s(:send, nil, :is_asserted_by),
+                s(:args),
+                s(:send,
+                  ast.children[2], :==,
+                  ast.children[3]))
+    conv = Unparser.unparse(newast).dup # => 'your(ruby(code))'
+    conv.gsub!(/do\n\s*/, "{ ")
+    conv.gsub!(/\n\s*end/, " }")
+    line = prespc + conv
+  end
+  line.gsub!(/assert_equal\(/, 'is_asserted_by { ')
+
+  if line =~ /\A(\s*)(assert_not_equal\(.*\))/
+    prespc = $1
+    body   = $2
+    ast = Unparser.parse(body)
+    newast = s(:block,
+                s(:send, nil, :is_asserted_by),
+                s(:args),
+                s(:send,
+                  ast.children[2], :!=,
+                  ast.children[3]))
+    conv = Unparser.unparse(newast).dup # => 'your(ruby(code))'
+    conv.gsub!(/do\n\s*/, "{ ")
+    conv.gsub!(/\n\s*end/, " }")
+    line = prespc + conv
+  end
+
+  if line =~ /\A(\s*)(assert_instance_of\(.*\))/
+    prespc = $1
+    body   = $2
+    ast = Unparser.parse(body)
+    newast = s(:block,
+                s(:send, nil, :is_asserted_by),
+                s(:args),
+                s(:send,
+                  s(:send,
+                    ast.children[3], :class), :==,
+                      ast.children[2]))
+    conv = Unparser.unparse(newast).dup # => 'your(ruby(code))'
+    conv.gsub!(/do\n\s*/, "{ ")
+    conv.gsub!(/\n\s*end/, " }")
+    line = prespc + conv
+  end
+
+  puts line
+end

data/utils/{extract_rdoc.rb → extract_yard.rb}

@@ -1,27 +1,22 @@
 
-puts %{
-class CArray
-end
-class CScalar
-end
-module CA
-end
-}
-
 Dir["*.c"].each do |file|
   open(file) { |io|
     while line = io.gets
-      if line =~ /\A\s*\/\*\s*rdoc:/
+      if line =~ /\A\s*\/\*\s*(@overload\s+(.*))$/
+        method_spec = $2
+        #        puts "  # " + line
         while line = io.gets
           case line
           when /\A\s*\*\//
+            puts "  def " + method_spec
+            puts "  end"
             break
           else
-            print line
+            print "  # " + line
           end
         end
         puts
       end
     end
-}
+  }
 end

data/utils/{diff_method.rb → monkey_patch_methods.rb}

@@ -7,8 +7,6 @@ class_list = [
   Numeric,
   Float,
   Integer,
-  Bignum,
-  Fixnum,
   Rational,
 ]
 
@@ -23,6 +21,7 @@ class_list.each do |klass|
   orig_s[klass] = klass.singleton_methods
 end
 
+$CARRAY_NO_AUTOLOAD = true
 require "carray"
 
 class_list.each do |klass|
@@ -38,15 +37,26 @@ end
 cnst_intr = (Object.constants - cnst_orig)
 
 require "pp"
-pp (cnst_intr.sort)
 
+puts "Global Constants"
+puts "----------"
+pp (cnst_intr.sort)
+puts
 
 class_list.each do |klass|
-  puts klass
-  p intr[klass].sort
-  p intr_s[klass].sort
+  puts "#{klass}"
+  puts "----------"
+  unless intr_s[klass].empty?
+    puts "### Singleton Methods"
+    pp intr_s[klass].sort 
+  end
+  unless intr[klass].empty?
+    puts "### Instance Methods"
+    pp intr[klass].sort
+  end
+  puts
 end
 
-p CA.singleton_methods.sort
+#pp CA.singleton_methods.sort