#include "precomp.hpp"

#include "opencv2/core/softfloat.hpp"

namespace cv

{

enum {

tininess_beforeRounding = 0,

tininess_afterRounding = 1

};

static const uint_fast8_t globalDetectTininess = tininess_afterRounding;

enum {

flag_inexact = 1,

flag_underflow = 2,

flag_overflow = 4,

flag_infinite = 8,

flag_invalid = 16

};

static inline void raiseFlags( uint_fast8_t /* flags */)

{

//exceptionFlags |= flags;

}

enum {

round_near_even = 0, // round to nearest, with ties to even

round_minMag = 1, // round to minimum magnitude (toward zero)

round_min = 2, // round to minimum (down)

round_max = 3, // round to maximum (up)

round_near_maxMag = 4, // round to nearest, with ties to maximum magnitude (away from zero)

round_odd = 5 // round to odd (jamming)

};

static const uint_fast8_t globalRoundingMode = round_near_even;

#define signF32UI( a ) (((uint32_t) (a)>>31) != 0)

#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF)

#define fracF32UI( a ) ((a) & 0x007FFFFF)

#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))

#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))

#define signF64UI( a ) (((uint64_t) (a)>>63) != 0)

#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF)

#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))

#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig)))

#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )))

typedef softfloat float32_t;

typedef softdouble float64_t;

static float32_t ui32_to_f32( uint32_t );

static float64_t ui32_to_f64( uint32_t );

static float32_t ui64_to_f32( uint64_t );

static float64_t ui64_to_f64( uint64_t );

static float32_t i32_to_f32( int32_t );

static float64_t i32_to_f64( int32_t );

static float32_t i64_to_f32( int64_t );

static float64_t i64_to_f64( int64_t );

static int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );

static int_fast32_t f32_to_i32_r_minMag( float32_t, bool );

static float64_t f32_to_f64( float32_t );

static float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );

static float32_t f32_add( float32_t, float32_t );

static float32_t f32_sub( float32_t, float32_t );

static float32_t f32_mul( float32_t, float32_t );

static float32_t f32_mulAdd( float32_t, float32_t, float32_t );

static float32_t f32_div( float32_t, float32_t );

static float32_t f32_rem( float32_t, float32_t );

static float32_t f32_sqrt( float32_t );

static bool f32_eq( float32_t, float32_t );

static bool f32_le( float32_t, float32_t );

static bool f32_lt( float32_t, float32_t );

static int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );

static int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );

static int_fast32_t f64_to_i32_r_minMag( float64_t, bool );

static float32_t f64_to_f32( float64_t );

static float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );

static float64_t f64_add( float64_t, float64_t );

static float64_t f64_sub( float64_t, float64_t );

static float64_t f64_mul( float64_t, float64_t );

static float64_t f64_mulAdd( float64_t, float64_t, float64_t );

static float64_t f64_div( float64_t, float64_t );

static float64_t f64_rem( float64_t, float64_t );

static float64_t f64_sqrt( float64_t );

static bool f64_eq( float64_t, float64_t );

static bool f64_le( float64_t, float64_t );

static bool f64_lt( float64_t, float64_t );

static float32_t f32_powi( float32_t x, int y);

static float64_t f64_powi( float64_t x, int y);

static float64_t f64_sin_kernel(float64_t x);

static float64_t f64_cos_kernel(float64_t x);

static void f64_sincos_reduce(const float64_t& x, float64_t& y, int& n);

static float32_t f32_exp( float32_t x);

static float64_t f64_exp(float64_t x);

static float32_t f32_log(float32_t x);

static float64_t f64_log(float64_t x);

static float32_t f32_cbrt(float32_t x);

static float32_t f32_pow( float32_t x, float32_t y);

static float64_t f64_pow( float64_t x, float64_t y);

static float64_t f64_sin( float64_t x );

static float64_t f64_cos( float64_t x );

softfloat::softfloat( const uint32_t a ) { *this = ui32_to_f32(a); }

softfloat::softfloat( const uint64_t a ) { *this = ui64_to_f32(a); }

softfloat::softfloat( const int32_t a ) { *this = i32_to_f32(a); }

softfloat::softfloat( const int64_t a ) { *this = i64_to_f32(a); }

softfloat::operator softdouble() const { return f32_to_f64(*this); }

