fortune 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9fc004785ef01cd70f23583a76c0d36cfd7d3607
+  data.tar.gz: eb71d50d976e4d0a78f582e2db63dc5a6947f9c3
+SHA512:
+  metadata.gz: df3008f56c4471c58cad733994baec963df15e064c80c8ddc0a46700417a571031c874e42e1220e4d75e1f396a962ac50cd75283d1cb30b20c3e990a9a0f4e32
+  data.tar.gz: 19695ff2b954f96f74ef008954690d18088d1116d13811db7dae5b54ffc634bc4fa3c05ffff2c515e9eb15c67fb082291db4d2a05185bc0e6663f819be84d10c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color --format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fortune.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Fotom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Fortune
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fortune'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fortune
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fortune.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fortune/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fortune"
+  spec.version       = Fortune::VERSION
+  spec.authors       = ["Malykh Oleg"]
+  spec.email         = ["malykholeg@gmail.com"]
+  spec.description   = %q{Ruby gem for calculate probability, odds and combinations. Mostly helpfull for gambling, e.g. Poker.}
+  spec.summary       = %q{Lib for get changes, odds, probability and combinations for given values}
+  spec.homepage      = "https://github.com/Fotom/Fortune"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end
+
+

data/lib/fortune.rb

@@ -0,0 +1,71 @@
+require "fortune/version"
+
+require 'fortune/p_abstract'
+require 'fortune/a'
+require 'fortune/c'
+require 'fortune/p'
+require 'fortune/c_repetition'
+require 'fortune/event_list'
+require 'fortune/event'
+require 'fortune/odds'
+require 'fortune/pn'
+require 'fortune/pn_repetition'
+
+module Fortune
+
+  factorial = %q{
+    def self.factorial(n)
+      return 1 if n.zero?
+      1.upto(n).inject(:*)
+    end
+  }
+  Math.module_eval(factorial)
+
+  # alias
+  Pnr = Pn_repetition
+
+  # Fortune::Pnr(h) || Fortune.Pnr(h)
+  [:Cr, :C_repetition, :C, :A, :Pnr, :Pn_repetition, :Pn].each{|c|
+    Fortune.module_eval(%|
+      def self.#{c}(h)
+        #{c}.calc(h)
+      end
+    |)
+  }
+
+  # alias
+  Cr = C_repetition
+
+  def self.P(*args)
+    P.new(*args)
+  end
+
+end
+
+class Hash
+
+  def to_P
+    n = 0
+    self.each{|k,v| n += v.to_i}
+    self.each{|k,v| self[k] = Fortune::P(:m => v.to_i, :n => n)}
+    self
+  end
+
+  def to_p
+    self.to_P.each{|k,v| self[k] = v.value}
+    self
+  end
+
+  # {:a => 1, :b => 2, ...}
+  def choose
+    Fortune::Event.select(self)
+  end
+
+  # {[:a, :b] => 1, [:c] => 2, ...} ||
+  #   {10 => 1, 15 => 2, ...}
+  def choose_set
+    Fortune::P.n_select(self)
+  end
+
+end
+

data/lib/fortune/a.rb

@@ -0,0 +1,14 @@
+module Fortune
+
+  # Permutation without repetition with select k elements (accommodation)
+  # example: 20 different elements and you need select 5 of them (how many ways of selection exists?)
+  #   elements is ordered ([a,b,c] != [b,c,a])
+  #   A.calc(:elements => 10, :select => 5)
+  class A < P_abstract
+    def initialize(h)
+      super(h)
+      self.value = Math.factorial(self.n)/Math.factorial(self.n - self.k)
+    end
+  end
+
+end

data/lib/fortune/c.rb

@@ -0,0 +1,14 @@
+module Fortune
+
+  # Combinations without repetition
+  # example: 10 different elements (students) and you need select 5 of them (how many ways of selection exists?)
+  #   elements does not ordered ([a,b,c] == [b,c,a])
+  #   C.calc(:elements => 10, :select => 5)
+  class C < P_abstract
+    def initialize(h)
+      super(h)
+      self.value = Math.factorial(self.n)/(Math.factorial(self.k)*Math.factorial(self.n - self.k))
+    end
+  end
+
+end

data/lib/fortune/c_repetition.rb

