7 #ifndef __OSITESTSOLVER_HPP__ 8 #define __OSITESTSOLVER_HPP__ 23 template <
class T>
static inline T
24 VolMax(
register const T x,
register const T y) {
25 return ((x) > (y)) ? (x) : (y);
28 template <
class T>
static inline T
30 return ((x) > 0) ? (x) : -(x);
35 #if defined(VOL_DEBUG) && (VOL_DEBUG != 0) 36 #define VOL_TEST_INDEX(i, size) \ 38 if ((i) < 0 || (i) >= (size)) { \ 39 printf("bad VOL_?vector index\n"); \ 43 #define VOL_TEST_SIZE(size) \ 46 printf("bad VOL_?vector size\n"); \ 51 #define VOL_TEST_INDEX(i, size) 52 #define VOL_TEST_SIZE(size) 161 v =
new double[sz = s];
170 std::copy(x.
v, x.
v + sz, v);
177 inline int size()
const {
return sz;}
202 printf(
"bad VOL_dvector sizes\n");
205 double * p_v = v - 1;
206 const double * p_w = w.
v - 1;
207 const double *
const p_e = v + sz;
208 const double one_gamma = 1.0 - gamma;
209 while ( ++p_v != p_e ){
210 *p_v = one_gamma * (*p_v) + gamma * (*++p_w);
219 v =
new double[sz = s];
263 std::copy(x.
v, x.
v + sz, v);
272 inline int size()
const {
return sz; }
326 VOL_primal(
const int psize,
const int dsize) : x(psize), v(dsize) {}
328 value(primal.value), viol(primal.viol), x(primal.x), v(primal.v) {}
345 value = alpha * p.
value + (1.0 - alpha) * value;
368 lcost(dual.lcost), xrc(dual.xrc), u(dual.u) {}
379 void step(
const double target,
const double lambda,
403 lastgreeniter = lastyellowiter = lastrediter = 0;
409 const double lcost,
const double ascent,
const int iter) {
412 if (ascent > 0.0 && lcost > dual.
lcost + eps) {
414 lastgreeniter = iter;
418 if (ascent <= 0 && lcost > dual.
lcost) {
420 lastyellowiter = iter;
434 double lambdafactor = 1.0;
440 cons = iter -
VolMax(lastyellowiter, lastrediter);
442 printf(
" G: Consecutive Gs = %3d\n\n", cons);
444 lastgreeniter = lastyellowiter = lastrediter = iter;
447 printf(
"\n ---- increasing lamda to %g ----\n\n",
448 lambda * lambdafactor);
453 cons = iter -
VolMax(lastgreeniter, lastrediter);
455 printf(
" Y: Consecutive Ys = %3d\n\n", cons);
457 lastgreeniter = lastyellowiter = lastrediter = iter;
460 printf(
"\n **** increasing lamda to %g *****\n\n",
461 lambda * lambdafactor);
466 cons = iter -
VolMax(lastgreeniter, lastyellowiter);
468 printf(
" R: Consecutive Rs = %3d\n\n", cons);
470 lastgreeniter = lastyellowiter = lastrediter = iter;
473 printf(
"\n **** decreasing lamda to %g *****\n\n",
474 lambda * lambdafactor);
483 printf(
"**** G= %i, Y= %i, R= %i ****\n", ngs, nys, nrs);
502 const double alpha) {
505 register const double ll =
VolAbs(lcost);
506 const double x = ll > 10 ? (lcost-lastvalue)/ll : (lcost-lastvalue);
527 VOL_vh(
const double alpha,
611 void set_default_parm();
630 int solve(
VOL_user_hooks& hooks,
const bool use_preset_dual =
false);
683 int iter()
const {
return iter_; }
685 double alpha()
const {
return alpha_; }
687 double lambda()
const {
return lambda_; }
694 void read_params(
const char* filename);
697 int initialize(
const bool use_preset_dual);
700 void print_info(
const int iter,
706 double readjust_target(
const double oldtarget,
const double lcost)
const;
static T VolAbs(register const T x)
double minimum_rel_ascent
terminate if the relative increase in lcost through ascent_check_invl steps is less than this ...
double lambdainit
initial value of lambda
int operator[](const int i) const
Return the i-th entry.
The user hooks should be overridden by the user to provide the problem specific routines for the volu...
VOL_dvector psol
final primal solution (OUTPUT)
VOL_primal & operator=(const VOL_primal &p)
VOL_primal(const int psize, const int dsize)
VOL_dvector()
Default constructor creates a vector of size 0.
VOL_dvector dsol
final dual solution (INPUT/OUTPUT)
#define VOL_TEST_SIZE(size)
void swap(VOL_dvector &w)
swaps the vector with w.
VOL_dvector dual_ub
upper bounds for the duals (if 0 length, then filled with +inf) (INPUT)
void cc(const double alpha, const VOL_primal &p)
This class holds every data for the Volume Algorithm and its solve method must be invoked to solve th...
double granularity
terminate if best_ub - lcost < granularity
int & operator[](const int i)
Return a reference to the i-th entry.
virtual ~VOL_user_hooks()
int ascent_check_invl
through how many iterations does the relative ascent have to reach a minimum
int iter() const
returns the iteration number
double ubinit
initial upper bound of the value of an integer solution
VOL_ivector()
Default constructor creates a vector of size 0.
~VOL_ivector()
The destructor deletes the data array.
double alpha() const
returns the value of alpha
double operator[](const int i) const
Return the i-th entry.
double alphafactor
when little progress is being done, we multiply alpha by alphafactor
int maxsgriters
maximum number of iterations
double & operator[](const int i)
Return a reference to the i-th entry.
int size() const
Return the size of the vector.
void clear()
Delete the content of the vector and replace it with a vector of length 0.
void allocate(const int s)
delete the current vector and allocate space for a vector of size s.
double factor(const VOL_parms &parm, const double lcost, const double alpha)
double value
final lagrangian value (OUTPUT)
double alphainit
initial value of alpha
double alpha_
value of alpha
VOL_ivector(const VOL_ivector &x)
Copy constructor makes a replica of x.
int dsize
length of dual solution (INPUT)
void allocate(const int s)
delete the current vector and allocate space for a vector of size s.
int sz
The size of the vector.
int printflag
controls the level of printing.
int iter_
iteration number
double lambda_
value of lambda
double gap_abs_precision
accept if abs gap is less than this
VOL_primal(const VOL_primal &primal)
int alphaint
number of iterations before we check if alpha should be decreased
double * v
The array holding the vector.
VOL_dvector(const VOL_dvector &x)
Copy constructor makes a replica of x.
int yellowtestinvl
how many consecutive yellow iterations are allowed before changing lambda
This class contains the parameters controlling the Volume Algorithm.
VOL_dvector dual_lb
lower bounds for the duals (if 0 length, then filled with -inf) (INPUT)
void clear()
Delete the content of the vector and replace it with a vector of length 0.
int heurinvl
controls how often we run the primal heuristic
VOL_dual(const VOL_dual &dual)
int greentestinvl
how many consecutive green iterations are allowed before changing lambda
double gap_rel_precision
accept if rel gap is less than this
int psize
length of primal solution (INPUT)
int * v
The array holding the vector.
void swap(VOL_ivector &w)
swaps the vector with w.
int printinvl
controls how often do we print
int size() const
Return the size of the vector.
~VOL_dvector()
The destructor deletes the data array.
char * temp_dualfile
name of file for saving dual solution
const double COIN_DBL_MAX
double alphamin
minimum value for alpha
void cc(const double gamma, const VOL_dvector &w)
Convex combination.
#define VOL_TEST_INDEX(i, size)
VOL_ivector(const int s)
Construct a vector of size s.
int ascent_first_check
when to check for sufficient relative ascent the first time
VOL_parms parm
The parameters controlling the Volume Algorithm (INPUT)
int redtestinvl
how many consecutive red iterations are allowed before changing lambda
double lambda() const
returns the value of lambda
int sz
The size of the vector.
double lfactor(const VOL_parms &parm, const double lambda, const int iter)
VOL_dvector(const int s)
Construct a vector of size s.
VOL_dvector viol
violations (b-Ax) for the relaxed constraints
VOL_dual(const int dsize)
double primal_abs_precision
accept if max abs viol is less than this
void cond(const VOL_dual &dual, const double lcost, const double ascent, const int iter)
static T VolMax(register const T x, register const T y)
VOL_dual & operator=(const VOL_dual &p)