Permutation and IntegerMapGenotype tests and changes

opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java

@@ -19,14 +19,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *******************************************************************************/
- 
+
 package org.opt4j.core.genotype;
 
 import java.lang.reflect.Constructor;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Random;
+import java.util.Set;
 
 import org.opt4j.core.Genotype;
 
@@ -68,6 +70,10 @@ public class IntegerMapGenotype<K> extends IntegerGenotype implements MapGenotyp
 	 */
 	public IntegerMapGenotype(List<K> list, Bounds<Integer> bounds) {
 		super(bounds);
+		Set<K> uniqueKeys = new HashSet<K>(list);
+		if (uniqueKeys.size() < list.size()) {
+			throw new IllegalArgumentException("The provided key objects have to be unique");
+		}
 		this.list = list;
 	}
 
@@ -136,9 +142,16 @@ public Integer getValue(K key) {
 	 */
 	@Override
 	public void setValue(K key, Integer value) {
+		if (!list.contains(key)) {
+			throw new IllegalArgumentException("Invalid key");
+		}
 		int i = list.indexOf(key);
 		while (size() <= i) {
-			add(bounds.getLowerBound(i));
+			add(bounds.getLowerBound(size()));
+		}
+		if (bounds.getLowerBound(i) > value || bounds.getUpperBound(i) < value) {
+			throw new IllegalArgumentException(
+					"The provided value does not lie within the bounds for the provided key");
 		}
 		set(i, value);
 	}
@@ -166,13 +179,15 @@ public <G extends Genotype> G newInstance() {
 	 */
 	@Override
 	public String toString() {
-		String s = "[";
+		StringBuilder stringBuilder = new StringBuilder();
+		stringBuilder.append("[");
 		for (int i = 0; i < size(); i++) {
 			K key = list.get(i);
 			double value = this.get(i);
-			s += key + "=" + value + ";";
+			stringBuilder.append(key + "=" + value + ";");
 		}
-		return s + "]";
+		stringBuilder.append("]");
+		return stringBuilder.toString();
 	}
 
 	/*
@@ -182,6 +197,9 @@ public String toString() {
 	 */
 	@Override
 	public int getIndexOf(K key) {
+		if (!list.contains(key)) {
+			throw new IllegalArgumentException("Invalid key");
+		}
 		return list.indexOf(key);
 	}
 

opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java

@@ -0,0 +1,264 @@
+package org.opt4j.core.genotype;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.Test;
+
+public class IntegerMapGenotypeTest {
+
+	class MockObject {
+		private final double field1;
+		private final int field2;
+
+		public MockObject(double field1, int field2) {
+			this.field1 = field1;
+			this.field2 = field2;
+		}
+
+		public double getField1() {
+			return field1;
+		}
+
+		public int getField2() {
+			return field2;
+		}
+
+		@Override
+		public String toString() {
+			return "mock";
+		}
+
+		@Override
+		public int hashCode() {
+			final int prime = 31;
+			int result = 1;
+			result = prime * result + getOuterType().hashCode();
+			long temp;
+			temp = Double.doubleToLongBits(field1);
+			result = prime * result + (int) (temp ^ (temp >>> 32));
+			result = prime * result + field2;
+			return result;
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj)
+				return true;
+			if (obj == null)
+				return false;
+			if (getClass() != obj.getClass())
+				return false;
+			MockObject other = (MockObject) obj;
+			if (!getOuterType().equals(other.getOuterType()))
+				return false;
+			if (Double.doubleToLongBits(field1) != Double.doubleToLongBits(other.field1))
+				return false;
+			if (field2 != other.field2)
+				return false;
+			return true;
+		}
+
+		private IntegerMapGenotypeTest getOuterType() {
+			return IntegerMapGenotypeTest.this;
+		}
+	}
+
+	@Test(expected = UnsupportedOperationException.class)
+	public void testForbiddenInit() {
+		Random rand = new Random();
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.init(rand, 3);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testNonUniqueKeys() {
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		inputList.add(mockup1);
+		new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(inputList, bounds);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testGetIndexInvalidKey() {
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		MockObject mockup4 = new MockObject(4.0, 4);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.getIndexOf(mockup4);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetInvalidKey() {
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		MockObject mockup4 = new MockObject(4.0, 4);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.setValue(mockup4, 1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetOutOfLowerBoundsValue() {
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.setValue(mockup3, -1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetOutOfUpperBoundsValue() {
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.setValue(mockup3, 5);
+	}
+
+	@Test
+	public void testToString() {
+		Random rand = new Random();
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 1, 2, 3 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		integerMapGenotype.init(rand);
+		assertEquals("[mock=1.0;mock=2.0;mock=3.0;]", integerMapGenotype.toString());
+	}
+
+	@Test
+	public void testFixedBoundConstructor() {
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, 1, 3);
+		for (int i = 1; i < 4; i++) {
+			assertEquals(1, integerMapGenotype.getLowerBound(i));
+			assertEquals(3, integerMapGenotype.getUpperBound(i));
+		}
+	}
+
+	@Test
+	public void testBoundConstructor() {
+		Random rand = new Random();
+		int[] lowerBounds = { 1, 2, 3 };
+		int[] upperBounds = { 2, 3, 4 };
+		Bounds<Integer> bounds = new IntegerBounds(lowerBounds, upperBounds);
+		MockObject mockup1 = new MockObject(1.0, 1);
+		MockObject mockup2 = new MockObject(2.0, 2);
+		MockObject mockup3 = new MockObject(3.0, 3);
+		MockObject mockup4 = new MockObject(4.0, 4);
+		List<MockObject> inputList = new ArrayList<IntegerMapGenotypeTest.MockObject>();
+		inputList.add(mockup1);
+		inputList.add(mockup2);
+		inputList.add(mockup3);
+		IntegerMapGenotype<MockObject> integerMapGenotype = new IntegerMapGenotype<IntegerMapGenotypeTest.MockObject>(
+				inputList, bounds);
+		assertTrue(integerMapGenotype.isEmpty());
+		assertEquals(integerMapGenotype.getLowerBound(0), 1);
+		assertEquals(integerMapGenotype.getLowerBound(1), 2);
+		assertEquals(integerMapGenotype.getLowerBound(2), 3);
+		assertEquals(integerMapGenotype.getUpperBound(0), 2);
+		assertEquals(integerMapGenotype.getUpperBound(1), 3);
+		assertEquals(integerMapGenotype.getUpperBound(2), 4);
+		integerMapGenotype.init(rand);
+		assertEquals(3, integerMapGenotype.size());
+		assertTrue(integerMapGenotype.containsKey(mockup1));
+		assertTrue(integerMapGenotype.containsKey(mockup2));
+		assertTrue(integerMapGenotype.containsKey(mockup3));
+		assertFalse(integerMapGenotype.containsKey(mockup4));
+		assertEquals(0, integerMapGenotype.getIndexOf(mockup1));
+		assertEquals(1, integerMapGenotype.getIndexOf(mockup2));
+		assertEquals(2, integerMapGenotype.getIndexOf(mockup3));
+		Collection<MockObject> keys = integerMapGenotype.getKeys();
+		assertTrue(keys.contains(mockup1));
+		assertTrue(keys.contains(mockup2));
+		assertTrue(keys.contains(mockup3));
+		assertFalse(keys.contains(mockup4));
+		assertTrue(integerMapGenotype.getValue(mockup1) >= 1);
+		assertTrue(integerMapGenotype.getValue(mockup1) <= 2);
+		assertTrue(integerMapGenotype.getValue(mockup2) >= 2);
+		assertTrue(integerMapGenotype.getValue(mockup2) <= 3);
+		assertTrue(integerMapGenotype.getValue(mockup3) >= 3);
+		assertTrue(integerMapGenotype.getValue(mockup3) <= 4);
+		integerMapGenotype.setValue(mockup3, 4);
+		assertEquals(new Long(4), new Long(integerMapGenotype.getValue(mockup3)));
+		IntegerMapGenotype<MockObject> other = integerMapGenotype.newInstance();
+		assertNotEquals(integerMapGenotype, other);
+		assertTrue(other.isEmpty());
+		other.setValue(mockup2, 2);
+		assertEquals(new Long(2), new Long(other.getValue(mockup2)));
+		assertEquals(new Long(1), new Long(other.getValue(mockup1)));
+	}
+
+}

opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java

@@ -0,0 +1,54 @@
+package org.opt4j.core.genotype;
+
+import static org.junit.Assert.*;
+
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+
+import org.junit.Test;
+
+public class PermutationGenotypeTest {
+
+	@Test
+	public void testEmptyConstructor() {
+		Random rand = new Random();
+		PermutationGenotype<Integer> permutationGenotype = new PermutationGenotype<Integer>();
+		permutationGenotype.add(1);
+		permutationGenotype.add(2);
+		permutationGenotype.add(3);
+
+		assertEquals(3, permutationGenotype.size());
+		permutationGenotype.init(rand);
+		assertEquals(3, permutationGenotype.size());
+		assertTrue(permutationGenotype.contains(1));
+		assertTrue(permutationGenotype.contains(2));
+		assertTrue(permutationGenotype.contains(3));
+
+		PermutationGenotype<Integer> other = permutationGenotype.newInstance();
+		assertNotEquals(permutationGenotype, other);
+		assertTrue(other.isEmpty());
+	}
+
+	@Test
+	public void testCollectionConstructor() {
+		Random rand = new Random();
+		Set<Integer> inputCollection = new HashSet<Integer>();
+		inputCollection.add(1);
+		inputCollection.add(2);
+		inputCollection.add(3);
+		PermutationGenotype<Integer> permutationGenotype = new PermutationGenotype<Integer>(inputCollection);
+
+		assertEquals(3, permutationGenotype.size());
+		permutationGenotype.init(rand);
+		assertEquals(3, permutationGenotype.size());
+		assertTrue(permutationGenotype.contains(1));
+		assertTrue(permutationGenotype.contains(2));
+		assertTrue(permutationGenotype.contains(3));
+
+		PermutationGenotype<Integer> other = permutationGenotype.newInstance();
+		assertNotEquals(permutationGenotype, other);
+		assertTrue(other.isEmpty());
+	}
+
+}