silicium 0.0.14 → 0.0.22

data/lib/numerical_integration.rb

@@ -0,0 +1,184 @@
+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

@@ -0,0 +1,208 @@
+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

data/lib/plotter.rb

@@ -0,0 +1,258 @@
+require 'chunky_png'
+require 'ruby2d'
+
+module Silicium
+  ##
+  # Plotter module
+  # Module contains classes, that are different kinds of plain plotters
+  #
+  module Plotter
+    include Silicium::Geometry
+    # The Color module defines methods for handling colors. Within the Plotter
+    # library, the concepts of pixels and colors are both used, and they are
+    # both represented by a Integer.
+    #
+    # Pixels/colors are represented in RGBA components. Each of the four
+    # components is stored with a depth of 8 bits (maximum value = 255 =
+    # {Plotter::Color::MAX}). Together, these components are stored in a 4-byte
+    # Integer.
+    #
+    # A color will always be represented using these 4 components in memory.
+    # When the image is encoded, a more suitable representation can be used
+    # (e.g. rgb, grayscale, palette-based), for which several conversion methods
+    # are provided in this module.
+    module Color
+      extend ChunkyPNG::Color
+      include ChunkyPNG::Color
+    end
+    ##
+    # Factory method to return a color value, based on the arguments given.
+    #
+    # @overload Color(r, g, b, a)
+    #   @param (see ChunkyPNG::Color.rgba)
+    #   @return [Integer] The rgba color value.
+    #
+    # @overload Color(r, g, b)
+    #   @param (see ChunkyPNG::Color.rgb)
+    #   @return [Integer] The rgb color value.
+    #
+    # @overload Color(hex_value, opacity = nil)
+    #   @param (see ChunkyPNG::Color.from_hex)
+    #   @return [Integer] The hex color value, with the opacity applied if one
+    #     was given.
+    #
+    # @overload Color(color_name, opacity = nil)
+    #   @param (see ChunkyPNG::Color.html_color)
+    #   @return [Integer] The hex color value, with the opacity applied if one
+    #     was given.
+    #
+    # @overload Color(color_value, opacity = nil)
+    #   @param [Integer, :to_i] The color value.
+    #   @return [Integer] The color value, with the opacity applied if one was
+    #     given.
+    #
+    # @return [Integer] The determined color value as RGBA integer.
+    # @raise [ArgumentError] if the arguments weren't understood as a color.
+    def color(*args)
+      case args.length
+      when 1 then Color.parse(args.first)
+      when 2 then (Color.parse(args.first) & 0xffffff00) | args[1].to_i
+      when 3 then Color.rgb(*args)
+      when 4 then Color.rgba(*args)
+      else raise ArgumentError,
+                 "Don't know how to create a color from #{args.inspect}!"
+      end
+    end
+    ##
+    # A class representing canvas for plotting bar charts and function graphs
+    class Image
+      include Silicium::Geometry
+      ##
+      # Creates a new plot with chosen +width+ and +height+ parameters
+      # with background colored +bg_color+
+      def initialize(width, height, bg_color = Color::TRANSPARENT, padding = 5)
+        @image = ChunkyPNG::Image.new(width, height, bg_color)
+        @padding = padding
+      end
+
+      def rectangle(left_upper, width, height, color)
+        x_end = left_upper.x + width - 1
+        y_end = left_upper.y + height - 1
+        (left_upper.x..x_end).each do |i|
+          (left_upper.y..y_end).each { |j| @image[i, j] = color }
+        end
+      end
+
+      private
+
+      def draw_axis(min, dpu, axis_color)
+        # Axis OX
+        rectangle(Point.new(
+                    @padding,
+                    @image.height - @padding - (min.y.abs * dpu.y).ceil
+                  ),
+                  @image.width - 2 * @padding,
+                  1,
+                  axis_color)
+        # Axis OY
+        rectangle(Point.new(@padding + (min.x.abs * dpu.x).ceil, @padding),
+                  1, @image.height - 2 * @padding, axis_color)
+      end
+
+      public
+
+      ##
+      # Draws a bar chart in the plot using provided +bars+,
+      # each of them has width of +bar_width+ and colored +bars_color+
+      def bar_chart(bars, bar_width,
+                    bars_color = Color('red @ 1.0'),
+                    axis_color = Color::BLACK)
+        if bars.count * bar_width > @image.width
+          raise ArgumentError,
+                'Not enough big size of image to plot these number of bars'
+        end
+
+        # Values of x and y on borders of plot
+        min = Point.new([bars.collect { |k, _| k }.min, 0].min,
+                        [bars.collect { |_, v| v }.min, 0].min)
+        max = Point.new([bars.collect { |k, _| k }.max, 0].max,
+                        [bars.collect { |_, v| v }.max, 0].max)
+
+        # Dots per unit
+        dpu = Point.new(
+          (@image.width - 2 * @padding).to_f / (max.x - min.x + bar_width),
+          (@image.height - 2 * @padding).to_f / (max.y - min.y)
+        )
+
+        draw_axis(min, dpu, axis_color)
+
+        bars.each do |x, y| # Cycle drawing bars
+          l_up_x = @padding + ((x + min.x.abs) * dpu.x).floor
+          l_up_y = if y.negative?
+                     @image.height - @padding - (min.y.abs * dpu.y).ceil + 1
+                   else
+                     @image.height - @padding - ((y + min.y.abs) * dpu.y).ceil
+                   end
+          rectangle(Point.new(l_up_x, l_up_y),
+                    bar_width, (y.abs * dpu.y).ceil,
+                    bars_color)
+        end
+      end
+
+      ##
+      # Exports plotted image to file +filename+
+      def export(filename)
+        @image.save(filename, interlace: true)
+      end
+    end
+
+    CENTER_X = Window.width / 2
+    CENTER_Y = Window.height / 2
+
+
+
+    ##
+    # draws axes
+    def draw_axes
+      Line.new(x1: 0, y1: CENTER_Y, x2: (get :width), y2: CENTER_Y, width: 1, color: 'white', z: 20)
+      Line.new(x1: CENTER_X, y1: 0, x2: CENTER_X, y2: (get :height), width: 1, color: 'white', z: 20)
+
+      x1 = CENTER_X
+      x2 = CENTER_X
+      while (x1 < Window.width * 1.1) and (x2 > Window.width * -1.1) do
+        Line.new(x1: x1, y1: CENTER_Y - 4, x2: x1, y2: CENTER_Y + 3, width: 1, color: 'white', z: 20)
+        Line.new(x1: x2, y1: CENTER_Y - 4, x2: x2, y2: CENTER_Y + 3, width: 1, color: 'white', z: 20)
+        x1 += mul
+        x2 -= mul
+      end
+
+      y1 = CENTER_Y
+      y2 = CENTER_Y
+      while (y1 < Window.height * 1.1) and (y2 > Window.height * -1.1) do
+        Line.new(x1: CENTER_X - 3, y1: y1, x2: CENTER_X + 3, y2: y1, width: 1, color: 'white', z: 20)
+        Line.new(x1: CENTER_X - 3, y1: y2, x2: CENTER_X + 3, y2: y2, width: 1, color: 'white', z: 20)
+        y1 += mul
+        y2 -= mul
+      end
+    end
+
+    ##
+    # Changes the coordinates to draw the next pixel for the +f+ function
+    # +x+ - current argument. +st+ - step to next point
+    def reset_step(x, st, &f)
+      y1 = f.call(x)
+      y2 = f.call(x + st)
+
+      if (y1 - y2).abs / mul > 1.0
+        [st / (y1 - y2).abs / mul, 0.001].max
+      else
+        st / mul * 2
+      end
+    end
+
+    ##
+    # Draws a point on coordinates +x+ and +y+
+    # with the scale +mul+ and color +col+
+    def draw_point(x, y, mul, col)
+      Line.new(
+          x1: CENTER_X + x * mul, y1: CENTER_Y - y * mul,
+          x2: CENTER_X + 1 + x * mul, y2: CENTER_Y + 2 - y * mul,
+          width: 1,
+          color: col,
+          z: 20
+      )
+    end
+
+    ##
+    # Reduces the interval to the window range. +a+ and +b+ that determine interval
+    def reduce_interval(a, b)
+      a *= mul
+      b *= mul
+      return [a, -(get :width) * 1.1].max / mul, [b, (get :width) * 1.1].min / mul
+    end
+
+    ##
+    # Draws the function +func+ at the interval from +a+ to +b+
+    def draw_fn(a, b, &func)
+      draw_axes
+
+      a, b = reduce_interval(a, b)
+
+      step = 0.38
+      c_step = step
+      arg = a
+
+      while arg < b do
+        c_step = step
+        begin
+          c_step = reset_step(arg, step) {|xx| fn(xx)}
+        rescue Math::DomainError
+          arg += c_step * 0.1
+        else
+          draw_point(arg, func.call(arg), mul, 'lime')
+        ensure
+          arg += c_step
+        end
+      end
+    end
+
+    ##
+    # show plot
+    def show_window
+      show
+    end
+
+    # @param [Integer] sc
+    def set_scale(sc)
+      @mul = sc
+    end
+
+    def mul
+      @mul || 100
+    end
+
+  end
+end
+
+
+