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

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

#ifndef __BFIGObjectiveFunction__
#define __BFIGObjectiveFunction__

#include <vector>
#include <math.h>

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

namespace Mers {
        namespace Models {
                namespace Base {
                        class BaseModelAssignment;
                        class BaseModelAssignmentArray;
                }
        }
        namespace Generators {
                namespace BFIG {

                        class BFIGAssignment;

                        class BFIGObjectiveFunction
                        {

                        public:
                                //--------------------------------------------
                                //      CONSTRUCTOR
                                //--------------------------------------------

                                BFIGObjectiveFunction(const bool mpi = true) : objectiveFunctionIsMPI(mpi) {};
        
                                virtual ~BFIGObjectiveFunction() {};

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

                                double getUtility(std::vector<Mers::Generators::BFIG::BFIGAssignment const *> & implicantAssignments,
                                                                        int sourceStateIndex = -1) const
                                {
                                        double utility;
                                        std::vector<Mers::Models::Base::BaseModelAssignment const *> bmAssignments;
                                        for(unsigned int i=0; i<implicantAssignments.size(); i++)
                                                        bmAssignments.push_back((Mers::Models::Base::BaseModelAssignment const *)
                                                                (implicantAssignments[i]));
                                        utility = calculateUtility(bmAssignments, sourceStateIndex);
                                        bmAssignments.clear();
                                        return utility;
                                };
                                double getUtility(Mers::Models::Base::BaseModelAssignmentArray const * bmAssignments,
                                                                        int sourceStateIndex = -1) const
                                {
                                        double utility;
                                        std::vector<Mers::Models::Base::BaseModelAssignment const *> bmAssignmentVector;
                                        for(unsigned int i=0; i<bmAssignments->getLength(); i++)
                                                        bmAssignmentVector.push_back((*bmAssignments)[i]);
                                        utility = calculateUtility(bmAssignmentVector, sourceStateIndex);
                                        bmAssignmentVector.clear();
                                        return utility;
                                };
                                double getCost(std::vector<Mers::Generators::BFIG::BFIGAssignment const *> & implicantAssignments,
                                                                int sourceStateIndex = -1) const
                                {
                                        double cost;
                                        std::vector<Mers::Models::Base::BaseModelAssignment const *> bmAssignments;
                                        for(unsigned int i=0; i<implicantAssignments.size(); i++)
                                                        bmAssignments.push_back((Mers::Models::Base::BaseModelAssignment const *)
                                                                (implicantAssignments[i]));
                                        cost = (-1.0) * log(calculateUtility(bmAssignments, sourceStateIndex));
                                        bmAssignments.clear();
                                        return cost;
                                };

                                bool isMPI(void) const
                                {
                                        return objectiveFunctionIsMPI;
                                };

                                
                        protected:
                                //--------------------------------------------
                                //      PROTECTED FUNCTION METHODS
                                //--------------------------------------------
                                
                                 virtual double calculateUtility(std::vector<Mers::Models::Base::BaseModelAssignment const *> & bmAssignments,
                                                                                                        int sourceStateIndex = -1) const = 0;

                        private:
                                //--------------------------------------------
                                //      PRIVATE FUNCTION METHODS
                                //--------------------------------------------

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

                                // States whether the objective function is MPI or not
                                const bool objectiveFunctionIsMPI;
                        };
                }
        }
}

#endif //ndef __BFIGObjectiveFunction__

---