/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGCommonDriver.cpp

//
// Copyright (c) 2004           Model-based Embedded and Robotic Systems Group
// All Rights Reserved          Massachusetts Institute of Technology
//
// This software is provided as is. Model-based Embedded and Robotic Systems
// (MERS) group does not assume any responsibility.
//
// Organization:        Model-based Embedded and Robotic Systems Group
//                                      Massachusetts Institute of Technology
//

#ifdef _MSC_VER
#pragma warning( disable : 4786 )
#endif

#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <string>
//#include <time.h>
#include <list>
#include <sstream>

#include "BFIGImplicant.h"
#include "BFIGVariable.h"
#include "BFIGConstraint.h"
#include "BFIGAssignment.h"

#include "BFIGGenerator.h"

#include <Mers/Models/Base/BaseModelVariableArray.h>
#include <Mers/Models/Base/BaseModelAssignmentArray.h>
#include <Mers/Models/Base/BaseModelDomain.h>
#include <Mers/Utils/Containers/IntegerArray.h>
//#include <Mers/Solvers/SAT/GATSAT/OpSAT/Opsat.h>

#include "BFIGFactory.h"

using Mers::Models::Base::BaseModelVariableArray;
using Mers::Models::Base::BaseModelVariable;
using Mers::Models::Base::BaseModelAssignmentArray;
using Mers::Models::Base::BaseModelAssignment;
using Mers::Models::Base::BaseModelValue;
using Mers::Models::Base::BaseModelDomain;
using Mers::Utils::Containers::IntegerArray;

namespace Mers {
        namespace Generators {
                namespace BFIG {
                        BFIGFactory * getBFIGFactory();
                }
        }
}

using namespace std;
using Mers::Generators::BFIG::BFIG;
using Mers::Generators::BFIG::BFIGGenerator;
using Mers::Generators::BFIG::BFIGFactory;
using Mers::Generators::BFIG::getBFIGFactory;

bool
file_exist(char const * filename)
{
        FILE *file;
        if ( (file = fopen(filename,"r")) == NULL )
                return false;
        fclose(file);
        return true;
}


BFIGGenerator *
readVariables(char const * filename, BaseModelVariableArray ** variableSet, bool useProb)
{
  bool ownsVars = true;
        BaseModelVariableArray * vars = new BaseModelVariableArray(ownsVars);
        vector<double> costs;
        IntegerArray valueMap;
        int position = 0;
        unsigned int UID = 0;
        valueMap.pushBack(position);
        char next;
        char tmp[400];

        if (!file_exist(filename))
        {
                cerr << "File " << filename << " does not exist." << endl;
                exit(-1);
        }

        ifstream in(filename);

        // skip comment lines
        while (!in.eof() && (next=in.peek()) == '#')
                in.getline(tmp,400);

        if (in.eof())
        {
                cout << "Data file contains no variables. " << endl;
                return NULL;
        }

        in >> ws;
        while (!in.eof())
        {
                in.getline(tmp,399);  // read variable
                in >> ws;
                if (strlen(tmp) == 0)
                        continue;
                istringstream line(tmp);
                char varname[400];
                line >> varname;
                line >> ws;
                bool ownsVals = true;
                BaseModelValue * value;
                BaseModelDomain * domain = new BaseModelDomain(varname, ownsVals);
                cout << "Domain name: " << domain->getName() << endl;
                while (!line.eof())
                {
                        char val[400];
                        double p;

                        line >> val;
                        cout << "   val: " << val << ", " ;
                        line >> p;
                        cout << "cost: " << p << endl;
                        line >> ws;
                        value = new BaseModelValue(val);
                        domain->pushBack(value);
                        costs.push_back(p);
                }
                position = position + domain->getLength();
                valueMap.pushBack(position);
                BaseModelVariable * var = new BaseModelVariable(varname, domain);
                var->setUID(UID);
                UID++;
                //cout << "Read variable: " << *var << endl ;
                //::cout << "(num values: " << values.size() << ")" << endl;
                vars->pushBack(var);
        }
        // We put one too many positions in valueMap
        valueMap.popBack();

        in.close();

        *variableSet = vars;
        cout << "Length of variable array: " << vars->getLength() << endl;
        cout << "Variables: " << *variableSet << endl;
        cout << "ValueMap: " << valueMap << endl;
        cout << "Costs: ";
        for (vector<double>::const_iterator p = costs.begin();
             p!=costs.end(); p++) {
          cout << *p << " ";
        }
        cout << endl;
        BFIGFactory * factory = getBFIGFactory();
        BFIGGenerator * gen =
                new BFIGGenerator(*factory, *vars, *vars, valueMap, costs, 1e10, useProb);
        delete factory;
        return gen;

        //cout << "Read file with " << (res.size()) << " variables." << endl;
        //cout << endl;

}


