EIC code displayed by LXR master/​include/​boost/​graph/​topology.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:37:38

 // Copyright 2009 The Trustees of Indiana University.
 
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  Authors: Jeremiah Willcock
 //           Douglas Gregor
 //           Andrew Lumsdaine
 #ifndef BOOST_GRAPH_TOPOLOGY_HPP
 #define BOOST_GRAPH_TOPOLOGY_HPP
 
 #include <boost/config/no_tr1/cmath.hpp>
 #include <cmath>
 #include <boost/random/uniform_01.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/math/constants/constants.hpp> // For root_two
 #include <boost/algorithm/minmax.hpp>
 #include <boost/config.hpp> // For BOOST_STATIC_CONSTANT
 #include <boost/math/special_functions/hypot.hpp>
 
 // Classes and concepts to represent points in a space, with distance and move
 // operations (used for Gurson-Atun layout), plus other things like bounding
 // boxes used for other layout algorithms.
 
 namespace boost
 {
 
 /***********************************************************
  * Topologies                                              *
  ***********************************************************/
 template < std::size_t Dims > class convex_topology
 {
 public: // For VisualAge C++
     struct point
     {
         BOOST_STATIC_CONSTANT(std::size_t, dimensions = Dims);
         point() {}
         double& operator[](std::size_t i) { return values[i]; }
         const double& operator[](std::size_t i) const { return values[i]; }
 
     private:
         double values[Dims];
     };
 
 public: // For VisualAge C++
     struct point_difference
     {
         BOOST_STATIC_CONSTANT(std::size_t, dimensions = Dims);
         point_difference()
         {
             for (std::size_t i = 0; i < Dims; ++i)
                 values[i] = 0.;
         }
         double& operator[](std::size_t i) { return values[i]; }
         const double& operator[](std::size_t i) const { return values[i]; }
 
         friend point_difference operator+(
             const point_difference& a, const point_difference& b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = a[i] + b[i];
             return result;
         }
 
         friend point_difference& operator+=(
             point_difference& a, const point_difference& b)
         {
             for (std::size_t i = 0; i < Dims; ++i)
                 a[i] += b[i];
             return a;
         }
 
         friend point_difference operator-(const point_difference& a)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = -a[i];
             return result;
         }
 
         friend point_difference operator-(
             const point_difference& a, const point_difference& b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = a[i] - b[i];
             return result;
         }
 
         friend point_difference& operator-=(
             point_difference& a, const point_difference& b)
         {
             for (std::size_t i = 0; i < Dims; ++i)
                 a[i] -= b[i];
             return a;
         }
 
         friend point_difference operator*(
             const point_difference& a, const point_difference& b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = a[i] * b[i];
             return result;
         }
 
         friend point_difference operator*(const point_difference& a, double b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = a[i] * b;
             return result;
         }
 
         friend point_difference operator*(double a, const point_difference& b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = a * b[i];
             return result;
         }
 
         friend point_difference operator/(
             const point_difference& a, const point_difference& b)
         {
             point_difference result;
             for (std::size_t i = 0; i < Dims; ++i)
                 result[i] = (b[i] == 0.) ? 0. : a[i] / b[i];
             return result;
         }
 
         friend double dot(const point_difference& a, const point_difference& b)
         {
             double result = 0;
             for (std::size_t i = 0; i < Dims; ++i)
                 result += a[i] * b[i];
             return result;
         }
 
     private:
         double values[Dims];
     };
 
 public:
     typedef point point_type;
     typedef point_difference point_difference_type;
 
     double distance(point a, point b) const
     {
         double dist = 0.;
         for (std::size_t i = 0; i < Dims; ++i)
         {
             double diff = b[i] - a[i];
             dist = boost::math::hypot(dist, diff);
         }
         // Exact properties of the distance are not important, as long as
         // < on what this returns matches real distances; l_2 is used because
         // Fruchterman-Reingold also uses this code and it relies on l_2.
         return dist;
     }
 
     point move_position_toward(point a, double fraction, point b) const
     {
         point result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = a[i] + (b[i] - a[i]) * fraction;
         return result;
     }
 
     point_difference difference(point a, point b) const
     {
         point_difference result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = a[i] - b[i];
         return result;
     }
 
     point adjust(point a, point_difference delta) const
     {
         point result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = a[i] + delta[i];
         return result;
     }
 
     point pointwise_min(point a, point b) const
     {
         BOOST_USING_STD_MIN();
         point result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = min BOOST_PREVENT_MACRO_SUBSTITUTION(a[i], b[i]);
         return result;
     }
 
     point pointwise_max(point a, point b) const
     {
         BOOST_USING_STD_MAX();
         point result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = max BOOST_PREVENT_MACRO_SUBSTITUTION(a[i], b[i]);
         return result;
     }
 
     double norm(point_difference delta) const
     {
         double n = 0.;
         for (std::size_t i = 0; i < Dims; ++i)
             n = boost::math::hypot(n, delta[i]);
         return n;
     }
 
     double volume(point_difference delta) const
     {
         double n = 1.;
         for (std::size_t i = 0; i < Dims; ++i)
             n *= delta[i];
         return n;
     }
 };
 
 template < std::size_t Dims, typename RandomNumberGenerator = minstd_rand >
 class hypercube_topology : public convex_topology< Dims >
 {
     typedef uniform_01< RandomNumberGenerator, double > rand_t;
 
 public:
     typedef typename convex_topology< Dims >::point_type point_type;
     typedef typename convex_topology< Dims >::point_difference_type
         point_difference_type;
 
     explicit hypercube_topology(double scaling = 1.0)
     : gen_ptr(new RandomNumberGenerator)
     , rand(new rand_t(*gen_ptr))
     , scaling(scaling)
     {
     }
 
     hypercube_topology(RandomNumberGenerator& gen, double scaling = 1.0)
     : gen_ptr(), rand(new rand_t(gen)), scaling(scaling)
     {
     }
 
     point_type random_point() const
     {
         point_type p;
         for (std::size_t i = 0; i < Dims; ++i)
             p[i] = (*rand)() * scaling;
         return p;
     }
 
     point_type bound(point_type a) const
     {
         BOOST_USING_STD_MIN();
         BOOST_USING_STD_MAX();
         point_type p;
         for (std::size_t i = 0; i < Dims; ++i)
             p[i] = min BOOST_PREVENT_MACRO_SUBSTITUTION(
                 scaling, max BOOST_PREVENT_MACRO_SUBSTITUTION(-scaling, a[i]));
         return p;
     }
 
     double distance_from_boundary(point_type a) const
     {
         BOOST_USING_STD_MIN();
         BOOST_USING_STD_MAX();
 #ifndef BOOST_NO_STDC_NAMESPACE
         using std::abs;
 #endif
         BOOST_STATIC_ASSERT(Dims >= 1);
         double dist = abs(scaling - a[0]);
         for (std::size_t i = 1; i < Dims; ++i)
             dist = min BOOST_PREVENT_MACRO_SUBSTITUTION(
                 dist, abs(scaling - a[i]));
         return dist;
     }
 
     point_type center() const
     {
         point_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = scaling * .5;
         return result;
     }
 
     point_type origin() const
     {
         point_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = 0;
         return result;
     }
 
     point_difference_type extent() const
     {
         point_difference_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = scaling;
         return result;
     }
 
 private:
     shared_ptr< RandomNumberGenerator > gen_ptr;
     shared_ptr< rand_t > rand;
     double scaling;
 };
 
 template < typename RandomNumberGenerator = minstd_rand >
 class square_topology : public hypercube_topology< 2, RandomNumberGenerator >
 {
     typedef hypercube_topology< 2, RandomNumberGenerator > inherited;
 
 public:
     explicit square_topology(double scaling = 1.0) : inherited(scaling) {}
 
     square_topology(RandomNumberGenerator& gen, double scaling = 1.0)
     : inherited(gen, scaling)
     {
     }
 };
 
 template < typename RandomNumberGenerator = minstd_rand >
 class rectangle_topology : public convex_topology< 2 >
 {
     typedef uniform_01< RandomNumberGenerator, double > rand_t;
 
 public:
     rectangle_topology(double left, double top, double right, double bottom)
     : gen_ptr(new RandomNumberGenerator)
     , rand(new rand_t(*gen_ptr))
     , left(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(left, right))
     , top(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(top, bottom))
     , right(std::max BOOST_PREVENT_MACRO_SUBSTITUTION(left, right))
     , bottom(std::max BOOST_PREVENT_MACRO_SUBSTITUTION(top, bottom))
     {
     }
 
     rectangle_topology(RandomNumberGenerator& gen, double left, double top,
         double right, double bottom)
     : gen_ptr()
     , rand(new rand_t(gen))
     , left(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(left, right))
     , top(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(top, bottom))
     , right(std::max BOOST_PREVENT_MACRO_SUBSTITUTION(left, right))
     , bottom(std::max BOOST_PREVENT_MACRO_SUBSTITUTION(top, bottom))
     {
     }
 
     typedef typename convex_topology< 2 >::point_type point_type;
     typedef typename convex_topology< 2 >::point_difference_type
         point_difference_type;
 
     point_type random_point() const
     {
         point_type p;
         p[0] = (*rand)() * (right - left) + left;
         p[1] = (*rand)() * (bottom - top) + top;
         return p;
     }
 
     point_type bound(point_type a) const
     {
         BOOST_USING_STD_MIN();
         BOOST_USING_STD_MAX();
         point_type p;
         p[0] = min BOOST_PREVENT_MACRO_SUBSTITUTION(
             right, max BOOST_PREVENT_MACRO_SUBSTITUTION(left, a[0]));
         p[1] = min BOOST_PREVENT_MACRO_SUBSTITUTION(
             bottom, max BOOST_PREVENT_MACRO_SUBSTITUTION(top, a[1]));
         return p;
     }
 
     double distance_from_boundary(point_type a) const
     {
         BOOST_USING_STD_MIN();
         BOOST_USING_STD_MAX();
 #ifndef BOOST_NO_STDC_NAMESPACE
         using std::abs;
 #endif
         double dist = abs(left - a[0]);
         dist = min BOOST_PREVENT_MACRO_SUBSTITUTION(dist, abs(right - a[0]));
         dist = min BOOST_PREVENT_MACRO_SUBSTITUTION(dist, abs(top - a[1]));
         dist = min BOOST_PREVENT_MACRO_SUBSTITUTION(dist, abs(bottom - a[1]));
         return dist;
     }
 
     point_type center() const
     {
         point_type result;
         result[0] = (left + right) / 2.;
         result[1] = (top + bottom) / 2.;
         return result;
     }
 
     point_type origin() const
     {
         point_type result;
         result[0] = left;
         result[1] = top;
         return result;
     }
 
     point_difference_type extent() const
     {
         point_difference_type result;
         result[0] = right - left;
         result[1] = bottom - top;
         return result;
     }
 
 private:
     shared_ptr< RandomNumberGenerator > gen_ptr;
     shared_ptr< rand_t > rand;
     double left, top, right, bottom;
 };
 
 template < typename RandomNumberGenerator = minstd_rand >
 class cube_topology : public hypercube_topology< 3, RandomNumberGenerator >
 {
     typedef hypercube_topology< 3, RandomNumberGenerator > inherited;
 
 public:
     explicit cube_topology(double scaling = 1.0) : inherited(scaling) {}
 
     cube_topology(RandomNumberGenerator& gen, double scaling = 1.0)
     : inherited(gen, scaling)
     {
     }
 };
 
 template < std::size_t Dims, typename RandomNumberGenerator = minstd_rand >
 class ball_topology : public convex_topology< Dims >
 {
     typedef uniform_01< RandomNumberGenerator, double > rand_t;
 
 public:
     typedef typename convex_topology< Dims >::point_type point_type;
     typedef typename convex_topology< Dims >::point_difference_type
         point_difference_type;
 
     explicit ball_topology(double radius = 1.0)
     : gen_ptr(new RandomNumberGenerator)
     , rand(new rand_t(*gen_ptr))
     , radius(radius)
     {
     }
 
     ball_topology(RandomNumberGenerator& gen, double radius = 1.0)
     : gen_ptr(), rand(new rand_t(gen)), radius(radius)
     {
     }
 
     point_type random_point() const
     {
         point_type p;
         double dist_sum;
         do
         {
             dist_sum = 0.0;
             for (std::size_t i = 0; i < Dims; ++i)
             {
                 double x = (*rand)() * 2 * radius - radius;
                 p[i] = x;
                 dist_sum += x * x;
             }
         } while (dist_sum > radius * radius);
         return p;
     }
 
     point_type bound(point_type a) const
     {
         BOOST_USING_STD_MIN();
         BOOST_USING_STD_MAX();
         double r = 0.;
         for (std::size_t i = 0; i < Dims; ++i)
             r = boost::math::hypot(r, a[i]);
         if (r <= radius)
             return a;
         double scaling_factor = radius / r;
         point_type p;
         for (std::size_t i = 0; i < Dims; ++i)
             p[i] = a[i] * scaling_factor;
         return p;
     }
 
     double distance_from_boundary(point_type a) const
     {
         double r = 0.;
         for (std::size_t i = 0; i < Dims; ++i)
             r = boost::math::hypot(r, a[i]);
         return radius - r;
     }
 
     point_type center() const
     {
         point_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = 0;
         return result;
     }
 
     point_type origin() const
     {
         point_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = -radius;
         return result;
     }
 
     point_difference_type extent() const
     {
         point_difference_type result;
         for (std::size_t i = 0; i < Dims; ++i)
             result[i] = 2. * radius;
         return result;
     }
 
 private:
     shared_ptr< RandomNumberGenerator > gen_ptr;
     shared_ptr< rand_t > rand;
     double radius;
 };
 
 template < typename RandomNumberGenerator = minstd_rand >
 class circle_topology : public ball_topology< 2, RandomNumberGenerator >
 {
     typedef ball_topology< 2, RandomNumberGenerator > inherited;
 
 public:
     explicit circle_topology(double radius = 1.0) : inherited(radius) {}
 
     circle_topology(RandomNumberGenerator& gen, double radius = 1.0)
     : inherited(gen, radius)
     {
     }
 };
 
 template < typename RandomNumberGenerator = minstd_rand >
 class sphere_topology : public ball_topology< 3, RandomNumberGenerator >
 {
     typedef ball_topology< 3, RandomNumberGenerator > inherited;
 
 public:
     explicit sphere_topology(double radius = 1.0) : inherited(radius) {}
 
     sphere_topology(RandomNumberGenerator& gen, double radius = 1.0)
     : inherited(gen, radius)
     {
     }
 };
 
 template < typename RandomNumberGenerator = minstd_rand > class heart_topology
 {
     // Heart is defined as the union of three shapes:
     // Square w/ corners (+-1000, -1000), (0, 0), (0, -2000)
     // Circle centered at (-500, -500) radius 500*sqrt(2)
     // Circle centered at (500, -500) radius 500*sqrt(2)
     // Bounding box (-1000, -2000) - (1000, 500*(sqrt(2) - 1))
 
     struct point
     {
         point()
         {
             values[0] = 0.0;
             values[1] = 0.0;
         }
         point(double x, double y)
         {
             values[0] = x;
             values[1] = y;
         }
 
         double& operator[](std::size_t i) { return values[i]; }
         double operator[](std::size_t i) const { return values[i]; }
 
     private:
         double values[2];
     };
 
     bool in_heart(point p) const
     {
 #ifndef BOOST_NO_STDC_NAMESPACE
         using std::abs;
 #endif
 
         if (p[1] < abs(p[0]) - 2000)
             return false; // Bottom
         if (p[1] <= -1000)
             return true; // Diagonal of square
         if (boost::math::hypot(p[0] - -500, p[1] - -500)
             <= 500. * boost::math::constants::root_two< double >())
             return true; // Left circle
         if (boost::math::hypot(p[0] - 500, p[1] - -500)
             <= 500. * boost::math::constants::root_two< double >())
             return true; // Right circle
         return false;
     }
 
     bool segment_within_heart(point p1, point p2) const
     {
         // Assumes that p1 and p2 are within the heart
         if ((p1[0] < 0) == (p2[0] < 0))
             return true; // Same side of symmetry line
         if (p1[0] == p2[0])
             return true; // Vertical
         double slope = (p2[1] - p1[1]) / (p2[0] - p1[0]);
         double intercept = p1[1] - p1[0] * slope;
         if (intercept > 0)
             return false; // Crosses between circles
         return true;
     }
 
     typedef uniform_01< RandomNumberGenerator, double > rand_t;
 
 public:
     typedef point point_type;
 
     heart_topology()
     : gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr))
     {
     }
 
     heart_topology(RandomNumberGenerator& gen)
     : gen_ptr(), rand(new rand_t(gen))
     {
     }
 
     point random_point() const
     {
         point result;
         do
         {
             result[0] = (*rand)()
                     * (1000
                         + 1000 * boost::math::constants::root_two< double >())
                 - (500 + 500 * boost::math::constants::root_two< double >());
             result[1] = (*rand)()
                     * (2000
                         + 500
                             * (boost::math::constants::root_two< double >()
                                 - 1))
                 - 2000;
         } while (!in_heart(result));
         return result;
     }
 
     // Not going to provide clipping to bounding region or distance from
     // boundary
 
     double distance(point a, point b) const
     {
         if (segment_within_heart(a, b))
         {
             // Straight line
             return boost::math::hypot(b[0] - a[0], b[1] - a[1]);
         }
         else
         {
             // Straight line bending around (0, 0)
             return boost::math::hypot(a[0], a[1])
                 + boost::math::hypot(b[0], b[1]);
         }
     }
 
     point move_position_toward(point a, double fraction, point b) const
     {
         if (segment_within_heart(a, b))
         {
             // Straight line
             return point(a[0] + (b[0] - a[0]) * fraction,
                 a[1] + (b[1] - a[1]) * fraction);
         }
         else
         {
             double distance_to_point_a = boost::math::hypot(a[0], a[1]);
             double distance_to_point_b = boost::math::hypot(b[0], b[1]);
             double location_of_point = distance_to_point_a
                 / (distance_to_point_a + distance_to_point_b);
             if (fraction < location_of_point)
                 return point(a[0] * (1 - fraction / location_of_point),
                     a[1] * (1 - fraction / location_of_point));
             else
                 return point(b[0]
                         * ((fraction - location_of_point)
                             / (1 - location_of_point)),
                     b[1]
                         * ((fraction - location_of_point)
                             / (1 - location_of_point)));
         }
     }
 
 private:
     shared_ptr< RandomNumberGenerator > gen_ptr;
     shared_ptr< rand_t > rand;
 };
 
 } // namespace boost
 
 #endif // BOOST_GRAPH_TOPOLOGY_HPP

This page was automatically generated by the 2.3.7 LXR engine. The LXR team