/home/coin/SVN-release/OS-2.4.0/ApplicationTemplates/template/template.cpp

Go to the documentation of this file.
00001 /* $Id: template.cpp 2710 2009-06-10 21:13:43Z kmartin $ */
00017 //#include <cppad/cppad.hpp> 
00018 #include "OSConfig.h"
00019 #include "OSCoinSolver.h"
00020 #include "OSIpoptSolver.h"
00021 #include "OSResult.h" 
00022 #include "OSiLReader.h"        
00023 #include "OSiLWriter.h"   
00024 #include "OSrLReader.h"          
00025 #include "OSrLWriter.h"  
00026 #include "OSoLWriter.h"  
00027 #include "OSInstance.h"  
00028 #include "OSFileUtil.h"   
00029 #include "OSDefaultSolver.h"     
00030 #include "OShL.h"     
00031 #include "OSErrorClass.h"
00032 #include "OSmps2osil.h"   
00033 #include "OSBase64.h"
00034 #include "OSErrorClass.h"
00035 #include "OSMathUtil.h"
00036 #include "CoinFinite.hpp"
00037 
00038 #include "ClpSimplex.hpp"
00039 #include "ClpSolve.hpp"
00040 #include "CbcOrClpParam.hpp"
00041 #include "ClpInterior.hpp"
00042 #include "ClpCholeskyBase.hpp"
00043 #include "ClpQuadraticObjective.hpp"
00044 
00045 #include<iostream> 
00046 #include <ostream>
00047 #include <sstream>
00048 #include <streambuf>
00049 
00050 #include<map>
00051 #include<stdio.h>
00052  
00053 using std::cout;   
00054 using std::endl;
00055 
00056 
00057 
00058 
00059 int main(int argC, char* argV[]){
00060         WindowsErrorPopupBlocker();
00061         FileUtil *fileUtil = NULL; 
00062         fileUtil = new FileUtil();
00063         
00064         
00065         //demonstrate use of Clp
00066         ClpSolve solveOptions;
00067         ClpSolve::SolveType method;
00068         method = ClpSolve::useBarrier;
00069         //or primal simplex
00070         method = ClpSolve::usePrimal;
00071         solveOptions.setSolveType( method);
00072 
00073         ClpSimplex*  qpClpModel;
00074     //ClpInterior*  qpClpModel;
00075         qpClpModel = NULL;
00076         // template -- add your code here -- //
00077         std::cout << "Hello World" << std::endl;
00078         
00079         
00081         
00082     CbcOrClpParam parameters[CBCMAXPARAMETERS];
00083     int numberParameters ;
00084     establishParams(numberParameters, parameters) ;
00085     std::cout << "NUMBER OF PARAMETERS = " << numberParameters<< std::endl;
00086 
00087     /*
00088     parameters[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
00089     parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
00090     parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
00091     parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters, parameters)].setStringValue(directory);
00092     parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
00093     parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
00094     parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
00095     parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters, parameters)].setDoubleValue(models->dualBound());
00096     parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->dualTolerance());
00097     parameters[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters, parameters)].setStringValue(exportFile);
00098     parameters[whichParam(CLP_PARAM_INT_IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
00099     parameters[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters, parameters)].setStringValue(importFile);
00100     parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntValue(models->logLevel());
00101     parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters, parameters)].setIntValue(models->factorizationFrequency());
00102     parameters[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntValue(models->maximumIterations());
00103     parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
00104     parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
00105     parameters[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters, parameters)].setIntValue(models->perturbation());
00106     parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->primalTolerance());
00107     parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(models->infeasibilityCost());
00108     parameters[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
00109     parameters[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters, parameters)].setStringValue(saveFile);
00110     parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT, numberParameters, parameters)].setDoubleValue(models->maximumSeconds());
00111     parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
00112     parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
00113     parameters[whichParam(CLP_PARAM_INT_SPRINT, numberParameters, parameters)].setIntValue(doSprint);
00114     parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
00115     parameters[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters, parameters)].setIntValue(dualize);
00116     parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
00117  */
00118 
00120         
00121 
00122         qpClpModel = new ClpSimplex();
00123     //qpClpModel = new  ClpInterior();
00124         
00125         
00126         //set a parameter
00127         
00128 
00129         qpClpModel->setIntParam(ClpMaxNumIteration, 100) ;
00130         
00131         
00132         //parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntValue(qpClpModel->logLevel());
00133         
00134         std::cout << "Parameter number for:  CLP_PARAM_INT_SOLVERLOGLEVEL  " <<  whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters) << std::endl;
00135         std::cout << "Parameter number for:  CLP_PARAM_INT_MAXITERATION  " <<  whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters) << std::endl;
00136         parameters[ whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntParameter(qpClpModel, 0);
00137         parameters[ whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntParameter(qpClpModel, 10);
00138         
00139         std::cout << "CLP_PARAM_INT_SOLVERLOGLEVEL = "  <<  parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].intValue() << std::endl;
00140         
00141         try{
00142 
00143         int i;
00144  
00145 
00146                 const char dirsep =  CoinFindDirSeparator();
00147                 std::string osil;
00148                 // Set directory containing mps data files.
00149                 std::string dataDir;
00150                 std::string osilFileName;
00151                 //dataDir = dirsep == '/' ? "../../data/" : "..\\..\\data\\";
00152                 dataDir = dirsep == '/' ? "../data/" : "..\\data\\";
00153                 // first declare a generic solver
00154                 DefaultSolver *solver  = NULL;
00155                 
00156                 OSiLReader *osilreader = NULL;
00157                 OSInstance *osinstance = NULL;
00158                 OSoLWriter *osolwriter = NULL;
00159                 OSOption* osoption = NULL;
00160                 
00161 
00162                 
00163                 /******************** Start Clp Example *************************/
00164                 std::cout << std::endl << std::endl;
00165                 std::cout << "CLP EXAMPLE" << std::endl;
00166                 
00167                 /******************** STEP 1 ************************
00168                 * Get an instance in mps format, and create an OSInstance object
00169                 */
00170                 std::string qpFileName;
00171                 qpFileName =  dataDir  +  "parincQuadratic2.osil";
00172                 // convert to the OS native format
00173                 osil = fileUtil->getFileAsString( qpFileName.c_str() );
00174                 osilreader = new OSiLReader(); 
00175                 osinstance = osilreader->readOSiL( osil);
00176                 
00177                 
00178                 /******************** STEP 2 ************************
00179                 * Create an OSOption object and give the solver options
00180                 */              
00181                 osoption = new OSOption();
00187                  // normally most output is turned off, here we turn it back on
00188                 osoption->setAnotherSolverOption("OsiHintTry","","osi","","OsiHintStrength","");
00189                 osoption->setAnotherSolverOption("OsiDoReducePrint","false","osi","","OsiHintParam","");
00190                 osolwriter = new OSoLWriter();
00191                 std::cout << osolwriter-> writeOSoL( osoption);
00192                 
00193                 
00194                 /******************** STEP 3 ************************
00195                 * Create the solver object -- for a CoinSolver we must specify
00196                 * which solver to use
00197                 */
00198                 //solver = new CoinSolver();
00199                 //solver->sSolverName ="clp"; 
00200                 
00201                 
00202             CoinPackedMatrix* matrix;
00203             bool columnMajor = true;
00204             double maxGap = 0;
00205                 matrix = new CoinPackedMatrix(
00206                 columnMajor, //Column or Row Major
00207                 columnMajor? osinstance->getConstraintNumber() : osinstance->getVariableNumber(), //Minor Dimension
00208                 columnMajor? osinstance->getVariableNumber() : osinstance->getConstraintNumber(), //Major Dimension
00209                 osinstance->getLinearConstraintCoefficientNumber(), //Number of nonzeroes
00210                 columnMajor? osinstance->getLinearConstraintCoefficientsInColumnMajor()->values : osinstance->getLinearConstraintCoefficientsInRowMajor()->values, //Pointer to matrix nonzeroes
00211                 columnMajor? osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes : osinstance->getLinearConstraintCoefficientsInRowMajor()->indexes, //Pointer to start of minor dimension indexes -- change to allow for row storage
00212                 columnMajor? osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts : osinstance->getLinearConstraintCoefficientsInRowMajor()->starts, //Pointers to start of columns.
00213                 0,   0, maxGap ); 
00214                 
00215                 qpClpModel->setOptimizationDirection( -1);
00216                 qpClpModel->loadProblem( *matrix, osinstance->getVariableLowerBounds(), 
00217                                 osinstance->getVariableUpperBounds(),  
00218                                 osinstance->getDenseObjectiveCoefficients()[0], 
00219                                 osinstance->getConstraintLowerBounds(), osinstance->getConstraintUpperBounds()
00220                 );
00221                 
00222                 
00223         //now for the quadratic part
00224                 //get the quadratic terms
00225                 std::map<int, std::map<int, double> > varIndexMap;
00226                 std::map<int, std::map<int, double> >::iterator mit1;
00227                 std::map<int, double> tmpMap;
00228                 std::map<int, double>::iterator mit2;
00229                 
00230                 int numNonz;
00231                 numNonz = 0;
00232                 
00233         QuadraticTerms* quadTerms = NULL;
00234         quadTerms = osinstance->getQuadraticTerms();
00235         int i1;
00236         int j1;
00237         int tmpint;
00238           
00239         for(i = 0; i < osinstance->getNumberOfQuadraticTerms(); i++){
00240                 
00241                 if( quadTerms->rowIndexes[ i] == -1){
00242                         
00243                         i1 = quadTerms->varOneIndexes[ i] ;
00244                         j1 = quadTerms->varTwoIndexes[ i] ;
00245                         
00246                         if(i1 == j1) quadTerms->coefficients[i] = 2*quadTerms->coefficients[i];
00247                         
00248                         //does Clp expect j1 >= i1?????
00249                         //try this
00250                         
00251                         if(j1 < i1){ //switch
00252                                 
00253                                 tmpint = j1;
00254                                 j1 = i1;
00255                                 i1 = tmpint;
00256                                 
00257                                 
00258                         }
00259                         
00260                         mit1 = varIndexMap.find( i1 );
00261                         
00262                         if( mit1 == varIndexMap.end() ){ //add new index
00263                                 
00264                                 tmpMap.insert( std::pair<int, double>( j1, 
00265                                                         quadTerms->coefficients[i]) );
00266                                 numNonz++;
00267                                 
00268                                 varIndexMap[ i1 ] = tmpMap;
00269                                 
00270                                 tmpMap.clear();
00271                         }else{ 
00272                                 
00273                                 //map index already exists
00274                                 //insert second index if not alreay there
00275                                 mit2 = mit1->second.find( j1) ;
00276                                 
00277                                 if( mit2 == mit1->second.end() ){
00278                                         //add the new index and coefficient
00279                                         mit1->second.insert(  std::pair<int, double>( j1, 
00280                                                         quadTerms->coefficients[i])  );
00281                                         numNonz++;
00282                                         
00283                                 }else{
00284                                         
00285                                         mit2->second += quadTerms->coefficients[i];
00286                                         
00287                                 }
00288                                 
00289                         }               
00290                 
00291                 }//end if on test for objective function index
00292                 
00293         }//end loop over quadratic terms
00294                 
00295         std::cout << "numNonz = " << numNonz << std::endl;
00296                 
00297         
00298         int *start = NULL;
00299         int *idx = NULL;
00300         double *nonz = NULL;
00301 
00302         start = new int[ varIndexMap.size() + 1];
00303         idx = new int[ numNonz]; //index the columns
00304         nonz = new double[ numNonz];
00305         
00306         int kount;
00307         kount = 0;
00308         numNonz = 0;
00309         start[ kount++] = numNonz;
00310 
00311         for( mit1 = varIndexMap.begin(); mit1 != varIndexMap.end();  mit1++){
00312                 
00313                 std::cout  << std::endl;
00314                 std::cout << "FIRST INDEX = " << mit1->first << std::endl;
00315                 for( mit2 = mit1->second.begin(); mit2 != mit1->second.end();  mit2++){
00316                         std::cout << "SECOND INDEX = " << mit2->first << std::endl;
00317                         std::cout << "COEFFICIENT = " << mit2->second << std::endl;
00318                         idx[ numNonz] = mit2->first;
00319                         //we multiply by 2 for Clp
00320                         nonz[ numNonz++ ] = mit2->second;       
00321                 }
00322                 start[ kount++] = numNonz ;
00323                 
00324         }
00325         
00343         qpClpModel->loadQuadraticObjective( qpClpModel->numberColumns(), start, idx, nonz);
00344         
00345         qpClpModel->writeMps("quad.mps");
00346         
00347         
00348         //call solver
00349                 //qpClpModel->primal();
00350         ClpCholeskyBase * cholesky = new ClpCholeskyBase();
00351         cholesky->setKKT(true);
00352        // qpClpModel->setCholesky(cholesky);
00353        // qpClpModel->primalDual();
00354         
00355         qpClpModel->initialSolve( solveOptions);
00356                 
00357         double *primal;
00358         double *dual;
00359         primal = qpClpModel->primalColumnSolution();
00360         dual = qpClpModel->dualRowSolution();
00361         
00362                 
00363         int numberColumns = qpClpModel->numberColumns();
00364         int numberRows = qpClpModel->numberRows();
00365         for (i = 0; i < numberColumns; i++) {
00366              if (fabs(primal[i]) > 1.0e-8)
00367                   printf("%d primal %g\n", i, primal[i]);
00368         }
00369         for (i = 0; i < numberRows; i++) {
00370              if (fabs(dual[i]) > 1.0e-8)
00371                   printf("%d dual %g\n", i, dual[i]);
00372         }
00373          
00374         
00375         std::cout << osinstance->printModel();
00376         
00377         
00378                 /******************** STEP 4 ************************
00379                 * Give the solver the instance and options and solve
00380                 */      
00381                 //solver->osinstance = osinstance;
00382                 //solver->osoption = osoption;  
00383                 //solver->solve();
00384                 
00385                 
00386                 /******************** STEP 5 ************************
00387                 * Create a result object and get the optimal objective
00388                 * and primal variable values
00389                 */      
00390                 //getOSResult( solver->osrl);
00391                 
00392                 //OSResult *osr = solver->osresult;
00393                 //int numOfBasisVar = osr->getNumberOfBasisVar(0);
00394                 //std::cout << "NUMBER OF BASIS VARS = " << numOfBasisVar << std::endl;
00395                 
00396 dfd
00397                 
00398                 
00399                 //do garbage collection
00400                 delete osilreader;
00401                 osilreader = NULL;
00402                 delete solver;
00403                 solver = NULL;
00404                 delete osoption;
00405                 osoption = NULL;
00406                 delete osolwriter;
00407                 osolwriter = NULL;
00408                 delete qpClpModel;
00409                 qpClpModel = NULL;
00410                 //finish garbage collection
00411 
00412                 
00413                 /******************** End Clp Example *************************/        
00414         
00415         
00416         
00417         delete fileUtil;
00418         fileUtil = NULL;        
00419         return 0;
00420         
00421         }
00422         catch(const ErrorClass& eclass){
00423                 delete fileUtil;
00424                 fileUtil = NULL;
00425                 delete qpClpModel;
00426                 qpClpModel = NULL;
00427                 std::cout << eclass.errormsg <<  std::endl;
00428                 return 0;
00429         } 
00430 
00431 }// end main
00432 

Generated on Thu Sep 22 03:05:50 2011 by  doxygen 1.4.7