| OpenCV 5.0.0alpha Open Source Computer Vision

Loading...
Searching...
No Matches
Classes | Functions | Variables
Softfloat support
Core functionality » Utility and system functions and macros

## 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 | ) |
| inline explicit

`#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 | ) |
| inline explicit

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Difference between 1 and next representable value.

## ◆ eps() [2/2]

static softfloat cv::softfloat::eps | ( |  | ) |
| inline static

`#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 | ) |
| inline static

`#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 | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Positive infinity constant.

## ◆ inf() [2/2]

static softfloat cv::softfloat::inf | ( |  | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Biggest finite value.

## ◆ max() [4/4]

static softfloat cv::softfloat::max | ( |  | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Smallest normalized value.

## ◆ min() [4/4]

static softfloat cv::softfloat::min | ( |  | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Default NaN constant.

## ◆ nan() [2/2]

static softfloat cv::softfloat::nan | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Default NaN constant.

## ◆ one() [1/2]

static softdouble cv::softdouble::one | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

One constant.

## ◆ one() [2/2]

static softfloat cv::softfloat::one | ( |  | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Correct pi approximation.

## ◆ pi() [2/2]

static softfloat cv::softfloat::pi | ( |  | ) |
| inline static

`#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 | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

## ◆ saturate_cast() [2/2]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | softfloat | a | ) |
| inline static

`#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 | ( |  | ) |
| inline static

`#include <opencv2/core/softfloat.hpp>`

Zero constant.

## ◆ zero() [2/2]

static softfloat cv::softfloat::zero | ( |  | ) |
| inline static

`#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