rational_choice 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d9c8ce05833c10354ed5a50430c8a2d23c605b8
+  data.tar.gz: 6f3f5990f6484cd086da5226903e79bd2948a643
+SHA512:
+  metadata.gz: 09fadb723ab85663042ce147028c5144b62fd80c605b601d638a00285963e7970bd4018e20bbd42404ccba2707f5c026a1e620e83e8535517b6f28e24ec8e07d
+  data.tar.gz: 68b35d64dc97aba4466da942f77dc161eb2b3933dc5a98c77a500239edd042f6031df5c1e9f6ca5b481ad03e689cedb64bae53b508b2079a24a4b98ab317581f

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 2.0.0
+  - 2.1.1
+  - 2.2.0
+cache: bundler
+sudo: false 

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+group :development do
+  gem 'yard'
+  gem "rspec", "~> 3.4.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 WeTransfer
+
+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,47 @@
+# rational_choice
+
+Makes a fuzzy logic choice based on a continuum of values. For when a "yes or no" is not-quite-good-enough.
+
+## Choice on one dimension of values
+
+Primary use is for things like load balancing. Imagine you have a server handling 14 connections,
+and you know that it can take about 20 maximum. When you decide whether to send the connection
+number 17 to it, you want to take a little margin and only send that connection sometimes, to
+balance the choices - so you want to use a softer bound (a bit of a fuzzy logic).
+
+    will_accept_connection = RationalChoice::Dimension.new(20, 10) # ten connections is always safe
+    if will_accept_connection.choose(server.current_connection_count + 1) # will give you a fuzzy choice
+      server.accept(new_client)
+    else
+      ... # over capacity at the moment, try later
+    end
+
+This way the return value of `choose()` will be determined by the probability of the value being `true` - i.e.
+how close it is to the upper bound. Values at or below the lower bound will always choose `false`. Values at
+or above the upper bound will always choose `true`.
+
+## Choice on multiple dimensions
+
+Useful to give rational choices on multiple values, averaged together.
+
+    num_clients = Dimension.new(200, 100)
+    bandwidth = Dimension.new(2048, 1024)
+    has_capacity = ManyDimensions.new(num_clients, bandwidth)
+    
+    will_accept_connection = has_capacity.choose(current_client_count, current_bandwidth)
+
+## Contributing to rational_choice
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2015 WeTransfer. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require_relative 'lib/rational_choice'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.version = RationalChoice::VERSION
+  gem.name = "rational_choice"
+  gem.homepage = "https://github.com/wetransfer/rational_choice"
+  gem.license = "MIT"
+  gem.description = %Q{Fuzzy logic gate}
+  gem.summary = %Q{Makes life-concerning choices based on an informed coin toss}
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'README*']   # optional
+  t.options = ['--markup markdown'] # optional
+  t.stats_options = ['--list-undoc']         # optional
+end

data/lib/rational_choice.rb

