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

//
// Copyright (c) 2005           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
//

#include "BFIGImplicantNoMPI.h"

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

#include <cassert>
#include "BFIGAssignment.h"
#include "BFIGVariable.h"
#include "BFIGConstraint.h"
#include "BFIGObjectiveFunction.h"
#include "ListManipulator.h"

using namespace std;
using Mers::Generators::BFIG::BFIGImplicant;
using Mers::Generators::BFIG::BFIGImplicantNoMPI;
using Mers::Generators::BFIG::BFIGVariable;
using Mers::Generators::BFIG::BFIGAssignment;
using Mers::Generators::BFIG::BFIGConstraint;
using Mers::Generators::BFIG::ListManipulator;
using Mers::Generators::BFIG::BFIGObjectiveFunction;

//      CONSTRUCTOR

BFIGImplicantNoMPI::BFIGImplicantNoMPI(vector<BFIGConstraint const *> const & unentailedConflictsList, 
                BFIGObjectiveFunction const * of)
: BFIGImplicant(unentailedConflictsList, of)
{
        if(objectiveFunction != NULL)
                bestCost = objectiveFunction->getCost(assignments);
}


BFIGImplicantNoMPI::BFIGImplicantNoMPI(const BFIGImplicant & i)
: BFIGImplicant(i)
{
        if(objectiveFunction != NULL)
                bestCost = objectiveFunction->getCost(assignments);
}


BFIGImplicantNoMPI::~BFIGImplicantNoMPI()
{
}


// protected
// does not preserve the siblings of the source implicant!! Intentional.
BFIGImplicantNoMPI::BFIGImplicantNoMPI(BFIGImplicant const * parent, 
        BFIGAssignment const * extraAssign)
: BFIGImplicant(parent, extraAssign)
{
        LOG4CPLUS_DEBUG(mLogger, "Created BFIGImplicantNoMPI");

        if(objectiveFunction != NULL)
                bestCost = objectiveFunction->getCost(assignments);
}


BFIGImplicantNoMPI::BFIGImplicantNoMPI(BFIGImplicant * parent, 
        BFIGAssignment const * extraAssign,
        vector<BFIGAssignment const *> siblingAssigns)
: BFIGImplicant(parent, extraAssign, siblingAssigns)
{
        LOG4CPLUS_DEBUG(mLogger, "Created BFIGImplicantNoMPI");

        if(objectiveFunction != NULL)
                bestCost = objectiveFunction->getCost(assignments);
}

//      PUBLIC METHODS

/*
void
BFIGImplicantNoMPI::addAssignment(BFIGAssignment const * a)
{
        // I don't know why the assignments in the implicant have to be sorted by 
        // variable uid but I'll leave it that way for now
#ifdef IMPLICANT_ENABLE_UNSORTED
        assignmentsUnsorted.push_back(a);
#endif
        vector<BFIGAssignment const *>::iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                if ( (*a) < (*(*aIter)) )
                {
                        assignments.insert(aIter, a);
                        break;
                }
        }
        if (aIter == assignments.end())
        {
                assignments.push_back(a);
        }

        LOG4CPLUS_DEBUG(mLogger, "Adding assignment");
        if(objectiveFunction != NULL)
                bestCost = objectiveFunction->getCost(assignments);
        else
                bestCost += a->getCost();
}
*/


double
BFIGImplicantNoMPI::getBestCost() const
{
        return bestCost;
}


double
BFIGImplicantNoMPI::getTrueCost() const
{
        return bestCost;
}


void
BFIGImplicantNoMPI::updateBestCost()
{
        cerr << "<BFIGImplicantNoMPI> ERROR: Should be updating costs through Objective Function!" << endl;
}


