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

: _fVal(fVal) {}

BoundedDouble() [3/4]

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

inline

Definition at line 733 of file NumericValue.h.

: _fVal(rhs._fVal) {}

BoundedDouble() [4/4]

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

inline

Definition at line 741 of file NumericValue.h.

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

~BoundedDouble()

virtual SVF::BoundedDouble::~BoundedDouble ( )

inlinevirtual

Definition at line 749 of file NumericValue.h.

{}

Member Function Documentation

doubleEqual()

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

inlinestatic

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

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

geq()

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

inline

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

    {
        return _fVal;
    }

getIntNumeral()

s64_t SVF::BoundedDouble::getIntNumeral ( ) const

inline

Definition at line 1272 of file NumericValue.h.

    {
        return getNumeral();
    }

getNumeral()

s64_t SVF::BoundedDouble::getNumeral ( ) const

inline

Return Numeral.

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

    {
        return _fVal;
    }

is_infinity()

bool SVF::BoundedDouble::is_infinity ( ) const

inline

Definition at line 773 of file NumericValue.h.

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

is_int()

bool SVF::BoundedDouble::is_int ( ) const

inline

Definition at line 1112 of file NumericValue.h.

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

is_minus_infinity()

bool SVF::BoundedDouble::is_minus_infinity ( ) const

inline

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

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

is_real()

bool SVF::BoundedDouble::is_real ( ) const

inline

Definition at line 1116 of file NumericValue.h.

    {
        return !is_int();
    }

is_true()

bool SVF::BoundedDouble::is_true ( ) const

inline

Definition at line 1250 of file NumericValue.h.

    {
        return _fVal != 0.0f;
    }

is_zero()

bool SVF::BoundedDouble::is_zero ( ) const

inline

Definition at line 798 of file NumericValue.h.

    {
        return doubleEqual(_fVal, 0.0f);
    }

isZero()

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

inlinestatic

Definition at line 803 of file NumericValue.h.

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

leq()

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

inline

Definition at line 813 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 1230 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 1215 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 793 of file NumericValue.h.

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

operator=() [1/2]

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

inline

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

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

plus_infinity()

static BoundedDouble SVF::BoundedDouble::plus_infinity ( )

inlinestatic

Definition at line 788 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 908 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 1049 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 988 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 783 of file NumericValue.h.

    {
        *this = minus_infinity();
    }

set_plus_infinity()

void SVF::BoundedDouble::set_plus_infinity ( )

inline

Definition at line 778 of file NumericValue.h.

    {
        *this = plus_infinity();
    }

to_string()

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

inlinevirtual

Definition at line 1282 of file NumericValue.h.

    {
        return std::to_string(_fVal);
    }

Friends And Related Function Documentation

abs

BoundedDouble abs ( const BoundedDouble &  lhs )

friend

Definition at line 1245 of file NumericValue.h.

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

eq

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

friend

Definition at line 1200 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 1187 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 1210 of file NumericValue.h.

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

min

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

friend

Definition at line 1205 of file NumericValue.h.

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

operator!

BoundedDouble operator! ( const BoundedDouble &  lhs )

friend

Definition at line 1154 of file NumericValue.h.

    {
        return !lhs._fVal;
    }

operator!=

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

friend

Definition at line 869 of file NumericValue.h.

    {
        return !lhs.equal(rhs);
    }

operator%

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

friend

Definition at line 1094 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 1128 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 1142 of file NumericValue.h.

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

operator*

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

friend

Definition at line 1034 of file NumericValue.h.

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

operator+

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

friend

Definition at line 962 of file NumericValue.h.

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

operator- [1/2]

BoundedDouble operator- ( const BoundedDouble &  lhs )

friend

Definition at line 968 of file NumericValue.h.

    {
        return -lhs._fVal;
    }

operator- [2/2]

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

friend

Definition at line 973 of file NumericValue.h.

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

operator/

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

friend

Definition at line 1088 of file NumericValue.h.

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

operator<

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

friend

Definition at line 881 of file NumericValue.h.

    {
        return !lhs.geq(rhs);
    }

operator<< [1/2]

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

friend

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

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

operator<=

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

friend

Definition at line 887 of file NumericValue.h.

    {
        return lhs.leq(rhs);
    }

operator==

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

friend

Reload operator.

Definition at line 863 of file NumericValue.h.

    {
        return lhs.equal(rhs);
    }

operator>

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

friend

Definition at line 875 of file NumericValue.h.

    {
        return !lhs.leq(rhs);
    }

operator>=

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

friend

Definition at line 893 of file NumericValue.h.

    {
        return lhs.geq(rhs);
    }

operator>>

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

friend

Definition at line 1159 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 1121 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 1135 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 1148 of file NumericValue.h.

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

Member Data Documentation

_fVal

double SVF::BoundedDouble::_fVal

protected

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