svf-tools 1.0.966 → 1.0.968

package/svf/include/AE/Core/NumericValue.h

@@ -34,22 +34,695 @@
 #define SVF_NUMERICVALUE_H
 
 #include "SVFIR/SVFType.h"
-#include <cmath>
 #include <cfloat> // For DBL_MAX
+#include <cmath>
 #include <utility>
 
-
 #define epsilon std::numeric_limits<double>::epsilon();
 namespace SVF
 {
 
+/**
+ * @brief A class representing a bounded 64-bit integer.
+ *
+ * BoundedInt is a class that represents a 64-bit integer that can also
+ * represent positive and negative infinity. It includes a 64-bit integer
+ * value and a boolean flag indicating whether the value is infinite.
+ * If the value is infinite, the integer value is used to represent the sign
+ * of infinity (1 for positive infinity and 0 for negative infinity).
+ */
+class BoundedInt
+{
+protected:
+    s64_t _iVal; // The 64-bit integer value.
+    bool _isInf; // True if the value is infinite. If true, _iVal == 1
+    // represents positive infinity and _iVal == 0 represents
+    // negative infinity.
+
+    // Default constructor is protected to prevent creating an object without
+    // initializing _iVal and _isInf.
+    BoundedInt() = default;
+
+public:
+    // Constructs a BoundedInt with the given 64-bit integer value. The value is
+    // not infinite.
+    BoundedInt(s64_t fVal) : _iVal(fVal), _isInf(false) {}
+
+    // Constructs a BoundedInt with the given 64-bit integer value and infinity
+    // flag.
+    BoundedInt(s64_t fVal, bool isInf) : _iVal(fVal), _isInf(isInf) {}
+
+    // Copy constructor.
+    BoundedInt(const BoundedInt& rhs) : _iVal(rhs._iVal), _isInf(rhs._isInf) {}
+
+    // Copy assignment operator.
+    BoundedInt& operator=(const BoundedInt& rhs)
+    {
+        _iVal = rhs._iVal;
+        _isInf = rhs._isInf;
+        return *this;
+    }
+
+    // Move constructor.
+    BoundedInt(BoundedInt&& rhs) : _iVal(rhs._iVal), _isInf(rhs._isInf) {}
+
+    // Move assignment operator.
+    BoundedInt& operator=(BoundedInt&& rhs)
+    {
+        _iVal = rhs._iVal;
+        _isInf = rhs._isInf;
+        return *this;
+    }
+
+    // Virtual destructor.
+    virtual ~BoundedInt() {}
+
+    // Checks if the BoundedInt represents positive infinity.
+    bool is_plus_infinity() const
+    {
+        return _isInf && _iVal == 1;
+    }
+
+    // Checks if the BoundedInt represents negative infinity.
+    bool is_minus_infinity() const
+    {
+        return _isInf && _iVal == -1;
+    }
+
+    // Checks if the BoundedInt represents either positive or negative infinity.
+    bool is_infinity() const
+    {
+        return is_plus_infinity() || is_minus_infinity();
+    }
+
+    // Sets the BoundedInt to represent positive infinity.
+    void set_plus_infinity()
+    {
+        *this = plus_infinity();
+    }
+
+    // Sets the BoundedInt to represent negative infinity.
+    void set_minus_infinity()
+    {
+        *this = minus_infinity();
+    }
+
+    // Returns a BoundedInt representing positive infinity.
+    static BoundedInt plus_infinity()
+    {
+        return {1, true};
+    }
+
+    // Returns a BoundedInt representing negative infinity.
+    static BoundedInt minus_infinity()
+    {
+        return {-1, true};
+    }
+
+    // Checks if the BoundedInt represents zero.
+    bool is_zero() const
+    {
+        return _iVal == 0;
+    }
+
+    // Checks if the given BoundedInt represents zero.
+    static bool isZero(const BoundedInt& expr)
+    {
+        return expr._iVal == 0;
+    }
+
+    // Checks if the BoundedInt is equal to another BoundedInt.
+    bool equal(const BoundedInt& rhs) const
+    {
+        return _iVal == rhs._iVal && _isInf == rhs._isInf;
+    }
+
+    // Checks if the BoundedInt is less than or equal to another BoundedInt.
+    bool leq(const BoundedInt& rhs) const
+    {
+        // If only one of the two BoundedInts is infinite.
+        if (is_infinity() ^ rhs.is_infinity())
+        {
+            if (is_infinity())
+            {
+                return is_minus_infinity();
+            }
+            else
+            {
+                return rhs.is_plus_infinity();
+            }
+        }
+        // If both BoundedInts are infinite.
+        if (is_infinity() && rhs.is_infinity())
+        {
+            if (is_minus_infinity())
+                return true;
+            else
+                return rhs.is_plus_infinity();
+        }
+        // If neither BoundedInt is infinite.
+        else
+            return _iVal <= rhs._iVal;
+    }
+
+    // Checks if the BoundedInt is greater than or equal to another BoundedInt.
+    bool geq(const BoundedInt& rhs) const
+    {
+        // If only one of the two BoundedInts is infinite.
+        if (is_infinity() ^ rhs.is_infinity())
+        {
+            if (is_infinity())
+            {
+                return is_plus_infinity();
+            }
+            else
+            {
+                return rhs.is_minus_infinity();
+            }
+        }
+        // If both BoundedInts are infinite.
+        if (is_infinity() && rhs.is_infinity())
+        {
+            if (is_plus_infinity())
+                return true;
+            else
+                return rhs.is_minus_infinity();
+        }
+        // If neither BoundedInt is infinite.
+        else
+            return _iVal >= rhs._iVal;
+    }
+
+    /// Reload operator
+    //{%
+    // Overloads the equality operator to compare two BoundedInt objects.
+    friend BoundedInt operator==(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs.equal(rhs);
+    }
+
+    // Overloads the inequality operator to compare two BoundedInt objects.
+    friend BoundedInt operator!=(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return !lhs.equal(rhs);
+    }
+
+    // Overloads the greater than operator to compare two BoundedInt objects.
+    friend BoundedInt operator>(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return !lhs.leq(rhs);
+    }
+
+    // Overloads the less than operator to compare two BoundedInt objects.
+    friend BoundedInt operator<(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return !lhs.geq(rhs);
+    }
+
+    // Overloads the less than or equal to operator to compare two BoundedInt
+    // objects.
+    friend BoundedInt operator<=(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs.leq(rhs);
+    }
+
+    // Overloads the greater than or equal to operator to compare two BoundedInt
+    // objects.
+    friend BoundedInt operator>=(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs.geq(rhs);
+    }
+
+    /**
+     * Safely adds two BoundedInt objects.
+     *
+     * This function adds two BoundedInt objects in a way that respects the
+     * bounds of the underlying s64_t type. It checks for conditions that would
+     * result in overflow or underflow and returns a representation of positive
+     * or negative infinity in those cases. If addition of the two numbers would
+     * result in a value that is within the representable range of s64_t, it
+     * performs the addition and returns the result. If the addition is not
+     * defined (e.g., positive infinity plus negative infinity), it asserts
+     * false to indicate an error.
+     *
+     * @param lhs The first BoundedInt to add. This can be any valid BoundedInt,
+     * including positive and negative infinity.
+     * @param rhs The second BoundedInt to add. This can be any valid
+     * BoundedInt, including positive and negative infinity.
+     * @return A BoundedInt that represents the result of the addition. If the
+     * addition would result in overflow, the function returns a BoundedInt
+     * representing positive infinity. If the addition would result in
+     * underflow, the function returns a BoundedInt representing negative
+     * infinity. If the addition is not defined (e.g., positive infinity plus
+     * negative infinity), the function asserts false and does not return a
+     * value.
+     */
+    static BoundedInt safeAdd(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        // If one number is positive infinity and the other is negative
+        // infinity, this is an invalid operation, so we assert false.
+        if ((lhs.is_plus_infinity() && rhs.is_minus_infinity()) ||
+                (lhs.is_minus_infinity() && rhs.is_plus_infinity()))
+        {
+            assert(false && "invalid add");
+        }
+
+        // If either number is positive infinity, the result is positive
+        // infinity.
+        if (lhs.is_plus_infinity() || rhs.is_plus_infinity())
+        {
+            return plus_infinity();
+        }
+
+        // If either number is negative infinity, the result is negative
+        // infinity.
+        if (lhs.is_minus_infinity() || rhs.is_minus_infinity())
+        {
+            return minus_infinity();
+        }
+
+        // If both numbers are positive and their sum would exceed the maximum
+        // representable number, the result is positive infinity.
+        if (lhs._iVal > 0 && rhs._iVal > 0 &&
+                (std::numeric_limits<s64_t>::max() - lhs._iVal) < rhs._iVal)
+        {
+            return plus_infinity();
+        }
+
+        // If both numbers are negative and their sum would be less than the
+        // most negative representable number, the result is negative infinity.
+        if (lhs._iVal < 0 && rhs._iVal < 0 &&
+                (-std::numeric_limits<s64_t>::max() - lhs._iVal) > rhs._iVal)
+        {
+            return minus_infinity();
+        }
+
+        // If none of the above conditions are met, the numbers can be safely
+        // added.
+        return lhs._iVal + rhs._iVal;
+    }
+
+    // Overloads the addition operator to safely add two BoundedInt objects.
+    // Utilizes the safeAdd method to handle potential overflow and underflow.
+    friend BoundedInt operator+(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return safeAdd(lhs, rhs);
+    }
+
+    // Overloads the unary minus operator to negate a BoundedInt object.
+    // The operation simply negates the internal integer value.
+    friend BoundedInt operator-(const BoundedInt& lhs)
+    {
+        return {-lhs._iVal, lhs._isInf};
+    }
+
+    // Overloads the subtraction operator to safely subtract one BoundedInt
+    // object from another. This is implemented as the addition of the lhs and
+    // the negation of the rhs, using the safeAdd method for safety.
+    friend BoundedInt operator-(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return safeAdd(lhs, -rhs);
+    }
+
+    /**
+     * @brief Performs safe multiplication of two BoundedInt objects.
+     *
+     * This function ensures that the multiplication of two BoundedInt objects
+     * doesn't result in overflow or underflow. It returns the multiplication
+     * result if it can be represented within the range of a 64-bit integer. If
+     * the result would be larger than the maximum representable positive
+     * number, it returns positive infinity. If the result would be less than
+     * the minimum representable negative number, it returns negative infinity.
+     * If either of the inputs is zero, the result is zero. If either of the
+     * inputs is infinity, the result is determined by the signs of the inputs.
+     *
+     * @param lhs The first BoundedInt to multiply.
+     * @param rhs The second BoundedInt to multiply.
+     * @return The result of the multiplication, or positive/negative infinity
+     * if the result would be outside the range of a 64-bit integer.
+     */
+    static BoundedInt safeMul(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        // If either number is zero, the result is zero.
+        if (lhs._iVal == 0 || rhs._iVal == 0)
+            return 0;
+
+        // If either number is infinity, the result depends on the signs of the
+        // numbers.
+        if (lhs.is_infinity() || rhs.is_infinity())
+        {
+            // If the signs of the numbers are the same, the result is positive
+            // infinity. If the signs of the numbers are different, the result
+            // is negative infinity.
+            if (lhs._iVal * rhs._iVal > 0)
+            {
+                return plus_infinity();
+            }
+            else
+            {
+                return minus_infinity();
+            }
+        }
+
+        // If both numbers are positive and their product would exceed the
+        // maximum representable number, the result is positive infinity.
+        if (lhs._iVal > 0 && rhs._iVal > 0 &&
+                (std::numeric_limits<s64_t>::max() / lhs._iVal) < rhs._iVal)
+        {
+            return plus_infinity();
+        }
+
+        // If both numbers are negative and their product would exceed the
+        // maximum representable number, the result is positive infinity.
+        if (lhs._iVal < 0 && rhs._iVal < 0 &&
+                (std::numeric_limits<s64_t>::max() / lhs._iVal) > rhs._iVal)
+        {
+            return plus_infinity();
+        }
+
+        // If one number is positive and the other is negative and their product
+        // would be less than the most negative representable number, the result
+        // is negative infinity.
+        if ((lhs._iVal > 0 && rhs._iVal < 0 &&
+                (-std::numeric_limits<s64_t>::max() / lhs._iVal) > rhs._iVal) ||
+                (lhs._iVal < 0 && rhs._iVal > 0 &&
+                 (-std::numeric_limits<s64_t>::max() / rhs._iVal) > lhs._iVal))
+        {
+            return minus_infinity();
+        }
+
+        // If none of the above conditions are met, the numbers can be safely
+        // multiplied.
+        return lhs._iVal * rhs._iVal;
+    }
+
+
+    friend BoundedInt operator%(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        if (rhs.is_zero())
+            assert(false && "divide by zero");
+        else if (!lhs.is_infinity() && !rhs.is_infinity())
+            return lhs._iVal % rhs._iVal;
+        else if (!lhs.is_infinity() && rhs.is_infinity())
+            return 0;
+        // TODO: not sure
+        else if (lhs.is_infinity() && !rhs.is_infinity())
+            return ite(rhs._iVal > 0, lhs, -lhs);
+        else
+            // TODO: +oo/-oo L'Hôpital's rule?
+            return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
+        abort();
+    }
+    // Overloads the multiplication operator to safely multiply two BoundedInt
+    // objects. Utilizes the safeMul method to handle potential overflow.
+    friend BoundedInt operator*(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return safeMul(lhs, rhs);
+    }
+
+    // Overloads the division operator to safely divide a BoundedInt object by
+    // another. Utilizes the safeDiv method to handle potential division by zero
+    // and overflow.
+    friend BoundedInt operator/(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        if (rhs.is_zero())
+            assert(false && "divide by zero");
+        else if (!lhs.is_infinity() && !rhs.is_infinity())
+            return lhs._iVal / rhs._iVal;
+        else if (!lhs.is_infinity() && rhs.is_infinity())
+            return 0;
+        else if (lhs.is_infinity() && !rhs.is_infinity())
+            return ite(rhs._iVal >= 0, lhs, -lhs);
+        else
+            return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
+    }
+
+    // Overload bitwise operators for BoundedInt objects. These operators
+    // directly apply the corresponding bitwise operators to the internal
+    // integer values of the BoundedInt objects.
+
+    // Overloads the bitwise XOR operator for BoundedInt objects.
+    friend BoundedInt operator^(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal ^ rhs._iVal;
+    }
+
+    // Overloads the bitwise AND operator for BoundedInt objects.
+    friend BoundedInt operator&(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal & rhs._iVal;
+    }
+
+    // Overloads the bitwise OR operator for BoundedInt objects.
+    friend BoundedInt operator|(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal | rhs._iVal;
+    }
+
+    // Overload logical operators for BoundedInt objects. These operators
+    // directly apply the corresponding logical operators to the internal
+    // integer values of the BoundedInt objects.
+
+    // Overloads the logical AND operator for BoundedInt objects.
+    friend BoundedInt operator&&(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal && rhs._iVal;
+    }
+
+    // Overloads the logical OR operator for BoundedInt objects.
+    friend BoundedInt operator||(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal || rhs._iVal;
+    }
+
+    // Overloads the logical NOT operator for BoundedInt objects.
+    friend BoundedInt operator!(const BoundedInt& lhs)
+    {
+        return !lhs._iVal;
+    }
+
+    // Overloads the right shift operator for BoundedInt objects.
+    // This operation is safe as long as the right-hand side is non-negative.
+    // If the left-hand side is zero or infinity, the result is the same as the
+    // left-hand side. If the right-hand side is infinity, the result depends on
+    // the sign of the left-hand side.
+    friend BoundedInt operator>>(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        assert(rhs.geq(0) && "rhs should be greater or equal than 0");
+        if (lhs.is_zero())
+            return lhs;
+        else if (lhs.is_infinity())
+            return lhs;
+        else if (rhs.is_infinity())
+            return lhs.geq(0) ? 0 : -1;
+        else
+            return lhs._iVal >> rhs._iVal;
+    }
+
+    // Overloads the left shift operator for BoundedInt objects.
+    // This operation is safe as long as the right-hand side is non-negative.
+    // If the left-hand side is zero or infinity, the result is the same as the
+    // left-hand side. If the right-hand side is infinity, the result depends on
+    // the sign of the left-hand side.
+    friend BoundedInt operator<<(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        assert(rhs.geq(0) && "rhs should be greater or equal than 0");
+        if (lhs.is_zero())
+            return lhs;
+        else if (lhs.is_infinity())
+            return lhs;
+        else if (rhs.is_infinity())
+            return lhs.geq(0) ? plus_infinity() : minus_infinity();
+        else
+            return lhs._iVal << rhs._iVal;
+    }
+
+    // Overloads the ternary if-then-else operator for BoundedInt objects.
+    // The condition is evaluated as a boolean, and the result is either the
+    // second or third argument depending on the condition.
+    friend BoundedInt ite(const BoundedInt& cond, const BoundedInt& lhs,
+                          const BoundedInt& rhs)
+    {
+        return cond._iVal != 0 ? lhs : rhs;
+    }
+
+    // Overloads the stream insertion operator for BoundedInt objects.
+    // This allows BoundedInt objects to be printed directly using std::cout or
+    // other output streams.
+    friend std::ostream& operator<<(std::ostream& out, const BoundedInt& expr)
+    {
+        out << expr._iVal;
+        return out;
+    }
+
+    // Defines a function to compare two BoundedInt objects for equality.
+    // This function directly compares the internal integer values of the
+    // BoundedInt objects.
+    friend bool eq(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        return lhs._iVal == rhs._iVal && lhs._isInf == rhs._isInf;
+    }
+
+    // Defines a function to find the minimum of two BoundedInt objects.
+    // This function directly compares the internal integer values of the BoundedInt objects,
+    // and also checks if either of them represents infinity.
+    friend BoundedInt min(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        if (lhs.is_minus_infinity() || rhs.is_minus_infinity())
+            return minus_infinity();
+        else if(lhs.is_plus_infinity())
+            return rhs;
+        else if(rhs.is_plus_infinity())
+            return lhs;
+        else
+            return BoundedInt(std::min(lhs._iVal, rhs._iVal));
+    }
+
+
+    // Defines a function to find the maximum of two BoundedInt objects.
+    // This function directly compares the internal integer values of the BoundedInt objects,
+    // and also checks if either of them represents infinity.
+    friend BoundedInt max(const BoundedInt& lhs, const BoundedInt& rhs)
+    {
+        if (lhs.is_plus_infinity() || rhs.is_plus_infinity())
+            return plus_infinity();
+        else if(lhs.is_minus_infinity())
+            return rhs;
+        else if(rhs.is_minus_infinity())
+            return lhs;
+        else
+            return BoundedInt(std::max(lhs._iVal, rhs._iVal));
+    }
+
+
+    // Defines a function to find the minimum of a vector of BoundedInt objects.
+    // This function iterates over the vector and returns the smallest
+    // BoundedInt object.
+    static BoundedInt min(std::vector<BoundedInt>& _l)
+    {
+        BoundedInt ret(plus_infinity());
+        for (const auto& it : _l)
+        {
+            if (it.is_minus_infinity())
+                return minus_infinity();
+            else if (!it.geq(ret))
+            {
+                ret = it;
+            }
+        }
+        return ret;
+    }
+
+    // Defines a function to find the maximum of a vector of BoundedInt objects.
+    // This function iterates over the vector and returns the largest BoundedInt
+    // object.
+    static BoundedInt max(std::vector<BoundedInt>& _l)
+    {
+        BoundedInt ret(minus_infinity());
+        for (const auto& it : _l)
+        {
+            if (it.is_plus_infinity())
+                return plus_infinity();
+            else if (!it.leq(ret))
+            {
+                ret = it;
+            }
+        }
+        return ret;
+    }
+
+    // Defines a function to find the absolute value of a BoundedInt object.
+    // This function directly applies the unary minus operator if the BoundedInt
+    // object is negative.
+    friend BoundedInt abs(const BoundedInt& lhs)
+    {
+        return lhs.leq(0) ? -lhs : lhs;
+    }
+
+    // Defines a method to check if a BoundedInt object is true.
+    // A BoundedInt object is considered true if its internal integer value is
+    // non-zero.
+    inline bool is_true() const
+    {
+        return _iVal != 0;
+    }
+
+    /**
+     * @brief Retrieves the numeral value of the BoundedInt object.
+     *
+     * This method returns the numeral representation of the BoundedInt object.
+     * If the object represents negative infinity, it returns the minimum
+     * representable 64-bit integer. If the object represents positive infinity,
+     * it returns the maximum representable 64-bit integer. Otherwise, it
+     * returns the actual 64-bit integer value of the object.
+     *
+     * @return The numeral value of the BoundedInt object.
+     */
+    inline s64_t getNumeral() const
+    {
+        // If the object represents negative infinity, return the minimum
+        // representable 64-bit integer.
+        if (is_minus_infinity())
+        {
+            return std::numeric_limits<s64_t>::min();
+        }
+        // If the object represents positive infinity, return the maximum
+        // representable 64-bit integer.
+        else if (is_plus_infinity())
+        {
+            return std::numeric_limits<s64_t>::max();
+        }
+        // Otherwise, return the actual 64-bit integer value of the object.
+        else
+        {
+            return _iVal;
+        }
+    }
+
+    inline virtual const std::string to_string() const
+    {
+        if (is_minus_infinity())
+        {
+            return "-oo";
+        }
+        if (is_plus_infinity())
+        {
+            return "+oo";
+        }
+        else
+            return std::to_string(_iVal);
+    }
+
+    //%}
+
+    bool is_real() const
+    {
+        return false;
+    }
+
+    inline s64_t getIntNumeral() const
+    {
+        return getNumeral();
+    }
+
+    inline double getRealNumeral() const
+    {
+        assert(false && "cannot get real number for integer!");
+        abort();
+    }
+
+    const double getFVal() const
+    {
+        assert(false && "cannot get real number for integer!");
+        abort();
+    }
+};
 /*!
  * Bounded double numeric value
  */
 class BoundedDouble
 {
 protected:
-
     double _fVal;
 
     BoundedDouble() = default;
@@ -65,7 +738,7 @@ public:
         return *this;
     }
 
-    BoundedDouble(BoundedDouble &&rhs) : _fVal(std::move(rhs._fVal)) {}
+    BoundedDouble(BoundedDouble&& rhs) : _fVal(std::move(rhs._fVal)) {}
 
     BoundedDouble& operator=(BoundedDouble&& rhs)
     {
@@ -75,7 +748,6 @@ public:
 
     virtual ~BoundedDouble() {}
 
-
     static bool doubleEqual(double a, double b)
     {
         if (std::isinf(a) && std::isinf(b))
@@ -123,23 +795,22 @@ public:
         return -std::numeric_limits<double>::infinity();
     }
 
-
     bool is_zero() const
     {
         return doubleEqual(_fVal, 0.0f);
     }
 
-    static bool isZero(const BoundedDouble &expr)
+    static bool isZero(const BoundedDouble& expr)
     {
         return doubleEqual(expr.getFVal(), 0.0f);
     }
 
-    bool equal(const BoundedDouble &rhs) const
+    bool equal(const BoundedDouble& rhs) const
     {
         return doubleEqual(_fVal, rhs._fVal);
     }
 
-    bool leq(const BoundedDouble &rhs) const
+    bool leq(const BoundedDouble& rhs) const
     {
         if (is_infinity() ^ rhs.is_infinity())
         {
@@ -152,16 +823,18 @@ public:
                 return rhs.is_plus_infinity();
             }
         }
-        if(is_infinity() && rhs.is_infinity())
+        if (is_infinity() && rhs.is_infinity())
         {
-            if(is_minus_infinity()) return true;
-            else return rhs.is_plus_infinity();
+            if (is_minus_infinity())
+                return true;
+            else
+                return rhs.is_plus_infinity();
         }
         else
             return _fVal <= rhs._fVal;
     }
 
-    bool geq(const BoundedDouble &rhs) const
+    bool geq(const BoundedDouble& rhs) const
     {
         if (is_infinity() ^ rhs.is_infinity())
         {
@@ -174,10 +847,12 @@ public:
                 return rhs.is_minus_infinity();
             }
         }
-        if(is_infinity() && rhs.is_infinity())
+        if (is_infinity() && rhs.is_infinity())
         {
-            if(is_plus_infinity()) return true;
-            else return rhs.is_minus_infinity();
+            if (is_plus_infinity())
+                return true;
+            else
+                return rhs.is_minus_infinity();
         }
         else
             return _fVal >= rhs._fVal;
@@ -185,32 +860,38 @@ public:
 
     /// Reload operator
     //{%
-    friend BoundedDouble operator==(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator==(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return lhs.equal(rhs);
     }
 
-    friend BoundedDouble operator!=(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator!=(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return !lhs.equal(rhs);
     }
 
-    friend BoundedDouble operator>(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator>(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return !lhs.leq(rhs);
     }
 
-    friend BoundedDouble operator<(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator<(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return !lhs.geq(rhs);
     }
 
-    friend BoundedDouble operator<=(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator<=(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return lhs.leq(rhs);
     }
 
-    friend BoundedDouble operator>=(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator>=(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return lhs.geq(rhs);
     }
@@ -256,8 +937,7 @@ public:
         if (lhs > 0 && rhs > 0 &&
                 (std::numeric_limits<double>::max() - lhs) < rhs)
         {
-            res =
-                std::numeric_limits<double>::infinity(); // Set result to
+            res = std::numeric_limits<double>::infinity(); // Set result to
             // positive infinity to
             // indicate overflow
             return res;
@@ -279,17 +959,19 @@ public:
         return res;
     }
 
-    friend BoundedDouble operator+(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator+(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return safeAdd(lhs._fVal, rhs._fVal);
     }
 
-    friend BoundedDouble operator-(const BoundedDouble &lhs)
+    friend BoundedDouble operator-(const BoundedDouble& lhs)
     {
         return -lhs._fVal;
     }
 
-    friend BoundedDouble operator-(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator-(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return safeAdd(lhs._fVal, -rhs._fVal);
     }
@@ -323,11 +1005,13 @@ public:
             // negative infinity
         }
         // Check for overflow scenarios
-        if (lhs > 0 && rhs > 0 && lhs > std::numeric_limits<double>::max() / rhs)
+        if (lhs > 0 && rhs > 0 &&
+                lhs > std::numeric_limits<double>::max() / rhs)
         {
             return std::numeric_limits<double>::infinity();
         }
-        if (lhs < 0 && rhs < 0 && lhs < std::numeric_limits<double>::max() / rhs)
+        if (lhs < 0 && rhs < 0 &&
+                lhs < std::numeric_limits<double>::max() / rhs)
         {
             return std::numeric_limits<double>::infinity();
         }
@@ -347,7 +1031,8 @@ public:
         return res; // If no overflow or underflow, return the product
     }
 
-    friend BoundedDouble operator*(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator*(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return safeMul(lhs._fVal, rhs._fVal);
     }
@@ -400,14 +1085,17 @@ public:
         return res; // If no special cases, return the quotient
     }
 
-    friend BoundedDouble operator/(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator/(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         return safeDiv(lhs._fVal, rhs._fVal);
     }
 
-    friend BoundedDouble operator%(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator%(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
-        if (rhs.is_zero()) assert(false && "divide by zero");
+        if (rhs.is_zero())
+            assert(false && "divide by zero");
         else if (!lhs.is_infinity() && !rhs.is_infinity())
             return std::fmod(lhs._fVal, rhs._fVal);
         else if (!lhs.is_infinity() && rhs.is_infinity())
@@ -430,41 +1118,46 @@ public:
         return !is_int();
     }
 
-    friend BoundedDouble operator^(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator^(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
         return lInt ^ rInt;
     }
 
-    friend BoundedDouble operator&(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator&(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
         return lInt & rInt;
     }
 
-    friend BoundedDouble operator|(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator|(const BoundedDouble& lhs,
+                                   const BoundedDouble& rhs)
     {
         int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
         return lInt | rInt;
     }
 
-
-    friend BoundedDouble operator&&(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator&&(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return lhs._fVal && rhs._fVal;
     }
 
-    friend BoundedDouble operator||(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator||(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         return lhs._fVal || rhs._fVal;
     }
 
-    friend BoundedDouble operator!(const BoundedDouble &lhs)
+    friend BoundedDouble operator!(const BoundedDouble& lhs)
     {
         return !lhs._fVal;
     }
 
-    friend BoundedDouble operator>>(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator>>(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         assert(rhs.geq(0) && "rhs should be greater or equal than 0");
         if (lhs.is_zero())
@@ -474,10 +1167,11 @@ public:
         else if (rhs.is_infinity())
             return lhs.geq(0) ? 0 : -1;
         else
-            return (s32_t) lhs.getNumeral() >> (s32_t) rhs.getNumeral();
+            return (s32_t)lhs.getNumeral() >> (s32_t)rhs.getNumeral();
     }
 
-    friend BoundedDouble operator<<(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble operator<<(const BoundedDouble& lhs,
+                                    const BoundedDouble& rhs)
     {
         assert(rhs.geq(0) && "rhs should be greater or equal than 0");
         if (lhs.is_zero())
@@ -487,32 +1181,33 @@ public:
         else if (rhs.is_infinity())
             return lhs.geq(0) ? plus_infinity() : minus_infinity();
         else
-            return (s32_t) lhs.getNumeral() << (s32_t) rhs.getNumeral();
+            return (s32_t)lhs.getNumeral() << (s32_t)rhs.getNumeral();
     }
 
-    friend BoundedDouble ite(const BoundedDouble& cond, const BoundedDouble& lhs,
-                             const BoundedDouble& rhs)
+    friend BoundedDouble ite(const BoundedDouble& cond,
+                             const BoundedDouble& lhs, const BoundedDouble& rhs)
     {
         return cond._fVal != 0.0f ? lhs._fVal : rhs._fVal;
     }
 
-    friend std::ostream &operator<<(std::ostream &out, const BoundedDouble &expr)
+    friend std::ostream& operator<<(std::ostream& out,
+                                    const BoundedDouble& expr)
     {
         out << expr._fVal;
         return out;
     }
 
-    friend bool eq(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend bool eq(const BoundedDouble& lhs, const BoundedDouble& rhs)
     {
         return doubleEqual(lhs._fVal, rhs._fVal);
     }
 
-    friend BoundedDouble min(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble min(const BoundedDouble& lhs, const BoundedDouble& rhs)
     {
         return std::min(lhs._fVal, rhs._fVal);
     }
 
-    friend BoundedDouble max(const BoundedDouble &lhs, const BoundedDouble &rhs)
+    friend BoundedDouble max(const BoundedDouble& lhs, const BoundedDouble& rhs)
     {
         return std::max(lhs._fVal, rhs._fVal);
     }
@@ -520,7 +1215,7 @@ public:
     static BoundedDouble min(std::vector<BoundedDouble>& _l)
     {
         BoundedDouble ret(plus_infinity());
-        for (const auto &it: _l)
+        for (const auto& it : _l)
         {
             if (it.is_minus_infinity())
                 return minus_infinity();
@@ -535,7 +1230,7 @@ public:
     static BoundedDouble max(std::vector<BoundedDouble>& _l)
     {
         BoundedDouble ret(minus_infinity());
-        for (const auto &it: _l)
+        for (const auto& it : _l)
         {
             if (it.is_plus_infinity())
                 return plus_infinity();
@@ -547,7 +1242,7 @@ public:
         return ret;
     }
 
-    friend BoundedDouble abs(const BoundedDouble &lhs)
+    friend BoundedDouble abs(const BoundedDouble& lhs)
     {
         return lhs.leq(0) ? -lhs : lhs;
     }
@@ -592,68 +1287,6 @@ public:
     //%}
 }; // end class BoundedDouble
 
-class BoundedInt : public BoundedDouble
-{
-private:
-    BoundedInt() = default;
-
-public:
-
-    BoundedInt(s32_t val)
-    {
-        _fVal = val;
-    }
-
-    BoundedInt(s64_t val)
-    {
-        _fVal = val;
-    }
-
-    BoundedInt(const BoundedInt& rhs)
-    {
-        _fVal = rhs._fVal;
-    }
-
-    BoundedInt& operator=(const BoundedInt& rhs)
-    {
-        _fVal = rhs._fVal;
-        return *this;
-    }
-
-    BoundedInt(BoundedInt&& rhs)
-    {
-        _fVal = rhs._fVal;
-    }
-
-    BoundedInt& operator=(const BoundedInt&& rhs)
-    {
-        _fVal = rhs._fVal;
-        return *this;
-    }
-
-    BoundedInt(double val)
-    {
-        _fVal = val;
-    }
-
-    BoundedInt(const BoundedDouble& f)
-    {
-        _fVal = f.getFVal();
-    }
-
-    virtual ~BoundedInt() {}
-
-    inline const std::string to_string() const override
-    {
-        if (is_minus_infinity())
-            return "-∞";
-        else if (is_plus_infinity())
-            return "∞";
-        else
-            return std::to_string(getIntNumeral());
-    }
-};
-
 } // end namespace SVF
 
 #endif // SVF_NUMERICVALUE_H