RhodeCode

The names of class and instance member variables and auto variables

(=variables used locally in methods) should look like the following.

\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv}

\qquad \forall u \in V \setminus \{s,t\}\f]

\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}

\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]

This group describes the algorithms for planarity checking,

embedding and drawing.

This group describes methods for reading and writing

\ref lgf-format "Lemon Graph Format".

            std::cerr << _command_name <<

              ": At least one of the following arguments is mandatory.\n";

            std::cerr << _command_name <<

              ": At most one of the following arguments can be given.\n";

///     void custom_assert_handler(const char* file, int line,

///                                const char* function, const char* message,

///                                const char* assertion);

    ///\param G is the digraph, to which we would like to define

    ///the \ref DistMap

    ///\param g is the digraph, to which we would like to define

    ///the \ref DistMap

  /// \tparam _Digraph The digraph type the algorithm runs on.

  /// The default value is

      /// \brief The value type of the map.

      /// (The type of objects associated with the keys).

      /// \brief The value type of the map.

      /// (The type of objects associated with the keys).

      /// \brief The value type of the map.

      /// (The type of objects associated with the keys).

      /// \brief The value type of the map.

      /// (The type of objects associated with the keys).

    ///\param G is the digraph, to which we would like to define

    ///the \ref DistMap

    ///\param g is the digraph, to which we would like to define

    ///the \ref DistMap

  /// \tparam _Digraph The digraph type the algorithm runs on.

  /// The default value is

    ///\param G is the digraph, to which we would like to define

    ///the \ref DistMap

      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>

      Create;

    ///\param g is the digraph, to which we would like to define

    ///the \ref DistMap

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

  ///By default it is <tt>std::cout</tt>.

    os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke }"

       << " bind def\n";

    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath }"

       << " bind def\n";

       << "  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub"

       << " moveto\n"

       << "  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto "

       << "stroke\n"

       << "  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub"

       << " lineto\n"

    os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx "

       << "exch def\n"

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

//                                 mycoords[g.source(*i)])/2.0;

//                 if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape))

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

  /// paths are given as a node map or an arc map.

  /// It is impossible to read this in

    ///\ref stop() "stop()"s. This can be useful e.g. to compute

    ///the running time

    check( !dijkstra_test.reached(u) ||

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

           "dist(target)-dist(source)-arc_length= " <<

           dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);

            "Wrong distance! Difference: " <<

            std::abs(dijkstra_test.dist(v)-dijkstra_test.dist(u)-length[e]));

        check(con1 == con2 && con2 == con3 && con3 == con4,

              "Different results.")

        check(al3(src, trg, con3) == INVALID,

              "There is more connecting arc.");

        check(findArc(fg, src, trg, con4) == INVALID,

              "There is more connecting arc.");

               (graph.v(con) == src && graph.u(con) == trg),

               "Wrong end nodes.");

    check(map6[A()] == 10 && map7[A()] == 10,

          "Something is wrong with ConstMap");

    check(identityMap<double>()[1.0] == 1.0 &&

          identityMap<double>()[3.14] == 3.14,

    check(map5[1.0] == 0 && map5[3.14] == 0 &&

          map6[1.0] == 10 && map6[3.14] == 10,

    check(map5[1.0] == 100 && map5[3.14] == 0 &&

          map6[1.0] == 10 && map6[3.14] == 100,

    check(!composeMap(m1,m2)[0] && composeMap(m1,m2)[1],

          "Something is wrong with ComposeMap")

    check(functorToMap(&func)[A()] == 3,

          "Something is wrong with FunctorToMap");

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

          "Something is wrong with MapToFunctor");

    check(mapToFunctor(functorToMap(&func))(A()) == 3 &&

          mapToFunctor(functorToMap(&func))[A()] == 3,

    checkConcept<ReadMap<double,double>,

      ConvertMap<ReadMap<double, int>, double> >();

    check(m1[1] == -1 && m1[5] == 10 && m2[1] == -1 &&

          m2[5] == 10 && map2[1] == -1 && map2[5] == 10,

    check(addMap(c1,id)[0] == 1.0  && addMap(c1,id)[10] == 11.0,

          "Something is wrong with AddMap");

    check(subMap(id,c1)[0] == -1.0 && subMap(id,c1)[10] == 9.0,

          "Something is wrong with SubMap");

    check(mulMap(id,c2)[0] == 0    && mulMap(id,c2)[2]  == 6.28,

          "Something is wrong with MulMap");

    check(divMap(c2,id)[1] == 3.14 && divMap(c2,id)[2]  == 1.57,

          "Something is wrong with DivMap");

    check(shiftWriteMap(id, 2.0)[1] == 3.0 &&

          shiftWriteMap(id, 2.0)[10] == 12.0,

    check(scaleWriteMap(id, 2.0)[1] == 2.0 &&

          scaleWriteMap(id, 2.0)[10] == 20.0,

    check(andMap(tm,rm)[0] && !andMap(tm,rm)[1] &&

          !andMap(fm,rm)[0] && !andMap(fm,rm)[1],

    check(orMap(tm,rm)[0] && orMap(tm,rm)[1] &&

          orMap(fm,rm)[0] && !orMap(fm,rm)[1],

    check(!notMap(rm)[0] && notMap(rm)[1],

          "Something is wrong with NotMap");

    check(!notWriteMap(rm)[0] && notWriteMap(rm)[1],

          "Something is wrong with NotWriteMap");

    LoggerBoolMap<std::back_insert_iterator<vec> >

      map1(std::back_inserter(v1));

          v1[0]==20 && v1[1]==50 && v1[2]==60 &&

          v2[0]==20 && v2[1]==50 && v2[2]==60,