Softfloat support

Detailed Description

SoftFloat is a software implementation of floating-point calculations according to IEEE 754 standard. All calculations are done in integers, that's why they are machine-independent and bit-exact. This library can be useful in accuracy-critical parts like look-up tables generation, tests, etc. OpenCV contains a subset of SoftFloat partially rewritten to C++.

Types

There are two basic types: softfloat and softdouble. These types are binary compatible with float and double types respectively and support conversions to/from them. Other types from original SoftFloat library like fp16 or fp128 were thrown away as well as quiet/signaling NaN support, on-the-fly rounding mode switch and exception flags (though exceptions can be implemented in the future).

Operations

Both types support the following:

• Construction from signed and unsigned 32-bit and 64 integers, float/double or raw binary representation
• Conversions between each other, to float or double and to int using cvRound, cvTrunc, cvFloor, cvCeil or a bunch of saturate_cast functions
• Add, subtract, multiply, divide, remainder, square root, FMA with absolute precision
• Comparison operations
• Explicit sign, exponent and significand manipulation through get/set methods, number state indicators (isInf, isNan, isSubnormal)
• Type-specific constants like eps, minimum/maximum value, best pi approximation, etc.
• min(), max(), abs(), exp(), log() and pow() functions

Classes
struct	cv::softdouble
struct	cv::softfloat

Functions
	cv::softdouble::softdouble ()
	Default constructor.
	cv::softdouble::softdouble (const double a)
	Construct from double.
	cv::softdouble::softdouble (const int32_t)
	cv::softdouble::softdouble (const int64_t)
	cv::softdouble::softdouble (const softdouble &c)
	Copy constructor.
	cv::softdouble::softdouble (const uint32_t)
	Construct from integer.
	cv::softdouble::softdouble (const uint64_t)
	cv::softfloat::softfloat ()
	Default constructor.
	cv::softfloat::softfloat (const float a)
	Construct from float.
	cv::softfloat::softfloat (const int32_t)
	cv::softfloat::softfloat (const int64_t)
	cv::softfloat::softfloat (const softfloat &c)
	Copy constructor.
	cv::softfloat::softfloat (const uint32_t)
	Construct from integer.
	cv::softfloat::softfloat (const uint64_t)
softdouble	cv::abs (softdouble a)
softfloat	cv::abs (softfloat a)
	Absolute value.
softfloat	cv::cbrt (const softfloat &a)
	Cube root.
softdouble	cv::cos (const softdouble &a)
	Cosine.
static softdouble	cv::softdouble::eps ()
	Difference between 1 and next representable value.
static softfloat	cv::softfloat::eps ()
	Difference between 1 and next representable value.
softdouble	cv::exp (const softdouble &a)
softfloat	cv::exp (const softfloat &a)
	Exponent.
static softdouble	cv::softdouble::fromRaw (const uint64_t a)
	Construct from raw.
static const softfloat	cv::softfloat::fromRaw (const uint32_t a)
	Construct from raw.
int	cv::softdouble::getExp () const
	Get 0-based exponent.
int	cv::softfloat::getExp () const
	Get 0-based exponent.
softdouble	cv::softdouble::getFrac () const
	Get a fraction part.
softfloat	cv::softfloat::getFrac () const
	Get a fraction part.
bool	cv::softdouble::getSign () const
	Get sign bit.
bool	cv::softfloat::getSign () const
	Get sign bit.
static softdouble	cv::softdouble::inf ()
	Positive infinity constant.
static softfloat	cv::softfloat::inf ()
	Positive infinity constant.
bool	cv::softdouble::isInf () const
	Inf state indicator.
bool	cv::softfloat::isInf () const
	Inf state indicator.
bool	cv::softdouble::isNaN () const
	NaN state indicator.
bool	cv::softfloat::isNaN () const
	NaN state indicator.
bool	cv::softdouble::isSubnormal () const
	Subnormal number indicator.
bool	cv::softfloat::isSubnormal () const
	Subnormal number indicator.
