/** * Fills the sequence with values of the given iterator. * * @param it the iterator of the values to fill this sequence. * @return {@code this} sequence. */ public default MSeq<T> setAll(final Iterator<? extends T> it) { for (int i = 0, n = length(); i < n && it.hasNext(); ++i) { set(i, it.next()); } return this; }
/** * Fill the sequence with the given values. * * @param values the first initial values of this sequence * @return {@code this} sequence. */ public default MSeq<T> setAll(final T[] values) { for (int i = 0, n = min(length(), values.length); i < n; ++i) { set(i, values[i]); } return this; }
/** * 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); }
@Override public T set(final int index, final T element) { final T oldElement = seq.get(index); ((MSeq<T>)seq).set(index, element); return oldElement; }
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 void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); final MSeq<IntegerGene> genes = MSeq.ofLength(in.readInt()); reflect.setField(this, "_lengthRange", in.readObject()); reflect.setField(this, "_min", in.readInt()); reflect.setField(this, "_max", in.readInt()); for (int i = 0; i < genes.length(); ++i) { genes.set(i, IntegerGene.of(in.readInt(), _min, _max)); } reflect.setField(this, "_genes", genes.toISeq()); }
@SuppressWarnings("unchecked") private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); _validAlleles = (ISeq<T>)in.readObject(); final MSeq<EnumGene<T>> genes = MSeq.ofLength(_validAlleles.length()); for (int i = 0; i < _validAlleles.length(); ++i) { genes.set(i, new EnumGene<>(in.readInt(), _validAlleles)); } reflect.setField(this, "_genes", genes.toISeq()); }
@Override public <B> Seq<B> map(final Function<? super T, ? extends B> mapper) { requireNonNull(mapper); final MSeq<B> result = MSeq.ofLength(length()); for (int i = 0; i < length(); ++i) { result.set(i, mapper.apply(get(i))); } return result.toISeq(); }
private static <G extends Gene<?, G> & Mean<G>> MSeq<G> mean(final MSeq<G> a, final Seq<G> b) { for (int i = a.length(); --i >= 0;) { a.set(i, a.get(i).mean(b.get(i))); } return a; }
@Test(dataProvider = "sequences") public void set(final MSeq<Integer> seq) { final long seed = random.seed(); final Random random = new Random(seed); for (int i = 0; i < seq.length(); ++i) { seq.set(i, random.nextInt()); } random.setSeed(seed); for (int i = 0; i < seq.length(); ++i) { Assert.assertEquals(seq.get(i).intValue(), random.nextInt()); } }
@Override @SuppressWarnings("unchecked") public void swap(int start, int end, MSeq<T> other, int otherStart) { checkIndex(start, end, otherStart, other.length()); if (start < end) { for (int i = end - start; --i >= 0;) { final T temp = array.get(i + start); array.set(i + start, other.get(otherStart + i)); other.set(otherStart + i, temp); } } }
@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); }
private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); final MSeq<DoubleGene> genes = MSeq.ofLength(in.readInt()); reflect.setField(this, "_lengthRange", in.readObject()); reflect.setField(this, "_min", in.readDouble()); reflect.setField(this, "_max", in.readDouble()); for (int i = 0; i < genes.length(); ++i) { genes.set(i, DoubleGene.of(in.readDouble(), _min, _max)); } reflect.setField(this, "_genes", genes.toISeq()); }
@Test public void sliceLastIndexOf() { final MSeq<Integer> proxy = MSeq.ofLength(1000); for (int i = 0; i < proxy.length(); ++i) { proxy.set(i, i); } final int sliceStart = 50; final int sliceEnd = 500; final MSeq<Integer> slice = proxy.subSeq(sliceStart, sliceEnd); final List<Integer> list = new SeqList<>(slice); for (int i = 0; i < list.size(); ++i) { final int index = list.lastIndexOf(sliceStart + i); Assert.assertEquals(index, i); } }
@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); }
@Test public void swapSamePosition() { MSeq<BitGene> seqWithFalse = newSeq(1); seqWithFalse.set(0, BitGene.FALSE); MSeq<BitGene> seqWithTrue = newSeq(1); seqWithTrue.set(0, BitGene.TRUE); seqWithFalse.swap(0, seqWithTrue); Assert.assertTrue(seqWithFalse.get(0).booleanValue()); Assert.assertFalse(seqWithTrue.get(0).booleanValue()); }
public static ISeq<Phenotype<DoubleGene, Double>> newDoublePopulation( final int length, final double min, final double max ) { final MSeq<Phenotype<DoubleGene, Double>> population = MSeq.ofLength(length); for (int i = 0; i < length; ++i) { population.set(i, newDoublePhenotype(min, max)); } return population.toISeq(); }
@Test(expectedExceptions = IllegalArgumentException.class) public void selectNegativeCountArgument() { final Factory<Genotype<DoubleGene>> gtf = Genotype.of(DoubleChromosome.of(0.0, 1.0)); final MSeq<Phenotype<DoubleGene, Double>> population = MSeq.ofLength(2); for (int i = 0, n = 2; i < n; ++i) { population.set(i, Phenotype.of(gtf.newInstance(), 12, TestUtils.FF)); } selector().select(population.toISeq(), -1, Optimize.MAXIMUM); }
@Test(expectedExceptions = NullPointerException.class) public void selectNullOptimizeArgument() { final Factory<Genotype<DoubleGene>> gtf = Genotype.of(DoubleChromosome.of(0.0, 1.0)); final MSeq<Phenotype<DoubleGene, Double>> population = MSeq.ofLength(2); for (int i = 0, n = 2; i < n; ++i) { population.set(i, Phenotype.of(gtf.newInstance(), 12, TestUtils.FF)); } selector().select(population.toISeq(), 1, null); }
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; }