A class representing a bounded 64-bit integer. More...

#include <NumericValue.h>

Public Member Functions
	BoundedInt (s64_t fVal)

	BoundedInt (s64_t fVal, bool isInf)

	BoundedInt (const BoundedInt &rhs)

BoundedInt &	operator= (const BoundedInt &rhs)

	BoundedInt (BoundedInt &&rhs)

BoundedInt &	operator= (BoundedInt &&rhs)

virtual	~BoundedInt ()

bool	is_plus_infinity () const

bool	is_minus_infinity () const

bool	is_infinity () const

void	set_plus_infinity ()

void	set_minus_infinity ()

bool	is_zero () const

bool	equal (const BoundedInt &rhs) const

bool	leq (const BoundedInt &rhs) const

bool	geq (const BoundedInt &rhs) const

bool	is_true () const

s64_t	getNumeral () const
	Retrieves the numeral value of the BoundedInt object.

virtual const std::string	to_string () const

bool	is_real () const

s64_t	getIntNumeral () const

double	getRealNumeral () const

const double	getFVal () const

Static Public Member Functions
static BoundedInt	plus_infinity ()

static BoundedInt	minus_infinity ()

static bool	isZero (const BoundedInt &expr)

static BoundedInt	safeAdd (const BoundedInt &lhs, const BoundedInt &rhs)

static BoundedInt	safeMul (const BoundedInt &lhs, const BoundedInt &rhs)
	Performs safe multiplication of two BoundedInt objects.

static BoundedInt	min (std::vector< BoundedInt > &_l)

static BoundedInt	max (std::vector< BoundedInt > &_l)

Protected Member Functions
	BoundedInt ()=default

Protected Attributes
s64_t	_iVal

bool	_isInf

Friends
bool	operator== (const BoundedInt &lhs, const BoundedInt &rhs)
	Reload operator.

bool	operator!= (const BoundedInt &lhs, const BoundedInt &rhs)

bool	operator> (const BoundedInt &lhs, const BoundedInt &rhs)

bool	operator< (const BoundedInt &lhs, const BoundedInt &rhs)

bool	operator<= (const BoundedInt &lhs, const BoundedInt &rhs)

