COIN-OR::LEMON - Graph Library

Ticket #327: 327-mcf-reset-75c97c3786d6.patch

File 327-mcf-reset-75c97c3786d6.patch, 35.3 KB (added by Peter Kovacs, 10 years ago)
  • lemon/capacity_scaling.h

    # HG changeset patch
    # User Peter Kovacs <kpeter@inf.elte.hu>
    # Date 1265825120 -3600
    # Node ID 75c97c3786d67ff19a6421c06ed497166ed310bd
    # Parent  a7e93de12cbda2267756b130476b8e84572002bf
    Handle graph changes in the MCF algorithms (#327)
    
    The reset() functions are renamed to resetParams() and the new reset()
    functions handle the graph chnages, as well.
    
    diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
    a b  
    314314      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
    315315        "The cost type of CapacityScaling must be signed");
    316316
    317       // Resize vectors
    318       _node_num = countNodes(_graph);
    319       _arc_num = countArcs(_graph);
    320       _res_arc_num = 2 * (_arc_num + _node_num);
    321       _root = _node_num;
    322       ++_node_num;
    323 
    324       _first_out.resize(_node_num + 1);
    325       _forward.resize(_res_arc_num);
    326       _source.resize(_res_arc_num);
    327       _target.resize(_res_arc_num);
    328       _reverse.resize(_res_arc_num);
    329 
    330       _lower.resize(_res_arc_num);
    331       _upper.resize(_res_arc_num);
    332       _cost.resize(_res_arc_num);
    333       _supply.resize(_node_num);
    334      
    335       _res_cap.resize(_res_arc_num);
    336       _pi.resize(_node_num);
    337       _excess.resize(_node_num);
    338       _pred.resize(_node_num);
    339 
    340       // Copy the graph
    341       int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
    342       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    343         _node_id[n] = i;
    344       }
    345       i = 0;
    346       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    347         _first_out[i] = j;
    348         for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    349           _arc_idf[a] = j;
    350           _forward[j] = true;
    351           _source[j] = i;
    352           _target[j] = _node_id[_graph.runningNode(a)];
    353         }
    354         for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    355           _arc_idb[a] = j;
    356           _forward[j] = false;
    357           _source[j] = i;
    358           _target[j] = _node_id[_graph.runningNode(a)];
    359         }
    360         _forward[j] = false;
    361         _source[j] = i;
    362         _target[j] = _root;
    363         _reverse[j] = k;
    364         _forward[k] = true;
    365         _source[k] = _root;
    366         _target[k] = i;
    367         _reverse[k] = j;
    368         ++j; ++k;
    369       }
    370       _first_out[i] = j;
    371       _first_out[_node_num] = k;
    372       for (ArcIt a(_graph); a != INVALID; ++a) {
    373         int fi = _arc_idf[a];
    374         int bi = _arc_idb[a];
    375         _reverse[fi] = bi;
    376         _reverse[bi] = fi;
    377       }
    378      
    379       // Reset parameters
     317      // Reset data structures
    380318      reset();
    381319    }
    382320
     
    511449    ///     .supplyMap(sup).run();
    512450    /// \endcode
    513451    ///
    514     /// This function can be called more than once. All the parameters
    515     /// that have been given are kept for the next call, unless
    516     /// \ref reset() is called, thus only the modified parameters
    517     /// have to be set again. See \ref reset() for examples.
    518     /// However, the underlying digraph must not be modified after this
    519     /// class have been constructed, since it copies and extends the graph.
     452    /// This function can be called more than once. All the given parameters
     453    /// are kept for the next call, unless \ref resetParams() or \ref reset()
     454    /// is used, thus only the modified parameters have to be set again.
     455    /// If the underlying digraph was also modified after the construction
     456    /// of the class (or the last \ref reset() call), then the \ref reset()
     457    /// function must be called.
    520458    ///
    521459    /// \param factor The capacity scaling factor. It must be larger than
    522460    /// one to use scaling. If it is less or equal to one, then scaling
     
    533471    /// these cases.
    534472    ///
    535473    /// \see ProblemType
     474    /// \see resetParams(), reset()
    536475    ProblemType run(int factor = 4) {
    537476      _factor = factor;
    538477      ProblemType pt = init();
     
    546485    /// before using functions \ref lowerMap(), \ref upperMap(),
    547486    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
    548487    ///
    549     /// It is useful for multiple run() calls. If this function is not
    550     /// used, all the parameters given before are kept for the next
    551     /// \ref run() call.
    552     /// However, the underlying digraph must not be modified after this
    553     /// class have been constructed, since it copies and extends the graph.
     488    /// It is useful for multiple \ref run() calls. Basically, all the given
     489    /// parameters are kept for the next \ref run() call, unless
     490    /// \ref resetParams() or \ref reset() is used.
     491    /// If the underlying digraph was also modified after the construction
     492    /// of the class or the last \ref reset() call, then the \ref reset()
     493    /// function must be used, otherwise \ref resetParams() is sufficient.
    554494    ///
    555495    /// For example,
    556496    /// \code
     
    560500    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
    561501    ///     .supplyMap(sup).run();
    562502    ///
    563     ///   // Run again with modified cost map (reset() is not called,
     503    ///   // Run again with modified cost map (resetParams() is not called,
    564504    ///   // so only the cost map have to be set again)
    565505    ///   cost[e] += 100;
    566506    ///   cs.costMap(cost).run();
    567507    ///
    568     ///   // Run again from scratch using reset()
     508    ///   // Run again from scratch using resetParams()
    569509    ///   // (the lower bounds will be set to zero on all arcs)
    570     ///   cs.reset();
     510    ///   cs.resetParams();
    571511    ///   cs.upperMap(capacity).costMap(cost)
    572512    ///     .supplyMap(sup).run();
    573513    /// \endcode
    574514    ///
    575515    /// \return <tt>(*this)</tt>
    576     CapacityScaling& reset() {
     516    ///
     517    /// \see reset(), run()
     518    CapacityScaling& resetParams() {
    577519      for (int i = 0; i != _node_num; ++i) {
    578520        _supply[i] = 0;
    579521      }
     
    586528      return *this;
    587529    }
    588530
     531    /// \brief Reset the internal data structures and all the parameters
     532    /// that have been given before.
     533    ///
     534    /// This function resets the internal data structures and all the
     535    /// paramaters that have been given before using functions \ref lowerMap(),
     536    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
     537    ///
     538    /// It is useful for multiple \ref run() calls. Basically, all the given
     539    /// parameters are kept for the next \ref run() call, unless
     540    /// \ref resetParams() or \ref reset() is used.
     541    /// If the underlying digraph was also modified after the construction
     542    /// of the class or the last \ref reset() call, then the \ref reset()
     543    /// function must be used, otherwise \ref resetParams() is sufficient.
     544    ///
     545    /// See \ref resetParams() for examples.
     546    ///
     547    /// \return <tt>(*this)</tt>
     548    ///
     549    /// \see resetParams(), run()
     550    CapacityScaling& reset() {
     551      // Resize vectors
     552      _node_num = countNodes(_graph);
     553      _arc_num = countArcs(_graph);
     554      _res_arc_num = 2 * (_arc_num + _node_num);
     555      _root = _node_num;
     556      ++_node_num;
     557
     558      _first_out.resize(_node_num + 1);
     559      _forward.resize(_res_arc_num);
     560      _source.resize(_res_arc_num);
     561      _target.resize(_res_arc_num);
     562      _reverse.resize(_res_arc_num);
     563
     564      _lower.resize(_res_arc_num);
     565      _upper.resize(_res_arc_num);
     566      _cost.resize(_res_arc_num);
     567      _supply.resize(_node_num);
     568     
     569      _res_cap.resize(_res_arc_num);
     570      _pi.resize(_node_num);
     571      _excess.resize(_node_num);
     572      _pred.resize(_node_num);
     573
     574      // Copy the graph
     575      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
     576      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     577        _node_id[n] = i;
     578      }
     579      i = 0;
     580      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     581        _first_out[i] = j;
     582        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     583          _arc_idf[a] = j;
     584          _forward[j] = true;
     585          _source[j] = i;
     586          _target[j] = _node_id[_graph.runningNode(a)];
     587        }
     588        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     589          _arc_idb[a] = j;
     590          _forward[j] = false;
     591          _source[j] = i;
     592          _target[j] = _node_id[_graph.runningNode(a)];
     593        }
     594        _forward[j] = false;
     595        _source[j] = i;
     596        _target[j] = _root;
     597        _reverse[j] = k;
     598        _forward[k] = true;
     599        _source[k] = _root;
     600        _target[k] = i;
     601        _reverse[k] = j;
     602        ++j; ++k;
     603      }
     604      _first_out[i] = j;
     605      _first_out[_node_num] = k;
     606      for (ArcIt a(_graph); a != INVALID; ++a) {
     607        int fi = _arc_idf[a];
     608        int bi = _arc_idb[a];
     609        _reverse[fi] = bi;
     610        _reverse[bi] = fi;
     611      }
     612     
     613      // Reset parameters
     614      resetParams();
     615      return *this;
     616    }
     617
    589618    /// @}
    590619
    591620    /// \name Query Functions
  • lemon/cost_scaling.h

    diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
    a b  
    332332        "The flow type of CostScaling must be signed");
    333333      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
    334334        "The cost type of CostScaling must be signed");
    335 
    336       // Resize vectors
    337       _node_num = countNodes(_graph);
    338       _arc_num = countArcs(_graph);
    339       _res_node_num = _node_num + 1;
    340       _res_arc_num = 2 * (_arc_num + _node_num);
    341       _root = _node_num;
    342 
    343       _first_out.resize(_res_node_num + 1);
    344       _forward.resize(_res_arc_num);
    345       _source.resize(_res_arc_num);
    346       _target.resize(_res_arc_num);
    347       _reverse.resize(_res_arc_num);
    348 
    349       _lower.resize(_res_arc_num);
    350       _upper.resize(_res_arc_num);
    351       _scost.resize(_res_arc_num);
    352       _supply.resize(_res_node_num);
    353335     
    354       _res_cap.resize(_res_arc_num);
    355       _cost.resize(_res_arc_num);
    356       _pi.resize(_res_node_num);
    357       _excess.resize(_res_node_num);
    358       _next_out.resize(_res_node_num);
    359 
    360       _arc_vec.reserve(_res_arc_num);
    361       _cost_vec.reserve(_res_arc_num);
    362 
    363       // Copy the graph
    364       int i = 0, j = 0, k = 2 * _arc_num + _node_num;
    365       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    366         _node_id[n] = i;
    367       }
    368       i = 0;
    369       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    370         _first_out[i] = j;
    371         for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    372           _arc_idf[a] = j;
    373           _forward[j] = true;
    374           _source[j] = i;
    375           _target[j] = _node_id[_graph.runningNode(a)];
    376         }
    377         for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    378           _arc_idb[a] = j;
    379           _forward[j] = false;
    380           _source[j] = i;
    381           _target[j] = _node_id[_graph.runningNode(a)];
    382         }
    383         _forward[j] = false;
    384         _source[j] = i;
    385         _target[j] = _root;
    386         _reverse[j] = k;
    387         _forward[k] = true;
    388         _source[k] = _root;
    389         _target[k] = i;
    390         _reverse[k] = j;
    391         ++j; ++k;
    392       }
    393       _first_out[i] = j;
    394       _first_out[_res_node_num] = k;
    395       for (ArcIt a(_graph); a != INVALID; ++a) {
    396         int fi = _arc_idf[a];
    397         int bi = _arc_idb[a];
    398         _reverse[fi] = bi;
    399         _reverse[bi] = fi;
    400       }
    401      
    402       // Reset parameters
     336      // Reset data structures
    403337      reset();
    404338    }
    405339
     
    534468    ///     .supplyMap(sup).run();
    535469    /// \endcode
    536470    ///
    537     /// This function can be called more than once. All the parameters
    538     /// that have been given are kept for the next call, unless
    539     /// \ref reset() is called, thus only the modified parameters
    540     /// have to be set again. See \ref reset() for examples.
    541     /// However, the underlying digraph must not be modified after this
    542     /// class have been constructed, since it copies and extends the graph.
     471    /// This function can be called more than once. All the given parameters
     472    /// are kept for the next call, unless \ref resetParams() or \ref reset()
     473    /// is used, thus only the modified parameters have to be set again.
     474    /// If the underlying digraph was also modified after the construction
     475    /// of the class (or the last \ref reset() call), then the \ref reset()
     476    /// function must be called.
    543477    ///
    544478    /// \param method The internal method that will be used in the
    545479    /// algorithm. For more information, see \ref Method.
     
    556490    /// these cases.
    557491    ///
    558492    /// \see ProblemType, Method
     493    /// \see resetParams(), reset()
    559494    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 8) {
    560495      _alpha = factor;
    561496      ProblemType pt = init();
     
    570505    /// before using functions \ref lowerMap(), \ref upperMap(),
    571506    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
    572507    ///
    573     /// It is useful for multiple run() calls. If this function is not
    574     /// used, all the parameters given before are kept for the next
    575     /// \ref run() call.
    576     /// However, the underlying digraph must not be modified after this
    577     /// class have been constructed, since it copies and extends the graph.
     508    /// It is useful for multiple \ref run() calls. Basically, all the given
     509    /// parameters are kept for the next \ref run() call, unless
     510    /// \ref resetParams() or \ref reset() is used.
     511    /// If the underlying digraph was also modified after the construction
     512    /// of the class or the last \ref reset() call, then the \ref reset()
     513    /// function must be used, otherwise \ref resetParams() is sufficient.
    578514    ///
    579515    /// For example,
    580516    /// \code
     
    584520    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
    585521    ///     .supplyMap(sup).run();
    586522    ///
    587     ///   // Run again with modified cost map (reset() is not called,
     523    ///   // Run again with modified cost map (resetParams() is not called,
    588524    ///   // so only the cost map have to be set again)
    589525    ///   cost[e] += 100;
    590526    ///   cs.costMap(cost).run();
    591527    ///
    592     ///   // Run again from scratch using reset()
     528    ///   // Run again from scratch using resetParams()
    593529    ///   // (the lower bounds will be set to zero on all arcs)
    594     ///   cs.reset();
     530    ///   cs.resetParams();
    595531    ///   cs.upperMap(capacity).costMap(cost)
    596532    ///     .supplyMap(sup).run();
    597533    /// \endcode
    598534    ///
    599535    /// \return <tt>(*this)</tt>
    600     CostScaling& reset() {
     536    ///
     537    /// \see reset(), run()
     538    CostScaling& resetParams() {
    601539      for (int i = 0; i != _res_node_num; ++i) {
    602540        _supply[i] = 0;
    603541      }
     
    617555      return *this;
    618556    }
    619557
     558    /// \brief Reset all the parameters that have been given before.
     559    ///
     560    /// This function resets all the paramaters that have been given
     561    /// before using functions \ref lowerMap(), \ref upperMap(),
     562    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
     563    ///
     564    /// It is useful for multiple run() calls. If this function is not
     565    /// used, all the parameters given before are kept for the next
     566    /// \ref run() call.
     567    /// However, the underlying digraph must not be modified after this
     568    /// class have been constructed, since it copies and extends the graph.
     569    /// \return <tt>(*this)</tt>
     570    CostScaling& reset() {
     571      // Resize vectors
     572      _node_num = countNodes(_graph);
     573      _arc_num = countArcs(_graph);
     574      _res_node_num = _node_num + 1;
     575      _res_arc_num = 2 * (_arc_num + _node_num);
     576      _root = _node_num;
     577
     578      _first_out.resize(_res_node_num + 1);
     579      _forward.resize(_res_arc_num);
     580      _source.resize(_res_arc_num);
     581      _target.resize(_res_arc_num);
     582      _reverse.resize(_res_arc_num);
     583
     584      _lower.resize(_res_arc_num);
     585      _upper.resize(_res_arc_num);
     586      _scost.resize(_res_arc_num);
     587      _supply.resize(_res_node_num);
     588     
     589      _res_cap.resize(_res_arc_num);
     590      _cost.resize(_res_arc_num);
     591      _pi.resize(_res_node_num);
     592      _excess.resize(_res_node_num);
     593      _next_out.resize(_res_node_num);
     594
     595      _arc_vec.reserve(_res_arc_num);
     596      _cost_vec.reserve(_res_arc_num);
     597
     598      // Copy the graph
     599      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
     600      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     601        _node_id[n] = i;
     602      }
     603      i = 0;
     604      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     605        _first_out[i] = j;
     606        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     607          _arc_idf[a] = j;
     608          _forward[j] = true;
     609          _source[j] = i;
     610          _target[j] = _node_id[_graph.runningNode(a)];
     611        }
     612        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     613          _arc_idb[a] = j;
     614          _forward[j] = false;
     615          _source[j] = i;
     616          _target[j] = _node_id[_graph.runningNode(a)];
     617        }
     618        _forward[j] = false;
     619        _source[j] = i;
     620        _target[j] = _root;
     621        _reverse[j] = k;
     622        _forward[k] = true;
     623        _source[k] = _root;
     624        _target[k] = i;
     625        _reverse[k] = j;
     626        ++j; ++k;
     627      }
     628      _first_out[i] = j;
     629      _first_out[_res_node_num] = k;
     630      for (ArcIt a(_graph); a != INVALID; ++a) {
     631        int fi = _arc_idf[a];
     632        int bi = _arc_idb[a];
     633        _reverse[fi] = bi;
     634        _reverse[bi] = fi;
     635      }
     636     
     637      // Reset parameters
     638      resetParams();
     639      return *this;
     640    }
     641
    620642    /// @}
    621643
    622644    /// \name Query Functions
  • lemon/cycle_canceling.h

    diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
    a b  
    250250      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
    251251        "The cost type of CycleCanceling must be signed");
    252252
    253       // Resize vectors
    254       _node_num = countNodes(_graph);
    255       _arc_num = countArcs(_graph);
    256       _res_node_num = _node_num + 1;
    257       _res_arc_num = 2 * (_arc_num + _node_num);
    258       _root = _node_num;
    259 
    260       _first_out.resize(_res_node_num + 1);
    261       _forward.resize(_res_arc_num);
    262       _source.resize(_res_arc_num);
    263       _target.resize(_res_arc_num);
    264       _reverse.resize(_res_arc_num);
    265 
    266       _lower.resize(_res_arc_num);
    267       _upper.resize(_res_arc_num);
    268       _cost.resize(_res_arc_num);
    269       _supply.resize(_res_node_num);
    270      
    271       _res_cap.resize(_res_arc_num);
    272       _pi.resize(_res_node_num);
    273 
    274       _arc_vec.reserve(_res_arc_num);
    275       _cost_vec.reserve(_res_arc_num);
    276       _id_vec.reserve(_res_arc_num);
    277 
    278       // Copy the graph
    279       int i = 0, j = 0, k = 2 * _arc_num + _node_num;
    280       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    281         _node_id[n] = i;
    282       }
    283       i = 0;
    284       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    285         _first_out[i] = j;
    286         for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    287           _arc_idf[a] = j;
    288           _forward[j] = true;
    289           _source[j] = i;
    290           _target[j] = _node_id[_graph.runningNode(a)];
    291         }
    292         for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
    293           _arc_idb[a] = j;
    294           _forward[j] = false;
    295           _source[j] = i;
    296           _target[j] = _node_id[_graph.runningNode(a)];
    297         }
    298         _forward[j] = false;
    299         _source[j] = i;
    300         _target[j] = _root;
    301         _reverse[j] = k;
    302         _forward[k] = true;
    303         _source[k] = _root;
    304         _target[k] = i;
    305         _reverse[k] = j;
    306         ++j; ++k;
    307       }
    308       _first_out[i] = j;
    309       _first_out[_res_node_num] = k;
    310       for (ArcIt a(_graph); a != INVALID; ++a) {
    311         int fi = _arc_idf[a];
    312         int bi = _arc_idb[a];
    313         _reverse[fi] = bi;
    314         _reverse[bi] = fi;
    315       }
    316      
    317       // Reset parameters
     253      // Reset data structures
    318254      reset();
    319255    }
    320256
     
    449385    ///     .supplyMap(sup).run();
    450386    /// \endcode
    451387    ///
    452     /// This function can be called more than once. All the parameters
    453     /// that have been given are kept for the next call, unless
    454     /// \ref reset() is called, thus only the modified parameters
    455     /// have to be set again. See \ref reset() for examples.
    456     /// However, the underlying digraph must not be modified after this
    457     /// class have been constructed, since it copies and extends the graph.
     388    /// This function can be called more than once. All the given parameters
     389    /// are kept for the next call, unless \ref resetParams() or \ref reset()
     390    /// is used, thus only the modified parameters have to be set again.
     391    /// If the underlying digraph was also modified after the construction
     392    /// of the class (or the last \ref reset() call), then the \ref reset()
     393    /// function must be called.
    458394    ///
    459395    /// \param method The cycle-canceling method that will be used.
    460396    /// For more information, see \ref Method.
     
    470406    /// these cases.
    471407    ///
    472408    /// \see ProblemType, Method
     409    /// \see resetParams(), reset()
    473410    ProblemType run(Method method = CANCEL_AND_TIGHTEN) {
    474411      ProblemType pt = init();
    475412      if (pt != OPTIMAL) return pt;
     
    483420    /// before using functions \ref lowerMap(), \ref upperMap(),
    484421    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
    485422    ///
    486     /// It is useful for multiple run() calls. If this function is not
    487     /// used, all the parameters given before are kept for the next
    488     /// \ref run() call.
    489     /// However, the underlying digraph must not be modified after this
    490     /// class have been constructed, since it copies and extends the graph.
     423    /// It is useful for multiple \ref run() calls. Basically, all the given
     424    /// parameters are kept for the next \ref run() call, unless
     425    /// \ref resetParams() or \ref reset() is used.
     426    /// If the underlying digraph was also modified after the construction
     427    /// of the class or the last \ref reset() call, then the \ref reset()
     428    /// function must be used, otherwise \ref resetParams() is sufficient.
    491429    ///
    492430    /// For example,
    493431    /// \code
     
    497435    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
    498436    ///     .supplyMap(sup).run();
    499437    ///
    500     ///   // Run again with modified cost map (reset() is not called,
     438    ///   // Run again with modified cost map (resetParams() is not called,
    501439    ///   // so only the cost map have to be set again)
    502440    ///   cost[e] += 100;
    503441    ///   cc.costMap(cost).run();
    504442    ///
    505     ///   // Run again from scratch using reset()
     443    ///   // Run again from scratch using resetParams()
    506444    ///   // (the lower bounds will be set to zero on all arcs)
    507     ///   cc.reset();
     445    ///   cc.resetParams();
    508446    ///   cc.upperMap(capacity).costMap(cost)
    509447    ///     .supplyMap(sup).run();
    510448    /// \endcode
    511449    ///
    512450    /// \return <tt>(*this)</tt>
    513     CycleCanceling& reset() {
     451    ///
     452    /// \see reset(), run()
     453    CycleCanceling& resetParams() {
    514454      for (int i = 0; i != _res_node_num; ++i) {
    515455        _supply[i] = 0;
    516456      }
     
    530470      return *this;
    531471    }
    532472
     473    /// \brief Reset the internal data structures and all the parameters
     474    /// that have been given before.
     475    ///
     476    /// This function resets the internal data structures and all the
     477    /// paramaters that have been given before using functions \ref lowerMap(),
     478    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
     479    ///
     480    /// It is useful for multiple \ref run() calls. Basically, all the given
     481    /// parameters are kept for the next \ref run() call, unless
     482    /// \ref resetParams() or \ref reset() is used.
     483    /// If the underlying digraph was also modified after the construction
     484    /// of the class or the last \ref reset() call, then the \ref reset()
     485    /// function must be used, otherwise \ref resetParams() is sufficient.
     486    ///
     487    /// See \ref resetParams() for examples.
     488    ///
     489    /// \return <tt>(*this)</tt>
     490    ///
     491    /// \see resetParams(), run()
     492    CycleCanceling& reset() {
     493      // Resize vectors
     494      _node_num = countNodes(_graph);
     495      _arc_num = countArcs(_graph);
     496      _res_node_num = _node_num + 1;
     497      _res_arc_num = 2 * (_arc_num + _node_num);
     498      _root = _node_num;
     499
     500      _first_out.resize(_res_node_num + 1);
     501      _forward.resize(_res_arc_num);
     502      _source.resize(_res_arc_num);
     503      _target.resize(_res_arc_num);
     504      _reverse.resize(_res_arc_num);
     505
     506      _lower.resize(_res_arc_num);
     507      _upper.resize(_res_arc_num);
     508      _cost.resize(_res_arc_num);
     509      _supply.resize(_res_node_num);
     510     
     511      _res_cap.resize(_res_arc_num);
     512      _pi.resize(_res_node_num);
     513
     514      _arc_vec.reserve(_res_arc_num);
     515      _cost_vec.reserve(_res_arc_num);
     516      _id_vec.reserve(_res_arc_num);
     517
     518      // Copy the graph
     519      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
     520      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     521        _node_id[n] = i;
     522      }
     523      i = 0;
     524      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     525        _first_out[i] = j;
     526        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     527          _arc_idf[a] = j;
     528          _forward[j] = true;
     529          _source[j] = i;
     530          _target[j] = _node_id[_graph.runningNode(a)];
     531        }
     532        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
     533          _arc_idb[a] = j;
     534          _forward[j] = false;
     535          _source[j] = i;
     536          _target[j] = _node_id[_graph.runningNode(a)];
     537        }
     538        _forward[j] = false;
     539        _source[j] = i;
     540        _target[j] = _root;
     541        _reverse[j] = k;
     542        _forward[k] = true;
     543        _source[k] = _root;
     544        _target[k] = i;
     545        _reverse[k] = j;
     546        ++j; ++k;
     547      }
     548      _first_out[i] = j;
     549      _first_out[_res_node_num] = k;
     550      for (ArcIt a(_graph); a != INVALID; ++a) {
     551        int fi = _arc_idf[a];
     552        int bi = _arc_idb[a];
     553        _reverse[fi] = bi;
     554        _reverse[bi] = fi;
     555      }
     556     
     557      // Reset parameters
     558      resetParams();
     559      return *this;
     560    }
     561
    533562    /// @}
    534563
    535564    /// \name Query Functions
  • lemon/network_simplex.h

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    194194    IntArcMap _arc_id;
    195195    IntVector _source;
    196196    IntVector _target;
     197    bool _arc_mixing;
    197198
    198199    // Node and arc data
    199200    ValueVector _lower;
     
    633634    /// but it is usually slower. Therefore it is disabled by default.
    634635    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
    635636      _graph(graph), _node_id(graph), _arc_id(graph),
     637      _arc_mixing(arc_mixing),
    636638      MAX(std::numeric_limits<Value>::max()),
    637639      INF(std::numeric_limits<Value>::has_infinity ?
    638640          std::numeric_limits<Value>::infinity() : MAX)
     
    643645      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
    644646        "The cost type of NetworkSimplex must be signed");
    645647       
    646       // Resize vectors
    647       _node_num = countNodes(_graph);
    648       _arc_num = countArcs(_graph);
    649       int all_node_num = _node_num + 1;
    650       int max_arc_num = _arc_num + 2 * _node_num;
    651 
    652       _source.resize(max_arc_num);
    653       _target.resize(max_arc_num);
    654 
    655       _lower.resize(_arc_num);
    656       _upper.resize(_arc_num);
    657       _cap.resize(max_arc_num);
    658       _cost.resize(max_arc_num);
    659       _supply.resize(all_node_num);
    660       _flow.resize(max_arc_num);
    661       _pi.resize(all_node_num);
    662 
    663       _parent.resize(all_node_num);
    664       _pred.resize(all_node_num);
    665       _forward.resize(all_node_num);
    666       _thread.resize(all_node_num);
    667       _rev_thread.resize(all_node_num);
    668       _succ_num.resize(all_node_num);
    669       _last_succ.resize(all_node_num);
    670       _state.resize(max_arc_num);
    671 
    672       // Copy the graph
    673       int i = 0;
    674       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
    675         _node_id[n] = i;
    676       }
    677       if (arc_mixing) {
    678         // Store the arcs in a mixed order
    679         int k = std::max(int(std::sqrt(double(_arc_num))), 10);
    680         int i = 0, j = 0;
    681         for (ArcIt a(_graph); a != INVALID; ++a) {
    682           _arc_id[a] = i;
    683           _source[i] = _node_id[_graph.source(a)];
    684           _target[i] = _node_id[_graph.target(a)];
    685           if ((i += k) >= _arc_num) i = ++j;
    686         }
    687       } else {
    688         // Store the arcs in the original order
    689         int i = 0;
    690         for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
    691           _arc_id[a] = i;
    692           _source[i] = _node_id[_graph.source(a)];
    693           _target[i] = _node_id[_graph.target(a)];
    694         }
    695       }
    696      
    697       // Reset parameters
     648      // Reset data structures
    698649      reset();
    699650    }
    700651
     
    842793    ///     .supplyMap(sup).run();
    843794    /// \endcode
    844795    ///
    845     /// This function can be called more than once. All the parameters
    846     /// that have been given are kept for the next call, unless
    847     /// \ref reset() is called, thus only the modified parameters
    848     /// have to be set again. See \ref reset() for examples.
    849     /// However, the underlying digraph must not be modified after this
    850     /// class have been constructed, since it copies and extends the graph.
     796    /// This function can be called more than once. All the given parameters
     797    /// are kept for the next call, unless \ref resetParams() or \ref reset()
     798    /// is used, thus only the modified parameters have to be set again.
     799    /// If the underlying digraph was also modified after the construction
     800    /// of the class (or the last \ref reset() call), then the \ref reset()
     801    /// function must be called.
    851802    ///
    852803    /// \param pivot_rule The pivot rule that will be used during the
    853804    /// algorithm. For more information, see \ref PivotRule.
     
    861812    /// cost and infinite upper bound.
    862813    ///
    863814    /// \see ProblemType, PivotRule
     815    /// \see resetParams(), reset()
    864816    ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {
    865817      if (!init()) return INFEASIBLE;
    866818      return start(pivot_rule);
     
    872824    /// before using functions \ref lowerMap(), \ref upperMap(),
    873825    /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType().
    874826    ///
    875     /// It is useful for multiple run() calls. If this function is not
    876     /// used, all the parameters given before are kept for the next
    877     /// \ref run() call.
    878     /// However, the underlying digraph must not be modified after this
    879     /// class have been constructed, since it copies and extends the graph.
     827    /// It is useful for multiple \ref run() calls. Basically, all the given
     828    /// parameters are kept for the next \ref run() call, unless
     829    /// \ref resetParams() or \ref reset() is used.
     830    /// If the underlying digraph was also modified after the construction
     831    /// of the class or the last \ref reset() call, then the \ref reset()
     832    /// function must be used, otherwise \ref resetParams() is sufficient.
    880833    ///
    881834    /// For example,
    882835    /// \code
     
    886839    ///   ns.lowerMap(lower).upperMap(upper).costMap(cost)
    887840    ///     .supplyMap(sup).run();
    888841    ///
    889     ///   // Run again with modified cost map (reset() is not called,
     842    ///   // Run again with modified cost map (resetParams() is not called,
    890843    ///   // so only the cost map have to be set again)
    891844    ///   cost[e] += 100;
    892845    ///   ns.costMap(cost).run();
    893846    ///
    894     ///   // Run again from scratch using reset()
     847    ///   // Run again from scratch using resetParams()
    895848    ///   // (the lower bounds will be set to zero on all arcs)
    896     ///   ns.reset();
     849    ///   ns.resetParams();
    897850    ///   ns.upperMap(capacity).costMap(cost)
    898851    ///     .supplyMap(sup).run();
    899852    /// \endcode
    900853    ///
    901854    /// \return <tt>(*this)</tt>
    902     NetworkSimplex& reset() {
     855    ///
     856    /// \see reset(), run()
     857    NetworkSimplex& resetParams() {
    903858      for (int i = 0; i != _node_num; ++i) {
    904859        _supply[i] = 0;
    905860      }
     
    913868      return *this;
    914869    }
    915870
     871    /// \brief Reset the internal data structures and all the parameters
     872    /// that have been given before.
     873    ///
     874    /// This function resets the internal data structures and all the
     875    /// paramaters that have been given before using functions \ref lowerMap(),
     876    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
     877    /// \ref supplyType().
     878    ///
     879    /// It is useful for multiple \ref run() calls. Basically, all the given
     880    /// parameters are kept for the next \ref run() call, unless
     881    /// \ref resetParams() or \ref reset() is used.
     882    /// If the underlying digraph was also modified after the construction
     883    /// of the class or the last \ref reset() call, then the \ref reset()
     884    /// function must be used, otherwise \ref resetParams() is sufficient.
     885    ///
     886    /// See \ref resetParams() for examples.
     887    ///
     888    /// \return <tt>(*this)</tt>
     889    ///
     890    /// \see resetParams(), run()
     891    NetworkSimplex& reset() {
     892      // Resize vectors
     893      _node_num = countNodes(_graph);
     894      _arc_num = countArcs(_graph);
     895      int all_node_num = _node_num + 1;
     896      int max_arc_num = _arc_num + 2 * _node_num;
     897
     898      _source.resize(max_arc_num);
     899      _target.resize(max_arc_num);
     900
     901      _lower.resize(_arc_num);
     902      _upper.resize(_arc_num);
     903      _cap.resize(max_arc_num);
     904      _cost.resize(max_arc_num);
     905      _supply.resize(all_node_num);
     906      _flow.resize(max_arc_num);
     907      _pi.resize(all_node_num);
     908
     909      _parent.resize(all_node_num);
     910      _pred.resize(all_node_num);
     911      _forward.resize(all_node_num);
     912      _thread.resize(all_node_num);
     913      _rev_thread.resize(all_node_num);
     914      _succ_num.resize(all_node_num);
     915      _last_succ.resize(all_node_num);
     916      _state.resize(max_arc_num);
     917
     918      // Copy the graph
     919      int i = 0;
     920      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
     921        _node_id[n] = i;
     922      }
     923      if (_arc_mixing) {
     924        // Store the arcs in a mixed order
     925        int k = std::max(int(std::sqrt(double(_arc_num))), 10);
     926        int i = 0, j = 0;
     927        for (ArcIt a(_graph); a != INVALID; ++a) {
     928          _arc_id[a] = i;
     929          _source[i] = _node_id[_graph.source(a)];
     930          _target[i] = _node_id[_graph.target(a)];
     931          if ((i += k) >= _arc_num) i = ++j;
     932        }
     933      } else {
     934        // Store the arcs in the original order
     935        int i = 0;
     936        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
     937          _arc_id[a] = i;
     938          _source[i] = _node_id[_graph.source(a)];
     939          _target[i] = _node_id[_graph.target(a)];
     940        }
     941      }
     942     
     943      // Reset parameters
     944      resetParams();
     945      return *this;
     946    }
     947   
    916948    /// @}
    917949
    918950    /// \name Query Functions
  • test/min_cost_flow_test.cc

    diff --git a/test/min_cost_flow_test.cc b/test/min_cost_flow_test.cc
    a b  
    157157      MCF mcf(me.g);
    158158      const MCF& const_mcf = mcf;
    159159
    160       b = mcf.reset()
     160      b = mcf.reset().resetParams()
    161161             .lowerMap(me.lower)
    162162             .upperMap(me.upper)
    163163             .costMap(me.cost)
     
    346346  mcf1.stSupply(v, w, 27);
    347347  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2,
    348348           mcf1.OPTIMAL, true,     8010, test_str + "-4");
    349   mcf1.reset().supplyMap(s1);
     349  mcf1.resetParams().supplyMap(s1);
    350350  checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1,
    351351           mcf1.OPTIMAL, true,       74, test_str + "-5");
    352352  mcf1.lowerMap(l2).stSupply(v, w, 27);
     
    363363           mcf1.OPTIMAL, true,     6360, test_str + "-9");
    364364
    365365  // Tests for the GEQ form
    366   mcf1.reset().upperMap(u).costMap(c).supplyMap(s5);
     366  mcf1.resetParams().upperMap(u).costMap(c).supplyMap(s5);
    367367  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s5,
    368368           mcf1.OPTIMAL, true,     3530, test_str + "-10", GEQ);
    369369  mcf1.lowerMap(l2);
     
    380380  mcf2.upperMap(neg1_u2);
    381381  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s,
    382382           mcf2.OPTIMAL, true,   -40000, test_str + "-14");
    383   mcf2.reset().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
     383  mcf2.resetParams().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
    384384  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l2, neg1_u1, neg1_c, neg1_s,
    385385           mcf2.UNBOUNDED, false,     0, test_str + "-15");
    386386