/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGVariable.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

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

#include "BFIGVariable.h"

#include <Mers/Models/Base/BaseModelVariable.h>

#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <cassert>
#include <cmath>
#include <iomanip>
#include "BFIGAssignment.h"

#include "ListManipulator.h"

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

#include <Mers/Models/Base/BaseModelClause.h>
#include <Mers/Models/Base/BaseModelDomain.h>


namespace Mers {
        namespace Generators {
                namespace BFIG {
                        const double c_MinimumProbability = 1e-100;
                }
        }
}

using Mers::Generators::BFIG::c_MinimumProbability;

//unsigned int BFIGVariable::varCount = 0;
//bool BFIGVariable::seeded = false;

/*#
        // useful in conversions. Stupidly absent in C++...
//static String
//intString(int n)
//{
//      char buf[32];
//      sprintf(buf, "%d", n);
//      return String(buf);
//}
*/

/*
static String
intString(unsigned int n)
{
        char buf[32];
        sprintf(buf, "%u", n);
        return String(buf);
}
*/

static bool
assignment_cost_less(BFIGAssignment const * a1, 
        BFIGAssignment const * a2)
{
        return ( a1->getCost() < a2->getCost() );
}

//template void vector<BFIGAssignment *>::sort<assignment_comp_func>(assignment_comp_func);

        //---------------------------------
        //      CONSTRUCTORS
        //---------------------------------
BFIGVariable::BFIGVariable(unsigned int index, 
        BaseModelVariable const * bmVariable,
        vector<double> const & costList, bool probabilityValues)
: assignments(), assignmentsUnconst(),
  bestAssignment(NULL), isSorted(false)
{
        mBMVariable = bmVariable;
        mIndex = index;
        //varCount++;
        //name = varCount;
        //nameString = new String(varName);
        //domainStrings = new String [domainList.size()];
        //IntegerArray domainIntList;
        //vector<String>::const_iterator dIter;
        //unsigned int i;
        //for (i = 0, dIter = domainList.begin(); dIter != domainList.end(); dIter++, i++)
        //{
        //      domainStrings[i] = (*dIter);
        //      domainIntList.pushBack(i);
        //}
        init(costList, probabilityValues);
}

/*
BFIGVariable::BFIGVariable(unsigned int varName, IntegerArray const & domainList,
                   vector<double> const & costList, bool probabilityValues,
                   DynamicArrayTemplate<BaseModelSentence const> const & guardList)
: assignments(), assignmentsUnconst(), assignmentsReachable(),
  bestAssignment(NULL), isSorted(false)
{
        bmVariable = NULL;
        nameString = NULL;
        domainStrings = NULL;
        name = varName;
        init(domainList, costList, guardList, probabilityValues);
}


BFIGVariable::BFIGVariable(unsigned int varName, String varNameString,
                   IntegerArray const & domainList,
                   vector<String> const & domainListString,
                   vector<double> const & costList, bool probabilityValues,
                   DynamicArrayTemplate<BaseModelSentence const> const & guardList)
: assignments(), assignmentsUnconst(), assignmentsReachable(),
  bestAssignment(NULL), isSorted(false)
{
        assert(domainList.getLength() == domainListString.size());
        bmVariable = NULL;
        name = varName;
        nameString = new String(varNameString);

        // NOTE: the const int here is to ward off the internal
        // compiler error on gcc 2.95.2
        const int numDomainStrings = domainList.getLength();
        domainStrings = new String [numDomainStrings];

        vector<String>::const_iterator dIter;
        unsigned int i;
        for (i = 0, dIter = domainListString.begin();
             dIter != domainListString.end(); dIter++, i++)
        {
                domainStrings[i] = (*dIter);
        }
        init(domainList, costList, guardList, probabilityValues);
}
*/

BFIGVariable::BFIGVariable(BFIGVariable const & v)
: assignments(v.assignments),
  assignmentsUnconst(v.assignmentsUnconst),
  bestAssignment(v.bestAssignment), isSorted(v.isSorted)
{
}


