silicium 0.0.14 → 0.0.22

data/lib/silicium/sparse.rb

@@ -0,0 +1,76 @@
+module Silicium
+  require_relative 'sugar'
+  require_relative 'conversions'
+  require_relative 'trans'
+  require_relative 'adding'
+  require_relative 'multi'
+
+  # here goes the sparse module
+  module Sparse
+    # here goes the Sparse class
+    class SparseMatrix
+      attr_reader :triplets
+      attr_reader :n
+      attr_reader :m
+      ##
+      # @param [Integer] rows - Count of rows
+      # @param [Integer] cols - Count of columns
+      #
+      # Initialize matrix with count of rows and columns
+      def initialize(rows, cols)
+        @n = rows
+        @m = cols
+        @triplets = []
+      end
+
+      ##
+      # @return [SparseMatrix::Object] - Returns a copy of a SparseMatrix object
+      #
+      # Creates a copy of matrix object
+      def copy
+        new = SparseMatrix.new(@n, @m)
+        triplets.each do |triplet|
+          new.add(triplet[0], triplet[1], triplet[2])
+        end
+        new
+      end
+
+      ##
+      # @param [Integer] i_pos - The i position of an element
+      # @param [Integer] j_pos - The j position of an element
+      # @param [Integer] elem - The value of an element to be added
+      #
+      # Adds an element to matrix by its position and value
+      def add(i_pos, j_pos, elem)
+        if i_pos > @n || j_pos > @m || i_pos.negative? || j_pos.negative?
+          raise 'out of range'
+        end
+
+        f = false
+        @triplets.each do |item|
+          if item[0] == i_pos && item[1] == j_pos
+            item = [i_pos, j_pos, elem]
+            f =  true
+            break
+          end
+        end
+        @triplets.push([i_pos, j_pos, elem]) unless f
+      end
+
+      ##
+      # @param [Integer] i_pos - The i position of an element
+      # @param [Integer] j_pos - The j position of an element
+      # @return [Integer] The element on i,j position
+      #
+      # Returns an element by its position
+      def get(i_pos, j_pos)
+        triplets.each do |triplet|
+          if triplet[0] == i_pos && triplet[1] == j_pos
+            return triplet[2]
+          end
+        end
+        0
+      end
+    end
+  end
+end

data/lib/silicium/sugar.rb

@@ -0,0 +1,37 @@
+module Silicium
+  module Sparse
+    # addition for SparseMatrix class
+    class SparseMatrix
+      ##
+      # @param [SparseMatrix] other - second matrix for adding
+      # @raise [ArgumentError] If the size of the first matrix doesn't match the size of the second matrix
+      # @return [SparseMatrix] Matrix as the sum of the other two matrices
+      #
+      # Makes the sum of two matrix
+      def +(other)
+        adding(other)
+      end
+
+      ##
+      # @param [SparseMatrix] other - second matrix for adding
+      # @raise [ArgumentError] If the size of the first matrix doesn't match the size of the second matrix
+      # @return [SparseMatrix] Matrix as the sum of the other two matrices
+      #
+      # Makes the sum of two matrix
+      def -(other)
+        adding(other.mult_by_num(-1))
+      end
+
+      ##
+      # @param [SparseMatrix::Object] other - A matrix to multiply to
+      # @raise [ArgumentError] if count of columns of right matrix
+      # doesn't match count of rows of left matrix
+      #
+      # Returns a matrix in its regular view but multiplied by other matrix
+      def *(other)
+        multiply(other)
+      end
+
+    end
+  end
+end

data/lib/silicium/trans.rb

@@ -0,0 +1,26 @@
+module Silicium
+  module Sparse
+    # here goes tha addition to SparseMatrix class
+    class SparseMatrix
+      ##
+      # Returns a transposed copy of matrix
+      def transpose
+        new = copy
+        new.triplets.each do |triplet|
+          triplet[0], triplet[1] = triplet[1], triplet[0]
+        end
+        new
+      end
+
+      ##
+      # Transposes matrix
+      def transpose!
+        triplets.each do |triplet|
+          triplet[0], triplet[1] = triplet[1], triplet[0]
+        end
+      end
+    end
+  end
+end
+
+

data/lib/silicium/version.rb

@@ -1,3 +1,3 @@
-module Silicium
-  VERSION = "0.0.14"
-end
+module Silicium
+  VERSION = "0.0.22"
+end