softfloat softfloat::operator + (const softfloat& a) const { return f32_add(*this, a); }

softfloat softfloat::operator - (const softfloat& a) const { return f32_sub(*this, a); }

softfloat softfloat::operator * (const softfloat& a) const { return f32_mul(*this, a); }

softfloat softfloat::operator / (const softfloat& a) const { return f32_div(*this, a); }

softfloat softfloat::operator % (const softfloat& a) const { return f32_rem(*this, a); }

bool softfloat::operator == ( const softfloat& a ) const { return f32_eq(*this, a); }

bool softfloat::operator != ( const softfloat& a ) const { return !f32_eq(*this, a); }

bool softfloat::operator > ( const softfloat& a ) const { return f32_lt(a, *this); }

bool softfloat::operator >= ( const softfloat& a ) const { return f32_le(a, *this); }

bool softfloat::operator < ( const softfloat& a ) const { return f32_lt(*this, a); }

bool softfloat::operator <= ( const softfloat& a ) const { return f32_le(*this, a); }

softdouble::softdouble( const uint32_t a ) { *this = ui32_to_f64(a); }

softdouble::softdouble( const uint64_t a ) { *this = ui64_to_f64(a); }

softdouble::softdouble( const int32_t a ) { *this = i32_to_f64(a); }

softdouble::softdouble( const int64_t a ) { *this = i64_to_f64(a); }

}

int cvTrunc(const cv::softfloat& a) { return cv::f32_to_i32_r_minMag(a, false); }

int cvRound(const cv::softfloat& a) { return cv::f32_to_i32(a, cv::round_near_even, false); }

int cvFloor(const cv::softfloat& a) { return cv::f32_to_i32(a, cv::round_min, false); }

int cvCeil (const cv::softfloat& a) { return cv::f32_to_i32(a, cv::round_max, false); }

int cvTrunc(const cv::softdouble& a) { return cv::f64_to_i32_r_minMag(a, false); }

int cvRound(const cv::softdouble& a) { return cv::f64_to_i32(a, cv::round_near_even, false); }

int cvFloor(const cv::softdouble& a) { return cv::f64_to_i32(a, cv::round_min, false); }

int cvCeil (const cv::softdouble& a) { return cv::f64_to_i32(a, cv::round_max, false); }

int64_t cvRound64(const cv::softdouble& a) { return cv::f64_to_i64(a, cv::round_near_even, false); }

namespace cv

{

softdouble::operator softfloat() const { return f64_to_f32(*this); }

softdouble softdouble::operator + (const softdouble& a) const { return f64_add(*this, a); }

softdouble softdouble::operator - (const softdouble& a) const { return f64_sub(*this, a); }

softdouble softdouble::operator * (const softdouble& a) const { return f64_mul(*this, a); }

softdouble softdouble::operator / (const softdouble& a) const { return f64_div(*this, a); }

softdouble softdouble::operator % (const softdouble& a) const { return f64_rem(*this, a); }

bool softdouble::operator == (const softdouble& a) const { return f64_eq(*this, a); }

bool softdouble::operator != (const softdouble& a) const { return !f64_eq(*this, a); }

bool softdouble::operator > (const softdouble& a) const { return f64_lt(a, *this); }

bool softdouble::operator >= (const softdouble& a) const { return f64_le(a, *this); }

bool softdouble::operator < (const softdouble& a) const { return f64_lt(*this, a); }

bool softdouble::operator <= (const softdouble& a) const { return f64_le(*this, a); }

softfloat mulAdd( const softfloat& a, const softfloat& b, const softfloat & c) { return f32_mulAdd(a, b, c); }

softdouble mulAdd( const softdouble& a, const softdouble& b, const softdouble& c) { return f64_mulAdd(a, b, c); }

softfloat sqrt( const softfloat& a ) { return f32_sqrt(a); }

softdouble sqrt( const softdouble& a ) { return f64_sqrt(a); }

softfloat exp( const softfloat& a) { return f32_exp(a); }

softdouble exp( const softdouble& a) { return f64_exp(a); }

softfloat log( const softfloat& a ) { return f32_log(a); }

softdouble log( const softdouble& a ) { return f64_log(a); }

softfloat pow( const softfloat& a, const softfloat& b) { return f32_pow(a, b); }

softdouble pow( const softdouble& a, const softdouble& b) { return f64_pow(a, b); }

softfloat cbrt(const softfloat& a) { return f32_cbrt(a); }

softdouble sin(const softdouble& a) { return f64_sin(a); }

softdouble cos(const softdouble& a) { return f64_cos(a); }

#define ui32_fromPosOverflow 0xFFFFFFFF

#define ui32_fromNegOverflow 0

#define ui32_fromNaN 0xFFFFFFFF

#define i32_fromPosOverflow 0x7FFFFFFF

#define i32_fromNegOverflow (-0x7FFFFFFF - 1)

#define i32_fromNaN 0x7FFFFFFF

#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )

#define ui64_fromNegOverflow 0

#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )

#define i64_fromPosOverflow UINT64_C( 0x7FFFFFFFFFFFFFFF )

#define i64_fromNegOverflow (~UINT64_C( 0x7FFFFFFFFFFFFFFF ) + 1 - 1)

#define i64_fromNaN UINT64_C( 0x7FFFFFFFFFFFFFFF )

struct commonNaN {

};

#define defaultNaNF32UI 0xFFC00000

#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))

static void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );

static uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );

static uint_fast32_t softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );

#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )

#define softfloat_isSigNaNF64UI( uiA ) \

((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && \

((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))

static void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );

static uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );

static uint_fast64_t softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );

#ifndef WORDS_BIGENDIAN

struct uint128 { uint64_t v0, v64; };

struct uint64_extra { uint64_t extra, v; };

struct uint128_extra { uint64_t extra; struct uint128 v; };

#else

struct uint128 { uint64_t v64, v0; };

struct uint64_extra { uint64_t v, extra; };

struct uint128_extra { struct uint128 v; uint64_t extra; };

#endif

#ifndef WORDS_BIGENDIAN

#define wordIncr 1

#define indexWord( total, n ) (n)

#define indexWordHi( total ) ((total) - 1)

#define indexWordLo( total ) 0

#define indexMultiword( total, m, n ) (n)

#define indexMultiwordHi( total, n ) ((total) - (n))

#define indexMultiwordLo( total, n ) 0

#define indexMultiwordHiBut( total, n ) (n)

#define indexMultiwordLoBut( total, n ) 0

#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 }

#else

#define wordIncr -1

#define indexWord( total, n ) ((total) - 1 - (n))

#define indexWordHi( total ) 0

#define indexWordLo( total ) ((total) - 1)

#define indexMultiword( total, m, n ) ((total) - 1 - (m))

#define indexMultiwordHi( total, n ) 0

#define indexMultiwordLo( total, n ) ((total) - (n))

#define indexMultiwordHiBut( total, n ) 0

#define indexMultiwordLoBut( total, n ) (n)

#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 }

#endif

enum {

softfloat_mulAdd_subC = 1,

softfloat_mulAdd_subProd = 2

};

static int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );

struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };

static struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );

static float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );

static float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );

static float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );

static float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );

static float32_t softfloat_mulAddF32(uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );

static int_fast64_t softfloat_roundToI64( bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);

struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };

static struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );

static float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );

static float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );

static float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );

static float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );

static float64_t softfloat_mulAddF64( uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );

static inline uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )

{ return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0); }

static inline uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )

}

static inline uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )

}

static const uint_least8_t softfloat_countLeadingZeros8[256] = {

8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

static inline uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )

}

static uint_fast8_t softfloat_countLeadingZeros64( uint64_t a );

#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a)))

static uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );

static const uint16_t softfloat_approxRecipSqrt_1k0s[16] = {

0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29,

0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1

};

static const uint16_t softfloat_approxRecipSqrt_1k1s[16] = {

0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6,

0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD

};

static inline struct uint128 softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )

}

static inline struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist )

}

static struct uint128 softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist );

static inline struct uint128 softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

}

static inline struct uint128 softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

}

static struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );

static float32_t f32_add( float32_t a, float32_t b )

}

static float32_t f32_div( float32_t a, float32_t b )

}

static bool f32_eq( float32_t a, float32_t b )

}

static bool f32_le( float32_t a, float32_t b )

}

static bool f32_lt( float32_t a, float32_t b )

}

static float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )

}

static float32_t f32_mul( float32_t a, float32_t b )

}

static float32_t f32_rem( float32_t a, float32_t b )