*
* Default implementation: Calls contains(index).
*/
- public default boolean get(int index)
+ default boolean get(int index)
{
return contains(index);
}
@@ -74,9 +77,9 @@ public default boolean get(int index)
* Default implementation:
* Tests via contains for all elements of other.
*/
- public default boolean contains(IntSet other)
+ default boolean contains(IntSet other)
{
- return other.stream().allMatch(this::contains);
+ return other.allMatch((IntPredicate) this::contains);
}
/**
@@ -86,7 +89,7 @@ public default boolean contains(IntSet other)
* Default implementation:
* Uses contains(IntSet other).
*/
- public default boolean contains(BitSet other)
+ default boolean contains(BitSet other)
{
return contains(asIntSet(other));
}
@@ -97,23 +100,32 @@ public default boolean contains(BitSet other)
* Default implementation:
* Wrap iterator() into an intStream.
*/
- public default IntStream stream() {
+ default IntStream stream()
+ {
return StreamSupport.intStream(
- () -> Spliterators.spliterator(
- iterator(), cardinality(),
- Spliterator.DISTINCT),
+ () -> spliterator(),
Spliterator.SIZED | Spliterator.DISTINCT,
false);
}
+ @Override
+ default Spliterator.OfInt spliterator()
+ {
+ return Spliterators.spliterator(
+ iterator(),
+ cardinality(),
+ Spliterator.SIZED | Spliterator.DISTINCT);
+ }
+
/** Return this set as a String */
- public default String asString()
+ @Override
+ default String asString()
{
// can't overload toString() with a default method in interface
StringBuffer sb = new StringBuffer();
sb.append("{");
boolean first = true;
- for (OfInt it = iterator(); it.hasNext(); ) {
+ for (PrimitiveIterator.OfInt it = iterator(); it.hasNext(); ) {
if (!first)
sb.append(",");
first = false;
@@ -123,33 +135,36 @@ public default String asString()
return sb.toString();
}
+
+
/**
* Wrapper class for obtaining an IntSet from a BitSet.
*
* Note: The BitSet should not be modified as long as the
* derived IntSet is in use.
*/
- public static class IntSetFromBitSet implements IntSet
+ static class IntSetFromBitSet implements IntSet
{
/** The wrapped BitSet */
- private BitSet bs;
+ protected BitSet bs;
/** The cardinality of the underlying BitSet (cached, -1 = not yet computed) */
int cardinality = -1;
/** Constructor */
public IntSetFromBitSet(BitSet bs)
{
+ Objects.requireNonNull(bs);
this.bs = bs;
}
@Override
- public OfInt iterator()
+ public FunctionalPrimitiveIterator.OfInt iterator()
{
return IterableBitSet.getSetBits(bs).iterator();
}
@Override
- public OfInt reversedIterator()
+ public FunctionalPrimitiveIterator.OfInt reversedIterator()
{
return IterableBitSet.getSetBitsReversed(bs).iterator();
}
@@ -161,7 +176,7 @@ public IntStream stream()
}
@Override
- public int cardinality()
+ public long count()
{
// not yet computed?
if (cardinality == -1)
@@ -183,86 +198,53 @@ public String toString()
}
};
+
+
/** Convenience class for simulating a singleton set */
- public static class SingletonIntSet implements IntSet
+ static class SingletonIntSet extends SingletonIterable.OfInt implements IntSet
{
- /** The single member of this singleton set */
- private int singleMember;
-
/**
* Constructor.
* @param singleMember the single member of this set
*/
public SingletonIntSet(int singleMember)
{
- this.singleMember = singleMember;
+ super(singleMember);
}
@Override
- public OfInt iterator()
- {
- return new OfInt() {
- boolean done = false;
- @Override
- public boolean hasNext()
- {
- return !done;
- }
- @Override
- public int nextInt()
- {
- done = true;
- return singleMember;
- }
- };
- }
-
- @Override
- public OfInt reversedIterator()
+ public FunctionalPrimitiveIterator.OfInt reversedIterator()
{
// iteration order does not matter for singleton set
return iterator();
}
- @Override
- public int cardinality()
- {
- return 1;
- }
-
- @Override
- public boolean contains(int index)
- {
- return index == singleMember;
- }
-
@Override
public String toString()
{
- return "{" + singleMember + "}";
+ return "{" + element + "}";
}
-
}
/**
- * Static constructor for obtaining an IntSet from a BitSet
+ * Factory method for obtaining an IntSet from a BitSet
*
* Note: The BitSet should not be modified as long as the derived IntSet is in use.
+ *
* @param bs The underlying BitSet
*/
- public static IntSet asIntSet(BitSet bs)
+ static IntSet asIntSet(BitSet bs)
{
return new IntSetFromBitSet(bs);
}
/**
- * Static constructor for obtaining an IntSet for a singleton set.
+ * Factory method for obtaining an IntSet for a singleton set.
+ *
* @param singleMember The single member of the singleton set
*/
- public static IntSet asIntSet(int singleMember)
+ static IntSet asIntSet(int singleMember)
{
return new SingletonIntSet(singleMember);
}
-
}
-
diff --git a/prism/src/common/IterableBitSet.java b/prism/src/common/IterableBitSet.java
index da2e85bfcf..8e90563a17 100644
--- a/prism/src/common/IterableBitSet.java
+++ b/prism/src/common/IterableBitSet.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2014-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -30,9 +30,9 @@
import java.util.BitSet;
import java.util.NoSuchElementException;
import java.util.Objects;
-import java.util.PrimitiveIterator.OfInt;
-import common.iterable.IterableInt;
+import common.iterable.FunctionalPrimitiveIterable;
+import common.iterable.FunctionalPrimitiveIterator;
/**
* Convenience class to loop easily over the set/clear bits of a BitSet.
@@ -40,7 +40,7 @@
* For example:
* for (Integer index : getSetBits(set)) { ... }
*/
-public class IterableBitSet implements IterableInt
+public class IterableBitSet implements FunctionalPrimitiveIterable.OfInt
{
protected final BitSet set;
protected final boolean clearBits;
@@ -92,7 +92,7 @@ public IterableBitSet(BitSet set, Integer maxIndex, boolean clearBits, boolean r
}
/** Implementation of the iterator over the set bits */
- private class SetBitsIterator implements OfInt
+ private class SetBitsIterator implements FunctionalPrimitiveIterator.OfInt
{
private int current = -1;
private int next = set.nextSetBit(0);
@@ -130,7 +130,7 @@ public void remove()
}
/** Implementation of the iterator over the set bits (reverse order) */
- private class SetBitsReversedIterator implements OfInt
+ private class SetBitsReversedIterator implements FunctionalPrimitiveIterator.OfInt
{
private int current = -1;
private int next;
@@ -168,7 +168,7 @@ public void remove()
}
/** Implementation of the iterator over the cleared bits, requires that {@code maxIndex != null} */
- private class ClearBitsIterator implements OfInt
+ private class ClearBitsIterator implements FunctionalPrimitiveIterator.OfInt
{
private int current = -1;
private int next = set.nextClearBit(0);
@@ -206,7 +206,7 @@ public void remove()
}
/** Implementation of the iterator over the clear bits (reverse order), requires that {@code maxIndex != null} */
- private class ClearBitsReversedIterator implements OfInt
+ private class ClearBitsReversedIterator implements FunctionalPrimitiveIterator.OfInt
{
private int current = -1;
private int next;
@@ -244,7 +244,7 @@ public void remove()
}
@Override
- public OfInt iterator()
+ public FunctionalPrimitiveIterator.OfInt iterator()
{
if (clearBits == false) {
if (reversed) {
diff --git a/prism/src/common/IterableStateSet.java b/prism/src/common/IterableStateSet.java
index 86427129c5..d7f14e8317 100644
--- a/prism/src/common/IterableStateSet.java
+++ b/prism/src/common/IterableStateSet.java
@@ -3,7 +3,7 @@
// Copyright (c) 2014-
// Authors:
// * Joachim Klein (TU Dresden)
-// * Steffen Märcker (TU Dresden)
+// * Steffen Märcker (TU Dresden)
//
//------------------------------------------------------------------------------
//
@@ -25,22 +25,23 @@
//
//==============================================================================
-
package common;
import java.util.BitSet;
-import java.util.PrimitiveIterator.OfInt;
-import common.iterable.*;
+import common.iterable.EmptyIterable;
+import common.iterable.FunctionalPrimitiveIterable;
+import common.iterable.FunctionalPrimitiveIterator;
+import common.iterable.Range;
/**
* A convenience wrapper around IterableBitSet that handles the three cases of
* iterating over the set or cleared bits of a BitSet representing a set of states
* as well as iterating over all states if the BitSet is {@code null}.
*/
-public class IterableStateSet implements IterableInt
+public class IterableStateSet implements FunctionalPrimitiveIterable.OfInt
{
- private final IterableInt setOfStates;
+ protected final FunctionalPrimitiveIterable.OfInt setOfStates;
/**
* Constructor (iterate over all states 0..numStates-1)
@@ -91,16 +92,16 @@ public IterableStateSet(BitSet setOfStates, int numStates, boolean complement, b
if (setOfStates == null || (setOfStates.length() == numStates && setOfStates.cardinality() == numStates)) {
// all states
if (complement) {
- this.setOfStates = EmptyIterable.OfInt();
+ this.setOfStates = EmptyIterable.ofInt();
} else {
- this.setOfStates = reversed ? new RangeIntIterable(numStates-1, 0) : new RangeIntIterable(0, numStates-1);
+ this.setOfStates = reversed ? new Range(numStates).reversed() : new Range(numStates);
}
} else if (setOfStates.isEmpty()) {
// no states
if (complement) {
- this.setOfStates = reversed ? new RangeIntIterable(numStates-1, 0) : new RangeIntIterable(0, numStates-1);
+ this.setOfStates = reversed ? new Range(numStates).reversed() : new Range(numStates);
} else {
- this.setOfStates = EmptyIterable.OfInt();
+ this.setOfStates = EmptyIterable.ofInt();
}
} else {
// build appropriate IterableBitSet with maxIndex = numStates-1
@@ -109,7 +110,7 @@ public IterableStateSet(BitSet setOfStates, int numStates, boolean complement, b
}
@Override
- public OfInt iterator()
+ public FunctionalPrimitiveIterator.OfInt iterator()
{
return setOfStates.iterator();
}
diff --git a/prism/src/common/IteratorTools.java b/prism/src/common/IteratorTools.java
index 24a0e79847..ea4b9e4d74 100644
--- a/prism/src/common/IteratorTools.java
+++ b/prism/src/common/IteratorTools.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2016-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -28,148 +28,233 @@
package common;
import java.util.Iterator;
-import java.util.function.DoublePredicate;
-import java.util.function.IntPredicate;
-import java.util.function.LongPredicate;
-import java.util.function.Predicate;
-
-import common.iterable.FilteringIterator;
-import common.iterable.MappingIterator;
-
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
import java.util.PrimitiveIterator.OfDouble;
import java.util.PrimitiveIterator.OfInt;
import java.util.PrimitiveIterator.OfLong;
+import java.util.function.Predicate;
-/** Convenience methods for performing operations on Iterators / Iterables */
+import common.iterable.Reducible;
+
+/**
+ * Convenience methods for performing operations on Iterators / Iterables
+ */
public class IteratorTools
{
- /** Count the number of elements */
- public static int count(final Iterable iterable)
+ /**
+ * Boolean AND-function: Are all elements true?
+ */
+ public static boolean and(Iterator booleans)
{
- return count(iterable.iterator());
+ while (booleans.hasNext()) {
+ if (!booleans.next()) {
+ return false;
+ }
+ }
+ return true;
}
- /** Count the number of elements */
- public static int count(final Iterator iterator)
+ /**
+ * Boolean OR-function: Is at least one elements true?
+ */
+ public static boolean or(Iterator booleans)
{
- if (iterator instanceof OfInt) {
- return count((OfInt) iterator);
- }
- if (iterator instanceof OfLong) {
- return count((OfLong) iterator);
- }
- if (iterator instanceof OfDouble) {
- return count((OfDouble) iterator);
+ while (booleans.hasNext()) {
+ if (booleans.next()) {
+ return true;
+ }
}
+ return false;
+ }
- int count=0;
- for (; iterator.hasNext(); iterator.next()) {
- count++;
- }
- return count;
+ /**
+ * Count the number of elements
+ */
+ public static long count(Iterable iterable)
+ {
+ return Reducible.extend(iterable).count();
}
- /** Count the number of elements */
- public static int count(final OfInt iterator)
+ /**
+ * Count the number of elements
+ */
+ public static long count(Iterator iterator)
{
- // call nextInt to avoid unnecessary boxing
- int count=0;
- for (; iterator.hasNext(); iterator.nextInt()) {
- count++;
- }
- return count;
+ return Reducible.extend(iterator).count();
}
- /** Count the number of elements */
- public static int count(final OfLong iterator)
+ /**
+ * Count the number of elements
+ */
+ public static long count(Iterable iterable, Predicate predicate)
{
- // call nextLong to avoid unnecessary boxing
- int count=0;
- for (; iterator.hasNext(); iterator.nextLong()) {
- count++;
- }
- return count;
+ return Reducible.extend(iterable).count(predicate);
}
- /** Count the number of elements */
- public static int count(final OfDouble iterator)
+ /**
+ * Count the number of elements
+ */
+ public static long count(Iterator iterator, Predicate predicate)
{
- // call nextDouble to avoid unnecessary boxing
- int count=0;
- for (; iterator.hasNext(); iterator.nextDouble()) {
- count++;
- }
- return count;
+ return Reducible.extend(iterator).count(predicate);
}
- /** Count the number of elements matching the predicate */
- public static int count(final Iterable iterable, final Predicate predicate)
+ /**
+ * Maximum over iterator elements
+ */
+ public static OptionalDouble max(OfDouble numbers)
{
- return count(iterable.iterator(), predicate);
+ return Reducible.extend(numbers).max();
}
- /** Count the number of elements matching the predicate */
- public static int count(final Iterator iterator, final Predicate predicate)
+ /**
+ * Maximum over iterator elements
+ */
+ public static OptionalInt max(OfInt numbers)
{
- if (iterator instanceof OfInt && predicate instanceof IntPredicate) {
- return count(new FilteringIterator.OfInt((OfInt) iterator, (IntPredicate) predicate));
- }
- if (iterator instanceof OfLong && predicate instanceof LongPredicate) {
- return count(new FilteringIterator.OfLong((OfLong) iterator, (LongPredicate) predicate));
- }
- if (iterator instanceof OfDouble && predicate instanceof DoublePredicate) {
- return count(new FilteringIterator.OfDouble((OfDouble) iterator, (DoublePredicate) predicate));
- }
+ return Reducible.extend(numbers).max();
+ }
- return count(new FilteringIterator.Of<>(iterator, predicate));
+ /**
+ * Maximum over iterator elements
+ */
+ public static OptionalLong max(OfLong numbers)
+ {
+ return Reducible.extend(numbers).max();
}
- /** Sum over iterator elements */
- public static int sumInt(final Iterator numbers)
+ /**
+ * Maximum over non-null iterator elements
+ */
+ public static OptionalDouble maxDouble(Iterator numbers)
{
- return sum(MappingIterator.toInt(numbers));
+ return Reducible.unboxDouble(Reducible.extend(numbers).nonNull()).max();
}
- /** Sum over iterator elements */
- public static int sum(final OfInt numbers)
+ /**
+ * Maximum over non-null iterator elements
+ */
+ public static OptionalInt maxInt(Iterator numbers)
{
- int sum = 0;
- while (numbers.hasNext()) {
- sum += numbers.nextInt();
- }
- return sum;
+ return Reducible.unboxInt(Reducible.extend(numbers).nonNull()).max();
}
- /** Sum over iterator elements */
- public static long sumLong(final Iterator numbers)
+ /**
+ * Maximum over non-null iterator elements
+ */
+ public static OptionalLong maxLong(Iterator numbers)
{
- return sum(MappingIterator.toLong(numbers));
+ return Reducible.unboxLong(Reducible.extend(numbers).nonNull()).max();
}
- /** Sum over iterator elements */
- public static long sum(final OfLong numbers)
+ /**
+ * Minimum over iterator elements
+ */
+ public static OptionalDouble min(OfDouble numbers)
{
- long sum = 0;
- while (numbers.hasNext()) {
- sum += numbers.nextLong();
- }
- return sum;
+ return Reducible.extend(numbers).min();
}
- /** Sum over iterator elements */
- public static double sumDouble(final Iterator numbers)
+ /**
+ * Minimum over iterator elements
+ */
+ public static OptionalInt min(OfInt numbers)
{
- return sum(MappingIterator.toDouble(numbers));
+ return Reducible.extend(numbers).min();
}
- /** Sum over iterator elements */
- public static double sum(final OfDouble numbers)
+ /**
+ * Minimum over iterator elements
+ */
+ public static OptionalLong min(OfLong numbers)
{
- double sum = 0;
- while (numbers.hasNext()) {
- sum += numbers.nextDouble();
- }
- return sum;
+ return Reducible.extend(numbers).min();
+ }
+
+ /**
+ * Minimum over non-null iterator elements
+ */
+ public static OptionalDouble minDouble(Iterator numbers)
+ {
+ return Reducible.unboxDouble(Reducible.extend(numbers).nonNull()).min();
}
+ /**
+ * Minimum over non-null iterator elements
+ */
+ public static OptionalInt minInt(Iterator numbers)
+ {
+ return Reducible.unboxInt(Reducible.extend(numbers).nonNull()).min();
+ }
+
+ /**
+ * Minimum over non-null iterator elements
+ */
+ public static OptionalLong minLong(Iterator numbers)
+ {
+ return Reducible.unboxLong(Reducible.extend(numbers).nonNull()).min();
+ }
+
+ /**
+ * Sum over iterator elements
+ */
+ public static double sum(OfDouble numbers)
+ {
+ return Reducible.extend(numbers).sum();
+ }
+
+ /**
+ * Sum over iterator elements
+ */
+ public static long sum(OfInt numbers)
+ {
+ return Reducible.extend(numbers).sum();
+ }
+
+ /**
+ * Sum over iterator elements
+ */
+ public static long sum(OfLong numbers)
+ {
+ return Reducible.extend(numbers).sum();
+ }
+
+ /**
+ * Sum over non-null iterator elements
+ */
+ public static double sumDouble(Iterator numbers)
+ {
+ return Reducible.unboxDouble(Reducible.extend(numbers).nonNull()).sum();
+ }
+
+ /**
+ * Sum over non-null iterator elements
+ */
+ public static long sumInt(Iterator numbers)
+ {
+ return Reducible.unboxInt(Reducible.extend(numbers).nonNull()).sum();
+ }
+
+ /**
+ * Sum over non-null iterator elements
+ */
+ public static long sumLong(Iterator numbers)
+ {
+ return Reducible.unboxLong(Reducible.extend(numbers).nonNull()).sum();
+ }
+
+ /**
+ * Create String "name = {e_1, e_2}".
+ *
+ * @param name name of a variable
+ * @param iterator the iterator to be printed
+ */
+ public static void printIterator(String name, Iterator iterator)
+ {
+ System.out.print(name + " = ");
+ System.out.print(Reducible.extend(iterator).asString());
+ System.out.println();
+ }
}
diff --git a/prism/src/common/Makefile b/prism/src/common/Makefile
index 115bf5b4ae..b22ca64d73 100644
--- a/prism/src/common/Makefile
+++ b/prism/src/common/Makefile
@@ -14,7 +14,7 @@ PRISM_DIR_REL = ../..
JNI_GEN_HEADER_DIR=$(THIS_DIR)/$(PRISM_DIR_REL)/$(PRISM_INCLUDE_DIR)/jni
-JAVA_FILES_ALL = $(wildcard *.java iterable/*.java functions/primitive/*.java)
+JAVA_FILES_ALL = $(wildcard *.java iterable/*.java functions/*.java)
JAVA_FILES = $(subst package-info.java,,$(JAVA_FILES_ALL))
CLASS_FILES = $(JAVA_FILES:%.java=$(PRISM_DIR_REL)/$(PRISM_CLASSES_DIR)/$(THIS_DIR)/%.class)
diff --git a/prism/src/common/functions/primitive/PairPredicateInt.java b/prism/src/common/functions/DoubleLongToDoubleFunction.java
similarity index 74%
rename from prism/src/common/functions/primitive/PairPredicateInt.java
rename to prism/src/common/functions/DoubleLongToDoubleFunction.java
index 4c1d8f4ae7..e60702ad91 100644
--- a/prism/src/common/functions/primitive/PairPredicateInt.java
+++ b/prism/src/common/functions/DoubleLongToDoubleFunction.java
@@ -1,9 +1,8 @@
//==============================================================================
//
-// Copyright (c) 2016-
+// Copyright (c) 2020-
// Authors:
-// * Steffen Maercker (TU Dresden)
-// * Joachim Klein (TU Dresden)
+// * Steffen Maercker (TU Dresden)
//
//------------------------------------------------------------------------------
//
@@ -25,11 +24,16 @@
//
//==============================================================================
-package common.functions.primitive;
+package common.functions;
-/** Functional interface for a predicate (int, int) -> boolean */
+/**
+ * Functional interface for a binary function (double, long) -> double.
+ */
@FunctionalInterface
-public interface PairPredicateInt
+public interface DoubleLongToDoubleFunction
{
- public abstract boolean test(int element1, int element2);
+ /**
+ * Applies this function to the given arguments.
+ */
+ double applyAsDouble(double d, long l);
}
diff --git a/prism/src/common/functions/DoubleObjToDoubleFunction.java b/prism/src/common/functions/DoubleObjToDoubleFunction.java
new file mode 100644
index 0000000000..5417cdc7c0
--- /dev/null
+++ b/prism/src/common/functions/DoubleObjToDoubleFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2020-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.DoubleUnaryOperator;
+
+/**
+ * Functional interface for a binary function (double, T) -> double.
+ */
+@FunctionalInterface
+public interface DoubleObjToDoubleFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ double applyAsDouble(double d, T t);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default DoubleObjToDoubleFunction andThen(DoubleUnaryOperator after) {
+ Objects.requireNonNull(after);
+ return (double d, T t) -> after.applyAsDouble(applyAsDouble(d, t));
+ }
+}
diff --git a/prism/src/common/iterable/IterableInt.java b/prism/src/common/functions/IntDoubleToIntFunction.java
similarity index 74%
rename from prism/src/common/iterable/IterableInt.java
rename to prism/src/common/functions/IntDoubleToIntFunction.java
index db8e42531e..3a3f1404c1 100644
--- a/prism/src/common/iterable/IterableInt.java
+++ b/prism/src/common/functions/IntDoubleToIntFunction.java
@@ -1,8 +1,8 @@
//==============================================================================
//
-// Copyright (c) 2016-
+// Copyright (c) 2020-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
//
//------------------------------------------------------------------------------
//
@@ -24,13 +24,16 @@
//
//==============================================================================
-package common.iterable;
+package common.functions;
-import java.util.PrimitiveIterator.OfInt;
-
-/** Iterable for a PrimitiveIterator.OfInt */
-public interface IterableInt extends Iterable
+/**
+ * Functional interface for a binary function (int, double) -> int.
+ */
+@FunctionalInterface
+public interface IntDoubleToIntFunction
{
- @Override
- public OfInt iterator();
+ /**
+ * Applies this function to the given arguments.
+ */
+ int applyAsInt(int i, double d);
}
diff --git a/prism/src/common/iterable/IterableDouble.java b/prism/src/common/functions/IntLongToIntFunction.java
similarity index 74%
rename from prism/src/common/iterable/IterableDouble.java
rename to prism/src/common/functions/IntLongToIntFunction.java
index f2690013e3..fd3bf44389 100644
--- a/prism/src/common/iterable/IterableDouble.java
+++ b/prism/src/common/functions/IntLongToIntFunction.java
@@ -1,8 +1,8 @@
//==============================================================================
//
-// Copyright (c) 2016-
+// Copyright (c) 2020-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
//
//------------------------------------------------------------------------------
//
@@ -24,13 +24,16 @@
//
//==============================================================================
-package common.iterable;
+package common.functions;
-import java.util.PrimitiveIterator.OfDouble;
-
-/** Iterable for a PrimitiveIterator.OfDouble */
-public interface IterableDouble extends Iterable
+/**
+ * Functional interface for a binary function (int, long) -> int.
+ */
+@FunctionalInterface
+public interface IntLongToIntFunction
{
- @Override
- public OfDouble iterator();
+ /**
+ * Applies this function to the given arguments.
+ */
+ int applyAsInt(int i, long l);
}
diff --git a/prism/src/common/functions/IntObjToIntFunction.java b/prism/src/common/functions/IntObjToIntFunction.java
new file mode 100644
index 0000000000..db70e8bae7
--- /dev/null
+++ b/prism/src/common/functions/IntObjToIntFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2020-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.IntUnaryOperator;
+
+/**
+ * Functional interface for a binary function (int, T) -> int.
+ */
+@FunctionalInterface
+public interface IntObjToIntFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ int applyAsInt(int i, T t);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default IntObjToIntFunction andThen(IntUnaryOperator after) {
+ Objects.requireNonNull(after);
+ return (int i, T t) -> after.applyAsInt(applyAsInt(i, t));
+ }
+}
diff --git a/prism/src/common/iterable/IterableLong.java b/prism/src/common/functions/LongDoubleToLongFunction.java
similarity index 74%
rename from prism/src/common/iterable/IterableLong.java
rename to prism/src/common/functions/LongDoubleToLongFunction.java
index c113ef73f1..9196fce233 100644
--- a/prism/src/common/iterable/IterableLong.java
+++ b/prism/src/common/functions/LongDoubleToLongFunction.java
@@ -1,8 +1,8 @@
//==============================================================================
//
-// Copyright (c) 2016-
+// Copyright (c) 2020-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
//
//------------------------------------------------------------------------------
//
@@ -24,13 +24,16 @@
//
//==============================================================================
-package common.iterable;
+package common.functions;
-import java.util.PrimitiveIterator.OfLong;
-
-/** Iterable for a PrimitiveIterator.OfLong */
-public interface IterableLong extends Iterable
+/**
+ * Functional interface for a binary function (int, double) -> int.
+ */
+@FunctionalInterface
+public interface LongDoubleToLongFunction
{
- @Override
- public OfLong iterator();
+ /**
+ * Applies this function to the given arguments.
+ */
+ long applyAsLong(long l, double i);
}
diff --git a/prism/src/common/functions/LongObjToLongFunction.java b/prism/src/common/functions/LongObjToLongFunction.java
new file mode 100644
index 0000000000..3bac121046
--- /dev/null
+++ b/prism/src/common/functions/LongObjToLongFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2020-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.LongUnaryOperator;
+
+/**
+ * Functional interface for a binary function (long, T) -> long.
+ */
+@FunctionalInterface
+public interface LongObjToLongFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ long applyAsLong(long i, T t);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default LongObjToLongFunction andThen(LongUnaryOperator after) {
+ Objects.requireNonNull(after);
+ return (long l, T t) -> after.applyAsLong(applyAsLong(l, t));
+ }
+}
diff --git a/prism/src/common/functions/ObjDoubleFunction.java b/prism/src/common/functions/ObjDoubleFunction.java
new file mode 100644
index 0000000000..6cdd6b307f
--- /dev/null
+++ b/prism/src/common/functions/ObjDoubleFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * Functional interface for a binary function (T, double) -> R.
+ */
+@FunctionalInterface
+public interface ObjDoubleFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ R apply(T t, double d);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default ObjDoubleFunction andThen(Function after) {
+ Objects.requireNonNull(after);
+ return (T t, double d) -> after.apply(apply(t, d));
+ }
+}
diff --git a/prism/src/common/functions/ObjIntFunction.java b/prism/src/common/functions/ObjIntFunction.java
new file mode 100644
index 0000000000..33cf0fa85f
--- /dev/null
+++ b/prism/src/common/functions/ObjIntFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * Functional interface for a binary function (T, int) -> R.
+ */
+@FunctionalInterface
+public interface ObjIntFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ R apply(T t, int i);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default ObjIntFunction andThen(Function after) {
+ Objects.requireNonNull(after);
+ return (T t, int i) -> after.apply(apply(t, i));
+ }
+}
diff --git a/prism/src/common/functions/ObjLongFunction.java b/prism/src/common/functions/ObjLongFunction.java
new file mode 100644
index 0000000000..b774fbce51
--- /dev/null
+++ b/prism/src/common/functions/ObjLongFunction.java
@@ -0,0 +1,51 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * Functional interface for a binary function (T, long) -> R.
+ */
+@FunctionalInterface
+public interface ObjLongFunction
+{
+ /**
+ * Applies this function to the given arguments.
+ */
+ R apply(T t, long l);
+
+ /**
+ * Returns a composed function that first applies this function to
+ * its input, and then applies the {@code after} function to the result.
+ */
+ default ObjLongFunction andThen(Function after) {
+ Objects.requireNonNull(after);
+ return (T t, long l) -> after.apply(apply(t, l));
+ }
+}
diff --git a/prism/src/common/functions/PairPredicateInt.java b/prism/src/common/functions/PairPredicateInt.java
new file mode 100644
index 0000000000..d1b4cb242f
--- /dev/null
+++ b/prism/src/common/functions/PairPredicateInt.java
@@ -0,0 +1,48 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+// * Joachim Klein (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.functions;
+
+/**
+ * Functional interface for a predicate (int, int) -> boolean.
+ */
+@FunctionalInterface
+public interface PairPredicateInt
+{
+ /**
+ * Evaluates this predicate on the given arguments.
+ */
+ boolean test(int i, int j);
+
+ /**
+ * Returns a predicate that represents the logical negation of this predicate.
+ */
+ default PairPredicateInt negate()
+ {
+ return (i, j) -> !test(i, j);
+ }
+}
diff --git a/prism/src/common/iterable/ArrayIterator.java b/prism/src/common/iterable/ArrayIterator.java
new file mode 100644
index 0000000000..5182034c45
--- /dev/null
+++ b/prism/src/common/iterable/ArrayIterator.java
@@ -0,0 +1,280 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+// * Marcus Daum (Frauenhofer Institut)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.iterable;
+
+import java.util.Objects;
+
+/**
+ * Abstract base class of efficient Iterators over array slices.
+ * Implementations should release the underlying array after iteration.
+ *
+ * @param type of the array elements
+ */
+public abstract class ArrayIterator implements FunctionalIterator
+{
+ protected final int toIndex;
+ protected int nextIndex;
+
+ /**
+ * Iterate over all elements in index interval [fromIndex, toIndex).
+ *
+ * @param fromIndex first index, inclusive
+ * @param toIndex last index, exclusive
+ * @param length length of the array
+ */
+ protected ArrayIterator(int fromIndex, int toIndex, int length)
+ {
+ Objects.checkFromToIndex(fromIndex, toIndex, length);
+ this.nextIndex = fromIndex;
+ this.toIndex = toIndex;
+ }
+
+ @Override
+ public boolean hasNext()
+ {
+ if (nextIndex < toIndex) {
+ return true;
+ }
+ release();
+ return false;
+ }
+
+ @Override
+ public long count()
+ {
+ return Math.max(0, toIndex - nextIndex);
+ }
+
+ /**
+ * Get the index of the next element.
+ */
+ public int nextIndex()
+ {
+ requireNext();
+ return nextIndex;
+ }
+
+ /**
+ * Release reference to the underlying array.
+ */
+ @Override
+ public void release()
+ {
+ nextIndex = toIndex;
+ }
+
+ /**
+ * Generic implementation of an Iterator over an array slice.
+ *
+ * @param type of the array elements
+ */
+ public static class Of extends ArrayIterator
+ {
+ /** Placeholder array after Iterator is exhausted */
+ public static final Object[] EMPTY_OBJECT = new Object[0];
+
+ protected E[] elements;
+
+ /**
+ * Iterate over all elements.
+ */
+ @SafeVarargs
+ public Of(E... elements)
+ {
+ this(elements, 0, elements.length);
+ }
+
+ /**
+ * Iterate over all elements in index interval [fromIndex, toIndex).
+ *
+ * @param fromIndex first index, inclusive
+ * @param toIndex last index, exclusive
+ */
+ public Of(E[] elements, int fromIndex, int toIndex)
+ {
+ super(fromIndex, toIndex, elements.length);
+ this.elements = elements;
+ }
+
+ @Override
+ public E next()
+ {
+ requireNext();
+ return elements[nextIndex++];
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public void release()
+ {
+ super.release();
+ elements = (E[]) EMPTY_OBJECT;
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code double} of an Iterator over an array slice.
+ */
+ public static class OfDouble extends ArrayIterator implements FunctionalPrimitiveIterator.OfDouble
+ {
+ /** Placeholder array after Iterator is exhausted */
+ public static final double[] EMPTY_DOUBLE = new double[0];
+
+ protected double[] elements;
+
+ /**
+ * Iterate over all elements.
+ */
+ public OfDouble(double... elements)
+ {
+ this(elements, 0, elements.length);
+ }
+
+ /**
+ * Iterate over all elements in index interval [fromIndex, toIndex).
+ *
+ * @param fromIndex first index, inclusive
+ * @param toIndex last index, exclusive
+ */
+ public OfDouble(double[] elements, int fromIndex, int toIndex)
+ {
+ super(fromIndex, toIndex, elements.length);
+ this.elements = elements;
+ }
+
+ @Override
+ public double nextDouble()
+ {
+ requireNext();
+ return elements[nextIndex++];
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ elements = EMPTY_DOUBLE;
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code int} of an Iterator over an array slice.
+ */
+ public static class OfInt extends ArrayIterator implements FunctionalPrimitiveIterator.OfInt
+ {
+ /** Placeholder array after Iterator is exhausted */
+ public static final int[] EMPTY_INT = new int[0];
+
+ protected int[] elements;
+
+ /**
+ * Iterate over all elements.
+ */
+ public OfInt(int... elements)
+ {
+ this(elements, 0, elements.length);
+ }
+
+ /**
+ * Iterate over all elements in index interval [fromIndex, toIndex).
+ *
+ * @param fromIndex first index, inclusive
+ * @param toIndex last index, exclusive
+ */
+ public OfInt(int[] elements, int fromIndex, int toIndex)
+ {
+ super(fromIndex, toIndex, elements.length);
+ this.elements = elements;
+ }
+
+ @Override
+ public int nextInt()
+ {
+ requireNext();
+ return elements[nextIndex++];
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ elements = EMPTY_INT;
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code long} of an Iterator over an array slice.
+ */
+ public static class OfLong extends ArrayIterator implements FunctionalPrimitiveIterator.OfLong
+ {
+ /** Placeholder array after Iterator is exhausted */
+ public static final long[] EMPTY_LONG = new long[0];
+
+ protected long[] elements;
+
+ /**
+ * Iterate over all elements.
+ */
+ public OfLong(long... elements)
+ {
+ this(elements, 0, elements.length);
+ }
+
+ /**
+ * Iterate over all elements in index interval [fromIndex, toIndex).
+ *
+ * @param fromIndex first index, inclusive
+ * @param toIndex last index, exclusive
+ */
+ public OfLong(long[] elements, int fromIndex, int toIndex)
+ {
+ super(fromIndex, toIndex, elements.length);
+ this.elements = elements;
+ }
+
+ @Override
+ public long nextLong()
+ {
+ requireNext();
+ return elements[nextIndex++];
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ elements = EMPTY_LONG;
+ }
+ }
+}
diff --git a/prism/src/common/iterable/CartesianProduct.java b/prism/src/common/iterable/CartesianProduct.java
new file mode 100644
index 0000000000..7c573ab814
--- /dev/null
+++ b/prism/src/common/iterable/CartesianProduct.java
@@ -0,0 +1,212 @@
+//==============================================================================
+//
+// Copyright (c) 2018-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.iterable;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.function.Function;
+
+import common.IteratorTools;
+
+/**
+ * This class provides static methods to construct
+ * the Cartesian product of a set of iterables.
+ * The implementation computes the tuples on the fly for space efficiency.
+ * It relies on an efficient implementation of {@code flatMap}.
+ *
+ * Since Stream::flatMap preallocates memory for the complete stream,
+ * we have to use the alternative implementation from FunctionalIterable.
+ *
+ */
+public class CartesianProduct
+{
+ /**
+ * Variant of the Cartesian product with {@code Object} as common super-type of the tuple/iterable elements.
+ * Elements of the product are distinct and safe to store/use elsewhere.
+ *
+ * @param iterables iterables to build Cartesian product from
+ * @see #of(Iterable)
+ */
+ public static FunctionalIterable of(Iterable ... iterables)
+ {
+ return of(new IterableArray.Of<>(iterables));
+ }
+
+ /**
+ * Typesafe generic variant of the Cartesian product.
+ * Elements of the product are distinct and safe to store/use elsewhere.
+ *
+ * @param type common super-type of the tuple/iterable elements
+ * @param iterables iterables to build Cartesian product from
+ * @see #of(Iterable)
+ */
+ @SafeVarargs
+ public static FunctionalIterable of(Class type, Iterable ... iterables)
+ {
+ return of(type, new IterableArray.Of<>(iterables));
+ }
+
+ /**
+ * Variant of the Cartesian product with {@code Object} as common super-type of the tuple/iterable elements.
+ * Elements of the product are distinct and safe to store/use elsewhere.
+ *
+ * @param iterables iterables to build Cartesian product from
+ * @see #of(Iterable)
+ */
+ public static FunctionalIterable of(Iterable> iterables)
+ {
+ return mutableOf(iterables).map(t -> Arrays.copyOf(t, t.length));
+ }
+
+ /**
+ * Typesafe generic variant of the Cartesian product.
+ * Elements of the product are distinct and safe to store/use elsewhere.
+ *
+ * @param type common super-type of the tuple/iterable elements
+ * @param iterables iterables to build Cartesian product from
+ * @see #of(Iterable)
+ */
+ public static FunctionalIterable of(Class type, Iterable> iterables)
+ {
+ return mutableOf(type, iterables).map(t -> Arrays.copyOf(t, t.length));
+ }
+
+ /**
+ * Variant of the Cartesian product with {@code Object} as common super-type of the tuple/iterable elements.
+ * Elements of the product must be copied if stored/used elsewhere.
+ *
+ * @param type common super-type of the tuple/iterable elements
+ * @param iterables iterables to build Cartesian product from
+ * @see #of(Iterable)
+ */
+ public static FunctionalIterable mutableOf(Iterable ... iterables)
+ {
+ return of(new IterableArray.Of<>(iterables));
+ }
+
+ /**
+ * Typesafe generic variant of the Cartesian product.
+ * Elements of the product must be copied if stored/used elsewhere.
+ *
+ * @param type common super-type of the tuple/iterable elements
+ * @param iterables iterables to build Cartesian product from
+ * @see #mutableOf(Iterator, Object[], int)
+ */
+ @SafeVarargs
+ public static FunctionalIterable mutableOf(Class type, Iterable ... iterables)
+ {
+ return mutableOf(type, new IterableArray.Of<>(iterables));
+ }
+
+ /**
+ * Variant of the Cartesian product with {@code Object} as common super-type of the tuple/iterable elements.
+ * Elements of the product must be copied if stored/used elsewhere.
+ *
+ * @param iterables iterables to build Cartesian product from
+ * @see #mutableOf(Iterator, Object[], int);
+ */
+ public static FunctionalIterable mutableOf(Iterable> iterables)
+ {
+ return mutableOf(Object.class, iterables);
+ }
+
+ /**
+ * Typesafe generic variant of the Cartesian product.
+ * Elements of the product must be copied if stored/used elsewhere.
+ *
+ * @param type common super-type of the tuple/iterable elements
+ * @param iterables iterables to build Cartesian product from
+ * @see #mutableOf(Iterator, Object[], int);
+ */
+ public static FunctionalIterable mutableOf(Class type, Iterable> iterables)
+ {
+ int arity = Math.toIntExact(Reducible.extend(iterables).count());
+ @SuppressWarnings("unchecked")
+ E[] tuple = (E[]) Array.newInstance(type, arity);
+ return mutableOf(iterables.iterator(), tuple, 0);
+ }
+
+ /**
+ * Build Cartesian product recursively over the provided iterables.
+ * For efficiency, the same tuple instance is reused for the elements of the result.
+ * Hence, an element has to be copied if it is stored/used elsewhere.
+ *
+ * @param iterables iterables to build Cartesian product from
+ * @param tuple the tuple instance to be used
+ * @param pos the current tuple position
+ * @return iterable of Cartesian product
+ */
+ protected static FunctionalIterable mutableOf(Iterator> iterables, T[] tuple, int pos)
+ {
+ // no iterable -> empty product
+ if (!iterables.hasNext()) {
+ return EmptyIterable.of();
+ }
+ assert pos < tuple.length : "Require slot in tuple for next element.";
+ FunctionalIterable elements = Reducible.extend(iterables.next());
+ // one iterable -> map elements to tuples
+ if (!iterables.hasNext()) {
+ return elements.map(e -> {tuple[pos] = e; return tuple;});
+ }
+ // more than one iterable: recurse
+ FunctionalIterable tuples = mutableOf(iterables, tuple, pos + 1);
+ // elements x tuples
+ return elements.flatMap(e -> {tuple[pos] = e; return tuples;});
+ }
+
+ /**
+ * Test method.
+ *
+ * @param args command-line arguments (ignored)
+ */
+ public static void main(final String[] args)
+ {
+ // declare type of function explicitly to circumvent class format error due to faulty type inference
+ Function toString = Arrays::toString;
+
+ FunctionalIterable product = of();
+ IteratorTools.printIterator("empty product ", product.iterator());
+ System.out.println();
+
+ product = of(Arrays.asList(1, 2, 3));
+ IteratorTools.printIterator("single product ", product.map(toString).iterator());
+ System.out.println();
+
+ product = of(Arrays.asList(1, 2, 3), Arrays.asList('a', 'b'));
+ IteratorTools.printIterator("binary product ", product.map(toString).iterator());
+ System.out.println();
+
+ product = of(Arrays.asList(1, 2, 3), Arrays.asList('a', 'b'), Arrays.asList(0.5));
+ IteratorTools.printIterator("ternary product", product.map(toString).iterator());
+ System.out.println();
+
+ product = mutableOf(Arrays.asList(1, 2, 3), Arrays.asList('a', 'b'), Arrays.asList(0.5));
+ IteratorTools.printIterator("ternary product", product.map(toString).iterator());
+ System.out.println();
+ }
+}
diff --git a/prism/src/common/iterable/ChainedIterable.java b/prism/src/common/iterable/ChainedIterable.java
new file mode 100644
index 0000000000..28b6868dbd
--- /dev/null
+++ b/prism/src/common/iterable/ChainedIterable.java
@@ -0,0 +1,151 @@
+//==============================================================================
+//
+// Copyright (c) 2016-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.iterable;
+
+import java.util.Objects;
+
+/**
+ * Abstract base class for Iterables that chain a sequence of Iterables.
+ *
+ * @param type of the Iterator's elements
+ * @param type of the underlying Iterables
+ */
+public abstract class ChainedIterable> implements FunctionalIterable
+{
+ /** The Iterable over the sequence of Iterables that are chained */
+ protected final FunctionalIterable iterables;
+
+ /**
+ * Constructor for an Iterable that chains Iterables provided in an Iterable.
+ *
+ * @param iterables an Iterable of Iterables to be chained
+ */
+ public ChainedIterable(Iterable iterables)
+ {
+ Objects.requireNonNull(iterables);
+ this.iterables = Reducible.extend(iterables);
+ }
+
+
+
+ /**
+ * Generic implementation of a chained Iterable.
+ *
+ * @param type of the Iterable's elements
+ */
+ public static class Of extends ChainedIterable>
+ {
+ /**
+ * Constructor for an Iterable that chains Iterables provided in an Iterable.
+ *
+ * @param iterables an Iterable of Iterables to be chained
+ */
+ @SuppressWarnings("unchecked")
+ public Of(Iterable> iterables)
+ {
+ super((Iterable>) iterables);
+ }
+
+ @Override
+ public FunctionalIterator iterator()
+ {
+ return new ChainedIterator.Of<>(iterables.map(Iterable::iterator).iterator());
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code double} of a chained Iterable.
+ */
+ public static class OfDouble extends ChainedIterable implements FunctionalPrimitiveIterable.OfDouble
+ {
+ /**
+ * Constructor for an Iterable that chains Iterables provided in an Iterable.
+ *
+ * @param iterables an Iterable of Iterables to be chained
+ */
+ public OfDouble(Iterable iterables)
+ {
+ super(iterables);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterator.OfDouble iterator()
+ {
+ return new ChainedIterator.OfDouble(iterables.map(PrimitiveIterable.OfDouble::iterator).iterator());
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code int} of a chained Iterable.
+ */
+ public static class OfInt extends ChainedIterable implements FunctionalPrimitiveIterable.OfInt
+ {
+ /**
+ * Constructor for an Iterable that chains Iterables provided in an Iterable.
+ *
+ * @param iterables an Iterable of Iterables to be chained
+ */
+ public OfInt(Iterable iterables)
+ {
+ super(iterables);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterator.OfInt iterator()
+ {
+ return new ChainedIterator.OfInt(iterables.map(PrimitiveIterable.OfInt::iterator).iterator());
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code long} of a chained Iterable.
+ */
+ public static class OfLong extends ChainedIterable implements FunctionalPrimitiveIterable.OfLong
+ {
+ /**
+ * Constructor for an Iterable that chains Iterables provided in an Iterable.
+ *
+ * @param iterables an Iterable of Iterables to be chained
+ */
+ public OfLong(Iterable iterables)
+ {
+ super(iterables);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterator.OfLong iterator()
+ {
+ return new ChainedIterator.OfLong(iterables.map(PrimitiveIterable.OfLong::iterator).iterator());
+ }
+ }
+}
\ No newline at end of file
diff --git a/prism/src/common/iterable/ChainedIterator.java b/prism/src/common/iterable/ChainedIterator.java
new file mode 100644
index 0000000000..ddc009a060
--- /dev/null
+++ b/prism/src/common/iterable/ChainedIterator.java
@@ -0,0 +1,426 @@
+//==============================================================================
+//
+// Copyright (c) 2015-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+// * Joachim Klein (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.iterable;
+
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+
+/**
+ * Abstract base class implementing an Iterator that chains a sequence of Iterators.
+ * Returns all the elements of the first Iterator, then the elements of the
+ * second Iterator and so on.
+ *
+ * The calls to {@code next()} of the underlying Iterator happen on-the-fly,
+ * i.e., only when {@code next()} is called for this Iterator.
+ *
+ * Implementations should release the underlying Iterators after iteration.
+ *
+ * This Iterator does not support the {@code remove()} method, even if the underlying
+ * Iterators support it.
+ *
+ * @param type of the {@link Iterator}'s elements
+ * @param common super type of {@link FunctionalIterator} for all Iterators in the chain
+ */
+public abstract class ChainedIterator> implements FunctionalIterator
+{
+ /** The Iterator over the sequence of Iterators that are chained */
+ protected FunctionalIterator iterators;
+ /** The current Iterator in the sequence of Iterators */
+ protected I current;
+
+ /**
+ * Constructor for an Iterator that chains Iterators provided in an Iterator.
+ *
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public ChainedIterator(Iterator>iterators)
+ {
+ this(EmptyIterator.of(), iterators);
+ }
+
+ /**
+ * Constructor for chaining an Iterator and a number of Iterators provided in an Iterator.
+ *
+ * @param iterator an Iterator to prepend the chain
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ @SuppressWarnings({ "unchecked"})
+ public ChainedIterator(Iterator iterator, Iterator> iterators)
+ {
+ Objects.requireNonNull(iterator);
+ Objects.requireNonNull(iterators);
+ this.current = (I) Reducible.extend(iterator);
+ this.iterators = (FunctionalIterator) Reducible.extend(iterators).map(Reducible::extend);
+ hasNext();
+ }
+
+ @Override
+ public boolean hasNext()
+ {
+ if (current.hasNext()) {
+ // the current iterator has another element
+ return true;
+ }
+
+ // the current iterator has no more elements,
+ // search for the next iterator that as an element
+ while (iterators.hasNext()) {
+ // consider the next iterator
+ current = iterators.next();
+ if (current.hasNext()) {
+ // iterator has element, keep current and return true
+ return true;
+ }
+ }
+ // there are no more iterators / elements
+ release();
+ return false;
+ }
+
+ @Override
+ public long count()
+ {
+ long count = current.count() + iterators.mapToLong(FunctionalIterator::count).sum();
+ release();
+ return count;
+ }
+
+ @Override
+ public void release()
+ {
+ iterators = EmptyIterator.of();
+ }
+
+
+
+ /**
+ * Generic implementation of a chained Iterator.
+ *
+ * @param type of the Iterator's elements
+ */
+ public static class Of extends ChainedIterator>
+ {
+ /**
+ * Constructor for an Iterator that chains Iterators provided in an Iterator.
+ *
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ @SuppressWarnings("unchecked")
+ public Of(Iterator> iterators)
+ {
+ super((Iterator>) iterators);
+ }
+
+ /**
+ * Constructor for chaining an Iterator and a number of Iterators provided in an Iterator.
+ *
+ * @param iterator an Iterator to prepend the chain
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ @SuppressWarnings("unchecked")
+ public Of(Iterator iterator, Iterator> iterators)
+ {
+ super((Iterator) iterator, (Iterator>) iterators);
+ }
+
+ @Override
+ public E next()
+ {
+ requireNext();
+ return current.next();
+ }
+
+ @Override
+ public boolean contains(Object obj)
+ {
+ boolean contains = current.contains(obj) || iterators.anyMatch(it -> it.contains(obj));
+ release();
+ return contains;
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ current = EmptyIterator.of();
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code double} of a chained Iterator.
+ */
+ public static class OfDouble extends ChainedIterator implements FunctionalPrimitiveIterator.OfDouble
+ {
+ /**
+ * Constructor for an Iterator that chains Iterators provided in an Iterator.
+ *
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfDouble(Iterator iterators)
+ {
+ super(iterators);
+ }
+
+ /**
+ * Constructor for chaining an Iterator and a number of Iterators provided in an Iterator.
+ *
+ * @param iterator an Iterator to prepend the chain
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfDouble(PrimitiveIterator.OfDouble iterator, Iterator iterators)
+ {
+ super(iterator, iterators);
+ }
+
+ @Override
+ public double nextDouble()
+ {
+ requireNext();
+ return current.nextDouble();
+ }
+
+ @Override
+ public boolean contains(double d)
+ {
+ boolean result = current.contains(d) || iterators.anyMatch(it -> it.contains(d));
+ release();
+ return result;
+ }
+
+ @Override
+ public OptionalDouble max()
+ {
+ if (!hasNext()) {
+ return OptionalDouble.empty();
+ }
+ double max = current.max().getAsDouble();
+ max = iterators.reduce(max, (m, it) -> Math.max(m, it.max().orElse(m)));
+ release();
+ return OptionalDouble.of(max);
+ }
+
+ @Override
+ public OptionalDouble min()
+ {
+ if (!hasNext()) {
+ return OptionalDouble.empty();
+ }
+ double min = current.min().getAsDouble();
+ min = iterators.reduce(min, (m, it) -> Math.min(m, it.min().orElse(m)));
+ release();
+ return OptionalDouble.of(min);
+ }
+
+ @Override
+ public double sum()
+ {
+ double sum = iterators.reduce(current.sum(), (s, it) -> s + it.sum());
+ release();
+ return sum;
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ current = EmptyIterator.ofDouble();
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code int} of a chained Iterator.
+ */
+ public static class OfInt extends ChainedIterator implements FunctionalPrimitiveIterator.OfInt
+ {
+ /**
+ * Constructor for an Iterator that chains Iterators provided in an Iterator.
+ *
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfInt(Iterator iterators)
+ {
+ super(iterators);
+ }
+
+ /**
+ * Constructor for chaining an Iterator and a number of Iterators provided in an Iterator.
+ *
+ * @param iterator an Iterator to prepend the chain
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfInt(PrimitiveIterator.OfInt iterator, Iterator iterators)
+ {
+ super(iterator, iterators);
+ }
+
+ @Override
+ public int nextInt()
+ {
+ requireNext();
+ return current.nextInt();
+ }
+
+ @Override
+ public boolean contains(int i)
+ {
+ boolean result = current.contains(i) || iterators.anyMatch(it -> it.contains(i));
+ release();
+ return result;
+ }
+
+ @Override
+ public OptionalInt max()
+ {
+ if (!hasNext()) {
+ return OptionalInt.empty();
+ }
+ int max = current.max().getAsInt();
+ max = iterators.reduce(max, (int m, FunctionalPrimitiveIterator.OfInt it) -> Math.max(m, it.max().orElse(m)));
+ release();
+ return OptionalInt.of(max);
+ }
+
+ @Override
+ public OptionalInt min()
+ {
+ if (!hasNext()) {
+ return OptionalInt.empty();
+ }
+ int min = current.min().getAsInt();
+ min = iterators.reduce(min, (int m, FunctionalPrimitiveIterator.OfInt it) -> Math.min(m, it.min().orElse(m)));
+ release();
+ return OptionalInt.of(min);
+ }
+
+ @Override
+ public long sum()
+ {
+ long sum = iterators.reduce(current.sum(), (long s, FunctionalPrimitiveIterator.OfInt it) -> s + it.sum());
+ release();
+ return sum;
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ current = EmptyIterator.ofInt();
+ }
+ }
+
+
+
+ /**
+ * Primitive specialisation for {@code long} of a chained iterator.
+ */
+ public static class OfLong extends ChainedIterator implements FunctionalPrimitiveIterator.OfLong
+ {
+ /**
+ * Constructor for an Iterator that chains Iterators provided in an Iterator.
+ *
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfLong(Iterator iterators)
+ {
+ super(iterators);
+ }
+
+ /**
+ * Constructor for chaining an Iterator and a number of Iterators provided in an Iterator.
+ *
+ * @param iterator an Iterator to prepend the chain
+ * @param iterators an Iterator over Iterators to be chained
+ */
+ public OfLong(PrimitiveIterator.OfLong iterator, Iterator iterators)
+ {
+ super(iterator, iterators);
+ }
+
+ @Override
+ public long nextLong()
+ {
+ requireNext();
+ return current.nextLong();
+ }
+
+ @Override
+ public boolean contains(long l)
+ {
+ boolean result = current.contains(l) || iterators.anyMatch(it -> it.contains(l));
+ release();
+ return result;
+ }
+
+ @Override
+ public OptionalLong max()
+ {
+ if (!hasNext()) {
+ return OptionalLong.empty();
+ }
+ long max = current.max().getAsLong();
+ max = iterators.reduce(max, (long m, FunctionalPrimitiveIterator.OfLong it) -> Math.max(m, it.max().orElse(m)));
+ release();
+ return OptionalLong.of(max);
+ }
+
+ @Override
+ public OptionalLong min()
+ {
+ if (!hasNext()) {
+ return OptionalLong.empty();
+ }
+ long min = current.min().getAsLong();
+ min = iterators.reduce(min, (long m, FunctionalPrimitiveIterator.OfLong it) -> Math.min(m, it.min().orElse(m)));
+ release();
+ return OptionalLong.of(min);
+ }
+
+ @Override
+ public long sum()
+ {
+ long sum = iterators.reduce(current.sum(), (long s, FunctionalPrimitiveIterator.OfLong it) -> s + it.sum());
+ release();
+ return sum;
+ }
+
+ @Override
+ public void release()
+ {
+ super.release();
+ current = EmptyIterator.ofLong();
+ }
+ }
+}
diff --git a/prism/src/common/iterable/Distinct.java b/prism/src/common/iterable/Distinct.java
new file mode 100644
index 0000000000..7ca672f3ea
--- /dev/null
+++ b/prism/src/common/iterable/Distinct.java
@@ -0,0 +1,164 @@
+//==============================================================================
+//
+// Copyright (c) 2020-
+// Authors:
+// * Steffen Maercker (TU Dresden)
+//
+//------------------------------------------------------------------------------
+//
+// This file is part of PRISM.
+//
+// PRISM is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// PRISM is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with PRISM; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+//==============================================================================
+
+package common.iterable;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.DoublePredicate;
+import java.util.function.IntPredicate;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+
+/**
+ * Mutable predicate that tells whether it encounters an element the first time or not.
+ *
+ * @param the type of the objects this predicate tests
+ */
+public abstract class Distinct
+{
+ protected final Set seen = new HashSet<>();
+
+ /**
+ * Answer whether the element has not been seen yet.
+ *
+ * @param element the element to be tested
+ * @return true iff the element has not been seen yet
+ */
+ protected boolean isUnseen(E element)
+ {
+ return seen.add(element);
+ }
+
+ /**
+ * Answer the elements that have already been seen.
+ */
+ public abstract FunctionalIterable getSeen();
+
+
+
+ /**
+ * Mutable predicate for {@code Object} that tells whether it encounters an element the first time or not.
+ * Elements are identified in terms of {@link Object#equals(Object)} which requires to be accompanied by a matching {@link Object#hashCode()} implementation.
+ * This implementation uses a {@code HashSet} to store the elements it has already seen.
+ *
+ * @param the type of the objects this predicate tests
+ */
+ public static class Of extends Distinct implements Predicate
+ {
+ @Override
+ public boolean test(E element)
+ {
+ return super.isUnseen(element);
+ }
+
+ @Override
+ public FunctionalIterable getSeen()
+ {
+ return Reducible.extend(seen);
+ }
+
+ }
+
+
+
+ /**
+ * Mutable predicate for {@code double} that tells whether it encounters an element the first time or not.
+ * Elements are identified in terms of {@link ==} except for {@code NaN} for which all instances are consider equal, although {@code Double.NaN != Double.NaN}.
+ * This implementation uses a {@code HashSet} to store the elements it has already seen.
+ */
+ public static class OfDouble extends Distinct implements DoublePredicate
+ {
+ boolean zeroSeen = false;
+
+ @Override
+ public boolean test(double value)
+ {
+ if (value == 0.0) {
+ // Circumvent HashSet considering +0.0 != -0.0
+ if (zeroSeen) {
+ return false;
+ } else {
+ zeroSeen = true;
+ seen.add(value);
+ return true;
+ }
+ }
+ // HashSet considers two Double.NaN instances to be equal
+ return super.isUnseen(value);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterable.OfDouble getSeen()
+ {
+ return Reducible.unboxDouble(seen);
+ }
+ }
+
+
+
+ /**
+ * Mutable predicate for {@code int} that tells whether it encounters an element the first time or not.
+ * Elements are identified in terms of {@link ==}.
+ * This implementation uses a {@code HashSet} to store the elements it has already seen.
+ */
+ public static class OfInt extends Distinct implements IntPredicate
+ {
+ @Override
+ public boolean test(int value)
+ {
+ return super.isUnseen(value);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterable.OfInt getSeen()
+ {
+ return Reducible.unboxInt(seen);
+ }
+ }
+
+
+
+ /**
+ * Mutable predicate for {@code long} that tells whether it encounters an element the first time or not.
+ * Elements are identified in terms of {@link ==}.
+ * This implementation uses a {@code HashSet} to store the elements it has already seen.
+ */
+ public static class OfLong extends Distinct implements LongPredicate
+ {
+ @Override
+ public boolean test(long value)
+ {
+ return super.isUnseen(value);
+ }
+
+ @Override
+ public FunctionalPrimitiveIterable.OfLong getSeen()
+ {
+ return Reducible.unboxLong(seen);
+ }
+ }
+}
diff --git a/prism/src/common/iterable/EmptyIterable.java b/prism/src/common/iterable/EmptyIterable.java
index 31b66316e7..5cef8008bc 100644
--- a/prism/src/common/iterable/EmptyIterable.java
+++ b/prism/src/common/iterable/EmptyIterable.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2016-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -25,75 +25,139 @@
//
//==============================================================================
-
package common.iterable;
-import java.util.Iterator;
-
/**
- * Base class for Iterables returning empty iterators,
- * static helpers for common primitive iterators.
+ * Abstract base class for empty Iterables.
+ * The four natural implementations (generic, double, int, and long)
+ * are implemented as Singletons and their instances accessible by a static method.
+ *
+ * @param type of the Iterable's elements
*/
-public abstract class EmptyIterable implements Iterable
+public abstract class EmptyIterable implements FunctionalIterable
{
- private static final Of OF = new Of<>();
- private static final OfInt OF_INT = new OfInt();
- private static final OfDouble OF_DOUBLE = new OfDouble();
-
+ /**
+ * Get unique instance for elements of a generic type.
+ *
+ * @param type of the Iterable's elements
+ */
@SuppressWarnings("unchecked")
- public static Of Of() {
- return (Of) OF;
+ public static Of of()
+ {
+ return (Of) Of.OF;
}
- public static OfInt OfInt() {
- return OF_INT;
+ /**
+ * Get unique instance for {@code double} elements.
+ */
+ public static OfDouble ofDouble()
+ {
+ return OfDouble.OF_DOUBLE;
}
- public static OfDouble OfDouble() {
- return OF_DOUBLE;
+ /**
+ * Get unique instance for {@code int} elements.
+ */
+ public static OfInt ofInt()
+ {
+ return OfInt.OF_INT;
}
- public static class Of extends EmptyIterable
+ /**
+ * Get unique instance for {@code long} elements.
+ */
+ public static OfLong ofLong()
{
- private Of() {};
+ return OfLong.OF_LONG;
+ }
+
+
+
+ /**
+ * Generic implementation of an empty Iterable as Singleton.
+ *
+ * @param type of the Iterable's elements
+ */
+ public static class Of extends EmptyIterable
+ {
+ /** Singleton instance elements of a generic type */
+ private static final Of OF = new Of<>();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private Of() {}
@Override
- public Iterator iterator()
+ public EmptyIterator.Of iterator()
{
- return EmptyIterator.Of();
+ return EmptyIterator.of();
}
}
- public static class OfInt extends EmptyIterable implements IterableInt
+
+
+ /**
+ * Primitive specialisation for {@code double} of an empty Iterable as Singleton.
+ */
+ public static class OfDouble extends EmptyIterable implements FunctionalPrimitiveIterable.OfDouble
{
- private OfInt() {};
+ /** Singleton instance for {@code double} elements */
+ private static final EmptyIterable.OfDouble OF_DOUBLE = new EmptyIterable.OfDouble();
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfDouble() {}
+
@Override
- public EmptyIterator.OfInt iterator()
+ public EmptyIterator.OfDouble iterator()
{
- return EmptyIterator.OfInt();
+ return EmptyIterator.ofDouble();
}
}
- public static class OfLong extends EmptyIterable implements IterableLong
+
+
+ /**
+ * Primitive specialisation for {@code int} of an empty Iterable as Singleton.
+ */
+ public static class OfInt extends EmptyIterable implements FunctionalPrimitiveIterable.OfInt
{
- private OfLong() {};
+ /** Singleton instance for {@code int} elements */
+ private static final EmptyIterable.OfInt OF_INT = new EmptyIterable.OfInt();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfInt() {}
@Override
- public EmptyIterator.OfLong iterator()
+ public EmptyIterator.OfInt iterator()
{
- return EmptyIterator.OfLong();
+ return EmptyIterator.ofInt();
}
}
- public static class OfDouble extends EmptyIterable implements IterableDouble
+
+
+ /**
+ * Primitive specialisation for {@code long} of an empty Iterable as Singleton.
+ */
+ public static class OfLong extends EmptyIterable implements FunctionalPrimitiveIterable.OfLong
{
- private OfDouble() {};
+ /** Singleton instance for {@code long} elements*/
+ private static final EmptyIterable.OfLong OF_LONG = new EmptyIterable.OfLong();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfLong() {}
@Override
- public EmptyIterator.OfDouble iterator()
+ public EmptyIterator.OfLong iterator()
{
- return EmptyIterator.OfDouble();
+ return EmptyIterator.ofLong();
}
}
-}
+}
\ No newline at end of file
diff --git a/prism/src/common/iterable/EmptyIterator.java b/prism/src/common/iterable/EmptyIterator.java
index c468648e4d..2c0e3d5673 100644
--- a/prism/src/common/iterable/EmptyIterator.java
+++ b/prism/src/common/iterable/EmptyIterator.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2016-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -27,36 +27,53 @@
package common.iterable;
-import java.util.Iterator;
import java.util.NoSuchElementException;
-import java.util.PrimitiveIterator;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
/**
- * Base class for empty Iterators,
- * static helpers for common primitive iterators.
+ * Abstract base class for empty Iterators.
+ * The four natural implementations (generic, double, int, and long)
+ * are implemented as Singletons and their instances accessible by a static method.
+ *
+ * @param type of the Iterator's elements
*/
-public abstract class EmptyIterator implements Iterator
+public abstract class EmptyIterator implements FunctionalIterator
{
- private static final Of OF = new Of<>();
- private static final OfInt OF_INT = new OfInt();
- private static final OfLong OF_LONG = new OfLong();
- private static final OfDouble OF_DOUBLE = new OfDouble();
-
+ /**
+ * Get unique instance for elements of a generic type.
+ *
+ * @param type of the Iterator's elements
+ */
@SuppressWarnings("unchecked")
- public static Of Of() {
- return (Of) OF;
+ public static Of of()
+ {
+ return (Of) Of.OF;
}
- public static OfInt OfInt() {
- return OF_INT;
+ /**
+ * Get unique instance for {@code double} elements.
+ */
+ public static OfDouble ofDouble()
+ {
+ return OfDouble.OF_DOUBLE;
}
- public static OfLong OfLong() {
- return OF_LONG;
+ /**
+ * Get unique instance for {@code int} elements.
+ */
+ public static OfInt ofInt()
+ {
+ return OfInt.OF_INT;
}
- public static OfDouble OfDouble() {
- return OF_DOUBLE;
+ /**
+ * Get unique instance for {@code long} elements.
+ */
+ public static OfLong ofLong()
+ {
+ return OfLong.OF_LONG;
}
@Override
@@ -65,47 +82,195 @@ public boolean hasNext()
return false;
}
- public static class Of extends EmptyIterator
+ @Override
+ public EmptyIterator dedupe()
+ {
+ return this;
+ }
+
+ @Override
+ public EmptyIterator distinct()
{
- private Of() {};
+ return this;
+ }
+
+
+
+ /**
+ * Generic implementation of an empty Iterator as Singleton.
+ *
+ * @param type of the Iterator's elements
+ */
+ public static class Of extends EmptyIterator
+ {
+ /** Singleton instance elements of a generic type */
+ private static final Of OF = new Of<>();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private Of() {}
@Override
- public T next()
+ public E next()
{
throw new NoSuchElementException();
}
}
- public static class OfInt extends EmptyIterator implements PrimitiveIterator.OfInt
+
+
+ /**
+ * Primitive specialisation for {@code double} of an empty Iterator as Singleton.
+ */
+ public static class OfDouble extends EmptyIterator implements FunctionalPrimitiveIterator.OfDouble
{
- private OfInt() {};
+ /** Singleton instance for {@code double} elements */
+ private static final EmptyIterator.OfDouble OF_DOUBLE = new EmptyIterator.OfDouble();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfDouble() {}
@Override
- public int nextInt()
+ public double nextDouble()
{
throw new NoSuchElementException();
}
+
+ @Override
+ public EmptyIterator.OfDouble dedupe()
+ {
+ return this;
+ }
+
+ @Override
+ public EmptyIterator.OfDouble distinct()
+ {
+ return this;
+ }
+
+ @Override
+ public OptionalDouble max()
+ {
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public OptionalDouble min()
+ {
+ return max();
+ }
+
+ @Override
+ public double sum()
+ {
+ return 0.0;
+ }
}
- public static class OfLong extends EmptyIterator implements PrimitiveIterator.OfLong
+
+
+ /**
+ * Primitive specialisation for {@code int} of an empty Iterator as Singleton.
+ */
+ public static class OfInt extends EmptyIterator implements FunctionalPrimitiveIterator.OfInt
{
- private OfLong() {};
+ /** Singleton instance for {@code int} elements */
+ private static final EmptyIterator.OfInt OF_INT = new EmptyIterator.OfInt();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfInt() {}
@Override
- public long nextLong()
+ public int nextInt()
{
throw new NoSuchElementException();
}
+
+ @Override
+ public EmptyIterator.OfInt dedupe()
+ {
+ return this;
+ }
+
+ @Override
+ public EmptyIterator.OfInt distinct()
+ {
+ return this;
+ }
+
+ @Override
+ public OptionalInt max()
+ {
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public OptionalInt min()
+ {
+ return max();
+ }
+
+ @Override
+ public long sum()
+ {
+ return 0;
+ }
}
- public static class OfDouble extends EmptyIterator implements PrimitiveIterator.OfDouble
+
+
+ /**
+ * Primitive specialisation for {@code long} of an empty Iterator as Singleton.
+ */
+ public static class OfLong extends EmptyIterator implements FunctionalPrimitiveIterator.OfLong
{
- private OfDouble() {};
+ /** Singleton instance for {@code long} elements*/
+ private static final EmptyIterator.OfLong OF_LONG = new EmptyIterator.OfLong();
+
+ /**
+ * Private constructor for the Singleton instance.
+ */
+ private OfLong() {}
@Override
- public double nextDouble()
+ public long nextLong()
{
throw new NoSuchElementException();
}
+
+ @Override
+ public EmptyIterator.OfLong dedupe()
+ {
+ return this;
+ }
+
+ @Override
+ public EmptyIterator.OfLong distinct()
+ {
+ return this;
+ }
+
+ @Override
+ public OptionalLong max()
+ {
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public OptionalLong min()
+ {
+ return max();
+ }
+
+ @Override
+ public long sum()
+ {
+ return 0;
+ }
}
}
diff --git a/prism/src/common/iterable/FilteringIterable.java b/prism/src/common/iterable/FilteringIterable.java
index b161b2e9c3..c3300c9bfd 100644
--- a/prism/src/common/iterable/FilteringIterable.java
+++ b/prism/src/common/iterable/FilteringIterable.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2016-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -27,138 +27,162 @@
package common.iterable;
-import java.util.Iterator;
-import java.util.PrimitiveIterator;
+import java.util.Objects;
import java.util.function.DoublePredicate;
import java.util.function.IntPredicate;
import java.util.function.LongPredicate;
import java.util.function.Predicate;
/**
- * Base class for Iterables around FilteringIterators,
- * static constructors for deduplicating entries. */
-public abstract class FilteringIterable implements Iterable
+ * Abstract base class for Iterables that filter elements by a predicate.
+ * Returns only those elements for which the filter predicate evaluates to {@code true}.
+ *
+ * @param type of the Iterable's elements
+ * @param type of the underlying Iterable
+ */
+public abstract class FilteringIterable> implements FunctionalIterable
{
- protected final Iterable iterable;
-
- public FilteringIterable(final Iterable iterable)
+ /** The Iterable which elements are filtered */
+ protected final I iterable;
+
+ /**
+ * Constructor for a filtering Iterable without a predicate.
+ *
+ * @param iterable an Iterable to be filtered
+ */
+ public FilteringIterable(I iterable)
{
+ Objects.requireNonNull(iterable);
this.iterable = iterable;
}
- public static class Of extends FilteringIterable
- {
- private Predicate predicate;
- public Of(Iterable iterable, Predicate predicate)
- {
- super(iterable);
- this.predicate = predicate;
- }
- @Override
- public Iterator iterator()
- {
- return new FilteringIterator.Of<>(iterable, predicate);
- }
- }
-
- public static class OfInt extends FilteringIterable implements IterableInt
+ /**
+ * Generic implementation of a filtering Iterable.
+ *
+ * @param type of the Iterable's elements
+ */
+ public static class Of extends FilteringIterable>
{
- private IntPredicate predicate;
-
- public OfInt(IterableInt iterable, IntPredicate predicate)
+ /** The predicate the Iterable uses to filter the elements */
+ protected final Predicate filter;
+
+ /**
+ * Constructor for an Iterable that filters elements by a predicate.
+ *
+ * Attention! If the predicate is stateful, subsequent iterations may yield different elements.
+ *
+ * @param iterable an Iterable to be filtered
+ * @param predicate a predicate used to filter the elements
+ */
+ public Of(Iterable iterable, Predicate predicate)
{
super(iterable);
- this.predicate = predicate;
+ Objects.requireNonNull(predicate);
+ this.filter = predicate;
}
@Override
- public PrimitiveIterator.OfInt iterator()
+ public FunctionalIterator iterator()
{
- return new FilteringIterator.OfInt((IterableInt) iterable, predicate);
+ return new FilteringIterator.Of<>(iterable.iterator(), filter);
}
}
- public static class OfLong extends FilteringIterable implements IterableLong
- {
- private LongPredicate predicate;
- public OfLong(IterableLong iterable, LongPredicate predicate)
+
+ /**
+ * Primitive specialisation for {@code double} of a filtering Iterable.
+ */
+ public static class OfDouble extends FilteringIterable implements FunctionalPrimitiveIterable.OfDouble
+ {
+ /** The predicate the Iterable uses to filter the elements */
+ protected final DoublePredicate filter;
+
+ /**
+ * Constructor for an Iterable that filters elements by a predicate.
+ *
+ * Attention! If the predicate is stateful, subsequent iterations may yield different elements.
+ *
+ * @param iterable an Iterable to be filtered
+ * @param predicate a predicate used to filter the elements
+ */
+ public OfDouble(PrimitiveIterable.OfDouble iterable, DoublePredicate predicate)
{
super(iterable);
- this.predicate = predicate;
+ Objects.requireNonNull(predicate);
+ this.filter = predicate;
}
@Override
- public PrimitiveIterator.OfLong iterator()
+ public FunctionalPrimitiveIterator.OfDouble iterator()
{
- return new FilteringIterator.OfLong((IterableLong) iterable, predicate);
+ return new FilteringIterator.OfDouble(iterable.iterator(), filter);
}
}
- public static class OfDouble extends FilteringIterable implements IterableDouble
- {
- private DoublePredicate predicate;
- public OfDouble(IterableDouble iterable, DoublePredicate predicate)
+
+ /**
+ * Primitive specialisation for {@code int} of a filtering Iterable.
+ */
+ public static class OfInt extends FilteringIterable implements FunctionalPrimitiveIterable.OfInt
+ {
+ /** The predicate the Iterable uses to filter the elements */
+ protected final IntPredicate filter;
+
+ /**
+ * Constructor for an Iterable that filters elements by a predicate.
+ *
+ * Attention! If the predicate is stateful, subsequent iterations may yield different elements.
+ *
+ * @param iterable an Iterable to be filtered
+ * @param predicate a predicate used to filter the elements
+ */
+ public OfInt(PrimitiveIterable.OfInt iterable, IntPredicate predicate)
{
super(iterable);
- this.predicate = predicate;
+ Objects.requireNonNull(predicate);
+ this.filter = predicate;
}
@Override
- public PrimitiveIterator.OfDouble iterator()
+ public FunctionalPrimitiveIterator.OfInt iterator()
{
- return new FilteringIterator.OfDouble((IterableDouble) iterable, predicate);
+ return new FilteringIterator.OfInt(iterable.iterator(), filter);
}
}
- public static IterableInt dedupe(IterableInt iterable)
- {
- return new IterableInt()
- {
- @Override
- public PrimitiveIterator.OfInt iterator()
- {
- return FilteringIterator.dedupe(iterable.iterator());
- }
- };
- }
- public static IterableLong dedupe(IterableLong iterable)
- {
- return new IterableLong()
- {
- @Override
- public PrimitiveIterator.OfLong iterator()
- {
- return FilteringIterator.dedupe(iterable.iterator());
- }
- };
- }
- public static IterableDouble dedupe(IterableDouble iterable)
+ /**
+ * Primitive specialisation for {@code long} of a filtering Iterable.
+ */
+ public static class OfLong extends FilteringIterable implements FunctionalPrimitiveIterable.OfLong
{
- return new IterableDouble()
+ /** The predicate the Iterable uses to filter the elements */
+ protected final LongPredicate filter;
+
+ /**
+ * Constructor for an Iterable that filters elements by a predicate.
+ *
+ * Attention! If the predicate is stateful, subsequent iterations may yield different elements.
+ *
+ * @param iterable an Iterable to be filtered
+ * @param predicate a predicate used to filter the elements
+ */
+ public OfLong(PrimitiveIterable.OfLong iterable, LongPredicate predicate)
{
- @Override
- public PrimitiveIterator.OfDouble iterator()
- {
- return FilteringIterator.dedupe(iterable.iterator());
- }
- };
- }
+ super(iterable);
+ Objects.requireNonNull(predicate);
+ this.filter = predicate;
+ }
- public static Iterable dedupe(Iterable iterable)
- {
- return new Iterable()
+ @Override
+ public FunctionalPrimitiveIterator.OfLong iterator()
{
- @Override
- public Iterator iterator()
- {
- return FilteringIterator.dedupe(iterable.iterator());
- }
- };
+ return new FilteringIterator.OfLong(iterable.iterator(), filter);
+ }
}
}
diff --git a/prism/src/common/iterable/FilteringIterator.java b/prism/src/common/iterable/FilteringIterator.java
index f5e1904e97..5b8ae4fdc5 100644
--- a/prism/src/common/iterable/FilteringIterator.java
+++ b/prism/src/common/iterable/FilteringIterator.java
@@ -2,7 +2,7 @@
//
// Copyright (c) 2016-
// Authors:
-// * Steffen Maercker (TU Dresden)
+// * Steffen Maercker (TU Dresden)
// * Joachim Klein (TU Dresden)
//
//------------------------------------------------------------------------------
@@ -27,46 +27,44 @@
package common.iterable;
-import java.util.HashSet;
import java.util.Iterator;
-import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PrimitiveIterator;
-import java.util.Set;
import java.util.function.DoublePredicate;
import java.util.function.IntPredicate;
import java.util.function.LongPredicate;
import java.util.function.Predicate;
/**
- * Base class for filtering iterators,
- * static helpers for common filtering task (deduping).
+ * Abstract base class implementing an Iterator that filters elements by a predicate.
+ * Returns only those elements for which the filter predicate evaluates to {@code true}.
+ *
+ * The calls to {@code next()} of the underlying Iterator happen on-the-fly,
+ * i.e., only when {@code next()} is called for this Iterator.
+ *
+ * Implementations should release the underlying Iterator after iteration.
+ *
+ * This Iterator does not support the {@code remove()} method, even if the underlying
+ * Iterator support it.
+ *
+ * @param type of the Iterator's elements
+ * @param type of the underlying Iterator
*/
-public abstract class FilteringIterator implements Iterator
+public abstract class FilteringIterator