Changeset 611:85cb3aa71cce in lemon1.2 for lemon/circulation.h
 Timestamp:
 04/21/09 16:18:54 (12 years ago)
 Branch:
 default
 Children:
 612:0c8e5c688440, 613:b1811c363299, 619:ec817dfc2cb7
 Parents:
 600:0ba8dfce7259 (diff), 610:dacc2cee2b4c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.  Phase:
 public
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

lemon/circulation.h
r581 r611 32 32 /// 33 33 /// Default traits class of Circulation class. 34 /// \tparam GR Digraph type. 35 /// \tparam LM Lower bound capacity map type. 36 /// \tparam UM Upper bound capacity map type. 37 /// \tparam DM Delta map type. 34 /// 35 /// \tparam GR Type of the digraph the algorithm runs on. 36 /// \tparam LM The type of the lower bound map. 37 /// \tparam UM The type of the upper bound (capacity) map. 38 /// \tparam SM The type of the supply map. 38 39 template <typename GR, typename LM, 39 typename UM, typename DM>40 typename UM, typename SM> 40 41 struct CirculationDefaultTraits { 41 42 … … 43 44 typedef GR Digraph; 44 45 45 /// \brief The type of the map that stores the circulation lower 46 /// bound. 47 /// 48 /// The type of the map that stores the circulation lower bound. 49 /// It must meet the \ref concepts::ReadMap "ReadMap" concept. 50 typedef LM LCapMap; 51 52 /// \brief The type of the map that stores the circulation upper 53 /// bound. 54 /// 55 /// The type of the map that stores the circulation upper bound. 56 /// It must meet the \ref concepts::ReadMap "ReadMap" concept. 57 typedef UM UCapMap; 58 59 /// \brief The type of the map that stores the lower bound for 60 /// the supply of the nodes. 61 /// 62 /// The type of the map that stores the lower bound for the supply 63 /// of the nodes. It must meet the \ref concepts::ReadMap "ReadMap" 46 /// \brief The type of the lower bound map. 47 /// 48 /// The type of the map that stores the lower bounds on the arcs. 49 /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. 50 typedef LM LowerMap; 51 52 /// \brief The type of the upper bound (capacity) map. 53 /// 54 /// The type of the map that stores the upper bounds (capacities) 55 /// on the arcs. 56 /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. 57 typedef UM UpperMap; 58 59 /// \brief The type of supply map. 60 /// 61 /// The type of the map that stores the signed supply values of the 62 /// nodes. 63 /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. 64 typedef SM SupplyMap; 65 66 /// \brief The type of the flow values. 67 typedef typename SupplyMap::Value Flow; 68 69 /// \brief The type of the map that stores the flow values. 70 /// 71 /// The type of the map that stores the flow values. 72 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" 64 73 /// concept. 65 typedef DM DeltaMap; 66 67 /// \brief The type of the flow values. 68 typedef typename DeltaMap::Value Value; 69 70 /// \brief The type of the map that stores the flow values. 71 /// 72 /// The type of the map that stores the flow values. 73 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 74 typedef typename Digraph::template ArcMap<Value> FlowMap; 74 typedef typename Digraph::template ArcMap<Flow> FlowMap; 75 75 76 76 /// \brief Instantiates a FlowMap. 77 77 /// 78 78 /// This function instantiates a \ref FlowMap. 79 /// \param digraph The digraph , towhich we would like to define79 /// \param digraph The digraph for which we would like to define 80 80 /// the flow map. 81 81 static FlowMap* createFlowMap(const Digraph& digraph) { … … 94 94 /// 95 95 /// This function instantiates an \ref Elevator. 96 /// \param digraph The digraph , towhich we would like to define96 /// \param digraph The digraph for which we would like to define 97 97 /// the elevator. 98 98 /// \param max_level The maximum level of the elevator. … … 104 104 /// 105 105 /// The tolerance used by the algorithm to handle inexact computation. 106 typedef lemon::Tolerance< Value> Tolerance;106 typedef lemon::Tolerance<Flow> Tolerance; 107 107 108 108 }; … … 112 112 113 113 \ingroup max_flow 114 This class implements a pushrelabel algorithm for the network115 circulation problem.114 This class implements a pushrelabel algorithm for the \e network 115 \e circulation problem. 116 116 It is to find a feasible circulation when lower and upper bounds 117 are given for the flow values on the arcs and lower bounds 118 are given for the supply values of the nodes. 117 are given for the flow values on the arcs and lower bounds are 118 given for the difference between the outgoing and incoming flow 119 at the nodes. 119 120 120 121 The exact formulation of this problem is the following. 121 122 Let \f$G=(V,A)\f$ be a digraph, 122 \f$lower, upper: A\rightarrow\mathbf{R}^+_0\f$, 123 \f$delta: V\rightarrow\mathbf{R}\f$. Find a feasible circulation 124 \f$f: A\rightarrow\mathbf{R}^+_0\f$ so that 125 \f[ \sum_{a\in\delta_{out}(v)} f(a)  \sum_{a\in\delta_{in}(v)} f(a) 126 \geq delta(v) \quad \forall v\in V, \f] 127 \f[ lower(a)\leq f(a) \leq upper(a) \quad \forall a\in A. \f] 128 \note \f$delta(v)\f$ specifies a lower bound for the supply of node 129 \f$v\f$. It can be either positive or negative, however note that 130 \f$\sum_{v\in V}delta(v)\f$ should be zero or negative in order to 131 have a feasible solution. 132 133 \note A special case of this problem is when 134 \f$\sum_{v\in V}delta(v) = 0\f$. Then the supply of each node \f$v\f$ 135 will be \e equal \e to \f$delta(v)\f$, if a circulation can be found. 136 Thus a feasible solution for the 137 \ref min_cost_flow "minimum cost flow" problem can be calculated 138 in this way. 123 \f$lower, upper: A\rightarrow\mathbf{R}^+_0\f$ denote the lower and 124 upper bounds on the arcs, for which \f$0 \leq lower(uv) \leq upper(uv)\f$ 125 holds for all \f$uv\in A\f$, and \f$sup: V\rightarrow\mathbf{R}\f$ 126 denotes the signed supply values of the nodes. 127 If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$ 128 supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with 129 \f$sup(u)\f$ demand. 130 A feasible circulation is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ 131 solution of the following problem. 132 133 \f[ \sum_{uv\in A} f(uv)  \sum_{vu\in A} f(vu) 134 \geq sup(u) \quad \forall u\in V, \f] 135 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f] 136 137 The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be 138 zero or negative in order to have a feasible solution (since the sum 139 of the expressions on the lefthand side of the inequalities is zero). 140 It means that the total demand must be greater or equal to the total 141 supply and all the supplies have to be carried out from the supply nodes, 142 but there could be demands that are not satisfied. 143 If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand 144 constraints have to be satisfied with equality, i.e. all demands 145 have to be satisfied and all supplies have to be used. 146 147 If you need the opposite inequalities in the supply/demand constraints 148 (i.e. the total demand is less than the total supply and all the demands 149 have to be satisfied while there could be supplies that are not used), 150 then you could easily transform the problem to the above form by reversing 151 the direction of the arcs and taking the negative of the supply values 152 (e.g. using \ref ReverseDigraph and \ref NegMap adaptors). 153 154 Note that this algorithm also provides a feasible solution for the 155 \ref min_cost_flow "minimum cost flow problem". 139 156 140 157 \tparam GR The type of the digraph the algorithm runs on. 141 \tparam LM The type of the lower bound capacitymap. The default158 \tparam LM The type of the lower bound map. The default 142 159 map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". 143 \tparam UM The type of the upper bound capacity map. The default 144 map type is \c LM. 145 \tparam DM The type of the map that stores the lower bound 146 for the supply of the nodes. The default map type is 160 \tparam UM The type of the upper bound (capacity) map. 161 The default map type is \c LM. 162 \tparam SM The type of the supply map. The default map type is 147 163 \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>". 148 164 */ … … 151 167 typename LM, 152 168 typename UM, 153 typename DM,169 typename SM, 154 170 typename TR > 155 171 #else … … 157 173 typename LM = typename GR::template ArcMap<int>, 158 174 typename UM = LM, 159 typename DM = typename GR::template NodeMap<typename UM::Value>,160 typename TR = CirculationDefaultTraits<GR, LM, UM, DM> >175 typename SM = typename GR::template NodeMap<typename UM::Value>, 176 typename TR = CirculationDefaultTraits<GR, LM, UM, SM> > 161 177 #endif 162 178 class Circulation { … … 168 184 typedef typename Traits::Digraph Digraph; 169 185 ///The type of the flow values. 170 typedef typename Traits::Value Value; 171 172 /// The type of the lower bound capacity map. 173 typedef typename Traits::LCapMap LCapMap; 174 /// The type of the upper bound capacity map. 175 typedef typename Traits::UCapMap UCapMap; 176 /// \brief The type of the map that stores the lower bound for 177 /// the supply of the nodes. 178 typedef typename Traits::DeltaMap DeltaMap; 186 typedef typename Traits::Flow Flow; 187 188 ///The type of the lower bound map. 189 typedef typename Traits::LowerMap LowerMap; 190 ///The type of the upper bound (capacity) map. 191 typedef typename Traits::UpperMap UpperMap; 192 ///The type of the supply map. 193 typedef typename Traits::SupplyMap SupplyMap; 179 194 ///The type of the flow map. 180 195 typedef typename Traits::FlowMap FlowMap; … … 192 207 int _node_num; 193 208 194 const L CapMap *_lo;195 const U CapMap *_up;196 const DeltaMap *_delta;209 const LowerMap *_lo; 210 const UpperMap *_up; 211 const SupplyMap *_supply; 197 212 198 213 FlowMap *_flow; … … 202 217 bool _local_level; 203 218 204 typedef typename Digraph::template NodeMap< Value> ExcessMap;219 typedef typename Digraph::template NodeMap<Flow> ExcessMap; 205 220 ExcessMap* _excess; 206 221 … … 232 247 template <typename T> 233 248 struct SetFlowMap 234 : public Circulation<Digraph, L CapMap, UCapMap, DeltaMap,249 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 235 250 SetFlowMapTraits<T> > { 236 typedef Circulation<Digraph, L CapMap, UCapMap, DeltaMap,251 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 237 252 SetFlowMapTraits<T> > Create; 238 253 }; … … 258 273 template <typename T> 259 274 struct SetElevator 260 : public Circulation<Digraph, L CapMap, UCapMap, DeltaMap,275 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 261 276 SetElevatorTraits<T> > { 262 typedef Circulation<Digraph, L CapMap, UCapMap, DeltaMap,277 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 263 278 SetElevatorTraits<T> > Create; 264 279 }; … … 286 301 template <typename T> 287 302 struct SetStandardElevator 288 : public Circulation<Digraph, L CapMap, UCapMap, DeltaMap,303 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 289 304 SetStandardElevatorTraits<T> > { 290 typedef Circulation<Digraph, L CapMap, UCapMap, DeltaMap,305 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 291 306 SetStandardElevatorTraits<T> > Create; 292 307 }; … … 300 315 public: 301 316 317 /// Constructor. 318 302 319 /// The constructor of the class. 303 304 /// The constructor of the class.305 /// \param g The digraph the algorithm runs on.306 /// \param lo The lower bound capacity of the arcs.307 /// \param up The upper bound capacity ofthe arcs.308 /// \param delta The lower bound for the supplyof the nodes.309 Circulation(const Digraph &g ,const LCapMap &lo,310 const U CapMap &up,const DeltaMap &delta)311 : _g(g ), _node_num(),312 _ lo(&lo),_up(&up),_delta(&delta),_flow(0),_local_flow(false),313 _ level(0), _local_level(false), _excess(0), _el() {}320 /// 321 /// \param graph The digraph the algorithm runs on. 322 /// \param lower The lower bounds for the flow values on the arcs. 323 /// \param upper The upper bounds (capacities) for the flow values 324 /// on the arcs. 325 /// \param supply The signed supply values of the nodes. 326 Circulation(const Digraph &graph, const LowerMap &lower, 327 const UpperMap &upper, const SupplyMap &supply) 328 : _g(graph), _lo(&lower), _up(&upper), _supply(&supply), 329 _flow(NULL), _local_flow(false), _level(NULL), _local_level(false), 330 _excess(NULL) {} 314 331 315 332 /// Destructor. … … 351 368 public: 352 369 353 /// Sets the lower bound capacitymap.354 355 /// Sets the lower bound capacitymap.370 /// Sets the lower bound map. 371 372 /// Sets the lower bound map. 356 373 /// \return <tt>(*this)</tt> 357 Circulation& lower CapMap(const LCapMap& map) {374 Circulation& lowerMap(const LowerMap& map) { 358 375 _lo = ↦ 359 376 return *this; 360 377 } 361 378 362 /// Sets the upper bound capacitymap.363 364 /// Sets the upper bound capacitymap.379 /// Sets the upper bound (capacity) map. 380 381 /// Sets the upper bound (capacity) map. 365 382 /// \return <tt>(*this)</tt> 366 Circulation& upper CapMap(const LCapMap& map) {383 Circulation& upperMap(const LowerMap& map) { 367 384 _up = ↦ 368 385 return *this; 369 386 } 370 387 371 /// Sets the lower bound map for the supply of the nodes.372 373 /// Sets the lower bound map for the supply of the nodes.388 /// Sets the supply map. 389 390 /// Sets the supply map. 374 391 /// \return <tt>(*this)</tt> 375 Circulation& deltaMap(const DeltaMap& map) {376 _ delta= ↦392 Circulation& supplyMap(const SupplyMap& map) { 393 _supply = ↦ 377 394 return *this; 378 395 } … … 454 471 455 472 for(NodeIt n(_g);n!=INVALID;++n) { 456 (*_excess)[n] = (*_ delta)[n];473 (*_excess)[n] = (*_supply)[n]; 457 474 } 458 475 … … 483 500 484 501 for(NodeIt n(_g);n!=INVALID;++n) { 485 (*_excess)[n] = (*_ delta)[n];502 (*_excess)[n] = (*_supply)[n]; 486 503 } 487 504 … … 496 513 (*_excess)[_g.source(e)] = (*_lo)[e]; 497 514 } else { 498 Valuefc = (*_excess)[_g.target(e)];515 Flow fc = (*_excess)[_g.target(e)]; 499 516 _flow>set(e, fc); 500 517 (*_excess)[_g.target(e)] = 0; … … 529 546 int actlevel=(*_level)[act]; 530 547 int mlevel=_node_num; 531 Valueexc=(*_excess)[act];548 Flow exc=(*_excess)[act]; 532 549 533 550 for(OutArcIt e(_g,act);e!=INVALID; ++e) { 534 551 Node v = _g.target(e); 535 Valuefc=(*_up)[e](*_flow)[e];552 Flow fc=(*_up)[e](*_flow)[e]; 536 553 if(!_tol.positive(fc)) continue; 537 554 if((*_level)[v]<actlevel) { … … 557 574 for(InArcIt e(_g,act);e!=INVALID; ++e) { 558 575 Node v = _g.source(e); 559 Valuefc=(*_flow)[e](*_lo)[e];576 Flow fc=(*_flow)[e](*_lo)[e]; 560 577 if(!_tol.positive(fc)) continue; 561 578 if((*_level)[v]<actlevel) { … … 633 650 /// \pre Either \ref run() or \ref init() must be called before 634 651 /// using this function. 635 Valueflow(const Arc& arc) const {652 Flow flow(const Arc& arc) const { 636 653 return (*_flow)[arc]; 637 654 } … … 652 669 Barrier is a set \e B of nodes for which 653 670 654 \f[ \sum_{ a\in\delta_{out}(B)} upper(a) 655 \sum_{ a\in\delta_{in}(B)} lower(a) < \sum_{v\in B}delta(v) \f]671 \f[ \sum_{uv\in A: u\in B} upper(uv)  672 \sum_{uv\in A: v\in B} lower(uv) < \sum_{v\in B} sup(v) \f] 656 673 657 674 holds. The existence of a set with this property prooves that a … … 716 733 for(NodeIt n(_g);n!=INVALID;++n) 717 734 { 718 Value dif=(*_delta)[n];735 Flow dif=(*_supply)[n]; 719 736 for(InArcIt e(_g,n);e!=INVALID;++e) dif=(*_flow)[e]; 720 737 for(OutArcIt e(_g,n);e!=INVALID;++e) dif+=(*_flow)[e]; … … 731 748 bool checkBarrier() const 732 749 { 733 Valuedelta=0;750 Flow delta=0; 734 751 for(NodeIt n(_g);n!=INVALID;++n) 735 752 if(barrier(n)) 736 delta=(*_ delta)[n];753 delta=(*_supply)[n]; 737 754 for(ArcIt e(_g);e!=INVALID;++e) 738 755 { 
lemon/circulation.h
r610 r611 231 231 ///@{ 232 232 233 template <typename _FlowMap>233 template <typename T> 234 234 struct SetFlowMapTraits : public Traits { 235 typedef _FlowMapFlowMap;235 typedef T FlowMap; 236 236 static FlowMap *createFlowMap(const Digraph&) { 237 237 LEMON_ASSERT(false, "FlowMap is not initialized"); … … 245 245 /// \ref namedtemplparam "Named parameter" for setting FlowMap 246 246 /// type. 247 template <typename _FlowMap>247 template <typename T> 248 248 struct SetFlowMap 249 249 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 250 SetFlowMapTraits< _FlowMap> > {250 SetFlowMapTraits<T> > { 251 251 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 252 SetFlowMapTraits< _FlowMap> > Create;252 SetFlowMapTraits<T> > Create; 253 253 }; 254 254 255 template <typename _Elevator>255 template <typename T> 256 256 struct SetElevatorTraits : public Traits { 257 typedef _ElevatorElevator;257 typedef T Elevator; 258 258 static Elevator *createElevator(const Digraph&, int) { 259 259 LEMON_ASSERT(false, "Elevator is not initialized"); … … 271 271 /// \ref run() or \ref init(). 272 272 /// \sa SetStandardElevator 273 template <typename _Elevator>273 template <typename T> 274 274 struct SetElevator 275 275 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 276 SetElevatorTraits< _Elevator> > {276 SetElevatorTraits<T> > { 277 277 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 278 SetElevatorTraits< _Elevator> > Create;278 SetElevatorTraits<T> > Create; 279 279 }; 280 280 281 template <typename _Elevator>281 template <typename T> 282 282 struct SetStandardElevatorTraits : public Traits { 283 typedef _ElevatorElevator;283 typedef T Elevator; 284 284 static Elevator *createElevator(const Digraph& digraph, int max_level) { 285 285 return new Elevator(digraph, max_level); … … 299 299 /// before calling \ref run() or \ref init(). 300 300 /// \sa SetElevator 301 template <typename _Elevator>301 template <typename T> 302 302 struct SetStandardElevator 303 303 : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 304 SetStandardElevatorTraits< _Elevator> > {304 SetStandardElevatorTraits<T> > { 305 305 typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap, 306 SetStandardElevatorTraits< _Elevator> > Create;306 SetStandardElevatorTraits<T> > Create; 307 307 }; 308 308 … … 471 471 472 472 for(NodeIt n(_g);n!=INVALID;++n) { 473 _excess>set(n, (*_supply)[n]);473 (*_excess)[n] = (*_supply)[n]; 474 474 } 475 475 476 476 for (ArcIt e(_g);e!=INVALID;++e) { 477 477 _flow>set(e, (*_lo)[e]); 478 _excess>set(_g.target(e), (*_excess)[_g.target(e)] + (*_flow)[e]);479 _excess>set(_g.source(e), (*_excess)[_g.source(e)]  (*_flow)[e]);478 (*_excess)[_g.target(e)] += (*_flow)[e]; 479 (*_excess)[_g.source(e)] = (*_flow)[e]; 480 480 } 481 481 … … 500 500 501 501 for(NodeIt n(_g);n!=INVALID;++n) { 502 _excess>set(n, (*_supply)[n]);502 (*_excess)[n] = (*_supply)[n]; 503 503 } 504 504 … … 506 506 if (!_tol.positive((*_excess)[_g.target(e)] + (*_up)[e])) { 507 507 _flow>set(e, (*_up)[e]); 508 _excess>set(_g.target(e), (*_excess)[_g.target(e)] + (*_up)[e]);509 _excess>set(_g.source(e), (*_excess)[_g.source(e)]  (*_up)[e]);508 (*_excess)[_g.target(e)] += (*_up)[e]; 509 (*_excess)[_g.source(e)] = (*_up)[e]; 510 510 } else if (_tol.positive((*_excess)[_g.target(e)] + (*_lo)[e])) { 511 511 _flow>set(e, (*_lo)[e]); 512 _excess>set(_g.target(e), (*_excess)[_g.target(e)] + (*_lo)[e]);513 _excess>set(_g.source(e), (*_excess)[_g.source(e)]  (*_lo)[e]);512 (*_excess)[_g.target(e)] += (*_lo)[e]; 513 (*_excess)[_g.source(e)] = (*_lo)[e]; 514 514 } else { 515 515 Flow fc = (*_excess)[_g.target(e)]; 516 516 _flow>set(e, fc); 517 _excess>set(_g.target(e), 0);518 _excess>set(_g.source(e), (*_excess)[_g.source(e)]  fc);517 (*_excess)[_g.target(e)] = 0; 518 (*_excess)[_g.source(e)] = fc; 519 519 } 520 520 } … … 555 555 if(!_tol.less(fc, exc)) { 556 556 _flow>set(e, (*_flow)[e] + exc); 557 _excess>set(v, (*_excess)[v] + exc);557 (*_excess)[v] += exc; 558 558 if(!_level>active(v) && _tol.positive((*_excess)[v])) 559 559 _level>activate(v); 560 _excess>set(act,0);560 (*_excess)[act] = 0; 561 561 _level>deactivate(act); 562 562 goto next_l; … … 564 564 else { 565 565 _flow>set(e, (*_up)[e]); 566 _excess>set(v, (*_excess)[v] + fc);566 (*_excess)[v] += fc; 567 567 if(!_level>active(v) && _tol.positive((*_excess)[v])) 568 568 _level>activate(v); … … 579 579 if(!_tol.less(fc, exc)) { 580 580 _flow>set(e, (*_flow)[e]  exc); 581 _excess>set(v, (*_excess)[v] + exc);581 (*_excess)[v] += exc; 582 582 if(!_level>active(v) && _tol.positive((*_excess)[v])) 583 583 _level>activate(v); 584 _excess>set(act,0);584 (*_excess)[act] = 0; 585 585 _level>deactivate(act); 586 586 goto next_l; … … 588 588 else { 589 589 _flow>set(e, (*_lo)[e]); 590 _excess>set(v, (*_excess)[v] + fc);590 (*_excess)[v] += fc; 591 591 if(!_level>active(v) && _tol.positive((*_excess)[v])) 592 592 _level>activate(v); … … 597 597 } 598 598 599 _excess>set(act, exc);599 (*_excess)[act] = exc; 600 600 if(!_tol.positive(exc)) _level>deactivate(act); 601 601 else if(mlevel==_node_num) { … … 700 700 /// 701 701 /// \note This function calls \ref barrier() for each node, 702 /// so it runs in \f$O(n)\f$time.702 /// so it runs in O(n) time. 703 703 /// 704 704 /// \pre Either \ref run() or \ref init() must be called before
Note: See TracChangeset
for help on using the changeset viewer.