softdouble	cv::log (const softdouble &a)
softfloat	cv::log (const softfloat &a)
	Natural logarithm.
softdouble	cv::max (const softdouble &a, const softdouble &b)
softfloat	cv::max (const softfloat &a, const softfloat &b)
static softdouble	cv::softdouble::max ()
	Biggest finite value.
static softfloat	cv::softfloat::max ()
	Biggest finite value.
softdouble	cv::min (const softdouble &a, const softdouble &b)
softfloat	cv::min (const softfloat &a, const softfloat &b)
	Min and Max functions.
static softdouble	cv::softdouble::min ()
	Smallest normalized value.
static softfloat	cv::softfloat::min ()
	Smallest normalized value.
softdouble	cv::mulAdd (const softdouble &a, const softdouble &b, const softdouble &c)
softfloat	cv::mulAdd (const softfloat &a, const softfloat &b, const softfloat &c)
	Fused Multiplication and Addition.
static softdouble	cv::softdouble::nan ()
	Default NaN constant.
static softfloat	cv::softfloat::nan ()
	Default NaN constant.
static softdouble	cv::softdouble::one ()
	One constant.
static softfloat	cv::softfloat::one ()
	One constant.
	cv::softdouble::operator double () const
	cv::softfloat::operator float () const
	cv::softfloat::operator softdouble () const
	Type casts
	cv::softdouble::operator softfloat () const
	Type casts
bool	cv::softdouble::operator!= (const softdouble &) const
bool	cv::softfloat::operator!= (const softfloat &) const
softdouble	cv::softdouble::operator% (const softdouble &) const
	Remainder operator.
softfloat	cv::softfloat::operator% (const softfloat &) const
	Remainder operator.
softdouble &	cv::softdouble::operator%= (const softdouble &a)
softfloat &	cv::softfloat::operator%= (const softfloat &a)
softdouble	cv::softdouble::operator* (const softdouble &) const
softfloat	cv::softfloat::operator* (const softfloat &) const
softdouble &	cv::softdouble::operator*= (const softdouble &a)
softfloat &	cv::softfloat::operator*= (const softfloat &a)
softdouble	cv::softdouble::operator+ (const softdouble &) const
	Basic arithmetics.
softfloat	cv::softfloat::operator+ (const softfloat &) const
	Basic arithmetics.
softdouble &	cv::softdouble::operator+= (const softdouble &a)
softfloat &	cv::softfloat::operator+= (const softfloat &a)
softdouble	cv::softdouble::operator- () const
softdouble	cv::softdouble::operator- (const softdouble &) const
softfloat	cv::softfloat::operator- () const
softfloat	cv::softfloat::operator- (const softfloat &) const
softdouble &	cv::softdouble::operator-= (const softdouble &a)
softfloat &	cv::softfloat::operator-= (const softfloat &a)
softdouble	cv::softdouble::operator/ (const softdouble &) const
softfloat	cv::softfloat::operator/ (const softfloat &) const
softdouble &	cv::softdouble::operator/= (const softdouble &a)
softfloat &	cv::softfloat::operator/= (const softfloat &a)
bool	cv::softdouble::operator< (const softdouble &) const
bool	cv::softfloat::operator< (const softfloat &) const
bool	cv::softdouble::operator<= (const softdouble &) const
bool	cv::softfloat::operator<= (const softfloat &) const
softdouble &	cv::softdouble::operator= (const softdouble &c)
	Assign constructor.
softfloat &	cv::softfloat::operator= (const softfloat &c)
	Assign constructor.
bool	cv::softdouble::operator== (const softdouble &) const
	Comparison operations.
bool	cv::softfloat::operator== (const softfloat &) const
	Comparison operations.
bool	cv::softdouble::operator> (const softdouble &) const
bool	cv::softfloat::operator> (const softfloat &) const
bool	cv::softdouble::operator>= (const softdouble &) const
bool	cv::softfloat::operator>= (const softfloat &) const
static softdouble	cv::softdouble::pi ()
	Correct pi approximation.
