numberpi.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file numberpi.h
///
/// Rigorous bounds for the number pi.
/// This file contains the definition of two numbers which bound
/// the number pi from below and from above.
/// These numbers are provided for two types: double and long double.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2007-2010 by Pawel Pilarczyk.
//
// This file is part of my research program package.  This is free software;
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation;
// either version 2 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on December 23, 2008. Last revision: December 31, 2008.


#ifndef _FINRESDYN_NUMBERPI_H_
#define _FINRESDYN_NUMBERPI_H_


// BOOST (this header must be included first)
#include "boost/numeric/interval.hpp"


// --------------------------------------------------
// -------- a class that holds the number pi --------
// --------------------------------------------------

/// A class that holds the number pi.
template <class numType>
class tNumberPi
{
public:
        /// A function that returns a lower bound for the number Pi.
        static const numType &lowerBound ();

        /// A function that returns an upper bound for the number Pi.
        static const numType &upperBound ();

private:
        /// A lower bound for the number pi.
        static numType theLowerPi;

        /// An upper bound for the number pi.
        static numType theUpperPi;

        /// Computation of a lower and an upper bound for the number pi.
        static void computeBoundsForPi ();

}; /* class tNumberPi */

// --------------------------------------------------

template <class numType>
inline const numType &tNumberPi<numType>::lowerBound ()
{
        if (theLowerPi < 1)
                computeBoundsForPi ();
        return theLowerPi;
} /* lowerBound */

template <class numType>
inline const numType &tNumberPi<numType>::upperBound ()
{
        if (theUpperPi < 1)
                computeBoundsForPi ();
        return theUpperPi;
} /* upperBound */

template <class numType>
numType tNumberPi<numType>::theLowerPi = 0;

template <class numType>
numType tNumberPi<numType>::theUpperPi = 0;

// --------------------------------------------------

template <>
inline void tNumberPi<float>::computeBoundsForPi ()
{
        theLowerPi = boost::numeric::interval_lib::constants::
                pi_lower<float> ();
        theUpperPi = boost::numeric::interval_lib::constants::
                pi_upper<float> ();
        return;
} /* computeBoundsForPi */

template <>
inline void tNumberPi<double>::computeBoundsForPi ()
{
        theLowerPi = boost::numeric::interval_lib::constants::
                pi_lower<double> ();
        theUpperPi = boost::numeric::interval_lib::constants::
                pi_upper<double> ();
        return;
} /* computeBoundsForPi */

template <>
inline void tNumberPi<long double>::computeBoundsForPi ()
{
        volatile long double approxPi = 3.141592653589793238462643383279\
502884197169399375105820974944592307816406286208998628034825342117067\
982148086513282306647093844609550582231725359408128481117450284102701\
9385211055596446229489549303820L;
        long double approxPi1 = approxPi;
        theLowerPi = tRounding<long double>::sub_down (approxPi1, 1e-198L);
        long double approxPi2 = approxPi;
        theUpperPi = tRounding<long double>::add_up (approxPi2, 1e-198L);
        if (theLowerPi == theUpperPi)
                throw "Wrong rounding for pi.";
        if (theLowerPi >= approxPi)
                throw "Wrong lower bound for pi.";
        if (theUpperPi <= approxPi)
                throw "Wrong upper bound for pi.";
        return;
} /* computeBoundsForPi */


#endif // _FINRESDYN_NUMBERPI_H_

---