dice_stats 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7086bffbd719c8eee013b15b67695a448dbd6d2
+  data.tar.gz: d4eb3dbf7782a16674b9b71fb4eae0da8df263f0
+SHA512:
+  metadata.gz: 425c4bb5208588c105c22003dce0fe6d845a4c8ae80f00009623c73b35e1fd5bc4ce9fcbab0eb98b81e25bda47282f517bdfb0a80527cb96f22a63764e0f70be
+  data.tar.gz: 9bf601977f33c8ad2430732ca58b396b16655d8287d4446e142437069e76b5811634ab60aa6cce96567eae4e98e8c40774073447fd0faf22289121143eaeac55

data/lib/Dice.rb

@@ -0,0 +1,147 @@
+require 'bigdecimal'
+require 'Internal_Utilities/Math_Utilities'
+require 'Internal_Utilities/probability_cache_db'
+
+module Dice_Stats
+
+	##
+	# This class repsents the roll statistics for a single type of dice. i.e. all d6s, or all d8s.
+	# The probability distribution is generated via the generating function found on line (10) of http://mathworld.wolfram.com/Dice.html
+	class Dice
+
+		##
+		# The number of dice, and how many sides they have.
+		attr_accessor :count, :sides
+
+		##
+		# The probability distribution of the dice.
+		attr_reader :probability_distribution
+
+		##
+		# Creates a new Dice instance of a number of dice (+dice_count+) with +dice_sides+ faces.
+		# All dice are assumed to go from 1 to +dice_sides+.
+		def initialize(dice_count, dice_sides)
+			@count = dice_count
+			@sides = dice_sides
+			@probability_distribution = {}
+
+			if (@count < 0 || @sides < 0)
+				#error
+			else
+				t1 = Time.now
+				if Cache.checkDice(@count.to_s + "d" + @sides.to_s)
+					@probability_distribution = Cache.getDice(@count.to_s + "d" + @sides.to_s)
+				else
+					@probability_distribution = calculate_probability_distribution
+					Cache.addDice(@count.to_s + "d" + @sides.to_s, @probability_distribution, (Time.now - t1).round(5))
+				end
+				#t2 = Time.now
+				#puts "Probabilities determined in #{(t2-t1).round(5)}"
+			end
+		end
+
+		##
+		# Returns the highest possible roll
+		def max
+			@count*@sides
+		end
+
+		## 
+		# Returns the lowest possible roll
+		def min
+			@count
+		end
+
+		## 
+		# Returns the average roll result
+		def expected
+			BigDecimal(@count) * ((@sides + 1.0) / 2.0)
+		end
+
+		##
+		# Returns the variance of the roll
+		def variance
+			var = BigDecimal.new(0)
+			(1..@sides).each { |i|
+				e = BigDecimal.new(@sides+1) / BigDecimal.new(2)
+				var += (BigDecimal.new(i - e)**2) / BigDecimal.new(@sides)
+			}
+			var * BigDecimal.new(@count)
+		end
+
+		##
+		# Returns the standard deviation of the roll
+		def standard_deviation
+			BigDecimal.new(variance).sqrt(5)
+		end
+
+		##
+		# Prints some basic stats about this roll
+		def print_stats
+			puts "Min: #{min}"
+			puts "Max: #{max}"
+			puts "Expected: #{expected}"
+			puts "Std Dev: #{standard_deviation}"
+			puts "Variance: #{variance}"
+
+			@probability_distribution.each { |k,v| 
+				puts "P(#{k}) => #{v}"
+			}
+		end
+
+		##
+		# Rolls the dice and returns the result
+		def roll
+			sum = 0
+			@count.times do |i|
+				sum += (1 + rand(@sides))
+			end
+			return sum
+		end
+
+		##
+		# For internal use only.
+		# Caclulates the probability distribution on initialization
+		def calculate_probability_distribution
+			number_of_possible_combinations = (@sides**@count)
+			#puts "Number of possible combinations: #{number_of_possible_combinations}"
+			result = {}
+			# weep softly: http://mathworld.wolfram.com/Dice.html
+			(min..max).each { |p|
+				if p > (max + min) / 2
+					result[p] = result[max - p + min]
+				else
+					thing = (BigDecimal.new(p - @count) / BigDecimal.new(@sides)).floor
+
+					c = BigDecimal.new(0)
+					((0..thing).each { |k|
+						n1 = ((-1)**k) 
+						n2 = BigDecimal.new(Internal_Utilities::Math_Utilities.Choose(@count, k))
+						n3 = BigDecimal.new(Internal_Utilities::Math_Utilities.Choose(p - (@sides * k) - 1, @count - 1))						
+						t = BigDecimal.new(n1 * n2 * n3)
+
+						c += t
+					})
+
+					#result = result.abs
+
+					result[p] = BigDecimal.new(c) / BigDecimal.new(number_of_possible_combinations)
+				end
+
+				#puts "\tProbability of #{p}: #{@probability_distribution[p].add(0, 5).to_s('F')}" 
+			}
+			@probability_distribution = result
+			#puts "Sum of probability_distribution: " + (@probability_distribution.inject(BigDecimal.new(0)) {|total, (k,v)| BigDecimal.new(total + v) }).add(0, 5).to_s('F')
+		end
+
+		##
+		# Returns the probability of a specific result (+val+). *Not* to be confused with Dice_Set#p.
+		def p(val)
+			if (@probability_distribution.key?(val))
+				return @probability_distribution[val]
+			else
+				return 0
+			end
+		end
+	end
+end