void
BFIGVariable::init(vector<double> costList, bool probabilityValues)
{
        assert( (mBMVariable->getDomain()->getLength() == costList.size()));

        if (probabilityValues)
        {
                //cout << "Converting to probability costs." << endl;
                vector<double> logCostList;
                vector<double>::const_iterator costIter;
                unsigned int i;
                for (i = 0, costIter = costList.begin();
                     costIter != costList.end(); costIter++, i++)
                {
                        double c = (*costIter);
                        logCostList.push_back(probToCost(c));
                }
                costList = logCostList;
        }

        BaseModelDomain const &domain = *(mBMVariable->getDomain());
        BaseModelDomain::ConstantIterator valueIter;
        vector<double>::const_iterator costIter;
        // simple costs given
        for (valueIter = domain.begin(), costIter = costList.begin();
                valueIter != domain.end(); valueIter++, costIter++)
        {
                BFIGAssignment * newAssignment = new BFIGAssignment(this, &(*valueIter), (*costIter));
                assignments.push_back(newAssignment);
                assignmentsUnconst.push_back(newAssignment);
        }

        randomIndex = 0;

        normalizeCosts();
}


BFIGVariable::~BFIGVariable()
{
        // destroy the Assignments - no one may hang on to them anyway.
        vector<BFIGAssignment *>::iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                delete (*aIter);
        }
}


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

unsigned int
BFIGVariable::getName()  const
{
        return getNameInt();
}


String
BFIGVariable::getNameString()  const
{
        return mBMVariable->getName();
}


unsigned int
BFIGVariable::getNameInt()  const
{
        return mIndex;
}


unsigned int
BFIGVariable::valueStringToInt(String val)  const
{
        BaseModelDomain const &domain = *(mBMVariable->getDomain());
        for (unsigned int i = 0; i < domain.getLength(); i++)
        {
                if (val == domain[i]->getName())
                        return i;
        }
        cerr << "Error in Variable '" << getNameString() << "': unknown value string: '"
                << val << "'!" << endl;
        return 0;
}


String
BFIGVariable::valueIntToString(unsigned int val)  const
{
        BaseModelDomain const &domain = *(mBMVariable->getDomain());
        if (val >= domain.getLength())
        {
                cerr << "Error in Variable: value too large: " << val << "!" << endl;
                return "";
        }
        return domain[val]->getName();
}


bool
BFIGVariable::operator==(BFIGVariable const & v) const
{
        return getName() == v.getName();
}


bool
BFIGVariable::operator< (BFIGVariable const & v)  const
{
        return getName() < v.getName();
}


BFIGAssignment const *
BFIGVariable::getAssignmentByValue(unsigned int val) const
{
        vector<BFIGAssignment const *>::const_iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                if (val == (*aIter)->getValue())
                        return (*aIter);
        }

        return NULL;
}


BFIGAssignment *
BFIGVariable::getAssignmentByValue(unsigned int val)
{
        vector<BFIGAssignment *>::iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                if (val == (*aIter)->getValue())
                        return (*aIter);
        }

        return NULL;
}


BFIGAssignment const *
BFIGVariable::getAssignmentByValue(String val) const
{
        return getAssignmentByValue(valueStringToInt(val));
}

/*
void
BFIGVariable::reset()
{
        setCurrent(defaultAssignment);
        clearNext();
}
*/

/*
void
BFIGVariable::setReachableAll(bool reachable)
{
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                (*aIter)->setReachable(reachable);
        }
}
*/
/*
void
BFIGVariable::eraseUnreachable()
{
        vector<BFIGAssignment *>::iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); )
        {
                if (!(*aIter)->isReachable())
                {
                        //delete (*aIter);
                        aIter = assignmentsUnconst.erase(aIter);
                } else
                {
                        aIter++;
                }
        }
        vector<BFIGAssignment const *>::iterator a2Iter;
        for (a2Iter = assignments.begin(); a2Iter != assignments.end(); )
        {
                if (!(*a2Iter)->isReachable())
                {
                        delete (*a2Iter);
                        a2Iter = assignments.erase(a2Iter);
                } else
                {
                        a2Iter++;
                }
        }
}
*/

/*
void
BFIGVariable::setAssignmentReachableByValue(unsigned int val, bool reachable)
{
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator assignmentIter;
        for (assignmentIter = assignmentsUnconst.begin();
             assignmentIter != assignmentsUnconst.end();
                 assignmentIter++)
        {
                if (val == (*assignmentIter)->getValue())
                {
                        (*assignmentIter)->setReachable(reachable);
                        return;
                }
        }

        cerr << "Error: Variable " << getName() << " could not find assignment to "
             << val << " to set reachability!" << endl;
}
*/

