numeric.hpp

Go to the documentation of this file.

/* 
 * eDSP, A cross-platform Digital Signal Processing library written in modern C++.
 * Copyright (C) 2018 Mohammed Boujemaoui Boulaghmoudi, All rights reserved.
 *
 * 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 3 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 width
 * this program.  If not, see <http://www.gnu.org/licenses/>

 * File: numeric.hpp
 * Date: 04/10/18
 * Author: Mohammed Boujemaoui Boulaghmoudi
 */

#ifndef EDSP_NUMERIC_HPP
#define EDSP_NUMERIC_HPP

#include <cmath>
#include <cstdint>
#include <complex>
#include <random>

namespace edsp { inline namespace math {

    template <typename T>
    constexpr bool is_negative(T x) {
        return x < 0;
    }

    template <typename T>
    constexpr bool is_odd(T x) {
        return (x % 2) == 1;
    }

    template <typename T>
    constexpr bool is_even(T x) {
        return !is_odd(x);
    }

    template <typename T>
    constexpr bool is_power_two(T x) {
        const auto tmp = static_cast<std::int32_t>(x);
        return tmp != 0 && !(tmp & (tmp - 1));
    }

    template <typename T>
    constexpr bool is_denormal(T x) {
        return std::fpclassify(x) == FP_SUBNORMAL;
    }

    template <typename T>
    constexpr bool is_normal(T x) {
        return std::fpclassify(x) == FP_NORMAL;
    }

    template <typename T>
    constexpr bool is_zero(T x) {
        return std::fpclassify(x) == FP_ZERO;
    }

    template <typename T>
    constexpr bool is_nan(T x) noexcept {
        return std::isnan(x);
    }

    template <typename T>
    constexpr bool is_inf(T x) {
        return std::fpclassify(x) == FP_INFINITE;
    }

    template <typename T>
    constexpr bool is_prime(T x) {
        auto n = static_cast<std::uint64_t>(x);
        if (n <= 1)
            return 0;
        else if (n <= 3)
            return 1;
        else if (!(n & 1))
            return 0;
        else if (!(n % 3))
            return 0;
        std::uint64_t r = 5;
        while (r * r <= n) {
            if ((n % r) == 0 || (n % (r + 2)) == 0)
                return 0;
            r += 6;
        }
        return false;
    }

    template <typename T>
    constexpr T sign(T x) noexcept {
        return is_negative(x) ? static_cast<T>(-1) : static_cast<T>(1);
    }

    template <typename T>
    constexpr T next_power_two(T x) {
        if (is_negative(x)) {
            return 0;
        } else if (is_power_two(x)) {
            return x;
        } else {
            auto _x = static_cast<int32_t>(x);
            --_x;
            _x |= _x >> 1;
            _x |= _x >> 2;
            _x |= _x >> 4;
            _x |= _x >> 8;
            _x |= _x >> 16;
            return static_cast<T>(_x + 1);
        }
    }

    template <typename T>
    constexpr T square(T x) {
        return x * x;
    }

    template <typename T>
    constexpr T fract(T x) {
        return x - std::floor(x);
    }

    template <typename T>
    constexpr T inv(T x) {
        return static_cast<T>(1) / x;
    }

    template <typename T>
    constexpr T half(T x) {
        return 0.5 * x;
    }

    template <typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, T>::type rand(T min, T max) {
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_real_distribution<T> distribution(min, max);
        return distribution(eng);
    }

    template <typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, T>::type rand() {
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_real_distribution<T> distribution(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
        return distribution(eng);
    }

    template <typename T>
    inline typename std::enable_if<std::is_integral<T>::value, T>::type rand(T min, T max) {
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_int_distribution<T> distribution(min, max);
        return distribution(eng);
    }

    template <typename T>
    inline typename std::enable_if<std::is_integral<T>::value, T>::type rand() {
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_int_distribution<T> distribution(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
        return distribution(eng);
    }

    enum distances {
        manhattan,
        euclidean,
        logarithmic
    };


    namespace internal {

        template <distances d>
        struct distance {};

        template <>
        struct distance<distances::manhattan> {
            template <typename T>
            constexpr T operator()(T x, T y) noexcept {
                return x - y;
            }
        };

        template <>
        struct distance<distances::euclidean> {
            template <typename T>
            constexpr T operator()(T x, T y) noexcept {
                return math::square(x - y);
            }
        };


        template <>
        struct distance<distances::logarithmic> {
            template <typename T>
            constexpr T operator()(T x, T y) noexcept {
                return std::log(std::abs(x) / std::abs(y));
            }
        };
    }


    template <distances d, typename T>
    constexpr T distance(T x, T y) noexcept {
        return internal::distance<d>{}(x, y);
    }



}} // namespace edsp::math

#endif //EDSP_NUMERIC_HPP