示例#1
0
void Manifold::read_signature(ifstream& f) {
	char* sig=new char[SIGNATURE_LENGTH];
	f.read(sig, SIGNATURE_LENGTH*sizeof(char));
	if (f.eof()) ibex_error("[manifold]: unexpected end of file.");
	if (strcmp(sig,SIGNATURE)!=0)
	ibex_error("[manifold]: not a \"manifold\" file.");
	read_int(f); // manifold version
}
示例#2
0
void Manifold::write(const char* filename) const {
	ofstream f;

	f.open(filename, ios::out | ios::binary);

	if (f.fail())
		ibex_error("[manifold]: cannot create output file.\n");

	write_signature(f);
	write_int(f,n);
	write_int(f,m);
	write_int(f,nb_ineq);
	write_int(f,status);
	write_int(f,inner.size());
	write_int(f,boundary.size());
	write_int(f,unknown.size());
	write_int(f,pending.size());
	write_double(f,time);
	write_int(f,nb_cells);

	for (vector<SolverOutputBox>::const_iterator it=inner.begin(); it!=inner.end(); it++)
		write_output_box(f,*it);

	for (vector<SolverOutputBox>::const_iterator it=boundary.begin(); it!=boundary.end(); it++)
		write_output_box(f,*it);

	for (vector<SolverOutputBox>::const_iterator it=unknown.begin(); it!=unknown.end(); it++)
		write_output_box(f,*it);

	for (vector<SolverOutputBox>::const_iterator it=pending.begin(); it!=pending.end(); it++)
		write_output_box(f,*it);

	f.close();
}
示例#3
0
void Gradient::jacobian(const Array<Domain>& d, IntervalMatrix& J) {

	if (!f.expr().dim.is_vector()) {
		ibex_error("Cannot called \"jacobian\" on a real-valued function");
	}

	int m=f.expr().dim.vec_size();

	// calculate the gradient of each component of f
	for (int i=0; i<m; i++) {
		const Function* fi=dynamic_cast<const Function*>(&f[i]);
		if (fi!=NULL) {
			// if this is a Function object we can
			// directly calculate the gradient with d
			fi->deriv_calculator().gradient(d,J[i]);
		} else {
			// otherwise we must give a box in argument
			// TODO add gradient with Array<Domain> in argument
			// in Function interface?
			// But, for the moment, cannot happen, because
			// this function is called by apply_bwd.
			IntervalVector box(f.nb_var());
			load(box,d);
			f[i].gradient(box,J[i]);
			if (J[i].is_empty()) { J.set_empty(); return; }
		}
	}
}
示例#4
0
ofstream* CovOptimData::write(const char* filename, const CovOptimData& cov, std::stack<unsigned int>& format_id, std::stack<unsigned int>& format_version) {

	format_id.push(subformat_number);
	format_version.push(FORMAT_VERSION);

	ofstream* f = CovList::write(filename, cov, format_id, format_version);

	write_vars   (*f, cov.var_names());
	write_pos_int(*f, cov.optimizer_status());
	write_pos_int(*f, (uint32_t) cov.is_extended_space());
	write_double (*f, cov.uplo());
	write_double (*f, cov.uplo_of_epsboxes());
	write_double (*f, cov.loup());

	if (!cov.loup_point().is_empty()) {
		unsigned int nb_var   = cov.is_extended_space() ? cov.n-1 : cov.n;
		// TODO: we assume here that the goal var is n-1
		if (cov[0].subvector(0,nb_var-1)!=cov.loup_point()) {
			ibex_error("[CovOptimData] the first box in the list must be the 'loup-point'.");
		}
		write_pos_int(*f, (uint32_t) 1);
	} else {
		write_pos_int(*f, (uint32_t) 0);
	}

	write_double(*f, cov.time());
	write_pos_int   (*f, cov.nb_cells());

	return f;
}
示例#5
0
SolverOutputBox Manifold::read_output_box(ifstream& f) {

	IntervalVector box(n);

	for (int j=0; j<n; j++) {
		double lb=read_double(f);
		double ub=read_double(f);
		box[j]=Interval(lb,ub);
	}

	int _status=read_int(f);
	if (_status<0 || _status>=4) {
		ibex_error("[manifold]: bad input file (bad status code).");
	}

	SolverOutputBox sol(n);

	switch(_status) {
	case 0: (SolverOutputBox::sol_status&) sol.status = SolverOutputBox::INNER; break;
	case 1: (SolverOutputBox::sol_status&) sol.status = SolverOutputBox::BOUNDARY; break;
	case 2: (SolverOutputBox::sol_status&) sol.status = SolverOutputBox::UNKNOWN; break;
	case 3: (SolverOutputBox::sol_status&) sol.status = SolverOutputBox::PENDING; break;
	}

	sol._existence = box;

	if (m<n) {
		if (_status<=1) {
			BitSet params(n);
			for (int j=0; j<n-m; j++) {
				int v=read_int(f);
				if (v<1 || v>n) {
					ibex_error("[manifold]: bad input file (bad parameter index)");
				}
				params.add(v-1); // index starting from 1 in the raw format
			}

			sol.varset = new VarSet(n,params,false);
		}
	}
	return sol;
}
示例#6
0
void CovOptimData::read_vars(ifstream& f, size_t n, vector<string>& var_names) {
	char x;
	for (size_t i=0; i<n; i++) {
		stringstream s;
		do {
			f.read(&x, sizeof(char));
			if (f.eof()) ibex_error("[CovManifold]: unexpected end of file.");
			if (x!='\0') s << x;
		} while(x!='\0');
		var_names.push_back(s.str());
	}
}
示例#7
0
void Manifold::load(const char* filename) {
	ifstream f;

	f.open(filename, ios::in | ios::binary);

	if (f.fail()) ibex_error("[manifold]: cannot open input file.\n");

	read_signature(f);

	if (read_int(f)!=n) ibex_error("[manifold]: bad input file (number of variables does not match).");

	if (read_int(f)!=m) ibex_error("[manifold]: bad input file (number of equalities does not match).");

	if (read_int(f)!=nb_ineq) ibex_error("[manifold]: bad input file (number of inequalities does not match).");

	read_int(f); // status

	int nb_inner = read_int(f);
	int nb_boundary = read_int(f);
	int nb_unknown = read_int(f);
	int nb_pending = read_int(f);
	int nb_sols = nb_inner + nb_boundary + nb_unknown + nb_pending;

	time = read_double(f);
	nb_cells = read_int(f);

	IntervalVector box(n);
	for (int i=0; i<nb_sols; i++) {
		SolverOutputBox sol = read_output_box(f);

		switch(sol.status) {
		case 0: inner.push_back(sol); break;
		case 1: boundary.push_back(sol); break;
		case 2: unknown.push_back(sol); break;
		case 3: pending.push_back(sol); break;
		}
	}
}
void CtcFirstOrderTest::contract(IntervalVector& box, ContractContext& context) {
	if(box.size() == 2) {
		return;
	}
	BxpNodeData* node_data = (BxpNodeData*) context.prop[BxpNodeData::id];
	if(node_data == nullptr) {
		ibex_error("CtcFirstOrderTest: BxpNodeData must be set");
	}
	vector<IntervalVector> gradients;
	for (int i = 0; i < system_.normal_constraints_.size() - 1; ++i) {
		if (!system_.normal_constraints_[i].isSatisfied(box)) {
			gradients.push_back(system_.normal_constraints_[i].gradient(box));
		}
	}
	for (int i = 0; i < system_.sic_constraints_.size(); ++i) {
		if (!system_.sic_constraints_[i].isSatisfied(box, node_data->sic_constraints_caches[i])) {
			gradients.push_back(system_.sic_constraints_[i].gradient(box, node_data->sic_constraints_caches[i]));
		}
	}

	// Without the goal variable
	IntervalMatrix matrix(nb_var - 1, gradients.size() + 1);
	matrix.set_col(0, system_.goal_function_->gradient(box.subvector(0, nb_var - 2)));
	for (int i = 0; i < gradients.size(); ++i) {
		matrix.set_col(i + 1, gradients[i].subvector(0, nb_var - 2));
	}
	bool testfailed = true;
	if (matrix.nb_cols() == 1) {
		if (matrix.col(0).contains(Vector::zeros(nb_var - 2))) {
			testfailed = false;
		}
	} else {
		int* pr = new int[matrix.nb_rows()];
		int* pc = new int[matrix.nb_cols()];
		IntervalMatrix LU(matrix.nb_rows(), matrix.nb_cols());
		testfailed = true;
		try {
			interval_LU(matrix, LU, pr, pc);
		} catch(SingularMatrixException&) {
			testfailed = false;
		}
		delete[] pr;
		delete[] pc;
	}
	if(testfailed) {
		box.set_empty();
	}

}
示例#9
0
ifstream* CovOptimData::read(const char* filename, CovOptimData& cov, std::stack<unsigned int>& format_id, std::stack<unsigned int>& format_version) {

	ifstream* f = CovList::read(filename, cov, format_id, format_version);

	if (format_id.empty() || format_id.top()!=subformat_number || format_version.top()!=FORMAT_VERSION) {
		cov.data->_optim_optimizer_status = (unsigned int) Optimizer::SUCCESS;
		cov.data->_optim_is_extended_space = false;
		cov.data->_optim_uplo = NEG_INFINITY;
		cov.data->_optim_loup = POS_INFINITY;
		cov.data->_optim_loup_point.resize((int) cov.n);
		cov.data->_optim_loup_point = IntervalVector::empty(cov.n);
		cov.data->_optim_time = -1;
		cov.data->_optim_nb_cells = 0;
	}
	else {
		format_id.pop();
		format_version.pop();

		read_vars(*f, cov.n, cov.data->_optim_var_names);

		unsigned int status = read_pos_int(*f);

		switch (status) {
		case 0: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::SUCCESS;           break;
		case 1: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::INFEASIBLE;        break;
		case 2: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::NO_FEASIBLE_FOUND; break;
		case 3: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::UNBOUNDED_OBJ;     break;
		case 4: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::TIME_OUT;     		break;
		case 5: cov.data->_optim_optimizer_status = (unsigned int) Optimizer::UNREACHED_PREC;    break;
		default: ibex_error("[CovOptimData]: invalid optimizer status.");
		}

		cov.data->_optim_is_extended_space = (bool) read_pos_int(*f);
		cov.data->_optim_uplo              = read_double(*f);
		cov.data->_optim_uplo_of_epsboxes  = read_double(*f);
		cov.data->_optim_loup              = read_double(*f);

		unsigned int loup_found   = read_pos_int(*f);
		unsigned int nb_var   = cov.is_extended_space() ? cov.n-1 : cov.n;
		cov.data->_optim_loup_point.resize((int) nb_var);
		// TODO: we assume here that the goal var is n-1
		cov.data->_optim_loup_point 		  = loup_found==1? cov[0].subvector(0,nb_var-1) : IntervalVector::empty(nb_var);

		cov.data->_optim_time              = read_double(*f);
		cov.data->_optim_nb_cells          = read_pos_int(*f);
	}

	return f;
}
void CtcBisectActiveParameters::contract(IntervalVector& box, ContractContext& context) {
    lp_solver_.clean_ctrs();
	lp_solver_.set_bounds(box);
	lp_solver_.set_obj_var(sys_.ext_nb_var - 1, 1.0);
	lp_solver_.set_sense(LPSolver::MINIMIZE);
	if(linearizer_.linearize(box, lp_solver_, context.prop) < 0) {
		return;
	}
	//lp_solver_.write_file();

	auto return_code = lp_solver_.solve();
	if (return_code != LPSolver::Status_Sol::OPTIMAL) {
		return;
	}
	//Vector sol(box.mid());
	Vector sol = lp_solver_.get_primal_sol();
	Vector sol_without_goal = sol.subvector(0, sys_.nb_var - 1);
	//Vector dual(lp_solver_.get_nb_rows());
	Vector dual = lp_solver_.get_dual_sol();
	//IntervalVector rhs(dual.size());
	IntervalVector rhs = lp_solver_.get_lhs_rhs();
	//Matrix A(lp_solver_.get_nb_rows(), system_.ext_nb_var);
	Matrix A = lp_solver_.get_rows();

	BxpNodeData* node_data = (BxpNodeData*) context.prop[BxpNodeData::id];
	if(node_data == nullptr) {
		ibex_error("CtcBisectActiveParameters: BxpNodeData must be set");
	}
	blankenship(sol, sys_, node_data);
	// After variables, linearized goal and normal constraints
	/*int current_row = sys_.ext_nb_var+sys_.normal_constraints_.size();
	for(int constraint_index = 0; constraint_index < sys_.sic_constraints_.size(); ++constraint_index) {
		auto& constraint = sys_.sic_constraints_[constraint_index];
		//auto& cache = constraint.cache_->parameter_caches_;
		auto& cache = node_data->sic_constraints_caches[constraint_index];
		int caches_size = cache.parameter_caches_.size();
		for(int i = 0; i < caches_size; ++i) {
			auto parameter_box = cache.parameter_caches_[i].parameter_box;
			//if(Interval(dual[current_row]).inflate(1e-10).contains(0)) {
			if(constraint.evaluate(sol, parameter_box).ub() > 0) {
				auto bisectList = bisectAllDim(parameter_box);
				cache.parameter_caches_[i] = _createNewCache(constraint, box, bisectList[0]);
				for (int j = 1; j < bisectList.size(); ++j)
					cache.parameter_caches_.emplace_back(_createNewCache(constraint, box, bisectList[j]));
			}
			current_row++;
		}
	}*/
}
示例#11
0
void Manifold::write_txt(const char* filename, bool MMA) const {
	ofstream file;

	file.open(filename, ios::out);

	if (file.fail())
		ibex_error("[manifold]: cannot create output file.\n");

	// character to separate elements in a list
	char s=MMA? ',' : ' ';
	// character that ends a list
	//char e=MMA? ' ' : '}';

	if (MMA) file << "{{";
	file << n << s << m << s << nb_ineq;
	if (MMA) file << "},"; else file << '\n';
	file << status;
	if (MMA) file << ",{"; else file << '\n';
	file << inner.size() << s << boundary.size() << s << unknown.size() << s << pending.size();
	if (MMA) file << "},{"; else file << '\n';
	file << time << s << nb_cells;
	if (MMA) file << "}"; else file << '\n';

	if (MMA) file << ",{";
	bool first_sol=true;
	for (vector<SolverOutputBox>::const_iterator it=inner.begin(); it!=inner.end(); it++) {
		if (!first_sol && MMA) file << ','; else first_sol=false;
		write_txt(file,*it,MMA);
	}
	for (vector<SolverOutputBox>::const_iterator it=boundary.begin(); it!=boundary.end(); it++) {
		if (!first_sol && MMA) file << ','; else first_sol=false;
		write_txt(file,*it,MMA);
	}
	for (vector<SolverOutputBox>::const_iterator it=unknown.begin(); it!=unknown.end(); it++) {
		if (!first_sol && MMA) file << ','; else first_sol=false;
		write_txt(file,*it,MMA);
	}
	for (vector<SolverOutputBox>::const_iterator it=pending.begin(); it!=pending.end(); it++) {
		if (!first_sol && MMA) file << ','; else first_sol=false;
		write_txt(file,*it,MMA);
	}
	if (MMA) file << '}';

	if (MMA) file << "}\n";

	file.close();
}
示例#12
0
FncKhunTucker::FncKhunTucker(const NormalizedSystem& sys, Function& _df, Function** _dg, const IntervalVector& current_box, const BitSet& active) :
								Fnc(1,1), nb_mult(0), // **tmp**
								n(sys.nb_var), sys(sys), df(_df), dg(active.size()), active(active),
								eq(BitSet::empty(sys.f_ctrs.image_dim())),
								ineq(BitSet::empty(sys.f_ctrs.image_dim())),
								bound_left(BitSet::empty(sys.nb_var)),
								bound_right(BitSet::empty(sys.nb_var)) {

	int l=1; // lambda0

	if (_dg==NULL && !active.empty()) {
		ibex_error("[FncKhunTucker] an unconstrained system cannot have active constraints");
	}

	unsigned int i=0; // index of a constraint in the active set
	for (BitSet::const_iterator c=active.begin(); c!=active.end(); ++c, ++i) {
		dg.set_ref(i,*_dg[c]);
		if (sys.ops[c]==EQ) eq.add(i);
		else ineq.add(i);
		//cout << " constraint n°" << c << " active\n";
	}
	l+=active.size();

	for (int j=0; j<sys.box.size(); j++) {
		if (current_box[j].lb() <= sys.box[j].lb()) {
			bound_left.add(j);
			//cout << " left bound n°" << j << " active\n";
			l++;
		}
		if (current_box[j].ub() >= sys.box[j].ub()) {
			bound_right.add(j);
			//cout << " right bound n°" << j << " active\n";
			l++;
		}

	}

	(int&) nb_mult = l;

	(int&) _nb_var = n + l;

	assert(_nb_var == sys.nb_var + eq.size() + ineq.size() + bound_left.size() + bound_right.size() + 1);

	(Dim&) _image_dim = Dim(_nb_var, 1);

}
示例#13
0
/*
 * Build the bisector
 */