data/lib/Dice_Set.rb

@@ -0,0 +1,152 @@
+require 'Dice'
+require 'Internal_Utilities/Math_Utilities'
+require 'Internal_Utilities/Filtered_distribution'
+require 'Internal_Utilities/probability_cache_db'
+
+module Dice_Stats
+
+	##
+	# This class represents the roll statistics for a combination of dice.
+	# The probability distribution is based off the constituent dice distributions.
+	class Dice_Set
+		##
+		# The raw probability distribution of the dice set.
+		# Can be queried more interactively through Dice_Set#p.
+		attr_reader :probability_distribution
+
+		##
+		# The constituent separate dice
+		attr_accessor :dice
+
+		##
+		# Instantiates a new Dice_Set with the specified +dice_string+ pattern.
+		# Examples:
+		# "2d6 + 1d3"
+		# "2d6 + 5"
+		# "1d8"
+		# "5d4 + 3d10"
+		def initialize(dice_string)
+			@dice = []
+			@constant = 0
+			@input_string = dice_string
+			@aborted_probability_distribution = false
+
+			split_string = dice_string.split('+')
+
+			split_string.map!{|i| i.strip }
+
+			split_string.count.times { |i|
+				if /\d+[dD]\d+/.match(split_string[i])
+					sub_string_split = split_string[i].downcase.split('d')
+					@dice << Dice.new(sub_string_split[0].to_i, sub_string_split[1].to_i)
+				elsif (split_string[i].to_i > 0)
+					@constant += split_string[i].to_i
+				else
+					puts "Unexpected paramter: #{split_string[0]}"
+				end
+			}
+
+			if @dice.inject(1) { |memo,d| memo * d.probability_distribution.length } > 10_000_000
+				# if the n-ary cartesian product has to process more than 10,000,000 combinations it can take quite a while to finish...
+				@aborted_probability_distribution = true
+			else
+				@dice.sort! { |d1,d2| d2.sides <=> d1.sides }
+
+				t1 = Time.now
+				if Cache.checkDice(self.clean_string(false))
+					@probability_distribution = Cache.getDice(self.clean_string(false))
+				else
+					@probability_distribution = combine_probability_distributions
+					Cache.addDice(self.clean_string(false), @probability_distribution, (Time.now - t1).round(5))
+				end
+				#t2 = Time.now
+				#puts "Probabilities determined in #{(t2-t1).round(5)}"
+
+				if (@probability_distribution.inject(0) { |memo,(k,v)| memo + v }.round(3).to_f != 1.0)
+					#puts "Error in probability distrubtion."
+				end
+			end
+		end
+
+		##
+		# Returns the highest possible roll
+		def max
+			@dice.inject(0) { |memo, d| memo + d.max }.to_i + @constant
+		end
+
+		##
+		# Returns the lowest possible roll
+		def min
+			@dice.inject(0) { |memo, d| memo + d.min }.to_i + @constant
+		end
+
+		## 
+		# Returns the average roll result
+		def expected
+			@dice.inject(0) { |memo, d| memo + d.expected }.to_f + @constant
+		end
+
+		##
+		# Returns the variance of the roll
+		def variance
+			@probability_distribution.inject(0) { |memo, (key,val)| memo + ((key - (expected - @constant))**2 * val) }.round(10).to_f
+		end
+
+		##
+		# Returns the standard deviation of the roll
+		def standard_deviation
+			BigDecimal.new(variance, 10).sqrt(5).round(10).to_f
+		end
+
+		## 
+		# For internal use only.
+		# Takes the cartesian product of the individual dice and combines them.
+		def combine_probability_distributions
+			separate_distributions = @dice.map { |d| d.probability_distribution }
+			Internal_Utilities::Math_Utilities.Cartesian_Product_For_Probabilities(separate_distributions)
+		end
+
+		## 
+		# Returns the dice string used to generate the pattern sorted by dice face, descending.
+		# For example "2d3 + 2 + 1d6" would become "1d6 + 2d3 + 2"
+		# If +with_constant+ is set to false, the constant "+ 2" will be ommitted.
+		def clean_string(with_constant=true)
+			formatted_string = ""
+			@dice.each { |d| 
+				formatted_string += d.count.to_s + "d" + d.sides.to_s + " + "
+			}
+			if with_constant && @constant > 0
+				formatted_string + @constant.to_s
+			else
+				formatted_string[0..formatted_string.length-4]
+			end
+		end
+
+		##
+		# Displays the probability distribution. 
+		# Can take up quite a lot of screen space for the mroe complicated rolls. 
+		def print_probability
+			@probability_distribution.each { |k,v| puts "p(#{k}) => #{v.round(8).to_f}"}
+		end
+
+		##
+		# Simulates a roll of the dice
+		def roll
+			@dice.inject(@constant || 0) { |memo,d| memo + d.roll }
+		end
+
+		## 
+		# Instantiates and returns a Filtered_distribution. See the documentation for Filtered_distribution.rb.
+		def p
+			weighted_prob_dist = @probability_distribution.inject(Hash.new) { |m,(k,v)| m[k+@constant] = v; m }
+			filtered_distribution = Internal_Utilities::Filtered_distribution.new(weighted_prob_dist)
+			return filtered_distribution
+		end
+
+		##
+		# If the probability distribution was determined to be too complex to compute this will return true.
+		def too_complex?
+			@aborted_probability_distribution
+		end
+	end
+end