@@ -0,0 +1,11 @@
+module Fortune
+
+  # Combination with repetition
+  class C_repetition < P_abstract
+    def initialize(h)
+      super(h)
+      self.value = Math.factorial(self.n + self.k - 1)/(Math.factorial(self.k)*Math.factorial(self.n - 1))
+    end
+  end
+
+end

data/lib/fortune/event.rb

@@ -0,0 +1,30 @@
+module Fortune
+
+  class Event
+    attr_accessor :has_come, :name, :m, :n
+    def initialize(h = {})
+      @has_come = false
+      [:name, :n, :m].each{|k| instance_variable_set("@#{k}", h[k])}
+    end
+    def p(h = {})
+      P.new(:m => self.m, :n => h[:n] || self.n).value
+    end
+    def try(h = {})
+      @has_come = P.is(self.m, h[:n] || self.n)
+      self
+    end
+    def has_come?
+      @has_come
+    end
+    def set_come
+      @has_come = true
+    end
+    def self.list(h = {})
+      EventList.new(h).calc
+    end
+    def self.select(h = {})
+      Event.list(h).active.name
+    end
+  end
+
+end

data/lib/fortune/event_list.rb

@@ -0,0 +1,45 @@
+module Fortune
+
+  class EventList < Array
+    attr_accessor :sum_m, :intervals, :n
+    def initialize(h = {})
+      h.each{|name, m| self.push(Event.new({:name => name, :m => m}))}
+      @sum_m = 0
+      @intervals = {}
+    end
+    def calc
+      self.calc_sum_m
+      self.calc_intervals
+      self.get_n
+      self.set_active
+      self
+    end
+    def set_active
+      self.map{|event|
+        next if event.m <= 0
+        event.set_come if self.n >= intervals[event.name][0] && self.n <= intervals[event.name][1]
+      }
+    end
+    def get_n
+      @n = P.n(self.sum_m)
+    end
+    def calc_sum_m
+      self.map{|event|
+        next if event.m <= 0
+        self.sum_m += event.m
+      }
+    end
+    def calc_intervals
+      x = 0
+      self.map{|event|
+        next if event.m <= 0
+        self.intervals[event.name] = [x + 1, x + event.m]
+        x = x + event.m
+      }
+    end
+    def active
+      self.select{|event| event.has_come?}.first
+    end
+  end
+
+end

data/lib/fortune/odds.rb

@@ -0,0 +1,140 @@
+module Fortune
+
+  # win
+  class Odds
+    include Comparable
+    attr_accessor :p, :s, :k, :type
+
+    def initialize(h = {})
+      # TODO: check p or (s and k) exists
+      h[:s] ||= h[:win]
+      h[:k] ||= h[:lose]
+      [:win, :lose].each{|k| h.delete(k)}
+
+      h.each{|k,v| instance_variable_set("@#{k}", v)}
+      self.p = P.new(s, s + k).value unless self.p
+      self.calc_s_k if !self.k || !self.s
+
+      self.to_win
+    end
+
+    def <=>(other)
+      if self.p < other.p
+        -1
+      elsif self.p > other.p
+        1
+      else
+        0
+      end
+    end
+
+    def to_i
+      self.s, self.k = self.s.to_i, self.k.to_i
+      self
+    end
+
+    def n_all
+      s + k
+    end
+    alias :variants :n_all
+
+    # h = {:k => int, [:fractions => true]}
+    def to_human(h = {:k => 7})
+      min_delta = nil
+      closest_odd = nil
+
+      Odds.human(h).each{|odd|
+        delta = (self.p - odd.p).abs
+        if !min_delta || delta < min_delta
+          min_delta = delta
+          closest_odd = odd
+        end
+      }
+
+      closest_odd
+    end
+
+    def is_on_win?
+      self.type == :on_win
+    end
+
+    def is_on_lose?
+      self.type == :on_lose
+    end
+
+    def to_win
+      self.s_to_k if self.is_on_lose?
+      self.type = :on_win
+      self
+    end
+
+    def s_to_k
+      self.s, self.k = self.k, self.s
+    end
+
+    def to_lose
+      self.s_to_k if self.is_on_win?
+      self.type = :on_lose
+      self
+    end
+
+    def revert
+      self.s_to_k
+      self.p = 1 - self.p
+      self
+    end
+
+    def self.equal
+      Odds.new({:s => 1, :k => 1})
+    end
+
+    def self.human(h)
+      Odds.p_human(h).values
+    end
+
+    def to_s
+      "#{self.s}:#{self.k} #{self.type} (p: #{p_obj.to_percent_string})"
+    end
+
+    def p_obj
+      P.new(self.p)
+    end
+
+    protected
+
+    def calc_s_k
+      self.s = 1
+      self.k = s.to_f/p.to_f - s.to_f
+    end
+
+    private
+
+    def self.p_human(h)
+      p_odds = {Odds.equal.p => Odds.equal}
+      (1..h[:k]).each{|k|
+        (0..k-1).each{|s|
+          Odds.fillup_p_human(p_odds, s, k)
+        }
+      }
+
+      h[:fractions] ? Odds.add_fractions(p_odds, h) : p_odds
+    end
+
+    def self.fillup_p_human(p_odds, s, k)
+      odd = Odds.new({:s => s, :k => k})
+      odd_dup = odd.dup.revert
+      p_odds[odd.p] = odd if not p_odds.has_key?(odd.p)
+      p_odds[odd_dup.p] = odd_dup if not p_odds.has_key?(odd_dup.p)
+    end
+
+    def self.add_fractions(p_odds, h)
+      p_odds_addons = {}
+      p_odds.each{|key, odd|
+        next if odd.k == h[:k]
+        Odds.fillup_p_human(p_odds_addons, odd.s, odd.k + 0.5)
+      }
+      p_odds_addons.merge(p_odds)
+    end
+  end
+
+end

