SVF::BoundedDouble Class Reference

#include <NumericValue.h>

Public Member Functions
	BoundedDouble (double fVal)
	BoundedDouble (const BoundedDouble &rhs)
BoundedDouble &	operator= (const BoundedDouble &rhs)
	BoundedDouble (BoundedDouble &&rhs)
BoundedDouble &	operator= (BoundedDouble &&rhs)
virtual	~BoundedDouble ()
const double	getFVal () const
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 BoundedDouble &rhs) const
bool	leq (const BoundedDouble &rhs) const
bool	geq (const BoundedDouble &rhs) const
bool	is_int () const
bool	is_real () const
bool	is_true () const
s64_t	getNumeral () const
	Return Numeral.
s64_t	getIntNumeral () const
double	getRealNumeral () const
virtual const std::string	to_string () const

Static Public Member Functions
static bool	doubleEqual (double a, double b)
static BoundedDouble	plus_infinity ()
static BoundedDouble	minus_infinity ()
static bool	isZero (const BoundedDouble &expr)
static double	safeAdd (double lhs, double rhs)
static double	safeMul (double lhs, double rhs)
static double	safeDiv (double lhs, double rhs)
static BoundedDouble	min (std::vector< BoundedDouble > &_l)
static BoundedDouble	max (std::vector< BoundedDouble > &_l)

Protected Member Functions
	BoundedDouble ()=default

Protected Attributes
double	_fVal

Friends
bool	operator== (const BoundedDouble &lhs, const BoundedDouble &rhs)
	Reload operator.
