FixedPoint.hh

Go to the documentation of this file.

#ifndef FIXEDPOINT_HH
#define FIXEDPOINT_HH
 
#include "narrow.hh"
#include "serialize.hh"
#include <cmath>
#include <cstdint>
 
namespace openmsx {
 
template<unsigned FRACTION_BITS_>
class FixedPoint {
public:
        static constexpr unsigned FRACTION_BITS = FRACTION_BITS_;
 
private:
        static constexpr int ONE = 1 << FRACTION_BITS;
 
        static constexpr float INV_ONE_F = 1.0f / ONE;
 
        static constexpr double INV_ONE_D = 1.0 / ONE;
 
        static constexpr int FRACTION_MASK = ONE - 1;
 
public:
        [[nodiscard]] static constexpr FixedPoint create(int value) {
                return FixedPoint(value, CreateRawTag{});
        }
 
        constexpr FixedPoint() = default;
 
        // Conversion to fixed point:
 
        explicit constexpr FixedPoint(int i)      : value(i << FRACTION_BITS) {}
        explicit constexpr FixedPoint(unsigned i) : value(i << FRACTION_BITS) {}
        explicit FixedPoint(float  f) : value(narrow_cast<int>(lrintf(f * ONE))) {}
        explicit FixedPoint(double d) : value(narrow_cast<int>(lrint (d * ONE))) {}
 
        [[nodiscard]] static constexpr FixedPoint roundRatioDown(unsigned n, unsigned d) {
                return create(narrow_cast<int>((static_cast<uint64_t>(n) << FRACTION_BITS) / d));
        }
 
        [[nodiscard]] static constexpr int shiftHelper(int x, int s) {
                return (s >= 0) ? (x >> s) : (x << -s);
        }
        template<unsigned BITS2>
        explicit constexpr FixedPoint(FixedPoint<BITS2> other)
                : value(shiftHelper(other.getRawValue(), BITS2 - FRACTION_BITS)) {}
 
        // Conversion from fixed point:
 
        [[nodiscard]] constexpr int toInt() const {
                return value >> FRACTION_BITS;
        }
 
        [[nodiscard]] constexpr float toFloat() const {
                return narrow_cast<float>(value) * INV_ONE_F;
        }
 
        [[nodiscard]] constexpr double toDouble() const {
                return narrow_cast<double>(value) * INV_ONE_D;
        }
 
        [[nodiscard]] constexpr float fractionAsFloat() const {
                return narrow_cast<float>(value & FRACTION_MASK) * INV_ONE_F;
        }
 
        [[nodiscard]] constexpr double fractionAsDouble() const {
                return narrow_cast<double>(value & FRACTION_MASK) * INV_ONE_D;
        }
 
        // Various arithmetic:
 
        [[nodiscard]] constexpr int divAsInt(FixedPoint other) const {
                return value / other.value;
        }
 
        [[nodiscard]] constexpr FixedPoint floor() const {
                return create(value & ~FRACTION_MASK);
        }
 
        [[nodiscard]] constexpr FixedPoint fract() const {
                return create(value & FRACTION_MASK);
        }
 
        [[nodiscard]] constexpr unsigned fractAsInt() const {
                return value & FRACTION_MASK;
        }
 
        // Arithmetic operators:
 
        [[nodiscard]] constexpr friend FixedPoint operator+(FixedPoint x, FixedPoint y) {
                return create(x.value + y.value);
        }
        [[nodiscard]] constexpr friend FixedPoint operator-(FixedPoint x, FixedPoint y) {
                return create(x.value - y.value);
        }
        [[nodiscard]] constexpr friend FixedPoint operator*(FixedPoint x, FixedPoint y) {
                return create(int(
                        (static_cast<int64_t>(x.value) * y.value) >> FRACTION_BITS));
        }
        [[nodiscard]] constexpr friend FixedPoint operator*(FixedPoint x, int y) {
                return create(x.value * y);
        }
        [[nodiscard]] constexpr friend FixedPoint operator*(int x, FixedPoint y) {
                return create(x * y.value);
        }
        [[nodiscard]] constexpr friend FixedPoint operator/(FixedPoint x, FixedPoint y) {
                return create(int(
                        (static_cast<int64_t>(x.value) << FRACTION_BITS) / y.value));
        }
        [[nodiscard]] constexpr friend FixedPoint operator/(FixedPoint x, int y) {
                return create(x.value / y);
        }
        [[nodiscard]] constexpr friend FixedPoint operator<<(FixedPoint x, int y) {
                return create(x.value << y);
        }
        [[nodiscard]] constexpr friend FixedPoint operator>>(FixedPoint x, int y) {
                return create(x.value >> y);
        }
 
        // Comparison operators:
        [[nodiscard]] constexpr auto operator<=>(const FixedPoint&) const = default;
 
        // Arithmetic operators that modify this object:
 
        constexpr void operator+=(FixedPoint other) {
                value += other.value;
        }
        constexpr void operator-=(FixedPoint other) {
                value -= other.value;
        }
 
        constexpr void addQuantum() {
                value += 1;
        }
 
        // Should only be used by other instances of this class
        //  templatized friend declarations are not possible in c++
        [[nodiscard]] constexpr int getRawValue() const {
                return value;
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned /*version*/)
        {
                ar.serialize("value", value);
        }
 
private:
        struct CreateRawTag {};
        constexpr FixedPoint(int raw_value, CreateRawTag)
                : value(raw_value) {}
 
        int value = 0;
};
 
} // namespace openmsx
 
#endif // FIXEDPOINT_HH