data/lib/fortune/p.rb

@@ -0,0 +1,58 @@
+module Fortune
+
+  class P
+    attr_accessor :p, :m, :n
+
+    # P.new(:m => 1, :n => 10), P.new(1, 10), P.new(0.1)
+    def initialize(m, n_all = nil)
+      m, n_all = m[:m], m[:n] if m.is_a?(Hash)
+      raise ArgumentError.new("Error: p should be less or equal 1") if (!n_all && m > 1) || (n_all && m > n_all)
+      @p = m unless n_all
+      @p = m.to_f/n_all.to_f if n_all
+      @m, @n = m, n_all if n_all
+    end
+
+    def +(other)
+      P.new(self.p + other.p)
+    end
+
+    def *(other)
+      P.new(self.p * other.p)
+    end
+
+    def odds
+      Odds.new(:p => self.p)
+    end
+
+    def to_percent_human
+      self.to_percent.round(2)
+    end
+    alias :to_human :to_percent_human
+
+    def to_percent
+      self.p*100
+    end
+
+    def to_percent_string
+      '%5.2f' % [self.to_percent] + '%'
+    end
+
+    def value
+      self.p
+    end
+
+    def self.is(chance, n_all)
+      P.n(n_all) <= chance
+    end
+    def self.n(n_all)
+      n_all.is_a?(Array) ? n_all.sample : rand(n_all) + 1
+    end
+    # P.n_select([1..10] => 5, [3..15] => 20, ...)
+    #   || P.n_select(10 => 90, 5 => 10)
+    #   || P.n_select([:a, :b] => 1, [:c] => 2)
+    def self.n_select(h = {})
+      P.n(Event.select(h))
+    end
+  end
+
+end

data/lib/fortune/p_abstract.rb

@@ -0,0 +1,19 @@
+module Fortune
+
+  # Permutations
+  class P_abstract
+    attr_accessor :value, :n, :k
+
+    def initialize(h, format = {:n => :elements, :k => :select})
+      raise ArgumentError.new("Error: arguments should be hash") unless h.is_a?(Hash)
+      self.n = h[:n] || h[format[:n]]
+      self.k = h[:k] || h[format[:k]]
+      self.value = h
+    end
+
+    def self.calc(n)
+      self.new(n).value
+    end
+  end
+
+end

data/lib/fortune/pn.rb

@@ -0,0 +1,16 @@
+module Fortune
+
+  # Permutation without repetition
+  # example: the amount of distributions of the four teams in four places (Pn.calc(4))
+  #   Pn.calc(5), Pn.calc(:elements => 5), Pn.calc(:elements => 5, :select => 2)
+  class Pn < P_abstract
+
+    def initialize(h)
+      h = {:n => h} unless h.is_a?(Hash)
+      super(h)
+      self.value = self.k ? A.calc(h) : Math.factorial(self.n)
+    end
+
+  end
+
+end

data/lib/fortune/pn_repetition.rb

@@ -0,0 +1,13 @@
+module Fortune
+
+  # Permutation with repetition
+  # example: how many different options you can dress up if there are three sweaters two skirts and two hats (3*2*2, if all thing is equal 3, then: Pn_repetition(:n => 3, :k => 3), k - element groups, n - elements count in group)
+  #   Pnr.calc(:groups => 10, :elements => 5)
+  class Pn_repetition < P_abstract
+    def initialize(h)
+      super(h, {:n => :groups, :k => :elements})
+      self.value = self.n**self.k
+    end
+  end
+
+end

data/lib/fortune/version.rb

@@ -0,0 +1,3 @@
+module Fortune
+  VERSION = "0.0.1"
+end

data/spec/fortune/a_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Fortune::A do
+
+  describe "calc" do
+    it "get permutation value for 5 from 10" do
+      Fortune::A.calc(:elements => 10, :select => 5).should eq 30240
+    end
+  end
+
+end
+
+

data/spec/fortune/c_repetition_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Fortune::C_repetition do
+
+  describe "calc" do
+    it "get combinations value for 5 from 10" do
+      Fortune::Cr.calc(:elements => 10, :select => 5).should eq 2002
+    end
+  end
+
+end
+
+

data/spec/fortune/c_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Fortune::C do
+
+  describe "calc" do
+    it "get combinations value for 5 from 10" do
+      Fortune::C.calc(:elements => 10, :select => 5).should eq 252
+    end
+  end
+
+end
+
+

data/spec/fortune/event_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Fortune::Event do
+
+  it "should have p" do
+    Fortune::Event.new(:name => :get_prize, :m => 1, :n => 5).p.should eq 0.2
+  end
+  it "certain event should be" do
+    Fortune::Event.new(:name => :get_prize, :m => 1, :n => 1).try.has_come?.should eq true
+  end
+  it "impossible event should not be" do
+    Fortune::Event.new(:name => :get_prize, :m => 0, :n => 1).try.has_come?.should eq false
+  end
+
+end
+
+

data/spec/fortune/odds_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Fortune::Odds do
+
+  before do
+    @odd = Fortune::Odds.new(:win => 1, :lose => 9)
+  end
+
+  it "correct comparison" do
+    @odd.should > Fortune::Odds.new(:win => 1, :lose => 99)
+  end
+  it "calculate variants" do
+    @odd.n_all.should eq 10
+    @odd.variants.should eq 10
+  end
+
+  describe "to_human" do
+    it "convert for 1:7 max" do
+      Fortune::Odds.new(:win => 400, :lose => 891).to_human.should eq Fortune::Odds.new(:win => 3, :lose => 7)
+    end
+    it "convert for 1:10 max" do
+      Fortune::Odds.new(:win => 400, :lose => 891).to_human(:k => 10).should eq Fortune::Odds.new(:win => 4, :lose => 9)
+    end
+  end
+
+  it "revertion" do
+    @odd.revert.should eq Fortune::Odds.new(:win => 9, :lose => 1)
+  end
+
+end
+
+

data/spec/fortune/p_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Fortune::P do
+
+  describe "new" do
+    it "create by n, m params" do
+      Fortune::P.new(:m => 1, :n => 10).value.should eq 0.1
+    end
+    it "create by list params" do
+      Fortune::P.new(1, 10).value.should eq 0.1
+    end
+    it "create by probability params" do
+      Fortune::P.new(0.1).value.should eq 0.1
+    end
+  end
+
+  describe "addition" do
+    it "p + p = 2p" do
+      (Fortune.P(0.1) + Fortune.P(0.2)).p.round(5).should eq Fortune.P(0.3).p.round(5)
+    end
+  end
+
+  describe "multiplication" do
+    it "p*p = p^2" do
+      (Fortune.P(0.1) * Fortune.P(0.2)).p.round(5).should eq Fortune.P(0.02).p.round(5)
+    end
+  end
+
+  describe "odds" do
+    it "calc odds for probability" do
+      Fortune.P(0.1).odds.should eq Fortune::Odds.new(:win => 1, :lose => 9)
+    end
+  end
+
+  it "to_percent conversation" do
+    Fortune.P(0.1).to_percent.should eq 10
+  end
+  it "check event is happen" do
+    Fortune::P.is(1,10**10).should eq false
+  end
+
+  describe "n" do
+    it "get random element from array" do
+      Fortune::P.n([1,1,1]).should eq 1
+    end
+    it "get random element from range" do
+      Fortune::P.n(100).should < 101
+      Fortune::P.n(100).should > 0
+    end
+  end
+
+end
+
+

