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 << "\"/>";
}
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;
}
typename property_traits<ColorMap>::value_type
sequential_vertex_coloring(const VertexListGraph& G, OrderPA order,
ColorMap color)
{
typedef graph_traits<VertexListGraph> GraphTraits;
typedef typename GraphTraits::vertex_descriptor Vertex;
typedef typename property_traits<ColorMap>::value_type size_type;
size_type max_color = 0;
const size_type V = num_vertices(G);
// We need to keep track of which colors are used by
// adjacent vertices. We do this by marking the colors
// that are used. The mark array contains the mark
// for each color. The length of mark is the
// number of vertices since the maximum possible number of colors
// is the number of vertices.
std::vector<size_type> mark(V,
std::numeric_limits<size_type>::max BOOST_PREVENT_MACRO_SUBSTITUTION());
//Initialize colors
typename GraphTraits::vertex_iterator v, vend;
for (tie(v, vend) = vertices(G); v != vend; ++v)
put(color, *v, V-1);
//Determine the color for every vertex one by one
for ( size_type i = 0; i < V; i++) {
Vertex current = get(order,i);
typename GraphTraits::adjacency_iterator v, vend;
//Mark the colors of vertices adjacent to current.
//i can be the value for marking since i increases successively
for (tie(v,vend) = adjacent_vertices(current, G); v != vend; ++v)
mark[get(color,*v)] = i;
//Next step is to assign the smallest un-marked color
//to the current vertex.
size_type j = 0;
//Scan through all useable colors, find the smallest possible
//color that is not used by neighbors. Note that if mark[j]
//is equal to i, color j is used by one of the current vertex's
//neighbors.
while ( j < max_color && mark[j] == i )
++j;
if ( j == max_color ) //All colors are used up. Add one more color
++max_color;
//At this point, j is the smallest possible color
put(color, current, j); //Save the color of vertex current
}
return max_color;
}
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> 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);
}
void back_edge(const Edge& e, Graph& g)
{
BOOST_USING_STD_MIN();
if ( target(e, g) != get(pred, source(e, g)) ) {
S.push(e);
put(lowpt, source(e, g),
min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, source(e, g)),
get(dtm, target(e, g))));
}
}
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;
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);
}
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;
}
bool floyd_warshall_noninit_dispatch(const VertexAndEdgeListGraph& g,
DistanceMatrix& d, WeightMap w,
const bgl_named_params<P, T, R>& params)
{
typedef typename property_traits<WeightMap>::value_type WM;
return floyd_warshall_all_pairs_shortest_paths(g, d, w,
choose_param(get_param(params, distance_compare_t()),
std::less<WM>()),
choose_param(get_param(params, distance_combine_t()),
closed_plus<WM>()),
choose_param(get_param(params, distance_inf_t()),
std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION()),
choose_param(get_param(params, distance_zero_t()),
WM()));
}
void finish_vertex(const Vertex& u, Graph&)
{
typedef typename graph_traits<Graph>::vertices_size_type v_size_t;
Vertex u_parent = get(parent, u);
v_size_t u_parent_lowpoint = get(low, u_parent);
v_size_t u_lowpoint = get(low, u);
BOOST_USING_STD_MIN();
if (u_parent != u)
{
put(low, u_parent,
min BOOST_PREVENT_MACRO_SUBSTITUTION(u_lowpoint,
u_parent_lowpoint
)
);
}
}
bool
johnson_dispatch(VertexAndEdgeListGraph& g,
DistanceMatrix& D,
const bgl_named_params<P, T, R>& params,
Weight w, VertexID id)
{
typedef typename property_traits<Weight>::value_type WT;
return johnson_all_pairs_shortest_paths
(g, D, id, w,
choose_param(get_param(params, distance_compare_t()),
std::less<WT>()),
choose_param(get_param(params, distance_combine_t()),
closed_plus<WT>()),
choose_param(get_param(params, distance_inf_t()),
std::numeric_limits<WT>::max BOOST_PREVENT_MACRO_SUBSTITUTION()),
choose_param(get_param(params, distance_zero_t()), WT()) );
}
void finish_vertex(const Vertex& u, Graph& g)
{
BOOST_USING_STD_MIN();
Vertex parent = get(pred, u);
bool is_art_point = false;
if ( get(dtm, parent) > get(dtm, u) ) {
parent = get(pred, parent);
is_art_point = true;
}
if ( parent == u ) { // at top
if ( get(dtm, u) + 1 == get(dtm, get(pred, u)) )
is_art_point = false;
} else {
put(lowpt, parent,
min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, parent),
get(lowpt, u)));
if (get(lowpt, u) >= get(dtm, parent)) {
if ( get(dtm, parent) > get(dtm, get(pred, parent)) ) {
put(pred, u, get(pred, parent));
put(pred, parent, u);
}
while ( get(dtm, source(S.top(), g)) >= get(dtm, u) ) {
put(comp, S.top(), c);
S.pop();
}
put(comp, S.top(), c);
S.pop();
++c;
if ( S.empty() ) {
put(pred, u, parent);
put(pred, parent, u);
}
}
}
if ( is_art_point )
*out++ = u;
}
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 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;
}
extern "C" long double BOOST_MATH_TR1_DECL betal BOOST_PREVENT_MACRO_SUBSTITUTION(long double x, long double y)
{
return c_policies::beta BOOST_PREVENT_MACRO_SUBSTITUTION(x, y);
}
extern "C" double BOOST_MATH_TR1_DECL acosh BOOST_PREVENT_MACRO_SUBSTITUTION(double x)
{
return c_policies::acosh BOOST_PREVENT_MACRO_SUBSTITUTION(x);
}
extern "C" float BOOST_MATH_TR1_DECL comp_ellint_1f BOOST_PREVENT_MACRO_SUBSTITUTION(float x)
{
return c_policies::ellint_1 BOOST_PREVENT_MACRO_SUBSTITUTION(x);
}
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return std::max BOOST_PREVENT_MACRO_SUBSTITUTION((_rng1.min)(), (_rng2.max)()); }
extern "C" float BOOST_MATH_TR1_DECL cyl_neumannf BOOST_PREVENT_MACRO_SUBSTITUTION(float nu, float x)
{
return c_policies::cyl_neumann BOOST_PREVENT_MACRO_SUBSTITUTION(nu, x);
}
extern "C" float BOOST_MATH_TR1_DECL comp_ellint_3f BOOST_PREVENT_MACRO_SUBSTITUTION(float k, float nu)
{
return c_policies::ellint_3 BOOST_PREVENT_MACRO_SUBSTITUTION(k, nu);
}
extern "C" long double BOOST_MATH_TR1_DECL erfl BOOST_PREVENT_MACRO_SUBSTITUTION(long double x)
{
return c_policies::erf BOOST_PREVENT_MACRO_SUBSTITUTION(x);
}
// Commit the resize transaction.
void commit()
{
old_size_
= std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
}
extern "C" long long BOOST_MATH_TR1_DECL llround BOOST_PREVENT_MACRO_SUBSTITUTION(double x)
{
return c_policies::llround BOOST_PREVENT_MACRO_SUBSTITUTION(x);
}
extern "C" long double BOOST_MATH_TR1_DECL cyl_bessel_il BOOST_PREVENT_MACRO_SUBSTITUTION(long double nu, long double x)
{
return c_policies::cyl_bessel_i BOOST_PREVENT_MACRO_SUBSTITUTION(nu, x);
}
extern "C" double BOOST_MATH_TR1_DECL copysign BOOST_PREVENT_MACRO_SUBSTITUTION(double x, double y)
{
return boost::math::copysign BOOST_PREVENT_MACRO_SUBSTITUTION(x, y);
}
extern "C" double BOOST_MATH_TR1_DECL sph_bessel BOOST_PREVENT_MACRO_SUBSTITUTION(unsigned n, double x)
{
return c_policies::sph_bessel BOOST_PREVENT_MACRO_SUBSTITUTION(n, x);
}
extern "C" double BOOST_MATH_TR1_DECL ellint_2 BOOST_PREVENT_MACRO_SUBSTITUTION(double k, double phi)
{
return c_policies::ellint_2 BOOST_PREVENT_MACRO_SUBSTITUTION(k, phi);
}
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return std::numeric_limits<result_type>::max BOOST_PREVENT_MACRO_SUBSTITUTION (); }
slice::range<RandomAccessIterator>
get_indices( const RandomAccessIterator& begin,
const RandomAccessIterator& end) const
{
// This is based loosely on PySlice_GetIndicesEx(), but it has been
// carefully crafted to ensure that these iterators never fall out of
// the range of the container.
slice::range<RandomAccessIterator> ret;
typedef typename iterator_difference<RandomAccessIterator>::type difference_type;
difference_type max_dist = abt_boost::detail::distance(begin, end);
object slice_start = this->start();
object slice_stop = this->stop();
object slice_step = this->step();
// Extract the step.
if (slice_step == object()) {
ret.step = 1;
}
else {
ret.step = extract<long>( slice_step);
if (ret.step == 0) {
PyErr_SetString( PyExc_IndexError, "step size cannot be zero.");
throw_error_already_set();
}
}
// Setup the start iterator.
if (slice_start == object()) {
if (ret.step < 0) {
ret.start = end;
--ret.start;
}
else
ret.start = begin;
}
else {
difference_type i = extract<long>( slice_start);
if (i >= max_dist && ret.step > 0)
throw std::invalid_argument( "Zero-length slice");
if (i >= 0) {
ret.start = begin;
BOOST_USING_STD_MIN();
std::advance( ret.start, min BOOST_PREVENT_MACRO_SUBSTITUTION(i, max_dist-1));
}
else {
if (i < -max_dist && ret.step < 0)
throw std::invalid_argument( "Zero-length slice");
ret.start = end;
// Advance start (towards begin) not farther than begin.
std::advance( ret.start, (-i < max_dist) ? i : -max_dist );
}
}
// Set up the stop iterator. This one is a little trickier since slices
// define a [) range, and we are returning a [] range.
if (slice_stop == object()) {
if (ret.step < 0) {
ret.stop = begin;
}
else {
ret.stop = end;
std::advance( ret.stop, -1);
}
}
else {
difference_type i = extract<long>(slice_stop);
// First, branch on which direction we are going with this.
if (ret.step < 0) {
if (i+1 >= max_dist || i == -1)
throw std::invalid_argument( "Zero-length slice");
if (i >= 0) {
ret.stop = begin;
std::advance( ret.stop, i+1);
}
else { // i is negative, but more negative than -1.
ret.stop = end;
std::advance( ret.stop, (-i < max_dist) ? i : -max_dist);
}
}
else { // stepping forward
if (i == 0 || -i >= max_dist)
throw std::invalid_argument( "Zero-length slice");
if (i > 0) {
ret.stop = begin;
std::advance( ret.stop, (std::min)( i-1, max_dist-1));
}
else { // i is negative, but not more negative than -max_dist
ret.stop = end;
std::advance( ret.stop, i-1);
}
}
}
// Now the fun part, handling the possibilites surrounding step.
// At this point, step has been initialized, ret.stop, and ret.step
// represent the widest possible range that could be traveled
// (inclusive), and final_dist is the maximum distance covered by the
// slice.
typename iterator_difference<RandomAccessIterator>::type final_dist =
abt_boost::detail::distance( ret.start, ret.stop);
// First case, if both ret.start and ret.stop are equal, then step
// is irrelevant and we can return here.
if (final_dist == 0)
return ret;
// Second, if there is a sign mismatch, than the resulting range and
// step size conflict: std::advance( ret.start, ret.step) goes away from
// ret.stop.
if ((final_dist > 0) != (ret.step > 0))
throw std::invalid_argument( "Zero-length slice.");
// Finally, if the last step puts us past the end, we move ret.stop
// towards ret.start in the amount of the remainder.
// I don't remember all of the oolies surrounding negative modulii,
// so I am handling each of these cases separately.
if (final_dist < 0) {
difference_type remainder = -final_dist % -ret.step;
std::advance( ret.stop, remainder);
}
else {
difference_type remainder = final_dist % ret.step;
std::advance( ret.stop, -remainder);
}
return ret;
}
extern "C" float BOOST_MATH_TR1_DECL roundf BOOST_PREVENT_MACRO_SUBSTITUTION(float x)
{
return c_policies::round BOOST_PREVENT_MACRO_SUBSTITUTION(x);
}
