silicium 0.0.2 → 0.0.21

data/lib/numerical_integration.rb

@@ -1,147 +1,184 @@
-module Silicium
-  class IntegralDoesntExistError < RuntimeError
-
-  end
-  ##
-  # A class providing numerical integration methods
-  class NumericalIntegration
-
-    # Computes integral from +a+ to +b+ of +block+ with accuracy +eps+
-    def self.three_eights_integration(a, b, eps = 0.0001, &block)
-      wrapper_method([a, b], eps, :three_eights_integration_n, &block)
-    end
-
-    # Computes integral from +a+ to +b+ of +block+ with +n+ segmentations
-    def self.three_eights_integration_n(a, b, n, &block)
-      dx = (b - a) / n.to_f
-      result = 0
-      x = a
-      n.times do
-        result +=
-          (block.call(x) + 3 * block.call((2 * x + x + dx) / 3.0) +
-              3 * block.call((x + 2 * (x + dx)) / 3.0) + block.call(x + dx)) / 8.0 * dx
-        x += dx
-      end
-      result
-    end
-
-
-    # Simpson integration with a segment
-    def self.simpson_integration_with_a_segment(a, b, n, &block)
-      dx = (b - a) / n.to_f
-      result = 0
-      i = 0
-      while i < n
-        result += (block.call(a + i * dx) + 4 * block.call(((a + i * dx) +
-            (a + (i + 1) * dx)) / 2.0) + block.call(a + (i + 1) * dx)) / 6.0 * dx
-        i += 1
-      end
-      result
-    end
-
-    # Simpson integration with specified accuracy
-    def self.simpson_integration(a, b, eps = 0.0001, &block)
-      wrapper_method([a, b], eps, :simpson_integration_with_a_segment, &block)
-    end
-
-    # Left Rectangle Method and Right Rectangle Method
-    def self.left_rect_integration(left_p, right_p, eps = 0.0001, &block)
-      splits = 1
-      res1 = left_rect_integration_n(left_p, right_p, 1, &block)
-      res2 = left_rect_integration_n(left_p, right_p, 5, &block)
-      while (res1 - res2).abs > eps
-        res1 = left_rect_integration_n(left_p, right_p, splits, &block)
-        splits *= 5
-        res2 = left_rect_integration_n(left_p, right_p, splits, &block)
-      end
-      (res1 + res2) / 2.0
-    end
-
-    # Left Rectangle Auxiliary Method and Right Rectangle Auxiliary Method
-    def self.left_rect_integration_n(left_p, right_p, splits, &block)
-      dx = (right_p - left_p) / splits.to_f
-      result = 0
-      i = 0
-      while i < splits
-        result += block.call(left_p + i * dx)
-        i += 1
-      end
-      result * dx
-    end
-
-
-    # Middle Rectangles Method with a segment
-    def self.middle_rectangles_with_a_segment(a, b, n, &block)
-      dx = (b - a) / n.to_f
-      result = 0
-      i = 0
-      n.times do
-        result += block.call(a + dx * (i + 1 / 2)) * dx
-        i += 1
-      end
-      result
-    end
-
-    # Middle Rectangles Method  with specified accuracy
-    def self.middle_rectangles(a, b, eps = 0.0001, &block)
-      wrapper_method([a, b], eps, :middle_rectangles_with_a_segment, &block)
-    end
-
-
-    # Trapezoid Method with a segment
-    def self.trapezoid_with_a_segment(a, b, n, &block)
-      dx = (b - a) / n.to_f
-      result = 0
-      i = 1
-      (n - 1).times do
-        result += block.call(a + dx * i)
-        i += 1
-      end
-      result += (block.call(a) + block.call(b)) / 2.0
-      result * dx
-    end
-
-    # Trapezoid Method with specified accuracy
-    def self.trapezoid(a, b, eps = 0.0001, &block)
-      wrapper_method([a, b], eps, :trapezoid_with_a_segment ,&block)
-    end
-
-    private
-
-    ##
-    # Wrapper method for num_integratons methods
-    # @param [Array] a_b integration range
-    # @param [Numeric] eps
-    # @param [Proc] proc - integration Proc
-    # @param [Block] block - integrated function as Block
-    def self.wrapper_method(a_b, eps, method_name, &block)
-      n = 1
-      a, b = a_b
-      begin
-        begin
-          result = send(method_name, a, b, n, &block)
-          check_value(result)
-          n *= 5
-          result1 = send(method_name, a, b, n, &block)
-          check_value(result1)
-        end until (result - result1).abs < eps
-      rescue Math::DomainError
-        raise IntegralDoesntExistError, 'Domain error in math function'
-      rescue ZeroDivisionError
-        raise IntegralDoesntExistError, 'Divide by zero'
-      end
-      (result + result1) / 2.0
-    end
-
-    def self.check_value(value)
-      if value.nan?
-        raise IntegralDoesntExistError, 'We have not-a-number result :('
-      end
-      if value == Float::INFINITY
-        raise IntegralDoesntExistError, 'We have infinity :('
-      end
-    end
-  end
-end
-
-
+module Silicium
+  class IntegralDoesntExistError < RuntimeError; end
+  
+  class NumberofIterOutofRangeError < RuntimeError; end
+    
+  ##
+  # A class providing numerical integration methods
+  class NumericalIntegration
+
+    ##
+    # Computes integral by the 3/8 rule
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.three_eights_integration(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :three_eights_integration_n, &block)
+    end
+
+    ##
+    # Computes integral by the 3/8 rule
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.three_eights_integration_n(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      result = 0
+      x = a
+      n.times do
+        result +=
+          (block.call(x) + 3 * block.call((2 * x + x + dx) / 3.0) +
+              3 * block.call((x + 2 * (x + dx)) / 3.0) + block.call(x + dx)) / 8.0 * dx
+        x += dx
+      end
+      result
+    end
+
+    ##
+    # Computes integral by the Simpson's rule
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.simpson_integration_with_a_segment(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      result = 0
+      i = 0
+      while i < n
+        result += (block.call(a + i * dx) + 4 * block.call(((a + i * dx) +
+            (a + (i + 1) * dx)) / 2.0) + block.call(a + (i + 1) * dx)) / 6.0 * dx
+        i += 1
+      end
+      result
+    end
+
+    ##
+    # Computes integral by the Simpson's rule
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.simpson_integration(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :simpson_integration_with_a_segment, &block)
+    end
+
+    ##
+    # Computes integral by the Left Rectangles method
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.left_rect_integration(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :left_rect_integration_n, &block)
+    end
+
+    ##
+    # Computes integral by the Left Rectangles method
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.left_rect_integration_n(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      amount_calculation(a, [0, n], dx, &block)
+    end
+
+    ##
+    # Computes integral by the Right Rectangles method
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.right_rect_integration(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :right_rect_integration_n, &block)
+    end
+
+    ##
+    # Computes integral by the Right Rectangles method
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.right_rect_integration_n(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      amount_calculation(a, [1, n + 1], dx, &block)
+    end
+
+    ##
+    # Computes integral by the Middle Rectangles method
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.middle_rectangles_with_a_segment(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      result = 0
+      i = 0
+      n.times do
+        result += block.call(a + dx * (i + 1 / 2)) * dx
+        i += 1
+      end
+      result
+    end
+
+    ##
+    # Computes integral by the Middle Rectangles method
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.middle_rectangles(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :middle_rectangles_with_a_segment, &block)
+    end
+
+    ##
+    # Computes integral by the Trapezoid method
+    # from +a+ to +b+ of +block+ with +n+ segmentations
+    def self.trapezoid_with_a_segment(a, b, n, &block)
+      dx = (b - a) / n.to_f
+      result = 0
+      i = 1
+      (n - 1).times do
+        result += block.call(a + dx * i)
+        i += 1
+      end
+      result += (block.call(a) + block.call(b)) / 2.0
+      result * dx
+    end
+
+    ##
+    # Computes integral by the Trapezoid method
+    # from +a+ to +b+ of +block+ with accuracy +eps+
+    def self.trapezoid(a, b, eps = 0.0001, &block)
+      wrapper_method([a, b], eps, :trapezoid_with_a_segment ,&block)
+    end
+
+    private
+
+    ##
+    # Wrapper method for num_integratons methods
+    # @param [Array] a_b integration range
+    # @param [Numeric] eps
+    # @param [Proc] proc - integration Proc
+    # @param [Block] block - integrated function as Block
+    def self.wrapper_method(a_b, eps, method_name, &block)
+      n = 1
+      max_it = 10_000
+      begin
+        begin
+          result = send(method_name, a_b[0], a_b[1], n, &block)
+          check_value(result)
+          n *= 5
+          raise NumberofIterOutofRangeError if n > max_it
+          result1 = send(method_name, a_b[0], a_b[1], n, &block)
+          check_value(result1)
+        end until (result - result1).abs < eps
+          
+      rescue Math::DomainError
+        raise IntegralDoesntExistError, 'Domain error in math function'
+      rescue ZeroDivisionError
+        raise IntegralDoesntExistError, 'Divide by zero'
+      end
+      (result + result1) / 2.0
+    end
+
+    def self.check_value(value)
+      if value.nan?
+        raise IntegralDoesntExistError, 'We have not-a-number result :('
+      end
+      if value == Float::INFINITY
+        raise IntegralDoesntExistError, 'We have infinity :('
+      end
+    end
+
+    ##
+    # Computes the sum of n rectangles on a segment
+    # of length dx at points of the form a + i * dx
+    # @param [Numeric] a - first division point
+    # @param [Array] i_n number of divisions
+    # @param [Numeric] dx - length of integration segment
+    # @param [Block] block - integrated function as Block
+    def self.amount_calculation(a, i_n, dx, &block)
+      result = 0
+      while i_n[0] < i_n[1]
+        result += block.call(a + i_n[0] * dx)
+        i_n[0] += 1
+      end
+      result * dx
+    end
+  end
+end
+
+

data/lib/optimization.rb

@@ -1,144 +1,209 @@
-require "silicium"
-require 'fast_matrix'
-
-module Silicium
-  module Optimization
-
-
-    # reflector function
-    def re_lu(x)
-      x.negative? ? 0 : x
-    end
-
-    #sigmoid function
-    def sigmoid(x)
-      1.0 / (1 + Math.exp(-x))
-    end
-
-    #integrating using method Monte Carlo (f - function, a, b - integrating limits, n - amount of random numbers)
-    def integrating_Monte_Carlo_base(a, b, n = 100000, &block)
-      res = 0
-      range = a..b.to_f
-      for i in 1..(n + 1)
-         x = rand(range)
-         res += (b - a) * 1.0 / n * block.call(x)
-      end
-      res
-    end
-
-    #return true if array is sorted
-    def sorted?(a)
-      return false if a.nil?
-      for i in 0..a.length - 2
-        if (a[i + 1] < a[i])
-          return false
-        end
-      end
-      true
-    end
-
-    #fastest(but it is not exactly) sort, modify sequance
-    def bogosort!(a)
-      if (a.nil?)
-        raise ArgumentError, "Nil array in bogosort"
-      end
-      while (!sorted?(a))
-        a.shuffle!
-      end
-      a
-    end
-
-    #fastest(but it is not exactly) sort
-    def bogosort(a)
-      if (a.nil?)
-        raise ArgumentError, "Nil array in bogosort"
-      end
-      crutch = a
-      while (!sorted?(crutch))
-        crutch = a.shuffle
-      end
-      crutch
-    end
-
-    #calculate current accuracy in Hook - Jeeves method
-    def accuracy(step)
-      acc = 0
-      step.each { |a| acc += a * a }
-      Math.sqrt(acc)
-    end
-
-    #do one Hook - Jeeves step
-    def hook_jeeves_step(x, i, step, &block)
-      x[i] += step[i]
-      tmp1 = block.call(x)
-      x[i] = x[i] - 2 * step[i]
-      tmp2 = block.call(x)
-      if (tmp1 > tmp2)
-        cur_f = tmp2
-      else
-        x[i] = x[i] + step[i] * 2
-        cur_f = tmp1
-      end
-      [cur_f, x[i]]
-    end
-
-    #switch step if current func value > previous func value
-    def switch_step(cur_f, prev_f, step, i)
-      return step[i] / 2.0 if cur_f >= prev_f #you can switch 2.0 on something else
-      step[i]
-    end
-    #Hook - Jeeves method for find minimum point (x - array of start variables, step - step of one iteration, eps - allowable error, alfa - slowdown of step,
-    #block - function which takes array x, WAENING function doesn't control  correctness of input
-    def hook_jeeves(x, step, eps = 0.1, &block)
-      prev_f = block.call(x)
-      acc = accuracy(step)
-      while (acc > eps)
-        for i in 0..x.length - 1
-          tmp = hook_jeeves_step(x, i, step, &block)
-          cur_f = tmp[0]
-          x[i] = tmp[1]
-          step[i] = switch_step(cur_f, prev_f, step, i)
-          prev_f = cur_f
-        end
-        acc = accuracy(step)
-      end
-      x
-    end
-
-    #find centr of interval
-    def middle(a, b)
-      (a + b) / 2.0
-    end
-
-    #do one half division step
-    def half_division_step(a, b, c, &block)
-      if (block.call(a) * block.call(c) < 0)
-        b = c
-        c = middle(a, c)
-      else
-        a = c
-        c = middle(b, c)
-      end
-      [a, b, c]
-    end
-
-    #find root in [a, b], if he exist, if number of iterations > iters -> error
-    def half_division(a, b, eps = 0.001, &block)
-      iters = 1000000
-      c = middle(a, b)
-      while ((block.call(c).abs) > eps)
-        tmp = half_division_step(a, b, c, &block)
-        a = tmp[0]
-        b = tmp[1]
-        c = tmp[2]
-        iters -= 1
-        if iters == 0
-          raise RuntimeError, "Root not found! Check does he exist, or change eps or iters"
-        end
-      end
-      c
-    end
-
-
-  end
-end
+require "silicium"
+require 'fast_matrix'
+
+module Silicium
+  module Optimization
+    # reflector function
+    def re_lu(x)
+      x.negative? ? 0 : x
+    end
+
+    # sigmoid function
+    def sigmoid(x)
+      1.0 / (1 + Math.exp(-x))
+    end
+
+    # integrating using method Monte Carlo (f - function, a, b - integrating limits, n - amount of random numbers)
+    def integrating_Monte_Carlo_base(a, b, n = 100000, &block)
+      res = 0
+      range = a..b.to_f
+      (0..n).each do
+        x = rand(range)
+        res += (b - a) * 1.0 / n * block.call(x)
+      end
+      res
+    end
+
+    # return true if array is sorted
+    def sorted?(a)
+      return false if a.nil?
+
+      for i in 0..a.length - 2
+        return false if (a[i + 1] < a[i])
+      end
+      true
+    end
+
+    # fastest(but it is not exactly) sort, modify sequance
+    def bogosort!(a)
+      raise ArgumentError, "Nil array in bogosort" if a.nil?
+
+      a.shuffle! until sorted?(a)
+      a
+    end
+
+    # fastest(but it is not exactly) sort
+    def bogosort(a)
+      raise ArgumentError, "Nil array in bogosort" if a.nil?
+
+      crutch = a
+      (crutch = a.shuffle) until sorted?(crutch)
+      crutch
+    end
+
+    # calculate current accuracy in Hook - Jeeves method
+    def accuracy(step)
+      acc = 0
+      step.each { |a| acc += a * a }
+      Math.sqrt(acc)
+    end
+
+    # do one Hook - Jeeves step
+    def hook_jeeves_step(x, i, step, &block)
+      x[i] += step[i]
+      tmp1 = block.call(x)
+      x[i] = x[i] - 2 * step[i]
+      tmp2 = block.call(x)
+      if (tmp1 > tmp2)
+        cur_f = tmp2
+      else
+        x[i] = x[i] + step[i] * 2
+        cur_f = tmp1
+      end
+      [cur_f, x[i]]
+    end
+
+    # switch step if current func value > previous func value
+    def switch_step(cur_f, prev_f, step, i)
+      return step[i] / 2.0 if cur_f >= prev_f # you can switch 2.0 on something else
+
+      step[i]
+    end
+
+    # Hook - Jeeves method for find minimum point (x - array of start variables, step - step of one iteration, eps - allowable error, alfa - slowdown of step,
+    # block - function which takes array x, WAENING function doesn't control  correctness of input
+    def hook_jeeves(x, step, eps = 0.1, &block)
+      prev_f = block.call(x)
+      acc = accuracy(step)
+      while (acc > eps)
+        for i in 0..x.length - 1
+          tmp = hook_jeeves_step(x, i, step, &block)
+          cur_f = tmp[0]
+          x[i] = tmp[1]
+          step[i] = switch_step(cur_f, prev_f, step, i)
+          prev_f = cur_f
+        end
+        acc = accuracy(step)
+      end
+      x
+    end
+
+    # find centr of interval
+    def middle(a, b)
+      (a + b) / 2.0
+    end
+
+    # do one half division step
+    def half_division_step(a, b, c, &block)
+      if (block.call(a) * block.call(c)).negative?
+        b = c
+        c = middle(a, c)
+      else
+        a = c
+        c = middle(b, c)
+      end
+      [a, b, c]
+    end
+
+    # find root in [a, b], if he exist, if number of iterations > iters -> error
+    def half_division(a, b, eps = 0.001, &block)
+      iters = 1000000
+      c = middle(a, b)
+      while (block.call(c).abs) > eps
+        tmp = half_division_step(a, b, c, &block)
+        a = tmp[0]
+        b = tmp[1]
+        c = tmp[2]
+        iters -= 1
+        raise RuntimeError, 'Root not found! Check does he exist, or change eps or iters' if iters == 0
+      end
+      c
+    end
+
+    # Find determinant 3x3 matrix
+    def determinant_sarryus(matrix)
+      raise ArgumentError, "Matrix size must be 3x3" if (matrix.row_count != 3 || matrix.column_count != 3)
+
+      matrix[0, 0] * matrix[1, 1] * matrix[2, 2] + matrix[0, 1] * matrix[1, 2] * matrix[2, 0] + matrix[0, 2] * matrix[1, 0] * matrix[2, 1] -
+        matrix[0, 2] * matrix[1, 1] * matrix[2, 0] - matrix[0, 0] * matrix[1, 2] * matrix[2, 1] - matrix[0, 1] * matrix[1, 0] * matrix[2, 2]
+    end
+
+    # return probability to accept
+    def accept_annealing(z, min, t, d)
+      p = (min - z) / (d * t * 1.0)
+      Math.exp(p)
+    end
+
+    # do one annealing step
+    def annealing_step(x, min_board, max_board)
+      x += rand(-0.5..0.5)
+      x = max_board if (x > max_board)
+      x = min_board if (x < min_board)
+      x
+    end
+
+    # update current min and xm if cond
+    def annealing_cond(z, min, t, d)
+      (z < min || accept_annealing(z, min, t, d) > rand(0.0..1.0))
+    end
+
+    # Annealing method to find min of function with one argument, between min_board max_board,
+    def simulated_annealing(min_board, max_board, t = 10000, &block)
+      d = Math.exp(-5) # Constant of annealing
+      x = rand(min_board * 1.0..max_board * 1.0)
+      xm = x
+      min = block.call(x)
+      while (t > 0.00001)
+        x = xm
+        x = annealing_step(x, min_board, max_board)
+        z = block.call(x)
+        if (annealing_cond(z, min, t, d))
+          min = z
+          xm = x
+        end
+        t *= 0.9999 # tempreture drops
+      end
+      xm
+    end
+
+    # Fast multiplication of num1 and num2.
+    def karatsuba(num1, num2)
+      return num1 * num2 if num1 < 10 || num2 < 10
+
+      max_size = [num1.to_s.length, num2.to_s.length].max
+
+      first_half1, last_half1 = make_equal(num1, max_size)
+      first_half2, last_half2 = make_equal(num2, max_size)
+
+      t0 = karatsuba(last_half1, last_half2)
+      t1 = karatsuba((first_half1 + last_half1), (first_half2 + last_half2))
+      t2 = karatsuba(first_half1, first_half2)
+
+      compute_karatsuba(t0, t1, t2, max_size / 2)
+    end
+
+    private
+
+    # Helper for karatsuba method. Divides num into two halves.
+    def make_equal(num, size)
+      mid = (size + 1) / 2
+      string = num.to_s.rjust(size, '0')
+      [string.slice(0...mid).to_i, string.slice(mid..-1).to_i]
+    end
+
+    # Helper for karatsuba method. Computes the result of karatsuba's multiplication.
+    def compute_karatsuba(tp0, tp1, tp2, num)
+      tp2 * 10**(2 * num) + ((tp1 - tp0 - tp2) * 10**num) + tp0
+    end
+  end
+end