Example #1
0
 /**
  * Constructs a node with the specified state, parent, action, and path
  * cost.
  *
  * @param state
  *            the state in the state space to which the node corresponds.
  * @param parent
  *            the node in the search tree that generated the node.
  * @param action
  *            the action that was applied to the parent to generate the
  *            node.
  * @param pathCost
  *            full pathCost from the root node to here, typically
  *            the root's path costs plus the step costs for executing
  *            the the specified action.
  */
 public Node(System.Object state, Node parent, Action action, double stepCost)
     : this(state)
 {
     this.parent = parent;
     this.action = action;
     this.pathCost = parent.pathCost + stepCost;
 }
Example #2
0
 /**
  * Inserts the node at the tail of the frontier if the corresponding state
  * was not yet explored.
  */
 protected override void addToFrontier(Node node)
 {
     if (!explored.Contains(node.getState()))
     {
     frontier.Enqueue(node);
     updateMetrics(frontier.Count);
     }
 }
Example #3
0
 /**
  * Calls the goal test of the problem and - if the goal test is effectively
  * a {@link SolutionChecker} - additionally checks, whether the solution is
  * acceptable. Solution checkers can be used to analyze several or all
  * solutions with only one search run.
  */
 public static bool isGoalState(Problem p, Node n)
 {
     bool isGoal = false;
     GoalTest gt = p.getGoalTest();
     if (gt.isGoalState(n.getState()))
     {
         if (gt is SolutionChecker)
         {
             isGoal = ((SolutionChecker)gt).isAcceptableSolution(
                     getSequenceOfActions(n), n.getState());
         }
         else
         {
             isGoal = true;
         }
     }
     return isGoal;
 }
Example #4
0
        /**
         * Returns the children obtained from expanding the specified node in the
         * specified problem.
         *
         * @param node
         *            the node to expand
         * @param problem
         *            the problem the specified node is within.
         *
         * @return the children obtained from expanding the specified node in the
         *         specified problem.
         */
        public List<Node> expand(Node node, Problem problem)
        {
            List<Node> successors = new List<Node>();

            ActionsFunction actionsFunction = problem.getActionsFunction();
            ResultFunction resultFunction = problem.getResultFunction();
            StepCostFunction stepCostFunction = problem.getStepCostFunction();

            foreach (Action action in actionsFunction.actions(node.getState()))
            {
                System.Object successorState = resultFunction.result(node.getState(), action);

                double stepCost = stepCostFunction.c(node.getState(), action, successorState);
                successors.Add(createNode(successorState, node, action, stepCost));
            }

            foreach (NodeListener listener in nodeListeners)
            {
                listener.onNodeExpanded(node);
            }
            counter++;
            return successors;
        }
Example #5
0
        /**
         * Returns the list of actions corresponding to the complete path to the
         * given node or NoOp if path length is one.
         */
        public static List<Action> getSequenceOfActions(Node node)
        {
            List<Node> nodes = node.getPathFromRoot();
            List<Action> actions = new List<Action>();

            if(nodes.Count == 1)
            {
                // I'm at the root node, this indicates I started at the
                // Goal node, therefore just return a NoOp
                actions.Add(NoOpAction.NO_OP);
            }
            else
            {
                // ignore the root node this has no action
                // hence index starts from 1 not zero
                for (int i = 1; i < nodes.Count; i++)
                {
                    Node node_temp = nodes[i];
                    actions.Add(node_temp.getAction());
                }
            }
            return actions;
        }
Example #6
0
 /**
  * Computes the path cost for getting from the root node state via the
  * parent node state to the specified state, creates a new node for the
  * specified state, adds it as child of the provided parent, and returns it.
  */
 public Node createNode(System.Object state, Node parent, Action action, double stepCost)
 {
     return new Node(state, parent, action, parent.getPathCost() + stepCost);
 }
Example #7
0
 /**
  * Inserts the node at the tail of the frontier.
  */
 protected override void addToFrontier(Node node)
 {
     frontier.Enqueue(node);
     updateMetrics(frontier.Count);
 }
 /**
  *
  * @param n
  * @return the cost, traditionally denoted by g(n), of the path from the
  *         initial state to the node, as indicated by the parent pointers.
  */
 public double g(Node n)
 {
     return n.getPathCost();
 }