static softfloat	cv::softfloat::pi ()
	Correct pi approximation.
softdouble	cv::pow (const softdouble &a, const softdouble &b)
softfloat	cv::pow (const softfloat &a, const softfloat &b)
	Raising to the power.
template<typename _Tp >
static _Tp	cv::saturate_cast (softdouble a)
template<typename _Tp >
static _Tp	cv::saturate_cast (softfloat a)
	Saturate casts.
template<>
int64_t	cv::saturate_cast< int64_t > (softdouble a)
template<>
int64_t	cv::saturate_cast< int64_t > (softfloat a)
template<>
schar	cv::saturate_cast< schar > (softdouble a)
template<>
schar	cv::saturate_cast< schar > (softfloat a)
template<>
short	cv::saturate_cast< short > (softdouble a)
template<>
short	cv::saturate_cast< short > (softfloat a)
template<>
uchar	cv::saturate_cast< uchar > (softdouble a)
template<>
uchar	cv::saturate_cast< uchar > (softfloat a)
template<>
uint64_t	cv::saturate_cast< uint64_t > (softdouble a)
template<>
uint64_t	cv::saturate_cast< uint64_t > (softfloat a)
template<>
unsigned	cv::saturate_cast< unsigned > (softdouble a)
template<>
unsigned	cv::saturate_cast< unsigned > (softfloat a)
	Saturate cast to unsigned integer and unsigned long long integer We intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
template<>
ushort	cv::saturate_cast< ushort > (softdouble a)
template<>
ushort	cv::saturate_cast< ushort > (softfloat a)
softdouble	cv::softdouble::setExp (int e) const
	Construct a copy with new 0-based exponent.
softfloat	cv::softfloat::setExp (int e) const
	Construct a copy with new 0-based exponent.
softdouble	cv::softdouble::setFrac (const softdouble &s) const
	Construct a copy with provided significand.
softfloat	cv::softfloat::setFrac (const softfloat &s) const
	Construct a copy with provided significand.
softdouble	cv::softdouble::setSign (bool sign) const
	Construct a copy with new sign bit.
softfloat	cv::softfloat::setSign (bool sign) const
	Construct a copy with new sign bit.
softdouble	cv::sin (const softdouble &a)
	Sine.
softdouble	cv::sqrt (const softdouble &a)
softfloat	cv::sqrt (const softfloat &a)
	Square root.
static softdouble	cv::softdouble::zero ()
	Zero constant.
static softfloat	cv::softfloat::zero ()
	Zero constant.

Variables
uint64_t	cv::softdouble::v
uint32_t	cv::softfloat::v

Function Documentation

softdouble() [1/7]

cv::softdouble::softdouble ( )

inline

#include <opencv2/core/softfloat.hpp>

Default constructor.

softdouble() [2/7]

cv::softdouble::softdouble ( const double a )

inlineexplicit

#include <opencv2/core/softfloat.hpp>

Construct from double.

softdouble() [3/7]

cv::softdouble::softdouble ( const int32_t )

explicit

#include <opencv2/core/softfloat.hpp>

softdouble() [4/7]

cv::softdouble::softdouble ( const int64_t )

explicit

#include <opencv2/core/softfloat.hpp>

softdouble() [5/7]

cv::softdouble::softdouble ( const softdouble & c )

inline

#include <opencv2/core/softfloat.hpp>

Copy constructor.

softdouble() [6/7]

cv::softdouble::softdouble ( const uint32_t )

explicit

#include <opencv2/core/softfloat.hpp>

Construct from integer.

softdouble() [7/7]

cv::softdouble::softdouble ( const uint64_t )

explicit

#include <opencv2/core/softfloat.hpp>

softfloat() [1/7]

cv::softfloat::softfloat ( )

inline

#include <opencv2/core/softfloat.hpp>

Default constructor.

softfloat() [2/7]

cv::softfloat::softfloat ( const float a )

inlineexplicit

#include <opencv2/core/softfloat.hpp>

Construct from float.

softfloat() [3/7]