@@ -0,0 +1,110 @@
+# Tiny fuzzy-logic gate for making choices based on a continuum of permitted values
+# as opposed to a hard condition.
+module RationalChoice
+  VERSION = '1.0.0'
+  
+  # Gets raised when a multidimensional choice has to be made with a wrong number
+  # of values versus the number of dimensions
+  CardinalityError = Class.new(ArgumentError)
+  
+  # Gets raised when a dimension has to be created with the same parameters
+  DomainError = Class.new(ArgumentError)
+  
+  # Represents a fuzzy choice on a single dimension (one real number)
+  class Dimension
+    # Initializes a new Dimension to evaluate values
+    #
+    # @param false_bound[#to_f, #<=>] the lower bound, at or below which the value will be considered false
+    # @param true_bound[#to_f, #<=>] the upper bound, at or above which the value will be considered true
+    def initialize(false_bound, true_bound)
+      raise DomainError, "Bounds were the same at #{false_bound}" if false_bound == true_bound
+      
+      @lower, @upper = [false_bound, true_bound].sort
+      @flip_sign = [@lower, @upper].sort != [false_bound, true_bound]
+    end
+    
+    # Evaluate a value against the given false and true bound.
+    #
+    # If the value is less than or equal to the false bound, the method will return `false`.
+    # If the value is larger than or equal to the true bound, the method will return 'true'.
+    #
+    # If the value is between the two bounds, the method will first determine the probability
+    # of the value being true, based on a linear interpolation.
+    # For example:
+    #
+    #     d = Dimension.new(0, 1)
+    #     d.choose(0) # => false
+    #     d.choose(1) # => true
+    #     d.choose(0.5) #=> will be `true` in 50% of the cases (probability of 0.5)
+    #     d.choose(0.1) #=> will be `true` in 10% of the cases (probability of 0.1)
+    #
+    # Primary use is for things like load balancing. Imagine you have a server handling 14 connections,
+    # and you know that it can take about 20 maximum. When you decide whether to send the connection
+    # number 17 to it, you want to take a little margin and only send that connection sometimes, to
+    # balance the choices - so you want to use a softer bound (a bit of a fuzzy logic).
+    #
+    #     will_accept_connection = Dimension.new(20, 10) # ten connections is always safe
+    #     will_accept_connection.choose(server.current_connection_count + 1) # will give you a fuzzy choice
+    #
+    # @param value[#to_f, Comparable] a value to be evaluated (must be coercible to a Float and Comparable)
+    # @return [Boolean] the chosen value based on probability and randomness
+    def choose(value)
+      choice = if !fuzzy?(value)
+        value >= @upper
+      else
+        # Interpolate the probability of the value being true
+        delta = @upper.to_f - @lower.to_f
+        v = (value - @lower).to_f
+        t = (v / delta)
+    
+        r = Random.new # To override in tests if needed
+        r.rand < t
+      end
+      choice ^ @flip_sign
+    end
+    
+    # Tells whether the evaluation will use the probabilities or not
+    # (whether the given value is within the range where probability evaluation will take place).
+    #
+    # @param value[Comparable] a value to be evaluated (must be comparable)
+    # @return [Boolean] whether choosing on this value will use probabilities or not
+    def fuzzy?(value)
+      value > @lower && value < @upper
+    end
+  end
+  
+  # Performs an evaluation based on multiple dimensions. The dimensions
+  # will be first coerced into one (number of truthy evaluations vs. number of falsey evaluations)
+  # and then a true/false value will be deduced from that.
+  class ManyDimensions
+    def initialize(*dimensions)
+      @dimensions = dimensions
+      raise CardinalityError, "%s has no dimensions to evaluate" % inspect if @dimensions.empty?
+    end
+    
+    # Performs a weighted choice, by first collecting choice results from all the dimensions,
+    # and then by interpolating those results by the ratio of truthy values vs falsey values.
+    #
+    #     x = Dimension.new(0,1)
+    #     y = Dimension.new(0,1)
+    #     z = Dimension.new(0,1)
+    #     
+    #     within_positive_3d_space = ManyDimensions.new(x, y, z)
+    #     within_positive_3d_space.choose(-1, -1, -0.5) #=> false
+    #     within_positive_3d_space.choose(1.1, 123, 1) #=> true
+    #     within_positive_3d_space.choose(1, 0.5, 0.7) #=> true or false depending on 3 probabilities
+    #
+    # @param values[Array<Comparable,#to_f>] an array of values of the same size as the `dimensions` given to `initialize`
+    # @return [Boolean] true or false
+    def choose(*values)
+      if @dimensions.length != values.length
+        raise CardinalityError, "%s has %d dimensions but %d values were given" % [inspect, @dimensions.length, values.length]
+      end
+      
+      evaluations = values.zip(@dimensions).map { |(v, d)| d.choose(v) }
+      num_truthy_choices = evaluations.select{|e| e}.length
+      
+      Dimension.new(0, evaluations.length).choose(num_truthy_choices)
+    end
+  end
+end

data/rational_choice.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: rational_choice 1.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "rational_choice"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2015-12-06"
+  s.description = "Fuzzy logic gate"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "lib/rational_choice.rb",
+    "rational_choice.gemspec",
+    "spec/rational_choice/dimension_spec.rb",
+    "spec/rational_choice/many_dimensions_spec.rb",
+    "spec/rational_choice_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "https://github.com/wetransfer/rational_choice"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Makes life-concerning choices based on an informed coin toss"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.4.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+    else
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 3.4.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    end
+  else
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 3.4.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+  end
+end
+

data/spec/rational_choice/dimension_spec.rb

