feat():initial version

install/boost_1_75_0/include/boost/graph/topology.hpp

@@ -0,0 +1,700 @@
+// 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