/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGAssignment.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
//
//# CHECKED MJP 08-07-2002

//============================================
//      BFIGAssignment IMPLEMENTATION
//============================================

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

#include "BFIGAssignment.h"

#include <cassert>
#include <iomanip>
#include "BFIGVariable.h"
#include "BFIGConstraint.h"
#include <Mers/Models/Base/BaseModelSentence.h>
#include <Mers/Models/Base/BaseModelDomain.h>

using namespace std;
using namespace Mers::Generators::BFIG;
using Mers::Models::Base::BaseModelValue;
using Mers::Utils::Lang::String;
using Mers::Utils::Containers::IntegerArray;

bool BFIGAssignment::terse = false;

        //----------------------------------------
        //      CONSTRUCTOR
        //----------------------------------------
BFIGAssignment::BFIGAssignment(BFIGVariable const * sourceVariable_p,
        BaseModelValue const * assignmentValue, double assignmentCost)
: BaseModelAssignment(sourceVariable_p->getBMVariable(), assignmentValue)
{
        assert(sourceVariable_p);
        debug = false;
        sourceVariable = sourceVariable_p;
        trueCost = assignmentCost;
        cost = trueCost;
        mEnabled = true;
        assertThis = new BFIGConstraint(this, true);
        assertNotThis = new BFIGConstraint(this, false);
}

/*
BFIGAssignment::BFIGAssignment(BFIGVariable const * sourceVariable_p,
        BaseModelValue * assignmentValue, vector<double> const & assignmentCosts,
        IntegerArray const & dependentValues)
: BaseModelAssignment(sourceVariable_p->getBMVariable(), assignmentValue)
{
        assert(sourceVariable_p);
        assert(!assignmentCosts.empty());
        assert(!dependentValues.isEmpty());
        assert(assignmentCosts.size() == dependentValues.getLength());
        debug = false;
        sourceVariable = sourceVariable_p;
        trueCostList = assignmentCosts;
        trueCostValues = dependentValues;
        //# trueCost = trueCostList.front();  // hack - not meaningful.
        trueCost = 0.0;
        cost = trueCost;
        isDefaultVal = false;
        mEnabled = true;
        assertThis = new BFIGConstraint(this, true);
        assertNotThis = new BFIGConstraint(this, false);
}


BFIGAssignment::BFIGAssignment(BFIGVariable const * sourceVariable_p, unsigned int assignmentValue,
                       vector<double> const & assignmentCosts,
                       IntegerArray const & dependentValues,
                       DynamicArrayTemplate<BaseModelSentence const> const & guards)
: value(assignmentValue), transitionGuardsClauses(false)
{
        assert(sourceVariable_p);
        assert(!assignmentCosts.empty());
        assert(!dependentValues.isEmpty());
        assert(assignmentCosts.size() == dependentValues.getLength());
        assert(assignmentCosts.size() == guards.getLength());
        debug = false;
        sourceVariable = sourceVariable_p;
        trueCostList = assignmentCosts;
        trueCostValues = dependentValues;
        trueCost = 0.0;
        transitionGuardsClauses = guards;  // should be gotten rid of - not elegant or efficient.
        cost = trueCost;
        isDefaultVal = false;
        mEnabled = true;

        //if (getName() == 0)
        //{
        //      cout << endl << "  Var " << getName() << " :  [" << value << "] : {" ;
        //      IntegerArray::const_iterator vIter;
        //      vector<BaseModelSentence const *>::const_iterator cIter;
        //      for (vIter = trueCostValues.begin(), cIter = transitionGuardsClauses.begin();
        //           vIter != trueCostValues.end(); vIter++, cIter++)
        //      {
        //              if (vIter != trueCostValues.begin())
        //                      cout << ", ";
        //              cout << (*vIter) << ":" << (*(*cIter));
        //      }
        //      cout << "}" << " (" << guards.size() << " guards)" << endl << endl;
        //}
/

        assertThis = new BFIGConstraint(this, true);
        assertNotThis = new BFIGConstraint(this, false);
}
*/

BFIGAssignment::~BFIGAssignment()
{
        //vector<BFIGConstraint *>::iterator cIter;
        //for (cIter = transitionGuards.begin(); cIter != transitionGuards.end(); cIter++)
        //{
        //      delete (*cIter);
        //}
        if (assertThis)
                delete assertThis;
        if (assertNotThis)
                delete assertNotThis;
}

        //----------------------------------------
        //      OVERLOADED OPERATORS
        //----------------------------------------
