/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGVariable.h

//
// 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

#ifndef __VARIABLE_BFIG__
#define __VARIABLE_BFIG__

#include <cstdlib>
#include <iostream>
#include <vector>

#include <Mers/Utils/Lang/String.h>

#include "BFIGAssignment.h"
#include <Mers/Utils/Containers/IntegerArray.h>

#include <Mers/Utils/Containers/DynamicArray.h>

        /*# assuming a NULL current assignment is better - but for now, we'll hack in a
         *  default for testing: */
//#define VARIABLE_DEFAULT_CURRENT
//#define ASSIGNMENT_MARGINAL_PROBABILITY   0.0000000001

namespace Mers {
        namespace Models {
                namespace Base {
                        class BaseModelSentence;
                        class BaseModelVariable;
                }
        }
}

namespace Mers {
        namespace Solvers {
                namespace SAT {
                        class AssignmentTesterInterface;
                }
        }
}

namespace Mers {
        namespace Generators {
                namespace BFIG {

                        class BFIGVariable
                        {
                        public:
                                friend std::ostream &  operator<<(std::ostream & os, BFIGVariable const & v);
                                friend class BFIGAssignment;

                        public:
                                bool operator==(BFIGVariable const & v) const;
                                bool operator< (BFIGVariable const & v)  const;

                                //------------------------------------------------------
                                //      TYPE DEFINITIONS
                                //------------------------------------------------------
                                //typedef Mers::Utils::Lang::String /*const*/ Value;

                                //------------------------------------------------------
                                //      CONSTRUCTOR
                                //------------------------------------------------------

                                // Performs normalization of the domain. 'probabilityValues'
                                // turns on a special mode for probability - the cost values
                                // are transformed into their negative logs.  Otherwise,
                                // assumes additive cost function, lower is better...
                                // Costs can be specified either as a simple list or as a list
                                // of length equal to the square of the domain list length -
                                // which specifies a matrix of costs based on the 'current'
                                // value. A matrix of guards can also be supplied that
                                // condition the transitions.

                                BFIGVariable(unsigned int index,
                                        Mers::Models::Base::BaseModelVariable const * bmVariable, 
                                        std::vector<double> const & costList,
                                        bool probabilityValues = false);

                                BFIGVariable(BFIGVariable const & v);

                                ~BFIGVariable();

                                //------------------------------------------------------
                                //      PUBLIC FUNCTION MEMBERS
                                //------------------------------------------------------
                                unsigned int         getName()  const;
                                Mers::Utils::Lang::String               getNameString()  const;
                                unsigned int         getNameInt()  const;
                                BFIGAssignment const *   getAssignmentByValue(Mers::Utils::Lang::String val)  const;
                                BFIGAssignment const *   getAssignmentByValue(unsigned int val)  const;
                                BFIGAssignment *   getAssignmentByValue(unsigned int val);

                                Mers::Utils::Containers::IntegerArray   getDomain()  const;
                                std::vector<Mers::Utils::Lang::String>         getDomainStrings()  const;
                                unsigned int         getDomainSize()  const;
                                unsigned int         getDomainTotalSize()  const;
                                std::vector<BFIGAssignment const *>
                                getAssignments()  const;
                                std::vector<BFIGAssignment const *>
                                getAssignmentsSorted()  const;
                                Mers::Utils::Containers::IntegerArray   getDomainTotal()  const;
                                std::vector<BFIGAssignment const *> const &
                                getAssignmentsTotal()  const;
                                bool                 allReachable()  const;
                                bool                 nullDomain()  const;

                                void setBMVariable(Mers::Models::Base::BaseModelVariable const * newBMVar)
                                {
                                        mBMVariable = newBMVar;
                                }

                                Mers::Models::Base::BaseModelVariable const * getBMVariable() const
                                {
                                        return mBMVariable;
                                }

