Fixed.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_FIXED_HPP
#define PLAYRHO_COMMON_FIXED_HPP
 
#include <PlayRho/Common/Wider.hpp>
#include <PlayRho/Common/Templates.hpp>
 
#include <cstdint>
#include <limits>
#include <cassert>
#include <type_traits>
#include <iostream>
 
namespace playrho {
 
    template <typename BASE_TYPE, unsigned int FRACTION_BITS>
    class Fixed
    {
    public:
        
        using value_type = BASE_TYPE;
        
        static PLAYRHO_CONSTEXPR const unsigned int TotalBits = sizeof(BASE_TYPE) * 8;
 
        static PLAYRHO_CONSTEXPR const unsigned int FractionBits = FRACTION_BITS;
        
        static PLAYRHO_CONSTEXPR const unsigned int WholeBits = TotalBits - FractionBits;
 
        static PLAYRHO_CONSTEXPR const value_type ScaleFactor = static_cast<value_type>(1u << FractionBits);
 
        enum class CmpResult
        {
            Incomparable,
            Equal,
            LessThan,
            GreaterThan
        };
 
        static PLAYRHO_CONSTEXPR inline Fixed GetMin() noexcept
        {
            return Fixed{1, scalar_type{1}};
        }
        
        static PLAYRHO_CONSTEXPR inline Fixed GetInfinity() noexcept
        {
            return Fixed{numeric_limits::max(), scalar_type{1}};
        }
        
        static PLAYRHO_CONSTEXPR inline Fixed GetMax() noexcept
        {
            // max reserved for +inf
            return Fixed{numeric_limits::max() - 1, scalar_type{1}};
        }
 
        static PLAYRHO_CONSTEXPR inline Fixed GetNaN() noexcept
        {
            return Fixed{numeric_limits::lowest(), scalar_type{1}};
        }
 
        static PLAYRHO_CONSTEXPR inline Fixed GetNegativeInfinity() noexcept
        {
            // lowest reserved for NaN
            return Fixed{numeric_limits::lowest() + 1, scalar_type{1}};
        }
        
        static PLAYRHO_CONSTEXPR inline Fixed GetLowest() noexcept
        {
            // lowest reserved for NaN
            // lowest + 1 reserved for -inf
            return Fixed{numeric_limits::lowest() + 2, scalar_type{1}};
        }
 
        template <typename T>
        static PLAYRHO_CONSTEXPR inline value_type GetFromFloat(T val) noexcept
        {
            static_assert(std::is_floating_point<T>::value, "floating point value required");
            // Note: std::isnan(val) *NOT* constant expression, so can't use here!
            return !(val <= 0 || val >= 0)? GetNaN().m_value:
                (val > static_cast<long double>(GetMax()))? GetInfinity().m_value:
                (val < static_cast<long double>(GetLowest()))? GetNegativeInfinity().m_value:
                static_cast<value_type>(val * ScaleFactor);
        }
        
        template <typename T>
        static PLAYRHO_CONSTEXPR inline value_type GetFromSignedInt(T val) noexcept
        {
            static_assert(std::is_integral<T>::value, "integral value required");
            static_assert(std::is_signed<T>::value, "must be signed");
            return (val > (GetMax().m_value / ScaleFactor))? GetInfinity().m_value:
                (val < (GetLowest().m_value / ScaleFactor))? GetNegativeInfinity().m_value:
                static_cast<value_type>(val * ScaleFactor);
        }
        
        template <typename T>
        static PLAYRHO_CONSTEXPR inline value_type GetFromUnsignedInt(T val) noexcept
        {
            static_assert(std::is_integral<T>::value, "integral value required");
            static_assert(!std::is_signed<T>::value, "must be unsigned");
            const auto max = static_cast<unsigned_wider_type>(GetMax().m_value / ScaleFactor);
            return (val > max)? GetInfinity().m_value: static_cast<value_type>(val) * ScaleFactor;
        }
        
        Fixed() = default;
        
