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 727 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 735 of file NumericValue.h.

: _fVal(fVal) {}

BoundedDouble() [3/4]

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

inline

Definition at line 737 of file NumericValue.h.

: _fVal(rhs._fVal) {}

BoundedDouble() [4/4]

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

inline

Definition at line 745 of file NumericValue.h.

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

~BoundedDouble()

virtual SVF::BoundedDouble::~BoundedDouble ( )

inlinevirtual

Definition at line 753 of file NumericValue.h.

{}

Member Function Documentation

doubleEqual()

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

inlinestatic

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

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

geq()

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

inline

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

    {
        return _fVal;
    }

getIntNumeral()

s64_t SVF::BoundedDouble::getIntNumeral ( ) const

inline

Definition at line 1276 of file NumericValue.h.

    {
        return getNumeral();
    }

getNumeral()

s64_t SVF::BoundedDouble::getNumeral ( ) const

inline

Return Numeral.

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

    {
        return _fVal;
    }

is_infinity()

bool SVF::BoundedDouble::is_infinity ( ) const

inline

Definition at line 777 of file NumericValue.h.

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

is_int()

bool SVF::BoundedDouble::is_int ( ) const

inline

Definition at line 1116 of file NumericValue.h.

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

is_minus_infinity()

bool SVF::BoundedDouble::is_minus_infinity ( ) const

inline

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

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

is_real()

bool SVF::BoundedDouble::is_real ( ) const

inline

Definition at line 1120 of file NumericValue.h.

    {
        return !is_int();
    }

is_true()

bool SVF::BoundedDouble::is_true ( ) const

inline

Definition at line 1254 of file NumericValue.h.

    {
        return _fVal != 0.0f;
    }

is_zero()

bool SVF::BoundedDouble::is_zero ( ) const

inline

Definition at line 802 of file NumericValue.h.

    {
        return doubleEqual(_fVal, 0.0f);
    }

isZero()

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

inlinestatic

Definition at line 807 of file NumericValue.h.

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

leq()

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

inline

Definition at line 817 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 1234 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 1219 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 797 of file NumericValue.h.

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

operator=() [1/2]

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

inline

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

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

plus_infinity()

static BoundedDouble SVF::BoundedDouble::plus_infinity ( )

inlinestatic

Definition at line 792 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 912 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 1053 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 992 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 787 of file NumericValue.h.

    {
        *this = minus_infinity();
    }

set_plus_infinity()

void SVF::BoundedDouble::set_plus_infinity ( )

inline

Definition at line 782 of file NumericValue.h.

    {
        *this = plus_infinity();
    }

to_string()

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

inlinevirtual

Definition at line 1286 of file NumericValue.h.

    {
        return std::to_string(_fVal);
    }

Friends And Related Symbol Documentation

abs

BoundedDouble abs ( const BoundedDouble &  lhs )

friend

Definition at line 1249 of file NumericValue.h.

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

eq

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

friend

Definition at line 1204 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 1191 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 1214 of file NumericValue.h.

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

min

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

friend

Definition at line 1209 of file NumericValue.h.

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

operator!

BoundedDouble operator! ( const BoundedDouble &  lhs )

friend

Definition at line 1158 of file NumericValue.h.

    {
        return !lhs._fVal;
    }

operator!=

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

friend

Definition at line 873 of file NumericValue.h.

    {
        return !lhs.equal(rhs);
    }

operator%

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

friend

Definition at line 1098 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 1132 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 1146 of file NumericValue.h.

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

operator*

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

friend

Definition at line 1038 of file NumericValue.h.

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

operator+

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

friend

Definition at line 966 of file NumericValue.h.

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

operator- [1/2]

BoundedDouble operator- ( const BoundedDouble &  lhs )

friend

Definition at line 972 of file NumericValue.h.

    {
        return -lhs._fVal;
    }

operator- [2/2]

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

friend

Definition at line 977 of file NumericValue.h.

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

operator/

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

friend

Definition at line 1092 of file NumericValue.h.

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

operator<

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

friend

Definition at line 885 of file NumericValue.h.

    {
        return !lhs.geq(rhs);
    }

operator<< [1/2]

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

friend

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

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

operator<=

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

friend

Definition at line 891 of file NumericValue.h.

    {
        return lhs.leq(rhs);
    }

operator==

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

friend

Reload operator.

Definition at line 867 of file NumericValue.h.

    {
        return lhs.equal(rhs);
    }

operator>

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

friend

Definition at line 879 of file NumericValue.h.

    {
        return !lhs.leq(rhs);
    }

operator>=

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

friend

Definition at line 897 of file NumericValue.h.

    {
        return lhs.geq(rhs);
    }

operator>>

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

friend

Definition at line 1163 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 1125 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 1139 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 1152 of file NumericValue.h.

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

Member Data Documentation

_fVal

double SVF::BoundedDouble::_fVal

protected

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