/** * Return this sequence as {@code MSeq} instance. If {@code this} is not a * {@code MSeq} a new seq is created. * * @since 3.8 * * @return a {@code MSeq} with this values */ public default MSeq<T> asMSeq() { return this instanceof MSeq ? (MSeq<T>)this : MSeq.of(this); }
@Override public MSeq<Object> append(final Iterable<?> values) { return MSeq.of(values); }
@Override public MSeq<Object> append(final Object... values) { return MSeq.of(values); }
@Override public MSeq<Object> prepend(final Object... values) { return MSeq.of(values); }
@Override public MSeq<Object> prepend(final Iterable<?> values) { return MSeq.of(values); }
/** * Create a new statistics object with the given expected parameter count of * the accepted samples. * * @param parameterCount the parameter count or sample size, respectively * @throws IllegalArgumentException if the given {@code parameterCount} * is smaller then one */ public SampleSummaryStatistics(final int parameterCount) { _parameterCount = require.positive(parameterCount); _moments = MSeq.of(DoubleMomentStatistics::new, parameterCount).toISeq(); _quantiles = MSeq.of(ExactQuantile::new, parameterCount).toISeq(); }
@Test(expectedExceptions = ArrayStoreException.class) public void toArray4() { final Seq<String> mseq = MSeq.of("1", "2"); final Integer[] array = mseq.toArray(new Integer[]{1, 2, 3, 4}); }
@Test(expectedExceptions = ArrayIndexOutOfBoundsException.class) public void subSeqOutOtBounds1() { MSeq.of(1, 2, 3).subSeq(5); }
@Test public void emptySeqAppend() { final MSeq<Integer> empty = MSeq.empty(); final MSeq<Integer> seq = MSeq.of(1, 2, 3, 4); final MSeq<Integer> aseq = empty.append(seq); Assert.assertEquals(aseq, seq); }
@Test public void toArray2() { final Seq<String> mseq = MSeq.of("1", "2"); final String[] array = mseq.toArray(new String[]{"a", "b", "c", "d"}); Assert.assertEquals(array.length, 4); Assert.assertEquals(array[0], mseq.get(0)); Assert.assertEquals(array[1], mseq.get(1)); Assert.assertNull(array[2]); Assert.assertEquals(array[3], "d"); }
@Test public void toArray3() { final Seq<String> mseq = MSeq.of("1", "2"); final Object[] array = mseq.toArray(new Object[]{"a", "b", "c", "d"}); Assert.assertEquals(array.length, 4); Assert.assertEquals(array[0], mseq.get(0)); Assert.assertEquals(array[1], mseq.get(1)); Assert.assertNull(array[2]); Assert.assertEquals(array[3], "d"); }
@Test public void emptySeqPrepend() { final MSeq<Integer> empty = MSeq.empty(); final MSeq<Integer> seq = MSeq.of(1, 2, 3, 4); final MSeq<Integer> aseq = empty.prepend(seq); Assert.assertEquals(aseq, seq); }
@Test public void zeroLengthSameAsEmpty() { Assert.assertSame(MSeq.of(), MSeq.empty()); }
@Test public void toArray() { final Seq<String> mseq = MSeq.of("1"); final String[] array = mseq.toArray(new String[0]); Assert.assertEquals(array.length, mseq.size()); Assert.assertEquals(array[0], mseq.get(0)); }
@Test public void recombine() { final Factory<DoubleGene> factory = DoubleGene.of(0, 100); final MSeq<DoubleGene> v = MSeq.of(factory::newInstance, 10); final MSeq<DoubleGene> w = MSeq.of(factory::newInstance, 10); final IntermediateCrossover<DoubleGene, Double> recombinator = new IntermediateCrossover<>(0.1, 10); recombinator.crossover(v, w); Assert.assertTrue(v.forAll(DoubleGene::isValid)); Assert.assertTrue(w.forAll(DoubleGene::isValid)); }
@Test public void recombine() { final Factory<DoubleGene> factory = DoubleGene.of(0, 100); final MSeq<DoubleGene> v = MSeq.of(factory::newInstance, 10); final MSeq<DoubleGene> w = MSeq.of(factory::newInstance, 10); final LineCrossover<DoubleGene, Double> recombinator = new LineCrossover<>(); recombinator.crossover(v, w); Assert.assertTrue(v.forAll(DoubleGene::isValid)); Assert.assertTrue(w.forAll(DoubleGene::isValid)); }
@Test public void subSeqEmptyMSeq() { Assert.assertSame(MSeq.of(1, 2, 3).subSeq(3), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(3, 3), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(2, 2), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(1, 1), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(0, 0), MSeq.empty()); }
@Test public void asISeq() { final Seq<String> iseq = ISeq.of("1"); Assert.assertSame(iseq.asISeq(), iseq); final Seq<String> mseq = MSeq.of("1"); Assert.assertNotSame(mseq.asISeq(), mseq); Assert.assertEquals(mseq.asISeq(), mseq); }
@Test public void asMSeq() { final Seq<String> mseq = MSeq.of("1"); Assert.assertSame(mseq.asMSeq(), mseq); final Seq<String> iseq = ISeq.of("1"); Assert.assertNotSame(iseq.asMSeq(), iseq); Assert.assertEquals(iseq.asMSeq(), iseq); }
@Override public AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { final AltererResult<G, C> result = _adoptee.alter(population, generation); final MSeq<Phenotype<G, C>> pop = MSeq.of(population); for (int i = 0, n = pop.size(); i < n; ++i) { if (!pop.get(i).isValid()) { pop.set(i, repair(pop.get(i))); } } return AltererResult.of(pop.toISeq(), result.getAlterations()); }