/*
void
BFIGVariable::setAssignmentReachableByValue(String val, bool reachable)
{
        setAssignmentReachableByValue(valueStringToInt(val), reachable);
}
*/


void
BFIGVariable::setAssignmentCostByValue(unsigned int val, double cost)
{
        isSorted = false;
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                if (val == (*aIter)->getValue())
                {
                        (*aIter)->setCost(cost);
                        return;
                }
        }

        cerr << "Error: Variable " << getName() << " could not find assignment to "
             << val << " to set cost!" << endl;
}

void
BFIGVariable::setAssignmentTrueCostByValue(String val, double cost)
{
        setAssignmentTrueCostByValue(valueStringToInt(val), cost);
}

void
BFIGVariable::setAssignmentTrueCostByValue(unsigned int val, double cost)
{
        isSorted = false;
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                if (val == (*aIter)->getValue())
                {
                        (*aIter)->setTrueCost(cost);
                        return;
                }
        }

        cerr << "Error: Variable " << getName() << " could not find assignment to "
             << val << " to set cost!" << endl;
}


void
BFIGVariable::setAssignmentCostByValue(String val, double cost)
{
        setAssignmentCostByValue(valueStringToInt(val), cost);
}


double BFIGVariable::probToCost(double prob)
{
#ifdef ASSIGNMENT_MARGINAL_PROBABILITY
        if ( prob < ASSIGNMENT_MARGINAL_PROBABILITY )
        {
                prob = ASSIGNMENT_MARGINAL_PROBABILITY;
                //cout << "Assuming marginal probability for Variable " << name << endl;
        }
#endif
        // must account for log(0).  Clamp it at > c_MinimumProbability.
        prob = std::max( prob, c_MinimumProbability );
        return -log(prob);
}


int BFIGVariable::setCost(unsigned int valUID, double cost)
{
        BFIGAssignment * asg = getAssignmentByValue(valUID);
        if(asg == NULL)
                return 1;
        asg->setTrueCost(cost);

        //BFIGAssignment const * best = getBestAssignment();
        //double bestReachableCost = 0.0;
        //if (best)
        //{
        //      bestReachableCost = best->getTrueCost();
        //}

        //vector<BFIGAssignment *>::iterator aIter;
        //for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        //{
        //      if (bestReachableCost != 0.0)  //ugh
        //              asg->setCost(cost - bestReachableCost);
        //      else
        //              asg->setCost(cost);
        //}
        return 0;
}


int BFIGVariable::setCosts(double costs[])
{
        unsigned int x;
        for (x = 0; x < assignmentsUnconst.size(); x++)
        {
                assignmentsUnconst[x]->setTrueCost(costs[x]);
        }
        return 0;
}



/*
void
BFIGVariable::setTrueCostsByCurrent()
{
        isSorted = false;
        bestAssignment = NULL;
        if (currentAssignment == NULL)
        {
                //cerr << "Error: Variable " << getName() << " can't set costs by current value "
                //     << "with no current value!" << endl;
                setAllTrueCosts(0.0);
                return;
        }
        vector<BFIGAssignment *>::const_iterator assignmentIter;
        for (assignmentIter = assignmentsUnconst.begin();
             assignmentIter != assignmentsUnconst.end();
                 assignmentIter++)
        {
                (*assignmentIter)->setTrueCostByValue(currentAssignment->getValueInt());
        }
}
*/

/*
void
BFIGVariable::convertGuards(ModelConvertorInterface const * mc)
{
        vector<BFIGAssignment *>::const_iterator assignmentIter;
        for (assignmentIter = assignmentsUnconst.begin();
             assignmentIter != assignmentsUnconst.end();
                 assignmentIter++)
        {
                (*assignmentIter)->convertGuards(mc);
        }
}
*/

/*
void
BFIGVariable::enableAssignmentsByGuards(AssignmentTesterInterface * currentSat)
{
        isSorted = false;
        bestAssignment = NULL;
                // start by assuming all are reachable:
        setReachableAll(true);

        if (currentAssignment == NULL)
        {
                //cerr << "Error: Variable " << getName() << " can't check guards "
                //     << "with no current value!" << endl;
                return;
        }

        vector<BFIGAssignment *>::const_iterator assignmentIter;
        for (assignmentIter = assignmentsUnconst.begin();
             assignmentIter != assignmentsUnconst.end();
                 assignmentIter++)
        {
                (*assignmentIter)->enableByGuard(currentSat, currentAssignment->getValueInt());
        }
}
*/

