silicium 0.0.2

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/version.rb

@@ -0,0 +1,3 @@
+module Silicium
+  VERSION = "0.0.2"
+end

data/lib/silicium.rb

@@ -0,0 +1,5 @@
+require "silicium/version"
+
+module Silicium
+  class Error < StandardError; end
+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

data/silicium.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "silicium/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "silicium"
+  spec.version       = Silicium::VERSION
+  spec.authors       = ["mmcs-ruby"]
+  spec.email         = ["poganesyan@sfedu.ru"]
+
+  spec.summary       = %q{Ruby math library made as exercise by MMCS students .}
+  spec.description   = %q{Long list of applied functions}
+ # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = "MIT"
+
+=begin
+
+  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+=end
+  spec.metadata["source_code_uri"] = 'https://github.com/mmcs-ruby/silicium'
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'simplecov'
+
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: silicium
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- mmcs-ruby
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Long list of applied functions
+email:
+- poganesyan@sfedu.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/Object.html
+- docs/README_md.html
+- docs/Silicium.html
+- docs/Silicium/Combinatorics.html
+- docs/Silicium/Dice.html
+- docs/Silicium/Dice/Polyhedron.html
+- docs/Silicium/Dice/PolyhedronSet.html
+- docs/Silicium/Error.html
+- docs/Silicium/Geometry.html
+- docs/Silicium/Geometry/Line2dCanon.html
+- docs/Silicium/Geometry/VariablesOrderException.html
+- docs/Silicium/Graphs.html
+- docs/Silicium/Graphs/GraphError.html
+- docs/Silicium/Graphs/OrientedGraph.html
+- docs/Silicium/Graphs/UnorientedGraph.html
+- docs/Silicium/IntegralDoesntExistError.html
+- docs/Silicium/NumericalIntegration.html
+- docs/Silicium/Optimization.html
+- docs/Silicium/Plotter.html
+- docs/Silicium/Plotter/Image.html
+- docs/created.rid
+- docs/css/fonts.css
+- docs/css/rdoc.css
+- docs/fonts/Lato-Light.ttf
+- docs/fonts/Lato-LightItalic.ttf
+- docs/fonts/Lato-Regular.ttf
+- docs/fonts/Lato-RegularItalic.ttf
+- docs/fonts/SourceCodePro-Bold.ttf
+- docs/fonts/SourceCodePro-Regular.ttf
+- docs/images/add.png
+- docs/images/arrow_up.png
+- docs/images/brick.png
+- docs/images/brick_link.png
+- docs/images/bug.png
+- docs/images/bullet_black.png
+- docs/images/bullet_toggle_minus.png
+- docs/images/bullet_toggle_plus.png
+- docs/images/date.png
+- docs/images/delete.png
+- docs/images/find.png
+- docs/images/loadingAnimation.gif
+- docs/images/macFFBgHack.png
+- docs/images/package.png
+- docs/images/page_green.png
+- docs/images/page_white_text.png
+- docs/images/page_white_width.png
+- docs/images/plugin.png
+- docs/images/ruby.png
+- docs/images/tag_blue.png
+- docs/images/tag_green.png
+- docs/images/transparent.png
+- docs/images/wrench.png
+- docs/images/wrench_orange.png
+- docs/images/zoom.png
+- docs/index.html
+- docs/js/darkfish.js
+- docs/js/navigation.js
+- docs/js/navigation.js.gz
+- docs/js/search.js
+- docs/js/search_index.js
+- docs/js/search_index.js.gz
+- docs/js/searcher.js
+- docs/js/searcher.js.gz
+- docs/table_of_contents.html
+- lib/geometry.rb
+- lib/graph.rb
+- lib/numerical_integration.rb
+- lib/optimization.rb
+- lib/plotter.rb
+- lib/silicium.rb
+- lib/silicium/version.rb
+- lib/theory_of_probability.rb
+- silicium.gemspec
+homepage: 
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/mmcs-ruby/silicium
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Ruby math library made as exercise by MMCS students .
+test_files: []