Solve.h

// Solve.h -- Various ugly global things used to solve problems w/ all algs.

/*
 * Copyright (C) 1998,2004-2005 Tudor Hulubei <tudor@hulubei.net>.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA,
 * 02111-1307, USA.
 */

// $Id: Solve_8h-source.html,v 1.1 2005/05/25 12:37:18 tudor Exp $

#ifndef _CSP_EXAMPLES_Solve_H
#define _CSP_EXAMPLES_Solve_H


#ifndef __cplusplus
#error Must use C++ for Solve.h.
#endif


#include <vector>
#include <string>


std::wostream& printBackdoor(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printBranchingAssignments(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printLastPathSelections(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printSolutionHeuristicMistakes(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printNodes(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printLeaves(
    std::wostream& wos,
    const csp::Decomposition& decomposition);
std::wostream& printBacktracks(
    std::wostream& wos,
    const csp::Decomposition& decomposition);

bool registerProblemSpecificHeuristics(
    csp::Decomposition& decomposition,
    const std::wstring& name,
    const std::vector<std::pair<double, double> >& intervals,
    double quality);

csp::Problem* clone(const csp::Problem& problem);

void solubleProblemFFA(const csp::Decomposition& decomposition);
void insolubleProblemFFA(const csp::Decomposition& decomposition);

bool problemIsWorthFFAing(bool hasSolutions);

typedef bool (*callback_type)(
    csp::Decomposition& decomposition,
    bool& countResources);

bool genericSolutionCallback(
    csp::Decomposition& decomposition,
    bool& countResources);

csp::Retraction* createRetraction(
    csp::Problem& problem,
    CommonOptions& options);

csp::Filter* createFilter(
    csp::Problem& problem,
    csp::Retraction& retraction,
    CommonOptions& options);

csp::Decomposition* createDecomposition(
    csp::Problem& problem,
    csp::Retraction& retraction,
    csp::Filter& filter,
    CommonOptions& options,
    int index = 0);

ulonglong regularSolver(
    CommonOptions& options,
    bool verbose,
    csp::Problem& problem,
    bool& timeLimitExceeded,
    bool& nodeLimitExceeded,
    callback_type solutionCallback = genericSolutionCallback,
    callback_type evaluationCallback = 0,
    callback_type refutationCallback = 0);

ulonglong driverSolver(
    CommonOptions& options,
    bool verbose,
    csp::Problem& problem,
    bool& timeLimitExceeded,
    bool& nodeLimitExceeded,
    callback_type solutionCallback = genericSolutionCallback);


#endif // _CSP_EXAMPLES_Solve_H

// Local Variables:
// mode: C++
// End:

---