red-arrow-numo-narray 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0af7121f227811b26d39f741e41d202a72dcdea9
-  data.tar.gz: 6b25427045952ac472d248d9aa728541be10ec66
+SHA256:
+  metadata.gz: d3548b4dd13c4472bf84d6a46593328972efd81c81f71fd9c022f7823734ed9c
+  data.tar.gz: 3e6c02abf4ba9827db4ba6f6dc8421a805a20df7c81d2bd050226e6888a768e5
 SHA512:
-  metadata.gz: '009047379e64ca2ef4d67e011045c8ee2e79290fd507815f0433295daf8765d13ca1e52ccdffc26439e98e82847309f0b63f080808adae4d1090b02ebaf17db1'
-  data.tar.gz: 017462754b7a95cc01ac858786e04fb677594ce0711d8b0b71a29e52a3ee4453af79d1bc0f36e0cdd8e972aaa70a8b5ba872d22ef8c3dd3b821f1741e6354f94
+  metadata.gz: 2c6d433d0e3f6738f0e6d8b77b97760d36ac775faa4992ff1f4992f21179cc0439c2aa383cc3044090d54f82e37c968920f3b4ec638a65edb1a73e62c8220cab
+  data.tar.gz: 78f28f991402fd5b3ac96b901e7b7ef230d6459d55f08b3b1f3644a599cd2995aca020615c5f0ea2cc11a039b8529e3ec3e167db619e366f936630aaa58b6aea

data/README.md

@@ -21,8 +21,8 @@ Red Arrow Numo::NArray adds `Arrow::Tensor#to_narray` and `#to_arrow` to `Numo::
 ```ruby
 require "arrow-numo-narray"
 
