void r_search(Node *root, const interval<T>& i, ivec& vec, int mode) { if (root == NULL) return; if (mode == OVERLAP && root->m_interval->overlaps(i)) vec.push_back(*(root->m_interval)); if (mode == CONTAIN && root->m_interval->contains(i)) vec.push_back(*(root->m_interval)); if (mode == CONTAINED && i.contains(*(root->m_interval))) vec.push_back(*(root->m_interval)); if (root->left != NULL && i.overlaps(root->left->min, root->left->max)) r_search(root->left, i, vec, mode); if (root->right != NULL && i.overlaps(root->right->min, root->right->max)) r_search(root->right, i, vec, mode); }
template<class T, class Policies> inline interval<T, Policies> fmod(const interval<T, Policies>& x, const interval<T, Policies>& y) { if (interval_lib::detail::test_input(x, y)) return interval<T, Policies>::empty(); typename Policies::rounding rnd; typedef typename interval_lib::unprotect<interval<T, Policies> >::type I; T const &yb = interval_lib::user::is_neg(x.lower()) ? y.lower() : y.upper(); T n = rnd.int_down(rnd.div_down(x.lower(), yb)); return (const I&)x - n * (const I&)y; }
void random_updater::diminish_interval_for_basic_var(numeric_pair<mpq>& nb_x, unsigned j, mpq & a, interval & r) { SASSERT(m_core_solver.m_r_heading[j] >= 0); numeric_pair<mpq> delta; SASSERT(a != zero_of_type<mpq>()); switch (m_core_solver.get_column_type(j)) { case column_type::free_column: break; case column_type::low_bound: delta = m_core_solver.m_r_x[j] - m_core_solver.m_r_low_bounds[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); if (a > 0) { r.set_upper_bound(nb_x + delta / a); } else { r.set_low_bound(nb_x + delta / a); } break; case column_type::upper_bound: delta = m_core_solver.m_r_upper_bounds()[j] - m_core_solver.m_r_x[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); if (a > 0) { r.set_low_bound(nb_x - delta / a); } else { r.set_upper_bound(nb_x - delta / a); } break; case column_type::boxed: if (a > 0) { delta = m_core_solver.m_r_x[j] - m_core_solver.m_r_low_bounds[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); r.set_upper_bound(nb_x + delta / a); delta = m_core_solver.m_r_upper_bounds()[j] - m_core_solver.m_r_x[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); r.set_low_bound(nb_x - delta / a); } else { // a < 0 delta = m_core_solver.m_r_upper_bounds()[j] - m_core_solver.m_r_x[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); r.set_upper_bound(nb_x - delta / a); delta = m_core_solver.m_r_x[j] - m_core_solver.m_r_low_bounds[j]; SASSERT(delta >= zero_of_type<numeric_pair<mpq>>()); r.set_low_bound(nb_x + delta / a); } break; case column_type::fixed: r.set_low_bound(nb_x); r.set_upper_bound(nb_x); break; default: SASSERT(false); } }
template<class T, class Policies> inline interval<T, Policies> intersect(const interval<T, Policies>& x, const interval<T, Policies>& y) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); if (interval_lib::detail::test_input(x, y)) return interval<T, Policies>::empty(); const T& l = max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()); const T& u = min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()); if (l <= u) return interval<T, Policies>(l, u, true); else return interval<T, Policies>::empty(); }
template<class T, class Policies> inline interval<T, Policies> operator/(const interval<T, Policies>& x, const T& y) { if (interval_lib::detail::test_input(x, y) || interval_lib::user::is_zero(y)) return interval<T, Policies>::empty(); typename Policies::rounding rnd; const T& xl = x.lower(); const T& xu = x.upper(); if (interval_lib::user::is_neg(y)) return interval<T, Policies>(rnd.div_down(xu, y), rnd.div_up(xl, y), true); else return interval<T, Policies>(rnd.div_down(xl, y), rnd.div_up(xu, y), true); }
template<class T, class Policies> inline interval<T, Policies> div_zero_part2(const interval<T, Policies>& x, const interval<T, Policies>& y) { // assert(::boost::numeric::interval_lib::user::is_neg(y.lower()) && ::boost::numeric::interval_lib::user::is_pos(y.upper()) && (div_zero_part1(x, y, b), b)); typename Policies::rounding rnd; typedef interval<T, Policies> I; typedef typename Policies::checking checking; if (::boost::numeric::interval_lib::user::is_neg(x.upper())) return I(rnd.div_down(x.upper(), y.lower()), checking::pos_inf(), true); else return I(rnd.div_down(x.lower(), y.upper()), checking::pos_inf(), true); }
template<class T, class Policies> inline interval<T, Policies> log(const interval<T, Policies>& x) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x) || !interval_lib::user::is_pos(x.upper())) return I::empty(); typename Policies::rounding rnd; typedef typename Policies::checking checking; T l = !interval_lib::user::is_pos(x.lower()) ? checking::neg_inf() : rnd.log_down(x.lower()); return I(l, rnd.log_up(x.upper()), true); }
template<class T, class Policies> inline interval<T, Policies> div_non_zero(const T& x, const interval<T, Policies>& y) { // assert(!in_zero(y)); typename Policies::rounding rnd; typedef interval<T, Policies> I; const T& yl = y.lower(); const T& yu = y.upper(); if (::boost::numeric::interval_lib::user::is_neg(x)) return I(rnd.div_down(x, yl), rnd.div_up(x, yu), true); else return I(rnd.div_down(x, yu), rnd.div_up(x, yl), true); }
template<class T, class Policies> inline interval<T, Policies> intersect(const interval<T, Policies>& x, const interval<T, Policies>& y) { BOOST_NUMERIC_INTERVAL_using_max(min); BOOST_NUMERIC_INTERVAL_using_max(max); if (interval_lib::detail::test_input(x, y)) return interval<T, Policies>::empty(); const T& l = max(x.lower(), y.lower()); const T& u = min(x.upper(), y.upper()); if (l <= u) return interval<T, Policies>(l, u, true); else return interval<T, Policies>::empty(); }
list<interval> split(interval const & i, unsigned n) { list<interval> ret; double lb = i.leftBound(); double const rb = i.rightBound(); double const width = rb - lb; double const step = width / n; for (unsigned i = 0; i < n - 1; i++) { ret.emplace_back(lb, lb + step); lb += step; } ret.emplace_back(lb, rb); return ret; }
template<class T, class Policies> inline interval<T, Policies> div_zero_part2(const interval<T, Policies>& x, const interval<T, Policies>& y) { // assert(y.lower() < 0 && y.upper() > 0 && (div_zero_part1(x, y, b), b)); typename Policies::rounding rnd; typedef interval<T, Policies> I; typedef typename I::checking checking; const T& inf = checking::inf(); if (is_neg(x.upper())) return I(rnd.div_down(x.upper(), y.lower()), inf, true); else return I(rnd.div_down(x.lower(), y.upper()), inf, true); }
template<class T, class Policies> inline interval<T, Policies> cosh(const interval<T, Policies>& x) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x)) return I::empty(); typename Policies::rounding rnd; if (interval_lib::user::is_neg(x.upper())) return I(rnd.cosh_down(x.upper()), rnd.cosh_up(x.lower()), true); else if (!interval_lib::user::is_neg(x.lower())) return I(rnd.cosh_down(x.lower()), rnd.cosh_up(x.upper()), true); else return I(static_cast<T>(0), rnd.cosh_up(-x.lower() > x.upper() ? x.lower() : x.upper()), true); }
template<class T, class Policies> inline interval<T, Policies> hull(const T& x, const interval<T, Policies>& y) { BOOST_NUMERIC_INTERVAL_using_max(min); BOOST_NUMERIC_INTERVAL_using_max(max); bool bad_x = interval_lib::detail::test_input<T, Policies>(x); bool bad_y = interval_lib::detail::test_input(y); if (bad_x) if (bad_y) return interval<T, Policies>::empty(); else return y; else if (bad_y) return interval<T, Policies>(x, x, true); return interval<T, Policies>(min(x, y.lower()), max(x, y.upper()), true); }
template<class T, class Policies> inline interval<T, Policies> hull(const T& x, const interval<T, Policies>& y) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); bool bad_x = interval_lib::detail::test_input<T, Policies>(x); bool bad_y = interval_lib::detail::test_input(y); if (bad_x) if (bad_y) return interval<T, Policies>::empty(); else return y; else if (bad_y) return interval<T, Policies>(x, x, true); return interval<T, Policies>(min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); }
template<class T, class Policies1, class Policies2> inline bool overlap(const interval<T, Policies1>& x, const interval<T, Policies2>& y) { if (interval_lib::detail::test_input(x, y)) return false; return x.lower() <= y.lower() && y.lower() <= x.upper() || y.lower() <= x.lower() && x.lower() <= y.upper(); }
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); }
template<class T, class Policies1, class Policies2> inline bool proper_subset(const interval<T, Policies1>& x, const interval<T, Policies2>& y) { if (empty(y)) return false; if (empty(x)) return true; return y.lower() <= x.lower() && x.upper() <= y.upper() && (y.lower() != x.lower() || x.upper() != y.upper()); }
void ode_solver::prune_trajectory(interval& time, IVector& e) { // Remove datapoints after time interval. auto ite = find_if (m_trajectory.begin(), m_trajectory.end(), [&time](pair<interval, IVector>& item) { return item.first.leftBound() > time.rightBound(); }); m_trajectory.erase(ite, m_trajectory.end()); // Update the datapoints in the time interval ite = find_if (m_trajectory.begin(), m_trajectory.end(), [&time](pair<interval, IVector>& item) { return item.first.leftBound()>= time.leftBound(); }); for_each(ite, m_trajectory.end(), [&e](pair<interval, IVector>& item) { intersection(item.second, e, item.second); }); }
template<class T, class Policies> inline interval<T, Policies> operator*(const T& x, const interval<T, Policies>& y) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x, y)) return I::empty(); typename Policies::rounding rnd; const T& yl = y.lower(); const T& yu = y.upper(); // x is supposed not to be infinite if (interval_lib::user::is_neg(x)) return I(rnd.mul_down(x, yu), rnd.mul_up(x, yl), true); else if (interval_lib::user::is_zero(x)) return I(static_cast<T>(0), static_cast<T>(0), true); else return I(rnd.mul_down(x, yl), rnd.mul_up(x, yu), true); }
// 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; }
template<class T, class Policies> inline T checked_upper(const interval<T, Policies>& x) { if (empty(x)) { typedef typename Policies::checking checking; return checking::nan(); } return x.upper(); }
template<class T, class Policies> inline interval<T, Policies> min BOOST_PREVENT_MACRO_SUBSTITUTION (const T& x, const interval<T, Policies>& y) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x, y)) return I::empty(); BOOST_USING_STD_MIN(); return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); }
template<class T, class Policies> inline interval<T, Policies> div_positive(const interval<T, Policies>& x, const T& yu) { // assert(yu > T(0)); if (is_zero(x)) return x; typename Policies::rounding rnd; typedef interval<T, Policies> I; const T& xl = x.lower(); const T& xu = x.upper(); typedef typename Policies::checking checking; const T& inf = checking::inf(); if (is_neg(xu)) return I(-inf, rnd.div_up(xu, yu), true); else if (is_neg(xl)) return I(-inf, inf, true); else return I(rnd.div_down(xl, yu), inf, true); }
std::vector<scigraphics::number> scigraphics::markerLinear::marksWithStepVector( const interval<number> Interval, const number Steps[] ) const { assert( Steps != NULL ); std::vector<number> Result; for ( number Order = std::pow( 10, baseOrder(Interval.distance()) - 2 ); Order < Interval.distance() * 10; Order *= 10 ) { for ( const number *Step = &Steps[0]; *Step != 0; ++Step ) { Result = marksWithStep( Interval, *Step * Order ); if ( vectorInMarkLimits(Result) ) return Result; } } return Result; }
template<class T, class Policies1, class Policies2> inline logic::tribool operator==(const interval<T, Policies1>& x, const interval<T, Policies2>& y) { if (detail::test_input(x, y)) throw comparison_error(); if (x.upper() == y.lower() && x.lower() == y.upper()) return true; if (x.upper() < y.lower() || x.lower() > y.upper()) return false; return logic::indeterminate; }
void random_updater::diminish_interval_to_leave_basic_vars_feasible(numeric_pair<mpq> &nb_x, interval & r) { m_column_j->reset(); unsigned i; mpq a; while (m_column_j->next(a, i)) { diminish_interval_for_basic_var(nb_x, m_core_solver.m_r_basis[i], a, r); if (r.is_empty()) break; } }
template<class T, class Policies> inline interval<T, Policies> div_positive(const interval<T, Policies>& x, const T& yu) { // assert(::boost::numeric::interval_lib::user::is_pos(yu)); if (::boost::numeric::interval_lib::user::is_zero(x.lower()) && ::boost::numeric::interval_lib::user::is_zero(x.upper())) return x; typename Policies::rounding rnd; typedef interval<T, Policies> I; const T& xl = x.lower(); const T& xu = x.upper(); typedef typename Policies::checking checking; if (::boost::numeric::interval_lib::user::is_neg(xu)) return I(checking::neg_inf(), rnd.div_up(xu, yu), true); else if (::boost::numeric::interval_lib::user::is_neg(xl)) return I(checking::neg_inf(), checking::pos_inf(), true); else return I(rnd.div_down(xl, yu), checking::pos_inf(), true); }
template<class T, class Policies> inline interval<T, Policies> fmod(const interval<T, Policies>& x, const T& y) { if (interval_lib::detail::test_input(x, y)) return interval<T, Policies>::empty(); typename Policies::rounding rnd; typedef typename interval_lib::unprotect<interval<T, Policies> >::type I; T n = rnd.int_down(rnd.div_down(x.lower(), y)); return (const I&)x - n * I(y); }
template<class T, class Policies> inline interval<T, Policies> operator/(const T& x, const interval<T, Policies>& y) { if (interval_lib::detail::test_input(x, y)) return interval<T, Policies>::empty(); if (zero_in(y)) if (!interval_lib::user::is_zero(y.lower())) if (!interval_lib::user::is_zero(y.upper())) return interval_lib::detail::div_zero<T, Policies>(x); else return interval_lib::detail::div_negative<T, Policies>(x, y.lower()); else if (!interval_lib::user::is_zero(y.upper())) return interval_lib::detail::div_positive<T, Policies>(x, y.upper()); else return interval<T, Policies>::empty(); else return interval_lib::detail::div_non_zero(x, y); }
// 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; }