Saf/Math/Basic.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library 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 3 of the License, or
    (at your option) any later version.

    Saf 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 Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_MATH_BASIC_H
#define SAF_MATH_BASIC_H

#include <math.h>
#include "../Type.h"

namespace Saf
{
    namespace Math
    {
        template <class T> 
        inline T Abs(T x)
        {
            return x < 0 ? -x : x;
        }

        template <>
        inline Uint8 Abs(Uint8 x)
        {
            return x;
        }

        template <>
        inline Uint16 Abs(Uint16 x)
        {
            return x;
        }

        template <>
        inline Uint32 Abs(Uint32 x)
        {
            return x;
        }

        template <>
        inline Uint64 Abs(Uint64 x)
        {
            return x;
        }
        template <class T>
        inline Int8 Sgn(T val)
        {
            return (val < 0) ? -1 : ((val > 0) ? 1 : 0);
        }

        template <class T> 
        inline T Restrict(T x, T low, T high) 
        { 
            return x > high ? high : (x < low ? low : x); 
        }

        template <class T>
        inline T Round(T v)
        {
            return v;            
        }

        template <>
        inline Float32 Round(Float32 v)
        {
            return (v >= 0) ? floor(v + 0.5f) : ceil(v - 0.5f);
        }

        template <>
        inline Float64 Round(Float64 v)
        {
            return (v >= 0) ? floor(v + 0.5) : ceil(v - 0.5);
        }    
        template <class T>
        inline T IntegerDivCeil(T dividend, T divisor)
        {
            return (dividend == 0) ? 0 : (1 + (dividend - 1) / divisor);
        }
    }
}

#endif