silicium 0.0.2 → 0.0.14

data/lib/plotter.rb

@@ -1,96 +0,0 @@
-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/theory_of_probability.rb

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