data/lib/silicium.rb

@@ -1,6 +1,29 @@
-require "silicium/version"
-
-module Silicium
-  class Error < StandardError; end
-  # Your code goes here...
-end
+require 'silicium/version'
+
+module Silicium
+  class Error < StandardError; end
+
+  require_relative 'geometry'
+  require_relative 'graph'
+
+  
+  require_relative 'algebra'
+  require_relative 'algebra_diff'
+  require_relative './geometry'
+  require_relative 'geometry3d'
+  require_relative './graph'
+  require_relative 'graph_visualizer'
+  require_relative 'ml_algorithms'
+  require_relative 'numerical_integration'
+  require_relative 'optimization'
+  require_relative 'plotter'
+  require_relative 'polynomial_division'
+  require_relative 'polynomial_interpolation'
+  require_relative 'regression'
+  require_relative 'theory_of_probability'
+  require_relative 'topological_sort'
+  require_relative 'silicium/sparse'
+  
+
+
+end

data/lib/theory_of_probability.rb

@@ -0,0 +1,240 @@
+require 'plotter'
+require 'chunky_png'
+
+include Silicium::Plotter
+
+module Combinatorics
+
+  def factorial(n)
+    (1..n).inject(:*) || 1
+  end
+
+  ##
+  #Function C(n,k)
+  def combination(n, k)
+    f = fact(n, k)
+    if n < k or k <= 0
+      -1
+    else
+      f[0] / (f[2] * f[1])
+    end
+  end
+
+  ##
+  #Function A(n,k)
+  def arrangement(n, k)
+    f = fact(n, k)
+    if n < k or k <= 0
+      -1
+    else
+      f[0] / f[1]
+    end
+  end
+
+  private
+
+  def fact(n, k)
+    res = [1,1,1]
+    fact_n_greater_1(n, k, res) if n > 1
+    res
+  end
+
+  def fact_n_greater_1(n,k, res)
+    c = 1
+    for i in 2..n
+      c *= i
+      determining_i([i, n, k, c], res)
+    end
+    res[0] = c
+  end
+
+  def determining_i(arr, res)
+    res[1] = arr[3] if arr[0] == arr[1] - arr[2]
+    res[2] = arr[3] if arr[0] == arr[2]
+  end
+
+end
+
+module Dice
+
+  ##
+  # Class represents a polyhedron
+  # csides - number or sides
+  # sides - array of sides(unusual for custom polyhedrons)
+  class Polyhedron
+
+    def csides
+      @csides
+    end
+
+    def sides
+      @sides
+    end
+
+    def to_s
+      sides
+    end
+
+    ##
+    # initializing polyhedron's variables
+    # there are two ways how to create it
+    # 1: by number (6) - creates polyhedron with 6 sides [1,2,3,4,5,6]
+    # 2: by array ([1,3,5]) - creates polyhedron with 3 sides [1,3,5]
+    def initialize(sides)
+      @csides = 1
+      @sides = [1]
+      if sides.class == Integer and sides > 1
+        @csides = sides
+        (2..sides).each {|i| @sides << i}
+      elsif sides.class == Array and sides.size > 0
+        @csides = sides.size
+        @sides = sides.sort
+      end
+    end
+
+    ##
+    # ability to throw a polyhedron
+    def throw
+      @sides[rand(0..@csides-1)]
+    end
+  end
+
+  ##
+  # Class represents a PolyhedronsSet
+  class PolyhedronSet
+
+    def initialize(arr)
+      @pons = parse_pons(arr).sort_by{|item| -item.csides}
+      @percentage = count_chance_sum
+    end
+
+    # hash with chances of getting definite score
+    def percentage
+      @percentage
+    end
+
+    ##
+    # returns array of polyhedrons
+    def to_s
+      @pons.map {|item| item.to_s}
+    end
+
+    ##
+    # ability to throw a polyhedron set using hash of chances
+    def throw
+      sum = 0
+      r = rand
+      @percentage.each do |item|
+        sum += item[1]
+        if sum >= r
+          item[0]
+          break
+        end
+      end
+    end
+
+    ##
+    # creating a graph representing chances of getting points
+    def make_graph_by_plotter(x = percentage.size * 10, y = percentage.size * 10)
+      filename = 'tmp/percentage.png'
+      File.delete(filename) if File.exist?(filename)
+      plotter = Image.new(x, y)
+      plotter.bar_chart(percentage, 1, color('red @ 1.0'))
+      plotter.export(filename)
+    end
+
+    private
+
+    def parse_pons(arr)
+      res = []
+      arr.each do |item|
+        if item.is_a?(Integer) or item.is_a?(Array)
+          res << Polyhedron.new(item)
+        elsif item.is_a?(Polyhedron)
+          res << item
+        end
+      end
+      res
+    end
+
+    def count_chance_sum_chances_step(arr1, arr2, arr3, h)
+      n = 0
+      m = 0
+      sum = 0
+      q = Queue.new
+      h1 = {}
+      while m < arr2.size
+        sum = m_0([sum, n, m], q, h, arr1)
+        sum -= q.pop if q.size > arr2.size || m > 0
+        h1[arr1[n] + arr2[m]] = sum
+        arr3 << (arr1[n] + arr2[m])
+        nmarr = n_less_arr1_size(n, arr1, m)
+        n, m = nmarr[0], nmarr[1]
+      end
+      h1
+    end
+
+    def m_0(arr, q, h, arr1)
+      if arr[2] == 0
+        a = h[arr1[arr[1]]]
+        q << a
+        arr[0] += a
+      end
+      arr[0]
+    end
+
+    def n_less_arr1_size(n, arr1, m)
+      if n < arr1.size - 1
+        n += 1
+      else
+        m += 1
+      end
+      [n,m]
+    end
+
+    def count_chance_sum
+      h = {}
+      @pons[0].sides.each { |item| h[item] = 1 }
+      arr3 = @pons[0].sides
+      for i in 1..@pons.size - 1
+        arr1 = arr3
+        arr3 = []
+        arr2 = @pons[i].sides
+        h1 = count_chance_sum_chances_step(arr1, arr2, arr3, h)
+        h = h1
+      end
+      res = {}
+      fchance = @pons.inject(1) { |mult, item| mult * item.csides }
+      arr3.each {|item| res[item] = Float(h[item]) / fchance}
+      res
+    end
+
+  end
+end
+
+module BernoulliTrials
+
+  include Combinatorics
+  include Math
+
+  def bernoulli_formula_and_laplace_theorem(n, k, all, suc = -1)
+    if suc != -1
+      p = suc.fdiv all
+    else
+      p = all
+    end
+    q = 1 - p
+    if n * p * q < 9         # Laplace theorem give satisfactory approximation for n*p*q > 9, else Bernoulli formula
+      combination(n, k) * (p ** k) * (q ** (n - k))          # Bernoulli formula C(n,k) * (p ^ k) * (q ^ (n-k))
+    else
+      gaussian_function((k - n * p).fdiv sqrt(n * p * q)).fdiv(sqrt(n * p * q))        # Laplace theorem φ((k - n*p)/sqrt(n*p*q)) / sqrt(n*p*q)
+    end
+  end
+
+  def gaussian_function(x)
+    if x < 0           # φ(-x) = φ(x)
+      x * -1
+    end
+    exp(-(x ** 2) / 2).fdiv sqrt(2 * PI)      # φ(x) = exp(-(x^2/2)) / sqrt(2*π)
+  end
+end

data/lib/topological_sort.rb

@@ -0,0 +1,50 @@
+require "set"
+
+module Silicium
+  module Graphs
+    class Graph
+      attr_accessor :nodes
+
+      def initialize
+        @nodes = []
+      end
+
+      def add_edge(from, to)
+        from.adjacents << to
+      end
+    end
+
+    class Node
+      attr_accessor :name, :adjacents
+
+      def initialize(name)
+        # using Set instead of an Array to avoid duplications
+        @adjacents = Set.new
+        @name = name
+      end
+
+      def to_s
+        @name
+      end
+    end
+
+    class TopologicalSortClass
+      attr_accessor :post_order
+
+      def initialize(graph)
+        @post_order = []
+        @visited = []
+
+        graph.nodes.each { |node| dfs(node) unless @visited.include?(node)}
+      end
+
+      private
+      def dfs(node)
+        @visited << node
+        node.adjacents.each { |adj_node| dfs(adj_node) unless @visited.include?(adj_node)}
+
+        @post_order << node
+      end
+    end
+  end
+end