const vector<BaseModelAssignmentArray *> *
readConflicts(char const * filename, BaseModelVariableArray * variableSet)
{

        vector<BaseModelAssignmentArray *> * conflicts = 
                new vector<BaseModelAssignmentArray *>();
        BaseModelAssignmentArray * conflict = NULL;

        char next;
        char tmp[400];

        if (!file_exist(filename))
        {
                cerr << "File " << filename << " does not exist." << endl;
                exit(-1);
        }

        ifstream in(filename);

        // skip comment lines
        while (!in.eof() && (next=in.peek()) == '#')
                in.getline(tmp,400);

        in >> ws;
        if (in.eof())
        {
                cout << "Data file contains no conflicts." << endl;
                return conflicts;  // try anyway, for testing...
        }

        while (!in.eof())
        {
                in.getline(tmp,399);  // read conflict
                in >> ws;
                if (strlen(tmp) == 0)
                        continue;
                istringstream line(tmp);
                bool bracketOpened = false;
                bool lastVarInConflict = false;
                while (!line.eof())
                {
                  char var[400];
                  //char var2[399];
                        char val[400];
                        char tmpChar, tmpChar2;

                        line >> tmpChar;
                        if (tmpChar == '[')
                          {
                            bracketOpened = true;
                                        //The original BaseModelVariableArray owns the variables
                            bool ownsVars = false;
                            conflict = new BaseModelAssignmentArray(ownsVars);
                            line >> var;
                          }
                        else if (tmpChar == ']') // End of a conflict
                          {
                            bracketOpened = false;
                            if (conflict != NULL && conflict->getLength() > 0)
                                conflicts->push_back(conflict);
                            line >> ws;
                            if (line.eof())
                              break;
                            line >> var;
                          }
                        else
                        {
                          var[0] = tmpChar;
                                // Get the rest of the variable name up to the next space.
                          for (int i = 1; i < 400; i++) {
                            tmpChar2 = line.get();
                            if (tmpChar2 == ' ') break;
                            var[i] = tmpChar2;
                          }
                        }
                        line >> val;
                        line >> ws;

                        // There was no space between value and ]
                        if (val[strlen(val) - 1] == ']')
                        {
                                val[strlen(val) - 1] = '\0';
                                lastVarInConflict = true;
                        }

                        const BaseModelVariable * variable = variableSet->find(var);
                        const BaseModelValue * value;
                        if (variable == NULL) {
                                cout << "Error: could not find conflict assignment "
                                       << var << ", " << val << endl;
                        }
                        else {
                          value = variable->getValue(val);
                          if (value == NULL) {
                            cout << "Error: could not find conflict assignment "
                                       << var << ", " << val << endl;
                          }
                          else if (!bracketOpened)
                            cerr << "Error: must start conflicts with a '['" << endl;
                          else {
                            conflict->pushBack(new BaseModelAssignment(variable, value));
                            if (lastVarInConflict) {
                              bracketOpened = false;
                              lastVarInConflict = false;
                              if (conflict != NULL && conflict->getLength() > 0)
                                conflicts->push_back(conflict);
                            }
                          }
                        }
                }
        }

        in.close();
        cout << "Finished reading conflicts: " << endl;
        int counter = 0;
        vector<BaseModelAssignmentArray *>::const_iterator p = conflicts->begin();
        for (; p != conflicts->end(); p++) {
          cout << "Conflict " << counter << endl;
          cout << **p << endl;
          counter++;
        }
        return conflicts;
}


