differentiation 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f929d2f761f2c899c992ee5c1c5298c9309571832e53785b05fa363ee8e7184
-  data.tar.gz: 83ee712e1b681bbf9ce607ba14e6fdb2bc5b03e5e54fc6345711a94011abba12
+  metadata.gz: ac6ecb62757c2673747b141af828086090e2cc42addb0ae5445503908f108f47
+  data.tar.gz: 39b075aca09020073e28b34aced45567b41a92bd9ddd755e2de60515ecd4299e
 SHA512:
-  metadata.gz: 22129a89a99a38eed921c69e8b84e7da61c6a89e102b9e8090d35faf2e8bc8b81df404f894f3e002fb43f65f8e06a49d30784962ff8039a3b6bee35b222cc0d1
-  data.tar.gz: 3f1c0c90283778a6a7add7cbbc4b61f07bce594aeb84241a80e0bb56b03345d42ec39b981aa016d9b09c2945221169b5d28b9ecabd78712415d8d717f3547e4f
+  metadata.gz: 6971cae699fbcdb58f86d36cb1e92908dec436d270d4f99d04c1480826674dbc016955510bf3172b96a924691c2fb9cdee2f9c895939742f239465ce24100fb3
+  data.tar.gz: e7d079380efccc25f93be4331f9e5ee18df5bb78b3f70cfc678ec43720439c77f76639bdff178627f8c99a0557c17a2e80a5a6078af8e6616c769c757c6a3db7

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Tomoyuki Chikanaga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/differentiation.rb

@@ -1,24 +1,43 @@
 # fronzen_string_literal: true
 
+require "differentiation/dual_number"
+
 module Differentiation
 
   def self.differentiable?(o)
-    # TODO: support Vector and Matrix
-    o.is_a?(Numeric)
+    o.is_a?(Numeric) or (defined?(Matrix) and o.is_a?(Matrix))
   end
 
-  def self.convert_to_dual_number(o, key: nil)
+  def self.convert_to_dual_number(o, key: nil, named_variables: {})
     if o.is_a?(DualNumber)
-      o
+      if key and o.named_variables.empty?
+        DualNumber.new(o.n, o.diff, key: key)
+      else
+        o
+      end
     elsif differentiable?(o)
-      DualNumber.new(o, lambda{|_key| _key == key ? 1 : 0})
+      if defined?(Matrix) and o.is_a?(Matrix)
+        if key
+          vars = Matrix.build(o.row_size, o.column_size){ nil }
+          named_variables = { key => vars }
+        end
+        Matrix.build(o.row_size, o.column_size) do |i, j|
+          v = self.convert_to_dual_number(o[i, j], named_variables: named_variables)
+          if key
+            vars.__send__(:[]=, i, j, v)
+          end
+          v
+        end
+      else
+        DualNumber.new(o, key: key, named_variables: named_variables)
+      end
     else
       o
     end
   end
 
   def self.differential(f)
-    unless f.is_a?(Proc) or f.is_a?(Method)
+    unless f.is_a?(Proc) or f.is_a?(Method) or f.is_a?(UnboundMethod)
       raise TypeError, "Only Proc or Method can be differentiable"
     end
 
@@ -35,6 +54,9 @@ module Differentiation
       end
     end
     f_prime = lambda {|*args, **kwargs|
+      if f.is_a?(UnboundMethod)
+        f = f.bind(self)
+      end
       args.map!.with_index do |a, i|
         Differentiation.convert_to_dual_number(a, key: positional[i])
       end
@@ -46,119 +68,9 @@ module Differentiation
       end
     }
   end