bool
BFIGAssignment::operator ==(BFIGAssignment const * a) const
{
        if (a == NULL)
                return false;

        return (getVariable()->getName() == a->getVariable()->getName()) &&
                 (getValue() == a->getValue());
}

bool
BFIGAssignment::operator ==(BFIGAssignment const & a) const
{
        return (getVariable()->getName() == a.getVariable()->getName()) &&
                 (getValue() == a.getValue());
}


bool
BFIGAssignment::operator <(BFIGAssignment const & a) const
{
        if (getName() < a.getName())
                return true;
        if (getName() > a.getName())
                return false;
        return (getValue() < a.getValue());
}


        //----------------------------------------
        //      PUBLIC FUNCTION METHODS
        //----------------------------------------

void
BFIGAssignment::setDebug(bool debugState)
{
        debug = debugState;
}


unsigned int
BFIGAssignment::getValue() const
{
        return getValueInt();
}


String
BFIGAssignment::getValueString() const
{
        return BaseModelAssignment::getValue()->getName();
}


unsigned int
BFIGAssignment::getValueInt() const
{
        return BaseModelAssignment::getValue()->getUID();
}


Mers::Generators::BFIG::BFIGVariable const *
BFIGAssignment::getVariable() const
{
        return sourceVariable;
}


unsigned int
BFIGAssignment::getName() const
{
        return getVariable()->getName();
}


String
BFIGAssignment::getNameString() const
{
        return getVariable()->getNameString();
}


unsigned int
BFIGAssignment::getNameInt() const
{
        return getVariable()->getNameInt();
}


/*#
void
BFIGAssignment::setValue(BFIGVariable::Value newValue)
{
        value = newValue;
}
*/

double
BFIGAssignment::getCost() const
{
        return cost;
}

double
BFIGAssignment::getTrueCost() const
{
        return trueCost;
}


void
BFIGAssignment::setCost(double assignmentCost)
{
        cost = assignmentCost;
        if ( cost == -0.0 )  // fix for -0.0...
                cost = 0.0;
        ((BFIGVariable *)sourceVariable)->isSorted = false;
        ((BFIGVariable *)sourceVariable)->bestAssignment = NULL;
}

void
BFIGAssignment::setTrueCost(double assignmentCost)
{
        trueCost = assignmentCost;
        /*#  better than nothing? */
        setCost(trueCost);
}


bool
BFIGAssignment::isEnabled()  const
{
        return mEnabled;
}


void
BFIGAssignment::setEnabled(bool enabled)
{
        mEnabled = enabled;
        ((BFIGVariable *)sourceVariable)->bestAssignment = NULL;
}

/*
bool
BFIGAssignment::isCurrent()  const
{
        return (this == getVariable()->getCurrentAssignment());
}


void
BFIGAssignment::setAsCurrent()  const
{ 
        ((BFIGVariable *)getVariable())->setCurrent(this);
}


bool
BFIGAssignment::isNext()  const
{
        return (this == getVariable()->getNextAssignment());
}


void
BFIGAssignment::setAsNext()  const
{
        ((BFIGVariable *)getVariable())->setNext(this);
}
*/

Mers::Generators::BFIG::BFIGConstraint const *
BFIGAssignment::getConstraint()  const
{
        return assertThis;
}


Mers::Generators::BFIG::BFIGConstraint const *
BFIGAssignment::getNegativeConstraint()  const
{
        return assertNotThis;
}

