react-native-executorch 0.4.8 → 0.5.1-rc.0

package/third-party/include/opencv2/core/softfloat.hpp

@@ -0,0 +1,657 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html
+
+// This file is based on files from package issued with the following license:
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3c, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#pragma once
+#ifndef softfloat_h
+#define softfloat_h 1
+
+#include "cvdef.h"
+
+namespace cv {
+
+/** @addtogroup core_utils_softfloat
+
+  [SoftFloat](http://www.jhauser.us/arithmetic/SoftFloat.html) 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: @ref softfloat and @ref 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 @ref cvRound, @ref cvTrunc, @ref cvFloor, @ref 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
+
+*/
+//! @{
+
+struct softfloat;
+struct softdouble;
+
+struct CV_EXPORTS softfloat {
+public:
+  /** @brief Default constructor */
+  softfloat() { v = 0; }
+  /** @brief Copy constructor */
+  softfloat(const softfloat &c) { v = c.v; }
+  /** @brief Assign constructor */
+  softfloat &operator=(const softfloat &c) {
+    if (&c != this)
+      v = c.v;
+    return *this;
+  }
+  /** @brief Construct from raw
+
+  Builds new value from raw binary representation
+  */
+  static const softfloat fromRaw(const uint32_t a) {
+    softfloat x;
+    x.v = a;
+    return x;
+  }
+
+  /** @brief Construct from integer */
+  explicit softfloat(const uint32_t);
+  explicit softfloat(const uint64_t);
+  explicit softfloat(const int32_t);
+  explicit softfloat(const int64_t);
+
+#ifdef CV_INT32_T_IS_LONG_INT
+  // for platforms with int32_t = long int
+  explicit softfloat(const int a) {
+    *this = softfloat(static_cast<int32_t>(a));
+  }
+#endif
+
+  /** @brief Construct from float */
+  explicit softfloat(const float a) {
+    Cv32suf s;
+    s.f = a;
+    v = s.u;
+  }
+
+  /** @brief Type casts  */
+  operator softdouble() const;
+  operator float() const {
+    Cv32suf s;
+    s.u = v;
+    return s.f;
+  }
+
+  /** @brief Basic arithmetics */
+  softfloat operator+(const softfloat &) const;
+  softfloat operator-(const softfloat &) const;
+  softfloat operator*(const softfloat &) const;
+  softfloat operator/(const softfloat &) const;
+  softfloat operator-() const {
+    softfloat x;
+    x.v = v ^ (1U << 31);
+    return x;
+  }
+
+  /** @brief 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.
+  */
+  softfloat operator%(const softfloat &) const;
+
+  softfloat &operator+=(const softfloat &a) {
+    *this = *this + a;
+    return *this;
+  }
+  softfloat &operator-=(const softfloat &a) {
+    *this = *this - a;
+    return *this;
+  }
+  softfloat &operator*=(const softfloat &a) {
+    *this = *this * a;
+    return *this;
+  }
+  softfloat &operator/=(const softfloat &a) {
+    *this = *this / a;
+    return *this;
+  }
+  softfloat &operator%=(const softfloat &a) {
+    *this = *this % a;
+    return *this;
+  }
+
+  /** @brief 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
+  */
+  bool operator==(const softfloat &) const;
+  bool operator!=(const softfloat &) const;
+  bool operator>(const softfloat &) const;
+  bool operator>=(const softfloat &) const;
+  bool operator<(const softfloat &) const;
+  bool operator<=(const softfloat &) const;
+
+  /** @brief NaN state indicator */
+  inline bool isNaN() const { return (v & 0x7fffffff) > 0x7f800000; }
+  /** @brief Inf state indicator */
+  inline bool isInf() const { return (v & 0x7fffffff) == 0x7f800000; }
+  /** @brief Subnormal number indicator */
+  inline bool isSubnormal() const { return ((v >> 23) & 0xFF) == 0; }
+
+  /** @brief Get sign bit */
+  inline bool getSign() const { return (v >> 31) != 0; }
+  /** @brief Construct a copy with new sign bit */
+  inline softfloat setSign(bool sign) const {
+    softfloat x;
+    x.v = (v & ((1U << 31) - 1)) | ((uint32_t)sign << 31);
+    return x;
+  }
+  /** @brief Get 0-based exponent */
+  inline int getExp() const { return ((v >> 23) & 0xFF) - 127; }
+  /** @brief Construct a copy with new 0-based exponent */
+  inline softfloat setExp(int e) const {
+    softfloat x;
+    x.v = (v & 0x807fffff) | (((e + 127) & 0xFF) << 23);
+    return x;
+  }
+
+  /** @brief Get a fraction part
+
+  Returns a number 1 <= x < 2 with the same significand
+  */
+  inline softfloat getFrac() const {
+    uint_fast32_t vv = (v & 0x007fffff) | (127 << 23);
+    return softfloat::fromRaw(vv);
+  }
+  /** @brief Construct a copy with provided significand
+
+  Constructs a copy of a number with significand taken from parameter
+  */
+  inline softfloat setFrac(const softfloat &s) const {
+    softfloat x;
+    x.v = (v & 0xff800000) | (s.v & 0x007fffff);
+    return x;
+  }
+
+  /** @brief Zero constant */
+  static softfloat zero() { return softfloat::fromRaw(0); }
+  /** @brief Positive infinity constant */
+  static softfloat inf() { return softfloat::fromRaw(0xFF << 23); }
+  /** @brief Default NaN constant */
+  static softfloat nan() { return softfloat::fromRaw(0x7fffffff); }
+  /** @brief One constant */
+  static softfloat one() { return softfloat::fromRaw(127 << 23); }
+  /** @brief Smallest normalized value */
+  static softfloat min() { return softfloat::fromRaw(0x01 << 23); }
+  /** @brief Difference between 1 and next representable value */
+  static softfloat eps() { return softfloat::fromRaw((127 - 23) << 23); }
+  /** @brief Biggest finite value */
+  static softfloat max() { return softfloat::fromRaw((0xFF << 23) - 1); }
+  /** @brief Correct pi approximation */
+  static softfloat pi() { return softfloat::fromRaw(0x40490fdb); }
+
+  uint32_t v;
+};
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+
+struct CV_EXPORTS softdouble {
+public:
+  /** @brief Default constructor */
+  softdouble() : v(0) {}
+  /** @brief Copy constructor */
+  softdouble(const softdouble &c) { v = c.v; }
+  /** @brief Assign constructor */
+  softdouble &operator=(const softdouble &c) {
+    if (&c != this)
+      v = c.v;
+    return *this;
+  }
+  /** @brief Construct from raw
+
+  Builds new value from raw binary representation
+  */
+  static softdouble fromRaw(const uint64_t a) {
+    softdouble x;
+    x.v = a;
+    return x;
+  }
+
+  /** @brief Construct from integer */
+  explicit softdouble(const uint32_t);
+  explicit softdouble(const uint64_t);
+  explicit softdouble(const int32_t);
+  explicit softdouble(const int64_t);
+
+#ifdef CV_INT32_T_IS_LONG_INT
+  // for platforms with int32_t = long int
+  explicit softdouble(const int a) {
+    *this = softdouble(static_cast<int32_t>(a));
+  }
+#endif
+
+  /** @brief Construct from double */
+  explicit softdouble(const double a) {
+    Cv64suf s;
+    s.f = a;
+    v = s.u;
+  }
+
+  /** @brief Type casts  */
+  operator softfloat() const;
+  operator double() const {
+    Cv64suf s;
+    s.u = v;
+    return s.f;
+  }
+
+  /** @brief Basic arithmetics */
+  softdouble operator+(const softdouble &) const;
+  softdouble operator-(const softdouble &) const;
+  softdouble operator*(const softdouble &) const;
+  softdouble operator/(const softdouble &) const;
+  softdouble operator-() const {
+    softdouble x;
+    x.v = v ^ (1ULL << 63);
+    return x;
+  }
+
+  /** @brief 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.
+  */
+  softdouble operator%(const softdouble &) const;
+
+  softdouble &operator+=(const softdouble &a) {
+    *this = *this + a;
+    return *this;
+  }
+  softdouble &operator-=(const softdouble &a) {
+    *this = *this - a;
+    return *this;
+  }
+  softdouble &operator*=(const softdouble &a) {
+    *this = *this * a;
+    return *this;
+  }
+  softdouble &operator/=(const softdouble &a) {
+    *this = *this / a;
+    return *this;
+  }
+  softdouble &operator%=(const softdouble &a) {
+    *this = *this % a;
+    return *this;
+  }
+
+  /** @brief 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
+  */
+  bool operator==(const softdouble &) const;
+  bool operator!=(const softdouble &) const;
+  bool operator>(const softdouble &) const;
+  bool operator>=(const softdouble &) const;
+  bool operator<(const softdouble &) const;
+  bool operator<=(const softdouble &) const;
+
+  /** @brief NaN state indicator */
+  inline bool isNaN() const {
+    return (v & 0x7fffffffffffffff) > 0x7ff0000000000000;
+  }
+  /** @brief Inf state indicator */
+  inline bool isInf() const {
+    return (v & 0x7fffffffffffffff) == 0x7ff0000000000000;
+  }
+  /** @brief Subnormal number indicator */
+  inline bool isSubnormal() const { return ((v >> 52) & 0x7FF) == 0; }
+
+  /** @brief Get sign bit */
+  inline bool getSign() const { return (v >> 63) != 0; }
+  /** @brief Construct a copy with new sign bit */
+  softdouble setSign(bool sign) const {
+    softdouble x;
+    x.v = (v & ((1ULL << 63) - 1)) | ((uint_fast64_t)(sign) << 63);
+    return x;
+  }
+  /** @brief Get 0-based exponent */
+  inline int getExp() const { return ((v >> 52) & 0x7FF) - 1023; }
+  /** @brief Construct a copy with new 0-based exponent */
+  inline softdouble setExp(int e) const {
+    softdouble x;
+    x.v =
+        (v & 0x800FFFFFFFFFFFFF) | ((uint_fast64_t)((e + 1023) & 0x7FF) << 52);
+    return x;
+  }
+
+  /** @brief Get a fraction part
+
+  Returns a number 1 <= x < 2 with the same significand
+  */
+  inline softdouble getFrac() const {
+    uint_fast64_t vv = (v & 0x000FFFFFFFFFFFFF) | ((uint_fast64_t)(1023) << 52);
+    return softdouble::fromRaw(vv);
+  }
+  /** @brief Construct a copy with provided significand
+
+  Constructs a copy of a number with significand taken from parameter
+  */
+  inline softdouble setFrac(const softdouble &s) const {
+    softdouble x;
+    x.v = (v & 0xFFF0000000000000) | (s.v & 0x000FFFFFFFFFFFFF);
+    return x;
+  }
+
+  /** @brief Zero constant */
+  static softdouble zero() { return softdouble::fromRaw(0); }
+  /** @brief Positive infinity constant */
+  static softdouble inf() {
+    return softdouble::fromRaw((uint_fast64_t)(0x7FF) << 52);
+  }
+  /** @brief Default NaN constant */
+  static softdouble nan() {
+    return softdouble::fromRaw(CV_BIG_INT(0x7FFFFFFFFFFFFFFF));
+  }
+  /** @brief One constant */
+  static softdouble one() {
+    return softdouble::fromRaw((uint_fast64_t)(1023) << 52);
+  }
+  /** @brief Smallest normalized value */
+  static softdouble min() {
+    return softdouble::fromRaw((uint_fast64_t)(0x01) << 52);
+  }
+  /** @brief Difference between 1 and next representable value */
+  static softdouble eps() {
+    return softdouble::fromRaw((uint_fast64_t)(1023 - 52) << 52);
+  }
+  /** @brief Biggest finite value */
+  static softdouble max() {
+    return softdouble::fromRaw(((uint_fast64_t)(0x7FF) << 52) - 1);
+  }
+  /** @brief Correct pi approximation */
+  static softdouble pi() {
+    return softdouble::fromRaw(CV_BIG_INT(0x400921FB54442D18));
+  }
+
+  uint64_t v;
+};
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+
+/** @brief Fused Multiplication and Addition
+
+Computes (a*b)+c with single rounding
+*/
+CV_EXPORTS softfloat mulAdd(const softfloat &a, const softfloat &b,
+                            const softfloat &c);
+CV_EXPORTS softdouble mulAdd(const softdouble &a, const softdouble &b,
+                             const softdouble &c);
+
+/** @brief Square root */
+CV_EXPORTS softfloat sqrt(const softfloat &a);
+CV_EXPORTS softdouble sqrt(const softdouble &a);
+} // namespace cv
+
+/*----------------------------------------------------------------------------
+| Ported from OpenCV and added for usability
+*----------------------------------------------------------------------------*/
+
+/** @brief Truncates number to integer with minimum magnitude */
+CV_EXPORTS int cvTrunc(const cv::softfloat &a);
+CV_EXPORTS int cvTrunc(const cv::softdouble &a);
+
+/** @brief Rounds a number to nearest even integer */
+CV_EXPORTS int cvRound(const cv::softfloat &a);
+CV_EXPORTS int cvRound(const cv::softdouble &a);
+
+/** @brief Rounds a number to nearest even long long integer */
+CV_EXPORTS int64_t cvRound64(const cv::softdouble &a);
+
+/** @brief Rounds a number down to integer */
+CV_EXPORTS int cvFloor(const cv::softfloat &a);
+CV_EXPORTS int cvFloor(const cv::softdouble &a);
+
+/** @brief Rounds number up to integer */
+CV_EXPORTS int cvCeil(const cv::softfloat &a);
+CV_EXPORTS int cvCeil(const cv::softdouble &a);
+
+namespace cv {
+/** @brief Saturate casts */
+template <typename _Tp> static inline _Tp saturate_cast(softfloat a) {
+  return _Tp(a);
+}
+template <typename _Tp> static inline _Tp saturate_cast(softdouble a) {
+  return _Tp(a);
+}
+
+template <> inline uchar saturate_cast<uchar>(softfloat a) {
+  return (uchar)std::max(std::min(cvRound(a), (int)UCHAR_MAX), 0);
+}
+template <> inline uchar saturate_cast<uchar>(softdouble a) {
+  return (uchar)std::max(std::min(cvRound(a), (int)UCHAR_MAX), 0);
+}
+
+template <> inline schar saturate_cast<schar>(softfloat a) {
+  return (schar)std::min(std::max(cvRound(a), (int)SCHAR_MIN), (int)SCHAR_MAX);
+}
+template <> inline schar saturate_cast<schar>(softdouble a) {
+  return (schar)std::min(std::max(cvRound(a), (int)SCHAR_MIN), (int)SCHAR_MAX);
+}
+
+template <> inline ushort saturate_cast<ushort>(softfloat a) {
+  return (ushort)std::max(std::min(cvRound(a), (int)USHRT_MAX), 0);
+}
+template <> inline ushort saturate_cast<ushort>(softdouble a) {
+  return (ushort)std::max(std::min(cvRound(a), (int)USHRT_MAX), 0);
+}
+
+template <> inline short saturate_cast<short>(softfloat a) {
+  return (short)std::min(std::max(cvRound(a), (int)SHRT_MIN), (int)SHRT_MAX);
+}
+template <> inline short saturate_cast<short>(softdouble a) {
+  return (short)std::min(std::max(cvRound(a), (int)SHRT_MIN), (int)SHRT_MAX);
+}
+
+template <> inline int saturate_cast<int>(softfloat a) { return cvRound(a); }
+template <> inline int saturate_cast<int>(softdouble a) { return cvRound(a); }
+
+template <> inline int64_t saturate_cast<int64_t>(softfloat a) {
+  return cvRound(a);
+}
+template <> inline int64_t saturate_cast<int64_t>(softdouble a) {
+  return cvRound64(a);
+}
+
+/** @brief Saturate cast to unsigned integer and unsigned long long integer
+We intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
+*/
+template <> inline unsigned saturate_cast<unsigned>(softfloat a) {
+  return cvRound(a);
+}
+template <> inline unsigned saturate_cast<unsigned>(softdouble a) {
+  return cvRound(a);
+}
+
+template <> inline uint64_t saturate_cast<uint64_t>(softfloat a) {
+  return cvRound(a);
+}
+template <> inline uint64_t saturate_cast<uint64_t>(softdouble a) {
+  return cvRound64(a);
+}
+
+/** @brief Min and Max functions */
+inline softfloat min(const softfloat &a, const softfloat &b) {
+  return (a > b) ? b : a;
+}
+inline softdouble min(const softdouble &a, const softdouble &b) {
+  return (a > b) ? b : a;
+}
+
+inline softfloat max(const softfloat &a, const softfloat &b) {
+  return (a > b) ? a : b;
+}
+inline softdouble max(const softdouble &a, const softdouble &b) {
+  return (a > b) ? a : b;
+}
+
+/** @brief Absolute value */
+inline softfloat abs(softfloat a) {
+  softfloat x;
+  x.v = a.v & ((1U << 31) - 1);
+  return x;
+}
+inline softdouble abs(softdouble a) {
+  softdouble x;
+  x.v = a.v & ((1ULL << 63) - 1);
+  return x;
+}
+
+/** @brief Exponent
+
+Special cases:
+- exp(NaN) is NaN
+- exp(-Inf) == 0
+- exp(+Inf) == +Inf
+*/
+CV_EXPORTS softfloat exp(const softfloat &a);
+CV_EXPORTS softdouble exp(const softdouble &a);
+
+/** @brief Natural logarithm
+
+Special cases:
+- log(NaN), log(x < 0) are NaN
+- log(0) == -Inf
+*/
+CV_EXPORTS softfloat log(const softfloat &a);
+CV_EXPORTS softdouble log(const softdouble &a);
+
+/** @brief 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
+*/
+CV_EXPORTS softfloat pow(const softfloat &a, const softfloat &b);
+CV_EXPORTS softdouble pow(const softdouble &a, const softdouble &b);
+
+/** @brief Cube root
+
+Special cases:
+- cbrt(NaN) is NaN
+- cbrt(+/-Inf) is +/-Inf
+*/
+CV_EXPORTS softfloat cbrt(const softfloat &a);
+
+/** @brief Sine
+
+Special cases:
+- sin(Inf) or sin(NaN) is NaN
+- sin(x) == x when sin(x) is close to zero
+*/
+CV_EXPORTS softdouble sin(const softdouble &a);
+
+/** @brief Cosine
+ *
+Special cases:
+- cos(Inf) or cos(NaN) is NaN
+- cos(x) == +/- 1 when cos(x) is close to +/- 1
+*/
+CV_EXPORTS softdouble cos(const softdouble &a);
+
+//! @} core_utils_softfloat
+
+} // namespace cv
+
+#endif