@@ -0,0 +1,136 @@
+require_relative '../spec_helper'
+
+describe 'RationalChoice::Dimension' do
+  describe '.new' do
+    it 'raises a DomainError if the bounds are the same' do
+      expect {
+        RationalChoice::Dimension.new(2,2)
+      }.to raise_error(/Bounds were the same at 2/)
+    end
+  end
+  
+  describe 'with values at or beyound the thresholds' do
+    it 'always evaluates to true for values above upper threshold' do
+      d = RationalChoice::Dimension.new(0, 1)
+      10_000.times do
+        expect(d.choose(1.1)).to eq(true)
+      end
+    end
+    
+    it 'always evaluates to true for values at upper threshold' do
+      d = RationalChoice::Dimension.new(0, 1)
+      10_000.times do
+        expect(d.choose(1)).to eq(true)
+      end
+    end
+    
+    it 'always evaluates to false for values at lower threshold' do
+      d = RationalChoice::Dimension.new(0, 1)
+      10_000.times do
+        expect(d.choose(0)).to eq(false)
+      end
+    end
+    
+    it 'always evaluates to false for values below lower threshold' do
+      d = RationalChoice::Dimension.new(0, 1)
+      10_000.times do
+        expect(d.choose(-0.0001)).to eq(false)
+      end
+    end
+  end
+  
+  describe 'with values between thresholds creates a sensible choice distribution' do
+    it 'for 0.5 on a continuum from 0 to 1' do
+      d = RationalChoice::Dimension.new(0, 1)
+      expect(d).to be_fuzzy(0.5)
+      
+      trues = 0
+      
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(0.5) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 2)
+    end
+    
+    it 'for 0.1 on a continuum from 0 to 1' do
+      d = RationalChoice::Dimension.new(0, 1)
+      expect(d).to be_fuzzy(0.1)
+      
+      trues = 0
+      
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(0.1) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 10)
+    end
+    
+    it 'for 0.5 on a continuum from 1 to 0' do
+      d = RationalChoice::Dimension.new(1, 0)
+      expect(d).to be_fuzzy(0.5)
+      
+      falses = 0
+      n_evaluations = 100_000
+      n_evaluations.times { falses += 1 if !d.choose(0.5) }
+      
+      expect(falses).to be_within(1000).of(n_evaluations / 2)
+    end
+    
+    it 'for 0.1 on a continuum from 1 to 0' do
+      d = RationalChoice::Dimension.new(1, 0)
+      expect(d).to be_fuzzy(0.1)
+      
+      trues = 0
+      
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(0.1) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 10 * 9) # Over 90% of the choices must be trues
+    end
+    
+    it 'for -0.5 on a continuum from -1 to 0' do
+      d = RationalChoice::Dimension.new(-1, 0)
+      expect(d).to be_fuzzy(-0.5)
+      
+      trues = 0
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(-0.5) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 2)
+    end
+    
+    it 'for -0.1 on a continuum from -1 to 0' do
+      d = RationalChoice::Dimension.new(-1, 0)
+      expect(d).to be_fuzzy(-0.1)
+      
+      trues = 0
+      
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(-0.1) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 10 * 9) # Over 90% of the choices must be trues
+    end
+    
+    it 'for -0.5 on a continuum from 0 to -1' do
+      d = RationalChoice::Dimension.new(0, -1)
+      expect(d).to be_fuzzy(-0.5)
+      
+      trues = 0
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(-0.5) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 2)
+    end
+    
+    it 'for -0.1 on a continuum from 0 to -1' do
+      d = RationalChoice::Dimension.new(0, -1)
+      expect(d).to be_fuzzy(-0.1)
+      
+      trues = 0
+      
+      n_evaluations = 100_000
+      n_evaluations.times { trues += 1 if d.choose(-0.1) }
+      
+      expect(trues).to be_within(1000).of(n_evaluations / 10) # Over 90% of the choices must be trues
+    end
+  end
+end

data/spec/rational_choice/many_dimensions_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../spec_helper'
+
+describe 'RationalChoice::ManyDimensions' do
+  describe '.new' do
+    it 'raises a CardinalityError when no dimensions are given' do
+      expect {
+        RationalChoice::ManyDimensions.new
+      }.to raise_error(RationalChoice::CardinalityError)
+    end
+  end
+  
+  describe '.choose' do
+    it 'raises a CardinalityError if the number of values does not match the number of dimensions' do
+      md = RationalChoice::ManyDimensions.new(nil, nil, nil)
+      expect {
+        md.choose(1, 2)
+      }.to raise_error(RationalChoice::CardinalityError)
+    end
+    
+    let(:md) {
+      one_to_zero = RationalChoice::Dimension.new(0, 1)
+      RationalChoice::ManyDimensions.new(one_to_zero, one_to_zero, one_to_zero)
+    }
+    
+    it 'returns "true" when all dimensions are at or above upper bound' do
+      10_000.times { expect(md.choose(1,1,1)).to eq(true) }
+      10_000.times { expect(md.choose(2,2,2)).to eq(true) }
+    end
+    
+    it 'returns "false" when all dimensions are at or below lower bound' do
+      10_000.times { expect(md.choose(0,0,0)).to eq(false) }
+      10_000.times { expect(md.choose(-1,-1,-1)).to eq(false) }
+    end
+    
+    it 'returns "true" in approximately 50% of the cases when all the values are at 0.5' do
+      truthy = 0
+      10_000.times { truthy += 1 if md.choose(0.5, 0.5, 0.5) }
+      expect(truthy).to be_within(100).of(10_000 / 2)
+    end
+    
+    it 'returns "true" in approximately 10% of the cases when all the values are at 0.1' do
+      truthy = 0
+      10_000.times { truthy += 1 if md.choose(0.1, 0.1, 0.1) }
+      expect(truthy).to be_within(100).of(10_000 / 10)
+    end
+    
+    it 'creates a very uniform distribution of values with random values across the board' do
+      truthy = 0
+      10_000.times { truthy += 1 if md.choose(rand, rand, rand) } # default rand() is 0..1
+      expect(truthy).to be_within(100).of(10_000 / 2)
+    end
+  end
+  
+end

data/spec/rational_choice_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RationalChoice" do
+  it "has the necessary constants" do
+    RationalChoice::CardinalityError
+    RationalChoice::Dimension
+    RationalChoice::ManyDimensions
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'rational_choice'
+
+RSpec.configure {|c| c.order = 'random' }

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: rational_choice
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+description: Fuzzy logic gate
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rational_choice.rb
+- rational_choice.gemspec
+- spec/rational_choice/dimension_spec.rb
+- spec/rational_choice/many_dimensions_spec.rb
+- spec/rational_choice_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/wetransfer/rational_choice
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Makes life-concerning choices based on an informed coin toss
+test_files: []