Index: lemon/bellman_ford.h =================================================================== --- lemon/bellman_ford.h (revision 1250) +++ lemon/bellman_ford.h (revision 1254) @@ -150,5 +150,5 @@ /// This class provides an efficient implementation of the Bellman-Ford /// algorithm. The maximum time complexity of the algorithm is - /// O(ne). + /// O(nm). /// /// The Bellman-Ford algorithm solves the single-source shortest path Index: lemon/capacity_scaling.h =================================================================== --- lemon/capacity_scaling.h (revision 1250) +++ lemon/capacity_scaling.h (revision 1254) @@ -70,5 +70,5 @@ /// \cite edmondskarp72theoretical. It is an efficient dual /// solution method, which runs in polynomial time - /// \f$O(e\log U (n+e)\log n)\f$, where U denotes the maximum + /// \f$O(m\log U (n+m)\log n)\f$, where U denotes the maximum /// of node supply and arc capacity values. /// @@ -647,5 +647,5 @@ /// /// This function returns the total cost of the found flow. - /// Its complexity is O(e). + /// Its complexity is O(m). /// /// \note The return type of the function can be specified as a Index: lemon/core.h =================================================================== --- lemon/core.h (revision 1253) +++ lemon/core.h (revision 1239) @@ -39,10 +39,4 @@ #ifdef __GNUC__ -#define GCC_VERSION (__GNUC__ * 10000 \ - + __GNUC_MINOR__ * 100 \ - + __GNUC_PATCHLEVEL__) -#endif - -#if GCC_VERSION >= 40800 // Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8 #pragma GCC diagnostic ignored "-Wunused-local-typedefs" Index: lemon/cost_scaling.h =================================================================== --- lemon/cost_scaling.h (revision 1250) +++ lemon/cost_scaling.h (revision 1254) @@ -98,5 +98,5 @@ /// "preflow push-relabel" algorithm for the maximum flow problem. /// It is a polynomial algorithm, its running time complexity is - /// \f$O(n^2e\log(nK))\f$, where K denotes the maximum arc cost. + /// \f$O(n^2m\log(nK))\f$, where K denotes the maximum arc cost. /// /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest @@ -671,5 +671,5 @@ /// /// This function returns the total cost of the found flow. - /// Its complexity is O(e). + /// Its complexity is O(m). /// /// \note The return type of the function can be specified as a Index: lemon/cycle_canceling.h =================================================================== --- lemon/cycle_canceling.h (revision 1241) +++ lemon/cycle_canceling.h (revision 1254) @@ -52,5 +52,5 @@ /// The most efficent one is the \ref CANCEL_AND_TIGHTEN /// "Cancel-and-Tighten" algorithm, thus it is the default method. - /// It runs in strongly polynomial time O(n2e2log(n)), + /// It runs in strongly polynomial time O(n2m2log(n)), /// but in practice, it is typically orders of magnitude slower than /// the scaling algorithms and \ref NetworkSimplex. @@ -134,5 +134,5 @@ /// \cite goldberg89cyclecanceling. It improves along a /// \ref min_mean_cycle "minimum mean cycle" in each iteration. - /// Its running time complexity is O(n2e3log(n)). + /// Its running time complexity is O(n2m3log(n)). MINIMUM_MEAN_CYCLE_CANCELING, /// The "Cancel-and-Tighten" algorithm, which can be viewed as an @@ -140,5 +140,5 @@ /// \cite goldberg89cyclecanceling. /// It is faster both in theory and in practice, its running time - /// complexity is O(n2e2log(n)). + /// complexity is O(n2m2log(n)). CANCEL_AND_TIGHTEN }; @@ -577,5 +577,5 @@ /// /// This function returns the total cost of the found flow. - /// Its complexity is O(e). + /// Its complexity is O(m). /// /// \note The return type of the function can be specified as a Index: lemon/gomory_hu.h =================================================================== --- lemon/gomory_hu.h (revision 956) +++ lemon/gomory_hu.h (revision 1254) @@ -47,5 +47,5 @@ /// /// The algorithm calculates \e n-1 distinct minimum cuts (currently with - /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall + /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall /// time complexity. It calculates a rooted Gomory-Hu tree. /// The structure of the tree and the edge weights can be Index: lemon/graph_to_eps.h =================================================================== --- lemon/graph_to_eps.h (revision 1249) +++ lemon/graph_to_eps.h (revision 1159) @@ -223,5 +223,5 @@ using T::_copyright; - using T::NodeTextColorType; + using typename T::NodeTextColorType; using T::CUST_COL; using T::DIST_COL; Index: lemon/hartmann_orlin_mmc.h =================================================================== --- lemon/hartmann_orlin_mmc.h (revision 1250) +++ lemon/hartmann_orlin_mmc.h (revision 1254) @@ -103,5 +103,5 @@ /// applies an early termination scheme. It makes the algorithm /// significantly faster for some problem instances, but slower for others. - /// The algorithm runs in time O(ne) and uses space O(n2+e). + /// The algorithm runs in time O(nm) and uses space O(n2+m). /// /// \tparam GR The type of the digraph the algorithm runs on. Index: lemon/karp_mmc.h =================================================================== --- lemon/karp_mmc.h (revision 1250) +++ lemon/karp_mmc.h (revision 1254) @@ -100,5 +100,5 @@ /// cycle of minimum mean cost in a digraph /// \cite karp78characterization, \cite dasdan98minmeancycle. - /// It runs in time O(ne) and uses space O(n2+e). + /// It runs in time O(nm) and uses space O(n2+m). /// /// \tparam GR The type of the digraph the algorithm runs on. Index: lemon/lp_base.h =================================================================== --- lemon/lp_base.h (revision 1252) +++ lemon/lp_base.h (revision 1250) @@ -1008,5 +1008,5 @@ public: - ///Unsupported file format exception + ///\e \ class UnsupportedFormatError : public Exception { Index: lemon/min_cost_arborescence.h =================================================================== --- lemon/min_cost_arborescence.h (revision 1250) +++ lemon/min_cost_arborescence.h (revision 1254) @@ -102,5 +102,5 @@ /// the minimum cost subgraph that is the union of arborescences with the /// given sources and spans all the nodes which are reachable from the - /// sources. The time complexity of the algorithm is O(n2+e). + /// sources. The time complexity of the algorithm is O(n2+m). /// /// The algorithm also provides an optimal dual solution, therefore Index: lemon/network_simplex.h =================================================================== --- lemon/network_simplex.h (revision 1241) +++ lemon/network_simplex.h (revision 1254) @@ -974,5 +974,5 @@ /// /// This function returns the total cost of the found flow. - /// Its complexity is O(e). + /// Its complexity is O(m). /// /// \note The return type of the function can be specified as a Index: lemon/preflow.h =================================================================== --- lemon/preflow.h (revision 1250) +++ lemon/preflow.h (revision 1254) @@ -108,5 +108,5 @@ /// flow algorithms. The current implementation uses a mixture of the /// \e "highest label" and the \e "bound decrease" heuristics. - /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. + /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$. /// /// The algorithm consists of two phases. After the first phase Index: lemon/suurballe.h =================================================================== --- lemon/suurballe.h (revision 1250) +++ lemon/suurballe.h (revision 1254) @@ -683,5 +683,5 @@ /// This function returns the total length of the found paths, i.e. /// the total cost of the found flow. - /// The complexity of the function is O(e). + /// The complexity of the function is O(m). /// /// \pre \ref run() or \ref findFlow() must be called before using