@Override public ISeq<Phenotype<G, C>> select( final Seq<Phenotype<G, C>> population, final int count, final Optimize opt ) { requireNonNull(population, "Population"); requireNonNull(opt, "Optimization"); if (count < 0) { throw new IllegalArgumentException(format( "Selection count must be greater or equal then zero, but was %s", count )); } final MinMax<Phenotype<G, C>> minMax = population.stream() .collect(MinMax.toMinMax(opt.ascending())); final MSeq<Phenotype<G, C>> result = MSeq.ofLength(count); return result.fill(minMax::getMax).toISeq(); }
static <A> ISeq<AnyGene<A>> seq( final IntRange lengthRange, final Supplier<? extends A> supplier, final Predicate<? super A> validator ) { return MSeq.<AnyGene<A>>ofLength(random.nextInt(lengthRange, getRandom())) .fill(() -> of(supplier.get(), supplier, validator)) .toISeq(); }
/** * Create a new chromosome from the given genes (given as string). * * @param alleles the character genes. * @param validChars the valid characters. * @return a new {@code CharacterChromosome} with the given parameter * @throws IllegalArgumentException if the genes string is empty. */ public static CharacterChromosome of( final String alleles, final CharSeq validChars ) { final IntRef index = new IntRef(); final Supplier<CharacterGene> geneFactory = () -> CharacterGene.of( alleles.charAt(index.value++), validChars ); final ISeq<CharacterGene> genes = MSeq.<CharacterGene>ofLength(alleles.length()) .fill(geneFactory) .toISeq(); return new CharacterChromosome(genes, IntRange.of(alleles.length())); }
@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); } }
static ISeq<PolygonGene> seq(final int polygonCount, final int polygonLength) { return MSeq.<PolygonGene>ofLength(polygonCount) .fill(() -> of(Polygon.newRandom(polygonLength))) .toISeq(); }
@DataProvider(name = "numberOfCrossoverPoints") public Iterator<Object[]> getNumberOfCrossoverPoints() { return MSeq.<Object[]>ofLength(11).fill(new Supplier<Object[]>() { private int point = 0; @Override public Object[] get() { return new Object[]{++point}; } }).iterator(); }
@Test(dataProvider = "sequences") public void fill(final MSeq<Integer> seq) { final long seed = random.seed(); final Random random = new Random(seed); seq.fill(RandomInt(random)); random.setSeed(seed); for (int i = 0; i < seq.length(); ++i) { Assert.assertEquals(seq.get(i).intValue(), random.nextInt()); } }
static ISeq<CharacterGene> seq( final CharSeq chars, final IntRange lengthRange ) { final Random r = RandomRegistry.getRandom(); return MSeq.<CharacterGene>ofLength(random.nextInt(lengthRange, r)) .fill(() -> new CharacterGene(chars, r.nextInt(chars.length()))) .toISeq(); }
public static void main(final String[] args) throws IOException { final File baseDir = new File( "jenetics/src/test/resources/io/jenetics/collection/serialization"); if (!baseDir.isDirectory() && !baseDir.mkdirs()) { throw new IOException("Error while creating directory " + baseDir); } for (int i = 0; i < 10; ++i) { final Random random = new Random(i); final MSeq<String> seq = MSeq.ofLength(i); seq.fill(() -> nextASCIIString(100, random)); IO.object.write(seq, new File(baseDir, format("MSeq[%s].object", i))); IO.object.write(seq.toISeq(), new File(baseDir, format("ISeq[%s].object", i))); } }
@Test public void serialization() throws IOException { for (int i = 0; i < 10; ++i) { final Random random = new Random(i); final MSeq<String> seq = MSeq.ofLength(i); seq.fill(() -> nextASCIIString(100, random)); String resource = format(RESOURCE_PATTERN, "MSeq", i); try (InputStream in = getClass().getResourceAsStream(resource)) { final Object o = IO.object.read(in); Assert.assertEquals(o, seq); } resource = format(RESOURCE_PATTERN, "ISeq", i); try (InputStream in = getClass().getResourceAsStream(resource)) { final Object o = IO.object.read(in); Assert.assertEquals(o, seq.toISeq()); } } }
static ISeq<DoubleGene> seq( final double min, final double max, final IntRange lengthRange ) { final Random r = getRandom(); return MSeq.<DoubleGene>ofLength(random.nextInt(lengthRange, r)) .fill(() -> of(nextDouble(min, max, r), min, max)) .toISeq(); }
static ISeq<LongGene> seq( final long min, final long max, final IntRange lengthRange ) { final Random r = getRandom(); return MSeq.<LongGene>ofLength(random.nextInt(lengthRange, r)) .fill(() -> LongGene.of(nextLong(r, min, max), min, max)) .toISeq(); }
static ISeq<IntegerGene> seq( final int min, final int max, final IntRange lengthRange ) { final Random r = getRandom(); return MSeq.<IntegerGene>ofLength(random.nextInt(lengthRange, r)) .fill(() -> new IntegerGene(nextInt(r, min, max), min, max)) .toISeq(); }
static ISeq<BigIntegerGene> seq( final BigInteger minimum, final BigInteger maximum, final int length ) { require.positive(length); final Random r = getRandom(); return MSeq.<BigIntegerGene>ofLength(length) .fill(() -> new BigIntegerGene( random.nextBigInteger(minimum, maximum, r), minimum, maximum)) .toISeq(); }
@Test(expectedExceptions = IndexOutOfBoundsException.class) public void valueOfIndexOutOfBounds1() { final int length = 100; final ISeq<Integer> alleles = MSeq.<Integer>ofLength(length).fill(Int()).toISeq(); new EnumGene<>(length + 1, alleles); }
@Test(expectedExceptions = IndexOutOfBoundsException.class) public void valueOfIndexOutOfBounds2() { final int length = 100; final ISeq<Integer> alleles = MSeq.<Integer>ofLength(length).fill(Int()).toISeq(); new EnumGene<>(-1, alleles); }
@Test(expectedExceptions = IllegalArgumentException.class) public void valueOfZeroLength() { final int length = 0; final ISeq<Integer> alleles = MSeq.<Integer>ofLength(length).fill(Int()).toISeq(); EnumGene.of(alleles); }
@Test public void invalidChromosome() { final ISeq<Integer> alleles = ISeq.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); final EnumGene<Integer> gene = new EnumGene<>(3, alleles); final ISeq<EnumGene<Integer>> genes = MSeq.<EnumGene<Integer>>ofLength(10) .fill(() -> gene) .toISeq(); final PermutationChromosome<Integer> chromosome = new PermutationChromosome<>(genes); Assert.assertFalse(chromosome.isValid()); }
@Test public void valueOf() { final int length = 100; final ISeq<Integer> alleles = MSeq.<Integer>ofLength(length).fill(Int()).toISeq(); Assert.assertEquals(alleles.length(), length); for (int i = 0; i < alleles.length(); ++i) { Assert.assertEquals(alleles.get(i), Integer.valueOf(i)); } for (int i = 0; i < alleles.length(); ++i) { Assert.assertEquals(new EnumGene<>(i, alleles).getAllele(), Integer.valueOf(i)); Assert.assertSame(new EnumGene<>(i, alleles).getValidAlleles(), alleles); } }
@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); }