/home/coin/svn-release/OS-2.8.4/OS/src/OSSolverInterfaces/OSRunSolver.cpp

Go to the documentation of this file.

/* $Id: OSRunSolver.cpp 4263 2011-09-09 20:19:26Z Martin $ */
#include "OSRunSolver.h"
#include "OSCoinSolver.h"
#include "OSResult.h"
#include "OSrLWriter.h"
#include "OSInstance.h"
#include "OSOption.h"
#include "OSConfig.h"
#include "OSDefaultSolver.h"
#include "OSErrorClass.h"

#ifdef COIN_HAS_KNITRO
#include "OSKnitroSolver.h"
#endif

#ifdef COIN_HAS_LINDO
#include "OSLindoSolver.h"
#endif

#ifdef COIN_HAS_IPOPT
# ifndef COIN_HAS_ASL
#  include "OSIpoptSolver.h"
#  undef COIN_HAS_ASL
# else
#  include "OSIpoptSolver.h"
# endif
#endif

#ifdef COIN_HAS_BONMIN
#include "OSBonminSolver.h"
#endif

#ifdef COIN_HAS_COUENNE
#include "OSCouenneSolver.h"
#endif

#include <stdio.h>
#include <map>


using std::cout;
using std::endl;
using std::ostringstream;
using std::string;
using std::map;


std::string runSolver(std::string solverName, std::string osol,
                        OSInstance *osinstance)
{
    DefaultSolver *solverType = NULL;
    solverType = selectSolver(solverName, osinstance);
    if (solverType == NULL)  
        throw ErrorClass("No appropriate solver found");
    //std::cout << "SOLVER NAME = " << solverName << std::endl;

    solverType->osinstance = osinstance;
    solverType->osol = osol;
    solverType->buildSolverInstance();
    solverType->setSolverOptions();
    solverType->solve();
    std::string resultString = solverType->osrl;
    if (solverType != NULL)
        delete solverType;
    solverType = NULL;
    return resultString;
} //runSolver (osinstance, osol)      


std::string runSolver(std::string solverName, OSOption* osoption,
                        OSInstance *osinstance)
{
    DefaultSolver *solverType = NULL;
    solverType = selectSolver(solverName, osinstance);
    if (solverType == NULL)  
        throw ErrorClass("No appropriate solver found");
    //std::cout << "SOLVER NAME = " << solverName << std::endl;

    solverType->osinstance = osinstance;
    solverType->osoption = osoption;
    solverType->buildSolverInstance();
    solverType->setSolverOptions();
    solverType->solve();
    std::string resultString = solverType->osrl;
    if (solverType != NULL)
        delete solverType;
    solverType = NULL;
    return resultString;
} //runSolver (osinstance, osoption)



std::string runSolver(std::string solverName, std::string osol,
                        std::string osil)
{
    OSInstance* osinstance = new OSInstance();
    OSiLReader* osilreader = new OSiLReader();

    DefaultSolver *solverType = NULL;

    osinstance = osilreader->readOSiL(osil);

    solverType = selectSolver(solverName, osinstance);
    if (solverType == NULL)  
        throw ErrorClass("No appropriate solver found");
    //std::cout << "SOLVER NAME = " << solverName << std::endl;

    solverType->osinstance = osinstance;
    solverType->osol = osol;
    solverType->buildSolverInstance();
    solverType->setSolverOptions();
    solverType->solve();
    std::string resultString = solverType->osrl;
    if (solverType != NULL)
        delete solverType;
    solverType = NULL;
    delete osilreader;
    osilreader = NULL;
    return resultString;
} //runSolver (osil, osol)      


std::string runSolver(std::string solverName, OSOption* osoption,
                        std::string osil)
{
    OSInstance* osinstance = new OSInstance();
    OSiLReader* osilreader = new OSiLReader();

    DefaultSolver *solverType = NULL;

    osinstance = osilreader->readOSiL(osil);

    solverType = selectSolver(solverName, osinstance);
    if (solverType == NULL)  
        throw ErrorClass("No appropriate solver found");
    //std::cout << "SOLVER NAME = " << solverName << std::endl;

    solverType->osinstance = osinstance;
    solverType->osoption = osoption;
    solverType->buildSolverInstance();
    solverType->setSolverOptions();
    solverType->solve();
    std::string resultString = solverType->osrl;
    if (solverType != NULL)
        delete solverType;
    solverType = NULL;
    delete osilreader;
    osilreader = NULL;
    return resultString;
} //runSolver (osil, osoption)



