RhodeCode

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

\code

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

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

LEMON contains several algorithms related to minimum cut problems:

\brief Algorithms for planarity checking, embedding and drawing

\image html planar.png

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

*/

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

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

            ok=false;

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

          }

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

            ok=false;

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

///   function.

///   \code

///   \endcode

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

#  define LEMON_FIXME(msg)                                                \

  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \

                        static_cast<const char*>(0)))

           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                                LEMON_FUNCTION_NAME, \

                                #exp), 0)))

#    else

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

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

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// The key type of the map.

      typedef K Key;

      typedef T Value;

      /// The reference type of the map.

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

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

    ///This function instantiates a \ref DistMap.

    static DistMap *createDistMap(const GR &G)

    {

    template <class T>

    struct DefPredMap

    };

    template <class T>

    struct DefProcessedMap

    };

    struct DefProcessedMapToBeDefaultMap

      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {

    };

    template <class H, class CR = typename Digraph::template NodeMap<int> >

    struct DefHeap

    };

    template <class H, class CR = typename Digraph::template NodeMap<int> >

    struct DefStandardHeap

      Create;

    };

    ///This function instantiates a \ref DistMap.

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

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

    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"

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

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

    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"

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

       << "       len w sub arrl sub dx dy lrl\n"

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

           dim2::Point<double> m;

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

//               t1=0;t2=1;

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

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

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

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

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

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

    ///of recursive functions.

    ///

    Node u=G.source(e);

    Node v=G.target(e);

  }

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

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

    }

  }

        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 (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.");

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

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

  }

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

          "Something is wrong with IdentityMap");

  }

    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;

  }

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

          "Something is wrong with FunctorToMap or MapToFunctor");

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

  // ConvertMap

  {

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

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

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

    map2.set(5, 10);

          "Something is wrong with ForkMap");

  }

    IdentityMap<int> im;

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

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

    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,

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

    vec v1;

    vec v2(10);

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

    map1.set(10, false);

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

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

          "Something is wrong with LoggerBoolMap");