                                BFIGAssignment const *   getBestAssignment();  //  const;
                                double               getEntropy(bool logProbabilities = true)  const;
                                double               getEntropyTotal(bool logProbabilities = true)  const;

                                void                 setAllCosts(double cost);
                                void                 setAssignmentCostByValue(unsigned int val, double cost);
                                void                 setAssignmentCostByValue(Mers::Utils::Lang::String val, double cost);
                                void                 setAllTrueCosts(double cost);
                                void                 setAssignmentTrueCostByValue(unsigned int val, double cost);
                                void                 setAssignmentTrueCostByValue(Mers::Utils::Lang::String val, double cost);

                                double probToCost(double prob);

                                int setCost(unsigned int valUID, double cost);

                                int setCosts(double costs[]);

                                //void                 setAssignmentReachableByValue(Mers::Utils::Lang::String val, bool reachable);
                                //void                 setAssignmentReachableByValue(unsigned int val, bool reachable);
                                //void                 setReachableAll(bool reachable);
                                // returns 'false' if can't find val:
                                //BFIGAssignment const *   getCurrentAssignment()  const;
                                //bool                 setCurrent(unsigned int val);
                                //bool                 setCurrent(Mers::Utils::Lang::String val);
                                //bool                 setCurrent(BFIGAssignment const * a);
                                //bool                 clearCurrent();
                                //BFIGAssignment const *   getNextAssignment()  const;
                                //bool                 setNext(unsigned int val);
                                //bool                 setNext(Mers::Utils::Lang::String val);
                                //bool                 setNext(BFIGAssignment const * a);
                                //bool                 clearNext();
                                //void                 setTrueCostsByCurrent();
                                //void                 enableAssignmentsByGuards(AssignmentTesterInterface * currentSat);
                                //void                 enableAssignmentsByGuards();
                                //void                 reset();

                                void                 orderCosts();
                                void                 normalizeCosts();

                                BFIGAssignment const *   bestConsistentAssignment(std::vector<BFIGAssignment const *> const & others);
                                Mers::Utils::Lang::String               toString()  const;

                                // used to remove unwanted assignments:
                                //void                 eraseUnreachable();

                                // these are just for helping with random ordering:
                                void                 randomizeIndex();
                                int                  getRandomIndex();
                                //bool                 isAssigned() const;
                                //BFIGAssignment const *   getCurrentAssignment() const;
                                //void                 setCurrentAssignment(BFIGAssignment const * newCurrentAssignment_p);
                                //void                 setPreviousAssignment(BFIGAssignment const * newPreviousAssignment_p);

                                //BFIGAssignment const *   getCurrentImplicantAssignment() const;
                                //void                 setCurrentImplicantAssignment(BFIGAssignment const * newNode_p);

                                //void                             printValue() const;
                                //void                             printVariable() const;

                        private:
                                // used for converting string names to integers - could also use a hash, possibly...
                                //static unsigned int       varCount;

                                // used for random number index only
                                //static bool               seeded;

                                //void                 init(IntegerArray const & domain, std::vector<double> costs,
                                //      DynamicArrayTemplate<Mers::Models::Base::BaseModelSentence const> const & guards, bool probability);
                                void init(std::vector<double> costs, bool probability);
                                unsigned int         valueStringToInt(Mers::Utils::Lang::String val)  const;
                                Mers::Utils::Lang::String               valueIntToString(unsigned int val)  const;
                                BFIGVariable();  // to dis-allow

                                //unsigned int              name;

                                std::vector<BFIGAssignment const *>  assignments;
                                std::vector<BFIGAssignment *>        assignmentsUnconst;
                                //std::vector<BFIGAssignment const *>  assignmentsReachable;

                                int randomIndex;

                                unsigned int mIndex;

                                BFIGAssignment const * bestAssignment;
                
                                bool isSorted;

                                Mers::Models::Base::BaseModelVariable const * mBMVariable;
                        };
                }
        }
}

#endif //ndef __VARIABLE_BFIG__

---