ChebyRuby 0.0.1.pre → 0.0.2.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c0f9d3747a36682aa90b2b738c563d5e744f7b6
-  data.tar.gz: 66f91daacd639572b3ee61bc5cf90664c5d45702
+  metadata.gz: ce9e90673dcb994d2b9e512a949a173a875c3264
+  data.tar.gz: bd39e0f58ac5668df89c99ae1f255c1eea25458c
 SHA512:
-  metadata.gz: 35b08a1ba0dee7629ee11c83ca1d461d93d32b31761ee92e4a9b83e9490fa2a6282f873d25a9deb866aed7e3ee5a030aa24a14cad79ed4b66014d46a1e6d782e
-  data.tar.gz: c2cb87ab8481d85bb2f8c085f1d9c6182954188e58eb82d7aa5a2f5572c598a2d9ed943276ed85fa24b682947d53dfcd21e9c84c693e173df6e0a0131c139896
+  metadata.gz: 25c353b12eee3bc7c9799b319fe04c469d53b9c3db0cc80eae5f4d97b1d7f2a7606c78ebe780d617e2f5b027f3ae2047248ae03a53efcbcc9d28830fcf46409a
+  data.tar.gz: 053d27aac92aed0404ee6c49f4700917ac609594a9e18263c46c22af27745b5e22a967f6d96adc6ee3d3084b1ef34919140a9664ef01eea0945de4da3a8df76d

data/lib/chebyruby/differentiation.rb

@@ -1,5 +1,18 @@
+# Module/Mixin for numeric differentiation methods. 
+# As of right now it is only mixed-in to @see [FiniteDifferencing]
+# but will likely be mixed into more in the future. 
 module ChebyRuby::Differentiation
+
+  # A crude method to calculate the "slope" of a function over the 
+  # span of two points.
+  # The formula used is:
+  # <pre>(f(b) - f(a))/(b - a)</pre>
+  # 
+  # @param [UnivariateFunction] func the univariate function to be used.
+  # @param [Numeric] a one of the values in the domain of func
+  # @param [Numeric] b the other value in the domain of func
+  # @return [Float] the slope as described above 
   def slope(func, a, b)
-    (func.value(b) - func.value(a))/(b-a)
+    (func.value(b) - func.value(a))/(b-a).to_f
   end
 end

data/lib/chebyruby/finite_differencing.rb

@@ -1,13 +1,40 @@
 require_relative 'differentiation'
+
+# This is the class for finite differencing.
+# Finite differencing is a popular method of finding a numeric
+# derivative. There are three different implementations of the finite
+# differencing method. There is the forward and backward implementations,
+# both with an order of accuracy of O(h) and central differencing with an
+# order of accuracy of O(h^2). 
+# 
+# @attr func [UnivariateFunction] the function to which differentiation will be applied
 class ChebyRuby::FiniteDifferencing
   include Differentiation
 
   attr_accessor :func
 
+  # Basic constructor for FiniteDifferencing. It can be implemented in two ways.
+  # It can either have a UnivariateFunction passed to it or a proc. 
+  # 
+  # @param [UnivariateFunction||Proc] func the function to implement
   def initialize(func)
-    @func = func
+    if func.is_a? Proc
+      @func = UnivariateFunction.new(&func)
+    else
+      @func = func
+    end
   end
 
+  # This does forward finite differencing. 
+  # The formula being used is:
+  # <pre> Sum[(-1)^i * Binom(n i) * f(x + (n-i) * h), {i, 0, n}]/(h^n) </pre>
+  # 
+  # @param [Numeric] x the value at which to find the derivative
+  # @param [Numeric] h the value to use for the differencing (generally 
+  # the smaller the better with exceptions especially when considering 
+  # underflow).
+  # @param [Integer] order the order of the derivative. (Ex. 1 for f', 2 for f'', etc.)
+  # @return [Float] the forward finite differencing approximation of f^(n) (x)
   def forward(x, h = 0.1, order = 1)
     (0..order).map do |i|
       (-1)**i * FiniteDifferencing::binomial(order, i) *
@@ -15,6 +42,16 @@ class ChebyRuby::FiniteDifferencing
     end.inject(:+) / (h**order).to_f
   end
 
+  # This does backward finite differencing. 
+  # The formula being used is:
+  # <pre> Sum[(-1)^i * Binom(n i) * f(x - i*h), {i, 0, n}]/(h^n) </pre>
+  # 
+  # @param [Numeric] x the value at which to find the derivative
+  # @param [Numeric] h the value to use for the differencing (generally 
+  # the smaller the better with exceptions especially when considering 
+  # underflow).
+  # @param [Integer] order the order of the derivative. (Ex. 1 for f', 2 for f'', etc.)
+  # @return [Float] the backward finite differencing approximation of f^(n) (x)
   def backward(x, h = 0.1, order = 1)
     (0..order).map do |i|
       (-1)**i * FiniteDifferencing::binomial(order, i) *
@@ -22,6 +59,16 @@ class ChebyRuby::FiniteDifferencing
     end.inject(:+) / (h**order).to_f
   end
 
+  # This does central finite differencing. 
+  # The formula being used is:
+  # <pre> Sum[(-1)^i * Binom(n i) * f(x + (n/2-i) * h), {i, 0, n}]/(h^n) </pre>
+  # 
+  # @param [Numeric] x the value at which to find the derivative
+  # @param [Numeric] h the value to use for the differencing (generally 
+  # the smaller the better with exceptions especially when considering 
+  # underflow).
+  # @param [Integer] order the order of the derivative. (Ex. 1 for f', 2 for f'', etc.)
+  # @return [Float] the central finite differencing approximation of f^(n) (x)
   def central(x, h = 0.1, order = 1)
     (0..order).map do |i|
       (-1)**i * FiniteDifferencing::binomial(order, i) *