data/lib/Internal_Utilities/Arbitrary_base_counter.rb

@@ -0,0 +1,85 @@
+module Dice_Stats
+
+end
+
+module Dice_Stats::Internal_Utilities
+
+	##
+	# This class defines a counter where each "digit" has a different base.
+	# For example, a counter of two digits, the first with base 3 and the second with base 2 may go like this:
+	# 0 => [0, 0]
+	# 1 => [0, 1]
+	# 2 => [1, 0]
+	# 3 => [1, 1]
+	# 4 => [2, 0]
+	# 5 => [2, 1]
+	# 5 would be the maximum number the counter could hold.
+	# 
+	# TODO:
+	# * Add a "decrement" method
+	# * Add a "value" method to return the count in base 10
+
+	class Arbitrary_base_counter
+		##
+		# A boolean value representing if the result has overflown.
+		# Will be false initially, will be set to true if the counter ends up back at [0, 0, ..., 0]
+		attr_reader :overflow
+
+		##
+		# Define a new counter.
+		# +maximums+ is an array of integers, each specifying the base of its respective digit.
+		# For example, to create a counter of 3 base 2 digits, supply [2,2,2]
+		def initialize(maximums)
+			@overflow = false
+			@index = maximums.map { |i| {:val => 0, :max => i} }
+		end
+
+		##
+		# Increase the "value" of the counter by one
+		def increment
+			#start at the end of the array (i.e. the "lowest" significant digit)
+			i = @index.length - 1 
+
+			loop do
+				#increment the last value
+				@index[i][:val] += 1
+
+				#check if it has "overflown" that digits base
+				if @index[i][:val] >= @index[i][:max]
+					#set it to 0
+					@index[i][:val] = 0
+					
+					if (i == 0) 
+						@overflow = true
+					end
+
+					#move to the next digit to the "left"
+					i -= 1
+					
+				else
+					#done
+					break
+				end
+			end
+		end
+
+		##
+		# Return an integer representing how many digits the counter holds
+		def length
+			@index.length
+		end
+
+
+		##
+		# Overloaded index operator, used to retrieve the number stored in the +i+th digit place
+		def [](i)
+			@index[i][:val]
+		end
+
+		##
+		# Puts the array of digits.
+		def print
+			puts @index
+		end
+	end
+end