cv::softfloat::softfloat ( const int32_t )

explicit

#include <opencv2/core/softfloat.hpp>

softfloat() [4/7]

cv::softfloat::softfloat ( const int64_t )

explicit

#include <opencv2/core/softfloat.hpp>

softfloat() [5/7]

cv::softfloat::softfloat ( const softfloat & c )

inline

#include <opencv2/core/softfloat.hpp>

Copy constructor.

softfloat() [6/7]

cv::softfloat::softfloat ( const uint32_t )

explicit

#include <opencv2/core/softfloat.hpp>

Construct from integer.

softfloat() [7/7]

cv::softfloat::softfloat ( const uint64_t )

explicit

#include <opencv2/core/softfloat.hpp>

abs() [1/2]

softdouble cv::abs ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

abs() [2/2]

softfloat cv::abs ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Absolute value.

cbrt()

softfloat cv::cbrt

(

const softfloat &

a

)

#include <opencv2/core/softfloat.hpp>

Cube root.

Special cases:

• cbrt(NaN) is NaN
• cbrt(+/-Inf) is +/-Inf

cos()

softdouble cv::cos

(

const softdouble &

a

)

#include <opencv2/core/softfloat.hpp>

Cosine.

Special cases:

• cos(Inf) or cos(NaN) is NaN
• cos(x) == +/- 1 when cos(x) is close to +/- 1

eps() [1/2]

static softdouble cv::softdouble::eps ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Difference between 1 and next representable value.

eps() [2/2]

static softfloat cv::softfloat::eps ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Difference between 1 and next representable value.

exp() [1/2]

softdouble cv::exp

(

const softdouble &

a

)

Python:
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

exp() [2/2]

softfloat cv::exp

(

const softfloat &

a

)

Python:
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

Exponent.

Special cases:

• exp(NaN) is NaN
• exp(-Inf) == 0
• exp(+Inf) == +Inf

fromRaw() [1/2]

static softdouble cv::softdouble::fromRaw ( const uint64_t a )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Construct from raw.

Builds new value from raw binary representation

fromRaw() [2/2]

static const softfloat cv::softfloat::fromRaw ( const uint32_t a )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Construct from raw.

Builds new value from raw binary representation

getExp() [1/2]

int cv::softdouble::getExp ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get 0-based exponent.

getExp() [2/2]

int cv::softfloat::getExp ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get 0-based exponent.

getFrac() [1/2]

softdouble cv::softdouble::getFrac ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get a fraction part.

Returns a number 1 <= x < 2 with the same significand

getFrac() [2/2]

softfloat cv::softfloat::getFrac ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get a fraction part.

Returns a number 1 <= x < 2 with the same significand

getSign() [1/2]

bool cv::softdouble::getSign ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get sign bit.

getSign() [2/2]

bool cv::softfloat::getSign ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Get sign bit.

inf() [1/2]

static softdouble cv::softdouble::inf ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Positive infinity constant.

inf() [2/2]

static softfloat cv::softfloat::inf ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Positive infinity constant.

isInf() [1/2]

bool cv::softdouble::isInf ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Inf state indicator.

isInf() [2/2]

bool cv::softfloat::isInf ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Inf state indicator.

isNaN() [1/2]

bool cv::softdouble::isNaN ( ) const

inline

#include <opencv2/core/softfloat.hpp>

NaN state indicator.

isNaN() [2/2]

bool cv::softfloat::isNaN ( ) const

inline

#include <opencv2/core/softfloat.hpp>

NaN state indicator.

isSubnormal() [1/2]

bool cv::softdouble::isSubnormal ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Subnormal number indicator.

isSubnormal() [2/2]

bool cv::softfloat::isSubnormal ( ) const

inline

#include <opencv2/core/softfloat.hpp>

Subnormal number indicator.

log() [1/2]

softdouble cv::log

(

const softdouble &

a

)

Python:
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

log() [2/2]

softfloat cv::log

(

const softfloat &

a

)

Python:
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

Natural logarithm.

Special cases:

• log(NaN), log(x < 0) are NaN
• log(0) == -Inf

max() [1/4]

softdouble cv::max ( const softdouble & a, const softdouble & b )

inline

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

max() [2/4]

softfloat cv::max ( const softfloat & a, const softfloat & b )

inline

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

max() [3/4]

static softdouble cv::softdouble::max ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Biggest finite value.

max() [4/4]

static softfloat cv::softfloat::max ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Biggest finite value.

min() [1/4]

softdouble cv::min ( const softdouble & a, const softdouble & b )

inline

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

min() [2/4]

softfloat cv::min ( const softfloat & a, const softfloat & b )

inline

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

Min and Max functions.

min() [3/4]

static softdouble cv::softdouble::min ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Smallest normalized value.

min() [4/4]

static softfloat cv::softfloat::min ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Smallest normalized value.

mulAdd() [1/2]

softdouble cv::mulAdd	(	const softdouble &	a,
		const softdouble &	b,
		const softdouble &	c )

#include <opencv2/core/softfloat.hpp>

mulAdd() [2/2]

softfloat cv::mulAdd	(	const softfloat &	a,
		const softfloat &	b,
		const softfloat &	c )

#include <opencv2/core/softfloat.hpp>

Fused Multiplication and Addition.

Computes (a*b)+c with single rounding

nan() [1/2]

static softdouble cv::softdouble::nan ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Default NaN constant.

nan() [2/2]

static softfloat cv::softfloat::nan ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Default NaN constant.

one() [1/2]

static softdouble cv::softdouble::one ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

One constant.

one() [2/2]

static softfloat cv::softfloat::one ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

One constant.

operator double()

cv::softdouble::operator double ( ) const

inline

#include <opencv2/core/softfloat.hpp>

operator float()

cv::softfloat::operator float ( ) const

inline

#include <opencv2/core/softfloat.hpp>

operator softdouble()

cv::softfloat::operator softdouble

(

)

const

#include <opencv2/core/softfloat.hpp>

Type casts

operator softfloat()

cv::softdouble::operator softfloat

(

)

const

#include <opencv2/core/softfloat.hpp>

Type casts

operator!=() [1/2]

bool cv::softdouble::operator!=

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator!=() [2/2]

bool cv::softfloat::operator!=

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator%() [1/2]

softdouble cv::softdouble::operator%

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

Remainder operator.

A quote from original SoftFloat manual:

‍The IEEE Standard remainder operation computes the value a - n * b, where n is the integer closest to a / b. If a / b is exactly halfway between two integers, n is the even integer closest to a / b. The IEEE Standard’s remainder operation is always exact and so requires no rounding. Depending on the relative magnitudes of the operands, the remainder functions can take considerably longer to execute than the other SoftFloat functions. This is an inherent characteristic of the remainder operation itself and is not a flaw in the SoftFloat implementation.

operator%() [2/2]

softfloat cv::softfloat::operator%

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

Remainder operator.

A quote from original SoftFloat manual:

‍The IEEE Standard remainder operation computes the value a - n * b, where n is the integer closest to a / b. If a / b is exactly halfway between two integers, n is the even integer closest to a / b. The IEEE Standard’s remainder operation is always exact and so requires no rounding. Depending on the relative magnitudes of the operands, the remainder functions can take considerably longer to execute than the other SoftFloat functions. This is an inherent characteristic of the remainder operation itself and is not a flaw in the SoftFloat implementation.

operator%=() [1/2]

softdouble & cv::softdouble::operator%= ( const softdouble & a )

inline

#include <opencv2/core/softfloat.hpp>

operator%=() [2/2]

softfloat & cv::softfloat::operator%= ( const softfloat & a )

inline

#include <opencv2/core/softfloat.hpp>

operator*() [1/2]

softdouble cv::softdouble::operator*

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator*() [2/2]

softfloat cv::softfloat::operator*

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator*=() [1/2]

softdouble & cv::softdouble::operator*= ( const softdouble & a )

inline