/*
void
BFIGVariable::enableAssignmentsByGuards()
{
        isSorted = false;
        bestAssignment = NULL;
                // start by assuming all are reachable:
        setReachableAll(true);

        if (currentAssignment == NULL)
        {
                //# stuck! no guards independent of current state!! What is right here???
                //#     cerr << "Error: Variable " << getName() << " can't check guards "
                //#          << "with no current value!" << endl;
                return;
        }

        vector<BFIGAssignment *>::const_iterator assignmentIter;
        for (assignmentIter = assignmentsUnconst.begin();
             assignmentIter != assignmentsUnconst.end();
                 assignmentIter++)
        {
                (*assignmentIter)->enableByGuard(currentAssignment->getValueInt());
        }
}
*/

void
BFIGVariable::normalizeCosts()
{
        /*# must have in order for getBestAssignment to work!! - not currently. */
        //orderCosts();

        //BFIGAssignment const * best = getBestAssignment();
        //double bestReachableCost = 0.0;
        //if (best)
        //{
        //      bestReachableCost = best->getTrueCost();
        //} else
        //{
                //return
        //}

        //cout << "normalizing:  best = " << bestReachableCost << endl;

        //# if (bestReachableCost == 0.0)  // unclean, but...
        //#     return;
        //vector<BFIGAssignment *>::iterator aIter;
        //for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        //{
        //      if (bestReachableCost != 0.0)  //ugh
        //              (*aIter)->setCost((*aIter)->getTrueCost() - bestReachableCost);
        //      else
        //              (*aIter)->setCost((*aIter)->getTrueCost());
        //}

/*#
        //cout << "    ";
        //for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        //{
        //      cout << (*aIter)->getTrueCost() << "  ";
        //}
        //cout << endl;
        //cout << "    ";
        //for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        //{
        //      cout << (*aIter)->getCost() << "  ";
        //}
        //cout << endl;
*/
}


void
BFIGVariable::orderCosts()
{
        if (isSorted)
                return;
        ListManipulator<BFIGAssignment const *> lm;
        lm.sort(assignments, assignment_cost_less);
        isSorted = true;
}


BFIGAssignment const *
BFIGVariable::getBestAssignment()  //const
{
        //orderCosts();

        if (bestAssignment)
                return bestAssignment;
        // assignments must remain as a sorted list, best (lowest) first. - (not for now)
        BFIGAssignment const * res = NULL;
        double bestFound = 999999999.9;
        vector<BFIGAssignment const *>::const_iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                if (!res || ( (*aIter)->getTrueCost() < bestFound ))
                {
                        res = (*aIter);
                        bestFound = res->getTrueCost();
                }
        }
        bestAssignment = res;
        return res;
}

/*
BFIGAssignment const *
BFIGVariable::getCurrentAssignment() const
{
        return currentAssignment;
}
*/
/*
bool
BFIGVariable::setCurrent(BFIGAssignment const * a)
{
        currentAssignment = a;
        if (currentAssignment)
        {
                setTrueCostsByCurrent();
                return true;
        }
        return false;
}
*/
/*
bool
BFIGVariable::setCurrent(unsigned int val)
{
        setCurrent(getAssignmentByValue(val));
        if (currentAssignment)
                return true;

        //if (debug)  // may want anyway!
        //{
        //      cerr << "Error: Variable " << getName() << " could not find assignment to "
        //           << val << " to set current state!" << endl;
        //}

        return false;
}
*/

/*
bool
BFIGVariable::setCurrent(String val)
{
        setCurrent(getAssignmentByValue(val));
        if (currentAssignment)
                return true;

        //if (debug)  // may want anyway!
        //{
        //      cerr << "Error: Variable " << getName() << " could not find assignment to "
        //           << val << " to set current state!" << endl;
        //}

        return false;
}
*/

/*
bool
BFIGVariable::clearCurrent()
{
        setCurrent((BFIGAssignment const *)NULL);
        return true;
}
*/

/*
BFIGAssignment const *
BFIGVariable::getNextAssignment() const
{
        return nextAssignment;
}
*/

