diff --git a/include/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp b/include/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp
new file mode 100644
index 000000000..d4c94b5c0
--- /dev/null
+++ b/include/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp
@@ -0,0 +1,338 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/calculation_type.hpp>
+
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <std::size_t I>
+struct compute_pythagoras_box_box
+{
+    template <typename Box1, typename Box2, typename T>
+    static inline void apply(Box1 const& box1, Box2 const& box2, T& result)
+    {
+        T const b1_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box1));
+        T const b1_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box1));
+
+        T const b2_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box2));
+        T const b2_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box2));
+
+        if ( b1_max_coord < b2_min_coord )
+        {
+            T diff = b2_min_coord - b1_max_coord;
+            result += diff * diff;
+        }
+        if ( b1_min_coord > b2_max_coord )
+        {
+            T diff = b1_min_coord - b2_max_coord;
+            result += diff * diff;
+        }
+
+        compute_pythagoras_box_box<I-1>::apply(box1, box2, result);
+    }
+};
+
+template <>
+struct compute_pythagoras_box_box<0>
+{
+    template <typename Box1, typename Box2, typename T>
+    static inline void apply(Box1 const&, Box2 const&, T&)
+    {
+    }
+};
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace comparable
+{
+
+/*!
+\brief Strategy to calculate comparable distance between two boxes
+\ingroup strategies
+\tparam Box1 \tparam_first_box
+\tparam Box2 \tparam_second_box
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CalculationType = void>
+class pythagoras_box_box
+{
+public :
+
+    template <typename Box1, typename Box2>
+    struct calculation_type
+    {
+        typedef typename util::calculation_type::geometric::binary
+            <
+                Box1,
+                Box2,
+                CalculationType
+            >::type type;
+    };
+
+    template <typename Box1, typename Box2>
+    static inline typename calculation_type<Box1, Box2>::type
+    apply(Box1 const& box1, Box2 const& box2)
+    {
+        BOOST_CONCEPT_ASSERT
+            ( (concept::ConstPoint<typename point_type<Box1>::type>) );
+        BOOST_CONCEPT_ASSERT
+            ( (concept::ConstPoint<typename point_type<Box2>::type>) );
+
+        // Calculate distance using Pythagoras
+        // (Leave comment above for Doxygen)
+
+        assert_dimension_equal<Box1, Box2>();
+
+        typename calculation_type<Box1, Box2>::type result(0);
+        
+        detail::compute_pythagoras_box_box
+            <
+                dimension<Box1>::value
+            >::apply(box1, box2, result);
+
+        return result;
+    }
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy to calculate the distance between two points or boxes
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading Notes]
+[note Can be used for boxes with two\, three or more dimensions]
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class pythagoras_box_box
+{
+public :
+
+    template <typename Box1, typename Box2>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              Box1,
+              Box2,
+              CalculationType,
+              double,
+              double // promote integer to double
+          >
+    {};
+
+    /*!
+    \brief applies the distance calculation using pythagoras_box_box
+    \return the calculated distance (including taking the square root)
+    \param box1 first box
+    \param box2 second box
+    */
+    template <typename Box1, typename Box2>
+    static inline typename calculation_type<Box1, Box2>::type
+    apply(Box1 const& box1, Box2 const& box2)
+    {
+        // Don't add std:: for ttmath
+        // The cast is necessary for MSVC which considers sqrt __int64 as an ambiguous call
+        return sqrt
+            (
+                 boost::numeric_cast<typename calculation_type
+                     <
+                         Box1, Box2
+                     >::type>
+                    (
+                        comparable::pythagoras_box_box
+                            <
+                                CalculationType
+                            >::apply(box1, box2)
+                    )
+            );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct tag<pythagoras_box_box<CalculationType> >
+{
+    typedef strategy_tag_distance_box_box type;
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct return_type<distance::pythagoras_box_box<CalculationType>, Box1, Box2>
+    : pythagoras_box_box<CalculationType>::template calculation_type<Box1, Box2>
+{};
+
+
+template <typename CalculationType>
+struct comparable_type<pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type
+    apply(pythagoras_box_box<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct result_from_distance<pythagoras_box_box<CalculationType>, Box1, Box2>
+{
+private:
+    typedef typename return_type
+        <
+            pythagoras_box_box<CalculationType>, Box1, Box2
+        >::type return_type;
+public:
+    template <typename T>
+    static inline return_type
+    apply(pythagoras_box_box<CalculationType> const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::pythagoras_box_box
+template <typename CalculationType>
+struct tag<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef strategy_tag_distance_box_box type;
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct return_type<comparable::pythagoras_box_box<CalculationType>, Box1, Box2>
+    : comparable::pythagoras_box_box
+        <
+            CalculationType
+        >::template calculation_type<Box1, Box2>
+{};
+
+
+
+
+template <typename CalculationType>
+struct comparable_type<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(comparable_type const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct result_from_distance
+    <
+        comparable::pythagoras_box_box<CalculationType>, Box1, Box2
+    >
+{
+private :
+    typedef typename return_type
+        <
+            comparable::pythagoras_box_box<CalculationType>, Box1, Box2
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(comparable::pythagoras_box_box<CalculationType> const&,
+          T const& value)
+    {
+        return_type const v = value;
+        return v * v;
+    }
+};
+
+
+template <typename Box1, typename Box2>
+struct default_strategy
+    <
+        box_tag, Box1, Box2, cartesian_tag, cartesian_tag, void, box_tag
+    >
+{
+    typedef pythagoras_box_box<> type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
diff --git a/include/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp b/include/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp
new file mode 100644
index 000000000..304250167
--- /dev/null
+++ b/include/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp
@@ -0,0 +1,333 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/calculation_type.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <size_t I>
+struct compute_pythagoras_point_box
+{
+    template <typename Point, typename Box, typename T>
+    static inline void apply(Point const& point, Box const& box, T& result)
+    {
+        T const p_coord = boost::numeric_cast<T>(geometry::get<I-1>(point));
+        T const b_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box));
+        T const b_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box));
+
+        if ( p_coord < b_min_coord )
+        {
+            T diff = b_min_coord - p_coord;
+            result += diff * diff;
+        }
+        if ( p_coord > b_max_coord )
+        {
+            T diff = p_coord - b_max_coord;
+            result += diff * diff;
+        }
+
+        compute_pythagoras_point_box<I-1>::apply(point, box, result);
+    }
+};
+
+template <>
+struct compute_pythagoras_point_box<0>
+{
+    template <typename Point, typename Box, typename T>
+    static inline void apply(Point const&, Box const&, T&)
+    {
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace comparable
+{
+
+/*!
+\brief Strategy to calculate comparable distance between two points
+\ingroup strategies
+\tparam Point \tparam_first_point
+\tparam Box \tparam_second_box
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CalculationType = void>
+class pythagoras_point_box
+{
+public :
+
+    template <typename Point, typename Box>
+    struct calculation_type
+    {
+        typedef typename util::calculation_type::geometric::binary
+            <
+                Point, Box, CalculationType
+            >::type type;
+    };
+
+    template <typename Point, typename Box>
+    static inline typename calculation_type<Point, Box>::type
+    apply(Point const& point, Box const& box)
+    {
+        BOOST_CONCEPT_ASSERT( (concept::ConstPoint<Point>) );
+        BOOST_CONCEPT_ASSERT
+            ( (concept::ConstPoint<typename point_type<Box>::type>) );
+
+        // Calculate distance using Pythagoras
+        // (Leave comment above for Doxygen)
+
+        assert_dimension_equal<Point, Box>();
+
+        typename calculation_type<Point, Box>::type result(0);
+        
+        detail::compute_pythagoras_point_box
+            <
+                dimension<Point>::value
+            >::apply(point, box, result);
+
+        return result;
+    }
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy to calculate the distance between two points or boxes
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading Notes]
+[note Can be used for points and boxes with two\, three or more dimensions]
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class pythagoras_point_box
+{
+public :
+
+    template <typename Point, typename Box>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              Point,
+              Box,
+              CalculationType,
+              double,
+              double // promote integer to double
+          >
+    {};
+
+    /*!
+    \brief applies the distance calculation using pythagoras
+    \return the calculated distance (including taking the square root)
+    \param point point
+    \param box box
+    */
+    template <typename Point, typename Box>
+    static inline typename calculation_type<Point, Box>::type
+    apply(Point const& point, Box const& box)
+    {
+        // Don't add std:: for ttmath
+        // The cast is necessary for MSVC which considers sqrt __int64 as an ambiguous call
+        return sqrt
+            (
+                 boost::numeric_cast<typename calculation_type
+                     <
+                         Point, Box
+                     >::type>
+                    (
+                        comparable::pythagoras_point_box
+                            <
+                                CalculationType
+                            >::apply(point, box)
+                    )
+            );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct tag<pythagoras_point_box<CalculationType> >
+{
+    typedef strategy_tag_distance_point_box type;
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct return_type<distance::pythagoras_point_box<CalculationType>, Point, Box>
+    : pythagoras_point_box
+        <
+            CalculationType
+        >::template calculation_type<Point, Box>
+{};
+
+
+template <typename CalculationType>
+struct comparable_type<pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type
+    apply(pythagoras_point_box<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct result_from_distance<pythagoras_point_box<CalculationType>, Point, Box>
+{
+private :
+    typedef typename return_type
+        <
+            pythagoras_point_box<CalculationType>, Point, Box
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(pythagoras_point_box<CalculationType> const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::pythagoras_point_box
+template <typename CalculationType>
+struct tag<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef strategy_tag_distance_point_box type;
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct return_type
+    <
+        comparable::pythagoras_point_box<CalculationType>, Point, Box
+    > : comparable::pythagoras_point_box
+        <
+            CalculationType
+        >::template calculation_type<Point, Box>
+{};
+
+
+
+
+template <typename CalculationType>
+struct comparable_type<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(comparable_type const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct result_from_distance
+    <
+        comparable::pythagoras_point_box<CalculationType>, Point, Box
+    >
+{
+private :
+    typedef typename return_type
+        <
+            comparable::pythagoras_point_box<CalculationType>, Point, Box
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(comparable::pythagoras_point_box<CalculationType> const& ,
+          T const& value)
+    {
+        return_type const v = value;
+        return v * v;
+    }
+};
+
+
+template <typename Point, typename Box>
+struct default_strategy<point_tag, Point, Box, cartesian_tag, cartesian_tag, void, box_tag>
+{
+    typedef pythagoras_point_box<> type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP