indicator_variable.hxx

Go to the documentation of this file.

#ifndef OPENGM_INDICATOR_VARIABLE_HXX_
#define OPENGM_INDICATOR_VARIABLE_HXX_

#include <utility> // for std::pair
#include <vector>
#include <algorithm>

namespace opengm {

/*********************
 * class definition *
 *********************/
template <class INDEX_TYPE = size_t, class LABEL_TYPE = size_t>
class IndicatorVariable {
public:
   // typedefs
   typedef INDEX_TYPE IndexType;
   typedef LABEL_TYPE LabelType;

   enum LogicalOperatorType {And, Or, Not};

   typedef std::pair<IndexType, LabelType> VariableLabelPair;
   typedef std::vector<VariableLabelPair>  VariableLabelPairContainerType;

   typedef typename VariableLabelPairContainerType::const_iterator IteratorType;

   // constructors
   IndicatorVariable();
   IndicatorVariable(const IndexType variable, const LabelType label, const LogicalOperatorType logicalOperatorType = And);
   IndicatorVariable(const VariableLabelPair& variableLabelPair, const LogicalOperatorType logicalOperatorType = And);
   IndicatorVariable(const VariableLabelPairContainerType& variableLabelPairs, const LogicalOperatorType logicalOperatorType = And);
   template<class ITERATOR_TYPE>
   IndicatorVariable(const ITERATOR_TYPE variableLabelPairsBegin, const ITERATOR_TYPE variableLabelPairsEnd, const LogicalOperatorType logicalOperatorType = And);

   // modify
   void reserve(const size_t numPairs);
   void add(const IndexType variable, const LabelType label);
   void add(const VariableLabelPair& variableLabelPair);
   void add(const VariableLabelPairContainerType& variableLabelPairs);
   template<class ITERATOR_TYPE>
   void add(const ITERATOR_TYPE variableLabelPairsBegin, const ITERATOR_TYPE variableLabelPairsEnd);
   void setLogicalOperatorType(const LogicalOperatorType logicalOperatorType);

   // evaluate
   template<class ITERATOR_TYPE>
   bool operator()(const ITERATOR_TYPE statesBegin) const;

   // const access
   IteratorType begin() const;
   IteratorType end() const;
   LogicalOperatorType getLogicalOperatorType() const;
protected:
   // storage
   VariableLabelPairContainerType variableLabelPairs_;
   LogicalOperatorType            logicalOperatorType_;

