rounding.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file rounding.h
///
/// Rigorous rounding of arithmetic operations.
/// This file contains the definition of a class for doing arithmetic
/// operations with controlled rounding directions (upwards/downwards).
/// This class uses the BOOST library.
///
/// @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 July 10, 2007. Last revision: April 12, 2010.


#ifndef _FINRESDYN_ROUNDING_H_
#define _FINRESDYN_ROUNDING_H_


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


// --------------------------------------------------
// -------------- rounding operations ---------------
// --------------------------------------------------

/// A class for rounding operations which uses the BOOST library.
template <class NumType>
class tRounding
{
public:
/// This is an internal macro of the class template "tRounding"
/// which defines arithmetic operations using the operations
/// available in the BOOST library.
#define DEFOP(WHAT) \
        static inline NumType WHAT (const NumType &x, const NumType &y) \
        { \
                NumType result = Rounding. WHAT (x, y); \
                Rounding. to_nearest (); \
                return result; \
        }

        DEFOP(add_down)
        DEFOP(add_up)
        DEFOP(sub_down)
        DEFOP(sub_up)
        DEFOP(mul_down)
        DEFOP(mul_up)
        DEFOP(div_down)
        DEFOP(div_up)

#undef DEFOP

/*      NumType add_down (const NumType &x, const NumType &y) const
        {
                NumType result = Rounding. add_down (x, y);
                Rounding. to_nearest ();
                return result;
        }
*/

        /// The smallest positive representable number.
        /// This function returns the smallest possible positive number,
        /// which typically equals the machine precision and may be
        /// implementation-dependent for different number types.
        static NumType min_number ();

private:
        /// This is an object from the BOOST library which contains
        /// the definitions of arithmetic operations with correct rounding.
        static boost::numeric::interval_lib::rounded_arith_std<NumType>
                Rounding;
}; /* class tRounding */

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

template <>
inline float tRounding<float>::min_number ()
{
        return __FLT_DENORM_MIN__;
} /* min_number */

template <>
inline double tRounding<double>::min_number ()
{
        return __DBL_DENORM_MIN__;
} /* min_number */

template <>
inline long double tRounding<long double>::min_number ()
{
        return __LDBL_DENORM_MIN__;
} /* min_number */

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

template <class NumType>
boost::numeric::interval_lib::rounded_arith_std<NumType>
        tRounding<NumType>::Rounding;


#endif // _FINRESDYN_ROUNDING_H_