narray-convolve 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c96997545f196ef2e81ca16ead2bfcd79023e417bf37cd8afc52bee6a2375990
-  data.tar.gz: b9f17105c3accb3eebe697562b35eb81dae9053d958dc69277cdd3f8f93c191b
+  metadata.gz: bf62c9359db179d212da6a852c5f8424e8d3bb1c00f80f27cc1239299b199a8e
+  data.tar.gz: 721e8321d0aa9a25cfe16858aadc65e71f15b06f6641f2991f1dccee20049d69
 SHA512:
-  metadata.gz: '0024721187219f45ec1a87b0b182d978bd86e245bed7045b35de02c56289d56e734b6a0b5a0cf144dbc1c1744b21ab7e176fa8bcdd03b3dc5f68cf10957748dc'
-  data.tar.gz: 5be09f6ac1dfb5a5cef1b0e46681482cca2af24c5a803757e0409ea3fd0a4bfc8e78eeee42eb685b53988c6a1edcaecd8e6861bf54f71e5440d8d05e03dc547e
+  metadata.gz: 16ef98924a5a72077e8a6df22e233d40e64304fd148f592dc09f62ce7bb37a6f07e0e2a86c8af17bbb71f26682ee647daf66b8e6b5efb1ed930d4ac280fd5220
+  data.tar.gz: 02c7f51d8805acf72658df1987554a796b45e9eaf90561d68de5be71ee724909b7a948708a810afa1a8d8fc9805dc297835197b762bb3260c210ee76e9d08e76

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/narray-convolve.svg)](https://badge.fury.io/rb/narray-convolve)
+
 # Narray::Convolve
 
 Narray::Convolve is returns the discrete, linear convolution of two one-dimensional sequences.

data/lib/narray/convolve.rb

@@ -1,44 +1,102 @@
-# frozen_string_literal: true
-
-require_relative "convolve/version"
-require "numo/narray"
-
-module Narray
-  module Convolve
-    
-    def convolve(n, m, mode = :full)
-      zero_size = m.size - 1
-      out_size = zero_size + n.size
-      n_end = out_size - 1
-      work_size = out_size + zero_size
-
-      out = Numo::DFloat.zeros(out_size)
-      work = Numo::DFloat.zeros(work_size)
-      work[zero_size..n_end].store(n[true])
-
-      work_size.times do |i|
-        w = i + zero_size
-        if w < work_size
-          mul = work[i..w] * m
-          out[i] = mul.sum
-        end
-      end
-
-      case mode
-      when :full # full: (N+M-1)
-        ans = out[true]
-      when :same # same: [M,N].max
-        s = (m.size / 2.0).round - 1
-        e = s + n.size
-        ans = out[s...e]
-      when :valid # valid: [M,N].max - [M,N].min + 1
-        s = zero_size
-        e = m.size
-        ans = out[s..-e]
-      end
-      ans
-    end
-    module_function :convolve    
-  end
-end
-
+# frozen_string_literal: true
+
+require_relative "convolve/version"
+require "numo/narray"
+
+module Narray
+  module Convolve
+    # ======================================
+    # 
+    # Narray::Convolve is similar to numpy.convolve, 
+    # but with a different order of second arguments.
+    #
+    # @example
+
+    # Narray::Convolve
+    # ```
+    # require "narray/convolve"
+    # n = Numo::DFloat[1,2,3]
+    # m = Numo::DFloat[0,1,0.5].reverse
+    # Narray::Convolve.convolve(n, m, :same)
+    # => [1, 2.5, 4]
+    # 
+    # or 
+    # 
+    # Narray::Convolve.convolve([1,2,3], [0,1,0.5].reverse, :same)
+    # => [1, 2.5, 4]
+    # ```
+    # 
+    # numpy.convolve
+    # ```
+    # >>> numpy.convolve([1,2,3],[0,1,0.5], 'same')
+    # array([1. , 2.5, 4. ])
+    # ```
+    # 
+    # ======================================
+    # 
+    # @param: 
+    #       n: (Numo::NArray, DFloat)
+    #       m: (Numo::NArray, DFloat)
+    #       mode: (Symbol) {:full, :same, :valid} 
+    #
+    # @Return: (Numo::NArray, DFloat)
+    #      convolution of n and m.
+    #
+    def convolve(n, m, mode = :full)
+      case n
+      when Array
+        n = Numo::DFloat.cast(n)
+      when Numo::DFloat
+        # ok
+      else
+        raise ArgumentError, "not Numo::DFloat: #{n.inspect[0..48]}"
+      end
+
+      case m
+      when Array
+        m = Numo::DFloat.cast(m)
+      when Numo::DFloat
+        # ok
+      else
+        raise ArgumentError, "not Numo::DFloat: #{n.inspect[0..48]}"
+      end
+
+      n_size = n.size
+      m_size = m.size
+      zero_size = m_size - 1
+      out_size = zero_size + n_size
+      n_end = out_size - 1
+      work_size = out_size + zero_size
+
+      out = Numo::DFloat.zeros(out_size)
+      work = Numo::DFloat.zeros(work_size)
+      work[zero_size..n_end].store(n[true])
+
+      work_size.times do |i|
+        w = i + zero_size
+        if w < work_size
+          out[i] = work[i..w].mulsum(m)
+        end
+      end
+
+      case mode
+      when :full
+        # full: (N+M-1)    
+        ans = out[true]
+      when :same
+        # same: [M,N].max
+        s = (m_size / 2.0).round - 1
+        e = s + n_size
+        ans = out[s...e]
+      when :valid
+        # valid: [M,N].max - [M,N].min + 1
+        s = zero_size
+        e = m_size
+        ans = out[s..-e]
+      end
+      ans
+    end
+    module_function :convolve    
+  end
+end
+

data/lib/narray/convolve/version.rb

@@ -2,6 +2,6 @@
 
 module Narray
   module Convolve
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: narray-convolve
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - icm7216