int
main(int argc, char** argv)
{
        argc--;
        argv++;

        bool useProb = false;
        bool useDebug = false;
        int numResults = 1;
        char const * logConfigFileName = NULL;

        for (; argc > 0 && argv[argc-1][0] == '-'; argc--)
        {
                if (argv[argc-1][1] == 'b' || argv[argc-1][1] == 'B')
                {
                        cout << "Showing debug info." << endl;
                        useDebug = true;
                } /*else
                if (argv[argc-1][1] == 'e' || argv[argc-1][1] == 'E')
                {
                        cout << "Using non-Conflict-Directed search." << endl;
                        useCD = false;
                        cout << "Using entropy to sort variables." << endl;
                        orderType = Opsat::ENTROPY;
                } else
                if (argv[argc-1][1] == 'r' || argv[argc-1][1] == 'R')
                {
                        cout << "Using non-Conflict-Directed search." << endl;
                        useCD = false;
                        cout << "Using random sorting of variables." << endl;
                        orderType = Opsat::RANDOM;
                        } */else
                if (argv[argc-1][1] == 'p' || argv[argc-1][1] == 'P')
                {
                        cout << "Treating costs as probabilities." << endl;
                        useProb = true;
                } else
                if (argv[argc-1][1] == 'n' || argv[argc-1][1] == 'N')
                {
                        char * numStr = argv[argc-1]+2;
                        numResults = atoi(numStr);
                        cout << "Searching for best " << numResults << " results." << endl;
                } else if (argv[argc-1][1] == 'l') {
                        logConfigFileName = argv[argc-1] + 2;
                        cout << "Using log4cplus config file " << logConfigFileName;
                } else {
                        cout << "Ignoring unrecognized option '" << argv[argc-1] << "'." << endl;
                }
        }
        if (argc != 2)
        {
                cout << "Arguments should be:" << endl << endl;
                cout << "   <variable_file> <conflict_file> "
                     << "[-c][-e][-p][-r][-b][-y][-n#]" << endl;
                cout << endl;
                cout << "-e   uses an entropy-directed search method (with -c)." << endl;
                cout << "-r   uses a random sorting of the variables (with -c)." << endl;
                cout << "-b   show debug info." << endl;
                cout << "-p   treats costs as probabilities." << endl;
                cout << "-n#  specifies the number to find (default is 1)." << endl;
                cout << "-l<log4cplus config file>: Specifies a config file to "
                        "load," << endl << "which is used to configure the log4cplus "
                        "logger output." << endl << "By default, log4cplus is "
                        "configured to print to standard out." << endl;
                cout << endl;
                exit(-1);
        }
        cout << endl;

        // load our config file
        if(logConfigFileName == NULL) {
                log4cplus::BasicConfigurator::doConfigure();
        } else {
                log4cplus::PropertyConfigurator::doConfigure(logConfigFileName);
        }

        char const * variableFile = argv[0];
        char const * conflictFile = argv[1];

        BaseModelVariableArray * variables;
        BFIGGenerator * bfig = readVariables(variableFile, &variables, useProb);
        const vector<BaseModelAssignmentArray *> * conflicts = readConflicts(conflictFile, variables);

        //float cutoff = 0.9F;
        int maxStatesTime = 20000;
        int maxStatesSize = 15000;

        bfig->setDebug(useDebug);

        vector<BaseModelAssignmentArray *>::const_iterator p = conflicts->begin();
        for (; p != conflicts->end(); p++) {
          bfig->addConflict(*p);
        }
        cout << "Added conflicts" << endl;
        
        /*      for (int i = 0; i < variables.getLength(); i++) {
          cout << *(bfig->findVariable(i)) << endl;
          }*/
        const BaseModelAssignmentArray * imp = bfig->generateBestImplicant(maxStatesTime, maxStatesSize);
        cout << endl;
        cout << "Implicant generated: " << *imp << endl;
        //      cout << "    true cost: " << (imp->getTrueCost()) << endl;
        cout << endl;

        bfig->printStatistics();
        //cout << "printed statistics." << endl;
        delete variables;
        delete bfig;
        //list<BFIGConstraint const *>::iterator cIter;
        //for (cIter = conflicts.begin(); cIter != conflicts.end(); cIter++)
        //{
        //      delete (*cIter);
        //}
        exit(0);
        return 0; //# to make MSVC happy - yes, it's that stupid.
}

---