RhodeCode

        _expr(e), _lb(NaN), _ub(NaN) {}

      ///\e

      void clear()

      {

        _expr.clear();

        _lb=_ub=NaN;

      }

      ///Reference to the linear expression

      Expr &expr() { return _expr; }

      ///Cont reference to the linear expression

      const Expr &expr() const { return _expr; }

      ///Reference to the lower bound.

      ///\return

      ///- \ref INF "INF": the constraint is lower unbounded.

      ///- \ref NaN "NaN": lower bound has not been set.

      ///- finite number: the lower bound

      Value &lowerBound() { return _lb; }

      ///The const version of \ref lowerBound()

      const Value &lowerBound() const { return _lb; }

      ///Reference to the upper bound.

      ///\return

      ///- \ref INF "INF": the constraint is upper unbounded.

      ///- \ref NaN "NaN": upper bound has not been set.

      ///- finite number: the upper bound

      Value &upperBound() { return _ub; }

      ///The const version of \ref upperBound()

      const Value &upperBound() const { return _ub; }

      ///Is the constraint lower bounded?

      bool lowerBounded() const {

      }

      ///Is the constraint upper bounded?

      bool upperBounded() const {

      }

    };

    ///Linear expression of rows

    ///This data structure represents a column of the matrix,

    ///thas is it strores a linear expression of the dual variables

    ///(\ref Row "Row"s).

    ///

    ///There are several ways to access and modify the contents of this

    ///container.

    ///\code

    ///e[v]=5;

    ///e[v]+=12;

    ///e.erase(v);

    ///\endcode

    ///or you can also iterate through its elements.

    ///\code

    ///double s=0;

    ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)

    ///  s+=*i;

    ///\endcode

    ///(This code computes the sum of all coefficients).

    ///- Numbers (<tt>double</tt>'s)

    ///and variables (\ref Row "Row"s) directly convert to an

    ///\ref DualExpr and the usual linear operations are defined, so

    ///\code

    ///v+w

    ///2*v-3.12*(v-w/2)

    ///v*2.1+(3*v+(v*12+w)*3)/2

    ///\endcode

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator>=(const LpBase::Expr &e,

                                   const LpBase::Value &f) {

    return LpBase::Constr(f, e, LpBase::INF);

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator==(const LpBase::Expr &e,

                                   const LpBase::Value &f) {

    return LpBase::Constr(f, e, f);

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator==(const LpBase::Expr &e,

                                   const LpBase::Expr &f) {

    return LpBase::Constr(0, f - e, 0);

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator<=(const LpBase::Value &n,

                                   const LpBase::Constr &c) {

    LpBase::Constr tmp(c);

    tmp.lowerBound()=n;

    return tmp;

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator<=(const LpBase::Constr &c,

                                   const LpBase::Value &n)

  {

    LpBase::Constr tmp(c);

    tmp.upperBound()=n;

    return tmp;

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator>=(const LpBase::Value &n,

                                   const LpBase::Constr &c) {

    LpBase::Constr tmp(c);

    tmp.upperBound()=n;

    return tmp;

  }

  ///Create constraint

  ///\relates LpBase::Constr

  ///

  inline LpBase::Constr operator>=(const LpBase::Constr &c,

                                   const LpBase::Value &n)

  {

    LpBase::Constr tmp(c);

    tmp.lowerBound()=n;

    return tmp;

  }

  ///Addition

  ///\relates LpBase::DualExpr

  ///

  inline LpBase::DualExpr operator+(const LpBase::DualExpr &a,

                                    const LpBase::DualExpr &b) {

    LpBase::DualExpr tmp(a);

    tmp+=b;

    return tmp;

  }

  ///Substraction

  ///\relates LpBase::DualExpr

  ///

  inline LpBase::DualExpr operator-(const LpBase::DualExpr &a,

                                    const LpBase::DualExpr &b) {

    LpBase::DualExpr tmp(a);

    tmp-=b;

    return tmp;

  }

  ///Multiply with constant

  ///\relates LpBase::DualExpr

  ///

  inline LpBase::DualExpr operator*(const LpBase::DualExpr &a,

                                    const LpBase::Value &b) {

    LpBase::DualExpr tmp(a);

    tmp*=b;

///Some extensions to the standard \c cmath library.

///

///This file includes the standard math library (cmath).

#include<cmath>

namespace lemon {

  /// \addtogroup misc

  /// @{

  /// The Euler constant

  const long double E       = 2.7182818284590452353602874713526625L;

  /// log_2(e)

  const long double LOG2E   = 1.4426950408889634073599246810018921L;

  /// log_10(e)

  const long double LOG10E  = 0.4342944819032518276511289189166051L;

  /// ln(2)

  const long double LN2     = 0.6931471805599453094172321214581766L;

  /// ln(10)

  const long double LN10    = 2.3025850929940456840179914546843642L;

  /// pi

  const long double PI      = 3.1415926535897932384626433832795029L;

  /// pi/2

  const long double PI_2    = 1.5707963267948966192313216916397514L;

  /// pi/4

  const long double PI_4    = 0.7853981633974483096156608458198757L;

  /// sqrt(2)

  const long double SQRT2   = 1.4142135623730950488016887242096981L;

  /// 1/sqrt(2)

  const long double SQRT1_2 = 0.7071067811865475244008443621048490L;

  /// @}

} //namespace lemon

#endif //LEMON_TOLERANCE_H