C++ interval::sup方法代码示例

 interval interval_relation_plugin::meet(interval const& src1, interval const& src2, bool& isempty) {
     isempty = false;
     if (is_empty(0, src1) || is_infinite(src2)) {
         return src1;
     }
     if (is_empty(0, src2) || is_infinite(src1)) {
         return src2;
     }
     bool l_open = src1.is_lower_open();
     bool r_open = src1.is_upper_open();
     ext_numeral low = src1.inf();
     ext_numeral high = src1.sup();
     if (src2.inf() > low || (src2.inf() == low && !l_open)) {
         low = src2.inf();
         l_open = src2.is_lower_open();
     }
     if (src2.sup() < high || (src2.sup() == high && !r_open)) {
         high = src2.sup();
         r_open = src2.is_upper_open();
     }
     if (low > high || (low == high && (l_open || r_open))) {
         isempty = true;
         return interval(dep());
     }
     else {
         return interval(dep(), low, l_open, nullptr, high, r_open, nullptr);
     }
 }

 interval interval_relation_plugin::unite(interval const& src1, interval const& src2) {
     bool l_open = src1.is_lower_open();
     bool r_open = src1.is_upper_open();
     ext_numeral low = src1.inf();
     ext_numeral high = src1.sup();
     if (src2.inf() < low || (src2.inf() == low && l_open)) {
         low = src2.inf();
         l_open = src2.is_lower_open();
     }
     if (src2.sup() > high || (src2.sup() == high && r_open)) {
         high = src2.sup();
         r_open = src2.is_upper_open();
     }
     return interval(dep(), low, l_open, nullptr, high, r_open, nullptr);
 }

// FIXME It actually performs intersection which is inconsistent with intersect
bool sqr_inverse(interval& z, interval& x, interval& gap) {

	bool has_gap = false;

	const interval x_1 = sqrt(z);

	const interval x_2 = -x_1;

	interval x_image;

	if (disjoint(x, x_2)) {

		x_image = x_1;
	}
	else if (disjoint(x, x_1)) {

		x_image = x_2;
	}
	else {

		gap = interval(x_2.sup(), x_1.inf());

		has_gap = gap.diameter() > IMPROVEMENT_TOL; // FIXME GAP_SQRT_TOL ?

		x_image = hull_of(x_1, x_2);
	}

	x.intersect(x_image);

	z.intersect(sqr(x));

	return has_gap;
}

// Returns true and sets gap if a gap is generated, otherwise gap is undefined
bool extended_division(const interval& x, const interval& y, interval& z, interval& gap) {

	gap = interval();

	if (z.is_narrow()) { // if narrow, don't do anything
		// TODO Actually, feasibility could be checked
		return false;
	}

	if (!y.contains(0)) {  // trivial case

		z.intersect(x/y);

		return false;
	}
	// y.contains(0)==true

	if (x.contains(0)) {  // no progress case

		return false;
	}
	// (!x.contains(0) && y.contains(0)) == true

	if (y.inf()==0 && y.sup()==0) {  // undefined case
		// FIXME Is it safe to declare it infeasible? Or should we just signal no progress?
		//ASSERT2(false, "undefined result; x, z: "<<x<<", "<<z);
		throw infeasible_problem();
	}

	return true_extended_division(x, y, z, gap);
}

 interval interval_relation_plugin::widen(interval const& src1, interval const& src2) {
     bool l_open = src1.is_lower_open();
     bool r_open = src1.is_upper_open();
     ext_numeral low = src1.inf();
     ext_numeral high = src1.sup();
     
     if (src2.inf() < low || (low == src2.inf() && l_open && !src2.is_lower_open())) {
         low = ext_numeral(false);
         l_open = true;
     }
     if (high < src2.sup() || (src2.sup() == high && !r_open && src2.is_upper_open())) {
         high = ext_numeral(true);
         r_open = true;
     }
     return interval(dep(), low, l_open, nullptr, high, r_open, nullptr);
 }

// FIXME Performs intersection which is inconsistent with intersect!
bool save_gap_if_any(const double l, const double u, interval& z, interval& gap) {

	ASSERT2( l <= u, "l, u: " << l << ", " << u );

	const double zL = z.inf(), zU = z.sup();

	bool ret_val = false;

	if (zL <= l && u <= zU) { // zL--l  u--zU

		gap = interval(l, u);

		ret_val = true;
	}
	else if (l < zL &&  zU < u) { // --l  zL--zU  u--

		throw infeasible_problem();
	}
	else if (zU <= l) { // zL--zU--l  u--

		; // no progress
	}
	else if (u <= zL) { // --l  u--zL--zU

		; // no progress
	}
	else if (zL <= l && zU < u) { // zL--l  zU  u--

		z = interval(zL, l);
	}
	else if (l < zL && u <= zU) { // --l  zL  u--zU

		z = interval(u, zU);
	}
	else {

		ASSERT(false);
	}

	ASSERT(z.subset_of(interval(zL, zU)));

	return ret_val;
}

 bool interval_relation_plugin::is_empty(unsigned, interval const& i) {
     return i.sup() < i.inf();
 }