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; }