Subject: [Boost-commit] svn:boost r71189 - sandbox/guild/pool/boost/pool/detail
From: john_at_[hidden]
Date: 2011-04-11 13:20:22
Author: johnmaddock
Date: 2011-04-11 13:20:21 EDT (Mon, 11 Apr 2011)
New Revision: 71189
URL: http://svn.boost.org/trac/boost/changeset/71189
Log:
Remove unneeded files.
Removed:
sandbox/guild/pool/boost/pool/detail/ct_gcd_lcm.hpp
sandbox/guild/pool/boost/pool/detail/gcd_lcm.hpp
Deleted: sandbox/guild/pool/boost/pool/detail/ct_gcd_lcm.hpp
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/ct_gcd_lcm.hpp 2011-04-11 13:20:21 EDT (Mon, 11 Apr 2011)
+++ (empty file)
@@ -1,126 +0,0 @@
-// Copyright (C) 2000 Stephen Cleary
-//
-// 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)
-//
-// See http://www.boost.org for updates, documentation, and revision history.
-
-#ifndef BOOST_POOL_CT_GCD_LCM_HPP
-#define BOOST_POOL_CT_GCD_LCM_HPP
-/*!
- \file
- \brief Compile-Time GCD and LCM.
- \details Provides two compile-time algorithms: greatest common divisor and least common multiple.
-
- Selected Quotation from the C++ Standard
-
- 5.19/1: Expressions: Constant Expressions:
- ". . . An integral constant expression can involve only literals (2.13),
- enumerators, const variables or static data members of integral or
- enumeration types initialized with constant expressions (8.5),
- non-type template parameters of integral or enumeration types,
- and sizeof expressions.
- Floating literals (2.13.3) can appear only if they are cast to integral or enumeration types.
- Only type conversions to integral or enumeration types can be used.
- In particular, except in sizeof expressions, functions, class objects, pointers, or references
- shall not be used, and assignment, increment, decrement, function-call,
- or comma operators shall not be used."
-*/
-
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/ice.hpp>
-
-namespace boost {
-
-namespace details {
-namespace pool {
-
-// Compile-time calculation of greatest common divisor and least common multiple
-
-// ct_gcd is a compile-time algorithm that calculates the greatest common
-// divisor of two unsigned integers, using Euclid's algorithm.
-//
-// assumes: A != 0 && B != 0
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace details
-{
- template <unsigned A, unsigned B, bool Bis0>
- struct ct_gcd_helper;
- template <unsigned A, unsigned B>
- struct ct_gcd_helper<A, B, false>
- { //! Helper function.
- //! \tparam A compile-time unsigned integer constant.
- //! \tparam B compile-time unsigned integer constant.
- //! \tparam Bis0 parameter B == 0, or not.
-
- BOOST_STATIC_CONSTANT(unsigned, A_mod_B_ = A % B);
- BOOST_STATIC_CONSTANT(unsigned, value =
- (::boost::details::pool::details::ct_gcd_helper<
- B, static_cast<unsigned>(A_mod_B_),
- ::boost::type_traits::ice_eq<A_mod_B_, 0>::value
- >::value) );
- };
- template <unsigned A, unsigned B>
- struct ct_gcd_helper<A, B, true>
- {
- BOOST_STATIC_CONSTANT(unsigned, value = A);
- };
-} // namespace details
-
-template <unsigned A, unsigned B>
-struct ct_gcd
-{ //! The greatest common divisor of A and B.
- //! \pre A != 0 && B != 0
- BOOST_STATIC_ASSERT(A != 0 && B != 0);
- BOOST_STATIC_CONSTANT(unsigned, value =
- (::boost::details::pool::details::ct_gcd_helper<A, B, false>::value) );
-};
-
-#else
-// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION == true
-// Thanks to Peter Dimov for providing this workaround!
-
-namespace details {
-template<unsigned A> struct ct_gcd2
-{ //! workaround for NO_TEMPLATE_PARTIAL_SPECIALIZATION (Thanks to Peter Dimov).
- template<unsigned B>
- struct helper
- {
- BOOST_STATIC_CONSTANT(unsigned, value = ct_gcd2<B>::helper<A % B>::value);
- };
- template<>
- struct helper<0>
- {
- BOOST_STATIC_CONSTANT(unsigned, value = A);
- };
-};
-} // namespace details
-
-template<unsigned A, unsigned B> struct ct_gcd
-{ //! Compile-time algorithm that calculates the greatest common divisor of A and B.
- //! \pre A != 0 && B != 0.
- BOOST_STATIC_ASSERT(A != 0 && B != 0);
- enum { value = details::ct_gcd2<A>::helper<B>::value };
-};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <unsigned A, unsigned B>
-struct ct_lcm
-{ //! Compile-time algorithm that calculates the least common multiple
- //! of two unsigned integers.
-
- //! \pre A != 0 && B != 0.
- BOOST_STATIC_CONSTANT(unsigned, value =
- (A / ::boost::details::pool::ct_gcd<A, B>::value * B) );
-};
-
-} // namespace pool
-} // namespace details
-
-} // namespace boost
-
-#endif
Deleted: sandbox/guild/pool/boost/pool/detail/gcd_lcm.hpp
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/gcd_lcm.hpp 2011-04-11 13:20:21 EDT (Mon, 11 Apr 2011)
+++ (empty file)
@@ -1,66 +0,0 @@
-// Copyright (C) 2000 Stephen Cleary
-//
-// 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)
-//
-// See http://www.boost.org for updates, documentation, and revision history.
-
-#ifndef BOOST_POOL_GCD_LCM_HPP
-#define BOOST_POOL_GCD_LCM_HPP
-
-/*!
- \file
- \brief GCD and LCM two generic integer algorithms: greatest common divisor and least common multiple..
-*/
-
-namespace boost {
-
-namespace details {
-namespace pool {
-
-// Greatest common divisor and least common multiple.
-
-// gcd is an algorithm that calculates the greatest common divisor of two
-// integers, using Euclid's algorithm.
-//
-// Pre: A > 0 && B > 0
-// Recommended: A > B
-template <typename Integer>
-Integer gcd(Integer A, Integer B)
-{ //! algorithm that calculates the greatest common divisor of two
- //! integers, using Euclid's algorithm.
- //! For faster results, ensure A > B.
- //! \pre A != 0 && B != 0.
- do
- {
- const Integer tmp(B);
- B = A % B;
- A = tmp;
- } while (B != 0);
-
- return A;
-}
-
-//
-// lcm is an algorithm that calculates the least common multiple of two integers.
-//
-// Pre: A > 0 && B > 0
-// Recommended: A > B
-template <typename Integer>
-Integer lcm(const Integer & A, const Integer & B)
-{ //! Algorithm that calculates the least common multiple of two integers.
- //! For faster results, ensure A > B.
- //! \pre A != 0 && B != 0.
- Integer ret = A;
- ret /= gcd(A, B);
- ret *= B;
- return ret;
-}
-
-} // namespace pool
-} // namespace details
-
-} // namespace boost
-
-#endif