/*
bool
BFIGVariable::setNext(BFIGAssignment const * a)
{
        nextAssignment = a;
        return true;
}
*/

/*
bool
BFIGVariable::setNext(unsigned int val)
{
        setNext(getAssignmentByValue(val));
        if (nextAssignment)
                return true;

        //if (debug)  // may want anyway!
        //{
        //      cerr << "Error: Variable " << getName() << " could not find assignment to "
        //           << val << " to set current state!" << endl;
        //}
        return false;
}
*/

/*
bool
BFIGVariable::setNext(String val)
{
        setNext(getAssignmentByValue(val));
        if (nextAssignment)
                return true;

        //if (debug)  // may want anyway!
        //{
        //      cerr << "Error: Variable " << getName() << " could not find assignment to "
        //           << val << " to set current state!" << endl;
        //}
        return false;
}
*/

/*
bool
BFIGVariable::clearNext()
{
        setNext((BFIGAssignment const *)NULL);
        return true;
}
*/

void
BFIGVariable::setAllCosts(double cost)
{
        isSorted = false;
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                (*aIter)->setCost(cost);
        }
}


void
BFIGVariable::setAllTrueCosts(double cost)
{
        isSorted = false;
        bestAssignment = NULL;
        vector<BFIGAssignment *>::const_iterator aIter;
        for (aIter = assignmentsUnconst.begin(); aIter != assignmentsUnconst.end(); aIter++)
        {
                (*aIter)->setTrueCost(cost);
        }
}


IntegerArray
BFIGVariable::getDomain() const
{
        IntegerArray res;
        vector<BFIGAssignment const *>::const_iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                res.pushBack((*aIter)->getValueInt());
        }
        return res;
}


vector<String>
BFIGVariable::getDomainStrings() const
{
        vector<String> res;
        vector<BFIGAssignment const *>::const_iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                res.push_back((*aIter)->getValueString());
        }
        return res;
}


unsigned int
BFIGVariable::getDomainSize() const
{
        return mBMVariable->getDomain()->getLength();
        //unsigned int res = 0;
        //vector<BFIGAssignment const *>::const_iterator aIter;
        //for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        //{
        //      if ((*aIter)->isReachable())
        //              res++;
        //}
        //return res;
}


unsigned int
BFIGVariable::getDomainTotalSize() const
{
        return mBMVariable->getDomain()->getLength();
}


IntegerArray
BFIGVariable::getDomainTotal() const
{
        IntegerArray res;
        vector<BFIGAssignment const *>::const_iterator aIter;
        for (aIter = assignments.begin(); aIter != assignments.end(); aIter++)
        {
                res.pushBack((*aIter)->getValueInt());
        }
        return res;
}


vector<BFIGAssignment const *>
BFIGVariable::getAssignments() const
{
        if (allReachable())
                return assignments;
        vector<BFIGAssignment const *> assignmentsC;
        vector<BFIGAssignment const *>::const_iterator
                assignmentIter;
        for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
                 assignmentIter++)
        {
                assignmentsC.push_back(*assignmentIter);
        }
        return assignmentsC;
}


vector<BFIGAssignment const *>
BFIGVariable::getAssignmentsSorted() const
{
        if (!isSorted)
                ((BFIGVariable *)this)->orderCosts();
        return getAssignments();
}


vector<BFIGAssignment const *> const &
BFIGVariable::getAssignmentsTotal()  const
{
        return assignments;
/*#
        //vector<BFIGAssignment const *> assignmentsC;
        //vector<BFIGAssignment const *>::const_iterator assignmentIter;
        //for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
        //       assignmentIter++)
        //{
        //      assignmentsC.push_back(*assignmentIter);
        //}
        //return assignmentsC;
*/
}


bool
BFIGVariable::allReachable()  const
{
        //vector<BFIGAssignment const *>::const_iterator assignmentIter;
        //for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
        //       assignmentIter++)
        //{
        //      if (!(*assignmentIter)->isReachable())
        //              return false;
        //}
        return true;
}


bool
BFIGVariable::nullDomain()  const
{
        return mBMVariable->getDomain()->getLength() > 0;
        //vector<BFIGAssignment const *>::const_iterator assignmentIter;
        //for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
        //       assignmentIter++)
        //{
        //      if ((*assignmentIter)->isReachable())
        //              return false;
        //}
        //return true;
}