data/lib/Internal_Utilities/Filtered_distribution.rb

@@ -0,0 +1,70 @@
+module Dice_Stats
+
+end
+
+module Dice_Stats::Internal_Utilities
+
+	##
+	# This class is used as a way to build clauses into a query of a probability distribution
+	# The +probability_distribution+ start out complete and each query removes selections of it.
+
+	class Filtered_distribution
+		##
+		# For internal use only. The Dice_Set#p method instantiates this with a fresh distribution for use in the query.
+		def initialize(probability_distribution)
+			@pd = probability_distribution
+		end
+
+		##
+		# Use Filtered_distribution#get to return the sum of the remaining probabilities in the distribution
+		def get
+			@pd.inject(BigDecimal.new(0)) { |m, (k,v)| m + v }
+		end
+
+		##
+		# The "less than" operator.
+		def lt(val)
+			@pd.select! { |k,v| k < val }
+			return self
+		end
+
+		## 
+		# The "less than or equal to" operator.
+		def lte(val)
+			@pd.select! { |k,v| k <= val }
+			return self
+		end
+
+		##
+		# The "greater than" operator.
+		def gt(val)
+			@pd.select! { |k,v| k > val }
+			return self
+		end
+
+		##
+		# The "greater than or equal to" operator.
+		def gte(val)
+			@pd.select! { |k,v| k >= val }
+			return self
+		end
+
+		## 
+		# The "equal to" operator. 
+		# *Note:* This removes all options except the one specified. This is not useful in conjunction with any other operators.
+		# The result of "p.eq(x).eq(y).get" will always be 0 if x and y are different.
+		def eq(val)
+			@pd.select! { |k,v| k == val }
+			return self
+		end
+
+		##
+		# The "not equal to" operator.
+		# This allows for arbitrailty selecting out option that don't fit a ranged criteria.
+		# For example "p.ne(2).ne(4).ne(6).get" would give the odds of rolling an odd number on a d6.
+		def ne(val)
+			@pd.select! { |k,v| k != val }
+			return self
+		end
+	end
+end

data/lib/Internal_Utilities/Math_Utilities.rb