#include <opencv2/core/softfloat.hpp>

operator*=() [2/2]

softfloat & cv::softfloat::operator*= ( const softfloat & a )

inline

#include <opencv2/core/softfloat.hpp>

operator+() [1/2]

softdouble cv::softdouble::operator+

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

Basic arithmetics.

operator+() [2/2]

softfloat cv::softfloat::operator+

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

Basic arithmetics.

operator+=() [1/2]

softdouble & cv::softdouble::operator+= ( const softdouble & a )

inline

#include <opencv2/core/softfloat.hpp>

operator+=() [2/2]

softfloat & cv::softfloat::operator+= ( const softfloat & a )

inline

#include <opencv2/core/softfloat.hpp>

operator-() [1/4]

softdouble cv::softdouble::operator- ( ) const

inline

#include <opencv2/core/softfloat.hpp>

operator-() [2/4]

softdouble cv::softdouble::operator-

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator-() [3/4]

softfloat cv::softfloat::operator- ( ) const

inline

#include <opencv2/core/softfloat.hpp>

operator-() [4/4]

softfloat cv::softfloat::operator-

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator-=() [1/2]

softdouble & cv::softdouble::operator-= ( const softdouble & a )

inline

#include <opencv2/core/softfloat.hpp>

operator-=() [2/2]

softfloat & cv::softfloat::operator-= ( const softfloat & a )

inline

#include <opencv2/core/softfloat.hpp>

operator/() [1/2]

softdouble cv::softdouble::operator/

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator/() [2/2]

softfloat cv::softfloat::operator/

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator/=() [1/2]

softdouble & cv::softdouble::operator/= ( const softdouble & a )

inline

#include <opencv2/core/softfloat.hpp>

operator/=() [2/2]

softfloat & cv::softfloat::operator/= ( const softfloat & a )

inline

#include <opencv2/core/softfloat.hpp>

operator<() [1/2]

bool cv::softdouble::operator<

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator<() [2/2]

bool cv::softfloat::operator<

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator<=() [1/2]

bool cv::softdouble::operator<=

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator<=() [2/2]

bool cv::softfloat::operator<=

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator=() [1/2]

softdouble & cv::softdouble::operator= ( const softdouble & c )

inline

#include <opencv2/core/softfloat.hpp>

Assign constructor.

operator=() [2/2]

softfloat & cv::softfloat::operator= ( const softfloat & c )

inline

#include <opencv2/core/softfloat.hpp>

Assign constructor.

operator==() [1/2]

bool cv::softdouble::operator==

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

Comparison operations.

• Any operation with NaN produces false
  • The only exception is when x is NaN: x != y for any y.
• Positive and negative zeros are equal

operator==() [2/2]

bool cv::softfloat::operator==

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

Comparison operations.

• Any operation with NaN produces false
  • The only exception is when x is NaN: x != y for any y.
• Positive and negative zeros are equal

operator>() [1/2]

bool cv::softdouble::operator>

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator>() [2/2]

bool cv::softfloat::operator>

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

operator>=() [1/2]

bool cv::softdouble::operator>=

(

const softdouble &

)

const

#include <opencv2/core/softfloat.hpp>

operator>=() [2/2]

bool cv::softfloat::operator>=

(

const softfloat &

)

const

#include <opencv2/core/softfloat.hpp>

pi() [1/2]

static softdouble cv::softdouble::pi ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Correct pi approximation.

pi() [2/2]

static softfloat cv::softfloat::pi ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Correct pi approximation.

pow() [1/2]

softdouble cv::pow	(	const softdouble &	a,
		const softdouble &	b )