Bsc&  StrategyParam::get_bsc() {
	Bsc* bsc;

	System& ext_sys = get_ext_sys(); // <=> original system in case of a solver

	if (bisection=="roundrobin")
		bsc = &rec(new RoundRobin (prec));
	else if (bisection== "largestfirst")
		bsc=  &rec(new LargestFirst(prec));
	else if (bisection=="smearsum")
		bsc =  &rec(new SmearSum(ext_sys,prec));
	else if (bisection=="smearmax")
		bsc =  &rec(new SmearMax(ext_sys,prec));
	else if (bisection=="smearsumrel")
		bsc =  &rec(new SmearSumRelative(ext_sys,prec));
	else if (bisection=="smearmaxrel")
		bsc =  &rec(new SmearMaxRelative(ext_sys,prec));
	else
		ibex_error("StrategyParam: unknown bisection mode");

	return *bsc;
}
示例#14
0
void BD_Factory::add_gaol(double f_RES) {
	Array<const ExprNode> new_args(sip.n_arg+sip.p_arg);
	int I=0;
	int J=0;
	for (int K=0; K<sip.n_arg+sip.p_arg; K++) {
		if (!sip.is_param[K]) new_args.set_ref(K,new_vars[I++]);
		else
			// necessary for applying goal function but ignored at the end
			// (there is no parameter in the goal function):
			new_args.set_ref(K,ExprConstant::new_(sip.p_domain[J++],true));
	}
	const ExprNode* goal_node=&((*sip.sys.goal)(new_args));

	if (problem==ORA) {
		const ExprConstant& f_RES_node=ExprConstant::new_scalar(f_RES);
		goal_node = &((*goal_node) - f_RES);
		add_ctr(ExprCtr(*goal_node,LEQ));

		const ExprNode& minus_eta=-new_vars[sip.n_arg];
		add_goal(minus_eta);
		delete &minus_eta;
	} else {
		add_goal(*goal_node);
	}

	// cleanup
	for (int K=0; K<sip.n_arg+sip.p_arg; K++) {
		if (sip.is_param[K]) {
			if (!new_args[K].fathers.is_empty())
				ibex_error("parameters in the objective");
			delete &new_args[K];
		}
	}

	cleanup(*goal_node,false);

	f_ctrs_copy.clone.clean();
}
示例#15
0
void Gradient::gradient(const IntervalVector& box, IntervalVector& gbox) {

	if (!f.expr().dim.is_scalar()) {
		ibex_error("Cannot called \"gradient\" on a vector-valued function");
	}

	if (_eval.eval(box).is_empty()) {
		// outside definition domain -> empty gradient
		gbox.set_empty(); return;
	}

	gbox.clear();

	g.write_arg_domains(gbox);

	f.forward<Gradient>(*this);

	g.top->i()=1.0;

	f.backward<Gradient>(*this);

	g.read_arg_domains(gbox);
}
示例#16
0
void Optimizer::update_uplo() {
	double new_uplo=POS_INFINITY;

	if (! buffer.empty()) {
		new_uplo= buffer.minimum();
		if (new_uplo > loup) {
			cout << " loup = " << loup << " new_uplo=" << new_uplo << endl;
			ibex_error("optimizer: new_uplo>loup (please report bug)");
		}
		if (new_uplo < uplo_of_epsboxes) uplo = new_uplo;
		else uplo= uplo_of_epsboxes;
	}
	else if (buffer.empty() && loup != POS_INFINITY) {
		// empty buffer : new uplo is set to ymax (loup - precision) if a loup has been found
		new_uplo=compute_ymax(); // not new_uplo=loup, because constraint y <= ymax was enforced
		//    cout << " new uplo buffer empty " << new_uplo << " uplo " << uplo << endl;

		double m = minimum(new_uplo, uplo_of_epsboxes);
		if (uplo < m) uplo = m; // warning: hides the field "m" of the class
		// note: we always have uplo <= uplo_of_epsboxes but we may have uplo > new_uplo, because
		// ymax is strictly lower than the loup.
	}

}
示例#17
0
Bsc::Bsc(const Vector& prec) : _prec(prec) {
	for (int i=0; i<prec.size(); i++)
		if (prec[i]<=0) ibex_error("precision must be a nonnegative number");
}
示例#18
0
double Manifold::read_double(ifstream& f) {
	double x;
	f.read((char*) &x, sizeof(x)); //f >> x;
	if (f.eof()) ibex_error("[manifold]: unexpected end of file.");
	return x;
}
示例#19
0
/*
 *  Build the contractors
 */
