Commit c9fe4b45 authored by Sebastian Vollbrecht's avatar Sebastian Vollbrecht

Refactored InfeasibleMinIIProperty up to the suffix creation phase.

parent d9abf184
......@@ -20,9 +20,8 @@ package graphgen.datastructures;
import java.util.Objects;
/**
* A basic class for arranging objects in pairs. Every pairing is immutable once
* created. To create a pair, use the static
* {@link Pair#makePair(Object, Object)} constructor.
* A basic class for arranging objects in pairs. Every pairing is immutable once created. To create a pair, use the
* static {@link Pair#makePair(Object, Object)} constructor.
*
* @param <T1> the type of the first element
* @param <T2> the type of the second element
......@@ -89,7 +88,8 @@ public class Pair<T1, T2> {
return false;
if (second == null) {
return other.second == null;
} else return second.equals(other.second);
} else
return second.equals(other.second);
}
}
......@@ -21,10 +21,8 @@ import java.util.Optional;
import java.util.Random;
/**
* A wrapper class for {@link Random} instances. This class disallows random
* number generation without having seeded the wrapped random instance
* beforehand, so that the graph generator does not generate 'true' random
* numbers by accident.
* A wrapper class for {@link Random} instances. This class disallows random number generation without having seeded the
* wrapped random instance beforehand, so that the graph generator does not generate 'true' random numbers by accident.
*
* @author Sebastian Vollbrecht
*/
......@@ -35,8 +33,8 @@ public class SeededRandom {
private final Random rng;
/**
* Creates a new, unseeded SeededRandom instance. Before random numbers can be
* generated, a call to the {@link #setSeed(long)} method will be necessary.
* Creates a new, unseeded SeededRandom instance. Before random numbers can be generated, a call to the {@link
* #setSeed(long)} method will be necessary.
*/
public SeededRandom() {
this.rng = new Random();
......@@ -44,8 +42,8 @@ public class SeededRandom {
}
/**
* Creates a new, seeded SeededRandom instance. Using this constructor, a call
* to the {@link #setSeed(long)} method is unnecessary.
* Creates a new, seeded SeededRandom instance. Using this constructor, a call to the {@link #setSeed(long)} method
* is unnecessary.
*
* @param seed the seed to pass to the random instance
*/
......@@ -65,13 +63,11 @@ public class SeededRandom {
}
/**
* Returns a random integer value between 0 (inclusive) and the given bound
* (exclusive).
* Returns a random integer value between 0 (inclusive) and the given bound (exclusive).
*
* @param bound the given bound
* @return the random integer value
* @throws UnsupportedOperationException if this instance has not yet been
* seeded
* @throws UnsupportedOperationException if this instance has not yet been seeded
*/
public int nextInt(int bound) {
checkSeededStatus();
......@@ -82,8 +78,7 @@ public class SeededRandom {
* Returns a random double value between 0.0 (inclusive) and 1.0 (exclusive).
*
* @return the random double value
* @throws UnsupportedOperationException if this instance has not yet been
* seeded
* @throws UnsupportedOperationException if this instance has not yet been seeded
*/
public double nextDouble() {
checkSeededStatus();
......@@ -94,8 +89,7 @@ public class SeededRandom {
* Returns the wrapped random instance.
*
* @return the wrapped instance
* @throws UnsupportedOperationException if this instance has not yet been
* seeded
* @throws UnsupportedOperationException if this instance has not yet been seeded
*/
public Random getRandom() {
checkSeededStatus();
......
......@@ -21,9 +21,8 @@ import modsched.Edge;
import modsched.Node;
/**
* An enumeration which stores possible edge types. The {@link #ALL} type is
* meant to be a representative of both forward edges and backedges, similar to
* a wildcard.
* An enumeration which stores possible edge types. The {@link #ALL} type is meant to be a representative of both
* forward edges and backedges, similar to a wildcard.
*
* @author Sebastian Vollbrecht
*/
......
......@@ -47,9 +47,8 @@ public enum EdgeValue {
BACKEDGE_DISTANCE;
/**
* Returns whether the given edge matches this edge value constant. This is
* useful to filter out backedges when the edge delay is needed, or forward
* edges when either the backedge delay or the backedge distance are needed.
* Returns whether the given edge matches this edge value constant. This is useful to filter out backedges when the
* edge delay is needed, or forward edges when either the backedge delay or the backedge distance are needed.
*
* @param <N> the edge's node type
* @param edge the given edge
......
......@@ -21,8 +21,7 @@ import modsched.EichenbergerFormulation;
import modsched.MoovacFormulation;
/**
* An enumeration which stores possible iterative modulo scheduling formulation
* types.
* An enumeration which stores possible iterative modulo scheduling formulation types.
*
* @author Sebastian Vollbrecht
*/
......
......@@ -20,9 +20,8 @@ package graphgen.enums;
import graphgen.graph.ResourceNode;
/**
* An enumeration which stores possible resource types. The {@link #ALL} type is
* meant to be a representative of both limited and unlimited resources, similar
* to a wildcard.
* An enumeration which stores possible resource types. The {@link #ALL} type is meant to be a representative of both
* limited and unlimited resources, similar to a wildcard.
*
* @author Sebastian Vollbrecht
*/
......
......@@ -20,26 +20,25 @@ package graphgen.generator.components;
import graphgen.datastructures.SeededRandom;
/**
* An interface which all components participating in the creation of graphs can
* implement. It provides initialization methods.
* An interface which all components participating in the creation of graphs can implement. It provides initialization
* methods.
*
* @author Sebastian Vollbrecht
*/
public interface Initializable {
/**
* Grants the implementing class access to the graph generator's random number
* generator. This method is called only <i>once</i> when the generator itself
* is constructed.
* Grants the implementing class access to the graph generator's random number generator. This method is called
* only
* <i>once</i> when the generator itself is constructed.
*
* @param rng the graph generator's random number generator
*/
public abstract void init(SeededRandom rng);
/**
* Resets the implementing class, preparing it for the generation of a new
* graph. This method is called every time before the generator begins
* generating a new graph.
* Resets the implementing class, preparing it for the generation of a new graph. This method is called every time
* before the generator begins generating a new graph.
*/
public abstract void reset();
}
......@@ -24,28 +24,24 @@ import graphgen.graph.ResourceNode;
import java.util.Map;
/**
* An interface which all classes participating in the creation of edges must
* implement. It provides setter methods for layer structures and ASAP times
* maps, which are useful for edge creation components which use the nodes'
* depths.
* An interface which all classes participating in the creation of edges must implement. It provides setter methods for
* layer structures and ASAP times maps, which are useful for edge creation components which use the nodes' depths.
*
* @author Sebastian Vollbrecht
*/
public interface EdgeCreationComponent extends Initializable {
/**
* Sets the layer structure of the implementing class, which can be used
* optionally for different purposes, such as edge validity checks or edge value
* computations regarding the depth of nodes.
* Sets the layer structure of the implementing class, which can be used optionally for different purposes, such as
* edge validity checks or edge value computations regarding the depth of nodes.
*
* @param layers the layer structure to use
*/
public abstract void setLayerStructure(LayerStructure layers);
/**
* Sets the ASAP times map of the implementing class, which can be used
* optionally for different purposes, such as backedge validity checks or
* backedge value computations regarding the 'ASAP depth' of nodes.
* Sets the ASAP times map of the implementing class, which can be used optionally for different purposes, such as
* backedge validity checks or backedge value computations regarding the 'ASAP depth' of nodes.
*
* @param asapTimes the ASAP times map to use
*/
......
......@@ -30,10 +30,9 @@ import java.util.Map;
import java.util.Objects;
/**
* A combined value computer combines several arbitrary value computers into a
* single one. Its computations are based on all contained value computers'
* decisions. This is done through an integer {@link FoldingStrategy folding
* strategy}, which combines several values into a single one.
* A combined value computer combines several arbitrary value computers into a single one. Its computations are based on
* all contained value computers' decisions. This is done through an integer {@link FoldingStrategy folding strategy},
* which combines several values into a single one.
*
* @author Sebastian Vollbrecht
*/
......@@ -43,9 +42,8 @@ public class CombinedValueComputer extends ValueComputer {
private final List<ValueComputer> valueComputers;
/**
* Creates a new combined value computer based on the provided value computers
* and the given folding strategy. The folding strategy combines the values of
* the given value computers into a single one.
* Creates a new combined value computer based on the provided value computers and the given folding strategy. The
* folding strategy combines the values of the given value computers into a single one.
*
* @param strategy the strategy to use
* @param valueComputers the value computers to combine into a single one
......
......@@ -24,8 +24,7 @@ import graphgen.graph.ResourceNode;
import java.util.Map;
/**
* This computer class always returns a constant value when computing delays or
* distances between nodes.
* This computer class always returns a constant value when computing delays or distances between nodes.
*
* @author Sebastian Vollbrecht
*/
......@@ -34,8 +33,7 @@ public class ConstantValueComputer extends ValueComputer {
private final int constant;
/**
* Constructs a new constant value computer which will use the constant when
* computing values.
* Constructs a new constant value computer which will use the constant when computing values.
*
* @param constant the constant
*/
......
......@@ -31,20 +31,17 @@ import java.util.Map;
import java.util.Objects;
/**
* This value computer computes edge values based on the depth of the edge's
* source nodes. If a node's computed depth value is not contained in the
* provided map of value computers and their depths, the corresponding value
* will be retrieved through linear interpolation of the values of the closest
* two value computers.
* This value computer computes edge values based on the depth of the edge's source nodes. If a node's computed depth
* value is not contained in the provided map of value computers and their depths, the corresponding value will be
* retrieved through linear interpolation of the values of the closest two value computers.
*
* @author Sebastian Vollbrecht
*/
public class DepthValueComputer extends ValueComputer {
/**
* This map is used to compute the nodes' depths. It can either be based on the
* graph's layer structure or the nodes' ASAP depths (depending on the provided
* {@link #useASAPDepths} flag).
* This map is used to compute the nodes' depths. It can either be based on the graph's layer structure or the
* nodes' ASAP depths (depending on the provided {@link #useASAPDepths} flag).
*/
private final Map<Integer, Integer> depthsByID;
......@@ -52,15 +49,13 @@ public class DepthValueComputer extends ValueComputer {
private final boolean useASAPDepths;
/**
* Constructs a new depth based value computer using the provided mapping of
* depths to value computers. The additional boolean flag denotes whether the
* nodes' ASAP times or the nodes' layer depths should be used when computing
* their respective depths.
* Constructs a new depth based value computer using the provided mapping of depths to value computers. The
* additional boolean flag denotes whether the nodes' ASAP times or the nodes' layer depths should be used when
* computing their respective depths.
*
* @param valueComputersByDepth the mapping of depths to value computers
* @param useASAPDepths true to use the nodes' ASAP times instead of the
* layer depths when computing the nodes' depths,
* otherwise false
* @param useASAPDepths true to use the nodes' ASAP times instead of the layer depths when computing the
* nodes' depths, otherwise false
* @throws NullPointerException if the mapping is null
* @throws IllegalArgumentException if the mapping is empty
*/
......
......@@ -34,8 +34,7 @@ public class DistributionValueComputer extends ValueComputer {
private final Distribution<Integer> distribution;
/**
* Constructs a new single distribution value computer using the given
* distribution.
* Constructs a new single distribution value computer using the given distribution.
*
* @param distribution the given distribution
*/
......
......@@ -31,8 +31,7 @@ import java.util.Optional;
import java.util.Set;
/**
* This value computer returns values identical to values of a provided set of
* edges.
* This value computer returns values identical to values of a provided set of edges.
*
* @author Sebastian Vollbrecht
*/
......@@ -42,10 +41,9 @@ public class IdenticalValueComputer extends ValueComputer {
private final Optional<Distribution<Integer>> defaultDistribution;
/**
* Constructs a new identical value computer for the specified
* {@link EdgeValue}, using the provided set of edges. If the provided set of
* edges does not contain a value for a given pair of source and destination
* nodes during graph creation, a corresponding exception will be thrown.
* Constructs a new identical value computer for the specified {@link EdgeValue}, using the provided set of edges.
* If the provided set of edges does not contain a value for a given pair of source and destination nodes during
* graph creation, a corresponding exception will be thrown.
*
* @param edgeValue the specified edge value
* @param edges the set of edges
......@@ -56,16 +54,13 @@ public class IdenticalValueComputer extends ValueComputer {
}
/**
* Constructs a new identical value computer for the specified
* {@link EdgeValue}, using the provided set of edges. The given distribution
* will be used for pairs of nodes which are not contained in the set of edges.
* If the specified distribution is null however, exceptions will be thrown
* instead.
* Constructs a new identical value computer for the specified {@link EdgeValue}, using the provided set of edges.
* The given distribution will be used for pairs of nodes which are not contained in the set of edges. If the
* specified distribution is null however, exceptions will be thrown instead.
*
* @param edgeValue the specified edge value
* @param edges the set of edges
* @param defaultDistribution the distribution to use for nodes that are not
* contained in the set of edges
* @param defaultDistribution the distribution to use for nodes that are not contained in the set of edges
* @throws NullPointerException if the edge value or the set of edges is null
*/
public IdenticalValueComputer(EdgeValue edgeValue, Set<Edge<ResourceNode>> edges,
......
......@@ -24,9 +24,8 @@ import graphgen.graph.ResourceNode;
import java.util.Map;
/**
* This value computer computes edge values based on the limitedness of the
* edge's nodes. It uses four value computers, one for each combination of node
* limitedness.
* This value computer computes edge values based on the limitedness of the edge's nodes. It uses four value computers,
* one for each combination of node limitedness.
*
* @author Sebastian Vollbrecht
*/
......@@ -38,24 +37,20 @@ public class LimitednessValueComputer extends ValueComputer {
private final ValueComputer unlimitedUnlimitedValueComputer;
/**
* Constructs a new limitedness based value computer using the provided value
* computers.
* Constructs a new limitedness based value computer using the provided value computers.
*
* @param limitedLimitedValueComputer the value computer for values of edges
* which connect limited nodes to limited
* nodes
* @param limitedUnlimitedValueComputer the value computer for values of edges
* which connect limited nodes to
* @param limitedLimitedValueComputer the value computer for values of edges which connect limited nodes to
* limited nodes
* @param limitedUnlimitedValueComputer the value computer for values of edges which connect limited nodes to
* unlimited nodes
* @param unlimitedLimitedValueComputer the value computer for values of edges
* which connect unlimited nodes to
* @param unlimitedLimitedValueComputer the value computer for values of edges which connect unlimited nodes to
* limited nodes
* @param unlimitedUnlimitedValueComputer the value computer for values of edges
* which connect unlimited nodes to
* @param unlimitedUnlimitedValueComputer the value computer for values of edges which connect unlimited nodes to
* unlimited nodes
*/
public LimitednessValueComputer(ValueComputer limitedLimitedValueComputer,
ValueComputer limitedUnlimitedValueComputer, ValueComputer unlimitedLimitedValueComputer,
ValueComputer limitedUnlimitedValueComputer,
ValueComputer unlimitedLimitedValueComputer,
ValueComputer unlimitedUnlimitedValueComputer) {
this.limitedLimitedValueComputer = limitedLimitedValueComputer;
......
......@@ -24,9 +24,8 @@ import java.util.HashMap;
import java.util.Map;
/**
* This is the class which every edge value computer must implement. An edge
* value computer computes edge delays, backedge delays and backedge distances
* for edges connecting given source and destination nodes.
* This is the class which every edge value computer must implement. An edge value computer computes edge delays,
* backedge delays and backedge distances for edges connecting given source and destination nodes.
*
* @author Sebastian Vollbrecht
*/
......@@ -45,8 +44,7 @@ public abstract class ValueComputer implements EdgeCreationComponent {
}
/**
* Retrieves the edge value of the edge connecting the source node to the
* destination node.
* Retrieves the edge value of the edge connecting the source node to the destination node.
*
* @param src the edge's source node
* @param dst the edge's destination node
......@@ -73,8 +71,7 @@ public abstract class ValueComputer implements EdgeCreationComponent {
}
/**
* Computes the edge value of the edge connecting the source node to the
* destination node.
* Computes the edge value of the edge connecting the source node to the destination node.
*
* @param src the edge's source node
* @param dst the edge's destination node
......@@ -83,8 +80,7 @@ public abstract class ValueComputer implements EdgeCreationComponent {
protected abstract int computeValue(ResourceNode src, ResourceNode dst);
/**
* Resets the implementing class, preparing it for the generation of a new
* graph.
* Resets the implementing class, preparing it for the generation of a new graph.
*/
protected abstract void implementedReset();
......
......@@ -33,9 +33,8 @@ import java.util.Map;
import java.util.Objects;
/**
* A combined edge includer combines several arbitrary edge includers into a
* single one. Its edge inclusion decisions are based on all contained edge
* includers' decisions. This is done through a {@link FoldingStrategy folding
* A combined edge includer combines several arbitrary edge includers into a single one. Its edge inclusion decisions
* are based on all contained edge includers' decisions. This is done through a {@link FoldingStrategy folding
* strategy}, which combines several decisions into a single one.
*
* @author Sebastian Vollbrecht
......@@ -48,9 +47,8 @@ public class CombinedEdgeIncluder extends EdgeIncluder {
private final List<EdgeIncluder> edgeIncluders;
/**
* Creates a new combined edge includer based on the provided edge includers and
* the given folding strategy. The folding strategy combines the decisions of
* the given edge includers into a single one.
* Creates a new combined edge includer based on the provided edge includers and the given folding strategy. The
* folding strategy combines the decisions of the given edge includers into a single one.
*
* @param strategy the strategy to use
* @param edgeIncluders the edge includers to combine into a single one
......
......@@ -33,20 +33,17 @@ import java.util.Map;
import java.util.Objects;
/**
* The depth edge includer bases its inclusion decisions on the depth
* information of an edge's source node. If a node's computed depth value is not
* contained in the provided map of edge includers and their depths, the
* corresponding decision will be computed probabilistically (see
* {@link DepthNodeCreator}).
* The depth edge includer bases its inclusion decisions on the depth information of an edge's source node. If a node's
* computed depth value is not contained in the provided map of edge includers and their depths, the corresponding
* decision will be computed probabilistically (see {@link DepthNodeCreator}).
*
* @author Sebastian Vollbrecht
*/
public class DepthEdgeIncluder extends EdgeIncluder {
/**
* This map is used to compute the nodes' depths. It can either be based on the
* graph's layer structure or the nodes' ASAP depths (depending on the provided
* {@link #useASAPDepths} flag).
* This map is used to compute the nodes' depths. It can either be based on the graph's layer structure or the
* nodes' ASAP depths (depending on the provided {@link #useASAPDepths} flag).
*/
private final Map<Integer, Integer> depthsByID;
......@@ -56,15 +53,13 @@ public class DepthEdgeIncluder extends EdgeIncluder {
private SeededRandom rng;
/**
* Constructs a new depth based edge includer using the provided mapping of
* depths to edge includers. The additional boolean flag denotes whether the
* nodes' ASAP times or the nodes' layer depths should be used when computing
* their respective depths.
* Constructs a new depth based edge includer using the provided mapping of depths to edge includers. The additional
* boolean flag denotes whether the nodes' ASAP times or the nodes' layer depths should be used when computing their
* respective depths.
*
* @param edgeIncludersByDepth the mapping of depths to edge includers
* @param useASAPDepths true to use the nodes' ASAP times instead of the
* layer depths when computing the nodes' depths,
* otherwise false
* @param useASAPDepths true to use the nodes' ASAP times instead of the layer depths when computing the
* nodes' depths, otherwise false
* @throws NullPointerException if any mapping is null
* @throws IllegalArgumentException if any mapping is empty
*/
......@@ -79,7 +74,6 @@ public class DepthEdgeIncluder extends EdgeIncluder {
this.depthsAndEdgeIncluders = new ArrayList<>();
this.useASAPDepths = useASAPDepths;
edgeIncludersByDepth.forEach((d, c) -> depthsAndEdgeIncluders.add(Pair.makePair(d, c)));
depthsAndEdgeIncluders.sort(Comparator.comparing(p -> p.first));
......
......@@ -26,8 +26,7 @@ import modsched.Edge;
import java.util.Map;
/**
* The distribution edge includer bases its edge inclusion decisions on an edge
* probability distribution.
* The distribution edge includer bases its edge inclusion decisions on an edge probability distribution.
*
* @author Sebastian Vollbrecht
*/
......@@ -38,11 +37,9 @@ public class DistributionEdgeIncluder extends EdgeIncluder {
private SeededRandom rng;
/**
* Creates a new distribution-based edge includer, using the provided
* probability distribution.
* Creates a new distribution-based edge includer, using the provided probability distribution.
*
* @param distribution the distribution of edge inclusion
* probabilities
* @param distribution the distribution of edge inclusion probabilities
*/
public DistributionEdgeIncluder(Distribution<Double> distribution) {
this.distribution = distribution;
......
......@@ -27,8 +27,7 @@ import java.util.HashMap;
import java.util.Map;
/**
* This class contains methods for deciding the inclusion of optional edges when
* generating graphs.
* This class contains methods for deciding the inclusion of optional edges when generating graphs.
*
* @author Sebastian Vollbrecht
*/
......@@ -70,12 +69,10 @@ public abstract class EdgeIncluder implements EdgeCreationComponent, Observer<Ed
}
/**
* Toggles strict mode, allowing or disallowing deviations of specified
* parameters.
* Toggles strict mode, allowing or disallowing deviations of specified parameters.
* <p>
* In strict mode, an edge can only be created if the includer allows so. If an
* edge is included although the includer disallowed doing it, a
* {@link StrictModeException} will be thrown.
* In strict mode, an edge can only be created if the includer allows so. If an edge is included although the
* includer disallowed doing it, a {@link StrictModeException} will be thrown.
*
* @param strict true to disallow deviations, false to allow deviations
*/
......@@ -104,8 +101,7 @@ public abstract class EdgeIncluder implements EdgeCreationComponent, Observer<Ed
protected abstract boolean decideEdgeInclusion(Edge<ResourceNode> edge);
/**
* Resets the implementing class, preparing it for the generation of a new
* graph.
* Resets the implementing class, preparing it for the generation of a new graph.
*/
protected abstract void implementedReset();
......
......@@ -27,9 +27,8 @@ import java.util.Map;
import java.util.Set;
/**
* This edge includer determines the inclusion of edges based on a provided set
* of edges. If the provided set of edges does not contain a requested edge, it
* will always returns false.
* This edge includer determines the inclusion of edges based on a provided set of edges. If the provided set of edges
* does not contain a requested edge, it will always returns false.
*
* @author Sebastian Vollbrecht
*/
......
......@@ -25,8 +25,8 @@ import modsched.Edge;
import java.util.Map;
/**
* The limitedness edge includer bases its inclusion decisions on four edge
* includers, one for each combination of node limitedness.
* The limitedness edge includer bases its inclusion decisions on four edge includers, one for each combination of node
* limitedness.
*
* @author Sebastian Vollbrecht
*/
......@@ -38,17 +38,13 @@ public class LimitednessEdgeIncluder extends EdgeIncluder {
private final EdgeIncluder unlimitedToUnlimitedIncluder;
/**
* Constructs a new limitedness based edge includer, using the provided
* includers during the edge creation phase to decide edge inclusions.
* Constructs a new limitedness based edge includer, using the provided includers during the edge creation phase to
* decide edge inclusions.
*
* @param limitedToLimitedIncluder the includer for edges connecting a
* limited node to a limited node
* @param limitedToUnlimitedIncluder the includer for edges connecting a
* limited node to an unlimited node
* @param unlimitedToLimitedIncluder the includer for edges connecting an
* unlimited node to a limited node
* @param unlimitedToUnlimitedIncluder the includer for edges connecting an
* unlimited node to an unlimited node
* @param limitedToLimitedIncluder the includer for edges connecting a limited node to a limited node
* @param limitedToUnlimitedIncluder the includer for edges connecting a limited node to an unlimited node
* @param unlimitedToLimitedIncluder the includer for edges connecting an unlimited node to a limited node
* @param unlimitedToUnlimitedIncluder the includer for edges connecting an unlimited node to an unlimited node
*/
public LimitednessEdgeIncluder(EdgeIncluder limitedToLimitedIncluder, EdgeIncluder limitedToUnlimitedIncluder,
EdgeIncluder unlimitedToLimitedIncluder, EdgeIncluder unlimitedToUnlimitedIncluder) {
......
......@@ -39,8 +39,7 @@ public class ProbabilityEdgeIncluder extends EdgeIncluder {
* Constructs a new probability edge includer based on the given probability.
*
* @param p_edge the probability to include an edge
* @throws IllegalArgumentException if the probability is not in the interval
* [0, 1]
* @throws IllegalArgumentException if the probability is not in the interval [0, 1]
*/
public ProbabilityEdgeIncluder(double p_edge) {
if (p_edge < 0 || p_edge > 1)
......
......@@ -22,8 +22,8 @@ import graphgen.datastructures.SeededRandom;
import java.util.List;
/**
* This class folds many boolean values into a single one in a conjunctive
* manner (i.e. using the logical AND operator).
* This class folds many boolean values into a single one in a conjunctive manner (i.e. using the logical AND
* operator).
*
* @author Sebastian Vollbrecht
*/
......
......@@ -22,8 +22,7 @@ import graphgen.generator.components.Initializable;
import java.util.List;
/**
* This interface represents strategies to fold arbitrary values of several
* components into one single value.
* This interface represents strategies to fold arbitrary values of several components into one single value.
*
* @author Sebastian Vollbrecht
*/
......
......@@ -22,8 +22,7 @@ import graphgen.datastructures.SeededRandom;
import java.util.List;