Python:
	cv.pow(	src, power[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

pow() [2/2]

softfloat cv::pow	(	const softfloat &	a,
		const softfloat &	b )

Python:
	cv.pow(	src, power[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

Raising to the power.

Special cases:

• x**NaN is NaN for any x
• ( |x| == 1 )**Inf is NaN
• ( |x| > 1 )**+Inf or ( |x| < 1 )**-Inf is +Inf
• ( |x| > 1 )**-Inf or ( |x| < 1 )**+Inf is 0
• x ** 0 == 1 for any x
• x ** 1 == 1 for any x
• NaN ** y is NaN for any other y
• Inf**(y < 0) == 0
• Inf ** y is +Inf for any other y
• (x < 0)**y is NaN for any other y if x can't be correctly rounded to integer
• 0 ** 0 == 1
• 0 ** (y < 0) is +Inf
• 0 ** (y > 0) is 0

saturate_cast() [1/2]

template<typename _Tp >

static _Tp cv::saturate_cast ( softdouble a )

inlinestatic

#include <opencv2/core/softfloat.hpp>

saturate_cast() [2/2]

template<typename _Tp >

static _Tp cv::saturate_cast ( softfloat a )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Saturate casts.

saturate_cast< int64_t >() [1/2]

template<>

int64_t cv::saturate_cast< int64_t > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< int64_t >() [2/2]

template<>

int64_t cv::saturate_cast< int64_t > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< schar >() [1/2]

template<>

schar cv::saturate_cast< schar > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< schar >() [2/2]

template<>

schar cv::saturate_cast< schar > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< short >() [1/2]

template<>

short cv::saturate_cast< short > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< short >() [2/2]

template<>

short cv::saturate_cast< short > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< uchar >() [1/2]

template<>

uchar cv::saturate_cast< uchar > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< uchar >() [2/2]

template<>

uchar cv::saturate_cast< uchar > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< uint64_t >() [1/2]

template<>

uint64_t cv::saturate_cast< uint64_t > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< uint64_t >() [2/2]

template<>

uint64_t cv::saturate_cast< uint64_t > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< unsigned >() [1/2]

template<>

unsigned cv::saturate_cast< unsigned > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< unsigned >() [2/2]

template<>

unsigned cv::saturate_cast< unsigned > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Saturate cast to unsigned integer and unsigned long long integer We intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.

Here is the call graph for this function:

saturate_cast< ushort >() [1/2]

template<>

ushort cv::saturate_cast< ushort > ( softdouble a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

saturate_cast< ushort >() [2/2]

template<>

ushort cv::saturate_cast< ushort > ( softfloat a )

inline

#include <opencv2/core/softfloat.hpp>

Here is the call graph for this function:

setExp() [1/2]

softdouble cv::softdouble::setExp ( int e ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with new 0-based exponent.

setExp() [2/2]

softfloat cv::softfloat::setExp ( int e ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with new 0-based exponent.

setFrac() [1/2]

softdouble cv::softdouble::setFrac ( const softdouble & s ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with provided significand.

Constructs a copy of a number with significand taken from parameter

setFrac() [2/2]

softfloat cv::softfloat::setFrac ( const softfloat & s ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with provided significand.

Constructs a copy of a number with significand taken from parameter

setSign() [1/2]

softdouble cv::softdouble::setSign ( bool sign ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with new sign bit.

setSign() [2/2]

softfloat cv::softfloat::setSign ( bool sign ) const

inline

#include <opencv2/core/softfloat.hpp>

Construct a copy with new sign bit.

sin()

softdouble cv::sin

(

const softdouble &

a

)

#include <opencv2/core/softfloat.hpp>

Sine.

Special cases:

• sin(Inf) or sin(NaN) is NaN
• sin(x) == x when sin(x) is close to zero

sqrt() [1/2]

softdouble cv::sqrt

(

const softdouble &

a

)

Python:
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

sqrt() [2/2]

softfloat cv::sqrt

(

const softfloat &

a

)

Python:
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core/softfloat.hpp>

Square root.

zero() [1/2]

static softdouble cv::softdouble::zero ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Zero constant.

zero() [2/2]

static softfloat cv::softfloat::zero ( )

inlinestatic

#include <opencv2/core/softfloat.hpp>

Zero constant.

Variable Documentation

v [1/2]

uint64_t cv::softdouble::v

v [2/2]

uint32_t cv::softfloat::v