>(
+ components, factory, 1.0);
+ // instantiate algorithm
+ return new ADStarForward(components.getBegin(), Collections.singleton(components.getGoal()), expander);
+ }
+}
diff --git a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/IDAStar.java b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/IDAStar.java
old mode 100644
new mode 100755
index 22f61a7..24f1483
--- a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/IDAStar.java
+++ b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/IDAStar.java
@@ -22,8 +22,6 @@
import es.usc.citius.hipster.model.HeuristicNode;
import es.usc.citius.hipster.model.function.NodeExpander;
-import java.util.Stack;
-
/**
*
* Implementation of the IDA* algorithm. Similar to Iterative DFS but using heuristics to limit
@@ -40,38 +38,18 @@
* @param type of the heuristic search node.
*
* @author Pablo Rodríguez Mier <pablo.rodriguez.mier@usc.es>
+ * @author Jennnnyz
+ *
*/
-public class IDAStar,N extends HeuristicNode> extends Algorithm {
-
- protected final N initialNode;
- protected final NodeExpander expander;
-
+public class IDAStar,N extends HeuristicNode> extends DepthFirstSearch {
+ /**
+ *
+ * @param initialNode
+ * @param expander
+ */
public IDAStar(N initialNode, NodeExpander expander) {
- this.initialNode = initialNode;
- this.expander = expander;
- }
-
- private class StackFrameNode {
- // Iterable used to compute neighbors of the current node
- java.util.Iterator successors;
- // Current search node
- N node;
- // Boolean value to check if the node is still unvisited
- // in the stack or not
- boolean visited = false;
- // Boolean to indicate that this node is fully processed
- boolean processed = false;
-
- StackFrameNode(java.util.Iterator successors, N node) {
- this.successors = successors;
- this.node = node;
- }
-
- StackFrameNode(N node) {
- this.node = node;
- this.successors = expander.expand(node).iterator();
- }
+ super(initialNode, expander);
}
/**
@@ -80,51 +58,17 @@ private class StackFrameNode {
* call to {@code iterator.next()} returns the next state after performing
* backtracking.
*/
- public class Iterator implements java.util.Iterator {
- protected Stack stack = new Stack();
+
+ public class Iterator extends DepthFirstSearch.Iterator {
protected C fLimit;
protected C minfLimit;
protected int reinitialization = 0;
- protected StackFrameNode next;
protected Iterator(){
// Set initial bound
+ super();
fLimit = initialNode.getEstimation();
minfLimit = null;
- this.stack.add(new StackFrameNode(initialNode));
- }
-
- @Override
- public boolean hasNext() {
- if (next == null){
- // Compute next
- next = nextUnvisited();
- if (next == null) return false;
- }
- return true;
- }
-
- @Override
- public N next(){
- if (next != null){
- StackFrameNode e = next;
- // Compute the next one
- next = null;
- // Return current node
- return e.node;
- }
- // Compute next
- StackFrameNode nextUnvisited = nextUnvisited();
- if (nextUnvisited!=null){
- return nextUnvisited.node;
- }
- return null;
-
- }
-
- @Override
- public void remove() {
- throw new UnsupportedOperationException();
}
protected void updateMinFLimit(C currentFLimit){
@@ -137,6 +81,7 @@ protected void updateMinFLimit(C currentFLimit){
}
}
+ @Override
protected StackFrameNode nextUnvisited(){
StackFrameNode nextNode;
do {
@@ -148,7 +93,7 @@ protected StackFrameNode nextUnvisited(){
fLimit = minfLimit;
reinitialization++;
minfLimit = null;
- stack.add(new StackFrameNode(initialNode));
+ super.getStack().addLast(new StackFrameNode(initialNode));
nextNode = processNextNode();
}
}
@@ -160,7 +105,7 @@ protected StackFrameNode nextUnvisited(){
return nextNode;
}
-
+ @Override
protected StackFrameNode processNextNode(){
// Get and process the current node. Cases:
// 1 - empty stack, return null
@@ -172,27 +117,27 @@ protected StackFrameNode processNextNode(){
// mark as visited, pop and return.
// 1- If the stack is empty, change fLimit and reinitialize the search
- if (stack.isEmpty()) return null;
+ if (super.getStack().isEmpty()) return null;
// Take current node in the stack but do not remove
- StackFrameNode current = stack.peek();
+ StackFrameNode current = (StackFrameNode) super.stack.peekLast();
// 2 - Check if the current node exceeds the limit bound
- C fCurrent = current.node.getScore();
+ C fCurrent = current.getNode().getScore();
if (fCurrent.compareTo(fLimit)>0){
// Current node exceeds the limit bound, update minfLimit, pop and skip.
updateMinFLimit(fCurrent);
// Remove from stack
current.processed = true;
- return stack.pop();
+ return (StackFrameNode) super.getStack().removeLast();
}
// Find a successor
- if (current.successors.hasNext()){
+ if (current.getSuccessors().hasNext()){
// 3 - Node has at least one neighbor
- N successor = current.successors.next();
+ N successor = current.getSuccessors().next();
// push the node
- stack.add(new StackFrameNode(successor));
+ super.getStack().addLast(new StackFrameNode(successor));
return current;
} else {
@@ -200,18 +145,10 @@ protected StackFrameNode processNextNode(){
if (current.visited){
current.processed = true;
}
- return stack.pop();
+ return (StackFrameNode) super.getStack().removeLast();
}
}
- public Stack getStack() {
- return stack;
- }
-
- public void setStack(Stack stack) {
- this.stack = stack;
- }
-
public C getfLimit() {
return fLimit;
}
@@ -235,14 +172,6 @@ public int getReinitialization() {
public void setReinitialization(int reinitialization) {
this.reinitialization = reinitialization;
}
-
- public StackFrameNode getNext() {
- return next;
- }
-
- public void setNext(StackFrameNode next) {
- this.next = next;
- }
}
@Override
diff --git a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/MultiobjectiveLS.java b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/MultiobjectiveLS.java
old mode 100644
new mode 100755
index a7d5247..bd36c7b
--- a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/MultiobjectiveLS.java
+++ b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/MultiobjectiveLS.java
@@ -56,7 +56,7 @@ public MultiobjectiveLS(N initialNode, NodeExpander nodeExpander) {
public class Iterator implements java.util.Iterator {
protected Queue queue = new LinkedList();
public Map> nonDominated;
- //auxiliar variable which stores an empty list to avoid nullable values in code
+ //auxiliary variable which stores an empty list to avoid nullable values in code
private final Collection EMPTYLIST = new ArrayList();
protected Iterator(){
diff --git a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/NegativeCycleException.java b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/NegativeCycleException.java
new file mode 100644
index 0000000..b012eb5
--- /dev/null
+++ b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/NegativeCycleException.java
@@ -0,0 +1,10 @@
+package es.usc.citius.hipster.algorithm;
+
+
+public class NegativeCycleException extends RuntimeException {
+ private static final String message = "Existence of a negative cycle detected";
+
+ public NegativeCycleException() {
+ super(message);
+ }
+}
diff --git a/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/localsearch/AnnealingSearch.java b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/localsearch/AnnealingSearch.java
new file mode 100644
index 0000000..cb805ea
--- /dev/null
+++ b/hipster-core/src/main/java/es/usc/citius/hipster/algorithm/localsearch/AnnealingSearch.java
@@ -0,0 +1,203 @@
+package es.usc.citius.hipster.algorithm.localsearch;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Random;
+
+import es.usc.citius.hipster.algorithm.Algorithm;
+import es.usc.citius.hipster.model.HeuristicNode;
+import es.usc.citius.hipster.model.Node;
+import es.usc.citius.hipster.model.function.NodeExpander;
+
+/**
+ * Implementation of the simulated annealing search that is a probabilistic
+ * technique for approximating the global optimum of a given function. It starts
+ * the exploration from a random point as a global optimum and selects one of
+ * its neighbors with a neighboring function. The neighbor will become the new
+ * optimum if its associated cost is lower or if the acceptance probability
+ * function returns a probability greater than a random number. The probability
+ * function takes as an input the cost of the current selected node, the cost of
+ * its randomly selected neighbour and the current temperature. The higher the
+ * cost of the neighbour is or the lower the temperature is, the more unlikely
+ * it is that the neighbour becomes the new optimum. The process continues until
+ * the temperature is below a given threshold. The temperature decreases at each
+ * iteration according to a geometric cooling schedule that has two parameters
+ * alpha and temperature min. The main idea of this algorithm is to avoid to be
+ * "trapped" in a bad local optimum by exploring more deeply the state space by
+ * looking at states whose cost is not optimum but that may have interesting
+ * neighbours. A user can adjusted the algorithm by tuning the alpha coefficient
+ * (default 0.9) or the min temperature (0.00001) or by providing his own
+ * implementation of the acceptance probability function (default: exp((old
+ * score - new score) / current temperature)) or the neighbouring function
+ * (random selection by default). Note: costs are Double in this implementation
+ * and have no type parameters.
+ *
+ * see in
+ * Wikipedia and in
+ * annealing search for more details.
+ *
+ * @param
+ * class defining the action
+ * @param
+ * class defining the state
+ * @param
+ * class defining the cost, must implement
+ * {@link java.lang.Comparable}
+ * @param
+ * type of the nodes
+ *
+ * @author Christophe Moins <
+ * christophe.moins@yahoo.fr
+ * >
+ */
+public class AnnealingSearch> extends Algorithm {
+
+ static final private Double DEFAULT_ALPHA = 0.9;
+ static final private Double DEFAULT_MIN_TEMP = 0.00001;
+ static final private Double START_TEMP = 1.;
+
+ private N initialNode;
+ private Double alpha;
+ private Double minTemp;
+ private AcceptanceProbability acceptanceProbability;
+ private SuccessorFinder successorFinder;
+ // expander to find all the successors of a given node.
+ private NodeExpander nodeExpander;
+
+ public AnnealingSearch(N initialNode, NodeExpander nodeExpander, Double alpha, Double minTemp,
+ AcceptanceProbability acceptanceProbability, SuccessorFinder successorFinder) {
+ if (initialNode == null) {
+ throw new IllegalArgumentException("Provide a valid initial node");
+ }
+ this.initialNode = initialNode;
+ if (nodeExpander == null) {
+ throw new IllegalArgumentException("Provide a valid node expander");
+ }
+ this.nodeExpander = nodeExpander;
+ if (alpha != null) {
+ if ((alpha <= 0.) || (alpha >= 1.0)) {
+ throw new IllegalArgumentException("alpha must be between 0. and 1.");
+ }
+ this.alpha = alpha;
+ } else {
+ this.alpha = DEFAULT_ALPHA;
+ }
+ if (minTemp != null) {
+ if ((minTemp < 0.) || (minTemp > 1.)) {
+ throw new IllegalArgumentException("Minimum temperature must be between 0. and 1.");
+ }
+ this.minTemp = minTemp;
+ } else {
+ this.minTemp = DEFAULT_MIN_TEMP;
+ }
+ if (acceptanceProbability != null) {
+ this.acceptanceProbability = acceptanceProbability;
+ } else {
+ this.acceptanceProbability = new AcceptanceProbability() {
+ @Override
+ public Double compute(Double oldScore, Double newScore, Double temp) {
+ return (newScore < oldScore ? 1 : Math.exp((oldScore - newScore) / temp));
+ }
+ };
+ }
+ if (successorFinder != null) {
+ this.successorFinder = successorFinder;
+ } else {
+ // default implementation of the successor: picks up a successor
+ // randomly
+ this.successorFinder = new SuccessorFinder() {
+ @Override
+ public N estimate(N node, NodeExpander nodeExpander) {
+ List successors = new ArrayList<>();
+ // find a random successor
+ for (N successor : nodeExpander.expand(node)) {
+ successors.add(successor);
+ }
+ Random randIndGen = new Random();
+ return successors.get(Math.abs(randIndGen.nextInt()) % successors.size());
+ }
+ };
+ }
+ }
+
+ @Override
+ public ASIterator iterator() {
+ // TODO Auto-generated method stub
+ return new ASIterator();
+ }
+
+ public class ASIterator implements Iterator {
+
+ private Queue queue = new LinkedList();
+ private Double bestScore = null;
+ private Double curTemp = START_TEMP;
+
+ private ASIterator() {
+ bestScore = initialNode.getEstimation();
+ queue.add(initialNode);
+ }
+
+ @Override
+ public boolean hasNext() {
+ return !queue.isEmpty();
+ }
+
+ @Override
+ public N next() {
+ N currentNode = this.queue.poll();
+ if (curTemp > minTemp) {
+ N newNode = null;
+ // we add a loop to increase the effect of a change of alpha.
+ for (int i = 0; i < 100; i++) {
+ N randSuccessor = successorFinder.estimate(currentNode, nodeExpander);
+ Double score = randSuccessor.getScore();
+ if (acceptanceProbability.compute(bestScore, score, curTemp) > Math.random()) {
+ newNode = randSuccessor;
+ bestScore = score;
+ }
+ }
+ if (newNode != null) {
+ queue.add(newNode);
+ } else {
+ queue.add(currentNode);
+ }
+ curTemp *= alpha;
+ }
+ return currentNode;
+ }
+
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+
+ }
+ }
+
+ /**
+ * Interface to compute the acceptance probability. If the new score is less
+ * than the old score, 1 will be returned so that the node is selected.
+ * Otherwise, we compute a probability that will decrease when the newScore
+ * or the temperature increase.
+ *
+ */
+
+ public interface AcceptanceProbability {
+ Double compute(Double oldScore, Double newScore, Double temp);
+ }
+
+ /**
+ * Interface to find the successor of a node.
+ *
+ * @param
+ */
+ public interface SuccessorFinder> {
+ /**
+ * @param Node
+ * @return the successor of a node.
+ */
+ N estimate(N node, NodeExpander nodeExpander);
+ }
+}
diff --git a/hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphBuilder.java b/hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphBuilder.java
index 9a9476e..540246c 100644
--- a/hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphBuilder.java
+++ b/hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphBuilder.java
@@ -44,6 +44,48 @@ private Connection(V vertex1, V vertex2, E edge) {
this.vertex2 = vertex2;
this.edge = edge;
}
+
+ private Connection(V vertex1, V vertex2) {
+ this.vertex1 = vertex1;
+ this.vertex2 = vertex2;
+ this.edge = (E) new Object();
+ }
+
+ public V getVertex1() {
+ return vertex1;
+ }
+
+ public void setVertex1(V vertex1) {
+ this.vertex1 = vertex1;
+ }
+
+ public V getVertex2() {
+ return vertex2;
+ }
+
+ public void setVertex2(V vertex2) {
+ this.vertex2 = vertex2;
+ }
+
+ public E getEdge() {
+ return edge;
+ }
+
+ public void setEdge(E edge) {
+ this.edge = edge;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ Connection that = (Connection) o;
+
+ if (!vertex1.equals(that.vertex1)) return false;
+ return vertex2.equals(that.vertex2);
+
+ }
}
private List connections = new LinkedList();
@@ -54,11 +96,16 @@ public static