/src/trunk2/BAL/Interfaces/BIMath.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007 Pleyo.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Pleyo nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY PLEYO AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL PLEYO OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef BIMATH_H_
#define BIMATH_H_

#ifndef __BAL_MATH_POSIX__
#include <math.h>
#else

#ifdef _MATH_H
# error "Never use <math.h> directly; include <BIMath.h> instead."
#endif

# define M_PI           3.14159265358979323846  /* pi */

namespace BAL {

    class BIMath {
        public:
            // this is mandatory
            ~BIMath(){}

            static float ceilf(float );
            static double ceil(double );

            static float fmodf(float , float );

            static long int lroundf(float );
            static long int lround(double );

            static float floorf(float );
            static double floor(double );

            static float roundf(float );
            static double round(double );

            static double nextafter(double , double );
            static float nextafterf(float , float );

            static int isfinite(double );

            static double fabs(double );

            static double copysign(double , double );

            static double exp(double );

            static double log(double );

            static double sqrt (double );

            static double acos(double );

            static double asin(double );

            static double atan(double );

            static double atan2(double , double );

            static double cos(double );

            static double sin(double );

            static double tan(double );

            static int signbit( double  );

            static double pow(double , double );

            static double fmod(double , double );

            static double log10(double );

            static int isnan( double );

            static int isinf( double );

            static double remainder(double , double );
    };
}

inline float ceilf(float x)
{
    return BAL::BIMath::ceilf( x );
}

inline float fmodf(float x, float y)
{
    return BAL::BIMath::fmodf( x, y );
}

inline long int lroundf(float x)
{
    return BAL::BIMath::lroundf( x );
}

inline float floorf(float x)
{
    return BAL::BIMath::floorf( x );
}

inline float roundf(float x)
{
    return BAL::BIMath::roundf( x );
}

inline double round(double x)
{
    return BAL::BIMath::round( x );
}

inline long int lround(double x)
{
    return BAL::BIMath::lround( x );
}


inline double nextafter(double x, double y)
{
    return BAL::BIMath::nextafter( x, y );
}

inline float nextafterf(float x, float y)
{
    return BAL::BIMath::nextafterf( x, y );
}

inline double floor(double x)
{
    return BAL::BIMath::floor( x );
}

inline int isfinite(double x)
{
    return BAL::BIMath::isfinite( x );
}

inline double fabs(double x)
{
    return BAL::BIMath::fabs( x );
}

inline double copysign(double x, double y)
{
    return BAL::BIMath::copysign( x, y );
}


inline double exp(double x)
{
    return BAL::BIMath::exp( x );
}

inline double log(double x)
{
    return BAL::BIMath::log( x );
}

inline double sqrt (double x)
{
    return BAL::BIMath::sqrt( x );
}

inline double acos(double x)
{
    return BAL::BIMath::acos( x );
}

inline double asin(double x)
{
    return BAL::BIMath::asin( x );
}

inline double atan(double x)
{
    return BAL::BIMath::atan( x );
}

inline double atan2(double y, double x)
{
    return BAL::BIMath::atan2( y, x );
}

inline double ceil(double x)
{
    return BAL::BIMath::ceil( x );
}

inline double cos(double x)
{
    return BAL::BIMath::cos( x );
}

inline double sin(double x)
{
    return BAL::BIMath::sin( x );
}

inline double tan(double x)
{
    return BAL::BIMath::tan( x );
}

inline int signbit( double x )
{
    return BAL::BIMath::signbit( x );
}

inline double pow(double x, double y)
{
    return BAL::BIMath::pow( x, y );
}

inline double fmod(double x, double y)
{
    return BAL::BIMath::fmod( x, y );
}


inline double log10(double x)
{
    return BAL::BIMath::log10( x );
}

inline int isnan( double x)
{
    return BAL::BIMath::isnan( x );
}

inline int isinf( double x)
{
    return BAL::BIMath::isinf( x );
}

inline double remainder(double x, double y)
{
    return BAL::BIMath::remainder( x, y );
}


const double HUGE_VAL = 0x7FF00000UL;
const double NAN = 0x7FC00000UL;

#endif // __MATH__
#endif // BIMATH_H_

---

pleyo.com