pmeth 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c10b7f39e2469c0ecfe087918e1a1bdf0fa9c200
-  data.tar.gz: 79da3d0a1648106e7ed3dd0bcbfb44a8964f58a2
+  metadata.gz: 16aba86c56088b02d3a72b8400c645aa1dfec5f2
+  data.tar.gz: a6ac908c2e1a370e363cd002fa25bba08cdccd37
 SHA512:
-  metadata.gz: 4211a9815d11ba335d958b0509902d8aa54a3aca195dff7cb242524da4d4b5fb19ba28697ef21cf4c88f29fb3e17493208b2d0536ab1f5bb012140b3e437d554
-  data.tar.gz: eb7d88b8b676d3ae595ef7b564ec80b8acb2461534cb4b6bf4a50abe6828c59411f446b9bc0a25f2d48e5c9e92e0c16065903f74e5f73dd57f2b41e4552df2c4
+  metadata.gz: 0c446aca00d392d2cf81458e37691d32fc81a78ca7fdad97bda379cf8a3914728fa6984dfe9d3b042a93122bd6acafb46bf20b1ec06ce83e51ca049d41816ebd
+  data.tar.gz: 0df635df12846fea56937794a9510404f1c93da78e04c21bc9f1c0d492d8671a67d44b5121dc7e45e4666922f259b5019253b81469410fad58115f0a83e123b1

data/lib/pmeth.rb

@@ -1,6 +1,6 @@
 #encoding: utf-8
 class PMeth
-	# Returns true if n is a prime number, false if not
+	# Returns true if integer n is a prime number, false if not
 	def self.prime?(n)
 		for d in 2..(n - 1)
 			if (n % d) == 0
@@ -30,25 +30,21 @@ class PMeth
 			ig_obj = permutation[ig] # save the object
 			permutation.delete_at(ig)
 		end
-		mutant = []
-		1.times do # this is to make use of the redo statement below
-			x = 0 # x is the randomly chosen size of chunks that permutation will be split into
-			until x > 2 # the chunk to be re-ordered must have at least 2 objects
-				x = division(permutation)
-			end
-			sliced = permutation.each_slice(x).to_a # permutation is sliced into chunks of size x
-			e = rand(sliced.length-1) # one of the chunks is chosen at random...
+		x = 0 # x is the randomly chosen size of chunks that permutation will be split into
+		until x > 2 # the chunk to be re-ordered must have at least 2 objects
+			x = division(permutation)
+		end
+		sliced = permutation.each_slice(x).to_a # permutation is sliced into chunks of size x
+		e = rand(sliced.length-1) # one of the chunks is chosen at random...
+		chunk = sliced[e]
+		until sliced[e] != chunk
 			sliced[e] = sliced[e].shuffle # ... and the objects within are shuffled
-			new_perm = sliced.flatten
-			if new_perm == permutation # if the size of the chunk to be shuffled is small, there is a chance that it may not be differently ordered by shuffle...
-				redo # ... redo is used to ensure that a mutant permutation is created
-			end
-			if ig != nil
-				new_perm.insert(ig, ig_obj)
-			end
-			mutant << new_perm # the new permutation has been added to an array for access outside the 1.times loop
 		end
-		return mutant[0] # new_perm
+		mutant = sliced.flatten
+		if ig != nil
+			mutant.insert(ig, ig_obj)
+		end
+		return mutant
 	end
 
 	# Returns a new permutation where two of the objects have swapped positions (indices)
@@ -66,54 +62,39 @@ class PMeth
 		return mutant
 	end
 
-	# Returns a permutation whose objects are ordered partly like a_parent permutation, and partly like b_parent permutation
-	def self.recombine(a_parent, b_parent)
+	# Returns a permutation whose objects are ordered partly like parent_1 permutation, and partly like parent_2 permutation
+	def self.recombine(parent_1, parent_2)
 		child_permutation = []