-
-  class DualNumber
-    include Comparable
-
-    def initialize(n, diff=lambda{|_| 0})
-      @n = n
-      @diff = diff
-    end
-
-    attr_reader :n, :diff
-
-    def derivative(key)
-      @diff.call(key)
-    end
-
-    def gradients(*keys)
-      keys.each_with_object({}) do |k, o|
-        o[k] = @diff.call(k)
-      end
-    end
-
-    def to_i
-      @n.to_i
-    end
-
-    def to_int
-      @n.to_int
-    end
-
-    def to_f
-      @n.to_f
-    end
-
-    def coerce(other)
-      if Differentiation.differentiable?(other)
-        [DualNumber.new(other), self]
-      else
-        super
-      end
-    end
-
-    def <=>(other)
-      if other.is_a?(DualNumber)
-        @n <=> other.n
-      else
-        @n <=> other
-      end
-    end
-
-    def +(other)
-      if other.is_a?(DualNumber)
-        n = @n + other.n
-        diff = ->(key) { @diff.call(key) + other.diff.call(key) }
-      else
-        n = @n + other
-        diff = @diff
-      end
-      DualNumber.new(n, diff)
-    end
-
-    def -(other)
-      if other.is_a?(DualNumber)
-        n = @n - other.n
-        diff = ->(key) { @diff.call(key) - other.diff.call(key) }
-      else
-        n = @n - other
-        diff = @diff
-      end
-      DualNumber.new(n, diff)
-    end
-
-    def *(other)
-      if other.is_a?(DualNumber)
-        n = @n * other.n
-        diff = ->(key) { @n * other.diff.call(key) + @diff.call(key) * other.n }
-      else
-        n = @n * other
-        diff = ->(key) { @diff.call(key) * other }
-      end
-      DualNumber.new(n, diff)
-    end
-
-    def /(other)
-      if other.is_a?(DualNumber)
-        n = @n / other.n
-        diff = ->(key) { (@diff.call(key) / other) + (@n * other.diff.call(key)) / (other.n ** 2) }
-      else
-        n = @n / other
-        diff = ->(key) { @diff.call(key) / other }
-      end
-      DualNumber.new(n, diff)
-    end
-
-    def **(other)
-      if other.is_a?(DualNumber)
-        n = @n ** other.n
-        diff = ->(key) { (@n ** other.n) * (other.diff.call(key) * Math.log(@n) + (other.n / @n)) }
-      else
-        n = @n ** other
-        diff = ->(key) { ((@n ** (other-1)) * other) * @diff.call(key) }
-      end
-      DualNumber.new(n, diff)
-    end
-
-    def inspect
-      if $DEBUG
-        "<DualNumber: #{@n} >"
-      else
-        @n.inspect
-      end
-    end
-  end
 end
 
 require "differentiation/ext/kernel"
+require "differentiation/ext/integer"
+require "differentiation/ext/float"
 

data/lib/differentiation/dual_number.rb

