gemetics 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ddeeb3132c636e9788f6ec9c1e4a8fd7cf7e584
-  data.tar.gz: 6136a2cb2d02172058db28b24fbc4e7858b94b56
+  metadata.gz: 03348853673a345fd2653bf0300963de087664ef
+  data.tar.gz: e0bc73e5ed66e085a859769b7ac2f644eacae404
 SHA512:
-  metadata.gz: 39a8fe2e1265bb761643846387c11150e63a8b30566671062db7b87ffee9330c9ef3231601d81b861451aeee33b89dc52ff2e23824b9ffc1634330aeed653635
-  data.tar.gz: 76dea21c731cdb8f7249db6e601ec2feadf9189d733f3380ae81e034d13418715086474ca09e0e51ba03200f10902a8f7d733f4bbcad19e706a6be11b0dee152
+  metadata.gz: d593ebf10f86fe18f6fade87886b39834bdd01cf10f581cf8528e262c4fa2caf92e1d155bfc744af4a647b3f62d7e56dd450240eac3c49d41594070b503e3cb4
+  data.tar.gz: b4191a88f4cf2163ad10033b1afed03e573946ba42419a63053a88505ec9e8a0fa52b4072f1db0ec498f4ae4997d2a6271cfd7cf7d4d4deaf0d03c19aa512c38

data/lib/gemetics.rb

@@ -9,55 +9,64 @@ def default_GA_options()
 	mutationPercent: 0.05,
 	elitism: 0,
 	debug: false,
+	tournamentSize: 10,
   }
 end
 
 def runGeneticAlgorithm(initialPopulation, eval, threshold, options)
-  # make sure options is assigned
+	# make sure options is assigned
 	if(options == nil)
-		options = default_GA_options
+		options = default_GA_options()
 	end
-	validOptions(options,population.size()) # Raises error if options are not correct
+	validOptions(options,initialPopulation.size()) # Raises error if options are not correct
 	currentGen = 0
 	bestCanidate = initialPopulation[0]
 	population = initialPopulation
 	while(continue?(bestCanidate.fitness, threshold, currentGen, options)) do
-	    if(options[:debug])
-	    	puts 'Best Canidate Soultion:'
-	      puts bestCanidate.inspect
-        puts 'Current Generation:'
-	      puts currentGen
-	    end
 		# evaluate the population
 		population = eval.call(population)
-		if(options[:greaterBetter])
+
+	    if(options[:greaterBetter])
 			sortedPopulation = population.sort{ |x , y| y.fitness <=> x.fitness }
 		else
 			sortedPopulation = population.sort{ |x , y| x.fitness <=> y.fitness }
 		end
 		bestCanidate = population[0].clone
 
+		if(options[:debug])
+	    	puts 'Best Canidate Soultion:'
+	     	puts bestCanidate.inspect
+        	puts 'Current Generation:'
+	     	puts currentGen
+	     	puts 'Average Fitness:'
+	     	cumulative = 0
+	     	for org in population
+	     		cumulative += org.fitness
+	     	end
+	     	puts cumulative/population.size()
+	    end
+
 
 		if(options[:totalPopReplace] == false)
 			# Do not replace every organism
-			mates = selection(sortedPopulation.clone(), options[:selectionStyle])
+			mates = selection(sortedPopulation.clone(), options)
 
 			# mate and replace
 			results = mateOrgs(mates[0], mates[1])
 			replaced = []
-      if(options[:elitism] > 0)
-        population = sortedPopulation
-        for i in 0...options[:elitism]
-          replaced.append(0)
-        end
-      end
+			if(options[:elitism] > 0)
+				population = sortedPopulation
+				for i in 0...options[:elitism]
+				  replaced.append(i)
+				end
+			end
 			for i in 0...results.size()
 				results[i].mutate() if Random.new.rand() < options[:mutationPercent]
 				temp = Random.new.rand(population.size())
-				while(!replaced.includes?(temp)) do
+				while(replaced.include?(temp)) do
 					temp = Random.new.rand(population.size())
 				end
-				replaced.append(temp)
+				replaced.push(temp)
 				population[replaced[-1]] = results[i]
 			end
 		else
@@ -65,24 +74,19 @@ def runGeneticAlgorithm(initialPopulation, eval, threshold, options)
 			needed = population.size()
 			have = 0
 			newPopulation = Array.new(population.size(), GeneticObject.new)
-      if(option[:elitism] > 0)
-        if(options[:greaterBetter])
-          sortedPopulation = population.sort{ |x , y| y.fitness <=> x.fitness }
-        else
-          sortedPopulation = population.sort{ |x , y| x.fitness <=> y.fitness }
-        end
-        for i in 0...options[:elitism]
-          newPopulation[i] = sortedPopulation[i]
-        end
-      end
+			if(options[:elitism] > 0)
+				for i in 0...options[:elitism]
+				  newPopulation[i] = sortedPopulation[i]
+				end
+			end
 			while have < needed do
-				mates = selection(sortedPopulation.clone(), options[:selectionStyle])
+				mates = selection(sortedPopulation.clone(), options)
 
 				# mate and put them into new pop
 				results = mateOrgs(mates[0], mates[1])
 				for i in 0...results.size()
 					results[i].mutate() if Random.new.rand() < options[:mutationPercent]
