Constraints.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_NUMERIC_CONSTRAINTS_H
#define BPP_NUMERIC_CONSTRAINTS_H


// From the STL:
#include <string>
#include <iostream>
#include <typeinfo>

// From Utils:
#include "../Clonable.h"
#include "../Text/TextTools.h"
#include "../Exceptions.h"

#include "NumConstants.h"

namespace bpp
{
class ConstraintInterface :
  public virtual Clonable
{
public:
  ConstraintInterface() {}
  virtual ~ConstraintInterface() {}

  ConstraintInterface* clone() const = 0;

public:
  virtual bool isCorrect(double value) const = 0;

  virtual bool includes(double min, double max) const = 0;

  virtual double getLimit(double value) const = 0;

  virtual double getAcceptedLimit(double value) const = 0;

  virtual std::string getDescription() const = 0;

  virtual ConstraintInterface* operator&(const ConstraintInterface& c) const = 0;

  virtual bool isEmpty() const = 0;
};

class IntervalConstraint :
  public virtual ConstraintInterface
{
protected:
  double lowerBound_, upperBound_;

  bool inclLowerBound_, inclUpperBound_;

  double precision_;

public:
  IntervalConstraint() :
    lowerBound_(NumConstants::MINF()),
    upperBound_(NumConstants::PINF()),
    inclLowerBound_(true),
    inclUpperBound_(true),
    precision_(NumConstants::TINY()) {}

  IntervalConstraint(double lowerBound, double upperBound, bool inclLower, bool inclUpper, double precision = NumConstants::TINY()) :
    lowerBound_(lowerBound),
    upperBound_(upperBound),
    inclLowerBound_(inclLower),
    inclUpperBound_(inclUpper),
    precision_(precision) {}

  IntervalConstraint(bool isPositive, double bound, bool incl, double precision = NumConstants::TINY()) :
    lowerBound_(isPositive ? bound : NumConstants::MINF()),
    upperBound_(isPositive ? NumConstants::PINF() : bound),
    inclLowerBound_(isPositive ? incl : false),
    inclUpperBound_(isPositive ? false : incl),
    precision_(precision) {}

  IntervalConstraint(std::string& desc) :
    lowerBound_(NumConstants::MINF()),
    upperBound_(NumConstants::PINF()),
    inclLowerBound_(true),
    inclUpperBound_(true),
    precision_(NumConstants::TINY())
  {
    readDescription(desc);
  }

  virtual ~IntervalConstraint() {}

  IntervalConstraint* clone() const override { return new IntervalConstraint(*this); }

public:
  void setLowerBound(double lowerBound, bool strict) { lowerBound_ = lowerBound; inclLowerBound_ = !strict; }
  void setUpperBound(double upperBound, bool strict) { upperBound_ = upperBound; inclUpperBound_ = !strict; }

  double getLowerBound() const { return lowerBound_; }
  double getUpperBound() const { return upperBound_; }

  bool strictLowerBound() const { return !inclLowerBound_; }
  bool strictUpperBound() const { return !inclUpperBound_; }

  bool finiteLowerBound() const { return lowerBound_ > NumConstants::MINF(); }
  bool finiteUpperBound() const { return upperBound_ < NumConstants::PINF(); }

  bool includes(double min, double max) const override
  {
    return (inclLowerBound_ ? min >= getLowerBound() : min > getLowerBound()) &&
           (inclUpperBound_ ? max <= getUpperBound() : max < getUpperBound());
  }

  virtual bool isCorrect(double value) const override
  {
    return (inclLowerBound_ ? value >= getLowerBound() : value > getLowerBound()) &&
           (inclUpperBound_ ? value <= getUpperBound() : value < getUpperBound());
  }

  bool operator<(double value) const
  {
    return inclUpperBound_ ? upperBound_ < value : upperBound_ <= value;
  }

  bool operator>(double value) const
  {
    return inclLowerBound_ ? lowerBound_ > value : lowerBound_ >= value;
  }

  bool operator<=(double value) const
  {
    return upperBound_ <= value;
  }

  bool operator>=(double value) const
  {
    return lowerBound_ >= value;
  }

  double getLimit(double value) const override
  {
    return isCorrect(value) ? value :
           (*this >= value ? lowerBound_ : upperBound_);
  }

  double getAcceptedLimit(double value) const override
  {
    return isCorrect(value) ? value :
           (*this >= value ?
           strictLowerBound() ? lowerBound_ + precision_ : lowerBound_ :
           strictUpperBound() ? upperBound_ - precision_ : upperBound_);
  }

  double getPrecision() const
  {
    return precision_;
  }

  std::string getDescription() const override
  {
    return (inclLowerBound_ ? "[ " : "]")
           + (finiteLowerBound() ? TextTools::toString(lowerBound_) : "-inf")
           + "; "
           + (finiteUpperBound() ? TextTools::toString(upperBound_) : "+inf")
           + (inclUpperBound_ ? "] " : "[");
  }

  void readDescription(std::string& desc)
  {
    size_t pdp = desc.find(";");
    size_t dc = desc.find_first_of("[]", 1);

    if (dc == std::string::npos || pdp == std::string::npos ||
        (desc[0] != ']' && desc[0] != '[') || (pdp >= dc))
      throw Exception("Constraints::readDescription. Wrong description:" + desc);

    std::string deb = desc.substr(1, pdp - 1);
    std::string fin = desc.substr(pdp + 1, dc - pdp - 1);

    inclLowerBound_ = (desc[0] == '[');
    inclUpperBound_ = (desc[dc] == ']');

    lowerBound_ =  (deb == "-inf") ? NumConstants::MINF() : TextTools::toDouble(deb);
    upperBound_ =  ((fin == "+inf") || (fin == "inf")) ? NumConstants::PINF() : TextTools::toDouble(fin);
  }

  ConstraintInterface* operator&(const ConstraintInterface& c) const override
  {
    double lowerBound, upperBound;
    bool inclLowerBound, inclUpperBound;

    const IntervalConstraint* pi = dynamic_cast<const IntervalConstraint*>(&c);

    if (pi)
    {
      if (lowerBound_ <= pi->lowerBound_)
      {
        lowerBound = pi->lowerBound_;
        inclLowerBound = pi->inclLowerBound_;
      }
      else
      {
        lowerBound = lowerBound_;
        inclLowerBound = inclLowerBound_;
      }

      if (upperBound_ >= pi->upperBound_)
      {
        upperBound = pi->upperBound_;
        inclUpperBound = pi->inclUpperBound_;
      }
      else
      {
        upperBound = upperBound_;
        inclUpperBound = inclUpperBound_;
      }
      return new IntervalConstraint(lowerBound, upperBound, inclLowerBound, inclUpperBound, (precision_ > pi->getPrecision()) ? precision_ : pi->getPrecision());
    }
    else
      return 0;
  }

  IntervalConstraint& operator&=(const ConstraintInterface& c)
  {
    try
    {
      const IntervalConstraint& pi = dynamic_cast<const IntervalConstraint&>(c);

      if (lowerBound_ <= pi.lowerBound_)
      {
        lowerBound_ = pi.lowerBound_;
        inclLowerBound_ = pi.inclLowerBound_;
      }

      if (upperBound_ >= pi.upperBound_)
      {
        upperBound_ = pi.upperBound_;
        inclUpperBound_ = pi.inclUpperBound_;
      }
      if (pi.getPrecision() > precision_)
        precision_ = pi.getPrecision();
    }
    catch (std::bad_cast&) {}

    return *this;
  }

  bool operator==(const IntervalConstraint& i) const
  {
    return lowerBound_ == i.lowerBound_
           && inclLowerBound_ == i.inclLowerBound_
           && upperBound_ == i.upperBound_
           && inclUpperBound_ == i.inclUpperBound_;
  }

  bool operator!=(const IntervalConstraint& i) const
  {
    return lowerBound_ != i.lowerBound_
           || inclLowerBound_ != i.inclLowerBound_
           || upperBound_ != i.upperBound_
           || inclUpperBound_ != i.inclUpperBound_;
  }

  bool operator<=(const IntervalConstraint& i) const
  {
    return lowerBound_ >= i.lowerBound_
           && upperBound_ <= i.upperBound_;
  }

  bool isEmpty() const override
  {
    return (lowerBound_ > upperBound_) ||
           ((lowerBound_ > upperBound_) &&
           inclUpperBound_ && inclLowerBound_);
  }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_CONSTRAINTS_H