data/spec/fortune/pn_repetition_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Fortune::Pn_repetition do
+
+  describe "calc" do
+    it "get Permutation with repetition value for 5 elements and 10 groups" do
+      Fortune::Pn_repetition.calc(:elements => 5, :groups => 10).should eq 100000
+    end
+  end
+
+end
+
+

data/spec/fortune/pn_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Fortune::Pn do
+
+  describe "calc" do
+    it "get Permutation value for 5 from 10" do
+      Fortune::Pn.calc(:elements => 10, :select => 5).should eq 30240
+    end
+    it "get Permutation value for 5" do
+      Fortune::Pn.calc(:elements => 5).should eq 120
+    end
+  end
+
+end
+
+

data/spec/fortune_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Fortune do
+
+  describe "P" do
+    it {Fortune.P(0.1).value.should eq(0.1)}
+  end
+
+end
+
+

data/spec/hash_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Hash do
+
+  describe "to_p" do
+    it "convert values to percent" do
+      {:a => 1, :b => 3}.to_p.should == {:a => 0.25, :b => 0.75}
+    end
+  end
+
+  describe "choose" do
+    it "select one element" do
+      [:a, :b].include?({:a => 1, :b => 3}.choose).should be_true
+    end
+    it "select by element weight" do
+      {:a => 1.0/10**5, :b => 1*10**10, :c => 1.0/10**10}.choose.should == :b
+    end
+    it "select one element by weight" do
+      {:a => 1, :b => 0, :c => 0}.choose.should == :a
+    end
+  end
+
+  describe "choose_set" do
+    it "get one from set" do
+      [:a, :b, :c].include?({[:a, :b, :c] => 1, [:d] => 0}.choose_set).should == true
+    end
+  end
+
+end

data/spec/math_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Math do
+
+  it "should have factorial method" do
+    Math.should respond_to :factorial
+  end
+  it "correct calc factorial" do
+    Math.factorial(5).should eq(120)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'fortune'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: fortune
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Malykh Oleg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Ruby gem for calculate probability, odds and combinations. Mostly helpfull
+  for gambling, e.g. Poker.
+email:
+- malykholeg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- fortune.gemspec
+- lib/fortune.rb
+- lib/fortune/a.rb
+- lib/fortune/c.rb
+- lib/fortune/c_repetition.rb
+- lib/fortune/event.rb
+- lib/fortune/event_list.rb
+- lib/fortune/odds.rb
+- lib/fortune/p.rb
+- lib/fortune/p_abstract.rb
+- lib/fortune/pn.rb
+- lib/fortune/pn_repetition.rb
+- lib/fortune/version.rb
+- spec/fortune/a_spec.rb
+- spec/fortune/c_repetition_spec.rb
+- spec/fortune/c_spec.rb
+- spec/fortune/event_spec.rb
+- spec/fortune/odds_spec.rb
+- spec/fortune/p_spec.rb
+- spec/fortune/pn_repetition_spec.rb
+- spec/fortune/pn_spec.rb
+- spec/fortune_spec.rb
+- spec/hash_spec.rb
+- spec/math_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Fotom/Fortune
+licenses:
+- MIT
+metadata: {}
+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.1.11
+signing_key: 
+specification_version: 4
+summary: Lib for get changes, odds, probability and combinations for given values
+test_files:
+- spec/fortune/a_spec.rb
+- spec/fortune/c_repetition_spec.rb
+- spec/fortune/c_spec.rb
+- spec/fortune/event_spec.rb
+- spec/fortune/odds_spec.rb
+- spec/fortune/p_spec.rb
+- spec/fortune/pn_repetition_spec.rb
+- spec/fortune/pn_spec.rb
+- spec/fortune_spec.rb
+- spec/hash_spec.rb
+- spec/math_spec.rb
+- spec/spec_helper.rb