@@ -0,0 +1,168 @@
+# fronzen_string_literal: true
+
+module Differentiation
+  class DualNumber
+    include Comparable
+
+    def initialize(n, diff=lambda{|var| var.equal?(self) ? 1.0 : 0.0 }, named_variables: {}, key: nil)
+      @n = n
+      @diff = diff
+      if key
+        @named_variables = { key => self }.freeze
+      else
+        @named_variables = named_variables.dup.freeze
+      end
+    end
+
+    attr_reader :n, :diff, :named_variables
+
+    def derivative(var)
+      if var.equal?(self)
+        1.0
+      else
+        @diff.call(var)
+      end
+    end
+
+    def gradients(*keys)
+      keys = keys.flatten(1)
+      return_hash = false
+      if keys.empty?
+        return_hash = true
+        keys = @named_variables.keys
+        vars = @named_variables.values
+      else
+        vars = keys.map do |k|
+          if k.is_a?(DualNumber) or (defined?(::Matrix) and k.is_a?(Matrix))
+            k
+          else
+            @named_variables[k]
+          end
+        end
+      end
+      if return_hash
+        keys.each_with_object({}) do |k, o|
+          v = @named_variables[k]
+          if v.nil?
+            o[k] = 0.0
+          elsif defined?(::Matrix) and v.is_a?(::Matrix)
+            o[k] = Matrix.build(v.row_size, v.column_size){|i, j| derivative(v[i, j]) }
+          else
+            o[k] = derivative(v)
+          end
+        end
+      else
+        vars.map do |v|
+          if v.nil?
+            0.0
+          elsif defined?(::Matrix) and v.is_a?(::Matrix)
+            Matrix.build(v.row_size, v.column_size){|i, j| derivative(v[i, j]) }
+          else
+            derivative(v)
+          end
+        end
+      end
+    end
+
+    def to_i
+      @n.to_i
+    end
+
+    def to_int
+      @n.to_int
+    end
+
+    def to_f
+      @n.to_f
+    end
+
+    def coerce(other)
+      if Differentiation.differentiable?(other)
+        [Differentiation.convert_to_dual_number(other), self]
+      else
+        super
+      end
+    end
+
+    def <=>(other)
+      if other.is_a?(DualNumber)
+        @n <=> other.n
+      else
+        @n <=> other
+      end
+    end
+
+    def +(other)
+      if other.is_a?(DualNumber)
+        n = @n + other.n
+        diff = ->(var) { self.derivative(var) + other.derivative(var) }
+        named_variables = @named_variables.merge(other.named_variables)
+      else
+        n = @n + other
+        diff = @diff
+        named_variables = @named_variables
+      end
+      DualNumber.new(n, diff, named_variables: named_variables)
+    end
+
+    def -(other)
+      if other.is_a?(DualNumber)
+        n = @n - other.n
+        diff = ->(var) { self.derivative(var) - other.derivative(var) }
+        named_variables = @named_variables.merge(other.named_variables)
+      else
+        n = @n - other
+        diff = @diff
+        named_variables = @named_variables
+      end
+      DualNumber.new(n, diff, named_variables: named_variables)
+    end
+
+    def *(other)
+      if other.is_a?(DualNumber)
+        n = @n * other.n
+        diff = ->(var) { @n * other.derivative(var) + self.derivative(var) * other.n }
+        named_variables = @named_variables.merge(other.named_variables)
+      else
+        n = @n * other
+        diff = ->(var) { self.derivative(var) * other }
+        named_variables = @named_variables
+      end
+      DualNumber.new(n, diff, named_variables: named_variables)
+    end
+
+    def /(other)
+      if other.is_a?(DualNumber)
+        n = @n / other.n
+        diff = ->(var) { (self.derivative(var) / other) + (@n * other.derivative(var)) / (other.n ** 2) }
+        named_variables = @named_variables.merge(other.named_variables)
+      else
+        n = @n / other
+        diff = ->(var) { self.derivative(var) / other }
+        named_variables = @named_variables
+      end
+      DualNumber.new(n, diff, named_variables: named_variables)
+    end
+
+    def **(other)
+      if other.is_a?(DualNumber)
+        n = @n ** other.n
+        diff = ->(var) { (@n ** other.n) * (other.derivative(var) * Math.log(@n) + (other.n / @n)) }
+        named_variables = @named_variables.merge(other.named_variables)
+      else
+        n = @n ** other
+        diff = ->(var) { ((@n ** (other-1)) * other) * self.derivative(var) }
+        named_variables = @named_variables
+      end
+      DualNumber.new(n, diff, named_variables: named_variables)
+    end
+
+    def inspect
+      if $DEBUG
+        "<DualNumber: #{@n} >"
+      else
+        @n.inspect
+      end
+    end
+  end
+end

data/lib/differentiation/ext/float.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Float
+  def to_dual_number(key: nil)
+    Differentiation.convert_to_dual_number(self, key: key)
+  end
+end

data/lib/differentiation/ext/integer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Integer
+  def to_dual_number(key: nil)
+    Differentiation.convert_to_dual_number(self, key: key)
+  end
+end

data/lib/differentiation/ext/kernel.rb

@@ -3,11 +3,15 @@
 module Kernel
   def differential(m)
     if m.is_a?(Symbol)
-      f = self.method(m)
-    elsif m.is_a?(Proc) or m.is_a?(Method)
+      if self.is_a?(Module)
+        f = self.instance_method(m)
+      else
+        f = self.method(m)
+      end
+    elsif m.is_a?(Proc) or m.is_a?(Method) or m.is_a?(UnboundMethod)
       f = m
     else
-      raise TypeError, "differential requires Method/Proc/Symbol argument."
+      raise TypeError, "differential requires Method/UnboundMethod/Proc/Symbol argument."
     end
     f = Differentiation.differential(f)
     if m.is_a?(Symbol)

data/lib/differentiation/version.rb

@@ -1,3 +1,3 @@
 module Differentiation
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: differentiation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - nagachika
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-31 00:00:00.000000000 Z
+date: 2019-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,12 +62,16 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - differentiation.gemspec
 - lib/differentiation.rb
+- lib/differentiation/dual_number.rb
+- lib/differentiation/ext/float.rb
+- lib/differentiation/ext/integer.rb
 - lib/differentiation/ext/kernel.rb
 - lib/differentiation/version.rb
 homepage: https://github.com/nagachika/differentiation
@@ -89,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Make Ruby Differentiable.