RhodeCode

\subsection cs-loc-var Class and instance member variables, auto variables

\code

all_lower_case_with_underscores

maximum flow is the \f$f_a\f$ solution of the next optimization problem:

\f[ 0 \le f_a \le c_a \f]

\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]

LEMON contains several algorithms for solving maximum flow problems:

\f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum

cut is the \f$X\f$ solution of the next optimization problem:

LEMON contains several algorithms related to minimum cut problems:

@ingroup algs

\brief Algorithms for planarity checking, embedding and drawing

\image html planar.png

\image latex planar.eps "Plane graph" width=\textwidth

@ingroup io_group

\brief Reading and writing \ref lgf-format "Lemon Graph Format".

*/

/**

              o!=i->second.opts.end();++o)

            if(_opts.find(*o)->second.set) ++set;

          if(i->second.mandatory&&!set) {

            ok=false;

            for(GroupData::Opts::iterator o=i->second.opts.begin();

                o!=i->second.opts.end();++o)

              showHelp(_opts.find(*o));

          }

          if(i->second.only_one&&set>1) {

            ok=false;

            for(GroupData::Opts::iterator o=i->second.opts.begin();

                o!=i->second.opts.end();++o)

/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler

///   function.

///   \code

///   \endcode

///   The name of the function should be defined as the \c

///   LEMON_CUSTOM_ASSERT_HANDLER macro name.

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

      return new DistMap(G);

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

#else

  /// class. It works with callback mechanism, the BfsVisit object calls

  /// on every bfs event the \c Visitor class member functions.

  ///

  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it

  /// is only passed to \ref BfsDefaultTraits.

  /// \tparam _Visitor The Visitor object for the algorithm. The

    public:

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// Returns the value associated with the given key.

    public:

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// Sets the value associated with the given key.

    public:

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// Returns the value associated with the given key.

      typedef True ReferenceMapTag;

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// The reference type of the map.

      typedef R Reference;

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

      return new DistMap(G);

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

#else

  /// class. It works with callback mechanism, the DfsVisit object calls

  /// on every dfs event the \c Visitor class member functions.

  ///

  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it

  /// is only passed to \ref DfsDefaultTraits.

  /// \tparam _Visitor The Visitor object for the algorithm. The

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

      return new DistMap(G);

    template <class T>

    struct DefProcessedMapToBeDefaultMap

      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {

    };

    template <class H, class CR>

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

#else

  ///Constructor

  ///\param _g  Reference to the graph to be printed.

  ///\param _os Reference to the output stream.

  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os

  ///will be explicitly deallocated by the destructor.

  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,

    //x1 y1 x2 y2 x3 y3 cr cg cb w

    os << "/lb { setlinewidth setrgbcolor newpath moveto\n"

       << "      4 2 roll 1 index 1 index curveto stroke } bind def\n";

    //x y r

    //x y r

    os << "/sq { newpath 2 index 1 index add 2 index 2 index add moveto\n"

       << "      2 index 1 index sub 2 index 2 index add lineto\n"

       << " 1.5 mul mul setlinewidth\n"

       << "  newpath 5 index 5 index moveto "

       << "5 index 5 index 5 index 3.01 mul sub\n"

       << "  5 index 5 index 5 index c fill\n"

       << "  setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"

       << "  } bind def\n";

       << "  1 index 1 index lineto\n"

       << "  1 index 1 index 7 index sub moveto\n"

       << "  1 index 1 index lineto\n"

       << "  stroke\n"

       << "  5 index 5 index 5 index c fill\n"

       << "  setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"

    // l dx_norm dy_norm

    os << "/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def\n";

    //len w dx_norm dy_norm x1 y1 cr cg cb

       << "       /w exch def /len exch def\n"

      //         << "       0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"

       << "       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto\n"

          //\todo better 'epsilon' would be nice here.

          dim2::Point<double> d(dvec/std::max(l,EPSILON));

           dim2::Point<double> m;

//            m=dim2::Point<double>(mycoords[g.source(*i)])+

//             dvec*(double(_nodeSizes[g.source(*i)])/

//               node_shape=_nodeShapes[g.source(*e)];

//               t1=0;t2=1;

//               for(int i=0;i<INTERPOL_PREC;++i)

//                 else t2=(t1+t2)/2;

//               bez=bez.after((t1+t2)/2);

              os << _arcWidths[*e]*_arcWidthScale << " setlinewidth "

  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).

  /// The previously read label node map should be passed to the \c

  /// useNodes() functions. Another application of multipass reading when

  /// a single pass, because the arcs are not constructed when the node

  /// maps are read.

  template <typename _Digraph>

    ///but it provides a bit finer control on the execution.

    ///The \ref Timer also counts the number of \ref start()

    ///executions, and is stops only after the same amount (or more)

    ///of recursive functions.

    ///

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

    Node u=G.source(e);

    Node v=G.target(e);

  }

  for(NodeIt v(G); v!=INVALID; ++v){

      Node u=G.source(e);

      check(u==dijkstra_test.predNode(v),"Wrong tree.");

      check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == length[e],

    }

  }

        Arc con2 = al2(src, trg);

        Arc con3 = al3(src, trg);

        Arc con4 = findArc(fg, src, trg);

        check(con1 != INVALID, "There is no connecting arc.");

        check(fg.source(con1) == src, "Wrong source.");

        check(fg.target(con1) == trg, "Wrong target.");

      }

    }

  }

    for (NodeIt trg(graph); trg != INVALID; ++trg) {

      for (ConEdgeIt<Graph> con(graph, src, trg); con != INVALID; ++con) {

        check( (graph.u(con) == src && graph.v(con) == trg) ||

        ++found[con];

        check(found[con] <= 2, "The edge found more than twice.");

      }

    ConstMap<A,Const<int,10> > map7 = map6;

    map6 = constMap<A,int,10>();

    map7 = constMap<A,Const<int,10> >();

  }

  // IdentityMap

    map1 = identityMap<A>();

    checkConcept<ReadMap<double,double>, IdentityMap<double> >();

          "Something is wrong with IdentityMap");

  }

    SparseMap<double, int> map7 = sparseMap(m);

    SparseMap<double, int> map8 = sparseMap(m,10);

          "Something is wrong with SparseMap");

    map5[1.0] = map6[3.14] = 100;

          "Something is wrong with SparseMap");

  }

    SparseMap<double, bool> m1(false); m1[3.14] = true;

    RangeMap<double> m2(2); m2[0] = 3.0; m2[1] = 3.14;

  }

  // CombineMap

    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();

    MapToFunctor<ReadMap<A,B> > map(ReadMap<A,B>());

          "Something is wrong with FunctorToMap or MapToFunctor");

    check(functorToMap(mapToFunctor(constMap<A,int>(2)))[A()] == 2,

          "Something is wrong with FunctorToMap or MapToFunctor");

  // ConvertMap

  {

    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));

    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));

  }

    ForkMap<RM, SM> map1(m1,m2);

    ForkMap<SM, RM> map2 = forkMap(m2,m1);

    map2.set(5, 10);

          "Something is wrong with ForkMap");

  }

    ConstMap<int, double> c1(1.0), c2(3.14);

    IdentityMap<int> im;

    ConvertMap<IdentityMap<int>, double> id(im);

    checkConcept<DoubleMap, ShiftMap<DoubleMap> >();

    checkConcept<DoubleWriteMap, ShiftWriteMap<DoubleWriteMap> >();

    check(shiftMap(id, 2.0)[1] == 3.0 && shiftMap(id, 2.0)[10] == 12.0,

          "Something is wrong with ShiftMap");

          "Something is wrong with ShiftWriteMap");

    check(scaleMap(id, 2.0)[1] == 2.0 && scaleMap(id, 2.0)[10] == 20.0,

          "Something is wrong with ScaleMap");

          "Something is wrong with ScaleWriteMap");

    check(negMap(id)[1] == -1.0 && negMap(id)[-10] == 10.0,

          "Something is wrong with NegMap");

    FalseMap<int> fm;

    RangeMap<bool> rm(2);

    rm[0] = true; rm[1] = false;

          "Something is wrong with AndMap");

          "Something is wrong with OrMap");

    ConstMap<int, double> cm(2.0);

    IdentityMap<int> im;

    typedef std::vector<int> vec;

    vec v1;

    vec v2(10);

    LoggerBoolMap<vec::iterator> map2(v2.begin());

    map1.set(10, false);

    map1.set(20, true);   map2.set(20, true);

    map1.set(50, true);   map2.set(50, true);

    map1.set(60, true);   map2.set(60, true);

    check(v1.size() == 3 && v2.size() == 10 &&

          "Something is wrong with LoggerBoolMap");

    int i = 0;