SVF::BoundedInt Class Reference

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. More...
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. More...
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
BoundedInt	operator== (const BoundedInt &lhs, const BoundedInt &rhs)
	Reload operator. More...
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	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 54 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 69 of file NumericValue.h.

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

BoundedInt() [3/5]

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

inline

Definition at line 73 of file NumericValue.h.

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

BoundedInt() [4/5]

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

inline

Definition at line 76 of file NumericValue.h.

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

BoundedInt() [5/5]

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

inline

Definition at line 87 of file NumericValue.h.

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

~BoundedInt()

virtual SVF::BoundedInt::~BoundedInt ( )

inlinevirtual

Definition at line 98 of file NumericValue.h.

{}

Member Function Documentation

equal()

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

inline

Definition at line 155 of file NumericValue.h.

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

geq()

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

inline

Definition at line 189 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 714 of file NumericValue.h.

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

getIntNumeral()

s64_t SVF::BoundedInt::getIntNumeral ( ) const

inline

Definition at line 703 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 661 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 708 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 113 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 107 of file NumericValue.h.

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

is_plus_infinity()

bool SVF::BoundedInt::is_plus_infinity ( ) const

inline

Definition at line 101 of file NumericValue.h.

    {
        return _isInf && _iVal == 1;
    }

is_real()

bool SVF::BoundedInt::is_real ( ) const

inline

Definition at line 698 of file NumericValue.h.

    {
        return false;
    }

is_true()

bool SVF::BoundedInt::is_true ( ) const

inline

Definition at line 645 of file NumericValue.h.

    {
        return _iVal != 0;
    }

is_zero()

bool SVF::BoundedInt::is_zero ( ) const

inline

Definition at line 143 of file NumericValue.h.

    {
        return _iVal == 0;
    }

isZero()

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

inlinestatic

Definition at line 149 of file NumericValue.h.

    {
        return expr._iVal == 0;
    }

leq()

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

inline

Definition at line 161 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 619 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 601 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 137 of file NumericValue.h.

    {
        return {-1, true};
    }

operator=() [1/2]

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

inline

Definition at line 90 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 79 of file NumericValue.h.

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

plus_infinity()

static BoundedInt SVF::BoundedInt::plus_infinity ( )

inlinestatic

Definition at line 131 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 280 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 364 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 125 of file NumericValue.h.

    {
        *this = minus_infinity();
    }

set_plus_infinity()

void SVF::BoundedInt::set_plus_infinity ( )

inline

Definition at line 119 of file NumericValue.h.

    {
        *this = plus_infinity();
    }

to_string()

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

inlinevirtual

Definition at line 682 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 Function Documentation

abs

BoundedInt abs ( const BoundedInt &  lhs )

friend

Definition at line 637 of file NumericValue.h.

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

eq

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

friend

Definition at line 561 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 543 of file NumericValue.h.

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

max

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

friend

Definition at line 585 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 569 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 499 of file NumericValue.h.

    {
        return !lhs._iVal;
    }

operator!=

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

friend

Definition at line 225 of file NumericValue.h.

    {
        return !lhs.equal(rhs);
    }

operator%

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

friend

Definition at line 420 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 471 of file NumericValue.h.

    {
        return lhs._iVal & rhs._iVal;
    }

operator&&

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

friend

Definition at line 487 of file NumericValue.h.

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

operator*

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

friend

Definition at line 438 of file NumericValue.h.

    {
        return safeMul(lhs, rhs);
    }

operator+

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

friend

Definition at line 327 of file NumericValue.h.

    {
        return safeAdd(lhs, rhs);
    }

operator- [1/2]

BoundedInt operator- ( const BoundedInt &  lhs )

friend

Definition at line 334 of file NumericValue.h.

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

operator- [2/2]

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

friend

Definition at line 342 of file NumericValue.h.

    {
        return safeAdd(lhs, -rhs);
    }

operator/

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

friend

Definition at line 446 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;
        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<

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

friend

Definition at line 237 of file NumericValue.h.

    {
        return !lhs.geq(rhs);
    }

operator<< [1/2]

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

friend

Definition at line 527 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 552 of file NumericValue.h.

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

operator<=

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

friend

Definition at line 244 of file NumericValue.h.

    {
        return lhs.leq(rhs);
    }

operator==

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

friend

Reload operator.

Definition at line 219 of file NumericValue.h.

    {
        return lhs.equal(rhs);
    }

operator>

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

friend

Definition at line 231 of file NumericValue.h.

    {
        return !lhs.leq(rhs);
    }

operator>=

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

friend

Definition at line 251 of file NumericValue.h.

    {
        return lhs.geq(rhs);
    }

operator>>

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

friend

Definition at line 509 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 465 of file NumericValue.h.

    {
        return lhs._iVal ^ rhs._iVal;
    }

operator|

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

friend

Definition at line 477 of file NumericValue.h.

    {
        return lhs._iVal | rhs._iVal;
    }

operator||

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

friend

Definition at line 493 of file NumericValue.h.

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

Member Data Documentation

_isInf

bool SVF::BoundedInt::_isInf

protected

Definition at line 58 of file NumericValue.h.

_iVal

s64_t SVF::BoundedInt::_iVal

protected

Definition at line 57 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