File indexing completed on 2024-05-12 15:58:16

 /*
  *  SPDX-FileCopyrightText: 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #ifndef __KIS_FIXED_POINT_MATHS_H
 #define __KIS_FIXED_POINT_MATHS_H
 
 #include <boost/operators.hpp>
 #include <QDataStream>
 
 class KisFixedPoint : boost::ordered_field_operators<KisFixedPoint>
 {
 public:
     KisFixedPoint()
         : d(0){};
 
     KisFixedPoint(int iValue)
         : d(iValue * 256)
     {
     }
 
     KisFixedPoint(qreal fValue)
         : d(static_cast<int>(fValue * 256))
     {
     }
 
     qint32 toInt() const {
         return d >= 0 ? d >> 8 : -((-d) >> 8);
     }
 
     qint32 toIntRound() const {
         return d >= 0 ? (d + (1 << 7)) >> 8 : -((-d + (1 << 7)) >> 8);
     }
 
     qint32 toIntCeil() const {
         return d >= 0 ? (d + ((1 << 8) - 1)) >> 8 : -((-d) >> 8);
     }
 
     qint32 toIntFloor() const {
         return d >= 0 ? d >> 8 : -((-d + ((1 << 8) - 1)) >> 8);
     }
 
     qreal toFloat() const {
         return qreal(d) / qreal(1 << 8);
     }
 
     KisFixedPoint& from256Frac(qint32 v) {
         d = v;
         return *this;
     }
 
     qint32 to256Frac() const {
         return d;
     }
 
     KisFixedPoint& inc256Frac() {
         d++;
         return *this;
     }
 
     KisFixedPoint& dec256Frac() {
         d--;
         return *this;
     }
 
     bool isInteger() const {
         return !(d & ((1 << 8) -1 ));
     }
 
     bool operator<(const KisFixedPoint& x) const {
         return d < x.d;
     }
 
     bool operator==(const KisFixedPoint& x) const {
         return d == x.d;
     }
 
     KisFixedPoint& operator+=(const KisFixedPoint& x) {
         d += x.d;
         return *this;
     }
 
     KisFixedPoint& operator-=(const KisFixedPoint& x) {
         d -= x.d;
         return *this;
     }
 
     KisFixedPoint &operator*=(const KisFixedPoint &x)
     {
         /**
          * Until C++20 `d >>= 8` is "implementation defined" for negative `d`.
          * But we have a unittest that confirms that the our compiler handles
          * that in an expected way
          */
 
         d *= x.d;
         d >>= 8;
         return *this;
     }
 
     KisFixedPoint &operator/=(const KisFixedPoint &x)
     {
         /**
          * Until C++20 `d <<= 8` is an "undefined behavior" for negative `d`.
          * But we have a unittest that confirms that the our compiler handles
          * that in an expected way
          */
 
         d *= 256;
         d /= x.d;
         return *this;
     }
 
 private:
     friend KisFixedPoint operator-(KisFixedPoint x);
     friend QDebug operator<<(QDebug dbg, const KisFixedPoint &v);
 
 private:
     qint32 d;
 };
 
 inline KisFixedPoint operator-(KisFixedPoint x) {
     x.d = -x.d;
     return x;
 }
 
 QDebug operator<<(QDebug dbg, const KisFixedPoint &v) {
     dbg.nospace() << v.toFloat() << " (d = " << v.d << ")";
     return dbg.space();
 }
 
 #endif /* __KIS_FIXED_POINT_MATHS_H */