math.h

Go to the documentation of this file.

// Xerus - A General Purpose Tensor Library
// Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
// 
// Xerus is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
// 
// Xerus 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 Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with Xerus. If not, see <http://www.gnu.org/licenses/>.
//
// For further information on Xerus visit https://libXerus.org 
// or contact us at contact@libXerus.org.

#pragma once

#include <limits>
#include <cmath>
#include "standard.h"
#include "sfinae.h"

namespace xerus {
    namespace misc {
        template<class T> 
        constexpr int sgn(const T _value) noexcept {
            return (T(0) < _value) - (_value < T(0));
        }
        
        
        template<class T>
        constexpr T sqr(const T &_a) noexcept {
            return _a*_a;
        }
        
        
        template<class T> 
        constexpr T pow(const T& _base, const uint32 _exp) noexcept {
            return _exp==0 ? T(1) : (_exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)));
        }
        
        template<class T> 
        constexpr T pow(const T &_base, const uint64 _exp) noexcept {
            return _exp==0 ? T(1) : (_exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)));
        }
        
        
        template<class T> 
        constexpr T pow(const T &_base, const int64 _exp) noexcept {
            return _exp==0 ? 
                        T(1) :
                        (
                            _exp<0 ? 
                                T( 1/pow(_base, -_exp)) 
                            : 
                                ( _exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)) )
                        );
        }
        
        
        template<class T> 
        constexpr T pow(const T &_base, const int32 _exp) noexcept {
            return _exp==0 ? 
                        T(1) :
                        (
                            _exp<0 ? 
                                T( 1/pow(_base, -_exp)) 
                            : 
                                ( _exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)) )
                        );
        }
        
        
        template<class T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = true>
        bool approx_equal(T _a, T _b, T _eps = 4*std::numeric_limits<T>::epsilon()) noexcept {
            return std::abs(_a-_b) <= _eps*0.5*(std::abs(_a)+std::abs(_b));
        }
        
        
        template<class T, typename std::enable_if<!std::is_floating_point<T>::value, bool>::type = true>
        bool approx_equal(T _a, T _b) {
            return _a == _b;
        }
        
        
        template<class T>
        constexpr bool hard_equal(const T _a, const T _b) noexcept {
            #pragma GCC diagnostic push
                #pragma GCC diagnostic ignored "-Wfloat-equal"
                return _a == _b;
            #pragma GCC diagnostic pop
        }
        
        
        template<class T>
        constexpr bool hard_not_equal(const T _a, const T _b) noexcept {
            #pragma GCC diagnostic push
                #pragma GCC diagnostic ignored "-Wfloat-equal"
                return _a != _b;
            #pragma GCC diagnostic pop
        }
    }
}