/*
void
BFIGAssignment::convertGuards(ModelConvertorInterface const * mc)
{
        assert(transitionGuards.empty());
        DynamicArrayTemplate<BaseModelSentence const>::ConstantIterator cIter;
        for (cIter = transitionGuardsClauses.begin();
             cIter != transitionGuardsClauses.end(); cIter++)
        {
                BaseModelSentence const &guard = (*cIter);
                //if (guard->type() == BaseModelSentence::DISJUNCTIVE)
                //{
                //      cerr << "Error: BFIGAssignment.convertGuards cannot handle disjunctions! "
                //           << "in guard clause: " << (*guard) << endl;
                //}
                if(&guard && guard.getLength() > 0 && guard[0] != NULL)
                        transitionGuards.push_back(mc->clauseToConstraint(guard[0], true));
        }
        transitionGuardsClauses.makeEmpty();
}


void
BFIGAssignment::enableByGuard(AssignmentTesterInterface * currentSat, unsigned int priorVal)
{
        setEnabled(true);
        if (transitionGuards.empty())
                return;  // assume enabled if no guards.

        IntegerArray::const_iterator vIter;
        vector<BFIGConstraint *>::const_iterator cIter;
        for (vIter = trueCostValues.begin(), cIter = transitionGuards.begin();
             vIter != trueCostValues.end(); vIter++, cIter++)
        {
                if ((unsigned int)(*vIter) == priorVal)
                {
                        // found the right guard...
                        BFIGConstraint * guard = (*cIter);
                        // should check for its entailment now...
                        //if (debug)
                        //{
                                cout << "Found guard: BFIGAssignment: " << (*this)
                                     << " (" << priorVal << "," << getVariable()->getCurrentAssignment()->getValue() << ")"
                                     << ", guard: " << (*guard)
                                     << endl;
                        //}
                        if (guard->empty()) // && guard->type() == BaseModelSentence::CONJUNCTIVE
                        {
                                return;  // trivially satisfied - leave enabled.
                        }
                        // perform the check:
/ *#
                        //Implicant imp;  // can we use this?
                        //BFIGConstraint guardConstraint;
                        //BaseModelSentence::const_iterator gcIter;
                        //for (gcIter = guard->begin(); gcIter != guard->end(); gcIter++)
                        //{
                        //      literal lit = (*gcIter);
                        //      bool litType = (lit.type() == literal::POSITIVE);
                        //      BFIGAssignment const * litAssignment = NULL;
                        //      BFIGAssignment const a = (*litIter).proposition();
                        //      //// *** need to convert the literal to the BFIGAssignment!!!
                        //      if (litAssignment)
                        //              guardConstraint.addUnit(ConstraintUnit(litAssignment, litType));
                        //}
                        //if (currentSat.tryAssignment(imp, true, useDPLL).empty())  // guard is entailed

                        //currentSat.addTemporaryConstraint(guardConstraint.toisatClause(&currentSat));
                        //if (currentSat.consistent(true))
/
                        BaseModelAssignmentArray conflict(false);
                        BaseModelAssignmentArray bmGuard(true);
                        list<BFIGConstraintUnit> bfigCUnits = guard->getConstraintUnits();
                        list<BFIGConstraintUnit>::iterator iter;
                        for(iter = bfigCUnits.begin(); iter != bfigCUnits.end(); iter++){
                                BaseModelVariable * bmVar = iter->getVariable()->getBMVariable();
                                BaseModelAssignment * bmAsg = 
                                        new BaseModelAssignment(bmVar, bmVar->getDomain()->getValue(iter->getValueInt()),
                                        (iter->getParity() ? BaseModelAssignment::Positive : BaseModelAssignment::Negative));
                                bmGuard.pushBack(bmAsg);
                        }

                        AssignmentTesterInterface::SolutionType solution =
                                currentSat->tryAssignment(&bmGuard, 0, true, conflict);
                        //if (!isCorrect)  // guard is entailed
                        if(solution == AssignmentTesterInterface::Unsatisfiable)
                        {
                                if (debug)
                                        cout << "    " << "guard is entailed." << endl;
                                setEnabled(true);
                        } else
                        {
                                if (debug)
                                        cout << "    " << "guard is NOT entailed." << endl;
                                setEnabled(false);
                        }
                        return;
                }
        }
        cerr << "Error: BFIGAssignment " << (*this) << " could not find value "
             << "in enableByGuard()!" << endl;
}


void
BFIGAssignment::enableByGuard(unsigned int priorVal)
{
        setEnabled(true);
        if (transitionGuards.empty())
                return;  // assume enabled if no guards.

        IntegerArray::const_iterator vIter;
        vector<BFIGConstraint *>::const_iterator cIter;

        if (debug)
        {
                cout << "Source modes for BFIGAssignment: " << (*this) << endl;
                for (vIter = trueCostValues.begin(), cIter = transitionGuards.begin();
                     vIter != trueCostValues.end(); vIter++, cIter++)
                {
                        cout << getVariable()->getAssignmentByValue(*vIter)->getValueString() 
                                 << " guard: " << *(*cIter) << endl;
                }
                cout << endl;
        }
        
        for (vIter = trueCostValues.begin(), cIter = transitionGuards.begin();
             vIter != trueCostValues.end(); vIter++, cIter++)
        {
                if ((unsigned int)(*vIter) == priorVal)
                {
                        // found the right guard...
                        BFIGConstraint * guard = (*cIter);
                        // check for its entailment now... without sat engine...
                        if (debug)
                        {
                                cout << "Found guard: BFIGAssignment: " << (*this)
                                     << " (" << priorVal << "," << getVariable()->getCurrentAssignment()->getValue() << ")"
                                     << ", guard: " << (*guard)
                                     << endl;
                        }
                        setEnabled(guard->isSatisfiedCurrent(true));
                        return;
                }
        }
        cerr << "Error: BFIGAssignment " << (*this) << " could not find value "
             << "in enableByGuard()!" << endl;
}
*/