@@ -0,0 +1,167 @@
+require_relative 'Arbitrary_base_counter'
+
+module Dice_Stats
+
+end
+
+module Dice_Stats::Internal_Utilities
+
+	##
+	# This class simple contains some methods to aid the calculating of probability distributions
+	class Math_Utilities
+
+		##
+		# The "Choose" operator. Sometimes noted as "(5 3)" or "5 c 3".
+		def self.Choose(a, b)
+			if (a < 0 || b < 0 || (a < b))
+				1
+			elsif (a == b || b == 0)
+				1
+			else
+				(a-b+1..a).inject(1, &:*) / (2..b).inject(1, &:*)
+			end
+		end
+
+		##
+		# The "Factorial" function
+		def self.Factorial(a)
+			(1..a).inject(:*) || 0
+		end
+
+		##
+		# Note that this method is not actually used. It was a proof of concept for templating a less "clever" way to do a
+		# Cartesian product of arbitrary objects in such a way that additional processing can be done on the elements.
+		def self.Cartesian_Product(arrays) #arrays is an array of array to cartesian product
+
+			# FROM https://gist.github.com/sepastian/6904643
+			# I found these examples later, after creating Option 3.
+			# TODO: See if using these can be used to simplify the process.
+			#Option 1
+			arrays[0].product(*arrays[1..-1])
+			#Option 2
+			arrays[1..-1].inject(arrays[0]) { |m,v| m.product(v).map(&:flatten) }
+
+			#Option 3
+			# however, we need to actually perform additional logic on the specific combinations, 
+			# not just aggregate them into one giant array
+			result = []
+			if (arrays.class != [].class)
+				puts "Not an array"			
+			elsif (arrays.length == 1)
+				arrays[0]
+			elsif (arrays.length == 0)
+				puts "No input."
+			elsif (arrays[0].class != [].class)
+				puts "Not an array of arrays"
+			else	
+				counter = Arbitrary_base_counter.new([*0..arrays.length-1].map { |i| arrays[i].length })
+
+				while !counter.overflow do
+					sub_result = []
+					(0..counter.length-1).each { |i|
+						sub_result << arrays[i][counter[i]]
+					}
+					result << sub_result
+
+					counter.increment
+				end
+			end
+
+			result
+		end
+
+		##
+		# This method combines an array of hashes (i.e. an array of probabilities) into an aggregate probability distribution
+		def self.Cartesian_Product_For_Probabilities(hashes) #hashes is a hash of hashes to cartesian product
+			result = {}
+
+			if (hashes.class != Array)
+				puts "Not an array"
+			elsif (hashes.length == 1)
+				puts "Returning first result"
+				result = hashes.first
+			elsif (hashes.length == 0)
+				puts "Returning new hash"
+				result = { 0 => 1 }
+			elsif (hashes[0].class != Hash)
+				puts "Not a Hash of Hashes"
+			else
+				counter = Arbitrary_base_counter.new([*0..hashes.length-1].map { |i| hashes[i].length })
+				hashes.map! { |h| h.to_a }
+
+				while !counter.overflow do
+					value = 0
+					probability = 1					
+					sub_result = {}
+
+					(0..counter.length-1).each { |i|
+						value += hashes[i][counter[i]][0]
+						probability *= hashes[i][counter[i]][1]
+					}
+					if (result.key?(value))
+						result[value] += probability
+					else
+						result[value] = probability
+					end
+
+					counter.increment
+				end
+			end
+
+			result
+		end
+
+		##
+		# Deprecated / incomplete.
+		# This method runs some quick tests on the basic math helper functions 
+		# to make sure that the Factorial and Choose methods are working as expected.
+		def self.Test_Suite
+			#Choose
+			puts "Testing Choose edge cases..."
+			Test_Choose(6, 10, 1)
+			Test_Choose(6, 6, 1)
+			Test_Choose(5, 0, 1)
+			Test_Choose(-1, 5, 1)
+			Test_Choose(5, -1, 1)
+			puts
+			puts "Testing Choose basic math..."
+			Test_Choose(5, 3, 10)
+			Test_Choose(6, 2, 15)
+			Test_Choose(14, 7, 3432)
+			Test_Choose(7, 2, 21)
+			Test_Choose(7, 5, 21)
+			Test_Choose(7, 5, 21)
+			Test_Choose(6, 3, 20)
+
+			#Factorial
+			puts
+			puts "Testing Factorial edge cases..."
+			Test_Factorial(0, 0)
+			Test_Factorial(-2, 0)
+			puts
+			puts "Testing Factorial basic math..."
+			Test_Factorial(6, 720)
+			Test_Factorial(5, 120)
+			Test_Factorial(4, 24)
+			Test_Factorial(3, 6)
+			Test_Factorial(2, 2)
+		end
+
+		##
+		# Helper function for testing the Choose method.
+		def self.Test_Choose(a, b, expected)
+			puts "(#{a} #{b}) => #{expected} (Actual: " + self.Choose(a, b).to_s + ")"
+			if (self.Choose(a, b) != expected) 
+				puts "`--> ERROR. FAILING CASE."
+			end
+		end
+
+		## Helper function for testing the Factorial method.
+		def self.Test_Factorial(a, expected)
+			puts "#{a}! => #{expected} (Actual: " + self.Factorial(a).to_s + ")"
+			if (self.Factorial(a) != expected) 
+				puts "`--> ERROR. FAILING CASE."
+			end
+		end
+	end
+end

