linear_constraint.hxx

Go to the documentation of this file.

#ifndef OPENGM_LINEAR_CONSTRAINT_HXX_
#define OPENGM_LINEAR_CONSTRAINT_HXX_

#include <iterator>
#include <vector>

#include <opengm/datastructures/indicator_variable.hxx>

namespace opengm {

/*********************
 * class definition *
 *********************/
class LinearConstraintTraits {
public:
   // typedefs
   struct LinearConstraintOperator {enum ValueType {LessEqual, Equal, GreaterEqual};};
};

template<class VALUE_TYPE, class INDEX_TYPE = size_t, class LABEL_TYPE = size_t>
class LinearConstraint {
public:
   // typedefs
   typedef VALUE_TYPE ValueType;
   typedef INDEX_TYPE IndexType;
   typedef LABEL_TYPE LabelType;

   typedef IndicatorVariable<IndexType, LabelType>          IndicatorVariableType;
   typedef std::vector<IndicatorVariableType>               IndicatorVariablesContainerType;
   typedef std::vector<ValueType>                           CoefficientsContainerType;
   typedef ValueType                                        BoundType;
   typedef LinearConstraintTraits::LinearConstraintOperator LinearConstraintOperatorType;
   typedef LinearConstraintOperatorType::ValueType          LinearConstraintOperatorValueType;

   typedef typename IndicatorVariableType::IteratorType             VariableLabelPairsIteratorType;
   typedef typename IndicatorVariablesContainerType::const_iterator IndicatorVariablesIteratorType;
   typedef typename CoefficientsContainerType::const_iterator       CoefficientsIteratorType;

   // constructors
   LinearConstraint();
   LinearConstraint(const IndicatorVariablesContainerType& indicatorVariables, const CoefficientsContainerType& coefficients, const BoundType bound = 0.0, const LinearConstraintOperatorValueType constraintOperator = LinearConstraintOperatorType::LessEqual);
   template<class INDICATOR_VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   LinearConstraint(const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesBegin, const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesEnd, const COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const BoundType bound = 0.0, const LinearConstraintOperatorValueType constraintOperator = LinearConstraintOperatorType::LessEqual);
   LinearConstraint(const LinearConstraint<ValueType, IndexType, LabelType>& linearConstraint);

   // modify
   void reserve(const size_t numIndicatorVariables);
   void add(const IndicatorVariableType& indicatorVariable, const ValueType coefficient);
   void add(const IndicatorVariablesContainerType& indicatorVariables, const CoefficientsContainerType& coefficients);
   template<class INDICATOR_VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
   void add(const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesBegin, const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesEnd, const COEFFICIENTS_ITERATOR_TYPE coefficientsBegin);
   void setBound(const BoundType bound);
   void setConstraintOperator(const LinearConstraintOperatorValueType constraintOperator);

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

