From 1472ab3082eecef164b5bae95a1dac6daee9f61e Mon Sep 17 00:00:00 2001 From: vidinalex Date: Mon, 17 Jul 2017 17:20:06 +0300 Subject: [PATCH 1/5] part 2 completed --- .../example/ArrayZipWithIndexExample.java | 1 - .../part2/exercise/IndexedDoublePair.java | 6 +- .../ZipWithIndexDoubleSpliterator.java | 36 ++++++------ .../ZipWithIndexDoubleSpliteratorTest.java | 57 +++++++++++++++++++ 4 files changed, 80 insertions(+), 20 deletions(-) create mode 100644 src/test/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliteratorTest.java 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..aec0551 100755 --- a/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java +++ b/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java @@ -1,20 +1,20 @@ package spliterators.part2.exercise; +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 +22,39 @@ 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)) { + OfDouble ofDouble = inner.trySplit(); + return new ZipWithIndexDoubleSpliterator(currentIndex + ofDouble.estimateSize(), ofDouble); + } else { + return super.trySplit(); + } - return super.trySplit(); } @Override public long estimateSize() { - // TODO - throw new UnsupportedOperationException(); + return 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 From 7c8fc62696cf4ea623c072f5d25333ec9877466e Mon Sep 17 00:00:00 2001 From: vidinalex Date: Tue, 18 Jul 2017 17:05:25 +0300 Subject: [PATCH 2/5] step 1 --- .../exercise/ZipWithArraySpliterator.java | 45 +++++++++++++------ 1 file changed, 31 insertions(+), 14 deletions(-) diff --git a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java index 292137e..b241669 100755 --- a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java +++ b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java @@ -7,42 +7,59 @@ 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 null; + return super.trySplit(); + } } @Override public long estimateSize() { - // TODO - throw new UnsupportedOperationException(); + return Math.min(array.length - currentIndex, inner.estimateSize()); } } From 2440317646eb1f981c79d5dcbf29f2b846ea08f6 Mon Sep 17 00:00:00 2001 From: vidinalex Date: Tue, 18 Jul 2017 17:06:12 +0300 Subject: [PATCH 3/5] step 2 --- .../exercise/ZipWithArraySpliteratorTest.java | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java 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..f5784f1 --- /dev/null +++ b/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java @@ -0,0 +1,86 @@ +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); + } + +} \ No newline at end of file From e88a9c84de684f0366dcac41a743b4a7d53cb806 Mon Sep 17 00:00:00 2001 From: vidinalex Date: Tue, 18 Jul 2017 17:11:49 +0300 Subject: [PATCH 4/5] part 2 fix --- .../part2/exercise/ZipWithIndexDoubleSpliterator.java | 9 +++++++-- .../part3/exercise/ZipWithArraySpliterator.java | 1 - 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java b/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java index aec0551..c5fdb92 100755 --- a/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java +++ b/src/main/java/spliterators/part2/exercise/ZipWithIndexDoubleSpliterator.java @@ -1,5 +1,7 @@ package spliterators.part2.exercise; +import spliterators.part3.exercise.ZipWithArraySpliterator; + import java.util.Comparator; import java.util.Spliterator; import java.util.Spliterators; @@ -45,12 +47,15 @@ public void forEachRemaining(Consumer action) { @Override public Spliterator trySplit() { if (inner.hasCharacteristics(Spliterator.SUBSIZED)) { + long innerSize = inner.estimateSize(); OfDouble ofDouble = inner.trySplit(); - return new ZipWithIndexDoubleSpliterator(currentIndex + ofDouble.estimateSize(), ofDouble); + + ZipWithIndexDoubleSpliterator zipWithIndexDoubleSpliterator = new ZipWithIndexDoubleSpliterator(currentIndex, ofDouble); + currentIndex = (int) (currentIndex + innerSize / 2); + return zipWithIndexDoubleSpliterator; } else { return super.trySplit(); } - } @Override diff --git a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java index b241669..7a94cc2 100755 --- a/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java +++ b/src/main/java/spliterators/part3/exercise/ZipWithArraySpliterator.java @@ -53,7 +53,6 @@ public Spliterator> trySplit() { currentIndex = (int) (currentIndex + innerSize / 2); return abZipWithArraySpliterator; } else { - //return null; return super.trySplit(); } } From ade097a0daf969885b0463663d9b48fcbafe55ca Mon Sep 17 00:00:00 2001 From: vidinalex Date: Tue, 18 Jul 2017 17:16:41 +0300 Subject: [PATCH 5/5] add tests --- .../exercise/ZipWithArraySpliteratorTest.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java b/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java index f5784f1..9781114 100644 --- a/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java +++ b/src/test/java/spliterators/part3/exercise/ZipWithArraySpliteratorTest.java @@ -83,4 +83,32 @@ public void testSeqDifSize() { 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