   // friends
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator==(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator!=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator<(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator>(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator<=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
   template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
   friend bool operator>=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);
};

// operators for IndicatorVariable
template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator==(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator!=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator<(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator>(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator<=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator>=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2);

/***********************
 * class documentation *
 ***********************/
/******************
 * implementation *
 ******************/

// constructors
template <class INDEX_TYPE, class LABEL_TYPE>
inline IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IndicatorVariable()
: variableLabelPairs_(), logicalOperatorType_(And) {

}

template <class INDEX_TYPE, class LABEL_TYPE>
inline IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IndicatorVariable(const IndexType variable, const LabelType label, const LogicalOperatorType logicalOperatorType)
: variableLabelPairs_(1, VariableLabelPair(variable, label)),
  logicalOperatorType_(logicalOperatorType) {

}

template <class INDEX_TYPE, class LABEL_TYPE>
inline IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IndicatorVariable(const VariableLabelPair& variableLabelPair, const LogicalOperatorType logicalOperatorType)
: variableLabelPairs_(1, variableLabelPair),
  logicalOperatorType_(logicalOperatorType) {

}

template <class INDEX_TYPE, class LABEL_TYPE>
inline IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IndicatorVariable(const VariableLabelPairContainerType& variableLabelPairs, const LogicalOperatorType logicalOperatorType)
: variableLabelPairs_(variableLabelPairs),
  logicalOperatorType_(logicalOperatorType) {
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

template <class INDEX_TYPE, class LABEL_TYPE>
template<class ITERATOR_TYPE>
inline IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IndicatorVariable(const ITERATOR_TYPE variableLabelPairsBegin, const ITERATOR_TYPE variableLabelPairsEnd, const LogicalOperatorType logicalOperatorType)
: variableLabelPairs_(variableLabelPairsBegin, variableLabelPairsEnd),
  logicalOperatorType_(logicalOperatorType) {
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

// modify
template <class INDEX_TYPE, class LABEL_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::reserve(const size_t numPairs) {
   variableLabelPairs_.reserve(numPairs);
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::add(const IndexType variable, const LabelType label) {
   variableLabelPairs_.push_back(VariableLabelPair(variable, label));
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::add(const VariableLabelPair& variableLabelPair) {
   variableLabelPairs_.push_back(variableLabelPair);
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::add(const VariableLabelPairContainerType& variableLabelPairs) {
   variableLabelPairs_.insert(variableLabelPairs_.end(), variableLabelPairs.begin(), variableLabelPairs.end());
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

template <class INDEX_TYPE, class LABEL_TYPE>
template<class ITERATOR_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::add(const ITERATOR_TYPE variableLabelPairsBegin, const ITERATOR_TYPE variableLabelPairsEnd) {
   variableLabelPairs_.insert(variableLabelPairs_.end(), variableLabelPairsBegin, variableLabelPairsEnd);
   std::sort(variableLabelPairs_.begin(), variableLabelPairs_.end());
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline void IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::setLogicalOperatorType(const LogicalOperatorType logicalOperatorType) {
   logicalOperatorType_ = logicalOperatorType;
}

// evaluate
template <class INDEX_TYPE, class LABEL_TYPE>
template<class ITERATOR_TYPE>
inline bool IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::operator()(const ITERATOR_TYPE statesBegin) const {
   bool result = true;
   if(logicalOperatorType_ == And) {
      for(IteratorType indicatorVariableIter = begin(); indicatorVariableIter != end(); ++indicatorVariableIter) {
         if(indicatorVariableIter->second != statesBegin[indicatorVariableIter->first]) {
            result = false;
            break;
         }
      }
   } else if(logicalOperatorType_ == Or) {
      result = false;
      for(IteratorType indicatorVariableIter = begin(); indicatorVariableIter != end(); ++indicatorVariableIter) {
         if(indicatorVariableIter->second == statesBegin[indicatorVariableIter->first]) {
            result = true;
            break;
         }
      }
   } else {
      // logicalOperatorType_ == Not
      for(IteratorType indicatorVariableIter = begin(); indicatorVariableIter != end(); ++indicatorVariableIter) {
         if(indicatorVariableIter->second == statesBegin[indicatorVariableIter->first]) {
            result = false;
            break;
         }
      }
   }
   return result;
}

// const access
template <class INDEX_TYPE, class LABEL_TYPE>
inline typename IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IteratorType IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::begin() const {
   return variableLabelPairs_.begin();
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline typename IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::IteratorType IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::end() const {
   return variableLabelPairs_.end();
}

template <class INDEX_TYPE, class LABEL_TYPE>
inline typename IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::LogicalOperatorType IndicatorVariable<INDEX_TYPE, LABEL_TYPE>::getLogicalOperatorType() const {
   return logicalOperatorType_;
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator==(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   return (indicatorVar1.logicalOperatorType_ == indicatorVar2.logicalOperatorType_) && (indicatorVar1.variableLabelPairs_ == indicatorVar2.variableLabelPairs_);
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator!=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   return (indicatorVar1.logicalOperatorType_ != indicatorVar2.logicalOperatorType_) || (indicatorVar1.variableLabelPairs_ != indicatorVar2.variableLabelPairs_);
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator<(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   if(indicatorVar1.logicalOperatorType_ < indicatorVar2.logicalOperatorType_) {
      return true;
   } else if(indicatorVar1.logicalOperatorType_ > indicatorVar2.logicalOperatorType_) {
      return false;
   } else {
      if(indicatorVar1.variableLabelPairs_.size() > indicatorVar2.variableLabelPairs_.size()) {
         return false;
      }
      if(indicatorVar1.variableLabelPairs_.size() == indicatorVar2.variableLabelPairs_.size()) {
         if(indicatorVar1.variableLabelPairs_.size() == 0) {
            return false;
         }
         for(size_t i = 0; i < indicatorVar1.variableLabelPairs_.size(); ++i) {
            if(indicatorVar1.variableLabelPairs_[i].first > indicatorVar2.variableLabelPairs_[i].first) {
               return false;
            } else if(indicatorVar1.variableLabelPairs_[i].first == indicatorVar2.variableLabelPairs_[i].first) {
               if(indicatorVar1.variableLabelPairs_[i].second >= indicatorVar2.variableLabelPairs_[i].second) {
                  return false;
               }
            }
         }
      }
      return true;
   }
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator>(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   if(indicatorVar1.logicalOperatorType_ < indicatorVar2.logicalOperatorType_) {
      return false;
   } else if(indicatorVar1.logicalOperatorType_ > indicatorVar2.logicalOperatorType_) {
      return true;
   } else {
      if(indicatorVar1.variableLabelPairs_.size() < indicatorVar2.variableLabelPairs_.size()) {
         return false;
      }
      if(indicatorVar1.variableLabelPairs_.size() == indicatorVar2.variableLabelPairs_.size()) {
         if(indicatorVar1.variableLabelPairs_.size() == 0) {
            return false;
         }
         for(size_t i = 0; i < indicatorVar1.variableLabelPairs_.size(); ++i) {
            if(indicatorVar1.variableLabelPairs_[i].first < indicatorVar2.variableLabelPairs_[i].first) {
               return false;
            } else if(indicatorVar1.variableLabelPairs_[i].first == indicatorVar2.variableLabelPairs_[i].first) {
               if(indicatorVar1.variableLabelPairs_[i].second <= indicatorVar2.variableLabelPairs_[i].second) {
                  return false;
               }
            }
         }
      }
      return true;
   }
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator<=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   if(indicatorVar1.logicalOperatorType_ < indicatorVar2.logicalOperatorType_) {
      return true;
   } else if(indicatorVar1.logicalOperatorType_ > indicatorVar2.logicalOperatorType_) {
      return false;
   } else {
      if(indicatorVar1.variableLabelPairs_.size() > indicatorVar2.variableLabelPairs_.size()) {
         return false;
      }
      if(indicatorVar1.variableLabelPairs_.size() == indicatorVar2.variableLabelPairs_.size()) {
         for(size_t i = 0; i < indicatorVar1.variableLabelPairs_.size(); ++i) {
            if(indicatorVar1.variableLabelPairs_[i].first > indicatorVar2.variableLabelPairs_[i].first) {
               return false;
            } else if(indicatorVar1.variableLabelPairs_[i].first == indicatorVar2.variableLabelPairs_[i].first) {
               if(indicatorVar1.variableLabelPairs_[i].second > indicatorVar2.variableLabelPairs_[i].second) {
                  return false;
               }
            }
         }
      }
      return true;
   }
}

template<class INDEX1_TYPE, class LABEL1_TYPE, class INDEX2_TYPE, class LABEL2_TYPE>
bool operator>=(const IndicatorVariable<INDEX1_TYPE, LABEL1_TYPE>& indicatorVar1, const IndicatorVariable<INDEX2_TYPE, LABEL2_TYPE>& indicatorVar2) {
   if(indicatorVar1.logicalOperatorType_ < indicatorVar2.logicalOperatorType_) {
      return false;
   } else if(indicatorVar1.logicalOperatorType_ > indicatorVar2.logicalOperatorType_) {
      return true;
   } else {
      if(indicatorVar1.variableLabelPairs_.size() < indicatorVar2.variableLabelPairs_.size()) {
         return false;
      }
      if(indicatorVar1.variableLabelPairs_.size() == indicatorVar2.variableLabelPairs_.size()) {
         for(size_t i = 0; i < indicatorVar1.variableLabelPairs_.size(); ++i) {
            if(indicatorVar1.variableLabelPairs_[i].first < indicatorVar2.variableLabelPairs_[i].first) {
               return false;
            } else if(indicatorVar1.variableLabelPairs_[i].first == indicatorVar2.variableLabelPairs_[i].first) {
               if(indicatorVar1.variableLabelPairs_[i].second < indicatorVar2.variableLabelPairs_[i].second) {
                  return false;
               }
            }
         }
      }
      return true;
   }
}

} // namespace opengm

#endif /* OPENGM_INDICATOR_VARIABLE_HXX_ */