/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGGenerator.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 __BFIGGenerator__
#define __BFIGGenerator__

#include <cstdlib>
#include <list>

#include <Mers/Generators/AssignmentGeneratorInterface.h>

#include "BFIG.h"
#include "BFIGFactory.h"

namespace Mers {
        namespace Utils {
                namespace Containers {
                        class IntegerArray;
                }
        }
}
#include <Mers/Utils/Containers/DynamicArrayTemplate.h>

#include <Mers/Models/Base/BaseModelVariableArray.h>
#include <Mers/Models/Base/BaseModelAssignmentArray.h>

namespace Mers {
        namespace Models {
                namespace Base {
                        class BaseModelClause;
                        class BaseModelSentence;
                        class BaseModelClauseArray;
                }
        }
}

#include <vector>

namespace Mers {
        namespace Generators {
                namespace BFIG {

                        class BFIGAssignment;
                        class BFIGConstraint;
                        class BFIGConstraintUnit;
                        class BFIGImplicant;
                        class BFIGVariable;
                        class BFIGImplicantExpander;

                        class BFIGGenerator : public AssignmentGeneratorInterface
                        {
                        public:
                                typedef Mers::Utils::Containers::DynamicArrayTemplate<Mers::Models::Base::BaseModelSentence const> GuardArray;

                                //--------------------------------------------
                                //      CONSTRUCTOR
                                //--------------------------------------------
        
                                BFIGGenerator(BFIGFactory &bfigFactory,
                                        Mers::Models::Base::BaseModelVariableArray const & variableSet,
                                        Mers::Generators::BFIG::BFIGObjectiveFunction const * ocspObjectiveFunction, 
                                        Mers::Models::Base::BaseModelVariableArray const &allVariables,
                                        double cutoffCost);

                                BFIGGenerator(BFIGFactory &bfigFactory,
                                        Mers::Models::Base::BaseModelVariableArray const & variableSet,
                                        Mers::Models::Base::BaseModelVariableArray const &allVariables,
                                        Mers::Utils::Containers::IntegerArray const &valueMap,
                                        std::vector<double> const & probabilities,
                                        double cutoffCost, bool useProb = true);

                                BFIGGenerator(BFIGFactory &bfigFactory,
                                        Mers::Models::Base::BaseModelVariableArray const & variableSet,
                                        Mers::Models::Base::BaseModelVariableArray const &allVariables,
                                        Mers::Utils::Containers::IntegerArray const &valueMap,
                                        std::vector<double> const & probabilities,
                                        bool useProb = true);
        
                                virtual ~BFIGGenerator();

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

                                virtual void addConflict(Mers::Models::Base::BaseModelAssignmentArray const * newConflict);
                                virtual void addConflict(Mers::Models::Base::BaseModelAssignmentArray const & newConflict);
                                virtual void addConflicts(Mers::Models::Base::BaseModelClauseArray const & 
                                                                                                                                        newConflicts);

                                void addConflict(BFIGConstraint const * newConflict);
                                void addConflict(BFIGConstraint const & newConflict);
                                void addConflicts(std::vector<BFIGConstraint const *>const & newConflicts);

                                Mers::Models::Base::BaseModelAssignmentArray const * generateBestImplicant(
                                        long maximumVisitedStateCount, long maxSize, bool expand = true);

                                void markBestFeasible();

                                virtual void printStatistics(bool verbose = false) const;

                                virtual void restart();
                                virtual void reset();
        
                                virtual void setDebug(unsigned int state);

                                //void normalizeCosts();

                                int updateProbability(unsigned int variableUID, unsigned int valueUID,
                                        double prob);

                                int updateProbabilities(unsigned int variableUID, double probs[]);

                                int updateAllProbabilities(Mers::Models::Base::BaseModelVariableArray const &decisionVars, 
                                        Mers::Utils::Containers::IntegerArray const &valueMap,
                                        std::vector<double> const &allProbabilities);


                                int updateCost(unsigned int variableUID, unsigned int valueUID,
                                        double cost);

                                int updateCosts(unsigned int variableUID, double costs[]);

                                virtual unsigned int getFullAssignmentSize();

                                unsigned int getNumberOfConflicts() {
                                        return bfig->getNumberOfConflicts();
                                }

                                unsigned int getLargestQueueSinceReset() {
                                        return bfig->getLargestQueueSinceReset();
                                }

                                unsigned int getTotalNumberNodesExpanded() {
                                        return bfig->getNodesExpanded();
                                }

                                unsigned int getNumberCandidatesSinceReset() {
                                        return bfig->getNumberCandidatesSinceReset();
                                }

                                virtual double getNumberOfSteps() const {
                                        return bfig->getNodesExpanded();
                                }

                        protected:
                                BFIGVariable * variableToVariable(unsigned int bfigVarIndex, 
                                        Mers::Models::Base::BaseModelVariable const * varIn,
                                        std::vector<double> &costs, bool useProb) const;

                                void sortBMVariables(Mers::Models::Base::BaseModelVariableArray const &unsortedArray,
                                        Mers::Models::Base::BaseModelVariableArray &sortedArray);

                                unsigned int bfindBMVariable(Mers::Models::Base::BaseModelVariableArray &sortedVars, 
                                        unsigned int uid);

                                unsigned int getBFIGVariable(unsigned int bmVarUID,
                                        BFIGVariable * &bfigVar);

                        private:
                                std::vector<double> extractVariableProbabilities(
                                        Mers::Models::Base::BaseModelVariable const &myVariable, 
                                        unsigned int index, Mers::Utils::Containers::IntegerArray const &valueMap,
                                        std::vector<double> const &allProbabilities) const;

                                //--------------------------------------------
                                //      PRIVATE DATA MEMBERS
                                //--------------------------------------------

                                //std::vector<BFIGVariable *> allBFIGVars;
                                // The set of all BFIG variables compactly stored so BFIG is happy.
                                std::vector<BFIGVariable *> compactBFIGVars;

                                Mers::Models::Base::BaseModelVariableArray mSearchBMVars;

                                Mers::Models::Base::BaseModelAssignmentArray bmImplicant;

                                BFIG * bfig;

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

                        };
                }
        }
}

#endif //ndef __BFIGGenerator__

---