marvin_Reciprocal.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 RITE_OF_SPRING_MARVIN_RECIPROCAL_H
#define RITE_OF_SPRING_MARVIN_RECIPROCAL_H
#include <marvin/library/marvin_Concepts.h>
namespace marvin::math {
    template <FloatType T>
    struct ReciprocalRange {
        T min;

        T centre;

        T max;
    };
 
    template <FloatType T>
    ReciprocalRange<T> operator+(const ReciprocalRange<T>& other, T constant) {
        return {
            .min = other.min + constant,
            .centre = other.centre + constant,
            .max = other.max + constant
        };
    }
 
    template <FloatType T>
    ReciprocalRange<T> operator-(const ReciprocalRange<T>& other, T constant) {
        return {
            .min = other.min - constant,
            .centre = other.centre - constant,
            .max = other.max - constant
        };
    }
 
    template <FloatType T>
    ReciprocalRange<T> operator*(const ReciprocalRange<T>& other, T constant) {
        return {
            .min = other.min * constant,
            .centre = other.centre * constant,
            .max = other.max * constant
        };
    }
 
    template <FloatType T>
    ReciprocalRange<T> operator/(const ReciprocalRange<T>& other, T constant) {
        return {
            .min = other.min / constant,
            .centre = other.centre / constant,
            .max = other.max / constant
        };
    }
 

    template <FloatType T>
    class Reciprocal final {
    public:
        Reciprocal(ReciprocalRange<T> src, ReciprocalRange<T> dest);
        explicit Reciprocal(ReciprocalRange<T> dest);
        T operator()(T toMap) noexcept;
 
    private:
        T m_a, m_b, m_c, m_d;
    };
} // namespace marvin::math
 
#endif // RITE_OF_SPRING_MARVIN_RECIPROCAL_H