public static void main(String[] args) throws Exception {
if (args.length == 2) {
int a, b;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
int x = UnifRandom(a, b);
assert (a <= x && x <= b);
} else {
Supplier<CloneableInputsMap> formInputs =
() -> {
Random rgen = new Random();
int a = rgen.nextInt(100);
int b = rgen.nextInt(100) + a + 1;
CloneableInputsMap inputs = new CloneableInputsMap();
inputs.addInteger("a", a);
inputs.addInteger("b", b);
return inputs;
};
Function<CloneableInputsMap, Integer> runAlg =
(inputs) -> UnifRandom(inputs.getInteger("a"), inputs.getInteger("b"));
BiFunction<Integer, CloneableInputsMap, Boolean> checkResults =
(observed, extra) ->
extra.getInteger("a") <= observed && observed <= extra.getInteger("b");
AlgVerifierInterfaces<Integer, CloneableInputsMap> algVerifier =
new InputOutputVerifier<>(checkResults);
AlgorithmFactory algorithmFactory =
new AlgorithmRunnerAndVerifier<>(
"UnifRandomNumberGenerator", NUM_TESTS, formInputs, runAlg, algVerifier);
algorithmFactory.run();
}
}
public static void main(String[] args) throws Exception {
Supplier<CloneableInputsMap> formInputs =
() -> {
CloneableInputsMap inputs = new CloneableInputsMap();
Random rgen = new Random();
char[] s = new char[(ARR_LEN << 1) + 1];
MiscHelperMethods.randCharArray(() -> (char) ('a' + rgen.nextInt(26)), ARR_LEN, s);
inputs.addCharArray("s", s);
inputs.addInteger("len", ARR_LEN);
return inputs;
};
Function<CloneableInputsMap, Integer> runAlg =
(inputs) -> replaceAndRemove(inputs.getCharArray("s"), inputs.getInteger("len"));
Function<CloneableInputsMap, Integer> knownOutput =
(inputs) -> {
String expected = knownOutput(inputs.getCharArray("s"), inputs.getInteger("len"));
inputs.addCharArray("s", expected.toCharArray());
return expected.length();
};
Function<CloneableInputsMap, CloneableInputsMap> saveExtraResults =
(inputs) -> {
CloneableInputsMap extraResults = new CloneableInputsMap();
extraResults.addCharArray("s", inputs.getCharArray("s"));
return extraResults;
};
AlgVerifierInterfaces.QuadFunction<
Integer, Integer, CloneableInputsMap, CloneableInputsMap, Boolean>
checkAns =
(observed, expected, algExtraResults, expExtraResults) ->
observed.equals(expected)
&& algExtraResults.getCharArray("s").length >= observed
&& expExtraResults.getCharArray("s").length >= observed
&& String.valueOf(algExtraResults.getCharArray("s"))
.substring(0, observed)
.equals(
String.valueOf(expExtraResults.getCharArray("s"))
.substring(0, observed));
AlgVerifierInterfaces<Integer, CloneableInputsMap> algVerifier =
new OutputOutputExtraExtraVerifier<>(checkAns);
AlgorithmFactory algorithmFactory =
new AlgorithmRunnerAndVerifier<>(
"Replace and Remove",
NUM_TESTS,
formInputs,
runAlg,
knownOutput,
saveExtraResults,
algVerifier);
System.out.println(
String.format("Running algorithms on character arrays of length %d...", ARR_LEN));
// algorithmFactory.setSequential();
algorithmFactory.run();
}
public static void main(String[] args) {
Algorithm algorithm =
AlgorithmFactory.getAlgorithm(AlgorithmFactory.AlgorithmType.SHORTEST_PATH);
if (algorithm != null) {
algorithm.solveProblem();
}
algorithm = AlgorithmFactory.getAlgorithm(AlgorithmFactory.AlgorithmType.SPANNING_TREE);
if (algorithm != null) {
algorithm.solveProblem();
}
}
/**
* Creates a new Chopper.
*
* @param alg The algorithm to use.
* @param graph The graph to slice.
*/
public BarrierChopper(String className, Graph g) {
// load the demanded algorithm
Object o = AlgorithmFactory.loadClass(className, g);
chopper = (edu.kit.joana.ifc.sdg.graph.chopper.barrier.BarrierChopper) o;
// initialize the sourceCriteria and sinkCriteria and barrier sets
sourceCriteria = new TreeSet<SDGNode>(SDGNode.getIDComparator());
sinkCriteria = new TreeSet<SDGNode>(SDGNode.getIDComparator());
barrier = new TreeSet<SDGNode>(SDGNode.getIDComparator());
}
/**
* Get the base probe for configuration. It should never be run! Instead use makeProbe() to make a
* copy which you can run.
*
* @return the base probe generating it if necessary or null if one cannot be generated (e.g. no
* selected sequence)
*/
Probe<?> getBaseProbe() {
// if there is no base probe and the sequence is not null then generate a new base probe for the
// sequence
if (_baseProbe == null && _sequence != null) {
try {
if (_sequence instanceof Ring) {
final TransferMapTracker tracker = AlgorithmFactory.createTransferMapTracker(_sequence);
_baseProbe = ProbeFactory.getTransferMapProbe(_sequence, tracker);
} else {
final ParticleTracker tracker = AlgorithmFactory.createParticleTracker(_sequence);
_baseProbe = ProbeFactory.createParticleProbe(_sequence, tracker);
}
} catch (Exception exception) {
throw new RuntimeException("Exception making a new probe.", exception);
}
}
return _baseProbe;
}
/**
* Gets the registered algorithmes.
*
* @return collection of algorithms registered
*/
public static Collection<LayoutToolAlgorithms> getRegisteredAlgorithmes() {
IConfigurationElement[] elements =
Platform.getExtensionRegistry()
.getConfigurationElementsFor(Constants.EXTENSION_POINT_ID_ALGORITHMS);
LinkedList<LayoutToolAlgorithms> algo = new LinkedList<LayoutToolAlgorithms>();
for (IConfigurationElement e : elements) {
try {
LayoutToolAlgorithms algorithm = new LayoutToolAlgorithms();
AlgorithmFactory factory =
(AlgorithmFactory) e.createExecutableExtension(Constants.EXTENSION_CLASS_ALGORITHMS);
algorithm.setAlgorithm(factory.createAlgorithm());
if (e.getAttribute(Constants.EXTENSION_NAME) != null) {
String name = e.getAttribute(Constants.EXTENSION_NAME);
name = format(name);
algorithm.setName(name);
}
if (e.getAttribute(Constants.EXTENSION_ICON) != null) {
algorithm.setIcon(getIcon(e, e.getAttribute(Constants.EXTENSION_ICON)));
}
if (e.getAttribute(Constants.EXTENSION_TOOLTIP) != null) {
algorithm.setToolTipText(e.getAttribute(Constants.EXTENSION_TOOLTIP));
}
if (e.getAttribute(Constants.EXTENSION_PATH) != null) {
algorithm.setPath(e.getAttribute(Constants.EXTENSION_PATH));
}
algo.add(algorithm);
} catch (CoreException e1) {
e1.printStackTrace();
}
if (!algo.isEmpty()) {
Collections.sort(
algo,
new Comparator<LayoutToolAlgorithms>() {
public int compare(LayoutToolAlgorithms arg0, LayoutToolAlgorithms arg1) {
int length0 = 0;
if (arg0.getPath() != null) {
String[] pathSplit0 = arg0.getPath().split("\\.");
length0 = pathSplit0.length;
}
int length1 = 0;
if (arg1.getPath() != null) {
String[] pathSplit1 = arg1.getPath().split("\\.");
length1 = pathSplit1.length;
}
if (length1 == length0) {
String a = arg0.getPath() + arg0.getName();
String b = arg1.getPath() + arg1.getName();
if (a == null) {
a = "";
}
if (b == null) {
b = "";
}
return a.compareTo(b);
}
return length1 - length0;
}
});
}
}
return algo;
}
@Test
public void createDepthFirstPathCounterMaximumStops() {
MatcherAssert.assertThat(
algorithmFactory.createCountPathsWithAtLeastAGivenNumberOfStops(A, B, 5),
isA(CountPathsWithAtLeastAGivenNumberOfStops.class));
}
@Test
public void createDepthFirstPathCounterExactStops() {
MatcherAssert.assertThat(
algorithmFactory.createCountPathsWithNumberOfStops(A, B, 5),
isA(CountPathsWithNumberOfStops.class));
}
@Test
public void createCycleCountAlgorithm() {
MatcherAssert.assertThat(algorithmFactory.createCycleCountAlgorithm(), isA(CycleCount.class));
}
@Test
public void createShortestPathAlgorithm() {
MatcherAssert.assertThat(
algorithmFactory.createShortestPathAlgorithm(A, B), isA(ShortestPath.class));
}