Ctc& StrategyParam::get_ctc() {

	Ctc* ctc;

	System& ext_sys = get_ext_sys(); // <=> original system in case of a solver

	// the first contractor called
	Ctc& hc4=rec(new CtcHC4(ext_sys,ratio_propag,hc4_incremental));

	// Build contractor #2:
	// --------------------------
	// An interval Newton iteration
	// for solving f()=0 where f is
	// a vector-valued function representing
	// the system.
	Ctc* ctcnewton= NULL;

	if (filtering == "acidhc4n" || filtering=="hc4n" || filtering=="3bcidhc4n")
	  ctcnewton= &rec(new CtcNewton(get_sys().f, NEWTON_CEIL, prec, GAUSS_SEIDEL_RATIO));

	if (filtering=="hc4" || filtering=="hc4n") {
		ctc = (!ctcnewton)?
				&hc4 :
				&rec(new CtcCompo(hc4,ctcnewton));
	} else {

		// hc4 inside acid and 3bcid : incremental propagation beginning with the shaved variable
		Ctc& hc44cid=rec(new CtcHC4(ext_sys.ctrs,0.1,true));

		if (filtering=="acidhc4" || filtering=="acidhc4n") {
			// The ACID contractor (component of the contractor  when filtering == "acidhc4")
			Ctc& acidhc4=rec(new CtcAcid(ext_sys,hc44cid,optim));

			// hc4 followed by acidhc4 : the actual contractor used when filtering == "acidhc4"
			ctc=(!ctcnewton)?
					&rec(new CtcCompo(hc4, acidhc4)) :
					&rec(new CtcCompo(hc4, acidhc4, *ctcnewton));
		}

		else if (filtering =="3bcidhc4" || filtering =="3bcidhc4n") {
			// The 3BCID contractor on all variables (component of the contractor when filtering == "3bcidhc4")
			Ctc& c3bcidhc4=rec(new Ctc3BCid(hc44cid));
			// hc4 followed by 3bcidhc4 : the actual contractor used when filtering == "3bcidhc4"

			ctc=(!ctcnewton)?
					&rec(new CtcCompo(hc4, c3bcidhc4)) :
					&rec(new CtcCompo(hc4, c3bcidhc4, *ctcnewton));
		}
		else  {
			ibex_error("StrategyParam: unknown contractor mode");
		}
	}

	// The CtcXNewton contractor

	// corner selection for linearizations : two corners are selected, a random one and its opposite
	vector<LinearRelaxXTaylor::corner_point> cpoints;
	cpoints.push_back(LinearRelaxXTaylor::RANDOM);
	cpoints.push_back(LinearRelaxXTaylor::RANDOM_INV);

	LinearRelax* lr;

	if (lin_relax=="art")
		lr = &rec(new LinearRelaxCombo(ext_sys,LinearRelaxCombo::ART));
	else if  (lin_relax=="compo")
		lr = &rec(new LinearRelaxCombo(ext_sys,LinearRelaxCombo::COMPO));
	else if (lin_relax=="xn")
		lr = &rec(new LinearRelaxXTaylor(ext_sys,cpoints));
	else
		ibex_error("StrategyParam: unknown liner relaxation mode");

	// fixpoint linear relaxation , hc4  with default fix point ratio 0.2

	if (lin_relax=="compo" || lin_relax=="art"|| lin_relax=="xn") {

		//cxn = new CtcLinearRelaxation (*lr, hc44xn);
		Ctc& cxn_poly = rec(new CtcPolytopeHull(*lr, CtcPolytopeHull::ALL_BOX));

		// hc4 inside xnewton loop
		Ctc& hc44xn = rec(new CtcHC4(ext_sys.ctrs,ratio_propag,false));

		Ctc& cxn_compo = rec(new CtcCompo(cxn_poly, hc44xn));

		Ctc& cxn = rec(new CtcFixPoint (cxn_compo, fixpoint_ratio));

		//  the actual contractor  ctc + linear relaxation
		return rec(new CtcCompo  (*ctc, cxn));

	}
	else
		return *ctc;

}
示例#20
0
Bsc::Bsc(double prec) : _prec(1,prec) {
	if (prec<0) ibex_error("precision must be a nonnegative number");
	// note: prec==0 allowed with, e.g., LargestFirst
}
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;
}
void SystemFactory::add_var(const ExprSymbol& v) {
	if (goal || !exprs.empty()) ibex_error("cannot add a variable to a system after a constraint (or the goal function)");
	vars.push_back(&v);

}