data/lib/Internal_Utilities/probability_cache_db.rb

@@ -0,0 +1,188 @@
+require 'sqlite3'
+require 'bigdecimal'
+
+module Dice_Stats
+
+end
+
+module Dice_Stats::Internal_Utilities
+
+	##
+	# This class represents the cache. The cache is used for storing previously calculated results.
+	# Some dice sets can take quite a while to calculate. 
+	# Storing them drastically increases performance when a cache hit is found.
+	class DB_cache_connection
+		##
+		# The version of the gem. If this is updated, the DB_cache_connection#initialize method will drop and recreate the tables
+		@@Version = [0, 1, 0]
+
+		##
+		# The path of the sqlite3 db file.
+		@@Path = '/srv/Dice_Stats/'
+
+		##
+		# The name of the sqlite3 db file.
+		@@DB_name = 'probability_cache.db'
+
+		##
+		# For internal use only. Checks the database version and schema on startup.
+		def initialize
+			checkSchema
+		end
+
+		##
+		# Checks the database version and schema and creates the table structures.
+		def checkSchema
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)
+				db.execute "CREATE TABLE IF NOT EXISTS DiceConfig(Key TEXT PRIMARY KEY, Val TEXT);"
+				statement = db.prepare "SELECT Val FROM DiceConfig WHERE Key = 'Version';"
+				row = statement.execute.next
+
+				if !row
+					db.execute "INSERT INTO DiceConfig (Key, Val) VALUES ('Version', '#{@@Version.join('.')}');"
+					createSchema(db, true)
+				else
+					version = row[0]
+					version = version.split('.')
+					version.map! { |i| i.to_i }
+					if (@@Version[0] != version[0] || @@Version[1] != version[1] || @@Version[2] != version[2])
+						# Version of database is different, drop and recreate!
+						createSchema(db, true)
+						db.execute "UPDATE DiceConfig SET Version = '#{@@Version.join('.')}' WHERE Key = 'Version'"
+					end
+
+				end
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				statement.close if statement
+				db.close if db
+			end
+
+		end
+
+		##
+		# Creates the tables if they don't already exist.
+		# If +drop+ is set to true, the tables will be dropped first.
+		def createSchema(db, drop=false)
+			db.execute "DROP TABLE IF EXISTS DiceSet;" if drop
+			db.execute "CREATE TABLE IF NOT EXISTS DiceSet (Id INTEGER PRIMARY KEY AUTOINCREMENT, Name TEXT UNIQUE, TimeElapsed DECIMAL)"
+
+			db.execute "DROP TABLE IF EXISTS RollProbability;" if drop
+			db.execute "CREATE TABLE IF NOT EXISTS RollProbability (Id INTEGER PRIMARY KEY AUTOINCREMENT, DiceSetId INT, Value INTEGER, Probability DECIMAL)"
+		end
+
+		##
+		# Drops and recreates the schema for the purpose of clearing the cache.
+		def purge
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)
+				puts "Purging cache..."
+				createSchema(db, true)
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				db.close if db
+			end
+		end
+
+		##
+		# Checks the cache to see if the pattern has been previously calculated.
+		def checkDice(dice_pattern)
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)
+				
+				statement = db.prepare "SELECT Id FROM DiceSet WHERE Name = '#{dice_pattern}'"
+
+				return statement.execute.count >= 1
+
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				statement.close if statement
+				db.close if db
+			end
+		end
+
+		##
+		# Caches a dice pattern for future retrieval.
+		def addDice(dice_pattern, probability_distribution, timeElapsed=0.0)
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)				
+				db.execute "INSERT INTO DiceSet (Name) VALUES ('#{dice_pattern}')"
+				diceset_id = db.last_insert_row_id
+				
+				values = []
+				probability_distribution.each { |k,v|  
+					values << "(#{diceset_id}, #{k}, #{v})"
+				}
+				#puts "Values:"
+				#puts values
+
+				insert = "INSERT INTO RollProbability (DiceSetId, Value, Probability) VALUES " + values.join(", ")
+
+				db.execute insert
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				db.close if db
+			end
+		end
+
+		##
+		# Retrieves the probability distribution for a dice pattern from the cache.
+		def getDice(dice_pattern)
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)
+				
+				statement1 = db.prepare "SELECT Id FROM DiceSet WHERE Name = '#{dice_pattern}'"
+				diceset_id = statement1.execute.first[0]
+
+				statement2 = db.prepare "SELECT Value, Probability FROM RollProbability WHERE DiceSetId = #{diceset_id}"
+
+				rs = statement2.execute
+				result = {}
+				rs.each { |row|
+					result[row[0]] = BigDecimal.new(row[1], 15)
+				}
+
+				return result
+
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				statement1.close if statement1
+				statement2.close if statement2
+				db.close if db
+			end
+		end
+
+		##
+		# Retrieves how long a cached result originally took to calculate.
+		def getElapsed(dice_pattern)
+			begin
+				db = SQLite3::Database.open(@@Path + @@DB_name)
+				statement = db.prepare "SELECT TimeElapsed FROM DiceSet WHERE Name = '#{dice_pattern}'"
+
+				rs = statement.execute				
+				result = nil
+				rs.each { |row| 
+					result = row[0]
+				}
+
+				if (result == nil)
+					return 0.0
+				else 
+					return result
+				end
+
+			rescue SQLite3::Exception => e 
+				puts e
+			ensure
+				statement.close if statement
+				db.close if db
+			end
+		end
+	end	
+end