/*
void
BFIGAssignment::setTrueCostByValue(unsigned int priorVal)
{
        if (trueCostList.empty())
        {
                //cerr << "Error: cannot set BFIGAssignment " << (*this) << " cost using prior "
                //     << priorVal << " without cost vector!" << endl;
                return;
        }
        IntegerArray::const_iterator vIter;
        vector<double>::const_iterator cIter;
        for (vIter = trueCostValues.begin(), cIter = trueCostList.begin();
             vIter != trueCostValues.end(); vIter++, cIter++)
        {
                if ((unsigned int)(*vIter) == priorVal)
                {
                        setTrueCost((*cIter));
                        return;
                }
        }
        cerr << "Error: BFIGAssignment " << (*this) << " could not find value "
             << "in setCostByValue()!" << endl;
}
*/

bool
BFIGAssignment::compatible(BFIGAssignment const *a) const
{
        return (getName() != a->getName() || getValue() == a->getValue());
}


bool
BFIGAssignment::compatible(vector<BFIGAssignment const *> const & a) const
{
        vector<BFIGAssignment const *>::const_iterator assignmentIter;
        for (assignmentIter = a.begin(); assignmentIter != a.end(); assignmentIter++)
        {
                if (!compatible(*assignmentIter))
                        return false;
        }
        return true;
}


IntegerArray
BFIGAssignment::alternateValues() const
        // *******************************
        //      This function will generate all of the alternate assignments that this
        //      particular BFIGAssignment points to.
        //      This is generated by searching through the vector for the BFIGAssignment and then
        //      removing it.
        // *******************************
{
        IntegerArray reducedDomain;

        IntegerArray variableDomain = sourceVariable->getDomain();

        for (unsigned int x = 0; x < variableDomain.getLength(); x++) {
                if (value->getUID() != (unsigned int) variableDomain[x])
                        reducedDomain.pushBack(variableDomain[x]);
        }

        return reducedDomain;
}


list<BFIGAssignment const *>
BFIGAssignment::alternateAssignments() const
        // *******************************
        //      This function will generate all of the alternate assignments that this
        //      particular assignment points to.
        //      This is generated by searching through the vector for the assignment and then
        //      removing it.
        // *******************************
{
        list<BFIGAssignment const *> others;

        vector<BFIGAssignment const *> assignmentSet = sourceVariable->getAssignments();

        for (unsigned int x = 0; x < assignmentSet.size(); x++) {
                if (value->getUID() != assignmentSet[x]->getValue() &&
                        assignmentSet[x]->isEnabled())
                        others.push_back(assignmentSet[x]);
        }

        return others;
}


vector<BFIGAssignment const *>
BFIGAssignment::alternateAssignmentsTotal() const
{
        vector<BFIGAssignment const *> others;

        vector<BFIGAssignment const *> assignmentSet = sourceVariable->getAssignments();  

        for (unsigned int x = 0; x < assignmentSet.size(); x++) {
                if (value->getUID() != assignmentSet[x]->getValue())
                        others.push_back(assignmentSet[x]);
        }
        return others;
}


String
BFIGAssignment::toString() const
{
        String res = "";
        res += "( " ;
        res += sourceVariable->getNameString() ;
        res += " = " ;
        res += getValueString() ;
        res += " )" ;
        //res += "\n" ;
        return res;
}

namespace Mers {
        namespace Generators {
                namespace BFIG {

                        ostream&
                        operator<<(ostream& os, BFIGAssignment const & a)
                        {
                                //# Apparently, MSVC does not understand the concept of "friends" very well.
                                if (a.terse)
                                {
                                        os << a.getName() << "=" << a.getValue();
                                } else
                                {
                                        int p = os.precision();
                                        os << "(" << a.getVariable()->getNameString() << "[" << a.getName() << "]" << " = " ;
                                        os << a.getValueString() << "[" << a.getValue() << "]" << ":"
                                                 << setprecision(2) << a.getCost() << setprecision(p) << ")" ;
                                }
                                
                                return os;
                        }
                }
        }
}

//----------------------------------------
//      PRIVATE FUNCTION METHODS
//----------------------------------------

---