RhodeCode

#include<sstream>

#include<algorithm>

#include<vector>

#ifndef WIN32

#include<sys/time.h>

#include<ctime>

#else

#define WIN32_LEAN_AND_MEAN

#define NOMINMAX

#include<windows.h>

#endif

#include<lemon/math.h>

#include<lemon/core.h>

#include<lemon/dim2.h>

#include<lemon/maps.h>

#include<lemon/color.h>

      timeval tv;

      gettimeofday(&tv, 0);

      char cbuf[26];

      ctime_r(&tv.tv_sec,cbuf);

      os << "%%CreationDate: " << cbuf;

#else

      SYSTEMTIME time;

      char buf1[11], buf2[9], buf3[5];

      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                        "ddd MMM dd", buf1, 11) &&

          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,

                        "HH':'mm':'ss", buf2, 9) &&

          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                                "yyyy", buf3, 5)) {

        os << "%%CreationDate: " << buf1 << ' '

           << buf2 << ' ' << buf3 << std::endl;

      }

#endif

    }

    if (_autoArcWidthScale) {

      double max_w=0;

      for(ArcIt e(g);e!=INVALID;++e)

        max_w=std::max(double(_arcWidths[e]),max_w);

      if(max_w>EPSILON) {

        _arcWidthScale/=max_w;

 */

///\file

///\brief The implementation of the LP solver interface.

#include <lemon/lp_base.h>

namespace lemon {

} //namespace lemon

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

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

  ///

  /// 1/sqrt(2)

  const long double SQRT1_2 = 0.7071067811865475244008443621048490L;

  ///Check whether the parameter is NaN or not

  ///This function checks whether the parameter is NaN or not.

  ///Is should be equivalent with std::isnan(), but it is not

  ///provided by all compilers.

    {

      return v!=v;

    }

  /// @}

} //namespace lemon

#ifndef LEMON_TIME_MEASURE_H

#define LEMON_TIME_MEASURE_H

///\ingroup timecount

///\file

///\brief Tools for measuring cpu usage

#ifdef WIN32

#define WIN32_LEAN_AND_MEAN

#define NOMINMAX

#include <windows.h>

#include <cmath>

#else

#include <sys/times.h>

#include <sys/time.h>

#endif

#include <string>

#include <fstream>

#include <iostream>