silicium 0.0.2

data/lib/geometry.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Silicium
+
+  module Geometry
+
+    ##
+    # Represents a point as two coordinates
+    # in two-dimensional space
+    Point = Struct.new(:x, :y)
+
+    ##
+    # Represents a point as three coordinates
+    # in three-dimensional space
+    Point3d = Struct.new(:x, :y, :z)
+
+    ##
+    #Calculates the distance from given points in two-dimensional space
+    def distance_point_to_point2d(a, b)
+      Math.sqrt((b.x - a.x)**2 + (b.y - a.y)**2)
+    end
+
+    # Class represents a line as equation y = k*x +b
+    # k - slope
+    # b - free_term
+    # in two-dimensional space
+    class Line2dCanon
+      attr_reader :slope
+      attr_reader :free_term
+
+      def initialize(p1, p2)
+        if (p1.x == p2.x) && (p1.y == p2.y)
+          raise ArgumentError, "You need 2 diffrent points"
+        end
+        if (p1.x == p2.x)
+          raise ArgumentError, "The straight line equation cannot be written in canonical form"
+        end
+        @slope = (p2.y - p1.y) / (p2.x - p1.x).to_f
+        @free_term = (p2.x * p1.y - p2.y * p1.x) / (p2.x - p1.x).to_f
+      end
+
+      ##
+      # Checks the point lies on the line or not
+      def point_is_on_line?(p1)
+        p1.y == @slope * p1.x + @free_term
+      end
+    end
+
+
+    ##
+    # Calculates the distance from given points in three-dimensional space
+    def distance_point_to_point3d(a, b)
+      Math.sqrt((b.x - a.x)**2 + (b.y - a.y)**2 + (b.z - a.z)**2)
+    end
+
+    ##
+    # The distance from a point to a line on a plane
+    # The line is defined by two points
+    # https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
+    def distance_point_line2d(p1, p2, a)
+      line_segment_length = distance_point_to_point2d(p1, p2)
+      ((p2.y - p1.y) * a.x - (p2.x - p1.x) * a.y + p2.x * p1.y - p2.y * p1.x).abs / (line_segment_length * 1.0)
+    end
+    
+    ##
+    # The distance from a point to a line on a plane
+    # Line defined by an equation
+    # return 0 if the equation does not define a line.
+    def distance_point_line_equation2d(a, b, c, p)
+      if a == 0 and b == 0
+        return 0
+      end
+      (a * p.x + b * p.y + c).abs / Math.sqrt(a**2 + b**2)
+    end
+
+    def oriented_area(a, b, c)
+      a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)
+    end
+
+    ##
+    # Determines if a clockwise crawl is performed
+    # for defined order of points
+    def clockwise(a, b, c)
+      oriented_area(a, b, c).negative?
+    end
+
+    ##
+    # Determines if a counter-clockwise crawl is
+    # performed for defined order of points
+    def counter_clockwise(a, b, c)
+      oriented_area(a, b, c).positive?
+    end
+
+    def not_polygon?(points)
+      points.empty? || points.size == 1 || points.size == 2
+    end
+
+    def put_point_in_part(part, point, direction)
+      direction = method(direction)
+      while part.size >= 2 && !direction.call(part[part.size - 2], part[part.size - 1], point)
+        part.pop
+      end
+      part.push(point)
+    end
+
+    ##
+    # Returns an array containing points that are included
+    # in the minimal convex hull for a given array of points
+    # https://e-maxx.ru/algo/convex_hull_graham
+    def minimal_convex_hull_2d(points)
+      return points if not_polygon?(points)
+
+      points.sort_by! { |p| [p.x, p.y] }
+      first = points[0]
+      last = points.last
+      up = [first]
+      down = [first]
+
+      (1...points.size).each do |i|
+        point = points[i]
+        is_last = i == points.size - 1
+        if is_last || clockwise(first, point, last)
+          put_point_in_part(up, point, :clockwise)
+        end
+        if is_last || counter_clockwise(first, point, last)
+          put_point_in_part(down, point, :counter_clockwise)
+        end
+      end
+
+      hull = up
+      (1..(down.size - 2)).reverse_each do |j|
+        hull.push(down[j])
+      end
+      hull
+    end
+
+    def process_cf(line_equation, variable)
+      if line_equation.include?(variable)
+        before = line_equation.index('/') + 1
+        after = line_equation.index('=')
+        line_equation.slice(before..after).gsub('=', '').sub('*', '').gsub('(', '').gsub(')', '').to_f
+      else
+        0.0
+      end
+    end
+
+    def cut_by_eq(line_equation)
+      line_equation.slice(line_equation.index('='), line_equation.length).sub('=', '')
+    end
+
+    def process_line_by_coordinates(line_equation, func)
+      copy_line = insert_eq(line_equation)
+      func = method(func)
+      res = []
+      res[0] = func.call(copy_line, 'x')
+      copy_line = cut_by_eq(copy_line)
+      res[1] = func.call(copy_line, 'y')
+      copy_line = cut_by_eq(copy_line)
+      res[2] = func.call(copy_line, 'z')
+      res
+    end
+
+    ##
+    # Creates an array- directing vector in three-dimensional space .
+    # The equation is specified in the canonical form.
+    # Example, (x-0) / 26 = (y + 300) / * (- 15) = (z-200) / 51
+    #
+    # Important: mandatory order of variables: x, y, z
+    def directing_vector3d(line_equation)
+      process_line_by_coordinates(line_equation, :process_cf)
+    end
+
+    class VariablesOrderException < Exception
+    end
+
+    def needed_variables_order?(before, after)
+      before < after
+    end
+
+    def process_free_member(line_equation, variable)
+      if line_equation.include?(variable)
+        before = line_equation.index(variable) + 1
+        after = line_equation.index('/')
+
+        unless needed_variables_order?(before, after)
+          throw VariablesOrderException
+        end
+
+        line_equation.slice(before..after).gsub('/', '').to_f * (-1)
+      else
+        0.0
+      end
+    end
+
+    ##
+    # Creates an array of coordinates of the point ([x, y, z] on the line
+    # given by the equation in the canonical form.
+    # Example, (x-0) / 26 = (y + 300) / * (- 15) = (z-200) / 51
+    #
+    # Important: mandatory order of variables: x, y, z
+    def height_point_3d(line_equation)
+      process_line_by_coordinates(line_equation, :process_free_member)
+    end
+
+    def vectors_product(v1, v2)
+      res = Array.new(3)
+      (0..2).each do |i|
+        res[i] = v1[(i + 1) % 3] * v2[(i + 2) % 3] - v1[(i + 2) % 3] * v2[(i + 1) % 3]
+      end
+      res
+    end
+
+    def vector_length(vector)
+      Math.sqrt(vector[0]**2 + vector[1]**2 + vector[2]**2)
+    end
+
+    ##
+    # Calculates the distance from a point given by a Point3d structure
+    # to a straight line given by a canonical equation.
+    # Example, (x-0) / 26 = (y + 300) / * (- 15) = (z-200) / 51
+    #
+    # Important: mandatory order of variables: x, y, z
+    def point_to_line_distance_3d(point, line_eq)
+      dir_vector = directing_vector3d(line_eq)
+      line_point = height_point_3d(line_eq)
+      height_vector = [line_point[0] - point.x, line_point[1] - point.y, line_point[2] - point.z]
+
+      height_on_dir = vectors_product(height_vector, dir_vector)
+      vector_length(height_on_dir) / vector_length(dir_vector)
+    end
+
+    def insert_eq(line_equation)
+      line_equation.gsub(' ', '').insert(line_equation.length, '=')
+    end
+  end
+end

