numo-narray/test/bit_test.rb at 55388ac4adae4ee1785daba400c5568d578e97cf · kojix2/numo-narray · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
require_relative "test_helper"

class BitTest < Test::Unit::TestCase
  dtype = Numo::Bit

  test dtype do
    assert { dtype < Numo::NArray }
  end

  procs = [
    [proc{|tp,a| tp[*a] },""],
    [proc{|tp,a| tp[*a][true] },"[true]"],
    [proc{|tp,a| tp[*a][0..-1] },"[0..-1]"]
  ]
  procs.each do |init, ref|

    test "#{dtype},[0,1,1,0,1,0,0,1]#{ref}" do
      src = [0,1,1,0,1,0,0,1]
      n = src.size
      a = init.call(dtype, src)

      assert { a == src }
      assert { (a & 0) == [0] * n }
      assert { (a & 1) == src }
      assert { (a | 0) == src }
      assert { (a | 1) == [1] * n }
      assert { (a ^ 0) == src.map {|x| x ^ 0 } }
      assert { (a ^ 1) == src.map {|x| x ^ 1 } }
      assert { ~a == src.map {|x| 1 - x } }

      assert { a.count_true == 4 }
      assert { a.count_false == 4 }
      assert { a.where == [1,2,4,7] }
      assert { a.where2 == [[1,2,4,7], [0,3,5,6]] }
      assert { a.mask(Numo::DFloat[1,2,3,4,5,6,7,8]) == [2,3,5,8] }
      assert { !a.all? }
      assert { a.any? }
      assert { !a.none? }
    end
  end

  procs = [
    [proc{|tp,a| tp[*a] },""],
    [proc{|tp,a| tp[*a][true,0..-1] },"[true,true]"],
  ]
  procs.each do |init, ref|

    test "#{dtype},[[0,1,1,0],[1,0,0,1]]#{ref}" do
      src = [[0,1,1,0],[1,0,0,1]]
      n = src.size
      a = init.call(dtype, src)

      assert { a[5] == 0 }
      assert { a[-1] == 1 }
      assert { a[1,0] == src[1][0] }
      assert { a[1,1] == src[1][1] }
      assert { a[1,2] == src[1][2] }
      assert { a[3..4] == [0,1] }
      assert { a[0,1..2] == [1,1] }
      assert { a[0,:*] == src[0] }
      assert { a[1,:*] == src[1] }
      assert { a[:*,1] == [src[0][1], src[1][1]] }

      assert { a.count_true == 4 }
      assert { a.count_false == 4 }
      assert { a.where == [1,2,4,7] }
      assert { a.where2 == [[1,2,4,7],[0,3,5,6]] }
      assert { a.mask(Numo::DFloat[[1,2,3,4],[5,6,7,8]]) == [2,3,5,8] }
      assert { !a.all? }
      assert { a.any? }
      assert { !a.none? }
    end
  end

  procs = [
    [proc{|tp,a| tp[*a] },""],
  ]
  procs.each do |init, ref|

    test "#{dtype},[]#{ref}" do
      src = []
      n = src.size
      a = init.call(dtype, src)

      assert { a == src }
      assert { (a & 0) == [0] * n }
      assert { (a & 1) == src }
      assert { (a | 0) == src }
      assert { (a | 1) == [1] * n }
      assert { (a ^ 0) == src.map {|x| x ^ 0 } }
      assert { (a ^ 1) == src.map {|x| x ^ 1 } }
      assert { ~a == src.map {|x| 1 - x } }

      assert { a.count_true == 0 }
      assert { a.count_false == 0 }
      assert { a.where == [] }
      assert { a.where2 == [[], []] }
      assert { a.mask(Numo::DFloat[]) == [] }
      assert { !a.all? }
      assert { !a.any? }
      assert { a.none? }
    end

  end

  test "store to view" do
    n=14
    x = Numo::Bit.zeros(n+2,n+2,3)
    ~(x[1..-2, 1..-2, 0].inplace)
    assert { x.where.size == n*n}

    x1 = Numo::Bit.ones(n,n)
    x0 = Numo::Bit.zeros(n,n)
    y0 = Numo::Bit.zeros(n+2,n+2)
    x = Numo::NArray.dstack([x1, x0, x0])
    y = Numo::NArray.dstack([y0, y0, y0])
    y[1..-2, 1..-2, true] = x
    assert { (~y[1..-2, 1..-2, 0]).where.size == 0}
    assert { y[true,true,1].where.size == 0 }
  end

  test "assign nil" do
    x = Numo::RObject.cast([1, 2, 3])
    x[Numo::Bit.cast([0, 1, 0])] = nil
    assert { x.to_a == [1, nil, 3] }
  end

  test "flipped matrices > 6x6" do
    m = Numo::Bit.zeros(7,7)
    m = m.flipud
    m[true, 1] = 1
    assert{ m == [[0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0],
                  [0, 1, 0, 0, 0, 0, 0]] }
  end
end