silicium 0.0.15 → 0.0.20

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

data/lib/plotter.rb

@@ -0,0 +1,96 @@
+require 'silicium'
+require 'chunky_png'
+
+module Silicium
+  module Plotter
+    ##
+    # 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; ChunkyPNG::Color.parse(args.first)
+      when 2; (ChunkyPNG::Color.parse(args.first) & 0xffffff00) | args[1].to_i
+      when 3; ChunkyPNG::Color.rgb(*args)
+      when 4; ChunkyPNG::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
+      ##
+      # Creates a new plot with chosen +width+ and +height+ parameters
+      # with background colored +bg_color+
+      def initialize(width, height, bg_color = ChunkyPNG::Color::TRANSPARENT)
+        @image = ChunkyPNG::Image.new(width, height, bg_color)
+      end
+
+      def rectangle(x, y, width, height, color)
+        x_end = x + width - 1
+        y_end = y + height - 1
+        (x..x_end).each do |i|
+          (y..y_end).each do |j|
+            @image[i, j] = color
+          end
+        end
+      end
+
+      ##
+      # 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 = ChunkyPNG::Color('red @ 1.0'), axis_color = ChunkyPNG::Color::BLACK)
+        if bars.count * bar_width > @image.width
+          raise ArgumentError, 'Not enough big size of image to plot these number of bars'
+        end
+
+        padding = 5
+        # Values of x and y on borders of plot
+        minx = [bars.collect { |k, _| k }.min, 0].min
+        maxx = [bars.collect { |k, _| k }.max, 0].max
+        miny = [bars.collect { |_, v| v }.min, 0].min
+        maxy = [bars.collect { |_, v| v }.max, 0].max
+        dpux = Float((@image.width - 2 * padding)) / (maxx - minx + bar_width) # Dots per unit for X
+        dpuy = Float((@image.height - 2 * padding)) / (maxy - miny) # Dots per unit for Y
+        rectangle(padding, @image.height - padding - (miny.abs * dpuy).ceil, @image.width - 2 * padding, 1, axis_color) # Axis OX
+        rectangle(padding + (minx.abs * dpux).ceil, padding, 1, @image.height - 2 * padding, axis_color) # Axis OY
+
+        bars.each do |x, y| # Cycle drawing bars
+          rectangle(padding + ((x + minx.abs) * dpux).floor,
+                    @image.height - padding - (([y, 0].max + miny.abs) * dpuy).ceil + (y.negative? ? 1 : 0),
+                    bar_width, (y.abs * dpuy).ceil, bars_color)
+        end
+      end
+
+      ##
+      # Exports plotted image to file +filename+
+      def export(filename)
+        @image.save(filename, :interlace => true)
+      end
+    end
+  end
+end

data/lib/silicium.rb

@@ -2,5 +2,4 @@ require "silicium/version"
 
 module Silicium
   class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/silicium/version.rb

@@ -1,3 +1,3 @@
 module Silicium
-  VERSION = "0.0.15"
+  VERSION = "0.0.20"
 end

data/lib/theory_of_probability.rb

@@ -0,0 +1,227 @@
+require 'silicium'
+require 'plotter'
+require 'chunky_png'
+
+include Silicium::Plotter
+module Silicium
+
+  module Combinatorics
+
+    def factorial(n)
+      res = (1..n).inject(:*) || 1
+      res
+    end
+
+    ##
+    #Factorial for counting 3 parameters in one run
+    def fact(n, k)
+      res = [1,1,1]
+      if n > 1
+        fact_n_greater_1(n, k, res)
+      end
+      res
+    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_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)
+      if arr[0] == arr[1] - arr[2]
+        res[1] = arr[3]
+      end
+      if arr[0] == arr[2]
+        res[2] = arr[3]
+      end
+    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
+    # percentage - hash with chances of getting definite score
+    class PolyhedronSet
+
+      def initialize(arr)
+        @pons = parse_pons(arr).sort_by{|item| -item.csides}
+        @percentage = count_chance_sum
+      end
+
+      def percentage
+        @percentage
+      end
+
+      ##
+      # returns array of polyhedrons
+      def to_s
+        res = @pons.map {|item| item.to_s}
+        res
+      end
+
+      ##
+      # ability to throw a polyhedron's 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|
+          res << Polyhedron.new(item)
+        end
+        res
+      end
+
+      def count_chance_sum_chances_step(arr1, arr2, arr3, h)
+        n = 0
+        m = 0
+        sum = 0
+        q = Queue.new
+        h1 = Hash.new
+        while m < arr2.size
+          sum = m_0([sum, n, m], q, h, arr1)
+          if q.size > arr2.size or m > 0
+            sum -= q.pop
+          end
+          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 = Hash.new
+        @pons[0].sides.each do |item|
+          h[item] = 1
+        end
+        arr3 = @pons[0].sides
+        for i in 1..@pons.size - 1
+          arr1 = arr3
+          arr3 = Array.new
+          arr2 = @pons[i].sides
+          h1 = count_chance_sum_chances_step(arr1, arr2, arr3, h)
+          h = h1
+          h1 = Hash.new
+        end
+        res = Hash.new
+        fchance = @pons.inject(1) { |mult, item| mult * item.csides }
+        arr3.each {|item| res[item] = Float(h[item]) / fchance}
+        res
+      end
+
+    end
+  end
+end