Saf/Math/Calculus/Powers.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_CALCULUS_POWERS_H
#define SAF_MATH_CALCULUS_POWERS_H

#include <math.h>
#include "../../Core.h"
#include "../../Type.h"
#include "../../InvalidOperationException.h"
#include "../../ArgumentException.h"

namespace Saf
{
    namespace Math
    {
        namespace Calculus
        {
            template <class T> 
            inline T Sqr(T x)
            {
                return x * x;
            }

            template <class T> 
            inline T Sqrt(T x);

            template <>
            inline Float32 Sqrt(Float32 x)
            {
                return sqrt(x);
            }

            template <> 
            inline Float64 Sqrt(Float64 x)
            {
                return sqrt(x);
            }
            template <class T>
            inline T Pow(T x, T y)
            {
                if (y < 0)
                {
                    throw ArgumentException(SAF_SOURCE_LOCATION, "Function undefined for"
                        " negative exponents.");
                }

                T v = 1;
                while (y-- > 0)
                {
                    v *= x;
                }
                return v;
            }

            template <>
            inline Float32 Pow(Float32 x, Float32 y)
            {
                return pow(x, y);
            }

            template <>
            inline Float64 Pow(Float64 x, Float64 y)
            {
                return pow(x, y);
            }
            template <class T>
            inline bool IsPowerOf2(T val)
            {
                return (val > 0) && ((val & (val - 1)) == 0);
            }

            template <>
            inline bool IsPowerOf2(Float32 val)
            {
                throw InvalidOperationException(SAF_SOURCE_LOCATION, "Function defined for"
                    " integral types only.");
            }

            template <> 
            inline bool IsPowerOf2(Float64 val)
            {
                throw InvalidOperationException(SAF_SOURCE_LOCATION, "Function defined for"
                    " integral types only.");
            }
            template <class T>
            T SAF_DLL_EXPORT RoundUpToPowerOf2(T val);

            template <class T>
            inline T RoundDownToPowerOf2(T val)
            {
                return T(1) << BinaryLogarithm(val);
            }

            template <class T>
            T SAF_DLL_EXPORT NearestPowerOf2(T val);

            template <class T>
            T SAF_DLL_EXPORT BinaryLogarithm(T val);
        }
    }
}

#endif