Ejemplo n.º 1
0
Archivo: search.cpp Proyecto: ombt/ombt
int
BreadthFirstSearch(List<NodeType> &startstatelist, 
		BinaryTree_AVL<DataType> &startlist, 
		BinaryTree_AVL<DataType> &otherlist)
{
	int status;

	// track all states created
	BinaryTree_AVL<String> allstates;

	// create open priority queue
	List<Proxy<NodeType> > openpq;

	// copy list of start states
	int nodedepth = 1;
	ListIterator<NodeType> startstateIter(startstatelist);
	for ( ; !startstateIter.done(); startstateIter++)
	{
		// copy start state
		Proxy<NodeType> pstart(startstateIter());

		// set start node depth
		pstart->setDepth(nodedepth);

		// insert start state into open queue
		if ((status = openpq.insertAtEnd(pstart)) != OK)
		{
			ERRORD("insertAtFront() failed.", status, errno);
			return(status);
		}
	}

	// start search loop
	for (Proxy<NodeType> pnode; ! openpq.isEmpty(); )
	{
		// remove next node from priority open queue
		if ((status = openpq.removeAtFront(pnode)) != OK)
		{
			ERRORD("removeAtFront() failed.", status, errno);
			return(status);
		}

		// set current node depth
		nodedepth = pnode->getDepth();

		// check if we have a goal node or not
		status = pnode->isGoal(startlist, otherlist);
		switch (status)
		{
		case OK:
			break;

		case NOMATCH:
		case MAXDEPTHEXCEEDED:
			// no clauses were generated. skip further
			// processing of this node.
			continue;

		case VALID:
			// goal node, print solution
			PrintSolution(pnode);
			PrintRenameVariables(pnode);

			// check if more than one solutions is required
			solutionsfound += 1;
			statistics[SolutionsFound] += 1;
			totalstatistics[TotalSolutionsFound] += 1;
			if (solutionsfound >= solutionsrequired)
				return(VALID);
			continue;

		case MAXCLAUSEEXCEEDED:
			// check if any solutions were found
			if (solutionsfound > 0)
				return(VALID);
			else
				return(NOTPROVEN);

		default:
			// some type of error
			ERRORD("isGoal() failed.", status, errno);
			return(status);
		}

		// generate the children of the current node
		if ((status = pnode->expand(startlist, otherlist)) != OK)
		{
			ERRORD("expand() failed.", status, errno);
			return(status);
		}

		// set up links to parent and calculate the heuristic value
		ListIterator<Proxy<NodeType> > 
			childrenIter(*pnode->getChildren());
		for ( ; !childrenIter.done(); childrenIter++)
		{
			// pointer to child
			Proxy<NodeType> pchild(childrenIter());

			// set up link to parent
			if (reporttype == ReportParent ||
			    reporttype == ReportBoth)
				pchild->setParent(pnode);

			// insert into queue
			if (!bfswithchecks)
			{
				pchild->setDepth(nodedepth+1);
				if ((status = openpq.insertAtEnd(
					pchild)) != OK)
				{
					ERRORD("insertAtEnd() failed.", 
						status, errno);
					return(status);
				}
			}
			else
			{
				statistics[RedundantClauseTestsAttempted] += 1;
				totalstatistics[TotalRedundantClauseTestsAttempted] += 1;
				String newnode(pchild->getNormalizedClauses());
				if (allstates.retrieve(newnode) == NOMATCH)
				{
					pchild->setDepth(nodedepth+1);
					if ((status = openpq.insertAtEnd(
							pchild)) != OK)
					{
						ERRORD("insertAtEnd() failed.", 
							status, errno);
						return(status);
					}
				}
				else
				{
					statistics[RedundantClausesRejected] += 1;
					totalstatistics[TotalRedundantClausesRejected] += 1;
				}
			}
		}

		if (bfswithchecks)
		{
			if (allstates.insert(pnode->getNormalizedClauses()) != OK)
			{
				ERRORD("insert() failed.", status, errno);
				return(status);
			}
		}
	}

	// check if any solutions were found
	if (solutionsfound > 0)
		return(VALID);
	else
		return(NOTPROVEN);
}
Ejemplo n.º 2
0
Archivo: search.cpp Proyecto: ombt/ombt
int
dfs(Proxy<NodeType> &pnode, int &threshold, int &next_threshold, 
	BinaryTree_AVL<DataType> &startlist, 
	BinaryTree_AVL<DataType> &otherlist)
{
	int status;

	// expand the current node's children
	if ((status = pnode->expand(startlist, otherlist)) != OK)
	{
		// some type of error
		ERRORD("expand() failed.", status, errno);
		return(status);
	}

	// scan children for goal nodes 
	ListIterator<Proxy<NodeType> > childrenIter(*pnode->getChildren());
	for ( ; !childrenIter.done(); childrenIter++)
	{
		// get pointer to child
		Proxy<NodeType> pchild(childrenIter());

		// set up link to parent
		if (reporttype == ReportParent ||
		    reporttype == ReportBoth)
			pchild->setParent(pnode);

		// calculate the heuristic value
		if ((status = pchild->heuristic(startlist, otherlist)) != OK)
		{
			ERRORD("heuristic() failed.", status, errno);
			return(status);
		}

		// check if we have a goal node
		status = pchild->isGoal(startlist, otherlist);
		switch (status)
		{
		case OK:
			break;

		case NOMATCH:
		case MAXDEPTHEXCEEDED:
			continue;

		case MAXCLAUSEEXCEEDED:
			return(status);

		case VALID:
			// goal node, print solution
			PrintSolution(pnode);
			PrintRenameVariables(pnode);
			return(VALID);

		default:
			// some type of error
			ERRORD("isGoal() failed.", status, errno);
			return(status);
		}

		// check if we continue, is threshold exceeded?
		int childcost = pchild->getFvalue();
		if (childcost <= threshold)
		{
			// continue depth-first search
			status = dfs(pchild, threshold, next_threshold,
					startlist, otherlist);
			switch (status)
			{
			case OK:
			case NOMATCH:
			case MAXDEPTHEXCEEDED:
			case NOTPROVEN:
				break;
	
			case MAXCLAUSEEXCEEDED:
				return(MAXCLAUSEEXCEEDED);

			case VALID:
				// goal node, print solution
				return(VALID);

			default:
				// some type of error
				ERRORD("dfs() failed.", status, errno);
				return(status);
			}
		}
		else if (childcost < next_threshold)
		{
			next_threshold = childcost;
		}
	}

	// goal was not not proven
	return(NOTPROVEN);
}
Ejemplo n.º 3
0
Archivo: search.cpp Proyecto: ombt/ombt
int
DepthFirstHillClimbSearch(List<NodeType> &startstatelist, 
		BinaryTree_AVL<DataType> &startlist, 
		BinaryTree_AVL<DataType> &otherlist)
{
	int status;

	// track all states created
	BinaryTree_AVL<String> allstates;

	// create open stack for traversal
	List<Proxy<NodeType> > openstack;

	// keep track of current path here instead of 
	// using parent pointers. parent pointers cause
	// cycles and reference-counted pointers cannot
	// deal with cyclic data structures. they cause
	// major memory leaks.
	//
	int nodedepth = 1;
	List<Proxy<NodeType> > currentpath;

	// copy list of start states
	ListIterator<NodeType> startstateIter(startstatelist);
	for ( ; !startstateIter.done(); startstateIter++)
	{
		// copy start state
		Proxy<NodeType> pstart(startstateIter());

		// calculate the heuristic value for this node
		if ((status = pstart->heuristic(startlist, otherlist)) != OK)
		{
			ERRORD("heuristic() failed.", status, errno);
			return(status);
		}

		// set start node depth
		pstart->setDepth(nodedepth);

		// insert start state into open queue
		if ((status = openstack.insertOrdered(pstart)) != OK)
		{
			ERRORD("insertOrdered() failed.", status, errno);
			return(status);
		}
	}

	// children priority queue
	List<Proxy<NodeType> > childpq;
	
	// start search loop
	int olddepth = nodedepth;
	Proxy<NodeType> pchild;
	for (Proxy<NodeType> pnode; ! openstack.isEmpty(); )
	{
		// remove next node from priority open queue
		if ((status = openstack.removeAtFront(pnode)) != OK)
		{
			ERRORD("removeAtFront() failed.", status, errno);
			return(status);
		}

		// check if we have a goal node or not
		status = pnode->isGoal(startlist, otherlist);
		switch (status)
		{
		case OK:
			// update current path
			if ((status = updatepath(nodedepth, 
				olddepth, pnode, currentpath)) != OK)
				return(status);
			break;

		case NOMATCH:
		case MAXDEPTHEXCEEDED:
			// no clauses were generated. skip further
			// processing of this node.
			continue;

		case VALID:
			// update current path
			if ((status = updatepath(nodedepth, 
				olddepth, pnode, currentpath)) != OK)
				return(status);

			// goal node, print solution
			PrintSolution(pnode);
			PrintSolution(currentpath);
			PrintRenameVariables(pnode);

			// check if more than one solutions is required
			solutionsfound += 1;
			statistics[SolutionsFound] += 1;
			totalstatistics[TotalSolutionsFound] += 1;
			if (solutionsfound >= solutionsrequired)
				return(VALID);
			continue;

		case MAXCLAUSEEXCEEDED:
			// check if any solutions were found
			if (solutionsfound > 0)
				return(VALID);
			else
				return(NOTPROVEN);

		default:
			// some type of error
			ERRORD("isGoal() failed.", status, errno);
			return(status);
		}

		// generate the children of the current node
		if ((status = pnode->expand(startlist, otherlist)) != OK)
		{
			ERRORD("expand() failed.", status, errno);
			return(status);
		}

		// clear children priority queue
		childpq.clear();

		// set up links to parent and calculate the heuristic value
		ListIterator<Proxy<NodeType> > 
			childrenIter(*pnode->getChildren());
		for ( ; !childrenIter.done(); childrenIter++)
		{
			// pointer to child
			pchild = childrenIter();

			// set up link to parent
			if (reporttype == ReportParent ||
			    reporttype == ReportBoth)
				pchild->setParent(pnode);

			// calculate the heuristic value
			if ((status = pchild->heuristic(
				startlist, otherlist)) != OK)
			{
				ERRORD("heuristic() failed.", status, errno);
				return(status);
			}

			// insert child into a priority queue to order
			pchild->setDepth(nodedepth+1);
			if ((status = childpq.insertOrdered(pchild)) != OK)
			{
				ERRORD("insertOrdered() failed.", 
					status, errno);
				return(status);
			}
		}

		// insert nodes into stack ordered by heuristic value
		while (!childpq.isEmpty())
		{
			// remove next node from priority open queue
			if ((status = childpq.removeAtEnd(pchild)) != OK)
			{
				ERRORD("removeAtEnd() failed.", 
					status, errno);
				return(status);
			}

			// insert node into a stack
			if (!bfswithchecks)
			{
				if ((status = openstack.insertAtFront(
					pchild)) != OK)
				{
					ERRORD("insertAtFront() failed.", 
						status, errno);
					return(status);
				}
			}
			else
			{
				statistics[RedundantClauseTestsAttempted] += 1;
				totalstatistics[TotalRedundantClauseTestsAttempted] += 1;
				String newnode(pchild->getNormalizedClauses());
				if (allstates.retrieve(newnode) == NOMATCH)
				{
					if ((status = openstack.insertAtFront(
							pchild)) != OK)
					{
						ERRORD("insertAtFront() failed.", 
							status, errno);
						return(status);
					}
				}
				else
				{
					statistics[RedundantClausesRejected] += 1;
					totalstatistics[TotalRedundantClausesRejected] += 1;
				}
			}
		}

		// children are now in the queue. release pointers to
		// children stored in node.
		//
		pnode->getChildren()->clear();
		if (bfswithchecks)
		{
			if (allstates.insert(pnode->getNormalizedClauses()) != OK)
			{
				ERRORD("insert() failed.", status, errno);
				return(status);
			}
		}
	}

	// check if any solutions were found
	if (solutionsfound > 0)
		return(VALID);
	else
		return(NOTPROVEN);
}