void TestCtcExist::test01() {
Variable x,y;
Function f(x,y,1.5*sqr(x)+1.5*sqr(y)-x*y-0.2);
double prec=1e-05;
NumConstraint c(f,LEQ);
CtcExist exist_y(c,y,IntervalVector(1,Interval(-10,10)),prec);
CtcExist exist_x(c,x,IntervalVector(1,Interval(-10,10)),prec);
IntervalVector box(1,Interval(-10,10));
RoundRobin rr(1e-03);
CellStack stack;
vector<IntervalVector> sols;
double right_bound=+0.3872983346072957;
Solver sx(exist_y,rr,stack);
sx.start(box);
sx.next(sols);
// note: we use the fact that the solver always explores the right
// branch first
TEST_ASSERT(sols.back()[0].contains(right_bound));
sols.clear();
Solver sy(exist_x,rr,stack);
sy.start(box);
sy.next(sols);
// note: we use the fact that the constraint is symmetric in x/y
TEST_ASSERT(sols.back()[0].contains(right_bound));
}
void TestGradient::transpose01() {
Variable x(3);
Variable y(3);
Function f(x,y,transpose(x)*y);
double _xy[]={1,2,3,4,5,6};
IntervalVector xy(Vector(6,_xy));
double _g[]={4,5,6,1,2,3};
check(f.gradient(xy),IntervalVector(Vector(6,_g)));
CPPUNIT_ASSERT(f.gradient(xy).is_superset(IntervalVector(Vector(6,_g))));
}
void TestExprDiff::apply03() {
Variable x("x"),y("y");
Function f(x,y,x*y,"f");
Function g(x,y,f(2*x,3*y));
Function dg(g,Function::DIFF);
TEST_ASSERT(sameExpr(dg.expr(),"((2*df((2*x),(3*y))[0]),(3*df((2*x),(3*y))[1]))"));
double _box[][2]={{1,1},{2,2}};
double _dg_box[][2]={{12,12},{6,6}};
IntervalVector dg_box(dg.eval_vector(IntervalVector(2,_box)));
TEST_ASSERT(dg_box==IntervalVector(2,_dg_box));
}
void TestCtcExist::test01() {
Variable x,y;
Function f(x,y,1.5*sqr(x)+1.5*sqr(y)-x*y-0.2);
double prec=1e-05;
NumConstraint c(f,LEQ);
CtcExist exist_y(c,y,IntervalVector(1,Interval(-10,10)),prec);
CtcExist exist_x(c,x,IntervalVector(1,Interval(-10,10)),prec);
IntervalVector box(1,Interval(-10,10));
double right_bound=+0.3872983346072957;
stack<IntervalVector> stack;
stack.push(box);
IntervalVector sol=box;
while (!stack.empty() && sol.max_diam()>1e-03) {
sol=stack.top();
stack.pop();
exist_y.contract(sol);
if (!sol.is_empty()) {
pair<IntervalVector,IntervalVector> p=sol.bisect(0);
stack.push(p.first);
stack.push(p.second);
}
}
// note: we use the fact that the solver always explores the right
// branch first
CPPUNIT_ASSERT(sol[0].contains(right_bound));
while (!stack.empty()) stack.pop();
stack.push(box);
sol=box;
while (!stack.empty() && sol.max_diam()>1e-03) {
sol=stack.top();
stack.pop();
exist_x.contract(sol);
if (!sol.is_empty()) {
pair<IntervalVector,IntervalVector> p=sol.bisect(0);
stack.push(p.first);
stack.push(p.second);
}
}
// note: we use the fact that the constraint is symmetric in x/y
CPPUNIT_ASSERT(sol[0].contains(right_bound));
}
void TestSolver::circle2() {
const ExprSymbol& x=ExprSymbol::new_("x");
const ExprSymbol& y=ExprSymbol::new_("y");
SystemFactory f;
f.add_var(x);
f.add_var(y);
f.add_ctr(sqr(x)+sqr(y)=1);
f.add_ctr(sqr(x-2)+sqr(y)=1);
double _sol1[]={1,0};
Vector sol1(2,_sol1);
System sys(f);
RoundRobin rr(1e-3);
CellStack stack;
CtcHC4 hc4(sys);
Vector prec(2,1e-3);
Solver solver(sys,hc4,rr,stack,prec,prec);
solver.start(IntervalVector(2,Interval(-10,10)));
CovSolverData::BoxStatus status;
bool res=solver.next(status);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(status==CovSolverData::UNKNOWN);
CPPUNIT_ASSERT(solver.get_data().nb_unknown()==1);
CPPUNIT_ASSERT(solver.get_data().unknown(0).is_superset(sol1));
res=solver.next(status);
CPPUNIT_ASSERT(!res);
}
IntervalVector FncKhunTucker::multiplier_domain() const {
IntervalVector box(nb_mult, Interval(0,1));
if (!eq.empty())
box.put(ineq.size()+1,IntervalVector(eq.size(),Interval(-1,1)));
return box;
}
int LSmear::var_to_bisect(IntervalMatrix& J, const IntervalVector& box) const {
int lvar = -1;
//Linearization
LPSolver::Status_Sol stat = LPSolver::UNKNOWN;
Vector dual_solution(1);
if (lsmode==LSMEAR_MG) { //compute the Jacobian in the midpoint
IntervalMatrix J2(sys.f_ctrs.image_dim(), sys.nb_var);
IntervalVector box2(IntervalVector(box.mid()).inflate(1e-8));
// IntervalVector box2(IntervalVector(box.random()));
box2 &= box;
sys.f_ctrs.jacobian(box2,J2);
stat = getdual(J2, box, dual_solution);
} else if (lsmode==LSMEAR) {
stat = getdual(J, box, dual_solution);
}
if (stat == LPSolver::OPTIMAL) {
double max_Lmagn = 0.0;
int k=0;
for (int j=0; j<nbvars; j++) {
Interval lsmear=Interval(0.0);
if ((!too_small(box,j)) && (box[j].mag() <1 || box[j].diam()/ box[j].mag() >= prec(j))){
lsmear=dual_solution[j];
for (int i=0; i<sys.f_ctrs.image_dim(); i++){
lsmear += dual_solution[sys.nb_var+i] * J[i][j];
}
}
lsmear*=(box[j].diam());
if (lsmear.mag() > 1e-10 && (j!=goal_var() || mylinearsolver->get_obj_value().mid() > box[goal_var()].lb() )) {
k++;
if (lsmear.mag() > max_Lmagn) {
max_Lmagn = lsmear.mag();
lvar = j;
}
}
}
if (k==1 && lvar==goal_var()) { lvar=-1; }
}
if (lvar==-1) {
// std::cout << "ssr " << std::endl;
lvar=SmearSumRelative::var_to_bisect(J, box);
}
// std::cout << "lsmear " << lvar << std::endl;
return lvar;
}
ExprLabel& Affine2Eval::eval_label(const Function& f, const Affine2Vector& box) const {
assert(f.expr().deco.af2);
assert(f.expr().deco.d);
f.write_arg_domains(IntervalVector(box));
f.write_arg_af2_domains(box);
return f.forward<Affine2Eval>(*this);
}
IntervalVector Function::eval_affine2_vector(const IntervalVector& box, Affine2Vector& affine) const {
ExprLabel res = Affine2Eval().eval_label(*this,box);
if (expr().dim.is_scalar() ) {
affine = Affine2Vector(1,res.af2->i());
return IntervalVector(1,res.d->i());
} else {
affine = res.af2->v();
return res.d->v();
}
}
void TestExprDiff::mat01() {
Variable x(2,2,"x");
Function f(x,x[1][0]);
Function df(f,Function::DIFF);
const ExprConstant* c=dynamic_cast<const ExprConstant*>(&df.expr());
CPPUNIT_ASSERT(c!=NULL);
//CPPUNIT_ASSERT(c->dim.type()==Dim::MATRIX);
double _M[][2]= {{0,0},{0,0},{1,1},{0,0}};
//CPPUNIT_ASSERT(c->get_matrix_value()==IntervalMatrix(2,2,_M));
CPPUNIT_ASSERT(c->get_vector_value()==IntervalVector(4,_M));
}
void TestExprDiff::issue247() {
const ExprSymbol& x=ExprSymbol::new_();
const ExprSymbol& y=ExprSymbol::new_();
const ExprNode& e=x+y;
Array<const ExprNode> a(e,e,e);
const ExprVector& v1=ExprVector::new_(a,false);
DoubleIndex idx(v1.dim,0,1,0,0);
const ExprVector& v2=ExprVector::new_(v1[idx],v1[idx],false);
Function f(x,y,v2[0]);
IntervalVector g=f.gradient(IntervalVector(2));
CPPUNIT_ASSERT(g==Vector::ones(2));
}
void TestExprDiff::vec03() {
Variable x(2,"x");
Array<const ExprNode> _vec1(x[0],x[1]);
const ExprNode& vec1=ExprVector::new_(_vec1,false);
Function f(x,vec1[1]);
Function df(f,Function::DIFF);
const ExprConstant* c=dynamic_cast<const ExprConstant*>(&df.expr());
TEST_ASSERT(c);
TEST_ASSERT(c->dim.type()==Dim::ROW_VECTOR);
double _v[][2]= {{0,0},{1,1}};
TEST_ASSERT(c->get_vector_value()==IntervalVector(2,_v));
}
void TestExprDiff::apply03() {
Variable x("x"),y("y");
Function f(x,y,x*y,"f");
Function g(x,y,f(2*x,3*y));
Function dg(g,Function::DIFF);
// TODO: there are actually many different equivalent expressions of
// the differential.
// What should we exactly test? Probably requires expression equivalence
// operator but this is known to be a difficult task...
// CPPUNIT_ASSERT(sameExpr(dg.expr(),"((2*df((2*x),(3*y))[0]),(3*df((2*x),(3*y))[1]))"));
//CPPUNIT_ASSERT(sameExpr(dg.expr(),"((df((2*x),(3*y))[0]*2),(df((2*x),(3*y))[1]*3))"));
CPPUNIT_ASSERT(sameExpr(dg.expr(),"((6*y),(6*x))"));
double _box[][2]={{1,1},{2,2}};
double _dg_box[][2]={{12,12},{6,6}};
IntervalVector dg_box(dg.eval_vector(IntervalVector(2,_box)));
//CPPUNIT_ASSERT(dg_box==IntervalVector(2,_dg_box));
check(dg_box,IntervalVector(2,_dg_box));
CPPUNIT_ASSERT(dg_box.is_superset(IntervalVector(2,_dg_box)));
}
void TestSolver::circle3() {
const ExprSymbol& x=ExprSymbol::new_("x");
const ExprSymbol& y=ExprSymbol::new_("y");
SystemFactory f;
f.add_var(x);
f.add_var(y);
f.add_ctr(sqr(x)+sqr(y)=1);
f.add_ctr(sqr(x-1)+sqr(y)=1);
double cospi6=0.5;
double sinpi6=(sqrt(Interval(3))/2).lb();
f.add_ctr(4*y*abs(y)<=3); // a rigorous way to impose y<=sin(pi/6).
double _sol1[]={cospi6,sinpi6};
double _sol2[]={cospi6,-sinpi6};
Vector sol1(2,_sol1);
Vector sol2(2,_sol2);
System sys(f);
RoundRobin rr(1e-3);
CellStack stack;
CtcHC4 hc4(sys);
Vector prec(2,1e-3);
Solver solver(sys,hc4,rr,stack,prec,prec);
solver.start(IntervalVector(2,Interval(-10,10)));
CovSolverData::BoxStatus status;
bool res=solver.next(status);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(status==CovSolverData::UNKNOWN);
CPPUNIT_ASSERT(solver.get_data().nb_unknown()==1);
CPPUNIT_ASSERT(solver.get_data().unknown(0).is_superset(sol1));
res=solver.next(status);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(status==CovSolverData::SOLUTION);
CPPUNIT_ASSERT(solver.get_data().nb_solution()==1);
CPPUNIT_ASSERT(solver.get_data().solution(0).is_superset(sol2));
res=solver.next(status);
CPPUNIT_ASSERT(!res);
}
void TestCtcNotIn::check_not_in(int dim, const IntervalVector& x_input, const IntervalVector& x_expected) {
Variable _x(dim);
Function f(_x,_x);
CtcNotIn* c;
if (dim==1) c=new CtcNotIn(f,Interval(-1,1));
else c=new CtcNotIn(f,IntervalVector(dim,Interval(-1,1)));
IntervalVector x(x_input);
c->contract(x);
check(x,x_expected);
delete c;
}
BD_Factory::BD_Factory(const MitsosSIP& sip, BD_Factory::problem_type problem) :
sip(sip), problem(problem), new_vars(problem==ORA? sip.n_arg +1 : sip.n_arg) {
// add "x" variable
varcopy(sip.vars,new_vars);
if (problem==ORA) {
// add "eta" variable
new_vars.set_ref(sip.n_arg, ExprSymbol::new_("eta",Dim::scalar()));
// initial domain of eta is computed dynamically
// see solve_ORA(...)
add_var(new_vars, cart_prod(sip.var_init_domain, IntervalVector(1)));
} else {
add_var(new_vars, sip.var_init_domain);
}
};
// called with the box without the objective
void Optimizer::firstorder_contract( IntervalVector& box, const IntervalVector& init_box) {
if (m==0) {
// for unconstrained optimization contraction with gradient=0
if (box.is_strict_subset(init_box)) {
// may throw an EmptyBoxException:
if (n==1)
df.backward(Interval::ZERO,box);
else
df.backward(IntervalVector(n,Interval::ZERO),box);
}
}
else {
PdcFirstOrder p(user_sys,init_box);
p.set_entailed(entailed);
if (p.test(box)==NO) throw EmptyBoxException();
}
}
// called with the box without the objective
void Optimizer::firstorder_contract(IntervalVector& box, const IntervalVector& init_box) {
if (m==0) {
// for unconstrained optimization contraction with gradient=0
if (box.is_strict_interior_subset(init_box)) {
if (n==1)
df.backward(Interval::ZERO,box);
else
df.backward(IntervalVector(n,Interval::ZERO),box);
}
}
// else {
//
// PdcFirstOrder p(user_sys,init_box);
//
// p.set_entailed(entailed);
// if (p.test(box)==NO) {
// box.set_empty();
// }
// }
}
// Launch a simulation given the method, creates a log file and an info window at the end
void MainWindow::Simu(int method){
first_simu = true;
double errgomne=0;
int cpt=0,cpt2=0;
cantlocalize=0;
nboutlier = 0;
errpos.clear();
par->box.clear();
par->box.push_back(IntervalVector(3,Interval(-25,25)));
ui->checkBox->setChecked(false);
for(int i=0;i<par->nb_beacon;i++){
par->x[i]= 1*(25 - rand() % 50);
par->y[i]= 1*(25 - rand() % 50);
par->z[i]= 5-i%4;
par->theta_sonar[i] = rand() % 360;
if((rand() % 100) <= probsensorfalse){
if (rand() % 1 ==1)
par->outliers[i]=1;
else par->outliers[i]=-1;
nboutlier++;
}
else{par->outliers[i]=0;}
}
ui->nbOutlierlcd->display(nboutlier);
par->nb_beacon = ui->BeaconSpinBox->value();
//Log
ofstream myfile;
myfile.open ("log_simu.txt");
remove("log_simu.txt");
myfile.close();
myfile.open ("log_simu.txt");
QString vt = "";
QElapsedTimer tsimu;
int gomnecpt=0;
tsimu.start();
step=ui->step_SpinBox->value();
for(double i=0;i<6500;i=i+step) cpt2++;
par->ratio_area.clear();
par->areain=0;
par->areap=0;
for(double i=0;i<6500;i=i+step){
//cout<<"entry box :"<<par->box.back()<<endl;
QElapsedTimer tcur;
QString vtcur = "";
tcur.start();
t=i;
par->iteration=t;
if(method==1) on_ButtonFindSol_clicked();
if (method==2) on_ButtonGOMNE_clicked();
if(method==3) {
int qtmp=par->q;
on_ButtonGOMNE_clicked();
SLAM(step);
if (par->q==qtmp) gomnecpt++;
//if (gomnecpt>4) method=4;
}
if(method==4) GOMNE_fixed_q();
errgomne += fabs(double(par->q-(double(par->nb_beacon) - double(nboutlier))) / (double(par->nb_beacon) - double(nboutlier))*100);
ui->TSlider->setValue(t);
Zoom(step);
delay();
vtcur = QString::number(tcur.elapsed());
vt.append(vtcur);vt.append("ms ; ");
myfile << vtcur.toUtf8().constData();myfile << "\n";
if(ui->StopSimu->isDown()) break;
cpt++;
}
double errpercoutliergomne = double(errgomne)/double(cpt);
myfile.close();
QString mess = "Execution time : ";
double exec = tsimu.elapsed();
mess.append(QString::number(exec));mess.append(" ms\n");
mess.append(vt);mess.append(" ms\n");
double cerpos=0;
double i=0;
vector<double> vcerpos;
while (!errpos.empty()){
cerpos+=errpos.back();
i++;
vcerpos.push_back(cerpos);
errpos.pop_back();
}
double mean= cerpos/i;
cerpos = 0;
while(!vcerpos.empty()){
cerpos+=pow(vcerpos.back()-mean,2);
vcerpos.pop_back();
}
cerpos/=i;
double area=0;
for (size_t ii = 0; ii < par->ratio_area.size(); ii++){ area += par->ratio_area[ii];
//cout<<par->ratio_area[ii]<<endl;
}
area/=par->ratio_area.size();
cantlocalize/=cpt;cantlocalize*=100;
mess.append(QString::number(cerpos));mess.append("\n");//mess.append(" variance (pixel)");
mess.append(QString::number(mean));mess.append("\n");//mess.append(" average error (pixel)\n");
mess.append(QString::number(exec));mess.append("\n");
mess.append(QString::number(errpercoutliergomne));mess.append("\n");
mess.append(QString::number(area));mess.append("\n");
mess.append(QString::number(cantlocalize));mess.append("\n");
QMessageBox::information(this,"End of Simulation",mess);
}
IntervalVector Fnc::eval_vector(const IntervalVector& box) const {
not_implemented("eval_vector");
return IntervalVector(0);
}
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;
}
UnconstrainedLocalSearch::ReturnCode UnconstrainedLocalSearch::minimize(const Vector& x0, Vector& xk, double eps, int max_iter) {
// parameter for the stopping criterion
this->eps = eps;
this->sigma=eps/::sqrt(n+1);
// parameter to update the trust region radius
double gamma00 = 0.05;
double gamma0 = 0.5;
double gamma2 = 2;
// parameters to measure the adequacy between
// the real function and its quadratic approximation.
// If >= mu, adequacy is good => the new iteration is kept
// If >= eta, adequacy is very good => the trust region is expanded.
// If <mu, the old iteration is kept but the approximation of the
// Hessian is updated (and more accurate so the next iteration is
// likely to succeed)
double mu = 0.25;
double eta = 0.75;
// could be initialized to something maybe more relevant
// for the case where x0 is invalid
xk = x0;
Vector xk1=x0; // next iterate
double fk1;
Vector gk1(n); // next gradient
niter = 0; //number of iteration
try {
// cout << " [minimize] xk= " << xk1 << endl;
// Initialize the quadratic approximation at the initial point x0
// like in the quasi-Newton algorithm
double fk=_mid(f.eval(xk1));
Vector gk=_mid(f.gradient(xk1));
Matrix Bk=Matrix::eye(n);
// cout << " [minimize] gk= " << gk << endl;
// initialize the current point
xk=xk1;
// initialization the trust region radius
double Delta = 0.1*gk.norm();
IntervalVector region(n);
BitSet I(BitSet::empty(n));
while ((niter<max_iter)&&(!stop(xk,gk))) {
niter++;
// cout << " [minimize] ITER= " << niter<<" fk= " << fk <<" ||gk||= " << gk.norm() << endl;
// cout << " [minimize] gk= " << gk << endl;
// creates the trust region (intersection with bounding box)
region=box & (IntervalVector(xk).inflate(Delta));
// Find the Generalized Cauchy Point
Vector x_gcp = find_gcp(gk, Bk, xk, region);
// Compute the active set I
I.clear();
// TODO: I should be retrieved from the last line search of find_gcp
for (int i =0; i<n;i++) {
if (fabs(x_gcp[i]-region[i].lb()) <sigma || fabs(x_gcp[i]-region[i].ub()) <sigma)
I.add(i);
}
// Compute the conjugate gradient
xk1 = conj_grad(gk,Bk,xk,x_gcp,region,I);
// Compute the ration of achieved to predicted reduction in the function
fk1 = _mid(f.eval(xk1));
// cout << " [minimize] xk1= " << xk1 <<" fk1 = "<<fk1<<" fk=" <<fk<< endl;
// computing m(xk1)-f(xk) = (xk1-xk)^T gk + 1/2 (xk1-xk)^T Bk (xk1-xzk)
Vector sk = xk1-xk;
double m =(sk*gk + 0.5* (sk*(Bk*sk)));
// cout << " [minimize] sk= " << sk <<" m= "<<m<< endl;
// warning if xk1=xk => sk =0 and m =0.
// In this case, xk = x_gcp = xk1. That means that we have converge
// but due to rounding error in the computation of the stopping criteria,
// we have not detected it. So, we stop the algorithm because
// it is impossible to reach the required precision eps.
if (m==0)
niter=max_iter;
else {
double rhok = (fk1-fk)/m;
// cout << " [minimize] rhok= " << rhok << endl;
// rhok can be <0 if we do not improve the criterion
// update x_k, f(x_k) and g(x_k)
if (rhok > mu) {
gk1 = _mid(f.gradient(xk1));
update_B_SR1(Bk,sk,gk,gk1);
fk = fk1;
xk = xk1;
gk = gk1;
}
// update Delta
if (rhok <= mu) {
if (Delta<sigma) niter = max_iter;
Delta = gamma0*Delta;
}
else if (rhok>=eta) Delta = gamma2*Delta;
// cout << " [minimize] Delta= " << Delta << endl;
}
}
} catch(InvalidPointException&) {
return INVALID_POINT;
}
return niter<max_iter ? SUCCESS : TOO_MANY_ITER;
}
void TestGradient::hansen01() {
IntervalMatrix H(30,30);
Ponts30 p30;
p30.f->hansen_matrix(IntervalVector(30,BOX1),H);
double error=1e-05;
CPPUNIT_ASSERT(almost_eq(H[0][0],Interval(0.485002,0.489002),error));
CPPUNIT_ASSERT(almost_eq(H[0][1],Interval(0.111265,0.115265),error));
CPPUNIT_ASSERT(almost_eq(H[0][2],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(H[0][3],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(H[1][0],Interval(0.14341,0.14741),error));
CPPUNIT_ASSERT(almost_eq(H[1][1],Interval(0.476389,0.480389),error));
CPPUNIT_ASSERT(almost_eq(H[1][4],Interval(-0.14941,-0.14141),error));
CPPUNIT_ASSERT(almost_eq(H[1][5],Interval(-0.482389,-0.474389),error));
CPPUNIT_ASSERT(almost_eq(H[2][2],Interval(-0.343592,-0.339592),error));
CPPUNIT_ASSERT(almost_eq(H[2][3],Interval(0.363124,0.367124),error));
CPPUNIT_ASSERT(almost_eq(H[2][4],Interval(0.337592,0.345592),error));
CPPUNIT_ASSERT(almost_eq(H[2][5],Interval(-0.369124,-0.361124),error));
CPPUNIT_ASSERT(almost_eq(H[3][2],Interval(0.485002,0.489002),error));
CPPUNIT_ASSERT(almost_eq(H[3][3],Interval(0.111265,0.115265),error));
CPPUNIT_ASSERT(almost_eq(H[3][10],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(H[3][11],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(H[4][4],Interval(0.025626,0.029626),error));
CPPUNIT_ASSERT(almost_eq(H[4][5],Interval(0.497236,0.501236),error));
CPPUNIT_ASSERT(almost_eq(H[4][6],Interval(-0.031626,-0.023626),error));
CPPUNIT_ASSERT(almost_eq(H[4][7],Interval(-0.503236,-0.495236),error));
CPPUNIT_ASSERT(almost_eq(H[5][4],Interval(0.485002,0.489002),error));
CPPUNIT_ASSERT(almost_eq(H[5][5],Interval(0.111265,0.115265),error));
CPPUNIT_ASSERT(almost_eq(H[5][8],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(H[5][9],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(H[6][6],Interval(-0.102805,-0.098805),error));
CPPUNIT_ASSERT(almost_eq(H[6][7],Interval(0.487733,0.491733),error));
CPPUNIT_ASSERT(almost_eq(H[6][16],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(H[6][17],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(H[7][6],Interval(0.457376,0.461376),error));
CPPUNIT_ASSERT(almost_eq(H[7][7],Interval(-0.387971,-0.383971),error));
CPPUNIT_ASSERT(almost_eq(H[7][8],Interval(-0.463376,-0.455376),error));
CPPUNIT_ASSERT(almost_eq(H[7][9],Interval(0.381971,0.389971),error));
CPPUNIT_ASSERT(almost_eq(H[8][8],Interval(0.339592,0.343592),error));
CPPUNIT_ASSERT(almost_eq(H[8][9],Interval(-0.367124,-0.363124),error));
CPPUNIT_ASSERT(almost_eq(H[8][10],Interval(-0.345592,-0.337592),error));
CPPUNIT_ASSERT(almost_eq(H[8][11],Interval(0.361124,0.369124),error));
CPPUNIT_ASSERT(almost_eq(H[9][2],Interval(0.14341,0.14741),error));
CPPUNIT_ASSERT(almost_eq(H[9][3],Interval(0.476389,0.480389),error));
CPPUNIT_ASSERT(almost_eq(H[9][8],Interval(-0.14941,-0.14141),error));
CPPUNIT_ASSERT(almost_eq(H[9][9],Interval(-0.482389,-0.474389),error));
CPPUNIT_ASSERT(almost_eq(H[10][10],Interval(5.19121,5.19521),error));
CPPUNIT_ASSERT(almost_eq(H[10][11],Interval(3.00309,3.00709),error));
CPPUNIT_ASSERT(almost_eq(H[10][12],Interval(-5.19721,-5.18921),error));
CPPUNIT_ASSERT(almost_eq(H[10][13],Interval(-3.00909,-3.00109),error));
CPPUNIT_ASSERT(almost_eq(H[11][10],Interval(1.18442,1.18842),error));
CPPUNIT_ASSERT(almost_eq(H[11][11],Interval(9.92737,9.93137),error));
CPPUNIT_ASSERT(almost_eq(H[11][14],Interval(-1.19042,-1.18242),error));
CPPUNIT_ASSERT(almost_eq(H[11][15],Interval(-9.93337,-9.92537),error));
CPPUNIT_ASSERT(almost_eq(H[12][12],Interval(-9.202,-9.198),error));
CPPUNIT_ASSERT(almost_eq(H[12][13],Interval(3.91718,3.92118),error));
CPPUNIT_ASSERT(almost_eq(H[12][26],Interval(9.196,9.204),error));
CPPUNIT_ASSERT(almost_eq(H[12][27],Interval(-3.92318,-3.91518),error));
CPPUNIT_ASSERT(almost_eq(H[13][12],Interval(0.798,0.802),error));
CPPUNIT_ASSERT(almost_eq(H[13][13],Interval(3.91718,3.92118),error));
CPPUNIT_ASSERT(almost_eq(H[13][28],Interval(-0.804,-0.796),error));
CPPUNIT_ASSERT(almost_eq(H[13][29],Interval(-3.92318,-3.91518),error));
CPPUNIT_ASSERT(almost_eq(H[14][14],Interval(-5.19521,-5.19121),error));
CPPUNIT_ASSERT(almost_eq(H[14][15],Interval(-3.00709,-3.00309),error));
CPPUNIT_ASSERT(almost_eq(H[14][26],Interval(5.18921,5.19721),error));
CPPUNIT_ASSERT(almost_eq(H[14][27],Interval(3.00109,3.00909),error));
CPPUNIT_ASSERT(almost_eq(H[15][12],Interval(-4.00879,-4.00479),error));
CPPUNIT_ASSERT(almost_eq(H[15][13],Interval(6.92228,6.92628),error));
CPPUNIT_ASSERT(almost_eq(H[15][14],Interval(4.00279,4.01079),error));
CPPUNIT_ASSERT(almost_eq(H[15][15],Interval(-6.92828,-6.92028),error));
CPPUNIT_ASSERT(almost_eq(H[16][16],Interval(-0.375719,-0.371719),error));
CPPUNIT_ASSERT(almost_eq(H[16][17],Interval(-0.334166,-0.330166),error));
CPPUNIT_ASSERT(almost_eq(H[16][18],Interval(0.369719,0.377719),error));
CPPUNIT_ASSERT(almost_eq(H[16][19],Interval(0.328166,0.336166),error));
CPPUNIT_ASSERT(almost_eq(H[17][16],Interval(-0.102805,-0.098805),error));
CPPUNIT_ASSERT(almost_eq(H[17][17],Interval(0.487733,0.491733),error));
CPPUNIT_ASSERT(almost_eq(H[17][24],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(H[17][25],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(H[18][6],Interval(-0.476524,-0.472524),error));
CPPUNIT_ASSERT(almost_eq(H[18][7],Interval(0.155567,0.159567),error));
CPPUNIT_ASSERT(almost_eq(H[18][18],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(H[18][19],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(H[19][18],Interval(-0.102805,-0.098805),error));
CPPUNIT_ASSERT(almost_eq(H[19][19],Interval(0.487733,0.491733),error));
CPPUNIT_ASSERT(almost_eq(H[19][22],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(H[19][23],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(H[20][20],Interval(0.371719,0.375719),error));
CPPUNIT_ASSERT(almost_eq(H[20][21],Interval(0.330166,0.334166),error));
CPPUNIT_ASSERT(almost_eq(H[20][22],Interval(-0.377719,-0.369719),error));
CPPUNIT_ASSERT(almost_eq(H[20][23],Interval(-0.336166,-0.328166),error));
CPPUNIT_ASSERT(almost_eq(H[21][18],Interval(-0.476524,-0.472524),error));
CPPUNIT_ASSERT(almost_eq(H[21][19],Interval(0.155567,0.159567),error));
CPPUNIT_ASSERT(almost_eq(H[21][20],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(H[21][21],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(H[22][16],Interval(-0.476524,-0.472524),error));
CPPUNIT_ASSERT(almost_eq(H[22][17],Interval(0.155567,0.159567),error));
CPPUNIT_ASSERT(almost_eq(H[22][22],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(H[22][23],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(H[23][22],Interval(0.371719,0.375719),error));
CPPUNIT_ASSERT(almost_eq(H[23][23],Interval(0.330166,0.334166),error));
CPPUNIT_ASSERT(almost_eq(H[23][24],Interval(-0.377719,-0.369719),error));
CPPUNIT_ASSERT(almost_eq(H[23][25],Interval(-0.336166,-0.328166),error));
CPPUNIT_ASSERT(almost_eq(H[24][14],Interval(-2.19099,-2.18699),error));
CPPUNIT_ASSERT(almost_eq(H[24][15],Interval(-8.20081,-8.19681),error));
CPPUNIT_ASSERT(almost_eq(H[24][24],Interval(2.18499,2.19299),error));
CPPUNIT_ASSERT(almost_eq(H[24][25],Interval(8.19481,8.20281),error));
CPPUNIT_ASSERT(almost_eq(H[25][24],Interval(-3.00621,-3.00221),error));
CPPUNIT_ASSERT(almost_eq(H[25][25],Interval(5.19172,5.19572),error));
CPPUNIT_ASSERT(almost_eq(H[25][26],Interval(3.00021,3.00821),error));
CPPUNIT_ASSERT(almost_eq(H[25][27],Interval(-5.19772,-5.18972),error));
CPPUNIT_ASSERT(almost_eq(H[26][26],Interval(9.998,10.002),error));
CPPUNIT_ASSERT(almost_eq(H[26][27],Interval(-0.002,0.002),error));
CPPUNIT_ASSERT(almost_eq(H[26][28],Interval(-10.004,-9.996),error));
CPPUNIT_ASSERT(almost_eq(H[26][29],Interval(-0.004,0.004),error));
CPPUNIT_ASSERT(almost_eq(H[27][27],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(H[28][28],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(H[29][29],Interval(1,1),error));
}
void TestGradient::jac02() {
IntervalMatrix J(30,30);
Ponts30 p30;
p30.f->jacobian(IntervalVector(30,BOX2),J);
double error=1e-5;
CPPUNIT_ASSERT(almost_eq(J[0][0],Interval(0.48632,0.487549),error));
CPPUNIT_ASSERT(almost_eq(J[0][1],Interval(0.112083,0.115061),error));
CPPUNIT_ASSERT(almost_eq(J[0][2],Interval(-0.487549,-0.48632),error));
CPPUNIT_ASSERT(almost_eq(J[0][3],Interval(-0.115061,-0.112083),error));
CPPUNIT_ASSERT(almost_eq(J[1][0],Interval(0.143925,0.146181),error));
CPPUNIT_ASSERT(almost_eq(J[1][1],Interval(0.476964,0.480027),error));
CPPUNIT_ASSERT(almost_eq(J[1][4],Interval(-0.146181,-0.143925),error));
CPPUNIT_ASSERT(almost_eq(J[1][5],Interval(-0.480027,-0.476964),error));
CPPUNIT_ASSERT(almost_eq(J[2][2],Interval(-0.342653,-0.341109),error));
CPPUNIT_ASSERT(almost_eq(J[2][3],Interval(0.363777,0.36607),error));
CPPUNIT_ASSERT(almost_eq(J[2][4],Interval(0.341109,0.342653),error));
CPPUNIT_ASSERT(almost_eq(J[2][5],Interval(-0.36607,-0.363777),error));
CPPUNIT_ASSERT(almost_eq(J[3][2],Interval(0.486787,0.487045),error));
CPPUNIT_ASSERT(almost_eq(J[3][3],Interval(0.113082,0.114187),error));
CPPUNIT_ASSERT(almost_eq(J[3][10],Interval(-0.487045,-0.486787),error));
CPPUNIT_ASSERT(almost_eq(J[3][11],Interval(-0.114187,-0.113082),error));
CPPUNIT_ASSERT(almost_eq(J[4][4],Interval(0.0255079,0.0276924),error));
CPPUNIT_ASSERT(almost_eq(J[4][5],Interval(0.498262,0.500422),error));
CPPUNIT_ASSERT(almost_eq(J[4][6],Interval(-0.0276924,-0.0255079),error));
CPPUNIT_ASSERT(almost_eq(J[4][7],Interval(-0.500422,-0.498262),error));
CPPUNIT_ASSERT(almost_eq(J[5][4],Interval(0.485872,0.487985),error));
CPPUNIT_ASSERT(almost_eq(J[5][5],Interval(0.112593,0.114557),error));
CPPUNIT_ASSERT(almost_eq(J[5][8],Interval(-0.487985,-0.485872),error));
CPPUNIT_ASSERT(almost_eq(J[5][9],Interval(-0.114557,-0.112593),error));
CPPUNIT_ASSERT(almost_eq(J[6][6],Interval(-0.101143,-0.0972429),error));
CPPUNIT_ASSERT(almost_eq(J[6][7],Interval(0.489483,0.490794),error));
CPPUNIT_ASSERT(almost_eq(J[6][16],Interval(0.0972429,0.101143),error));
CPPUNIT_ASSERT(almost_eq(J[6][17],Interval(-0.490794,-0.489483),error));
CPPUNIT_ASSERT(almost_eq(J[7][6],Interval(0.459466,0.461192),error));
CPPUNIT_ASSERT(almost_eq(J[7][7],Interval(-0.38664,-0.384894),error));
CPPUNIT_ASSERT(almost_eq(J[7][8],Interval(-0.461192,-0.459466),error));
CPPUNIT_ASSERT(almost_eq(J[7][9],Interval(0.384894,0.38664),error));
CPPUNIT_ASSERT(almost_eq(J[8][8],Interval(0.341455,0.342282),error));
CPPUNIT_ASSERT(almost_eq(J[8][9],Interval(-0.365251,-0.364476),error));
CPPUNIT_ASSERT(almost_eq(J[8][10],Interval(-0.342282,-0.341455),error));
CPPUNIT_ASSERT(almost_eq(J[8][11],Interval(0.364476,0.365251),error));
CPPUNIT_ASSERT(almost_eq(J[9][2],Interval(0.144505,0.145591),error));
CPPUNIT_ASSERT(almost_eq(J[9][3],Interval(0.477559,0.479438),error));
CPPUNIT_ASSERT(almost_eq(J[9][8],Interval(-0.145591,-0.144505),error));
CPPUNIT_ASSERT(almost_eq(J[9][9],Interval(-0.479438,-0.477559),error));
CPPUNIT_ASSERT(almost_eq(J[10][10],Interval(5.19321,5.19321),error));
CPPUNIT_ASSERT(almost_eq(J[10][11],Interval(3.00509,3.00509),error));
CPPUNIT_ASSERT(almost_eq(J[10][12],Interval(-5.19321,-5.19321),error));
CPPUNIT_ASSERT(almost_eq(J[10][13],Interval(-3.00509,-3.00509),error));
CPPUNIT_ASSERT(almost_eq(J[11][10],Interval(1.18642,1.18642),error));
CPPUNIT_ASSERT(almost_eq(J[11][11],Interval(9.92937,9.92937),error));
CPPUNIT_ASSERT(almost_eq(J[11][14],Interval(-1.18642,-1.18642),error));
CPPUNIT_ASSERT(almost_eq(J[11][15],Interval(-9.92937,-9.92937),error));
CPPUNIT_ASSERT(almost_eq(J[12][12],Interval(-9.2,-9.2),error));
CPPUNIT_ASSERT(almost_eq(J[12][13],Interval(3.91918,3.91918),error));
CPPUNIT_ASSERT(almost_eq(J[12][26],Interval(9.2,9.2),error));
CPPUNIT_ASSERT(almost_eq(J[12][27],Interval(-3.91918,-3.91918),error));
CPPUNIT_ASSERT(almost_eq(J[13][12],Interval(0.8,0.8),error));
CPPUNIT_ASSERT(almost_eq(J[13][13],Interval(3.91918,3.91918),error));
CPPUNIT_ASSERT(almost_eq(J[13][28],Interval(-0.8,-0.8),error));
CPPUNIT_ASSERT(almost_eq(J[13][29],Interval(-3.91918,-3.91918),error));
CPPUNIT_ASSERT(almost_eq(J[14][14],Interval(-5.19321,-5.19321),error));
CPPUNIT_ASSERT(almost_eq(J[14][15],Interval(-3.00509,-3.00509),error));
CPPUNIT_ASSERT(almost_eq(J[14][26],Interval(5.19321,5.19321),error));
CPPUNIT_ASSERT(almost_eq(J[14][27],Interval(3.00509,3.00509),error));
CPPUNIT_ASSERT(almost_eq(J[15][12],Interval(-4.00679,-4.00679),error));
CPPUNIT_ASSERT(almost_eq(J[15][13],Interval(6.92428,6.92428),error));
CPPUNIT_ASSERT(almost_eq(J[15][14],Interval(4.00679,4.00679),error));
CPPUNIT_ASSERT(almost_eq(J[15][15],Interval(-6.92428,-6.92428),error));
CPPUNIT_ASSERT(almost_eq(J[16][16],Interval(-0.378006,-0.372188),error));
CPPUNIT_ASSERT(almost_eq(J[16][17],Interval(-0.334222,-0.329547),error));
CPPUNIT_ASSERT(almost_eq(J[16][18],Interval(0.372188,0.378006),error));
CPPUNIT_ASSERT(almost_eq(J[16][19],Interval(0.329547,0.334222),error));
CPPUNIT_ASSERT(almost_eq(J[17][16],Interval(-0.102688,-0.0996866),error));
CPPUNIT_ASSERT(almost_eq(J[17][17],Interval(0.489621,0.489962),error));
CPPUNIT_ASSERT(almost_eq(J[17][24],Interval(0.0996866,0.102688),error));
CPPUNIT_ASSERT(almost_eq(J[17][25],Interval(-0.489962,-0.489621),error));
CPPUNIT_ASSERT(almost_eq(J[18][6],Interval(-0.476148,-0.472432),error));
CPPUNIT_ASSERT(almost_eq(J[18][7],Interval(0.155602,0.160906),error));
CPPUNIT_ASSERT(almost_eq(J[18][18],Interval(0.472432,0.476148),error));
CPPUNIT_ASSERT(almost_eq(J[18][19],Interval(-0.160906,-0.155602),error));
CPPUNIT_ASSERT(almost_eq(J[19][18],Interval(-0.102939,-0.0971202),error));
CPPUNIT_ASSERT(almost_eq(J[19][19],Interval(0.485907,0.493623),error));
CPPUNIT_ASSERT(almost_eq(J[19][22],Interval(0.0971202,0.102939),error));
CPPUNIT_ASSERT(almost_eq(J[19][23],Interval(-0.493623,-0.485907),error));
CPPUNIT_ASSERT(almost_eq(J[20][20],Interval(0.366904,0.381292),error));
CPPUNIT_ASSERT(almost_eq(J[20][21],Interval(0.320063,0.34306),error));
CPPUNIT_ASSERT(almost_eq(J[20][22],Interval(-0.381292,-0.366904),error));
CPPUNIT_ASSERT(almost_eq(J[20][23],Interval(-0.34306,-0.320063),error));
CPPUNIT_ASSERT(almost_eq(J[21][18],Interval(-0.481229,-0.467026),error));
CPPUNIT_ASSERT(almost_eq(J[21][19],Interval(0.146229,0.170178),error));
CPPUNIT_ASSERT(almost_eq(J[21][20],Interval(0.467026,0.481229),error));
CPPUNIT_ASSERT(almost_eq(J[21][21],Interval(-0.170178,-0.146229),error));
CPPUNIT_ASSERT(almost_eq(J[22][16],Interval(-0.478128,-0.472125),error));
CPPUNIT_ASSERT(almost_eq(J[22][17],Interval(0.156019,0.159742),error));
CPPUNIT_ASSERT(almost_eq(J[22][22],Interval(0.472125,0.478128),error));
CPPUNIT_ASSERT(almost_eq(J[22][23],Interval(-0.159742,-0.156019),error));
CPPUNIT_ASSERT(almost_eq(J[23][22],Interval(0.372438,0.37544),error));
CPPUNIT_ASSERT(almost_eq(J[23][23],Interval(0.33022,0.333601),error));
CPPUNIT_ASSERT(almost_eq(J[23][24],Interval(-0.37544,-0.372438),error));
CPPUNIT_ASSERT(almost_eq(J[23][25],Interval(-0.333601,-0.33022),error));
CPPUNIT_ASSERT(almost_eq(J[24][14],Interval(-2.18899,-2.18899),error));
CPPUNIT_ASSERT(almost_eq(J[24][15],Interval(-8.19881,-8.19881),error));
CPPUNIT_ASSERT(almost_eq(J[24][24],Interval(2.18899,2.18899),error));
CPPUNIT_ASSERT(almost_eq(J[24][25],Interval(8.19881,8.19881),error));
CPPUNIT_ASSERT(almost_eq(J[25][24],Interval(-3.00421,-3.00421),error));
CPPUNIT_ASSERT(almost_eq(J[25][25],Interval(5.19372,5.19372),error));
CPPUNIT_ASSERT(almost_eq(J[25][26],Interval(3.00421,3.00421),error));
CPPUNIT_ASSERT(almost_eq(J[25][27],Interval(-5.19372,-5.19372),error));
CPPUNIT_ASSERT(almost_eq(J[26][26],Interval(10,10),error));
CPPUNIT_ASSERT(almost_eq(J[26][28],Interval(-10,-10),error));
CPPUNIT_ASSERT(almost_eq(J[27][27],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(J[28][28],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(J[29][29],Interval(1,1),error));
}
void TestGradient::jac01() {
IntervalMatrix J(30,30);
Ponts30 p30;
p30.f->jacobian(IntervalVector(30,BOX1),J);
double error=1e-5;
CPPUNIT_ASSERT(almost_eq(J[0][0],Interval(0.483002,0.491002),error));
CPPUNIT_ASSERT(almost_eq(J[0][1],Interval(0.109265,0.117265),error));
CPPUNIT_ASSERT(almost_eq(J[0][2],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(J[0][3],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(J[1][0],Interval(0.14141,0.14941),error));
CPPUNIT_ASSERT(almost_eq(J[1][1],Interval(0.474389,0.482389),error));
CPPUNIT_ASSERT(almost_eq(J[1][4],Interval(-0.14941,-0.14141),error));
CPPUNIT_ASSERT(almost_eq(J[1][5],Interval(-0.482389,-0.474389),error));
CPPUNIT_ASSERT(almost_eq(J[2][2],Interval(-0.345592,-0.337592),error));
CPPUNIT_ASSERT(almost_eq(J[2][3],Interval(0.361124,0.369124),error));
CPPUNIT_ASSERT(almost_eq(J[2][4],Interval(0.337592,0.345592),error));
CPPUNIT_ASSERT(almost_eq(J[2][5],Interval(-0.369124,-0.361124),error));
CPPUNIT_ASSERT(almost_eq(J[3][2],Interval(0.483002,0.491002),error));
CPPUNIT_ASSERT(almost_eq(J[3][3],Interval(0.109265,0.117265),error));
CPPUNIT_ASSERT(almost_eq(J[3][10],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(J[3][11],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(J[4][4],Interval(0.023626,0.031626),error));
CPPUNIT_ASSERT(almost_eq(J[4][5],Interval(0.495236,0.503236),error));
CPPUNIT_ASSERT(almost_eq(J[4][6],Interval(-0.031626,-0.023626),error));
CPPUNIT_ASSERT(almost_eq(J[4][7],Interval(-0.503236,-0.495236),error));
CPPUNIT_ASSERT(almost_eq(J[5][4],Interval(0.483002,0.491002),error));
CPPUNIT_ASSERT(almost_eq(J[5][5],Interval(0.109265,0.117265),error));
CPPUNIT_ASSERT(almost_eq(J[5][8],Interval(-0.491002,-0.483002),error));
CPPUNIT_ASSERT(almost_eq(J[5][9],Interval(-0.117265,-0.109265),error));
CPPUNIT_ASSERT(almost_eq(J[6][6],Interval(-0.104805,-0.096805),error));
CPPUNIT_ASSERT(almost_eq(J[6][7],Interval(0.485733,0.493733),error));
CPPUNIT_ASSERT(almost_eq(J[6][16],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(J[6][17],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(J[7][6],Interval(0.455376,0.463376),error));
CPPUNIT_ASSERT(almost_eq(J[7][7],Interval(-0.389971,-0.381971),error));
CPPUNIT_ASSERT(almost_eq(J[7][8],Interval(-0.463376,-0.455376),error));
CPPUNIT_ASSERT(almost_eq(J[7][9],Interval(0.381971,0.389971),error));
CPPUNIT_ASSERT(almost_eq(J[8][8],Interval(0.337592,0.345592),error));
CPPUNIT_ASSERT(almost_eq(J[8][9],Interval(-0.369124,-0.361124),error));
CPPUNIT_ASSERT(almost_eq(J[8][10],Interval(-0.345592,-0.337592),error));
CPPUNIT_ASSERT(almost_eq(J[8][11],Interval(0.361124,0.369124),error));
CPPUNIT_ASSERT(almost_eq(J[9][2],Interval(0.14141,0.14941),error));
CPPUNIT_ASSERT(almost_eq(J[9][3],Interval(0.474389,0.482389),error));
CPPUNIT_ASSERT(almost_eq(J[9][8],Interval(-0.14941,-0.14141),error));
CPPUNIT_ASSERT(almost_eq(J[9][9],Interval(-0.482389,-0.474389),error));
CPPUNIT_ASSERT(almost_eq(J[10][10],Interval(5.18921,5.19721),error));
CPPUNIT_ASSERT(almost_eq(J[10][11],Interval(3.00109,3.00909),error));
CPPUNIT_ASSERT(almost_eq(J[10][12],Interval(-5.19721,-5.18921),error));
CPPUNIT_ASSERT(almost_eq(J[10][13],Interval(-3.00909,-3.00109),error));
CPPUNIT_ASSERT(almost_eq(J[11][10],Interval(1.18242,1.19042),error));
CPPUNIT_ASSERT(almost_eq(J[11][11],Interval(9.92537,9.93337),error));
CPPUNIT_ASSERT(almost_eq(J[11][14],Interval(-1.19042,-1.18242),error));
CPPUNIT_ASSERT(almost_eq(J[11][15],Interval(-9.93337,-9.92537),error));
CPPUNIT_ASSERT(almost_eq(J[12][12],Interval(-9.204,-9.196),error));
CPPUNIT_ASSERT(almost_eq(J[12][13],Interval(3.91518,3.92318),error));
CPPUNIT_ASSERT(almost_eq(J[12][26],Interval(9.196,9.204),error));
CPPUNIT_ASSERT(almost_eq(J[12][27],Interval(-3.92318,-3.91518),error));
CPPUNIT_ASSERT(almost_eq(J[13][12],Interval(0.796,0.804),error));
CPPUNIT_ASSERT(almost_eq(J[13][13],Interval(3.91518,3.92318),error));
CPPUNIT_ASSERT(almost_eq(J[13][28],Interval(-0.804,-0.796),error));
CPPUNIT_ASSERT(almost_eq(J[13][29],Interval(-3.92318,-3.91518),error));
CPPUNIT_ASSERT(almost_eq(J[14][14],Interval(-5.19721,-5.18921),error));
CPPUNIT_ASSERT(almost_eq(J[14][15],Interval(-3.00909,-3.00109),error));
CPPUNIT_ASSERT(almost_eq(J[14][26],Interval(5.18921,5.19721),error));
CPPUNIT_ASSERT(almost_eq(J[14][27],Interval(3.00109,3.00909),error));
CPPUNIT_ASSERT(almost_eq(J[15][12],Interval(-4.01079,-4.00279),error));
CPPUNIT_ASSERT(almost_eq(J[15][13],Interval(6.92028,6.92828),error));
CPPUNIT_ASSERT(almost_eq(J[15][14],Interval(4.00279,4.01079),error));
CPPUNIT_ASSERT(almost_eq(J[15][15],Interval(-6.92828,-6.92028),error));
CPPUNIT_ASSERT(almost_eq(J[16][16],Interval(-0.377719,-0.369719),error));
CPPUNIT_ASSERT(almost_eq(J[16][17],Interval(-0.336166,-0.328166),error));
CPPUNIT_ASSERT(almost_eq(J[16][18],Interval(0.369719,0.377719),error));
CPPUNIT_ASSERT(almost_eq(J[16][19],Interval(0.328166,0.336166),error));
CPPUNIT_ASSERT(almost_eq(J[17][16],Interval(-0.104805,-0.096805),error));
CPPUNIT_ASSERT(almost_eq(J[17][17],Interval(0.485733,0.493733),error));
CPPUNIT_ASSERT(almost_eq(J[17][24],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(J[17][25],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(J[18][6],Interval(-0.478524,-0.470524),error));
CPPUNIT_ASSERT(almost_eq(J[18][7],Interval(0.153567,0.161567),error));
CPPUNIT_ASSERT(almost_eq(J[18][18],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(J[18][19],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(J[19][18],Interval(-0.104805,-0.096805),error));
CPPUNIT_ASSERT(almost_eq(J[19][19],Interval(0.485733,0.493733),error));
CPPUNIT_ASSERT(almost_eq(J[19][22],Interval(0.096805,0.104805),error));
CPPUNIT_ASSERT(almost_eq(J[19][23],Interval(-0.493733,-0.485733),error));
CPPUNIT_ASSERT(almost_eq(J[20][20],Interval(0.369719,0.377719),error));
CPPUNIT_ASSERT(almost_eq(J[20][21],Interval(0.328166,0.336166),error));
CPPUNIT_ASSERT(almost_eq(J[20][22],Interval(-0.377719,-0.369719),error));
CPPUNIT_ASSERT(almost_eq(J[20][23],Interval(-0.336166,-0.328166),error));
CPPUNIT_ASSERT(almost_eq(J[21][18],Interval(-0.478524,-0.470524),error));
CPPUNIT_ASSERT(almost_eq(J[21][19],Interval(0.153567,0.161567),error));
CPPUNIT_ASSERT(almost_eq(J[21][20],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(J[21][21],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(J[22][16],Interval(-0.478524,-0.470524),error));
CPPUNIT_ASSERT(almost_eq(J[22][17],Interval(0.153567,0.161567),error));
CPPUNIT_ASSERT(almost_eq(J[22][22],Interval(0.470524,0.478524),error));
CPPUNIT_ASSERT(almost_eq(J[22][23],Interval(-0.161567,-0.153567),error));
CPPUNIT_ASSERT(almost_eq(J[23][22],Interval(0.369719,0.377719),error));
CPPUNIT_ASSERT(almost_eq(J[23][23],Interval(0.328166,0.336166),error));
CPPUNIT_ASSERT(almost_eq(J[23][24],Interval(-0.377719,-0.369719),error));
CPPUNIT_ASSERT(almost_eq(J[23][25],Interval(-0.336166,-0.328166),error));
CPPUNIT_ASSERT(almost_eq(J[24][14],Interval(-2.19299,-2.18499),error));
CPPUNIT_ASSERT(almost_eq(J[24][15],Interval(-8.20281,-8.19481),error));
CPPUNIT_ASSERT(almost_eq(J[24][24],Interval(2.18499,2.19299),error));
CPPUNIT_ASSERT(almost_eq(J[24][25],Interval(8.19481,8.20281),error));
CPPUNIT_ASSERT(almost_eq(J[25][24],Interval(-3.00821,-3.00021),error));
CPPUNIT_ASSERT(almost_eq(J[25][25],Interval(5.18972,5.19772),error));
CPPUNIT_ASSERT(almost_eq(J[25][26],Interval(3.00021,3.00821),error));
CPPUNIT_ASSERT(almost_eq(J[25][27],Interval(-5.19772,-5.18972),error));
CPPUNIT_ASSERT(almost_eq(J[26][26],Interval(9.996,10.004),error));
CPPUNIT_ASSERT(almost_eq(J[26][27],Interval(-0.004,0.004),error));
CPPUNIT_ASSERT(almost_eq(J[26][28],Interval(-10.004,-9.996),error));
CPPUNIT_ASSERT(almost_eq(J[26][29],Interval(-0.004,0.004),error));
CPPUNIT_ASSERT(almost_eq(J[27][27],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(J[28][28],Interval(1,1),error));
CPPUNIT_ASSERT(almost_eq(J[29][29],Interval(1,1),error));
}
void TestCtcNotIn::vector03() {
double vec[2][2]={{-2,0},{-2,0}};
check_not_in(2,IntervalVector(2,vec),IntervalVector(2,vec));
}
void TestCtcNotIn::vector02() {
double input[2][2]={{-0.99,0},{-2,0}};
double expected[2][2]={{-0.99,0},{-2,-1}};
check_not_in(2,IntervalVector(2,input),IntervalVector(2,expected));
}
void TestCtcNotIn::vector01() {
double vec[2][2]={{-0.99,0.99},{-0.99,0.99}};
check_not_in(2,IntervalVector(2,vec),IntervalVector::empty(2));
}
void TestCtcNotIn::check_not_in(const Interval& x_input, const Interval& x_expected) {
check_not_in(1, IntervalVector(1,x_input), IntervalVector(1,x_expected));
}
int LinearizerDuality::linearize(const IntervalVector& box, LPSolver& lp_solver, BoxProperties& prop) {
// ========= get active constraints ===========
/* Using system cache seems not interesting. */
//BxpSystemCache* cache=(BxpSystemCache*) prop[BxpSystemCache::get_id(sys)];
BxpSystemCache* cache=NULL;
//--------------------------------------------------------------------------
BitSet* active;
if (cache!=NULL) {
active = &cache->active_ctrs();
} else {
active = new BitSet(sys.active_ctrs(box));
}
// ============================================
size_t n = sys.nb_var;
size_t m = sys.f_ctrs.image_dim();
size_t n_total = n + m*n;
int nb_ctr=0; // number of inequalities added in the LP solver
// BxpLinearRelaxArgMin* argmin=(BxpLinearRelaxArgMin*) prop[BxpLinearRelaxArgMin::get_id(sys)];
//
// if (argmin && argmin->argmin()) {
// pt=*argmin->argmin();
// } else
pt=box.mid();
if (!active->empty()) {
//IntervalMatrix J=cache? cache->active_ctrs_jacobian() : sys.f_ctrs.jacobian(box,active);
//IntervalMatrix J=sys.f_ctrs.jacobian(box,*active);
IntervalMatrix J(active->size(),n); // derivatives over the box
sys.f_ctrs.hansen_matrix(box,pt,J,*active);
if (J.is_empty()) {
if (cache==NULL) delete active;
return -1;
}
// the evaluation of the constraints in the point
IntervalVector gx(sys.f_ctrs.eval_vector(pt,*active));
if (gx.is_empty()) {
if (cache==NULL) delete active;
return 0;
}
int i=0; // counter of active constraints
for (BitSet::iterator c=active->begin(); c!=active->end(); ++c, i++) {
if (!sys.f_ctrs.deriv_calculator().is_linear[c]) {
for (size_t j=0; j<n; j++) {
Vector row(n_total,0.0);
row[j]=1;
row[n + c*n +j]=1;
double rhs = pt[j] - lp_solver.get_epsilon();
lp_solver.add_constraint(row, LEQ, rhs);
nb_ctr++;
}
}
Vector row(n_total,0.0);
row.put(0,J[i].lb());
IntervalVector gl(J[i].lb());
Vector diam_correctly_rounded = (IntervalVector(J[i].ub())-gl).lb();
for (size_t j=0; j<n; j++) {
if (diam_correctly_rounded[j]<0)
ibex_error("negative diameter");
}
row.put(n + c*n,-diam_correctly_rounded);
double rhs = (-gx[i] + (gl*pt)).lb()- lp_solver.get_epsilon();
lp_solver.add_constraint(row, LEQ, rhs);
nb_ctr++;
}
}
if (cache==NULL) delete active;
return nb_ctr;
}