-					newPopulation[have+i] = result[i] if (have+i) < needed
+					newPopulation[have+i] = results[i] if (have+i) < needed
 				end
 				have += results.size()
 			end
@@ -98,13 +102,13 @@ end
 
 def continue?(highestFitness, threshold, currentGen, options)
 	return false if exceedsThreshold?(options[:greaterBetter], highestFitness, threshold)
-	return false if currentGen > options[:maxGen]
+	return false if currentGen > options[:genMax]
 	return true
 end
 
 def exceedsThreshold?(greaterBetter, val, threshold)
 	if(val == nil)
-	return false
+		return false
 	end
 	if(greaterBetter)
 		return val>=threshold
@@ -114,25 +118,73 @@ def exceedsThreshold?(greaterBetter, val, threshold)
 	return false
 end
 
-def selection(population, type)
+def selection(population, options)
 	# select mates
-	if(type == 'tournament')
-		return tournamentSelection(population)
-	elsif(type == 'best')
+	if(options[:selectionStyle] == 'tournament')
+		return tournamentSelection(population, options[:tournamentSize])
+	elsif(options[:selectionStyle] == 'best')
 		return bestSelection(population)
+	elsif(options[:selectionStyle] == 'roulette')
+		return rouletteSelection(population)
 	end
 	raise 'Problem with selection type'
 end
 
-def tournamentSelection(population)
+# Selection algorithms are based on population being sorted
+
+def tournamentSelection(population, size)
 	population = population.shuffle
-	return population[0..10].sort{ |x , y| x.fitness <=> y.fitness }[0..1]
+	subPop = population[0...size]
+	additiveFitness = 0
+	result = []
+	for member in subPop
+		additiveFitness += member.fitness
+	end
+	for member in subPop
+		if Random.new.rand() <= (member.fitness/additiveFitness)
+			result.push(member)
+			break
+		end
+	end
+	for member in subPop
+		if Random.new.rand() <= (member.fitness/additiveFitness)
+			result.push(member)
+			break
+		end
+	end
+	result.push(subPop[0]) while result.size() < 2
+	return result
 end
 
 def bestSelection(population)
 	return population[0..1]
 end
 
+def rouletteSelection(population)
+	additiveFitness = 0.0
+	for member in population
+		additiveFitness += member.fitness
+	end
+
+	result = []
+	for member in population
+		if Random.new.rand() <= (member.fitness/additiveFitness)
+			result.push(member)
+			break
+		end
+	end
+	
+	for member in population
+		if Random.new.rand() <= (member.fitness/additiveFitness)
+			result.push(member)
+			break
+		end
+	end
+
+	result.push(population[0]) while result.size() < 2
+	return result
+end
+
 def mateOrgs(one, two)
 	return one.mate(two)
 end
@@ -141,17 +193,27 @@ end
 
 def validOptions(options, populationSize)
 	raise 'Required Option Missing' if !hasRequiredOptions(options)
+	raise 'Required Dependent Options Missing' if !hasRequiredDependentOptions(options)
 	raise 'Options Not Within Limits' if !withinLimits(options, populationSize)
+	raise 'Dependent Options Not Within Limits' if !dependentOptionsWithinLimits(options, populationSize)
 	return true
 end
 
 def hasRequiredOptions(options)
 	return false if !options.has_key?(:greaterBetter)
 	return false if !options.has_key?(:totalPopReplace)
+	return false if !options.has_key?(:selectionStyle)
 	return false if !options.has_key?(:genMax)
-	return false if !options.has_key?(:mutation_percent)
+	return false if !options.has_key?(:mutationPercent)
 	return false if !options.has_key?(:debug)
-  return false if !options.has_key?(:elitism)
+	return false if !options.has_key?(:elitism)
+	return true
+end
+
+def hasRequiredDependentOptions(options)
+	if(options[:selectionStyle] == 'tournament')
+		return false if !options.has_key?(:tournamentSize)
+	end
 	return true
 end
 
@@ -159,13 +221,20 @@ def withinLimits(options, populationSize)
 	possibleGreaterBetter = [true, false]
 	possibleTotalPopReplace = [true, false]
 	possibleDebug = [true, false]
-	possibleSelectionStyle = ['tournament', 'best']
+	possibleSelectionStyle = ['tournament', 'best', 'roulette']
 	return false if !(possibleGreaterBetter.include?(options[:greaterBetter]))
 	return false if !(possibleTotalPopReplace.include?(options[:totalPopReplace]))
 	return false if !(options[:genMax]>0)
 	return false if !(possibleSelectionStyle.include?(options[:selectionStyle]))
 	return false if !(options[:mutationPercent]>0.0)
 	return false if !(possibleDebug.include?(options[:debug]))
-  return false if !(options[:elitism]>=0 && options[:elitism]<populationSize)
+	return false if !(options[:elitism]>=0 && options[:elitism]<populationSize)
+	return true
+end
+
+def dependentOptionsWithinLimits(options, populationSize)
+	if(options[:selectionStyle] == 'tournament')
+		return false if !(options[:tournamentSize] > 0 && options[:tournamentSize] <= populationSize)
+	end
 	return true
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemetics
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Michael Huelsman