data/lib/dice_stats.rb

@@ -0,0 +1,22 @@
+#The "main" function
+
+##
+# Dice_Stats is the main namespace for the gem.
+# Dice Stats is a ruby gem for handling dice related statistics.
+# see the README.md for more information.
+module Dice_Stats
+end
+
+##
+# The Internal_Utilities module is a namespace for some basic helper functions and classes used by Dice_Stats.
+# Things in it are simply encapsulated this way to avoid polluting the lexical scope of the main module.
+module Dice_Stats::Internal_Utilities
+end
+
+require 'Dice_Set'
+
+##
+# Instantiates the cache.
+# The cache is an instance of a DB_cache_connection in the Internal_Utilities module.
+# It is used to cache past results.
+Dice_Stats::Cache = Dice_Stats::Internal_Utilities::DB_cache_connection.new

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: dice_stats
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Foy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+description: Provides utilities for calculating dice statistics
+email: mattfoy91@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/Dice.rb
+- lib/Dice_Set.rb
+- lib/Internal_Utilities/Arbitrary_base_counter.rb
+- lib/Internal_Utilities/Filtered_distribution.rb
+- lib/Internal_Utilities/Math_Utilities.rb
+- lib/Internal_Utilities/probability_cache_db.rb
+- lib/dice_stats.rb
+homepage: http://matthewfoy.ca
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Dice statistics utility.
+test_files: []