silicium 0.0.2 → 0.0.14

data/lib/geometry.rb

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

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

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

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