bool	operator>= (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator+ (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator- (const BoundedInt &lhs)

BoundedInt	operator- (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator% (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator* (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator/ (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator^ (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator& (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator\| (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator&& (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator\|\| (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator! (const BoundedInt &lhs)

BoundedInt	operator>> (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	operator<< (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	ite (const BoundedInt &cond, const BoundedInt &lhs, const BoundedInt &rhs)

std::ostream &	operator<< (std::ostream &out, const BoundedInt &expr)

bool	eq (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	min (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	max (const BoundedInt &lhs, const BoundedInt &rhs)

BoundedInt	abs (const BoundedInt &lhs)

Detailed Description

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).

Definition at line 55 of file NumericValue.h.

Constructor & Destructor Documentation

◆ BoundedInt() [1/5]

SVF::BoundedInt::BoundedInt ( )

protecteddefault

◆ BoundedInt() [2/5]

SVF::BoundedInt::BoundedInt ( s64_t fVal )

inline

Definition at line 70 of file NumericValue.h.

70: _iVal(fVal), _isInf(false) {}

SVF::BoundedInt::_iVal

s64_t _iVal

Definition NumericValue.h:58

SVF::BoundedInt::_isInf

bool _isInf

Definition NumericValue.h:59

SVF::IRBuilder

llvm::IRBuilder IRBuilder

Definition BasicTypes.h:76

◆ BoundedInt() [3/5]

SVF::BoundedInt::BoundedInt	(	s64_t	fVal,
		bool	isInf
	)

inline

Definition at line 74 of file NumericValue.h.

74: _iVal(fVal), _isInf(isInf) {}

◆ BoundedInt() [4/5]

SVF::BoundedInt::BoundedInt ( const BoundedInt & rhs )

inline

Definition at line 77 of file NumericValue.h.

77: _iVal(rhs._iVal), _isInf(rhs._isInf) {}

◆ BoundedInt() [5/5]

SVF::BoundedInt::BoundedInt ( BoundedInt && rhs )

inline

Definition at line 88 of file NumericValue.h.

88: _iVal(rhs._iVal), _isInf(rhs._isInf) {}

◆ ~BoundedInt()

virtual SVF::BoundedInt::~BoundedInt ( )

inlinevirtual

Definition at line 99 of file NumericValue.h.

99{}

Member Function Documentation

◆ equal()

bool SVF::BoundedInt::equal ( const BoundedInt & rhs ) const

inline

Definition at line 156 of file NumericValue.h.

    {
        return _iVal == rhs._iVal && _isInf == rhs._isInf;
    }

◆ geq()

bool SVF::BoundedInt::geq ( const BoundedInt & rhs ) const

inline

Definition at line 190 of file NumericValue.h.

    {
        // 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;
    }

◆ getFVal()

const double SVF::BoundedInt::getFVal ( ) const

inline

Definition at line 718 of file NumericValue.h.

    {
        assert(false && "cannot get real number for integer!");
        abort();
    }

◆ getIntNumeral()

s64_t SVF::BoundedInt::getIntNumeral ( ) const

inline

Definition at line 707 of file NumericValue.h.

    {
        return getNumeral();
    }

◆ getNumeral()

s64_t SVF::BoundedInt::getNumeral ( ) const

inline

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.

Returns: The numeral value of the BoundedInt object.

Definition at line 665 of file NumericValue.h.

    {
        // 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;
        }
    }

◆ getRealNumeral()

double SVF::BoundedInt::getRealNumeral ( ) const

inline

Definition at line 712 of file NumericValue.h.

    {
        assert(false && "cannot get real number for integer!");
        abort();
    }

◆ is_infinity()

bool SVF::BoundedInt::is_infinity ( ) const

inline

Definition at line 114 of file NumericValue.h.

    {
        return is_plus_infinity() || is_minus_infinity();
    }

◆ is_minus_infinity()

bool SVF::BoundedInt::is_minus_infinity ( ) const

inline

Definition at line 108 of file NumericValue.h.

    {
        return _isInf && _iVal == -1;
    }

◆ is_plus_infinity()

bool SVF::BoundedInt::is_plus_infinity ( ) const

inline

Definition at line 102 of file NumericValue.h.

    {
        return _isInf && _iVal == 1;
    }

◆ is_real()

bool SVF::BoundedInt::is_real ( ) const

inline

Definition at line 702 of file NumericValue.h.

    {
        return false;
    }

◆ is_true()

bool SVF::BoundedInt::is_true ( ) const

inline

Definition at line 649 of file NumericValue.h.

    {
        return _iVal != 0;
    }

◆ is_zero()

bool SVF::BoundedInt::is_zero ( ) const

inline

Definition at line 144 of file NumericValue.h.

    {
        return _iVal == 0;
    }

◆ isZero()

static bool SVF::BoundedInt::isZero ( const BoundedInt & expr )

inlinestatic

Definition at line 150 of file NumericValue.h.

    {
        return expr._iVal == 0;
    }

◆ leq()

bool SVF::BoundedInt::leq ( const BoundedInt & rhs ) const

inline

Definition at line 162 of file NumericValue.h.

    {
        // 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;
    }

◆ max()

static BoundedInt SVF::BoundedInt::max ( std::vector< BoundedInt > & _l )

inlinestatic

Definition at line 623 of file NumericValue.h.

    {
        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;
    }

◆ min()

static BoundedInt SVF::BoundedInt::min ( std::vector< BoundedInt > & _l )

inlinestatic

Definition at line 605 of file NumericValue.h.

    {
        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;
    }

◆ minus_infinity()

static BoundedInt SVF::BoundedInt::minus_infinity ( )

inlinestatic

Definition at line 138 of file NumericValue.h.

    {
        return {-1, true};
    }

◆ operator=() [1/2]

BoundedInt & SVF::BoundedInt::operator= ( BoundedInt && rhs )

inline

Definition at line 91 of file NumericValue.h.

    {
        _iVal = rhs._iVal;
        _isInf = rhs._isInf;
        return *this;
    }

◆ operator=() [2/2]

BoundedInt & SVF::BoundedInt::operator= ( const BoundedInt & rhs )

inline

Definition at line 80 of file NumericValue.h.

    {
        _iVal = rhs._iVal;
        _isInf = rhs._isInf;
        return *this;
    }

◆ plus_infinity()

static BoundedInt SVF::BoundedInt::plus_infinity ( )

inlinestatic

Definition at line 132 of file NumericValue.h.

    {
        return {1, true};
    }

◆ safeAdd()

static BoundedInt SVF::BoundedInt::safeAdd	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

inlinestatic

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.

Parameters

lhs	The first BoundedInt to add. This can be any valid BoundedInt, including positive and negative infinity.
rhs	The second BoundedInt to add. This can be any valid BoundedInt, including positive and negative infinity.

Returns: 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.

Definition at line 281 of file NumericValue.h.

    {
        // 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;
    }

◆ safeMul()

static BoundedInt SVF::BoundedInt::safeMul	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

inlinestatic

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.

Parameters

lhs	The first BoundedInt to multiply.
rhs	The second BoundedInt to multiply.

Returns: The result of the multiplication, or positive/negative infinity if the result would be outside the range of a 64-bit integer.

Definition at line 365 of file NumericValue.h.

    {
        // 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;
    }

◆ set_minus_infinity()

void SVF::BoundedInt::set_minus_infinity ( )

inline

Definition at line 126 of file NumericValue.h.

    {
        *this = minus_infinity();
    }

◆ set_plus_infinity()

void SVF::BoundedInt::set_plus_infinity ( )

inline

Definition at line 120 of file NumericValue.h.

    {
        *this = plus_infinity();
    }

◆ to_string()

virtual const std::string SVF::BoundedInt::to_string ( ) const

inlinevirtual

Definition at line 686 of file NumericValue.h.

    {
        if (is_minus_infinity())
        {
            return "-oo";
        }
        if (is_plus_infinity())
        {
            return "+oo";
        }
        else
            return std::to_string(_iVal);
    }

Friends And Related Symbol Documentation

◆ abs

BoundedInt abs ( const BoundedInt & lhs )

friend

Definition at line 641 of file NumericValue.h.

    {
        return lhs.leq(0) ? -lhs : lhs;
    }

◆ eq

bool eq	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 565 of file NumericValue.h.

    {
        return lhs._iVal == rhs._iVal && lhs._isInf == rhs._isInf;
    }

◆ ite

BoundedInt ite	(	const BoundedInt &	cond,
		const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 547 of file NumericValue.h.

    {
        return cond._iVal != 0 ? lhs : rhs;
    }

◆ max

BoundedInt max	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 589 of file NumericValue.h.

    {
        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));
    }

◆ min

BoundedInt min	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 573 of file NumericValue.h.

    {
        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));
    }

◆ operator!

BoundedInt operator! ( const BoundedInt & lhs )

friend

Definition at line 503 of file NumericValue.h.

    {
        return !lhs._iVal;
    }

◆ operator!=

bool operator!=	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 226 of file NumericValue.h.

    {
        return !lhs.equal(rhs);
    }

◆ operator%

BoundedInt operator%	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 421 of file NumericValue.h.

    {
        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();
    }

◆ operator&

BoundedInt operator&	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 475 of file NumericValue.h.

    {
        return lhs._iVal & rhs._iVal;
    }

◆ operator&&

BoundedInt operator&&	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 491 of file NumericValue.h.

    {
        return lhs._iVal && rhs._iVal;
    }

◆ operator*

BoundedInt operator*	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 439 of file NumericValue.h.

    {
        return safeMul(lhs, rhs);
    }

◆ operator+

BoundedInt operator+	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 328 of file NumericValue.h.

    {
        return safeAdd(lhs, rhs);
    }

◆ operator- [1/2]

BoundedInt operator- ( const BoundedInt & lhs )

friend

Definition at line 335 of file NumericValue.h.

    {
        return {-lhs._iVal, lhs._isInf};
    }

◆ operator- [2/2]

BoundedInt operator-	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 343 of file NumericValue.h.

    {
        return safeAdd(lhs, -rhs);
    }

◆ operator/

BoundedInt operator/	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 447 of file NumericValue.h.

    {
        if (rhs.is_zero())
        {
            assert(false && "divide by zero");
            abort();
        }
        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();
    }

◆ operator<

bool operator<	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 238 of file NumericValue.h.

    {
        return !lhs.geq(rhs);
    }

◆ operator<< [1/2]

BoundedInt operator<<	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 531 of file NumericValue.h.

    {
        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;
    }

◆ operator<< [2/2]

std::ostream & operator<<	(	std::ostream &	out,
		const BoundedInt &	expr
	)

friend

Definition at line 556 of file NumericValue.h.

    {
        out << expr._iVal;
        return out;
    }

◆ operator<=

bool operator<=	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 245 of file NumericValue.h.

    {
        return lhs.leq(rhs);
    }

◆ operator==

bool operator==	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Reload operator.

Definition at line 220 of file NumericValue.h.

    {
        return lhs.equal(rhs);
    }

◆ operator>

bool operator>	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 232 of file NumericValue.h.

    {
        return !lhs.leq(rhs);
    }

◆ operator>=

bool operator>=	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 252 of file NumericValue.h.

    {
        return lhs.geq(rhs);
    }

◆ operator>>

BoundedInt operator>>	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 513 of file NumericValue.h.

    {
        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;
    }

◆ operator^

BoundedInt operator^	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 469 of file NumericValue.h.

    {
        return lhs._iVal ^ rhs._iVal;
    }

◆ operator|

BoundedInt operator\|	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 481 of file NumericValue.h.

    {
        return lhs._iVal | rhs._iVal;
    }

◆ operator||

BoundedInt operator\|\|	(	const BoundedInt &	lhs,
		const BoundedInt &	rhs
	)

friend

Definition at line 497 of file NumericValue.h.

    {
        return lhs._iVal || rhs._iVal;
    }

Member Data Documentation

◆ _isInf

bool SVF::BoundedInt::_isInf

protected

Definition at line 59 of file NumericValue.h.

◆ _iVal

s64_t SVF::BoundedInt::_iVal

protected

Definition at line 58 of file NumericValue.h.

The documentation for this class was generated from the following file:

/home/runner/work/SVF/SVF/svf/include/AE/Core/NumericValue.h

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ BoundedInt() [1/5]

◆ BoundedInt() [2/5]

◆ BoundedInt() [3/5]

◆ BoundedInt() [4/5]

◆ BoundedInt() [5/5]

◆ ~BoundedInt()

Member Function Documentation

◆ equal()

◆ geq()

◆ getFVal()

◆ getIntNumeral()

◆ getNumeral()

◆ getRealNumeral()

◆ is_infinity()

◆ is_minus_infinity()

◆ is_plus_infinity()

◆ is_real()

◆ is_true()

◆ is_zero()

◆ isZero()

◆ leq()

◆ max()

◆ min()

◆ minus_infinity()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ plus_infinity()

◆ safeAdd()

◆ safeMul()

◆ set_minus_infinity()

◆ set_plus_infinity()

◆ to_string()

Friends And Related Symbol Documentation

◆ abs

◆ eq

◆ ite

◆ max

◆ min

◆ operator!

◆ operator!=

◆ operator%

◆ operator&

◆ operator&&

◆ operator*

◆ operator+

◆ operator- [1/2]

◆ operator- [2/2]

◆ operator/

◆ operator<

◆ operator<< [1/2]

◆ operator<< [2/2]

◆ operator<=

◆ operator==

◆ operator>

◆ operator>=

◆ operator>>

◆ operator^

◆ operator|

◆ operator||

Member Data Documentation

◆ _isInf

◆ _iVal