-		1.times do # this is to make use of the redo statement below
-			x = division(a_parent) # the randomly chosen size of chunks that permutations will be split into
-			if prime?(a_parent.length) # to compensate for permutations with a prime number of objects:
-				ig = rand(a_parent.length)-1 # choose a random object to ignore - to add back at its original index after mutation
-				a_parent_reduced, b_parent_reduced = a_parent.dup, b_parent.dup # then create duplicates of the parent arrays...
-				a_parent_reduced.delete_at(ig); b_parent_reduced.delete_at(ig) # .. and remove the ignored object from these duplicates
-				x = division(a_parent_reduced) # choose a new chunk size for reduced parent permutations, that no longer have a prime number of objects
-				a_parent_sliced = a_parent_reduced.each_slice(x).to_a # slice the reduced parent permutations into chunks of size x
-				b_parent_sliced = b_parent_reduced.each_slice(x).to_a
-			else
-				a_parent_sliced = a_parent.each_slice(x).to_a # if permutation lengths are non-prime, just slice the parent permutations into chunks of size x
-				b_parent_sliced = b_parent.each_slice(x).to_a
-			end
-			chosen = rand(b_parent_sliced.length)-1 # choose a chunk to have b_parent ordered objects in child permutation
-			child = a_parent_sliced.flatten.dup # un-modified child permutation to accept chunk from b_parent (and possibly ignored object)
-			a_indices = []
-			### place each object in chosen a_parent chunk into the index it's corresponding object (from b_parent) occupies in a_parent ###
-			a_parent_sliced[chosen].each do |i| 
-				index = a_parent_sliced[chosen].index(i) # the index of each object in the chosen a_parent chunk...
-				b_object = b_parent_sliced[chosen][index] # ... the object at that index in the chosen b_parent chunk...
-				a_indices << a_parent_sliced.flatten.index(b_object) # ... the index of that object (from b_parent chunk) (INDEX RHO) in a_parent is added to an array
+		x = division(parent_1) # the randomly chosen size of chunks that permutations will be split into
+		if prime?(parent_1.length) # to compensate for permutations with a prime number of objects:
+			ig = rand(parent_1.length)-1 # choose a random object to ignore - to add back at its original index after mutation
+			p2_ig = parent_2.index(parent_1[ig]) # choose the same object from parent_2
+			parent_1_reduced, parent_2_reduced = parent_1.dup, parent_2.dup # then create duplicates of the parent arrays...
+			parent_1_reduced.delete_at(ig); parent_2_reduced.delete_at(p2_ig) # .. and remove the ignored object from these duplicates
+			x = division(parent_1_reduced) # choose a new chunk size for reduced parent permutations, that no longer have a prime number of objects
+			p1s, p2s = parent_1_reduced.each_slice(x).to_a, parent_2_reduced.each_slice(x).to_a # slice the reduced parent permutations into chunks of size x
+		else
+			p1s, p2s = parent_1.each_slice(x).to_a, parent_2.each_slice(x).to_a # if permutation lengths are non-prime, just slice the parent permutations into chunks of size x
+		end
+		chosen = rand(p2s.length)-1 # choose a chunk to have parent_2 ordered objects in child permutation
+		child = p1s.flatten.dup # un-modified child permutation to accept chunk from parent_2 (and possibly ignored object)
+		p1s[chosen].each do |i| # place each object in chosen parent_1 chunk into the index it's corresponding object (from parent_2) occupies in parent_1:
+			index = p1s[chosen].index(i) # the index of each object in the chosen parent_1 chunk...
+			p2_object = p2s[chosen][index] # ... the object at that index in the chosen parent_2 chunk...
+			p1_index = p1s.flatten.index(p2_object) # ... the index of that object (from parent_2 chunk) in parent_1
+			unless p2s[chosen].include?(p1s[chosen][index]) # unless the chosen chunk from parent_2 includes objects from the chosen parent_1 chunk...
+				child[p1_index] = p1s[chosen][index] # ... the object from the chosen chunk in parent_1 is added to p1_index in child
+				chosen_index = p1s.flatten.index(p1s[chosen][index]) # index of object from parent_1's chosen chunk in parent_1
+				child[chosen_index] = p2s[chosen][index] # swapping the indices of objects in chunks from parents, to give their indices in child
 			end
-			if a_indices.include?(nil) # TODO unsure why: a_indices sometimes includes nil
-				redo
+		end
+		if ig != nil # if the permutations are a prime number in length, we now add the ignored object from earlier into child
+			if p2s[chosen].include?(parent_2[p2_ig]) # add the ignored object from parent_2 if it's in the chosen chunk...
+				child.insert(p2_ig, parent_2[p2_ig])
 			else
-				y = 0
-				a_indices.each do |ai|
-					unless b_parent_sliced[chosen].include?(a_parent_sliced[chosen][y]) # unless the chosen chunk from b_parent includes objects from the chosen a_parent chunk...
-						child[ai] = a_parent_sliced[chosen][y] # ... the object from the chosen chunk in parent_a is added to INDEX RHO in child
-						chosen_index = a_parent_sliced.flatten.index(a_parent_sliced[chosen][y]) # index of object from a_parent's chosen chunk in a_parent
-						child[chosen_index] = b_parent_sliced[chosen][y] # swapping the indices of objects in chunks from parents, to give their indices in child
-					end
-					y+=1
-				end
-			end
-			if ig != nil # if the permutations are a prime number in length, we now add the ignored object from earlier into child
-				if b_parent_sliced[chosen].include?(b_parent[ig]) # add the ignored object from b_parent if it's in the chosen chunk...
-					child.insert(ig, b_parent[ig])
-				else
-					child.insert(ig, a_parent[ig]) # ...otherwise add the ignored object from a_parent
-				end
+				child.insert(ig, parent_1[ig]) # ...otherwise add the ignored object from parent_1
 			end
-			child_permutation << child # so we can access this outside the loop
 		end
-		return child_permutation[0]
+		return child
 	end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pmeth
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Edward Chalstrey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-30 00:00:00.000000000 Z
+date: 2014-05-06 00:00:00.000000000 Z
 dependencies: []
 description: "Reproduction methods for genetic (and other iterative improvement) algorithms,
   being used to solve permutation problems, \n  where permutations are arrays of unique