typename std::basic_string<Ch, Tr, Alloc>::size_type basic_format<Ch,Tr, Alloc>:: size () const { #ifdef BOOST_MSVC // If std::min<unsigned> or std::max<unsigned> are already instantiated // at this point then we get a blizzard of warning messages when we call // those templates with std::size_t as arguments. Weird and very annoyning... #pragma warning(push) #pragma warning(disable:4267) #endif BOOST_USING_STD_MAX(); size_type sz = prefix_.size(); unsigned long i; for(i=0; i < items_.size(); ++i) { const format_item_t& item = items_[i]; sz += item.res_.size(); if( item.argN_ == format_item_t::argN_tabulation) sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz, static_cast<size_type>(item.fmtstate_.width_) ); sz += item.appendix_.size(); } return sz; #ifdef BOOST_MSVC #pragma warning(pop) #endif }
inline std::pair<typename property_traits<EccentricityMap>::value_type, typename property_traits<EccentricityMap>::value_type> all_eccentricities(const Graph& g, const DistanceMatrix& dist, EccentricityMap ecc) { function_requires< VertexListGraphConcept<Graph> >(); typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename graph_traits<Graph>::vertex_iterator VertexIterator; function_requires< ReadablePropertyMapConcept<DistanceMatrix,Vertex> >(); typedef typename property_traits<DistanceMatrix>::value_type DistanceMap; function_requires< WritablePropertyMapConcept<EccentricityMap,Vertex> >(); typedef typename property_traits<EccentricityMap>::value_type Eccentricity; BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); Eccentricity r = numeric_values<Eccentricity>::infinity(), d = numeric_values<Eccentricity>::zero(); VertexIterator i, end; tie(i, end) = vertices(g); for(tie(i, end) = vertices(g); i != end; ++i) { DistanceMap dm = get(dist, *i); Eccentricity e = eccentricity(g, dm); put(ecc, *i, e); // track the radius and diameter at the same time r = min BOOST_PREVENT_MACRO_SUBSTITUTION (r, e); d = max BOOST_PREVENT_MACRO_SUBSTITUTION (d, e); } return make_pair(r, d); }
bool intersects(double x1, double y1, double x2, double y2, double a1, double b1, double a2, double b2, double epsilon = 0.000001 ) { if (x1 - x2 == 0) { std::swap(x1,a1); std::swap(y1,b1); std::swap(x2,a2); std::swap(y2,b2); } if (x1 - x2 == 0) { BOOST_USING_STD_MAX(); BOOST_USING_STD_MIN(); //two vertical line segments double min_y = min BOOST_PREVENT_MACRO_SUBSTITUTION(y1,y2); double max_y = max BOOST_PREVENT_MACRO_SUBSTITUTION(y1,y2); double min_b = min BOOST_PREVENT_MACRO_SUBSTITUTION(b1,b2); double max_b = max BOOST_PREVENT_MACRO_SUBSTITUTION(b1,b2); if ((max_y > max_b && max_b > min_y) || (max_b > max_y && max_y > min_b) ) return true; else return false; } double x_diff = x1 - x2; double y_diff = y1 - y2; double a_diff = a2 - a1; double b_diff = b2 - b1; double beta_denominator = b_diff - (y_diff/((double)x_diff)) * a_diff; if (beta_denominator == 0) { //parallel lines return false; } double beta = (b2 - y2 - (y_diff/((double)x_diff)) * (a2 - x2)) / beta_denominator; double alpha = (a2 - x2 - beta*(a_diff))/x_diff; double upper_bound = 1 - epsilon; double lower_bound = 0 + epsilon; return (beta < upper_bound && beta > lower_bound && alpha < upper_bound && alpha > lower_bound); }
T max_abs( T t1 , T t2 ) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); if( t1>0 ) return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); else return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); }
template<class T, class Policies> inline interval<T, Policies> max 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_MAX(); return I(max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true); }
typename graph_traits<Graph>::vertices_size_type max_wavefront(const Graph& g, VertexIndexMap index) { BOOST_USING_STD_MAX(); typename graph_traits<Graph>::vertices_size_type b = 0; typename graph_traits<Graph>::vertex_iterator i, end; for (boost::tie(i, end) = vertices(g); i != end; ++i) b = max BOOST_PREVENT_MACRO_SUBSTITUTION(b, ith_wavefront(*i, g, index)); return b; }
template<class T, class Policies> inline T norm(const interval<T, Policies>& x) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x)) { typedef typename Policies::checking checking; return checking::nan(); } BOOST_USING_STD_MAX(); return max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper()); }
template<class T, class Policies> inline interval<T, Policies> operator*(const interval<T, Policies>& x, const interval<T, Policies>& y) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x, y)) return I::empty(); typename Policies::rounding rnd; const T& xl = x.lower(); const T& xu = x.upper(); const T& yl = y.lower(); const T& yu = y.upper(); if (interval_lib::user::is_neg(xl)) if (interval_lib::user::is_pos(xu)) if (interval_lib::user::is_neg(yl)) if (interval_lib::user::is_pos(yu)) // M * M return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_down(xl, yu), rnd.mul_down(xu, yl)), max BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_up (xl, yl), rnd.mul_up (xu, yu)), true); else // M * N return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yl), true); else if (interval_lib::user::is_pos(yu)) // M * P return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yu), true); else // M * Z return I(static_cast<T>(0), static_cast<T>(0), true); else if (interval_lib::user::is_neg(yl)) if (interval_lib::user::is_pos(yu)) // N * M return I(rnd.mul_down(xl, yu), rnd.mul_up(xl, yl), true); else // N * N return I(rnd.mul_down(xu, yu), rnd.mul_up(xl, yl), true); else if (interval_lib::user::is_pos(yu)) // N * P return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yl), true); else // N * Z return I(static_cast<T>(0), static_cast<T>(0), true); else if (interval_lib::user::is_pos(xu)) if (interval_lib::user::is_neg(yl)) if (interval_lib::user::is_pos(yu)) // P * M return I(rnd.mul_down(xu, yl), rnd.mul_up(xu, yu), true); else // P * N return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yu), true); else if (interval_lib::user::is_pos(yu)) // P * P return I(rnd.mul_down(xl, yl), rnd.mul_up(xu, yu), true); else // P * Z return I(static_cast<T>(0), static_cast<T>(0), true); else // Z * ? return I(static_cast<T>(0), static_cast<T>(0), true); }
template<class T, class Policies> inline interval<T, Policies> abs(const interval<T, Policies>& x) { typedef interval<T, Policies> I; if (interval_lib::detail::test_input(x)) return I::empty(); if (!interval_lib::user::is_neg(x.lower())) return x; if (!interval_lib::user::is_pos(x.upper())) return -x; BOOST_USING_STD_MAX(); return I(static_cast<T>(0), max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper()), true); }
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> 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); }
typename std::basic_string<Ch, Tr, Alloc>::size_type basic_format<Ch,Tr, Alloc>:: size () const { BOOST_USING_STD_MAX(); size_type sz = prefix_.size(); unsigned long i; for(i=0; i < items_.size(); ++i) { const format_item_t& item = items_[i]; sz += item.res_.size(); if( item.argN_ == format_item_t::argN_tabulation) sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz, static_cast<size_type>(item.fmtstate_.width_) ); sz += item.appendix_.size(); } return sz; }
static inline void apply(std::basic_ostream<Char, Traits>& os, Box const& box, std::string const& style, int size) { // Prevent invisible boxes, making them >=1, using "max" BOOST_USING_STD_MAX(); typedef typename coordinate_type<Box>::type ct; ct x = geometry::get<geometry::min_corner, 0>(box); ct y = geometry::get<geometry::min_corner, 1>(box); ct width = max BOOST_PREVENT_MACRO_SUBSTITUTION(1, geometry::get<geometry::max_corner, 0>(box) - x); ct height = max BOOST_PREVENT_MACRO_SUBSTITUTION (1, geometry::get<geometry::max_corner, 1>(box) - y); os << "<rect x=\"" << x << "\" y=\"" << y << "\" width=\"" << width << "\" height=\"" << height << "\" style=\"" << style << "\"/>"; }
inline void clique (const Clique& c, Graph2& g) { if (c.size () >= min_size_) { BOOST_USING_STD_MAX(); maximum_ = std::max BOOST_PREVENT_MACRO_SUBSTITUTION (maximum_, c.size()); //save clique... typename Clique::const_iterator i, end = c.end (); std::vector<size_t> * cc = new std::vector<size_t> (c.size ()); cliques_.push_back (cc); size_t p; for (i = c.begin (); i != end; ++i, ++p) cc->at (p) = (*i); n_cliques_++; } else return; }
inline void clique (const Clique& c, Graph2& g) { if (c.size () >= min_size) { BOOST_USING_STD_MAX(); maximum = std::max BOOST_PREVENT_MACRO_SUBSTITUTION (maximum, c.size()); //save clique... typename Clique::const_iterator i, end = c.end (); //std::vector<void *> * cc = new std::vector<void *> (c.size ()); std::vector<size_t> * cc = new std::vector<size_t> (c.size ()); cliques.push_back (cc); size_t p; for (i = c.begin (); i != end; ++i, ++p) { //cc->at (p) = static_cast<void *> (*i); cc->at (p) = (*i); } n_cliques++; } else { return; } // Simply assert that each vertex in the clique is connected // to all others in the clique. /*typename Clique::const_iterator i, j, end = c.end(); for(i = c.begin(); i != end; ++i) { for(j = c.begin(); j != end; ++j) { if(i != j) { BOOST_ASSERT(edge(*i, *j, g).second); } } }*/ }
inline std::pair<typename property_traits<EccentricityMap>::value_type, typename property_traits<EccentricityMap>::value_type> radius_and_diameter(const Graph& g, EccentricityMap ecc) { function_requires< VertexListGraphConcept<Graph> >(); typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename graph_traits<Graph>::vertex_iterator VertexIterator; function_requires< ReadablePropertyMapConcept<EccentricityMap, Vertex> >(); typedef typename property_traits<EccentricityMap>::value_type Eccentricity; BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); VertexIterator i, end; tie(i, end) = vertices(g); Eccentricity radius = get(ecc, *i); Eccentricity diameter = get(ecc, *i); for(i = boost::next(i); i != end; ++i) { Eccentricity cur = get(ecc, *i); radius = min BOOST_PREVENT_MACRO_SUBSTITUTION (radius, cur); diameter = max BOOST_PREVENT_MACRO_SUBSTITUTION (diameter, cur); } return std::make_pair(radius, diameter); }
T operator ()(T x, T y) const { BOOST_USING_STD_MAX(); return max BOOST_PREVENT_MACRO_SUBSTITUTION (x, y); }