   // const access
   IndicatorVariablesIteratorType    indicatorVariablesBegin() const;
   IndicatorVariablesIteratorType    indicatorVariablesEnd() const;
   CoefficientsIteratorType          coefficientsBegin() const;
   CoefficientsIteratorType          coefficientsEnd() const;
   BoundType                         getBound() const;
   LinearConstraintOperatorValueType getConstraintOperator() const;
protected:
   // storage
   IndicatorVariablesContainerType   indicatorVariables_;
   CoefficientsContainerType         coefficients_;
   BoundType                         bound_;
   LinearConstraintOperatorValueType constraintOperator_;
};

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

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::LinearConstraint() : indicatorVariables_(),
   coefficients_(), bound_(0.0),
   constraintOperator_(LinearConstraintOperatorType::LessEqual) {

}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::LinearConstraint(const IndicatorVariablesContainerType& indicatorVariables, const CoefficientsContainerType& coefficients, const BoundType bound, const LinearConstraintOperatorValueType constraintOperator)
   : indicatorVariables_(indicatorVariables), coefficients_(coefficients),
     bound_(bound), constraintOperator_(constraintOperator) {

}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class INDICATOR_VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::LinearConstraint(const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesBegin, const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesEnd, const COEFFICIENTS_ITERATOR_TYPE coefficientsBegin, const BoundType bound, const LinearConstraintOperatorValueType constraintOperator)
   : indicatorVariables_(indicatorVariablesBegin, indicatorVariablesEnd),
     coefficients_(coefficientsBegin, coefficientsBegin + std::distance(indicatorVariablesBegin, indicatorVariablesEnd)),
     bound_(bound), constraintOperator_(constraintOperator) {

}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::LinearConstraint(const LinearConstraint<ValueType, IndexType, LabelType>& linearConstraint)
   : indicatorVariables_(linearConstraint.indicatorVariables_),
     coefficients_(linearConstraint.coefficients_),
     bound_(linearConstraint.bound_),
     constraintOperator_(linearConstraint.constraintOperator_) {

}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::reserve(const size_t numIndicatorVariables) {
   indicatorVariables_.reserve(numIndicatorVariables);
   coefficients_.reserve(numIndicatorVariables);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::add(const IndicatorVariableType& indicatorVariable, const ValueType coefficient) {
   indicatorVariables_.push_back(indicatorVariable);
   coefficients_.push_back(coefficient);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::add(const IndicatorVariablesContainerType& indicatorVariables, const CoefficientsContainerType& coefficients) {
   indicatorVariables_.insert(indicatorVariables_.end(), indicatorVariables.begin(), indicatorVariables.end());
   coefficients_.insert(coefficients_.end(), coefficients.begin(), coefficients.end());
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class INDICATOR_VARIABLES_ITERATOR_TYPE, class COEFFICIENTS_ITERATOR_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::add(const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesBegin, const INDICATOR_VARIABLES_ITERATOR_TYPE indicatorVariablesEnd, const COEFFICIENTS_ITERATOR_TYPE coefficientsBegin) {
   indicatorVariables_.insert(indicatorVariables_.end(), indicatorVariablesBegin, indicatorVariablesEnd);
   coefficients_.insert(coefficients_.end(), coefficientsBegin, coefficientsBegin + std::distance(indicatorVariablesBegin, indicatorVariablesEnd));
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::setBound(const BoundType bound) {
   bound_ = bound;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::setConstraintOperator(const LinearConstraintOperatorValueType constraintOperator) {
   constraintOperator_ = constraintOperator;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class ITERATOR_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::ValueType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::operator()(const ITERATOR_TYPE statesBegin) const {
   ValueType leftHandSide = 0.0;
   for(IndexType i = 0; i < indicatorVariables_.size(); ++i) {
      if(indicatorVariables_[i](statesBegin)) {
         leftHandSide += coefficients_[i];
      }
   }

   // compare left hand side against bound
   const ValueType weight = leftHandSide - bound_;
   switch(constraintOperator_) {
      case LinearConstraintOperatorType::LessEqual : {
         if(weight > 0.0) {
            return weight;
         } else {
            return 0.0;
         }
         break;
      }
      case LinearConstraintOperatorType::Equal : {
         if(weight > 0.0) {
            return weight;
         } else if(weight < 0.0) {
            return -weight;
         } else {
            return 0.0;
         }
         break;
      }
      /*case LinearConstraintOperatorType::GreaterEqual : {
         if(weight < 0.0) {
            return -weight;
         } else {
            return 0.0;
         }
         break;
      } */
      default : { // default corresponds to GreaterEqual case
         if(weight < 0.0) {
            return -weight;
         } else {
            return 0.0;
         }
      }
   }
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndicatorVariablesIteratorType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::indicatorVariablesBegin() const {
   return indicatorVariables_.begin();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndicatorVariablesIteratorType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::indicatorVariablesEnd() const {
   return indicatorVariables_.end();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::CoefficientsIteratorType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::coefficientsBegin() const {
   return coefficients_.begin();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::CoefficientsIteratorType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::coefficientsEnd() const {
   return coefficients_.end();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::BoundType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getBound() const {
   return bound_;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::LinearConstraintOperatorValueType LinearConstraint<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getConstraintOperator() const {
   return constraintOperator_;
}

} // namespace opengm

#endif /* OPENGM_LINEAR_CONSTRAINT_HXX_ */