libcoyotl - A Library of C++ Tools

Created by Scott Robert Ladd at Coyote Gulch Productions.

---

realutil.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//
//  realutil.h (libcoyotl)
//
//  A collection of useful functions for working with numbers.
//---------------------------------------------------------------------
//
//  Copyright 1990-2005 Scott Robert Ladd
//
//  This program 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 program 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 program; if not, write to the
//      Free Software Foundation, Inc.
//      59 Temple Place - Suite 330
//      Boston, MA 02111-1307, USA.
//
//-----------------------------------------------------------------------
//
//  For more information on this software package, please visit
//  Scott's web site, Coyote Gulch Productions, at:
//
//      http://www.coyotegulch.com
//  
//-----------------------------------------------------------------------

#if !defined(LIBCOYOTL_REALUTIL_H)
#define LIBCOYOTL_REALUTIL_H

#include <cstddef>
#include <cmath>
#include <limits>

namespace libcoyotl
{

    template <typename T>
    T round_nearest(T x)
    {
        T result, fraction, dummy;

        fraction = fabs(modf(x,&result));

        if (fraction == T(0.0))
            return result;

        if (fraction == T(0.5))
        {
            if (modf(result / T(2.0), &dummy) != T(0.0))
            {
                if (x < T(0.0))
                    result -= T(1.0);
                else
                    result += T(1.0);
            }
        }
        else
        {
            if (fraction > T(0.5))
            {
                if (x < T(0.0))
                    result -= T(1.0);
                else
                    result += T(1.0);
            }
        }

        return result;
    }

    // Set number of significant digits in a floating-point value
    template <typename T>
    T sigdig(T x, unsigned short n)
    {
        T scale_factor, result;

        // is asking for no digits, or more digits than in double, simply return x
        if ((n == 0) || (n > std::numeric_limits<T>::digits10))
            result = x;
        else
        {
            // find a factor of ten such that all significant digits will
            //    be in the integer part of the double
            scale_factor = pow(T(10.0),T((int)n - 1 - (int)floor(log10(fabs(x)))));

            // scale up, round, and scale down
            result = round_nearest(x * scale_factor) / scale_factor;
        }

        return result;
    }


    template <typename T>
    bool are_equal(T a, T b, T tolerance = T(1.0))
    {
        // find the range of tolerance
        T adjustment = tolerance * std::numeric_limits<T>::epsilon();

        // set high and low bounds on a's value
        T low = b - adjustment;
        T hi  = b + adjustment;

        // compare a to range
        return ((a >= low) && (a <= hi));
    }

    // Lowest common multiple
    unsigned long lcm(unsigned long x, unsigned long y);

    // Greatest common denominator
    unsigned long gcd(unsigned long x, unsigned long y);


    template <class T> inline T abs_val(T value)
    {
        return (value < 0 ? (-value) : value);
    }


    inline unsigned long abs_val(unsigned long value)
    {
        return value;
    }


    inline unsigned int abs_val(unsigned int value)
    {
        return value;
    }


    inline unsigned short abs_val(unsigned short value)
    {
        return value;
    }


    inline unsigned char abs_val(unsigned char value)
    {
        return value;
    }


    template <class T> inline T min_of(T x1,T x2)
    {
        return (x1 < x2 ? x1 : x2);
    }


    template <class T> inline T max_of(T x1,T x2)
    {
        return (x1 > x2 ? x1 : x2);
    }


    inline double asinh(const double& x)
    {
        return log(x + sqrt(x * x + 1.0));
    }


    inline double acosh(const double& x)
    {
        return log(x + sqrt(x * x - 1.0));
    }


    inline double atanh(const double& x)
    {
        return log((1.0 + x) / (1.0 - x)) / 2.0;
    }
    
} // end namespace libcoyotl

#endif

---

© 1996-2005 Scott Robert Ladd. All rights reserved.
HTML documentation generated by Dimitri van Heesch's excellent Doxygen tool.