Rational.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Rational.h - Run-time rational number handling
 *
 * @author mikee47 <mike@sillyhouse.net>
 *
 * Where calculations all involve constant values use std::ratio to have computations performed at compile time.
 *
 ****/
 
#pragma once
 
#include <cstdint>
#include <ratio>
#include <algorithm>
#include <muldiv.h>
#include <WString.h>
 
template <typename T> struct BasicRatio {
    T num;
    T den;
 
    operator String() const
    {
        String s(num);
        s += '/';
        s += den;
        return s;
    }
};
 
using BasicRatio16 = BasicRatio<uint16_t>;
using BasicRatio32 = BasicRatio<uint32_t>;
using BasicRatio64 = BasicRatio<uint64_t>;
 
template <typename T> struct Ratio : public BasicRatio<T> {
    Ratio() = default;
 
    Ratio(const BasicRatio<T>& r)
    {
        this->num = r.num;
        this->den = r.den;
    }
 
    explicit Ratio(T num, T den = 1)
    {
        set(num, den);
    }
 
    template <T num, T den> void set()
    {
        using R = std::ratio<num, den>;
        this->num = R::num;
        this->den = R::den;
    }
 
    void set(T num, T den = 1)
    {
        // Note: Officially added std::numerics::gcd in C++17
        auto g = std::__gcd(num, den);
        this->num = num / g;
        this->den = den / g;
    }
 
    template <typename ValueType> explicit operator ValueType() const
    {
        return muldiv(this->num, T(1), this->den);
    }
 
    friend Ratio operator*(const Ratio& lhs, const Ratio& rhs)
    {
        return Ratio(lhs.num * rhs.num, lhs.den * rhs.den);
    }
 
    template <typename ValueType> friend ValueType operator*(ValueType lhs, const Ratio& rhs)
    {
        return muldiv(lhs, rhs.num, rhs.den);
    }
 
    template <typename ValueType> friend ValueType operator*(const Ratio& lhs, const ValueType& rhs)
    {
        return rhs * lhs;
    }
 
    friend Ratio operator/(const Ratio& lhs, const Ratio& rhs)
    {
        return Ratio(lhs.num * rhs.den, lhs.den * rhs.num);
    }
 
    template <typename ValueType> friend Ratio operator/(Ratio lhs, const ValueType& rhs)
    {
        return Ratio(lhs.num, lhs.den * rhs);
    }
 
    template <typename ValueType> friend ValueType operator/(ValueType lhs, const Ratio& rhs)
    {
        return muldiv(lhs, rhs.den, rhs.num);
    }
};
 
using Ratio16 = Ratio<uint16_t>;
using Ratio32 = Ratio<uint32_t>;
using Ratio64 = Ratio<uint64_t>;