diff --git a/src/main/java/spliterators/part2/example/ArrayZipWithIndexExample.java b/src/main/java/spliterators/part2/example/ArrayZipWithIndexExample.java index dd00263..96da908 100755 --- a/src/main/java/spliterators/part2/example/ArrayZipWithIndexExample.java +++ b/src/main/java/spliterators/part2/example/ArrayZipWithIndexExample.java @@ -8,7 +8,6 @@ public class ArrayZipWithIndexExample { public static class IndexedArraySpliterator extends Spliterators.AbstractSpliterator> { - private final T[] array; private int startInclusive; private final int endExclusive; diff --git a/src/main/java/spliterators/part2/exercise/IndexedDoublePair.java b/src/main/java/spliterators/part2/exercise/IndexedDoublePair.java index d3c0162..424948b 100755 --- a/src/main/java/spliterators/part2/exercise/IndexedDoublePair.java +++ b/src/main/java/spliterators/part2/exercise/IndexedDoublePair.java @@ -5,15 +5,15 @@ import org.apache.commons.lang3.builder.ToStringBuilder; public class IndexedDoublePair { - private final int index; + private final long index; private final double value; - public IndexedDoublePair(int index, double value) { + public IndexedDoublePair(long index, double value) { this.index = index; this.value = value; } - public int getIndex() { + public long getIndex() { return index; } diff --git a/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java b/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java index deb4867..c5fdb92 100755 --- a/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java +++ b/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java @@ -1,20 +1,22 @@ package spliterators.part2.exercise; +import spliterators.part3.exercise.ZipWithArraySpliterator; + +import java.util.Comparator; import java.util.Spliterator; import java.util.Spliterators; import java.util.function.Consumer; public class ZipWithIndexDoubleSpliterator extends Spliterators.AbstractSpliterator { - private final OfDouble inner; - private int currentIndex; + private long currentIndex; public ZipWithIndexDoubleSpliterator(OfDouble inner) { this(0, inner); } - private ZipWithIndexDoubleSpliterator(int firstIndex, OfDouble inner) { + private ZipWithIndexDoubleSpliterator(long firstIndex, OfDouble inner) { super(inner.estimateSize(), inner.characteristics()); currentIndex = firstIndex; this.inner = inner; @@ -22,35 +24,42 @@ private ZipWithIndexDoubleSpliterator(int firstIndex, OfDouble inner) { @Override public int characteristics() { - // TODO - throw new UnsupportedOperationException(); + return inner.characteristics() | Spliterator.DISTINCT /*& ~Spliterator.SORTED*/; } @Override public boolean tryAdvance(Consumer action) { - // TODO - throw new UnsupportedOperationException(); + return inner.tryAdvance((double d) -> action.accept(new IndexedDoublePair(currentIndex++, d))); + } + + @Override + public Comparator getComparator() { + return (i1, i2) -> inner.getComparator().compare(i1.getValue(),i2.getValue()); } @Override public void forEachRemaining(Consumer action) { - // TODO - throw new UnsupportedOperationException(); + inner.forEachRemaining( + (double d) -> action.accept(new IndexedDoublePair(currentIndex++, d)) + ); } @Override public Spliterator trySplit() { - // TODO - // if (inner.hasCharacteristics(???)) { - // use inner.trySplit - // } else + if (inner.hasCharacteristics(Spliterator.SUBSIZED)) { + long innerSize = inner.estimateSize(); + OfDouble ofDouble = inner.trySplit(); - return super.trySplit(); + ZipWithIndexDoubleSpliterator zipWithIndexDoubleSpliterator = new ZipWithIndexDoubleSpliterator(currentIndex, ofDouble); + currentIndex = (int) (currentIndex + innerSize / 2); + return zipWithIndexDoubleSpliterator; + } else { + return super.trySplit(); + } } @Override public long estimateSize() { - // TODO - throw new UnsupportedOperationException(); + return inner.estimateSize(); } } diff --git a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java index 292137e..7a94cc2 100755 --- a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java +++ b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java @@ -7,42 +7,58 @@ public class ZipWithArraySpliterator extends Spliterators.AbstractSpliterator> { - private final Spliterator inner; + private Spliterator inner; + int currentIndex; private final B[] array; public ZipWithArraySpliterator(Spliterator inner, B[] array) { - super(Long.MAX_VALUE, 0); // FIXME: - // TODO - throw new UnsupportedOperationException(); + this(inner, array, 0); + } + + private ZipWithArraySpliterator(Spliterator inner, B[] array, int index) { + super(Math.min(inner.estimateSize(), array.length), inner.characteristics()); + this.inner = inner; + this.array = array; + this.currentIndex = index; } @Override public int characteristics() { - // TODO - throw new UnsupportedOperationException(); + return inner.characteristics() & ~Spliterator.SORTED; } @Override public boolean tryAdvance(Consumer> action) { - // TODO - throw new UnsupportedOperationException(); + return inner.tryAdvance(value -> + action.accept( + new Pair<>(value, array[currentIndex++]) + ) + ); } @Override public void forEachRemaining(Consumer> action) { - // TODO - throw new UnsupportedOperationException(); + for (; currentIndex < estimateSize(); ++currentIndex) { + inner.tryAdvance(value -> new Pair<>(value, array[currentIndex])); + } } @Override public Spliterator> trySplit() { - // TODO - throw new UnsupportedOperationException(); + if (inner.hasCharacteristics(Spliterator.SUBSIZED)) { + long innerSize = inner.estimateSize(); + Spliterator aSpliterator = inner.trySplit(); + + ZipWithArraySpliterator abZipWithArraySpliterator = new ZipWithArraySpliterator<>(aSpliterator, array, currentIndex); + currentIndex = (int) (currentIndex + innerSize / 2); + return abZipWithArraySpliterator; + } else { + return super.trySplit(); + } } @Override public long estimateSize() { - // TODO - throw new UnsupportedOperationException(); + return Math.min(array.length - currentIndex, inner.estimateSize()); } } diff --git a/src/test/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliteratorTest.java b/src/test/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliteratorTest.java new file mode 100644 index 0000000..b290561 --- /dev/null +++ b/src/test/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliteratorTest.java @@ -0,0 +1,57 @@ +package spliterators.part2.exercise; + +import org.junit.Test; + +import java.util.Spliterator; +import java.util.stream.DoubleStream; +import java.util.stream.StreamSupport; + +import static org.junit.Assert.*; + +/** + * Created by student on 7/17/17. + */ +public class ZipWithIndexDoubleSpliteratorTest { + + private int maxSize; + + @Test + public void testPar() { + maxSize = 100; + Spliterator.OfDouble spliterator = DoubleStream.iterate(1.0, i -> i + 0.1) + .limit(maxSize) + .spliterator(); + + double sum = StreamSupport.stream(new ZipWithIndexDoubleSpliterator(spliterator), true) + .mapToDouble(z -> z.getIndex()*z.getValue()) + .sum(); + + double res = 0.0; + + for (int i = 0; i < maxSize; ++i) { + res += i * (1.0 + 0.1*i); + } + + assertEquals(sum, res, 0.1); + } + + @Test + public void testSeq() { + maxSize = 100; + Spliterator.OfDouble spliterator = DoubleStream.iterate(1.0, i -> i + 0.1) + .limit(maxSize) + .spliterator(); + + double sum = StreamSupport.stream(new ZipWithIndexDoubleSpliterator(spliterator), false) + .mapToDouble(z -> z.getIndex()*z.getValue()) + .sum(); + + double res = 0.0; + + for (int i = 0; i < maxSize; ++i) { + res += i * (1.0 + 0.1*i); + } + + assertEquals(sum, res, 0.1); + } +} \ No newline at end of file diff --git a/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java b/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java new file mode 100644 index 0000000..9781114 --- /dev/null +++ b/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java @@ -0,0 +1,114 @@ +package spliterators.part3.exercise; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.Spliterator; +import java.util.stream.DoubleStream; +import java.util.stream.StreamSupport; + +import static org.junit.Assert.*; + +/** + * Created by student on 7/18/17. + */ +public class ZipWithArraySpliteratorTest { + + private int maxSize; + + @Test + public void testPar() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(array), Arrays.copyOf(array, array.length)), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + + private Double[] generateDouble() { + Double[] doubles = new Double[maxSize]; + + for (int i = 0; i < maxSize; i++) { + doubles[i] = Math.random(); + } + + return doubles; + } + + @Test + public void testSeq() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(array), Arrays.copyOf(array, array.length)), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + + @Test + public void testParDifSize() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(array), Arrays.copyOf(array, array.length/2)), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + + + @Test + public void testSeqDifSize() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(array), Arrays.copyOf(array, array.length/2)), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + + @Test + public void emptyRight() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(array), Arrays.copyOf(array, 0)), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + + @Test + public void emptLeft() { + maxSize = 10000; + + Double[] array = generateDouble(); + double sum = StreamSupport.stream(new ZipWithArraySpliterator<>(Arrays.spliterator(Arrays.copyOf(array, 0)), array), true) + .mapToDouble(pair -> pair.getA() - pair.getB()) + .sum(); + + double res = 0.0; + + assertEquals(sum, res, 0.1); + } + +} \ No newline at end of file