Changes in / [922:9312d6c89d02:921:140c953ad5d1] in lemon-main
- Files:
-
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/coding_style.dox
r919 r440 99 99 \subsection pri-loc-var Private member variables 100 100 101 Private member variables should start with underscore .101 Private member variables should start with underscore 102 102 103 103 \code 104 _start_with_underscore 104 _start_with_underscores 105 105 \endcode 106 106 -
doc/groups.dox
r919 r904 407 407 strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling. 408 408 409 In general , \ref NetworkSimplex and \ref CostScaling are the most efficient410 implementations, but the other two algorithms could be faster in special cases.409 In general NetworkSimplex is the most efficient implementation, 410 but in special cases other algorithms could be faster. 411 411 For example, if the total supply and/or capacities are rather small, 412 \refCapacityScaling is usually the fastest algorithm (without effective scaling).412 CapacityScaling is usually the fastest algorithm (without effective scaling). 413 413 */ 414 414 … … 472 472 \ref dasdan98minmeancycle. 473 473 474 In practice, the \ref HowardMmc "Howard" algorithm turned outto be by far the474 In practice, the \ref HowardMmc "Howard" algorithm proved to be by far the 475 475 most efficient one, though the best known theoretical bound on its running 476 476 time is exponential. … … 540 540 541 541 /** 542 @defgroup planar Planar Embedding and Drawing542 @defgroup planar Planarity Embedding and Drawing 543 543 @ingroup algs 544 544 \brief Algorithms for planarity checking, embedding and drawing -
lemon/capacity_scaling.h
r922 r921 90 90 /// \warning All input data (capacities, supply values, and costs) must 91 91 /// be integer. 92 /// \warning This algorithm does not support negative costs for 93 /// arcs havinginfinite upper bound.92 /// \warning This algorithm does not support negative costs for such 93 /// arcs that have infinite upper bound. 94 94 #ifdef DOXYGEN 95 95 template <typename GR, typename V, typename C, typename TR> … … 424 424 /// 425 425 /// Using this function has the same effect as using \ref supplyMap() 426 /// with a map in which \c k is assigned to \c s, \c -k is426 /// with such a map in which \c k is assigned to \c s, \c -k is 427 427 /// assigned to \c t and all other nodes have zero supply value. 428 428 /// -
lemon/core.h
r919 r893 448 448 } 449 449 450 /// \briefCheck whether a graph is undirected.450 /// Check whether a graph is undirected. 451 451 /// 452 452 /// This function returns \c true if the given graph is undirected. -
lemon/cost_scaling.h
r922 r921 98 98 /// "preflow push-relabel" algorithm for the maximum flow problem. 99 99 /// 100 /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest101 /// implementations available in LEMON for this problem.102 ///103 100 /// Most of the parameters of the problem (except for the digraph) 104 101 /// can be given using separate functions, and the algorithm can be … … 120 117 /// \warning All input data (capacities, supply values, and costs) must 121 118 /// be integer. 122 /// \warning This algorithm does not support negative costs for 123 /// arcs havinginfinite upper bound.119 /// \warning This algorithm does not support negative costs for such 120 /// arcs that have infinite upper bound. 124 121 /// 125 122 /// \note %CostScaling provides three different internal methods, … … 183 180 /// relabel operation. 184 181 /// By default, the so called \ref PARTIAL_AUGMENT 185 /// "Partial Augment-Relabel" method is used, which turned outto be182 /// "Partial Augment-Relabel" method is used, which proved to be 186 183 /// the most efficient and the most robust on various test inputs. 187 184 /// However, the other methods can be selected using the \ref run() … … 452 449 /// 453 450 /// Using this function has the same effect as using \ref supplyMap() 454 /// with a map in which \c k is assigned to \c s, \c -k is451 /// with such a map in which \c k is assigned to \c s, \c -k is 455 452 /// assigned to \c t and all other nodes have zero supply value. 456 453 /// -
lemon/cycle_canceling.h
r922 r921 69 69 /// \warning All input data (capacities, supply values, and costs) must 70 70 /// be integer. 71 /// \warning This algorithm does not support negative costs for 72 /// arcs havinginfinite upper bound.71 /// \warning This algorithm does not support negative costs for such 72 /// arcs that have infinite upper bound. 73 73 /// 74 74 /// \note For more information about the three available methods, … … 118 118 /// \ref CycleCanceling provides three different cycle-canceling 119 119 /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten" 120 /// is used, which is by far the most efficient and the most robust. 120 /// is used, which proved to be the most efficient and the most robust 121 /// on various test inputs. 121 122 /// However, the other methods can be selected using the \ref run() 122 123 /// function with the proper parameter. … … 350 351 /// 351 352 /// Using this function has the same effect as using \ref supplyMap() 352 /// with a map in which \c k is assigned to \c s, \c -k is353 /// with such a map in which \c k is assigned to \c s, \c -k is 353 354 /// assigned to \c t and all other nodes have zero supply value. 354 355 /// -
lemon/euler.h
r919 r877 37 37 ///Euler tour iterator for digraphs. 38 38 39 /// \ingroup graph_prop erties39 /// \ingroup graph_prop 40 40 ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed 41 41 ///graph (if there exists) and it converts to the \c Arc type of the digraph. -
lemon/grosso_locatelli_pullan_mc.h
r918 r904 47 47 /// 48 48 /// This class provides a simple but highly efficient and robust heuristic 49 /// method that quickly finds a quitelarge clique, but not necessarily the49 /// method that quickly finds a large clique, but not necessarily the 50 50 /// largest one. 51 /// The algorithm performs a certain number of iterations to find several52 /// cliques and selects the largest one among them. Various limits can be53 /// specified to control the running time and the effectiveness of the54 /// search process.55 51 /// 56 52 /// \tparam GR The undirected graph type the algorithm runs on. … … 89 85 }; 90 86 91 /// \brief Constants for the causes of search termination.92 ///93 /// Enum type containing constants for the different causes of search94 /// termination. The \ref run() function returns one of these values.95 enum TerminationCause {96 97 /// The iteration count limit is reached.98 ITERATION_LIMIT,99 100 /// The step count limit is reached.101 STEP_LIMIT,102 103 /// The clique size limit is reached.104 SIZE_LIMIT105 };106 107 87 private: 108 88 … … 114 94 // Note: vector<char> is used instead of vector<bool> for efficiency reasons 115 95 116 // The underlying graph117 96 const GR &_graph; 118 97 IntNodeMap _id; … … 121 100 BoolMatrix _gr; 122 101 int _n; 123 124 // Search options125 bool _delta_based_restart;126 int _restart_delta_limit;127 128 // Search limits129 int _iteration_limit;130 int _step_limit;131 int _size_limit;132 102 133 103 // The current clique … … 411 381 GrossoLocatelliPullanMc(const GR& graph) : 412 382 _graph(graph), _id(_graph), _rnd(rnd) 413 { 414 initOptions(); 415 } 383 {} 416 384 417 385 /// \brief Constructor with random seed. … … 424 392 GrossoLocatelliPullanMc(const GR& graph, int seed) : 425 393 _graph(graph), _id(_graph), _rnd(seed) 426 { 427 initOptions(); 428 } 394 {} 429 395 430 396 /// \brief Constructor with random number generator. … … 437 403 GrossoLocatelliPullanMc(const GR& graph, const Random& random) : 438 404 _graph(graph), _id(_graph), _rnd(random) 439 { 440 initOptions(); 441 } 405 {} 442 406 443 407 /// \name Execution Control 444 /// The \ref run() function can be used to execute the algorithm.\n445 /// The functions \ref iterationLimit(int), \ref stepLimit(int), and446 /// \ref sizeLimit(int) can be used to specify various limits for the447 /// search process.448 449 408 /// @{ 450 451 /// \brief Sets the maximum number of iterations. 452 /// 453 /// This function sets the maximum number of iterations. 454 /// Each iteration of the algorithm finds a maximal clique (but not 455 /// necessarily the largest one) by performing several search steps 456 /// (node selections). 457 /// 458 /// This limit controls the running time and the success of the 459 /// algorithm. For larger values, the algorithm runs slower, but it more 409 410 /// \brief Runs the algorithm. 411 /// 412 /// This function runs the algorithm. 413 /// 414 /// \param step_num The maximum number of node selections (steps) 415 /// during the search process. 416 /// This parameter controls the running time and the success of the 417 /// algorithm. For larger values, the algorithm runs slower but it more 460 418 /// likely finds larger cliques. For smaller values, the algorithm is 461 419 /// faster but probably gives worse results. 462 ///463 /// The default value is \c 1000.464 /// \c -1 means that number of iterations is not limited.465 ///466 /// \warning You should specify a reasonable limit for the number of467 /// iterations and/or the number of search steps.468 ///469 /// \return <tt>(*this)</tt>470 ///471 /// \sa stepLimit(int)472 /// \sa sizeLimit(int)473 GrossoLocatelliPullanMc& iterationLimit(int limit) {474 _iteration_limit = limit;475 return *this;476 }477 478 /// \brief Sets the maximum number of search steps.479 ///480 /// This function sets the maximum number of elementary search steps.481 /// Each iteration of the algorithm finds a maximal clique (but not482 /// necessarily the largest one) by performing several search steps483 /// (node selections).484 ///485 /// This limit controls the running time and the success of the486 /// algorithm. For larger values, the algorithm runs slower, but it more487 /// likely finds larger cliques. For smaller values, the algorithm is488 /// faster but probably gives worse results.489 ///490 /// The default value is \c -1, which means that number of steps491 /// is not limited explicitly. However, the number of iterations is492 /// limited and each iteration performs a finite number of search steps.493 ///494 /// \warning You should specify a reasonable limit for the number of495 /// iterations and/or the number of search steps.496 ///497 /// \return <tt>(*this)</tt>498 ///499 /// \sa iterationLimit(int)500 /// \sa sizeLimit(int)501 GrossoLocatelliPullanMc& stepLimit(int limit) {502 _step_limit = limit;503 return *this;504 }505 506 /// \brief Sets the desired clique size.507 ///508 /// This function sets the desired clique size that serves as a search509 /// limit. If a clique of this size (or a larger one) is found, then the510 /// algorithm terminates.511 ///512 /// This function is especially useful if you know an exact upper bound513 /// for the size of the cliques in the graph or if any clique above514 /// a certain size limit is sufficient for your application.515 ///516 /// The default value is \c -1, which means that the size limit is set to517 /// the number of nodes in the graph.518 ///519 /// \return <tt>(*this)</tt>520 ///521 /// \sa iterationLimit(int)522 /// \sa stepLimit(int)523 GrossoLocatelliPullanMc& sizeLimit(int limit) {524 _size_limit = limit;525 return *this;526 }527 528 /// \brief The maximum number of iterations.529 ///530 /// This function gives back the maximum number of iterations.531 /// \c -1 means that no limit is specified.532 ///533 /// \sa iterationLimit(int)534 int iterationLimit() const {535 return _iteration_limit;536 }537 538 /// \brief The maximum number of search steps.539 ///540 /// This function gives back the maximum number of search steps.541 /// \c -1 means that no limit is specified.542 ///543 /// \sa stepLimit(int)544 int stepLimit() const {545 return _step_limit;546 }547 548 /// \brief The desired clique size.549 ///550 /// This function gives back the desired clique size that serves as a551 /// search limit. \c -1 means that this limit is set to the number of552 /// nodes in the graph.553 ///554 /// \sa sizeLimit(int)555 int sizeLimit() const {556 return _size_limit;557 }558 559 /// \brief Runs the algorithm.560 ///561 /// This function runs the algorithm. If one of the specified limits562 /// is reached, the search process terminates.563 ///564 420 /// \param rule The node selection rule. For more information, see 565 421 /// \ref SelectionRule. 566 422 /// 567 /// \return The termination cause of the search. For more information,568 /// see \ref TerminationCause.569 TerminationCause run(SelectionRule rule = PENALTY_BASED)423 /// \return The size of the found clique. 424 int run(int step_num = 100000, 425 SelectionRule rule = PENALTY_BASED) 570 426 { 571 427 init(); 572 428 switch (rule) { 573 429 case RANDOM: 574 return start<RandomSelectionRule>( );430 return start<RandomSelectionRule>(step_num); 575 431 case DEGREE_BASED: 576 return start<DegreeBasedSelectionRule>(); 577 default: 578 return start<PenaltyBasedSelectionRule>(); 579 } 432 return start<DegreeBasedSelectionRule>(step_num); 433 case PENALTY_BASED: 434 return start<PenaltyBasedSelectionRule>(step_num); 435 } 436 return 0; // avoid warning 580 437 } 581 438 … … 583 440 584 441 /// \name Query Functions 585 /// The results of the algorithm can be obtained using these functions.\n586 /// The run() function must be called before using them.587 588 442 /// @{ 589 443 … … 677 531 678 532 private: 679 680 // Initialize search options and limits681 void initOptions() {682 // Search options683 _delta_based_restart = true;684 _restart_delta_limit = 4;685 686 // Search limits687 _iteration_limit = 1000;688 _step_limit = -1; // this is disabled by default689 _size_limit = -1; // this is disabled by default690 }691 533 692 534 // Adds a node to the current clique … … 745 587 // Executes the algorithm 746 588 template <typename SelectionRuleImpl> 747 TerminationCause start() { 748 if (_n == 0) return SIZE_LIMIT; 589 int start(int max_select) { 590 // Options for the restart rule 591 const bool delta_based_restart = true; 592 const int restart_delta_limit = 4; 593 594 if (_n == 0) return 0; 749 595 if (_n == 1) { 750 596 _best_clique[0] = true; 751 597 _best_size = 1; 752 return SIZE_LIMIT; 753 } 754 755 // Iterated local search algorithm 756 const int max_size = _size_limit >= 0 ? _size_limit : _n; 757 const int max_restart = _iteration_limit >= 0 ? 758 _iteration_limit : std::numeric_limits<int>::max(); 759 const int max_select = _step_limit >= 0 ? 760 _step_limit : std::numeric_limits<int>::max(); 761 598 return _best_size; 599 } 600 601 // Iterated local search 762 602 SelectionRuleImpl sel_method(*this); 763 int select = 0 , restart = 0;603 int select = 0; 764 604 IntVector restart_nodes; 765 while (select < max_select && restart < max_restart) { 605 606 while (select < max_select) { 766 607 767 608 // Perturbation/restart 768 restart++; 769 if (_delta_based_restart) { 609 if (delta_based_restart) { 770 610 restart_nodes.clear(); 771 611 for (int i = 0; i != _n; i++) { 772 if (_delta[i] >= _restart_delta_limit)612 if (_delta[i] >= restart_delta_limit) 773 613 restart_nodes.push_back(i); 774 614 } … … 824 664 _best_clique = _clique; 825 665 _best_size = _size; 826 if (_best_size >= max_size) return SIZE_LIMIT;666 if (_best_size == _n) return _best_size; 827 667 } 828 668 sel_method.update(); 829 669 } 830 670 831 return (restart >= max_restart ? ITERATION_LIMIT : STEP_LIMIT);671 return _best_size; 832 672 } 833 673 -
lemon/network_simplex.h
r922 r921 48 48 /// flow problem. 49 49 /// 50 /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest51 /// i mplementations available in LEMON for this problem.52 /// Furthermore, this class supports both directions of the supply/demand53 /// inequalityconstraints. For more information, see \ref SupplyType.50 /// In general, %NetworkSimplex is the fastest implementation available 51 /// in LEMON for this problem. 52 /// Moreover, it supports both directions of the supply/demand inequality 53 /// constraints. For more information, see \ref SupplyType. 54 54 /// 55 55 /// Most of the parameters of the problem (except for the digraph) … … 127 127 /// of the algorithm. 128 128 /// By default, \ref BLOCK_SEARCH "Block Search" is used, which 129 /// turend outto be the most efficient and the most robust on various129 /// proved to be the most efficient and the most robust on various 130 130 /// test inputs. 131 131 /// However, another pivot rule can be selected using the \ref run() … … 169 169 typedef std::vector<Cost> CostVector; 170 170 typedef std::vector<signed char> CharVector; 171 // Note: vector<signed char> is used instead of vector<ArcState> and 171 // Note: vector<signed char> is used instead of vector<ArcState> and 172 172 // vector<ArcDirection> for efficiency reasons 173 173 … … 736 736 /// 737 737 /// \return <tt>(*this)</tt> 738 ///739 /// \sa supplyType()740 738 template<typename SupplyMap> 741 739 NetworkSimplex& supplyMap(const SupplyMap& map) { … … 754 752 /// 755 753 /// Using this function has the same effect as using \ref supplyMap() 756 /// with a map in which \c k is assigned to \c s, \c -k is754 /// with such a map in which \c k is assigned to \c s, \c -k is 757 755 /// assigned to \c t and all other nodes have zero supply value. 758 756 /// -
lemon/path.h
r920 r877 44 44 /// 45 45 /// In a sense, the path can be treated as a list of arcs. The 46 /// LEMONpath type stores just this list. As a consequence, it46 /// lemon path type stores just this list. As a consequence, it 47 47 /// cannot enumerate the nodes of the path and the source node of 48 48 /// a zero length path is undefined. … … 136 136 void clear() { head.clear(); tail.clear(); } 137 137 138 /// \brief The n -th arc.138 /// \brief The nth arc. 139 139 /// 140 140 /// \pre \c n is in the <tt>[0..length() - 1]</tt> range. … … 144 144 } 145 145 146 /// \brief Initialize arc iterator to point to the n -th arc146 /// \brief Initialize arc iterator to point to the nth arc 147 147 /// 148 148 /// \pre \c n is in the <tt>[0..length() - 1]</tt> range. … … 232 232 /// 233 233 /// In a sense, the path can be treated as a list of arcs. The 234 /// LEMONpath type stores just this list. As a consequence it234 /// lemon path type stores just this list. As a consequence it 235 235 /// cannot enumerate the nodes in the path and the zero length paths 236 236 /// cannot store the source. … … 328 328 void clear() { data.clear(); } 329 329 330 /// \brief The n -th arc.330 /// \brief The nth arc. 331 331 /// 332 332 /// \pre \c n is in the <tt>[0..length() - 1]</tt> range. … … 335 335 } 336 336 337 /// \brief Initializes arc iterator to point to the n -th arc.337 /// \brief Initializes arc iterator to point to the nth arc. 338 338 ArcIt nthIt(int n) const { 339 339 return ArcIt(*this, n); … … 396 396 /// 397 397 /// In a sense, the path can be treated as a list of arcs. The 398 /// LEMONpath type stores just this list. As a consequence it398 /// lemon path type stores just this list. As a consequence it 399 399 /// cannot enumerate the nodes in the path and the zero length paths 400 400 /// cannot store the source. … … 505 505 }; 506 506 507 /// \brief The n -th arc.508 /// 509 /// This function looks for the n -th arc in O(n) time.507 /// \brief The nth arc. 508 /// 509 /// This function looks for the nth arc in O(n) time. 510 510 /// \pre \c n is in the <tt>[0..length() - 1]</tt> range. 511 511 const Arc& nth(int n) const { … … 517 517 } 518 518 519 /// \brief Initializes arc iterator to point to the n -th arc.519 /// \brief Initializes arc iterator to point to the nth arc. 520 520 ArcIt nthIt(int n) const { 521 521 Node *node = first; … … 736 736 /// 737 737 /// In a sense, the path can be treated as a list of arcs. The 738 /// LEMONpath type stores just this list. As a consequence it738 /// lemon path type stores just this list. As a consequence it 739 739 /// cannot enumerate the nodes in the path and the source node of 740 740 /// a zero length path is undefined. … … 832 832 }; 833 833 834 /// \brief The n -th arc.834 /// \brief The nth arc. 835 835 /// 836 836 /// \pre \c n is in the <tt>[0..length() - 1]</tt> range. … … 839 839 } 840 840 841 /// \brief The arc iterator pointing to the n -th arc.841 /// \brief The arc iterator pointing to the nth arc. 842 842 ArcIt nthIt(int n) const { 843 843 return ArcIt(*this, n); … … 1043 1043 /// 1044 1044 /// In a sense, the path can be treated as a list of arcs. The 1045 /// LEMONpath type stores only this list. As a consequence, it1045 /// lemon path type stores only this list. As a consequence, it 1046 1046 /// cannot enumerate the nodes in the path and the zero length paths 1047 1047 /// cannot have a source node. -
test/max_clique_test.cc
r918 r904 59 59 // Check with general graphs 60 60 template <typename Param> 61 void checkMaxCliqueGeneral( Param rule) {61 void checkMaxCliqueGeneral(int max_sel, Param rule) { 62 62 typedef ListGraph GR; 63 63 typedef GrossoLocatelliPullanMc<GR> McAlg; … … 69 69 GR::NodeMap<bool> map(g); 70 70 McAlg mc(g); 71 mc.iterationLimit(50); 72 check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause"); 71 check(mc.run(max_sel, rule) == 0, "Wrong clique size"); 73 72 check(mc.cliqueSize() == 0, "Wrong clique size"); 74 73 check(CliqueIt(mc) == INVALID, "Wrong CliqueNodeIt"); 75 74 76 75 GR::Node u = g.addNode(); 77 check(mc.run( rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");76 check(mc.run(max_sel, rule) == 1, "Wrong clique size"); 78 77 check(mc.cliqueSize() == 1, "Wrong clique size"); 79 78 mc.cliqueMap(map); … … 84 83 85 84 GR::Node v = g.addNode(); 86 check(mc.run( rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");85 check(mc.run(max_sel, rule) == 1, "Wrong clique size"); 87 86 check(mc.cliqueSize() == 1, "Wrong clique size"); 88 87 mc.cliqueMap(map); … … 92 91 93 92 g.addEdge(u, v); 94 check(mc.run( rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");93 check(mc.run(max_sel, rule) == 2, "Wrong clique size"); 95 94 check(mc.cliqueSize() == 2, "Wrong clique size"); 96 95 mc.cliqueMap(map); … … 112 111 113 112 McAlg mc(g); 114 mc.iterationLimit(50); 115 check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause"); 113 check(mc.run(max_sel, rule) == 4, "Wrong clique size"); 116 114 check(mc.cliqueSize() == 4, "Wrong clique size"); 117 115 mc.cliqueMap(map); … … 130 128 // Check with full graphs 131 129 template <typename Param> 132 void checkMaxCliqueFullGraph( Param rule) {130 void checkMaxCliqueFullGraph(int max_sel, Param rule) { 133 131 typedef FullGraph GR; 134 132 typedef GrossoLocatelliPullanMc<FullGraph> McAlg; … … 139 137 GR::NodeMap<bool> map(g); 140 138 McAlg mc(g); 141 check(mc.run( rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");139 check(mc.run(max_sel, rule) == size, "Wrong clique size"); 142 140 check(mc.cliqueSize() == size, "Wrong clique size"); 143 141 mc.cliqueMap(map); … … 153 151 // Check with grid graphs 154 152 template <typename Param> 155 void checkMaxCliqueGridGraph( Param rule) {153 void checkMaxCliqueGridGraph(int max_sel, Param rule) { 156 154 GridGraph g(5, 7); 157 155 GridGraph::NodeMap<char> map(g); 158 156 GrossoLocatelliPullanMc<GridGraph> mc(g); 159 160 mc.iterationLimit(100); 161 check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause"); 162 check(mc.cliqueSize() == 2, "Wrong clique size"); 163 164 mc.stepLimit(100); 165 check(mc.run(rule) == mc.STEP_LIMIT, "Wrong termination cause"); 166 check(mc.cliqueSize() == 2, "Wrong clique size"); 167 168 mc.sizeLimit(2); 169 check(mc.run(rule) == mc.SIZE_LIMIT, "Wrong termination cause"); 157 check(mc.run(max_sel, rule) == 2, "Wrong clique size"); 170 158 check(mc.cliqueSize() == 2, "Wrong clique size"); 171 159 } … … 173 161 174 162 int main() { 175 checkMaxCliqueGeneral( GrossoLocatelliPullanMc<ListGraph>::RANDOM);176 checkMaxCliqueGeneral( GrossoLocatelliPullanMc<ListGraph>::DEGREE_BASED);177 checkMaxCliqueGeneral( GrossoLocatelliPullanMc<ListGraph>::PENALTY_BASED);163 checkMaxCliqueGeneral(50, GrossoLocatelliPullanMc<ListGraph>::RANDOM); 164 checkMaxCliqueGeneral(50, GrossoLocatelliPullanMc<ListGraph>::DEGREE_BASED); 165 checkMaxCliqueGeneral(50, GrossoLocatelliPullanMc<ListGraph>::PENALTY_BASED); 178 166 179 checkMaxCliqueFullGraph( GrossoLocatelliPullanMc<FullGraph>::RANDOM);180 checkMaxCliqueFullGraph( GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED);181 checkMaxCliqueFullGraph( GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED);167 checkMaxCliqueFullGraph(50, GrossoLocatelliPullanMc<FullGraph>::RANDOM); 168 checkMaxCliqueFullGraph(50, GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED); 169 checkMaxCliqueFullGraph(50, GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED); 182 170 183 checkMaxCliqueGridGraph( GrossoLocatelliPullanMc<GridGraph>::RANDOM);184 checkMaxCliqueGridGraph( GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED);185 checkMaxCliqueGridGraph( GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED);171 checkMaxCliqueGridGraph(50, GrossoLocatelliPullanMc<GridGraph>::RANDOM); 172 checkMaxCliqueGridGraph(50, GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED); 173 checkMaxCliqueGridGraph(50, GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED); 186 174 187 175 return 0;
Note: See TracChangeset
for help on using the changeset viewer.