BoolInterval PdcHansenFeasibility::test(const IntervalVector& box) {
int n=f.nb_var();
int m=f.image_dim();
IntervalVector mid=box.mid();
/* Determine the "most influencing" variable thanks to
* the pivoting of Gauss elimination */
// ==============================================================
Matrix A=f.jacobian(mid).mid();
Matrix LU(m,n);
int pr[m];
int pc[n]; // the interesting output: the variables permutation
try {
real_LU(A,LU,pr,pc);
} catch(SingularMatrixException&) {
// means in particular that we could not extract an
// invertible m*m submatrix
return MAYBE;
}
// ==============================================================
PartialFnc pf(f,pc,m,mid);
IntervalVector box2(pf.chop(box));
IntervalVector savebox(box2);
if (inflating) {
if (inflating_newton(pf,box2)) {
_solution = pf.extend(box2);
return YES;
}
}
else {
try {
newton(pf,box2);
if (box2.is_strict_subset(savebox)) {
_solution = pf.extend(box2);
return YES;
}
} catch (EmptyBoxException& ) { }
}
_solution.set_empty();
return MAYBE;
}
void CtcUnion::contract(IntervalVector& box) {
IntervalVector savebox(box);
IntervalVector result(IntervalVector::empty(box.size()));
for (int i=0; i<list.size(); i++) {
if (i>0) box=savebox;
try {
list[i].contract(box);
result |= box;
}
catch(EmptyBoxException&) {
}
}
box = result;
if (box.is_empty()) throw EmptyBoxException();
} // end namespace ibex
void SepUnion::separate(IntervalVector &x_in, IntervalVector &x_out){
assert(x_in==x_out);
IntervalVector result_x_out(IntervalVector::empty(x_out.size()));
IntervalVector savebox(x_out);
for (int i=0; i<list.size(); i++) {
if (i>0) x_out=savebox;
try {
x_out &= x_in;
list[i].separate(x_in,x_out);
result_x_out |= x_out;
} catch(EmptyBoxException&) { }
}
x_out = result_x_out;
}
void CtcNotIn::contract(IntervalVector& box) {
// it's simpler here to use direct computation, but
// we could also have used CtCunion of two CtcFwdBwd
IntervalVector savebox(box);
try {
HC4Revise().proj(f,d1,box);
} catch (EmptyBoxException& ) {box.set_empty(); }
try {
HC4Revise().proj(f,d2,savebox);
} catch (EmptyBoxException& ) {savebox.set_empty(); }
box |= savebox;
if (box.is_empty()) throw EmptyBoxException();
}
void CtcUnion::contract(IntervalVector& box) {
IntervalVector savebox(box);
IntervalVector result(IntervalVector::empty(box.size()));
BitSet flags(BitSet::empty(Ctc::NB_OUTPUT_FLAGS));
BitSet impact(BitSet::all(nb_var)); // always set to "all" for the moment (to be improved later)
for (int i=0; i<list.size(); i++) {
if (i>0) box=savebox;
flags.clear();
list[i].contract(box,impact,flags);
result |= box;
if (flags[INACTIVE]) { set_flag(INACTIVE); break; }
}
box = result;
} // end namespace ibex
int LinearRelaxXTaylor::X_Linearization(IntervalVector& box,
int ctr, corner_point cpoint, CmpOp op,
IntervalVector& G2, int id_point, int& nb_nonlinear_vars, LinearSolver *mysolver) {
IntervalVector G = G2;
int n = sys.nb_var;
int nonlinear_var = 0;
if (id_point != 0 && linear_ctr[ctr])
return 0; // only one corner for a linear constraint
/*
bool* corner=NULL;
if(!linear[ctr]){
// best not implemented in version 2.0 BNE
if(cpoint==BEST){
corner= new bool[n];
best_corner(ctr, op, G, corner);
}
}
*/
IntervalVector savebox(box);
Interval ev(0.0);
Interval tot_ev(0.0);
Vector row1(n);
for (int j=0; j< n; j++) {
//cout << "[LinearRelaxXTaylor] variable n°" << j << endl;
if (sys.ctrs[ctr].f.used(j)) {
if (lmode == HANSEN && !linear[ctr][j])
// get the partial derivative of ctr w.r.t. var n°j
G[j]=df[ctr*n+j].eval(box);
}
else
continue;
//cout << "[LinearRelaxXTaylor] coeffs=" << G[j] << endl;
if (G[j].diam() > max_diam_deriv) {
box = savebox; // [gch] where box has been modified? at the end of the loop (for Hansen computation) [bne]
return 0; // To avoid problems with SoPleX
}
if (linear[ctr][j])
cpoint = INF_X;
else if (G[j].diam() > 1e-10)
nonlinear_var++;
bool inf_x;
/* for GREEDY heuristics :not implemented in v2
IntervalVector save;
double fh_inf, fh_sup;
double D;
*/
switch (cpoint) {
/*
case BEST:
inf_x=corner[j]; last_rnd[j]=inf_x? 0:1; break;
*/
case INF_X:
inf_x = true;
break;
case SUP_X:
inf_x = false;
break;
case RANDOM:
last_rnd[j] = rand();
inf_x = (last_rnd[j] % 2 == 0);
break;
case K4:
if (id_point == 0) {
inf_x = (rand() % 2 == 0);
base_coin[j] = inf_x;
} else if (nb_nonlinear_vars < 3) {
if (id_point == 1)
inf_x = !base_coin[j];
else
return 0;
} else if (G[j].diam() <= 1e-10) {
inf_x = (rand() % 2 == 0);
} else if (id_point == 1) {
if (((double) nonlinear_var) <= (((double) nb_nonlinear_vars)/ 3.0))
inf_x = base_coin[j];
else
inf_x = !base_coin[j];
} else if (id_point == 2) {
if (((double) nonlinear_var )> ((double) nb_nonlinear_vars)/ 3.0
&& (double) nonlinear_var
<= 2 * (double) nb_nonlinear_vars / 3.0)
inf_x = base_coin[j];
else
inf_x = !base_coin[j];
} else if (id_point == 3) {
if (((double) nonlinear_var)
> 2 * ((double) nb_nonlinear_vars) / 3.0)
inf_x = base_coin[j];
else
inf_x = !base_coin[j];
}
break;
case RANDOM_INV:
inf_x = (last_rnd[j] % 2 != 0);
break;
case NEG:
inf_x = (last_rnd[j] % 2 != 0);
break;
/* not implemented in v2.0
case GREEDY1:
inf_x=((abs(Inf(G(j+1))) < abs(Sup(G(j+1))) && (op == LEQ || op== LT)) ||
(abs(Inf(G(j+1))) >= abs(Sup(G(j+1))) && (op == GEQ || op== GT)) )? true:false;
break;
case MONO:
if (ctr==goal_ctr && ((Inf(G(j+1)) >0 && (op == LEQ || op== LT)) ||
(Sup (G(j+1)) < 0 && (op == GEQ || op== GT))))
inf_x = true;
else if
(ctr == goal_ctr &&
((Sup(G(j+1)) <0 && (op == LEQ || op== LT)) ||
(Inf(G(j+1)) > 0 && (op == GEQ || op== GT))))
inf_x=false;
else inf_x = (rand()%2==0);
last_rnd[j]=inf_x? 0:1;
break;
case NEGMONO:
if ((Inf(G(j+1)) >0 && (op == LEQ || op== LT)) ||
(Sup (G(j+1)) < 0 && (op == GEQ || op== GT)))
inf_x = false;
else if
((Sup(G(j+1)) <0 && (op == LEQ || op== LT)) ||
(Inf(G(j+1)) > 0 && (op == GEQ || op== GT)))
inf_x=true;
else inf_x = (rand()%2==0);
last_rnd[j]=inf_x? 0:1;
break;
*/
/*
case GREEDY7:
//select the coin nearest to the loup
if(goal_ctr!=-1 && Dimension(Optimizer::global_optimizer())>0){
// if(j==0)cout<< Optimizer::global_optimizer()<<end;
inf_x=(abs(Optimizer::global_optimizer()(j+1)-Inf(savebox(j+1))) <
abs(Optimizer::global_optimizer()(j+1)-Sup(savebox(j+1))))? true:false;
}else{
inf_x=(rand()%2==0);
}
break;
*/
/*
case GREEDY6:
save=space.box;
fh_inf, fh_sup;
D=Diam(savebox(j+1));
space.box=Mid(space.box);
space.box(j+1)=Inf(savebox(j+1));
fh_inf=Mid(sys.ctr(ctr).eval(space));
space.box(j+1)=Sup(savebox(j+1));
fh_sup=Mid(sys.ctr(ctr).eval(space));
if (op == LEQ || op== LT)
inf_x=((fh_sup-fh_inf)/(REAL)(n-1) - 0.5*D*(Inf(G(j+1))+Sup(G(j+1))) > 0)? false:true;
else
inf_x=((fh_sup-fh_inf)/(REAL)(n-1) - 0.5*D*(Inf(G(j+1))+Sup(G(j+1))) < 0)? false:true;
last_rnd[j]=inf_x? 0:1;
space.box=save;
break;
case GREEDY5:
save=space.box;
fh_inf, fh_sup;
D=Diam(savebox(j+1));
space.box=Mid(space.box);
space.box(j+1)=Inf(savebox(j+1));
fh_inf=Mid(sys.ctr(ctr).eval(space));
space.box(j+1)=Sup(savebox(j+1));
fh_sup=Mid(sys.ctr(ctr).eval(space));
if (op == LEQ || op== LT)
inf_x=(fh_sup-fh_inf - 0.5*D*(Inf(G(j+1))+Sup(G(j+1))) > 0)? false:true;
else
inf_x=(fh_sup-fh_inf - 0.5*D*(Inf(G(j+1))+Sup(G(j+1))) < 0)? false:true;
last_rnd[j]=inf_x? 0:1;
space.box=save;
break;
*/
default:
last_rnd[j] = rand();
inf_x = (last_rnd[j] % 2 == 0);
break;
}
// cout << " j " << j << " " << savebox[j] << G[j] << endl;
box[j]=inf_x? savebox[j].lb():savebox[j].ub();
Interval a = ((inf_x && (op == LEQ || op== LT)) ||
(!inf_x && (op == GEQ || op== GT))) ? G[j].lb() : G[j].ub();
row1[j] = a.mid();
ev -= a*box[j];
}
// cout << " ev " << ev << endl;
/* used in BEST not implemented in v2.0
if(corner) delete[] corner;
*/
ev+= sys.ctrs[ctr].f.eval(box);
if(id_point==0) nb_nonlinear_vars=nonlinear_var;
for(int j=0;j<n;j++)
tot_ev+=row1[j]*savebox[j]; //natural evaluation of the left side of the linear constraint
bool added=false;
if (op == LEQ || op == LT) {
//g(xb) + a1' x1 + ... + an xn <= 0
if(tot_ev.lb()>(-ev).ub())
throw EmptyBoxException(); // the constraint is not satisfied
if((-ev).ub()<tot_ev.ub()) { // otherwise the constraint is satisfied for any point in the box
mysolver->addConstraint( row1, LEQ, (-ev).ub());
added=true;
}
} else {
if(tot_ev.ub()<(-ev).lb())
throw EmptyBoxException();
if ((-ev).lb()>tot_ev.lb()) {
mysolver->addConstraint( row1, GEQ, (-ev).lb() );
added=true;
}
}
box=savebox;
return (added)? 1:0;
}
BoolInterval PdcHansenFeasibility::test(const IntervalVector& box) {
int n=f.nb_var();
int m=f.image_dim();
IntervalVector mid=box.mid();
/* Determine the "most influencing" variable thanks to
* the pivoting of Gauss elimination */
// ==============================================================
Matrix A=f.jacobian(mid).mid();
Matrix LU(m,n);
int *pr = new int[m];
int *pc = new int[n]; // the interesting output: the variables permutation
BoolInterval res=MAYBE;
try {
real_LU(A,LU,pr,pc);
} catch(SingularMatrixException&) {
// means in particular that we could not extract an
// invertible m*m submatrix
delete [] pr;
delete [] pc;
return MAYBE;
}
// ==============================================================
// PartialFnc pf(f,pc,m,mid);
BitSet _vars=BitSet::empty(n);
for (int i=0; i<m; i++) _vars.add(pc[i]);
VarSet vars(f.nb_var(),_vars);
IntervalVector box2(box);
// fix parameters to their midpoint
vars.set_param_box(box2, vars.param_box(box).mid());
IntervalVector savebox(box2);
if (inflating) {
if (inflating_newton(f,vars,box2)) {
_solution = box2;
res = YES;
} else {
_solution.set_empty();
}
}
else {
// ****** TODO **********
newton(f,vars,box2);
if (box2.is_empty()) {
_solution.set_empty();
} else if (box2.is_strict_subset(savebox)) {
_solution = box2;
res = YES;
}
}
delete [] pr;
delete [] pc;
return res;
}