vector<BFIGImplicant *>
BFIGImplicantNoMPI::generateChildren(vector<BFIGVariable *> const * varSet)
{
        vector<BFIGImplicant *> ext;

        // No need to have a pointer to the parent anymore
        delete siblingParent;
        siblingParent = NULL;
        
        // expand to children
        list<BFIGAssignment const *> supports;
        if (entailsAllConflictsCheck())
        {
                // No conflict needs to be covered, so...
                if (varSet)
                {
                        // extend to unspecified assignments - no particular order...
                        vector<BFIGVariable *>::const_iterator vIter;
                        for (vIter = varSet->begin(); vIter != varSet->end(); vIter++)
                        {
                                if(*vIter == NULL)
                                        continue;
                                if (!contains(*vIter))
                                {
// #ifdef IMPLICANT_EXTEND_ALL  // Not sure what this definition is.... removing for now
//                                      vector<BFIGAssignment const *> newSupports = (*vIter)->getAssignmentsSorted();
// #ifdef _MSC_VER
//                                      ListManipulator<BFIGAssignment const *> lm;
//                                      lm.merge(supports, newSupports, assignment_cost_less);
// #else
//                                      supports.merge<assignment_comp_func>(newSupports, assignment_cost_less);
// #endif
// #else
                                        // this one is free...
                                        vector<BFIGAssignment const *> vSupports = (*vIter)->getAssignments();  // Don't care if they're sorted
                                        for(unsigned int v = 0; v < vSupports.size(); v++){
                                                supports.push_back(vSupports[v]);
                                        }
                                        break;
// #endif
                                }
                        }
                } else
                {
                        // can't extend to non-conflict-resolving assigns without knowing the variables.
                }
        } else
        {
                // we will cover another conflict
                BFIGConstraint const * firstConflict = unentailedConflicts.front();
                supports = firstConflict->getPrimeImplicants();         // This could be more efficient if we could 
                                                                        // prevent the prime implicants from being sorted
        }
        
        // place all the compatible supports in the queue
        BFIGAssignment const * bestExtension = NULL;
        list<BFIGAssignment const *>::iterator sIter = supports.begin();
        while(sIter != supports.end())
        {
                bestExtension = *sIter;
                sIter = supports.erase(sIter);
                if (bestExtension->compatible(assignments))
                {
                        if(ext.empty())
                                ext.push_back(new BFIGImplicantNoMPI(this, bestExtension));
                        else
                        {
                                BFIGImplicant * newParent = new BFIGImplicantNoMPI(*this);
                                ext.push_back(new BFIGImplicantNoMPI(newParent, bestExtension));
                        }
                }
        }

        return ext;
}


BFIGImplicant * BFIGImplicantNoMPI::generateSibling()
{
        BFIGImplicant * sibimp = NULL;
//--------------------------------------------------------------------
// All siblings should already be place on the queue if the problem
// is MPI. Return NULL. 
//--------------------------------------------------------------------
//
//      // this one has been expanded before...
//      if (siblingParent != NULL)
//      {
//              BFIGAssignment const * nextSiblingAssign = NULL;
//              unsigned int x = 0;
//
//              while (x < siblingAssignments.size())
//              {
//                      nextSiblingAssign = siblingAssignments[x++];
//                      if (nextSiblingAssign->compatible(siblingParent->getAssignments()))
//                              break;
//                      else
//                              nextSiblingAssign = NULL;
//              }
//
//              siblingAssignments.erase(siblingAssignments.begin(), 
//                      siblingAssignments.begin() + x);
//
//              if (nextSiblingAssign == NULL)
//              {
//                      // all done with siblings
//                      // let it go...
//                      delete siblingParent;
//              } else {
//                      if (!siblingAssignments.empty())
//                      {
//                              sibimp = new BFIGImplicantNoMPI(siblingParent, nextSiblingAssign,
//                                      siblingAssignments);
//                              // sibimp now owns siblingParent memory...
//                      } else {
//                              sibimp = new BFIGImplicantNoMPI(siblingParent, nextSiblingAssign);
//                              delete siblingParent;
//                      }
//              }
//              
//              siblingParent = NULL;
//              siblingAssignments.clear();
//      }

        return sibimp;
}


namespace Mers {
        namespace Generators {
                namespace BFIG {
                        ostream&
                        operator<<(ostream& os, BFIGImplicantNoMPI const & in)
                        {
                                os << "NonMPI[" ;
                                if (!in.terse)
                                        os << in.getBestCost() << ": " ;

                                vector<BFIGAssignment const *> assigns = in.assignments;
                                bool first = true;
                                vector<BFIGAssignment const *>::const_iterator assignmentIter;
                                for (assignmentIter = assigns.begin();
                                                 assignmentIter != assigns.end(); assignmentIter++)
                                {
                                        if (first)
                                                first = false;
                                        else
                                                if (in.terse)
                                                        os << " ";
                                                else
                                                        os << ", ";
                                        os << *(*assignmentIter) ;
                                }
                                if (in.essentialConflict)
                                        os << " X";
                                if(!in.terse) {
                                        if(!in.entailsAllConflicts())
                                                os << " C";
                                }
                                os << "]";
                                return os;
                        }
                }
        }
}

---