Optimizer::Status Optimizer::optimize(const IntervalVector& init_box, double obj_init_bound) {
loup=obj_init_bound;
pseudo_loup=obj_init_bound;
buffer.contract(loup);
uplo=NEG_INFINITY;
uplo_of_epsboxes=POS_INFINITY;
nb_cells=0;
nb_simplex=0;
diam_simplex=0;
nb_rand=0;
diam_rand=0;
buffer.flush();
Cell* root=new Cell(IntervalVector(n+1));
write_ext_box(init_box,root->box);
// add data required by the bisector
bsc.add_backtrackable(*root);
// add data "pu" and "pf" (if required)
buffer.cost2().add_backtrackable(*root);
// add data required by optimizer + Fritz John contractor
root->add<EntailedCtr>();
//root->add<Multipliers>();
entailed=&root->get<EntailedCtr>();
entailed->init_root(user_sys,sys);
loup_changed=false;
initial_loup=obj_init_bound;
loup_point=init_box.mid();
time=0;
Timer::start();
handle_cell(*root,init_box);
update_uplo();
try {
while (!buffer.empty()) {
// if (trace >= 2) cout << " buffer " << buffer << endl;
if (trace >= 2) buffer.print(cout);
// cout << "buffer size " << buffer.size() << " " << buffer2.size() << endl;
// removes from the heap buffer, the cells already chosen in the other buffer
if (buffer.empty()) {
//cout << " buffer empty " << buffer.empty() << " " << buffer2.empty() << endl;
// this update is only necessary when buffer was not
// initially empty
update_uplo();
break;
}
loup_changed=false;
Cell *c;
// random choice between the 2 buffers corresponding to two criteria implemented in two heaps)
// critpr chances over 100 to choose the second heap (see CellDoubleHeap)
c=buffer.top();
try {
pair<IntervalVector,IntervalVector> boxes=bsc.bisect(*c);
pair<Cell*,Cell*> new_cells=c->bisect(boxes.first,boxes.second);
buffer.pop();
delete c; // deletes the cell.
handle_cell(*new_cells.first, init_box);
handle_cell(*new_cells.second, init_box);
if (uplo_of_epsboxes == NEG_INFINITY) {
cout << " possible infinite minimum " << endl;
break;
}
if (loup_changed) {
// In case of a new upper bound (loup_changed == true), all the boxes
// with a lower bound greater than (loup - goal_prec) are removed and deleted.
// Note: if contraction was before bisection, we could have the problem
// that the current cell is removed by contractHeap. See comments in
// older version of the code (before revision 284).
double ymax=compute_ymax();
buffer.contract(ymax);
//cout << " now buffer is contracted and min=" << buffer.minimum() << endl;
if (ymax <= NEG_INFINITY) {
if (trace) cout << " infinite value for the minimum " << endl;
break;
}
if (trace) cout << setprecision(12) << "ymax=" << ymax << " uplo= " << uplo<< endl;
}
update_uplo();
time_limit_check();
}
catch (NoBisectableVariableException& ) {
update_uplo_of_epsboxes((c->box)[ext_sys.goal_var()].lb());
buffer.pop();
delete c; // deletes the cell.
update_uplo(); // the heap has changed -> recalculate the uplo
}
}
}
catch (TimeOutException& ) {
return TIME_OUT;
}
Timer::stop();
time+= Timer::VIRTUAL_TIMELAPSE();
if (uplo_of_epsboxes == POS_INFINITY && (loup==POS_INFINITY || (loup==initial_loup && goal_abs_prec==0 && goal_rel_prec==0)))
return INFEASIBLE;
else if (loup==initial_loup)
return NO_FEASIBLE_FOUND;
else if (uplo_of_epsboxes == NEG_INFINITY)
return UNBOUNDED_OBJ;
else
return SUCCESS;
}
bool Solver::next(std::vector<IntervalVector>& sols) {
try {
while (!buffer.empty()) {
if (trace==2) cout << buffer << endl;
Cell* c=buffer.top();
try {
int v=c->get<BisectedVar>().var; // last bisected var.
if (v!=-1) impact.set(v);
ctc.contract(c->box,impact);
if (v!=-1) impact.unset(v);
if (c->box.max_diam()<=prec) {
new_sol(sols,c->box);
delete buffer.pop();
impact.set_all();
return !buffer.empty();
// note that we skip time_limit_check() here.
// In the case where "next" is called by "solve",
// and if time has exceeded, the exception will be raised by the
// very next call to "next" anyway. This holds, unless "next" finds
// new solutions again and again endlessly. So there is a little risk
// of uncaught timeout in this case (but this case is probably already
// an error case).
}
else {
try {pair<IntervalVector,IntervalVector> boxes=bsc.bisect(*c);
pair<Cell*,Cell*> new_cells=c->bisect(boxes.first,boxes.second);
delete buffer.pop();
buffer.push(new_cells.first);
buffer.push(new_cells.second);
nb_cells+=2;
if (cell_limit >=0 && nb_cells>=cell_limit) throw CellLimitException();}
catch (NoBisectableVariableException&) {
new_sol(sols, c->box);
delete buffer.pop();
impact.set_all();
return !buffer.empty();
}
}
time_limit_check();
} catch(EmptyBoxException&) {
assert(c->box.is_empty());
delete buffer.pop();
impact.set_all();
}
}
}
catch (TimeOutException&) {
cout << "time limit " << time_limit << "s. reached " << endl; return false;
}
catch (CellLimitException&) {
cout << "cell limit " << cell_limit << " reached " << endl;
}
Timer::stop();
time+= Timer::VIRTUAL_TIMELAPSE();
return false;
}
void Optimizer::optimize(const IntervalVector& init_box) {
buffer.flush();
Cell* root=new Cell(IntervalVector(n+1));
write_ext_box(init_box,root->box);
// add data required by the bisector
bsc.add_backtrackable(*root);
// add data required by optimizer + Fritz John contractor
root->add<EntailedCtr>();
//root->add<Multipliers>();
entailed=&root->get<EntailedCtr>();
entailed->init_root(user_sys,sys);
loup_changed=false;
loup_point=init_box.mid();
time=0;
Timer::start();
handle_cell(*root,init_box);
try {
while (!buffer.empty()) {
loup_changed=false;
if (trace >= 2) cout << ((CellBuffer&) buffer) << endl;
Cell* c=buffer.top();
// cout << " box before bisection " << c->box << endl;
try {
pair<IntervalVector,IntervalVector> boxes=bsc.bisect(*c);
pair<Cell*,Cell*> new_cells=c->bisect(boxes.first,boxes.second);
delete buffer.pop();
handle_cell(*new_cells.first, init_box);
handle_cell(*new_cells.second, init_box);
if (uplo_of_epsboxes == NEG_INFINITY) {
cout << " possible infinite minimum " << endl;
break;
}
if (loup_changed ) {
// In case of a new upper bound (loup_changed == true), all the boxes
// with a lower bound greater than (loup - goal_prec) are removed and deleted.
// Note: if contraction was before bisection, we could have the problem
// that the current cell is removed by contract_heap. See comments in
// older version of the code (before revision 284).
double ymax= compute_ymax();
buffer.contract_heap(ymax);
if (ymax <=NEG_INFINITY) {
if (trace) cout << " infinite value for the minimum " << endl;
break;
}
if (trace) cout << setprecision(12) << "ymax=" << ymax << " uplo= " << uplo<< endl;
}
update_uplo();
time_limit_check();
}
catch (NoBisectableVariableException& ) {
bool bb=false;
for (int i=0;(!bb)&&( i<(c->box).size()); i++) {
if (i!=ext_sys.goal_var()) // skip goal variable
bb=bb||(c->box)[i].is_unbounded();
}
if (!bb) {
// rem4: this case can append if the interval [1.79769e+308,inf] is in c.box.
// It is only numerical degenerated case
update_uplo_of_epsboxes ((c->box)[ext_sys.goal_var()].lb());
}
delete buffer.pop();
}
}
}
catch (TimeOutException& ) {
return;
}
Timer::stop();
time+= Timer::VIRTUAL_TIMELAPSE();
}
