Alps 1.5.7
AlpsSolutionPool.h
Go to the documentation of this file.
1/*===========================================================================*
2 * This file is part of the Abstract Library for Parallel Search (ALPS). *
3 * *
4 * ALPS is distributed under the Eclipse Public License as part of the *
5 * COIN-OR repository (http://www.coin-or.org). *
6 * *
7 * Authors: *
8 * *
9 * Yan Xu, Lehigh University *
10 * Ted Ralphs, Lehigh University *
11 * *
12 * Conceptual Design: *
13 * *
14 * Yan Xu, Lehigh University *
15 * Ted Ralphs, Lehigh University *
16 * Laszlo Ladanyi, IBM T.J. Watson Research Center *
17 * Matthew Saltzman, Clemson University *
18 * *
19 * *
20 * Copyright (C) 2001-2019, Lehigh University, Yan Xu, and Ted Ralphs. *
21 *===========================================================================*/
22
23#ifndef AlpsSolutionPool_h_
24#define AlpsSolutionPool_h_
25
26#include "AlpsKnowledgePool.h"
27#include "AlpsSolution.h"
28
29//#############################################################################
30
34 // *FIXME* ? : we do want to allow solutions with the same priority, but do
35 // *FIXME* ? : we want to allow identical solutions?
36 private:
38 AlpsSolutionPool& operator=(const AlpsSolutionPool&);
39
40 private:
41// std::multimap< double, CoinSharedPtr<AlpsSolution> > solutions_;
42 std::multimap< double, AlpsSolution* > solutions_;
43 int maxNumSolutions_;
44
45// inline void addSolution(CoinSharedPtr<AlpsSolution> sol,
46// double priority) {
47// solutions_.insert(std::make_pair(priority, sol));
48// if (maxNumSolutions_ > 0 && solutions_.size() > maxNumSolutions_) {
49// std::multimap< double, CoinSharedPtr<AlpsSolution> >::
50// iterator si = solutions_.end();
51// --si;
52// solutions_.erase(si);
53// }
54// }
55
56 public:
57 AlpsSolutionPool(int maxsols = 1) : maxNumSolutions_(maxsols) {}
59 if (! solutions_.empty()) {
60 clean();
61 }
62 }
63
65 // int getNumSolutions() const { return solutions_.size(); }
66 inline int getNumKnowledges() const {
67 return static_cast<int> (solutions_.size());
68 }
69
71 inline bool hasKnowledge() const
72 { return solutions_.empty() ? false : true; }
73
76// inline std::pair<AlpsKnowledge*, double> getKnowledge() const {
77// return std::make_pair(solutions_.begin()->second.get(),
78// solutions_.begin()->first);
79// }
80 inline std::pair<AlpsKnowledge*, double> getKnowledge() const {
81 return std::make_pair(static_cast<AlpsKnowledge *>
82 (solutions_.begin()->second),
83 solutions_.begin()->first);
84 }
85
87 inline void popKnowledge() {
88 throw CoinError("Can not call popKnowledge()",
89 "popKnowledge()", "AlpsSolutionPool");
90 }
91
94 // void addSolution(const AlpsSolution* sol, double priority) {
95 // CoinSharedPtr<const AlpsSolution> ssol(sol);
96 // addSolution(ssol, priority);
97 // }
98
99// inline void addKnowledge(AlpsKnowledge* sol, double priority=0) {
100// CoinSharedPtr<AlpsSolution>
101// ssol( dynamic_cast<AlpsSolution*>(sol) );
102// addSolution(ssol, priority);
103// }
104 inline void addKnowledge(AlpsKnowledge* sol, double priority) {
105 std::pair<const double, AlpsSolution*> ps(priority, dynamic_cast<AlpsSolution*>(sol));
106 solutions_.insert(ps);
107 //solutions_.insert(std::make_pair(priority,
108// (AlpsSolution*)sol));
109 if ((maxNumSolutions_ > 0) &&
110 (static_cast<int>(solutions_.size()) > maxNumSolutions_)) {
111 std::multimap< double, AlpsSolution* >::iterator si =
112 solutions_.end();
113 --si;
114 AlpsSolution* sol = si->second;
115 solutions_.erase(si);
116 delete sol;
117 }
118 }
119
121 inline int getMaxNumKnowledges() const { return maxNumSolutions_; }
122
124// inline void setMaxNumKnowledges(int maxsols) {
125// if (maxsols > 0) {
126// if (solutions_.size() > maxsols) {
127// std::multimap< double, CoinSharedPtr<AlpsSolution> >::
128// iterator si = solutions_.begin();
129// for (int i = 0; i < maxsols; ++i)
130// ++si;
131// solutions_.erase(si, solutions_.end());
132// }
133// }
134// maxNumSolutions_ = maxsols;
135// }
136 inline void setMaxNumKnowledges(int maxsols) {
137 if (maxsols > 0) {
138 if (static_cast<int>(solutions_.size()) > maxsols) {
139 std::multimap<double, AlpsSolution*>::
140 iterator si = solutions_.begin();
141 for (int i = 0; i < maxsols; ++i)
142 ++si;
143 solutions_.erase(si, solutions_.end());
144 }
145 }
146 maxNumSolutions_ = maxsols;
147 }
148
151// inline std::pair<AlpsKnowledge*, double> getBestKnowledge() const {
152// return std::make_pair(solutions_.begin()->second.get(),
153// solutions_.begin()->first);
154// }
155 inline std::pair<AlpsKnowledge*, double> getBestKnowledge() const {
156 return std::make_pair(static_cast<AlpsKnowledge *>
157 (solutions_.begin()->second),
158 solutions_.begin()->first);
159 }
160
163// inline void getAllKnowledges
164// (std::vector<std::pair<AlpsKnowledge*, double> >& sols) const {
165// sols.reserve(sols.size() + solutions_.size());
166// std::multimap< double, CoinSharedPtr<AlpsSolution> >::
167// const_iterator si;
168// for (si = solutions_.begin(); si != solutions_.end(); ++si) {
169// sols.push_back(std::make_pair(si->second.get(), si->first));
170// }
171// }
173 (std::vector<std::pair<AlpsKnowledge*, double> >& sols) const {
174 sols.reserve(sols.size() + solutions_.size());
175 std::multimap<double, AlpsSolution*>::const_iterator si;
176 for (si = solutions_.begin(); si != solutions_.end(); ++si) {
177 sols.push_back(std::make_pair(static_cast<AlpsKnowledge *>
178 (si->second), si->first));
179 }
180 }
181
183 void clean() {
184 while (!solutions_.empty()) {
185 std::multimap< double, AlpsSolution* >::iterator si =
186 solutions_.end();
187 --si;
188 AlpsSolution* sol = si->second;
189 solutions_.erase(si);
190 delete sol;
191 sol = NULL;
192 }
193
194 //for_each(solutions_.begin(), solutions_.end(), DeletePtrObject());
195 }
196};
197
198
199
200#define AlpsSolutionInterface(ref) \
201int getNumSolutions() const { \
202 (ref).getNumSolutions(); \
203} \
204int getMaxNumSolutions() const { \
205 return (ref).getMaxNumSolutions(); \
206} \
207void setMaxNumSolutions(int num) { \
208 (ref).setMaxNumSolutions(num); \
209} \
210bool hasSolution() const { \
211 return (ref).hasSolution(); \
212} \
213std::pair<const AlpsSolution*, double> getBestSolution() const { \
214 return (ref).getBestSolution(); \
215} \
216void getAllSolutions \
217 (std::vector<std::pair<const AlpsSolution*, double> >& sols) { \
218 return (ref).getAllSolutions(sols); \
219} \
220void addSolution(const AlpsSolution* sol, double priority) { \
221 (ref).addSolution(sol, priority); \
222}
223
224#endif
The abstract base class of any user-defined class that Alps has to know about in order to encode/deco...
Definition: AlpsKnowledge.h:51
In the solution pool we assume that the lower the priority value the more desirable the solution is.
void addKnowledge(AlpsKnowledge *sol, double priority)
Append the solution to the end of the vector of solutions.
void popKnowledge()
Remove a solution from the pool.
int getNumKnowledges() const
query the current number of solutions
bool hasKnowledge() const
return true if there are any solution stored in the solution pool
void setMaxNumKnowledges(int maxsols)
reset the maximum number of solutions
std::pair< AlpsKnowledge *, double > getKnowledge() const
Get a solution from solution pool, doesn't remove it from the pool.
AlpsSolutionPool(int maxsols=1)
void getAllKnowledges(std::vector< std::pair< AlpsKnowledge *, double > > &sols) const
Return all the solutions of the solution pool in the provided argument vector.
void clean()
Delete all the solutions in pool.
virtual ~AlpsSolutionPool()
std::pair< AlpsKnowledge *, double > getBestKnowledge() const
Return the best solution.
int getMaxNumKnowledges() const
query the maximum number of solutions