-tensor.to_narray # -> A Numo::NArray's numeric subclass such as Numo::Int8
-narray.to_arrow  # -> An Arrow::Tensor object
+tensor.to_narray # -> An object of Numo::NArray's numeric subclass such as Numo::Int8
+narray.to_arrow  # -> An object of Arrow::Tensor
 ```
 
 ## Dependencies

data/doc/text/news.md

@@ -1,5 +1,16 @@
 # News
 
+## 0.0.2 - 2019-08-07
+
+### Improvements
+
+  * Added `Arrow::Array#to_narray`.
+    [GitHub#1][Suggested by Kenta Murata]
+
+### Thanks
+
+  * Kenta Murata
+
 ## 0.0.1 - 2017-04-20
 
 Initial release!!!

data/lib/arrow-numo-narray.rb

@@ -17,5 +17,7 @@ require "numo/narray"
 
 require "arrow-numo-narray/version"
 
+require "arrow-numo-narray/error"
+
 require "arrow-numo-narray/to-arrow"
 require "arrow-numo-narray/to-narray"

data/lib/arrow-numo-narray/error.rb

@@ -0,0 +1,21 @@
+# Copyright 2019 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module ArrowNumoNArray
+  class Error < StandardError
+  end
+
+  class UncovertableError < Error
+  end
+end

data/lib/arrow-numo-narray/to-narray.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2019 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -73,6 +73,18 @@ module Arrow
     end
   end
 
+  class Array
+    def to_narray
+      unless n_nulls.zero?
+        message = "can't convert #{self.class} that has null values to NArray"
+        raise UnconvertableError, message
+      end
+      narray = value_data_type.narray_class.new(length)
+      narray.store_binary(buffer.data.to_s)
+      narray
+    end
+  end
+
   class Tensor
     def to_narray
       narray = value_data_type.narray_class.new(shape)

data/lib/arrow-numo-narray/version.rb

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module ArrowNumoNArray
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/test-to-narray.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2019 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,253 +13,317 @@
 # limitations under the License.
 
 class ToNAarrayTest < Test::Unit::TestCase
-  test("Int8") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [-1, -2, -3, -4],
-      ],
-      [
-        [-5, -6, -7, -8],
-        [-9, -10, -11, -12],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt8DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("c*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::Int8.new(shape).store(data),
-                 tensor.to_narray)
-  end
+  sub_test_case("Array") do
+    test("Int8") do
+      array = Arrow::Int8Array.new([-(2 ** 7), 0, 2 ** 7 - 1])
+      assert_equal(Numo::Int8[-(2 ** 7), 0, 2 ** 7 - 1],
+                   array.to_narray)
+    end
 
-  test("Int16") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [-1, -2, -3, -4],
-      ],
-      [
-        [-5, -6, -7, -8],
-        [-9, -10, -11, -12],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt16DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("s*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::Int16.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("Int16") do
+      array = Arrow::Int16Array.new([-(2 ** 15), 0, 2 ** 15 - 1])
+      assert_equal(Numo::Int16[-(2 ** 15), 0, 2 ** 15 - 1],
+                   array.to_narray)
+    end
 
-  test("Int32") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [-1, -2, -3, -4],
-      ],
-      [
-        [-5, -6, -7, -8],
-        [-9, -10, -11, -12],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt32DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("l*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::Int32.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("Int32") do
+      array = Arrow::Int32Array.new([-(2 ** 31), 0, 2 ** 31 - 1])
+      assert_equal(Numo::Int32[-(2 ** 31), 0, 2 ** 31 - 1],
+                   array.to_narray)
+    end
 
-  test("Int64") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [-1, -2, -3, -4],
-      ],
-      [
-        [-5, -6, -7, -8],
-        [-9, -10, -11, -12],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt64DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("q*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::Int64.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("Int64") do
+      array = Arrow::Int64Array.new([-(2 ** 63), 0, 2 ** 63 - 1])
+      assert_equal(Numo::Int64[-(2 ** 63), 0, 2 ** 63 - 1],
+                   array.to_narray)
+    end
 
-  test("UInt8") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      [
-        [17, 18, 19, 20],
-        [21, 22, 23, 24],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt8DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("C*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::UInt8.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("UInt8") do
+      array = Arrow::UInt8Array.new([0, 2 ** 8 - 1])
+      assert_equal(Numo::UInt8[0, 2 ** 8 - 1],
+                   array.to_narray)
+    end
 
-  test("UInt16") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      [
-        [17, 18, 19, 20],
-        [21, 22, 23, 24],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt16DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("S*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::UInt16.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("UInt16") do
+      array = Arrow::UInt16Array.new([0, 2 ** 16 - 1])
+      assert_equal(Numo::UInt16[0, 2 ** 16 - 1],
+                   array.to_narray)
+    end
 
-  test("UInt32") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      [
-        [17, 18, 19, 20],
-        [21, 22, 23, 24],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt32DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("L*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::UInt32.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("UInt32") do
+      array = Arrow::UInt32Array.new([0, 2 ** 32 - 1])
+      assert_equal(Numo::UInt32[0, 2 ** 32 - 1],
+                   array.to_narray)
+    end
 
-  test("UInt64") do
-    data = [
-      [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      [
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      [
-        [17, 18, 19, 20],
-        [21, 22, 23, 24],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::UInt64DataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("Q*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::UInt64.new(shape).store(data),
-                 tensor.to_narray)
-  end
+    test("UInt64") do
+      array = Arrow::UInt64Array.new([0, 2 ** 64 - 1])
+      assert_equal(Numo::UInt64[0, 2 ** 64 - 1],
+                   array.to_narray)
+    end
+
+    test("Float") do
+      array = Arrow::FloatArray.new([-1.1, 0, 1.1])
+      assert_equal(Numo::SFloat[-1.1, 0, 1.1],
+                   array.to_narray)
+    end
 
-  test("Float") do
-    data = [
-      [
-        [1.0, 2.0, 3.0, 4.0],
-        [5.0, 6.0, 7.0, 8.0],
-      ],
-      [
-        [9.0, 10.0, 11.0, 12.0],
-        [13.0, 14.0, 15.0, 16.0],
-      ],
-      [
-        [17.0, 18.0, 19.0, 20.0],
-        [21.0, 22.0, 23.0, 24.0],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::FloatDataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("f*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::SFloat.new(shape).store(data),
-                 tensor.to_narray)
+    test("Double") do
+      array = Arrow::DoubleArray.new([-1.1, 0, 1.1])
+      assert_equal(Numo::DFloat[-1.1, 0, 1.1],
+                   array.to_narray)
+    end
   end
 
-  test("Double") do
-    data = [
-      [
-        [1.0, 2.0, 3.0, 4.0],
-        [5.0, 6.0, 7.0, 8.0],
-      ],
-      [
-        [9.0, 10.0, 11.0, 12.0],
-        [13.0, 14.0, 15.0, 16.0],
-      ],
-      [
-        [17.0, 18.0, 19.0, 20.0],
-        [21.0, 22.0, 23.0, 24.0],
-      ],
-    ]
-    shape = [3, 2, 4]
-    tensor = Arrow::Tensor.new(Arrow::DoubleDataType.new,
-                               Arrow::Buffer.new(data.flatten.pack("d*")),
-                               shape,
-                               nil,
-                               nil)
-    assert_equal(Numo::DFloat.new(shape).store(data),
-                 tensor.to_narray)
+  sub_test_case("Tensor") do
+    test("Int8") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [-1, -2, -3, -4],
+        ],
+        [
+          [-5, -6, -7, -8],
+          [-9, -10, -11, -12],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::Int8DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("c*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::Int8.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("Int16") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [-1, -2, -3, -4],
+        ],
+        [
+          [-5, -6, -7, -8],
+          [-9, -10, -11, -12],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::Int16DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("s*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::Int16.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("Int32") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [-1, -2, -3, -4],
+        ],
+        [
+          [-5, -6, -7, -8],
+          [-9, -10, -11, -12],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::Int32DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("l*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::Int32.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("Int64") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [-1, -2, -3, -4],
+        ],
+        [
+          [-5, -6, -7, -8],
+          [-9, -10, -11, -12],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::Int64DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("q*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::Int64.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("UInt8") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [13, 14, 15, 16],
+        ],
+        [
+          [17, 18, 19, 20],
+          [21, 22, 23, 24],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::UInt8DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("C*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::UInt8.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("UInt16") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [13, 14, 15, 16],
+        ],
+        [
+          [17, 18, 19, 20],
+          [21, 22, 23, 24],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::UInt16DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("S*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::UInt16.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("UInt32") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [13, 14, 15, 16],
+        ],
+        [
+          [17, 18, 19, 20],
+          [21, 22, 23, 24],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::UInt32DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("L*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::UInt32.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("UInt64") do
+      data = [
+        [
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+        ],
+        [
+          [9, 10, 11, 12],
+          [13, 14, 15, 16],
+        ],
+        [
+          [17, 18, 19, 20],
+          [21, 22, 23, 24],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::UInt64DataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("Q*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::UInt64.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("Float") do
+      data = [
+        [
+          [1.0, 2.0, 3.0, 4.0],
+          [5.0, 6.0, 7.0, 8.0],
+        ],
+        [
+          [9.0, 10.0, 11.0, 12.0],
+          [13.0, 14.0, 15.0, 16.0],
+        ],
+        [
+          [17.0, 18.0, 19.0, 20.0],
+          [21.0, 22.0, 23.0, 24.0],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::FloatDataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("f*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::SFloat.new(shape).store(data),
+                   tensor.to_narray)
+    end
+
+    test("Double") do
+      data = [
+        [
+          [1.0, 2.0, 3.0, 4.0],
+          [5.0, 6.0, 7.0, 8.0],
+        ],
+        [
+          [9.0, 10.0, 11.0, 12.0],
+          [13.0, 14.0, 15.0, 16.0],
+        ],
+        [
+          [17.0, 18.0, 19.0, 20.0],
+          [21.0, 22.0, 23.0, 24.0],
+        ],
+      ]
+      shape = [3, 2, 4]
+      tensor = Arrow::Tensor.new(Arrow::DoubleDataType.new,
+                                 Arrow::Buffer.new(data.flatten.pack("d*")),
+                                 shape,
+                                 nil,
+                                 nil)
+      assert_equal(Numo::DFloat.new(shape).store(data),
+                   tensor.to_narray)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow-numo-narray
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-20 00:00:00.000000000 Z
+date: 2019-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -127,6 +127,7 @@ files:
 - doc/text/apache-2.0.txt
 - doc/text/news.md
 - lib/arrow-numo-narray.rb
+- lib/arrow-numo-narray/error.rb
 - lib/arrow-numo-narray/to-arrow.rb
 - lib/arrow-numo-narray/to-narray.rb
 - lib/arrow-numo-narray/version.rb
@@ -155,13 +156,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Red Arrow Numo::NArray is a library that provides converters between Apache
   Arrow's tensor data (`Arrow::Tensor`) and Numo::NArray data.
 test_files:
-- test/test-to-narray.rb
-- test/test-to-arrow.rb
 - test/helper.rb
 - test/run-test.rb
+- test/test-to-arrow.rb
+- test/test-to-narray.rb