        PLAYRHO_CONSTEXPR inline Fixed(long double val) noexcept:
            m_value{GetFromFloat(val)}
        {
            // Intentionally empty
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(double val) noexcept:
            m_value{GetFromFloat(val)}
        {
            // Intentionally empty
        }
 
        PLAYRHO_CONSTEXPR inline Fixed(float val) noexcept:
            m_value{GetFromFloat(val)}
        {
            // Intentionally empty
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(unsigned long long val) noexcept:
            m_value{GetFromUnsignedInt(val)}
        {
            // Intentionally empty.
        }
 
        PLAYRHO_CONSTEXPR inline Fixed(unsigned long val) noexcept:
            m_value{GetFromUnsignedInt(val)}
        {
            // Intentionally empty.
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(unsigned int val) noexcept:
            m_value{GetFromUnsignedInt(val)}
        {
            // Intentionally empty.
        }
 
        PLAYRHO_CONSTEXPR inline Fixed(long long val) noexcept:
            m_value{GetFromSignedInt(val)}
        {
            // Intentionally empty.
        }
 
        PLAYRHO_CONSTEXPR inline Fixed(long val) noexcept:
            m_value{GetFromSignedInt(val)}
        {
            // Intentionally empty.
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(int val) noexcept:
            m_value{GetFromSignedInt(val)}
        {
            // Intentionally empty.
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(short val) noexcept:
            m_value{GetFromSignedInt(val)}
        {
            // Intentionally empty.
        }
        
        PLAYRHO_CONSTEXPR inline Fixed(value_type val, unsigned int fraction) noexcept:
            m_value{static_cast<value_type>(static_cast<std::uint32_t>(val * ScaleFactor) | fraction)}
        {
            // Intentionally empty.
        }
        
        template <typename BT, unsigned int FB>
        PLAYRHO_CONSTEXPR inline Fixed(const Fixed<BT, FB> val) noexcept:
            Fixed(static_cast<long double>(val))
        {
            // Intentionally empty
        }
        
        // Methods
        
        template <typename T>
        PLAYRHO_CONSTEXPR inline T ConvertTo() const noexcept
        {
            return isnan()? std::numeric_limits<T>::signaling_NaN():
                !isfinite()? std::numeric_limits<T>::infinity() * getsign():
                    m_value / static_cast<T>(ScaleFactor);
        }
 
        PLAYRHO_CONSTEXPR inline CmpResult Compare(const Fixed other) const noexcept
        {
            if (isnan() || other.isnan())
            {
                return CmpResult::Incomparable;
            }
            if (m_value < other.m_value)
            {
                return CmpResult::LessThan;
            }
            if (m_value > other.m_value)
            {
                return CmpResult::GreaterThan;
            }
            return CmpResult::Equal;
        }
 
        // Unary operations
 
        explicit PLAYRHO_CONSTEXPR inline operator long double() const noexcept
        {
            return ConvertTo<long double>();
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator double() const noexcept
        {
            return ConvertTo<double>();
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator float() const noexcept
        {
            return ConvertTo<float>();
        }
    
        explicit PLAYRHO_CONSTEXPR inline operator long long() const noexcept
        {
            return m_value / ScaleFactor;
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator long() const noexcept
        {
            return m_value / ScaleFactor;
        }
 
        explicit PLAYRHO_CONSTEXPR inline operator unsigned long long() const noexcept
        {
            // Behavior is undefined if m_value is negative
            return static_cast<unsigned long long>(m_value / ScaleFactor);
        }
 
        explicit PLAYRHO_CONSTEXPR inline operator unsigned long() const noexcept
        {
            // Behavior is undefined if m_value is negative
            return static_cast<unsigned long>(m_value / ScaleFactor);
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator unsigned int() const noexcept
        {
            // Behavior is undefined if m_value is negative
            return static_cast<unsigned int>(m_value / ScaleFactor);
        }
 
        explicit PLAYRHO_CONSTEXPR inline operator int() const noexcept
        {
            return static_cast<int>(m_value / ScaleFactor);
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator short() const noexcept
        {
            return static_cast<short>(m_value / ScaleFactor);
        }
        
        PLAYRHO_CONSTEXPR inline Fixed operator- () const noexcept
        {
            return (isnan())? *this: Fixed{-m_value, scalar_type{1}};
        }
        
        PLAYRHO_CONSTEXPR inline Fixed operator+ () const noexcept
        {
            return *this;
        }
        
        explicit PLAYRHO_CONSTEXPR inline operator bool() const noexcept
        {
            return m_value != 0;
        }
        
        PLAYRHO_CONSTEXPR inline bool operator! () const noexcept
        {
            return m_value == 0;
        }
        
        PLAYRHO_CONSTEXPR inline Fixed& operator+= (Fixed val) noexcept
        {
            if (isnan() || val.isnan()
                || ((m_value == GetInfinity().m_value) && (val.m_value == GetNegativeInfinity().m_value))
                || ((m_value == GetNegativeInfinity().m_value) && (val.m_value == GetInfinity().m_value))
                )
            {
                *this = GetNaN();
            }
            else if (val.m_value == GetInfinity().m_value)
            {
                m_value = GetInfinity().m_value;
            }
            else if (val.m_value == GetNegativeInfinity().m_value)
            {
                m_value = GetNegativeInfinity().m_value;
            }
            else if (isfinite() && val.isfinite())
            {
                const auto result = wider_type{m_value} + val.m_value;
                if (result > GetMax().m_value)
                {
                    // overflow from max
                    m_value = GetInfinity().m_value;
                }
                else if (result < GetLowest().m_value)
                {
                    // overflow from lowest
                    m_value = GetNegativeInfinity().m_value;
                }
                else
                {
                    m_value = static_cast<value_type>(result);
                }
            }
            return *this;
        }
 
        PLAYRHO_CONSTEXPR inline Fixed& operator-= (Fixed val) noexcept
        {
            if (isnan() || val.isnan()
                || ((m_value == GetInfinity().m_value) && (val.m_value == GetInfinity().m_value))
                || ((m_value == GetNegativeInfinity().m_value) && (val.m_value == GetNegativeInfinity().m_value))
            )
            {
                *this = GetNaN();
            }
            else if (val.m_value == GetInfinity().m_value)
            {
                m_value = GetNegativeInfinity().m_value;
            }
            else if (val.m_value == GetNegativeInfinity().m_value)
            {
                m_value = GetInfinity().m_value;
            }
            else if (isfinite() && val.isfinite())
            {
                const auto result = wider_type{m_value} - val.m_value;
                if (result > GetMax().m_value)
                {
                    // overflow from max
                    m_value = GetInfinity().m_value;
                }
                else if (result < GetLowest().m_value)
                {
                    // overflow from lowest
                    m_value = GetNegativeInfinity().m_value;
                }
                else
                {
                    m_value = static_cast<value_type>(result);
                }
            }
            return *this;
        }
 
        PLAYRHO_CONSTEXPR inline Fixed& operator*= (Fixed val) noexcept
        {
            if (isnan() || val.isnan())
            {
                *this = GetNaN();
            }
            else if (!isfinite() || !val.isfinite())
            {
                if (m_value == 0 || val.m_value == 0)
                {
                    *this = GetNaN();
                }
                else
                {
                    *this = ((m_value > 0) != (val.m_value > 0))? -GetInfinity(): GetInfinity();
                }
            }
            else
            {
                const auto product = wider_type{m_value} * wider_type{val.m_value};
                const auto result = product / ScaleFactor;
                
                if (product != 0 && result == 0)
                {
                    // underflow
                    m_value = static_cast<value_type>(result);
                }
                else if (result > GetMax().m_value)
                {
                    // overflow from max
                    m_value = GetInfinity().m_value;
                }
                else if (result < GetLowest().m_value)
                {
                    // overflow from lowest
                    m_value = GetNegativeInfinity().m_value;
                }
                else
                {
                    m_value = static_cast<value_type>(result);
                }
            }
            return *this;
        }
 
        PLAYRHO_CONSTEXPR inline Fixed& operator/= (Fixed val) noexcept
        {
            if (isnan() || val.isnan())
            {
                *this = GetNaN();
            }
            else if (!isfinite() && !val.isfinite())
            {
                *this = GetNaN();
            }
            else if (!isfinite())
            {
                *this = ((m_value > 0) != (val.m_value > 0))? -GetInfinity(): GetInfinity();
            }
            else if (!val.isfinite())
            {
                *this = 0;
            }
            else
            {
                const auto product = wider_type{m_value} * ScaleFactor;
                const auto result = product / val.m_value;
                
                if (product != 0 && result == 0)
                {
                    // underflow
                    m_value = static_cast<value_type>(result);
                }
                else if (result > GetMax().m_value)
                {
                    // overflow from max
                    m_value = GetInfinity().m_value;
                }
                else if (result < GetLowest().m_value)
                {
                    // overflow from lowest
                    m_value = GetNegativeInfinity().m_value;
                }
                else
                {
                    m_value = static_cast<value_type>(result);
                }
            }
            return *this;
        }
        
        PLAYRHO_CONSTEXPR inline Fixed& operator%= (Fixed val) noexcept
        {
            assert(!isnan());
            assert(!val.isnan());
 
            m_value %= val.m_value;
            return *this;
        }
        
        PLAYRHO_CONSTEXPR inline bool isfinite() const noexcept
        {
            return (m_value > GetNegativeInfinity().m_value)
            && (m_value < GetInfinity().m_value);
        }
        
        PLAYRHO_CONSTEXPR inline bool isnan() const noexcept
        {
            return m_value == GetNaN().m_value;
        }
        
        PLAYRHO_CONSTEXPR inline int getsign() const noexcept
        {
            return (m_value >= 0)? +1: -1;
        }
 
    private:
        
        using wider_type = typename Wider<value_type>::type;
 
        using unsigned_wider_type = typename std::make_unsigned<wider_type>::type;
 
        struct scalar_type
        {
            value_type value = 1; 
        };
        
        using numeric_limits = std::numeric_limits<value_type>;
        
        PLAYRHO_CONSTEXPR inline Fixed(value_type val, scalar_type scalar) noexcept:
            m_value{val * scalar.value}
        {
            // Intentionally empty.
        }
        
        value_type m_value; 
    };
 
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator== (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        return lhs.Compare(rhs) == Fixed<BT, FB>::CmpResult::Equal;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator!= (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        return lhs.Compare(rhs) != Fixed<BT, FB>::CmpResult::Equal;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator< (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        return lhs.Compare(rhs) == Fixed<BT, FB>::CmpResult::LessThan;
    }
 
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator> (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        return lhs.Compare(rhs) == Fixed<BT, FB>::CmpResult::GreaterThan;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator<= (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed<BT, FB>::CmpResult::LessThan ||
               result == Fixed<BT, FB>::CmpResult::Equal;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool operator>= (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed<BT, FB>::CmpResult::GreaterThan || result == Fixed<BT, FB>::CmpResult::Equal;
    }
 
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> operator+ (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        lhs += rhs;
        return lhs;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> operator- (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        lhs -= rhs;
        return lhs;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> operator* (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        lhs *= rhs;
        return lhs;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> operator/ (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        lhs /= rhs;
        return lhs;
    }
    
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> operator% (Fixed<BT, FB> lhs, Fixed<BT, FB> rhs) noexcept
    {
        lhs %= rhs;
        return lhs;
    }
 
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool AlmostZero(Fixed<BT, FB> value)
    {
        return value == 0;
    }
 
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline bool AlmostEqual(Fixed<BT, FB> x, Fixed<BT, FB> y, int ulp = 2)
    {
        return abs(x - y) <= Fixed<BT, FB>{0, static_cast<std::uint32_t>(ulp)};
    }
    
#ifdef CONFLICT_WITH_GETINVALID
    template <typename BT, unsigned int FB>
    PLAYRHO_CONSTEXPR inline Fixed<BT, FB> GetInvalid() noexcept
    {
        return Fixed<BT, FB>::GetNaN();
    }
#endif // CONFLICT_WITH_GETINVALID
 
    template <typename BT, unsigned int FB>
    inline ::std::ostream& operator<<(::std::ostream& os, const Fixed<BT, FB>& value)
    {
        return os << static_cast<double>(value);
    }
 
    using Fixed32 = Fixed<std::int32_t,9>;
 
    // Fixed32 free functions.
    
    template <>
    PLAYRHO_CONSTEXPR inline Fixed32 GetInvalid() noexcept
    {
        return Fixed32::GetNaN();
    }
    
    PLAYRHO_CONSTEXPR inline Fixed32 operator+ (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        lhs += rhs;
        return lhs;
    }
 
    PLAYRHO_CONSTEXPR inline Fixed32 operator- (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        lhs -= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed32 operator* (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        lhs *= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed32 operator/ (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        lhs /= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed32 operator% (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        lhs %= rhs;
        return lhs;
    }    
    
    PLAYRHO_CONSTEXPR inline bool operator== (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        return lhs.Compare(rhs) == Fixed32::CmpResult::Equal;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator!= (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        return lhs.Compare(rhs) != Fixed32::CmpResult::Equal;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator <= (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return (result == Fixed32::CmpResult::LessThan) || (result == Fixed32::CmpResult::Equal);
    }
    
    PLAYRHO_CONSTEXPR inline bool operator >= (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return (result == Fixed32::CmpResult::GreaterThan) || (result == Fixed32::CmpResult::Equal);
    }
    
    PLAYRHO_CONSTEXPR inline bool operator < (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed32::CmpResult::LessThan;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator > (Fixed32 lhs, Fixed32 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed32::CmpResult::GreaterThan;
    }
    
    template <>
    inline const char* GetTypeName<Fixed32>() noexcept
    {
        return "Fixed32";
    }
 
#ifdef PLAYRHO_INT128
    // Fixed64 free functions.
 
    using Fixed64 = Fixed<std::int64_t,24>;
    
    template <>
    PLAYRHO_CONSTEXPR inline Fixed64 GetInvalid() noexcept
    {
        return Fixed64::GetNaN();
    }
 
    PLAYRHO_CONSTEXPR inline Fixed64 operator+ (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        lhs += rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed64 operator- (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        lhs -= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed64 operator* (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        lhs *= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed64 operator/ (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        lhs /= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline Fixed64 operator% (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        lhs %= rhs;
        return lhs;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator== (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        return lhs.Compare(rhs) == Fixed64::CmpResult::Equal;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator!= (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        return lhs.Compare(rhs) != Fixed64::CmpResult::Equal;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator <= (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return (result == Fixed64::CmpResult::LessThan) || (result == Fixed64::CmpResult::Equal);
    }
    
    PLAYRHO_CONSTEXPR inline bool operator >= (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return (result == Fixed64::CmpResult::GreaterThan) || (result == Fixed64::CmpResult::Equal);
    }
    
    PLAYRHO_CONSTEXPR inline bool operator < (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed64::CmpResult::LessThan;
    }
    
    PLAYRHO_CONSTEXPR inline bool operator > (Fixed64 lhs, Fixed64 rhs) noexcept
    {
        const auto result = lhs.Compare(rhs);
        return result == Fixed64::CmpResult::GreaterThan;
    }
 
    template<> struct Wider<Fixed32> {
        using type = Fixed64; 
    };
    
    template <>
    inline const char* GetTypeName<Fixed64>() noexcept
    {
        return "Fixed64";
    }
 
#endif /* PLAYRHO_INT128 */
 
} // namespace playrho
 
#endif // PLAYRHO_COMMON_FIXED_HPP