@@ -30,6 +77,11 @@ class ChebyRuby::FiniteDifferencing
   end
 
   private
+  # Used to calculate the binomial coefficient.
+  # 
+  # @param [Integer] n the upper binomial value
+  # @param [Integer] k the lowe binomial value
+  # @return [Float] Binom(n k)
   def FiniteDifferencing.binomial(n, k)
     (1..k).map do |i|
       (n + 1 - i)/i.to_f

data/lib/chebyruby/integration.rb

@@ -1,4 +1,17 @@
+# Module/Mixin for integration.
+# 
+# It is currently mixed into Romberg and Simpson's
 module ChebyRuby::Integration
+
+  # This method returns the trapezoid integration estimate.
+  # 
+  # @param [UnivariateFunction] func the univariate function to integrate
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [Integer] iterations the number of iterations/subregions requested.
+  # While a higher number will be more accurate, it will also take longer.
+  # @return [Float] the trapezoidal estimation of the integral of func from
+  # a to b.
   def trap_integrate(func, a, b, iterations = 32)
     h = (b - a)/iterations.to_f
     mesh = (a..b).step(h).to_a[1...-1]
@@ -7,6 +20,13 @@ module ChebyRuby::Integration
     (b - a)/(2.0 * iterations) * summand
   end
 
+  # This method compares the accuate of certain methods to each other.
+  # 
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [String] method the method being used
+  # @param [String] cm the method to compare to
+  # @return [Float] the absolute difference between the two methods.
   def accuracy_comparison(a, b, method = 'Trapezoid', cm = 'Trapezoid')
     case method
     when 'Trapezoid' then (integrate(a, b) - trap_integrate(func, a, b)).abs
@@ -15,7 +35,14 @@ module ChebyRuby::Integration
     end
   end
 
+  # Singleton class for mixin purposes.
   class << self
+    # This method provides a singleton implementation of an
+    # integration method in an integration class.
+    # 
+    # @param [UnivariateFunction] func the function over which to integrate
+    # @param [Numeric] a the lower bounds of the integral
+    # @param [Numeric] b the upper bounds of the integral
     def sintegrate(func, a, b)
       self.new(func).integrate(a, b)
     end

data/lib/chebyruby/romberg_integration.rb

@@ -1,14 +1,33 @@
 require_relative 'integration'
 
+# This class is for Romberg integration. The Romberg integration method
+# involves using Richardson extrapolation combined with the trapezoid
+# method to get a more accurate integration method. It was published by
+# Werner Romberg in 1955.
+# 
+# @attr func [UnivariateFunction] the function over which to integrate.
 class ChebyRuby::RombergIntegration
   include ChebyRuby::Integration
 
   attr_accessor :func
 
+  # Basic constructor for RombergIntegration. It can be implemented in two ways.
+  # It can either have a UnivariateFunction passed to it or a proc. 
+  # 
+  # @param [UnivariateFunction||Proc] func the function to implement
   def initialize(func)
-    @func = func
+    if func.is_a? Proc
+      @func = UnivariateFunction.new(&func)
+    else
+      @func = func
+    end
   end
 
+  # This method integrates the function parameter using romberg integration.
+  # 
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [Integer] iterations the number of iterations to be used for integration.
   def integrate(a, b, iterations = 8)
     t = Array.new(iterations)
     iterations.times do |i|
@@ -23,7 +42,13 @@ class ChebyRuby::RombergIntegration
     t.last.last
   end
 
+  # This method compares the accuate of Romberg to other methods.
+  # 
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [String] method the method to compare to
+  # @return [Float] the absolute difference between the two methods.
   def accuracy_comparison(a, b, method = 'Trapezoid')
-    super.accuracy_comparison(a, b, method, 'RombergIntegration')
+    super.accuracy_comparison(a, b, method, 'Romberg')
   end
 end

data/lib/chebyruby/simpsons_integration.rb

@@ -1,14 +1,32 @@
 require_relative 'integration'
 
+# This class is for the composite Simpson's rule. The Composite Simpson's rule
+# involves summing Simpson's rule being calculated over a fine mesh.
+# 
+# @attr func [UnivariateFunction] the function over which to integrate.
 class ChebyRuby::SimpsonsIntegration
   include ChebyRuby::Integration
 
   attr_accessor :func
 
+  # Basic constructor for SimpsonsIntegration. It can be implemented in two ways.
+  # It can either have a UnivariateFunction passed to it or a proc. 
+  # 
+  # @param [UnivariateFunction||Proc] func the function to implement
   def initialize(func)
-    @func = func
+    if func.is_a? Proc
+      @func = UnivariateFunction.new(&func)
+    else
+      @func = func
+    end
   end
 
+  # This method integrates the function parameter using 
+  # the composite simpsons rule.
+  # 
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [Integer] iterations the number of iterations to be used for integration.
   def integrate(a, b, iterations = 32)
     h = (b - a) / iterations.to_f
     mesh = (a..b).step(h).to_a[1...-1]
@@ -19,7 +37,13 @@ class ChebyRuby::SimpsonsIntegration
     (h / 3.0) * summand
   end
 
+  # This method compares the accuate of Simpsons to other methods.
+  # 
+  # @param [Numeric] a the lower bounds of the integral
+  # @param [Numeric] b the upper bounds of the integral
+  # @param [String] method the method to compare to
+  # @return [Float] the absolute difference between the two methods.
   def accuracy_comparison(a, b, method = 'Trapezoid')
-    super.accuracy_comparison(a, b, method, 'RombergIntegration')
-  end
+    super.accuracy_comparison(a, b, method, 'Simpsons')
+  end 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ChebyRuby
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.0.2.pre
 platform: ruby
 authors:
 - Eli Sadoff