data/lib/graph.rb

@@ -0,0 +1,164 @@
+#require 'set'
+#require 'silicium'
+
+module Silicium
+  module Graphs
+    Pair = Struct.new(:first, :second)
+
+    class GraphError < Error
+
+    end
+
+    class OrientedGraph
+      def initialize(initializer = [])
+        @vertices = {}
+        @edge_labels = {}
+        @vertex_labels = {}
+        initializer.each do |v|
+          add_vertex!(v[:v])
+          v[:i].each { |iv| add_edge_force!(v[:v], iv)}
+        end
+      end
+
+      def add_vertex!(vertex_id)
+        if @vertices.has_key?(vertex_id)
+          return
+        end
+        @vertices[vertex_id] = [].to_set
+      end
+
+      def add_edge!(from, to)
+        if @vertices.has_key?(from) && @vertices.has_key?(to)
+          @vertices[from] << to
+        end
+      end
+
+      # should only be used in constructor
+      def add_edge_force!(from, to)
+        add_vertex!(from)
+        add_vertex!(to)
+        add_edge!(from, to)
+      end
+
+      def adjacted_with(vertex)
+        unless @vertices.has_key?(vertex)
+          raise GraphError.new("Graph does not contain vertex #{vertex}")
+        end
+
+        @vertices[vertex].clone
+      end
+
+      def label_edge!(from, to, label)
+        unless @vertices.has_key?(from) && @vertices[from].include?(to)
+          raise GraphError.new("Graph does not contain edge (#{from}, #{to})")
+        end
+
+        @edge_labels[Pair.new(from, to)] = label
+      end
+
+      def label_vertex!(vertex, label)
+        unless @vertices.has_key?(vertex)
+          raise GraphError.new("Graph does not contain vertex #{vertex}")
+        end
+
+        @vertex_labels[vertex] = label
+      end
+
+      def get_edge_label(from, to)
+        if !@vertices.has_key?(from) || ! @vertices[from].include?(to)
+          raise GraphError.new("Graph does not contain edge (#{from}, #{to})")
+        end
+
+        @edge_labels[Pair.new(from, to)]
+      end
+
+      def get_vertex_label(vertex)
+        unless @vertices.has_key?(vertex)
+          raise GraphError.new("Graph does not contain vertex #{vertex}")
+        end
+
+        @vertex_labels[vertex]
+      end
+
+      def vertex_number
+        @vertices.count
+      end
+
+      def edge_number
+        res = 0
+        @vertices.values.each do |item|
+          res += item.count
+        end
+        res
+      end
+
+      def vertex_label_number
+        @vertex_labels.count
+      end
+
+      def edge_label_number
+        @edge_labels.count
+      end
+
+      def has_vertex?(vertex)
+        @vertices.has_key?(vertex)
+      end
+
+      def has_edge?(from, to)
+        @vertices.has_key?(from) && @vertices[from].include?(to)
+      end
+
+      def delete_vertex!(vertex)
+        if has_vertex?(vertex)
+          @vertices.keys.each do |key|
+            delete_edge!(key, vertex)
+          end
+          @vertices.delete(vertex)
+          @vertex_labels.delete(vertex)
+
+          @vertices.keys.each do |key|
+            @edge_labels.delete(Pair.new(vertex, key))
+          end
+        end
+      end
+
+      def delete_edge!(from, to)
+        if has_edge?(from, to)
+          @vertices[from].delete(to)
+          @edge_labels.delete(Pair.new(from, to))
+        end
+      end
+
+    end
+
+    class UnorientedGraph < OrientedGraph
+      def add_edge!(from, to)
+        super(from, to)
+        super(to, from)
+      end
+
+      def label_edge!(from, to, label)
+        super(from, to, label)
+        super(to, from, label)
+      end
+
+      def delete_edge!(from, to)
+        super(from, to)
+        super(to, from)
+      end
+
+      def edge_number
+        res = 0
+        @vertices.each do |from, tos|
+          tos.each {|to| res += (to == from ? 2 : 1)}
+        end
+        res / 2
+      end
+    end
+
+    def dijkstra_algorythm(graph, starting_vertex)
+      #
+    end
+  end
+
+end

data/lib/numerical_integration.rb

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

data/lib/optimization.rb

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