Skip to content

Commit

Permalink
Merge pull request #2 from FedorSmirnovUdacity/master
Browse files Browse the repository at this point in the history 
Permutation and IntegerMapGenotype tests and changes
  • Loading branch information
felixreimann committed Feb 15, 2018
2 parents 2a4106e + c5e6bdb commit 18a5dcb
Show file tree
Hide file tree
Showing 4 changed files with 456 additions and 5 deletions.
28 changes: 23 additions & 5 deletions opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down Expand Up @@ -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;
}

Expand Down Expand Up @@ -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);
}
Expand Down Expand Up @@ -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();
}

/*
Expand All @@ -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);
}

Expand Down
264 changes: 264 additions & 0 deletions opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java
View file
Original file line number Diff line number Diff line change
@@ -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)));
}

}
54 changes: 54 additions & 0 deletions opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java
View file
Original file line number Diff line number Diff line change
@@ -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());
}

}

0 comments on commit 18a5dcb

Please sign in to comment.