pmeth 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c65096ac15217bc9e12437449a1b6fa9833f627b
-  data.tar.gz: a51645f73810ae436fb329d5188fcd8cc5023842
+  metadata.gz: c10b7f39e2469c0ecfe087918e1a1bdf0fa9c200
+  data.tar.gz: 79da3d0a1648106e7ed3dd0bcbfb44a8964f58a2
 SHA512:
-  metadata.gz: b60e083691a3f2e138f12df22ec9fc84605d1ffa47ec0e2c5ade4d3eef383818c97ee0050a7a4582fec3ce7c91fcf7bf048cffdcd3eabb00a01a373be78e4ede
-  data.tar.gz: f89066070ad87abb955b225f597cf219b5e630267ae172837df870e3da778d420a1d9208ebb5238cc0d75b30d0f561a910daacb7330759ae80b4842c6e358411
+  metadata.gz: 4211a9815d11ba335d958b0509902d8aa54a3aca195dff7cb242524da4d4b5fb19ba28697ef21cf4c88f29fb3e17493208b2d0536ab1f5bb012140b3e437d554
+  data.tar.gz: eb7d88b8b676d3ae595ef7b564ec80b8acb2461534cb4b6bf4a50abe6828c59411f446b9bc0a25f2d48e5c9e92e0c16065903f74e5f73dd57f2b41e4552df2c4

data/lib/pmeth.rb

@@ -1,124 +1,119 @@
 #encoding: utf-8
 class PMeth
-	# Input: An integer you wish to know whether is prime
-	# Output: true/false
+	# Returns true if n is a prime number, false if not
 	def self.prime?(n)
 		for d in 2..(n - 1)
 			if (n % d) == 0
-	    		return false
-	    	end
+				return false
+			end
 		end
 		true
 	end
 
-	# Input: A permutation array of unique objects
-	# Output: A random integer that the length of the Input 0 array can be divided by to get another integer (the randomly chosen size of chunks that permutations will be split into, in the recombine/mutate methods)
-	def self.division(objects) #number of objects must be => 10
-		x = 1.5
-		until objects.length/x == (objects.length/x).to_i && x <= objects.length
-			x = (objects.length/10).to_f + rand(objects.length).to_f
+	# Returns a random integer that array can be divided by to get another integer (other than the array length itself)
+	def self.division(array)
+		x = 1.5 # x assigned a non-integer value to begin with
+		if prime?(array.length) # array with prime number of objects is not divisible by any integer other than 1 and itself
+			x = 1
+		else
+			until x > 0 && array.length/x.to_f == (array.length/x.to_f).to_i && Integer === x
+				x = rand(array.length)
+			end
 		end
 		return x
 	end
 
-	# Input 0: A parent permutation array of unique objects
-	# Input 1: A second parent permutation array of the same unique objects as input 0
-	# Output: A child permutation array, whose order is a recombination of the parent permutations (the same unique objects ordered differently to either input)
+	# Returns a new permutation that has had a randomly sized sub-section re-ordered by shuffle
+	def self.chunk_mutate(permutation)
+		if prime?(permutation.length) # if there are a prime number of objects in the permutation
+			ig = rand(permutation.length)-1 # choose a random object to ignore - to add back at its original index after mutation
+			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...
+			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
+	end
+
+	# Returns a new permutation where two of the objects have swapped positions (indices)
+	def self.swap_mutate(permutation)
+		a = b = x = y = 0
+		until a != b
+			x = rand(permutation.length-1) # randomly choose two indices x and y...
+			y = rand(permutation.length-1)
+			a = permutation[x] # ... and call the objects at these indices a and b
+			b = permutation[y]
+		end
+		mutant = permutation.dup # create a new permutation...
+		mutant[x] = b # ... with object b at index x...
+		mutant[y] = a # ... and object a at index y
+		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)
-		kid = []
-		1.times do # so we can use redo
-			x = division(a_parent)
-			if x == a_parent.length && prime?(x) == false # If a permutation with a non-prime number of objects comes up with x == array length, redo
-				redo
-			elsif x == a_parent.length # to compensate for permutations with a prime number of objects:
-				ig = rand(a_parent.length)-1 # choose a random element of the array to ignore - we add the object at this element back at its original position after recombination
-				a_parent_reduced = a_parent.dup
-				b_parent_reduced = b_parent.dup
-				a_parent_reduced.delete_at(ig)
-				b_parent_reduced.delete_at(ig)
-				x = division(a_parent_reduced)
-				a_parent_sliced = a_parent_reduced.each_slice(x).to_a
+		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
+				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 one of the chunks (sub array from a permutation) to keep from b_parent
-			child = a_parent_sliced.flatten.dup
-			y = 0
-			pos_array = []
-			a_parent_sliced[chosen].each do |object| # place each object in the equivalent a_parent chunk into the position it's corresponding object (from b_parent) occupies in a_parent
-				chunk = b_parent_sliced[chosen][y] # the equivalent object in the chosen b_parent chunk
-				pos = a_parent_sliced.flatten.index(chunk) # the position of the b_parent chunk in a_parent
-				c_pos = a_parent_sliced.flatten.index(object) # the position of the object in a_parent
-				pos_array << pos
-				y+=1
+			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
 			end
-			if pos_array.include?(nil)
+			if a_indices.include?(nil) # TODO unsure why: a_indices sometimes includes nil
 				redo
 			else
 				y = 0
-				pos_array.each do |pos|
-					unless b_parent_sliced[chosen].include?(a_parent_sliced[chosen][y])
-						child[pos] = a_parent_sliced[chosen][y]
-						child[a_parent_sliced.flatten.index(a_parent_sliced[chosen][y])] = b_parent_sliced[chosen][y] # swapping the positions of objects in chunks from parents, to give their positions in child
+				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 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
 			end
-			if child != child.uniq
-				redo
-			end
-			kid << child # so we can access this outside the loop
-		end
-		return kid[0]
-	end
-
-	# Input: A permutation array of unique objects
-	# Output: A slightly different permutation array of the same unique objects
-	def self.mutate(fasta)
-		mutant = []
-		1.times do
-			x = 0
-			until x > 2
-				x = division(fasta)
-			end
-			sliced = fasta.each_slice(x).to_a
-			e = rand(sliced.length-1).to_i
-			sliced[e] = sliced[e].shuffle
-			if sliced.flatten == fasta
-				redo
-			end
-			mutant << sliced.flatten
+			child_permutation << child # so we can access this outside the loop
 		end
-		return mutant[0]
+		return child_permutation[0]
 	end
 
-	# Input: A permutation array of unique objects
-	# Output: A slightly different permutation array of the same unique objects
-	def self.mini_mutate(fasta)
-		a = b = 0
-		until a != b
-			a = fasta[rand(fasta.length-1)]
-			b = fasta[rand(fasta.length-1)]
-		end
-		mutant = []
-		fasta.each do |i|
-			if i == a
-				mutant << b
-			elsif i == b
-				mutant << a
-			else
-				mutant << i
-			end
-		end
-		return mutant
-	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pmeth
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Edward Chalstrey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-25 00:00:00.000000000 Z
+date: 2014-04-30 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