DefaultSolver* selectSolver(std::string solverName, OSInstance *osinstance)
{
    DefaultSolver *solverType = NULL;
    try
    {
        if (solverName == "")  // must determine the default solver
        {
            if (osinstance == NULL)
                throw ErrorClass(
                    "there was a NULL instance sent to buildSolver");
            //see if we have an integer program
            if (osinstance->getNumberOfIntegerVariables()
                    + osinstance->getNumberOfBinaryVariables() > 0)  //we have an integer program
            {
                if ((osinstance->getNumberOfNonlinearExpressions() > 0)
                        || (osinstance->getNumberOfQuadraticTerms() > 0))   // we are nonlinear and integer
                {
                    solverName = "bonmin";
                }
                else    //we are linear integer
                {
                    solverName = "cbc";
                }
            }
            else    // we have a continuous problem
            {
                if ((osinstance->getNumberOfNonlinearExpressions() > 0)
                        || (osinstance->getNumberOfQuadraticTerms() > 0))   // we are nonlinear and continuous
                {
                    solverName = "ipopt";
                }
                else    //we have linear program
                {
                    solverName = "clp";
                }
            }
        }//end of if solverName == ""

        //now build the solver through its constructor

        if (solverName.find("ipopt") != std::string::npos)
        {
            // we are requesting the Ipopt solver
#ifdef COIN_HAS_IPOPT
            solverType = new IpoptSolver();
            solverType->sSolverName = "ipopt";
#else
            throw ErrorClass("the Ipopt solver requested is not present");
#endif                
        }

        else if (solverName.find("lindo") != std::string::npos)
        {
            // we are requesting the Lindo solver
#ifdef COIN_HAS_LINDO
            solverType = new LindoSolver();
            solverType->sSolverName = "lindo";
#else
            throw ErrorClass( "the Lindo solver requested is not present");
#endif
        }

        else if (solverName.find("clp") != std::string::npos)
        {
            solverType = new CoinSolver();
            solverType->sSolverName = "clp";
        }

        else if (solverName.find("cplex") != std::string::npos)
        {
#ifdef COIN_HAS_CPX
            solverType = new CoinSolver();
            solverType->sSolverName = "cplex";
#else
            throw ErrorClass( "the Cplex solver requested is not present");
#endif
        }

        else if (solverName.find("glpk") != std::string::npos)
        {
#ifdef COIN_HAS_GLPK
            solverType = new CoinSolver();
            solverType->sSolverName = "glpk";
#else
            throw ErrorClass( "the GLPK solver requested is not present");
#endif
        }

        else if (solverName.find("dylp") != std::string::npos)
        {
#ifdef COIN_HAS_DYLP
            solverType = new CoinSolver();
            solverType->sSolverName = "dylp";
#else
            throw ErrorClass( "the DyLP solver requested is not present");
#endif
        }

        else if (solverName.find("symphony") != std::string::npos)
        {
#ifdef COIN_HAS_SYMPHONY
            solverType = new CoinSolver();
            solverType->sSolverName = "symphony";
#else
            throw ErrorClass( "the SYMPHONY solver requested is not present");
#endif
        }

        else if (solverName.find("knitro") != std::string::npos)
        {
#ifdef COIN_HAS_KNITRO
            solverType = new KnitroSolver();
            solverType->sSolverName = "knitro";
#else
            throw ErrorClass( "the Knitro solver requested is not present");
#endif
        }

        else if (solverName.find("vol") != std::string::npos)
        {
#ifdef COIN_HAS_VOL
            solverType = new CoinSolver();
            solverType->sSolverName = "vol";
#else
            throw ErrorClass( "the Vol solver requested is not present");
#endif
        }

        else if (solverName.find("bonmin") != std::string::npos)
        {
            // we are requesting the Bonmin solver
#ifdef COIN_HAS_BONMIN
            solverType = new BonminSolver();
            solverType->sSolverName = "bonmin";
#else
            throw ErrorClass( "the Bonmin solver requested is not present");
#endif
        }

        else if (solverName.find("couenne") != std::string::npos)
        {
             // we are requesting the Couenne solver
#ifdef COIN_HAS_COUENNE
            solverType = new CouenneSolver();
            solverType->sSolverName = "couenne";
#else
            throw ErrorClass( "the Couenne solver requested is not present");
#endif
        }

        else if (solverName.find("cbc") != std::string::npos)
        {
            solverType = new CoinSolver();
            solverType->sSolverName = "cbc";
        }

        else if (solverName.find("gurobi") != std::string::npos)
        {
#ifdef COIN_HAS_GRB
            solverType = new CoinSolver();
            solverType->sSolverName = "gurobi";
#else
            throw ErrorClass( "the Gurobi solver requested is not present");
#endif
        }

        else if (solverName.find("mosek") != std::string::npos)
        {
#ifdef COIN_HAS_MSK
            solverType = new CoinSolver();
            solverType->sSolverName = "mosek";
#else
            throw ErrorClass( "the Mosek solver requested is not present");
#endif
        }

        else if (solverName.find("soplex") != std::string::npos)
        {
#ifdef COIN_HAS_SOPLEX
            solverType = new CoinSolver();
            solverType->sSolverName = "soplex";
#else
            throw ErrorClass( "the Soplex solver requested is not present");
#endif
        }

        else if (solverName.find("xpress") != std::string::npos)
        {
#ifdef COIN_HAS_XPR
            solverType = new CoinSolver();
            solverType->sSolverName = "xpress";
#else
            throw ErrorClass( "the Xpress solver requested is not present");
#endif
        }

        else
        {
            std::string errorMessage;
            errorMessage = "solver " + solverName + " is not supported";
            throw ErrorClass( errorMessage );
        }

        return solverType;
    }

    catch (const ErrorClass& eclass)
    {
        if (solverType != NULL)
            delete solverType;
        solverType = NULL;
        throw eclass;
        return NULL;
    }

}//selectSolver

---