double
BFIGVariable::getEntropy(bool logProbabilities) const
{
        double res = 0.0;
        vector<BFIGAssignment const *>::const_iterator assignmentIter;
        for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
                 assignmentIter++)
        {
                if (logProbabilities)
                {
                        if ((*assignmentIter)->getTrueCost() >= c_MinimumProbability)
                                res += exp(-(*assignmentIter)->getTrueCost()) *
                                            (*assignmentIter)->getTrueCost();
                } else
                {
                        if ((*assignmentIter)->getTrueCost() >= c_MinimumProbability)
                                res += (*assignmentIter)->getTrueCost() * -1 *
                                        log((*assignmentIter)->getTrueCost());
                }
        }
        return res;
}


double
BFIGVariable::getEntropyTotal(bool logProbabilities) const
{
        double res = 0.0;
        vector<BFIGAssignment const *>::const_iterator assignmentIter;
        for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
                 assignmentIter++)
        {
                if (logProbabilities)
                {
                        if ((*assignmentIter)->getTrueCost() >= c_MinimumProbability )
                                res += exp(-(*assignmentIter)->getTrueCost()) *
                                            (*assignmentIter)->getTrueCost();
                } else
                {
                        if ((*assignmentIter)->getTrueCost() >= c_MinimumProbability )
                                res += (*assignmentIter)->getTrueCost() * -1 *
                                        log((*assignmentIter)->getTrueCost());
                }
        }
        return res;
}


BFIGAssignment const *
BFIGVariable::bestConsistentAssignment(vector<BFIGAssignment const *> const & otherAssignments)
{
        orderCosts();

        vector<BFIGAssignment const *>::const_iterator assignmentIter;
        for (assignmentIter = assignments.begin(); assignmentIter != assignments.end();
                 assignmentIter++)
        {
                if ((*assignmentIter)->compatible(otherAssignments))
                        return (*assignmentIter);
        }
        return NULL;
}


void
BFIGVariable::randomizeIndex()
{
        //if (!seeded)
        //{
        //      srand((unsigned)time(NULL));
        //      seeded = true;
        //}
        while (randomIndex == 0)
                randomIndex = rand();
}


int
BFIGVariable::getRandomIndex()
{
        if (randomIndex == 0)
                randomizeIndex();
        return randomIndex;
}


String
BFIGVariable::toString() const
{
        BaseModelDomain const &domain = *(mBMVariable->getDomain());
        unsigned int valIndex;
        //IntegerArray varDomain = domain;
        //IntegerArray::iterator varDomainIter;

        String res = "";

        res += "[";
        res += getNameString() ;
/*#
        //if (isAssigned())
        //{
        //      res += " = ";
        //      res += getCurrentAssignment()->getValue() ;
        //}
*/
        res += ", {" ;
        for (valIndex = 0; valIndex != domain.getLength();
                valIndex++)
        {
                if (valIndex != 0)
                        res += ", " ;
                res += domain[valIndex]->getName() ;
        }
        res += "}]" ;
        //res += "\n" ;
        return res;
}

namespace Mers {
        namespace Generators {
                namespace BFIG {

                        ostream&
                        operator<<(ostream& os, Mers::Generators::BFIG::BFIGVariable const & v)
                        {
                                //# Apparently, MSVC does not understand the concept of "friends" very well.
                                int p = os.precision();
                                vector<BFIGAssignment *>::const_iterator domainIter;

                                os << "[" << v.getNameString() << "(" << v.getNameInt() << ")";
                                os << ":  { " ;
                                bool first = true;
                                for (domainIter = v.assignmentsUnconst.begin(); 
                                                 domainIter != v.assignmentsUnconst.end(); domainIter++)
                                {
                                        if (first)
                                                first = false;
                                        else
                                                os << ", " ;
                                        //if (!(*domainIter)->isReachable())
                                        //      os << "-";
                                        //if ((*domainIter) == v.getCurrentAssignment())
                                        //      os << "+";
                                        //if ((*domainIter) == v.getNextAssignment())
                                        //      os << ">";
                                        os << (*domainIter)->getValueString()
                                                 << "(" << (*domainIter)->getValueInt() << ")" << ":" ;
                                        os << setprecision(2) << (*domainIter)->getCost() << setprecision(p) ;
                                }
                                os << " }]" ;
                                return os;
                        }
                }
        }
}

---