RhodeCode

  // Create an .eps file showing the colors of a default Palette

  ListDigraph h;

  ListDigraph::NodeMap<int> hcolors(h);

  ListDigraph::NodeMap<Point> hcoords(h);

  for(int i=0;i<int(paletteW.size());i++) {

    Node n=h.addNode();

    hcoords[n]=Point(1+i%cols,1+i/cols);

    hcolors[n]=i;

  }

        _in_arc(ns.in_arc), _arc_num(ns._arc_num), _next_arc(0)

      {

        // The main parameters of the pivot rule

        const double BLOCK_SIZE_FACTOR = 2.0;

        const int MIN_BLOCK_SIZE = 10;

                                MIN_BLOCK_SIZE );

      }

      // Find next entering arc

      bool findEnteringArc() {

        Cost c, min = 0;

        // The main parameters of the pivot rule

        const double LIST_LENGTH_FACTOR = 1.0;

        const int MIN_LIST_LENGTH = 10;

        const double MINOR_LIMIT_FACTOR = 0.1;

        const int MIN_MINOR_LIMIT = 3;

                                 MIN_LIST_LENGTH );

        _minor_limit = std::max( int(MINOR_LIMIT_FACTOR * _list_length),

                                 MIN_MINOR_LIMIT );

        _curr_length = _minor_count = 0;

        _candidates.resize(_list_length);

      }

        // The main parameters of the pivot rule

        const double BLOCK_SIZE_FACTOR = 1.5;

        const int MIN_BLOCK_SIZE = 10;

        const double HEAD_LENGTH_FACTOR = 0.1;

        const int MIN_HEAD_LENGTH = 3;

                                MIN_BLOCK_SIZE );

        _head_length = std::max( int(HEAD_LENGTH_FACTOR * _block_size),

                                 MIN_HEAD_LENGTH );

        _candidates.resize(_head_length + _block_size);

        _curr_length = 0;

      }

        _pi[_root] = -art_cost;

      } else {

        _pi[_root] = art_cost;

      }

      // Store the arcs in a mixed order

      int i = 0;

      for (ArcIt e(_graph); e != INVALID; ++e) {

        _arc_ref[i] = e;

        if ((i += k) >= _arc_num) i = (i % k) + 1;

      }

ListGraph::NodeMap<Point> coords(g);

double totalLen(){

  double tlen=0;

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

  return tlen;

}

int tsp_impr_num=0;

const double EPSILON=1e-8;

      (r.x * r.x + r.y * r.y) * (p.x - q.x);

    double f = (p.x * p.x + p.y * p.y) * (q.x * r.y - r.x * q.y) +

      (q.x * q.x + q.y * q.y) * (r.x * p.y - p.x * r.y) +

      (r.x * r.x + r.y * r.y) * (p.x * q.y - q.x * p.y);

  }

  inline bool circle_form(const Point& p, const Point& q, const Point& r) {

    return rot90(q - p) * (r - q) < 0.0;

  }

    if (sx < p.x + epsilon) return p.y;

    if (sx < q.x + epsilon) return q.y;

    double a = q.x - p.x;

    double b = (q.x - sx) * p.y - (p.x - sx) * q.y;

    double d = (q.x - sx) * (p.x - sx) * (p - q).normSquare();

  }

  struct YLess {

    YLess(const std::vector<Point>& points, double& sweep)

  std::cout << "Number of nodes    : " << countNodes(g) << std::endl;

  std::cout << "Number of arcs    : " << countEdges(g) << std::endl;

  double tlen=0;

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

  std::cout << "Total arc length  : " << tlen << std::endl;

  if(ap["eps"])

    graphToEps(g,prefix+".eps").scaleToA4().

      scale(600).nodeScale(.005).arcWidthScale(.001).preScale(false).

      coords(coords).hideNodes(ap.given("nonodes")).run();