bool	operator!= (const BoundedDouble &lhs, const BoundedDouble &rhs)
bool	operator> (const BoundedDouble &lhs, const BoundedDouble &rhs)
bool	operator< (const BoundedDouble &lhs, const BoundedDouble &rhs)
bool	operator<= (const BoundedDouble &lhs, const BoundedDouble &rhs)
bool	operator>= (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator+ (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator- (const BoundedDouble &lhs)
BoundedDouble	operator- (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator* (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator/ (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator% (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator^ (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator& (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator| (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator&& (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator|| (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator! (const BoundedDouble &lhs)
BoundedDouble	operator>> (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	operator<< (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	ite (const BoundedDouble &cond, const BoundedDouble &lhs, const BoundedDouble &rhs)
std::ostream &	operator<< (std::ostream &out, const BoundedDouble &expr)
bool	eq (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	min (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	max (const BoundedDouble &lhs, const BoundedDouble &rhs)
BoundedDouble	abs (const BoundedDouble &lhs)

Detailed Description

Bounded double numeric value

Definition at line 726 of file NumericValue.h.

Constructor & Destructor Documentation

BoundedDouble() [1/4]

SVF::BoundedDouble::BoundedDouble ( )

protecteddefault

BoundedDouble() [2/4]

SVF::BoundedDouble::BoundedDouble ( double  fVal )

inline

Definition at line 734 of file NumericValue.h.

: _fVal(fVal) {}

BoundedDouble() [3/4]

SVF::BoundedDouble::BoundedDouble ( const BoundedDouble &  rhs )

inline

Definition at line 736 of file NumericValue.h.

: _fVal(rhs._fVal) {}

BoundedDouble() [4/4]

SVF::BoundedDouble::BoundedDouble ( BoundedDouble &&  rhs )

inline

Definition at line 744 of file NumericValue.h.

: _fVal(std::move(rhs._fVal)) {}

~BoundedDouble()

virtual SVF::BoundedDouble::~BoundedDouble ( )

inlinevirtual

Definition at line 752 of file NumericValue.h.

{}

Member Function Documentation

doubleEqual()

static bool SVF::BoundedDouble::doubleEqual ( double  a, double  b  )

inlinestatic

Definition at line 754 of file NumericValue.h.

    {
        if (std::isinf(a) && std::isinf(b))
            return a == b;
        return std::fabs(a - b) < epsilon;
    }

equal()

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

inline

Definition at line 811 of file NumericValue.h.

    {
        return doubleEqual(_fVal, rhs._fVal);
    }

geq()

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

inline

Definition at line 840 of file NumericValue.h.

    {
        if (is_infinity() ^ rhs.is_infinity())
        {
            if (is_infinity())
            {
                return is_plus_infinity();
            }
            else
            {
                return rhs.is_minus_infinity();
            }
        }
        if (is_infinity() && rhs.is_infinity())
        {
            if (is_plus_infinity())
                return true;
            else
                return rhs.is_minus_infinity();
        }
        else
            return _fVal >= rhs._fVal;
    }

getFVal()

const double SVF::BoundedDouble::getFVal ( ) const

inline

Definition at line 761 of file NumericValue.h.

    {
        return _fVal;
    }

getIntNumeral()

s64_t SVF::BoundedDouble::getIntNumeral ( ) const

inline

Definition at line 1275 of file NumericValue.h.

    {
        return getNumeral();
    }

getNumeral()

s64_t SVF::BoundedDouble::getNumeral ( ) const

inline

Return Numeral.

Definition at line 1259 of file NumericValue.h.

    {
        if (is_minus_infinity())
        {
            return INT64_MIN;
        }
        else if (is_plus_infinity())
        {
            return INT64_MAX;
        }
        else
        {
            return std::round(_fVal);
        }
    }

getRealNumeral()

double SVF::BoundedDouble::getRealNumeral ( ) const

inline

Definition at line 1280 of file NumericValue.h.

    {
        return _fVal;
    }

is_infinity()

bool SVF::BoundedDouble::is_infinity ( ) const

inline

Definition at line 776 of file NumericValue.h.

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

is_int()

bool SVF::BoundedDouble::is_int ( ) const

inline

Definition at line 1115 of file NumericValue.h.

    {
        return _fVal == std::round(_fVal);
    }

is_minus_infinity()

bool SVF::BoundedDouble::is_minus_infinity ( ) const

inline

Definition at line 771 of file NumericValue.h.

    {
        return _fVal == -std::numeric_limits<double>::infinity();
    }

is_plus_infinity()

bool SVF::BoundedDouble::is_plus_infinity ( ) const

inline

Definition at line 766 of file NumericValue.h.

    {
        return _fVal == std::numeric_limits<double>::infinity();
    }

is_real()

bool SVF::BoundedDouble::is_real ( ) const

inline

Definition at line 1119 of file NumericValue.h.

    {
        return !is_int();
    }

is_true()

bool SVF::BoundedDouble::is_true ( ) const

inline

Definition at line 1253 of file NumericValue.h.

    {
        return _fVal != 0.0f;
    }

is_zero()

bool SVF::BoundedDouble::is_zero ( ) const

inline

Definition at line 801 of file NumericValue.h.

    {
        return doubleEqual(_fVal, 0.0f);
    }

isZero()

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

inlinestatic

Definition at line 806 of file NumericValue.h.

    {
        return doubleEqual(expr.getFVal(), 0.0f);
    }

leq()

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

inline

Definition at line 816 of file NumericValue.h.

    {
        if (is_infinity() ^ rhs.is_infinity())
        {
            if (is_infinity())
            {
                return is_minus_infinity();
            }
            else
            {
                return rhs.is_plus_infinity();
            }
        }
        if (is_infinity() && rhs.is_infinity())
        {
            if (is_minus_infinity())
                return true;
            else
                return rhs.is_plus_infinity();
        }
        else
            return _fVal <= rhs._fVal;
    }

max()

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

inlinestatic

Definition at line 1233 of file NumericValue.h.

    {
        BoundedDouble 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 BoundedDouble SVF::BoundedDouble::min ( std::vector< BoundedDouble > &  _l )

inlinestatic

Definition at line 1218 of file NumericValue.h.

    {
        BoundedDouble 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 BoundedDouble SVF::BoundedDouble::minus_infinity ( )

inlinestatic

Definition at line 796 of file NumericValue.h.

    {
        return -std::numeric_limits<double>::infinity();
    }

operator=() [1/2]

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

inline

Definition at line 746 of file NumericValue.h.

    {
        _fVal = std::move(rhs._fVal);
        return *this;
    }

operator=() [2/2]

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

inline

Definition at line 738 of file NumericValue.h.

    {
        _fVal = rhs._fVal;
        return *this;
    }

plus_infinity()

static BoundedDouble SVF::BoundedDouble::plus_infinity ( )

inlinestatic

Definition at line 791 of file NumericValue.h.

    {
        return std::numeric_limits<double>::infinity();
    }

safeAdd()

static double SVF::BoundedDouble::safeAdd ( double  lhs, double  rhs  )

inlinestatic

Adds two floating-point numbers safely, checking for overflow and underflow conditions.

Parameters

lhs	Left-hand side operand of the addition.
rhs	Right-hand side operand of the addition.

Returns

The sum of lhs and rhs. If overflow or underflow occurs, returns positive or negative infinity.

Definition at line 911 of file NumericValue.h.

    {
        if ((lhs == std::numeric_limits<double>::infinity() &&
                rhs == -std::numeric_limits<double>::infinity()) ||
                (lhs == -std::numeric_limits<double>::infinity() &&
                 rhs == std::numeric_limits<double>::infinity()))
        {
            assert(false && "invalid add");
        }
        double res =
            lhs + rhs; // Perform the addition and store the result in 'res'
 
        // Check if the result is positive infinity due to overflow
        if (res == std::numeric_limits<double>::infinity())
        {
            return res; // Positive overflow has occurred, return positive
            // infinity
        }
 
        // Check if the result is negative infinity, which can indicate a large
        // negative overflow
        if (res == -std::numeric_limits<double>::infinity())
        {
            return res; // Negative "overflow", effectively an underflow to
            // negative infinity
        }
 
        // Check for positive overflow: verify if both operands are positive and
        // their sum exceeds the maximum double value
        if (lhs > 0 && rhs > 0 &&
                (std::numeric_limits<double>::max() - lhs) < rhs)
        {
            res = std::numeric_limits<double>::infinity(); // Set result to
            // positive infinity to
            // indicate overflow
            return res;
        }
 
        // Check for an underflow scenario: both numbers are negative and their
        // sum is more negative than what double can represent
        if (lhs < 0 && rhs < 0 &&
                (-std::numeric_limits<double>::max() - lhs) > rhs)
        {
            res = -std::numeric_limits<
                  double>::infinity(); // Set result to negative infinity to
            // clarify extreme negative sum
            return res;
        }
 
        // If none of the above conditions are met, return the result of the
        // addition
        return res;
    }

safeDiv()

static double SVF::BoundedDouble::safeDiv ( double  lhs, double  rhs  )

inlinestatic

Safely divides one floating-point number by another, checking for division by zero and overflow.

Parameters

lhs	Left-hand side operand (numerator).
rhs	Right-hand side operand (denominator).

Returns

The quotient of lhs and rhs. Returns positive or negative infinity for division by zero, or when overflow occurs.

Definition at line 1052 of file NumericValue.h.

    {
        // Check for division by zero
        if (doubleEqual(rhs, 0.0f))
        {
            return (lhs >= 0.0f) ? std::numeric_limits<double>::infinity()
                   : -std::numeric_limits<double>::infinity();
        }
        double res = lhs / rhs;
        // Check if the result is positive infinity due to overflow
        if (res == std::numeric_limits<double>::infinity())
        {
            return res; // Positive overflow has occurred, return positive
            // infinity
        }
 
        // Check if the result is negative infinity, which can indicate a large
        // negative overflow
        if (res == -std::numeric_limits<double>::infinity())
        {
            return res; // Negative "overflow", effectively an underflow to
            // negative infinity
        }
 
        // Check for overflow when dividing small numbers
        if (rhs > 0 && rhs < std::numeric_limits<double>::min() &&
                lhs > std::numeric_limits<double>::max() * rhs)
        {
            return std::numeric_limits<double>::infinity();
        }
        if (rhs < 0 && rhs > -std::numeric_limits<double>::min() &&
                lhs > std::numeric_limits<double>::max() * rhs)
        {
            return -std::numeric_limits<double>::infinity();
        }
 
        return res; // If no special cases, return the quotient
    }

safeMul()

static double SVF::BoundedDouble::safeMul ( double  lhs, double  rhs  )

inlinestatic

Safely multiplies two floating-point numbers, checking for overflow and underflow.

Parameters

lhs	Left-hand side operand of the multiplication.
rhs	Right-hand side operand of the multiplication.

Returns

The product of lhs and rhs. If overflow or underflow occurs, returns positive or negative infinity accordingly.

Definition at line 991 of file NumericValue.h.

    {
        if (doubleEqual(lhs, 0.0f) || doubleEqual(rhs, 0.0f))
            return 0.0f;
        double res = lhs * rhs;
        // Check if the result is positive infinity due to overflow
        if (res == std::numeric_limits<double>::infinity())
        {
            return res; // Positive overflow has occurred, return positive
            // infinity
        }
 
        // Check if the result is negative infinity, which can indicate a large
        // negative overflow
        if (res == -std::numeric_limits<double>::infinity())
        {
            return res; // Negative "overflow", effectively an underflow to
            // negative infinity
        }
        // Check for overflow scenarios
        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)
        {
            return std::numeric_limits<double>::infinity();
        }
 
        // Check for "underflow" scenarios (negative overflow)
        if (lhs > 0 && rhs < 0 &&
                rhs < std::numeric_limits<double>::lowest() / lhs)
        {
            return -std::numeric_limits<double>::infinity();
        }
        if (lhs < 0 && rhs > 0 &&
                lhs < std::numeric_limits<double>::lowest() / rhs)
        {
            return -std::numeric_limits<double>::infinity();
        }
 
        return res; // If no overflow or underflow, return the product
    }

set_minus_infinity()

void SVF::BoundedDouble::set_minus_infinity ( )

inline

Definition at line 786 of file NumericValue.h.

    {
        *this = minus_infinity();
    }

set_plus_infinity()

void SVF::BoundedDouble::set_plus_infinity ( )

inline

Definition at line 781 of file NumericValue.h.

    {
        *this = plus_infinity();
    }

to_string()

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

inlinevirtual

Definition at line 1285 of file NumericValue.h.

    {
        return std::to_string(_fVal);
    }

Friends And Related Symbol Documentation

abs

BoundedDouble abs ( const BoundedDouble &  lhs )

friend

Definition at line 1248 of file NumericValue.h.

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

eq

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

friend

Definition at line 1203 of file NumericValue.h.

    {
        return doubleEqual(lhs._fVal, rhs._fVal);
    }

ite

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

friend

Definition at line 1190 of file NumericValue.h.

    {
        return cond._fVal != 0.0f ? lhs._fVal : rhs._fVal;
    }

max

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

friend

Definition at line 1213 of file NumericValue.h.

    {
        return std::max(lhs._fVal, rhs._fVal);
    }

min

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

friend

Definition at line 1208 of file NumericValue.h.

    {
        return std::min(lhs._fVal, rhs._fVal);
    }

operator!

BoundedDouble operator! ( const BoundedDouble &  lhs )

friend

Definition at line 1157 of file NumericValue.h.

    {
        return !lhs._fVal;
    }

operator!=

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

friend

Definition at line 872 of file NumericValue.h.

    {
        return !lhs.equal(rhs);
    }

operator%

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

friend

Definition at line 1097 of file NumericValue.h.

    {
        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())
            return 0.0f;
        // TODO: not sure
        else if (lhs.is_infinity() && !rhs.is_infinity())
            return ite(rhs._fVal > 0.0f, lhs, -lhs);
        else
            // TODO: +oo/-oo L'Hôpital's rule?
            return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
        abort();
    }

operator&

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

friend

Definition at line 1131 of file NumericValue.h.

    {
        int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
        return lInt & rInt;
    }

operator&&

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

friend

Definition at line 1145 of file NumericValue.h.

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

operator*

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

friend

Definition at line 1037 of file NumericValue.h.

    {
        return safeMul(lhs._fVal, rhs._fVal);
    }

operator+

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

friend

Definition at line 965 of file NumericValue.h.

    {
        return safeAdd(lhs._fVal, rhs._fVal);
    }

operator- [1/2]

BoundedDouble operator- ( const BoundedDouble &  lhs )

friend

Definition at line 971 of file NumericValue.h.

    {
        return -lhs._fVal;
    }

operator- [2/2]

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

friend

Definition at line 976 of file NumericValue.h.

    {
        return safeAdd(lhs._fVal, -rhs._fVal);
    }

operator/

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

friend

Definition at line 1091 of file NumericValue.h.

    {
        return safeDiv(lhs._fVal, rhs._fVal);
    }

operator<

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

friend

Definition at line 884 of file NumericValue.h.

    {
        return !lhs.geq(rhs);
    }

operator<< [1/2]

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

friend

Definition at line 1176 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 (s32_t)lhs.getNumeral() << (s32_t)rhs.getNumeral();
    }

operator<< [2/2]

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

friend

Definition at line 1196 of file NumericValue.h.

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

operator<=

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

friend

Definition at line 890 of file NumericValue.h.

    {
        return lhs.leq(rhs);
    }

operator==

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

friend

Reload operator.

Definition at line 866 of file NumericValue.h.

    {
        return lhs.equal(rhs);
    }

operator>

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

friend

Definition at line 878 of file NumericValue.h.

    {
        return !lhs.leq(rhs);
    }

operator>=

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

friend

Definition at line 896 of file NumericValue.h.

    {
        return lhs.geq(rhs);
    }

operator>>

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

friend

Definition at line 1162 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 (s32_t)lhs.getNumeral() >> (s32_t)rhs.getNumeral();
    }

operator^

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

friend

Definition at line 1124 of file NumericValue.h.

    {
        int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
        return lInt ^ rInt;
    }

operator|

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

friend

Definition at line 1138 of file NumericValue.h.

    {
        int lInt = std::round(lhs._fVal), rInt = std::round(rhs._fVal);
        return lInt | rInt;
    }

operator||

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

friend

Definition at line 1151 of file NumericValue.h.

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

Member Data Documentation

_fVal

double SVF::BoundedDouble::_fVal

protected

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