private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); final MSeq<BigIntegerGene> genes = MSeq.ofLength(in.readInt()); reflect.setField(this, "_min", in.readObject()); reflect.setField(this, "_max", in.readObject()); for (int i = 0; i < genes.length(); ++i) { final BigInteger value = (BigInteger)in.readObject(); genes.set(i, BigIntegerGene.of(value, _min, _max)); } reflect.setField(this, "_genes", genes.toISeq()); }
private FilterResult<G, C> filter( final Seq<Phenotype<G, C>> population, final long generation ) { int killCount = 0; int invalidCount = 0; final MSeq<Phenotype<G, C>> pop = MSeq.of(population); for (int i = 0, n = pop.size(); i < n; ++i) { final Phenotype<G, C> individual = pop.get(i); if (!_validator.test(individual)) { pop.set(i, newPhenotype(generation)); ++invalidCount; } else if (individual.getAge(generation) > _maximalPhenotypeAge) { pop.set(i, newPhenotype(generation)); ++killCount; } } return new FilterResult<>(pop.toISeq(), killCount, invalidCount); }
/** * Swap the elements at the two positions. * * @param i the index of the first element. * @param j the index of the second element. * @throws IndexOutOfBoundsException if {@code i < 0 || j >= length()}. */ public default void swap(final int i, final int j) { final T temp = get(i); set(i, get(j)); set(j, temp); }
@Test public void toArrayLong() { long seed = random.seed(); final Random random = new Random(seed); final MSeq<Long> proxy = MSeq.ofLength(1000); for (int i = 0; i < proxy.length(); ++i) { proxy.set(i, random.nextLong()); } final List<Long> list = new SeqList<>(proxy); final Long[] array = list.toArray(new Long[0]); for (int i = 0; i < array.length; ++i) { Assert.assertEquals(array[i], proxy.get(i)); } }
@Test(dataProvider = "sequences") public void swapIntInt(final MSeq<BitGene> seq) { for (int i = 0; i < seq.length() - 3; ++i) { final BitGene[] copy = seq.toArray(new BitGene[0]); final int j = i + 2; final BitGene vi = seq.get(i); final BitGene vj = seq.get(j); seq.swap(i, j); Assert.assertEquals(seq.get(i), vj); Assert.assertEquals(seq.get(j), vi); for (int k = 0; k < seq.length(); ++k) { if (k != i && k != j) { Assert.assertEquals(seq.get(k), copy[k]); } } } }
final Comparator<? super T> dominance ) { final MSeq<T> front = MSeq.of(set); int n = front.size(); int i = 0; while (i < n) { int j = i + 1; while (j < n) { if (dominance.compare(front.get(i), front.get(j)) > 0) { --n; front.swap(j, n); } else if (dominance.compare(front.get(j), front.get(i)) > 0) { --n; front.swap(i, n); --i; break; return front.subSeq(0, n).copy().toISeq();
@Test public void crossoverWithIllegalChromosome() { final PartiallyMatchedCrossover<Integer, Double> pmco = new PartiallyMatchedCrossover<>(1); final int length = 1000; final MSeq<Integer> alleles = MSeq.<Integer>ofLength(length).fill(Int()); final ISeq<Integer> ialleles = alleles.toISeq(); final MSeq<EnumGene<Integer>> that = alleles.map(i -> new EnumGene<>(i, ialleles)); final MSeq<EnumGene<Integer>> other = alleles.map(i -> new EnumGene<>(i, ialleles)); pmco.crossover(that, other); }
@Test(dataProvider = "subSequences") public void subSeqImmutable(final Named<MSeq<Integer>> parameter) { final MSeq<Integer> seq = parameter.value; final Integer second = seq.get(1); final MSeq<Integer> slice = seq.subSeq(1); Assert.assertEquals(slice.get(0), second); final ISeq<Integer> islice = slice.toISeq(); Assert.assertEquals(islice.get(0), second); final Integer newSecond = -22; seq.set(1, newSecond); Assert.assertEquals(slice.get(0), newSecond); Assert.assertEquals(islice.get(0), second); }
@Test(dataProvider = "sequences") public void reverse(final MSeq<Integer> seq) { final ISeq<Integer> original = seq.toISeq(); seq.reverse(); Assert.assertNotEquals(seq, original); for (int i = 0; i < seq.length(); ++i) { Assert.assertEquals(seq.get(i), original.get(seq.length() - i - 1)); } Assert.assertEquals(original, seq.reverse()); }
@Test public void validPredicate() { final MSeq<Verifiable> array = MSeq.ofLength(100); for (int i = 0; i < array.length(); ++i) { array.set(i, () -> true); } Assert.assertEquals(array.indexWhere(o -> !o.isValid()), -1); array.set(77, () -> false); Assert.assertEquals(array.indexWhere(o -> !o.isValid()), 77); }
@Test(dataProvider = "subSequences") public void immutable(final Named<MSeq<Integer>> parameter) { final MSeq<Integer> seq = parameter.value; final Integer second = seq.get(1); final ISeq<Integer> iseq = seq.toISeq(); Assert.assertEquals(iseq.get(1), second); final Integer newSecond = -22; seq.set(1, newSecond); Assert.assertEquals(seq.get(1), newSecond); Assert.assertEquals(iseq.get(1), second); }
private static Seq<Integer> indexSort(final IndexSorter sorter, final Seq<Integer> values) { final int[] indexes = sorter.sort(values, indexes(values.length())); final MSeq<Integer> result = MSeq.ofLength(values.length()); for (int i = 0; i < result.length(); ++i) { result.set(i, values.get(indexes[i])); } return result; }
@Test(dataProvider = "sequences") public void setAll(final MSeq<Integer> seq) { final long seed = random.seed(); final Random random = new Random(seed); final Integer v = random.nextInt(); seq.fill(() -> v); random.setSeed(seed); final Integer value = random.nextInt(); for (int i = 0; i < seq.length(); ++i) { Assert.assertEquals(seq.get(i), value); } }