marvin_Math.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_MATH_H
#define MARVIN_MATH_H
#include "marvin/library/marvin_Concepts.h"
#include "marvin/utils/marvin_Range.h"
#include <cmath>
#include <algorithm>
#include <span>
#include <complex>
#include <cassert>
#include <numbers>
 
namespace marvin::math {

    template <FloatType T>
    [[nodiscard]] T lerp(T start, T end, T ratio) noexcept {
        const auto interpolated = start + (end - start) * ratio;
        return interpolated;
    }
 

    template <FloatType T>
    [[nodiscard]] T remap(T x, T newMin, T newMax) {
        // (v_n . (mx - mn)) + mn = v
        const auto rescaled = (x * (newMax - newMin)) + newMin;
        return rescaled;
    }

    template <FloatType T>
    [[nodiscard]] T remap(T x, T srcMin, T srcMax, T newMin, T newMax) {
        // (v - mn) / (mx - mn) == v_n
        const auto normalised = (x - srcMin) / (srcMax - srcMin);
        return remap<T>(normalised, newMin, newMax);
    }

    template <FloatType T>
    [[nodiscard]] T remap(T x, marvin::utils::Range<T> srcRange, marvin::utils::Range<T> newRange) {
        return remap<T>(x, srcRange.min, srcRange.max, newRange.min, newRange.max);
    }

    template <FloatType T>
    [[nodiscard]] T remap(T x, marvin::utils::Range<T> newRange) {
        return remap<T>(x, newRange.min, newRange.max);
    }

    template <FloatType T>
    [[nodiscard]] std::span<std::complex<T>> interleavedToComplexView(std::span<T> data) {
        assert(data.size() % 2 == 0);
        std::span<std::complex<T>> complexView{ reinterpret_cast<std::complex<T>*>(data.data()), data.size() / 2 };
        return complexView;
    }

    template <FloatType T>
    [[nodiscard]] std::span<T> complexViewToInterleaved(std::span<std::complex<T>> data) {
        std::span<T> interleavedView{ reinterpret_cast<T*>(data.data()), data.size() * 2 };
        return interleavedView;
    }
    template <FloatType T>
    [[nodiscard]] T sinc(T x) noexcept {
        static constexpr auto epsilon{ static_cast<T>(1e-6) };
        if (std::abs(x) < epsilon) {
            return static_cast<T>(1.0);
        }
        const auto xPi = x * std::numbers::pi_v<T>;
        return std::sin(xPi) / xPi;
    }
 
} // namespace marvin::math
 
#endif