RhodeCode

#define LEMON_GRAPH_TO_EPS_H

#include<iostream>

#include<fstream>

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

#include<lemon/bits/bezier.h>

#include<lemon/error.h>

    os << "%%Creator: LEMON, graphToEps()\n";

    {

#ifndef WIN32

      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;

      }

    }

    if (_autoNodeScale) {

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\file

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

#include <lemon/lp_base.h>

namespace lemon {

} //namespace lemon

      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.

  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;

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

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

#endif //LEMON_TOLERANCE_H

 * purpose.

 *

 */

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

namespace lemon {

  /// \addtogroup timecount

  /// @{