SkFloatingPoint.h 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260
  1. /*
  2. * Copyright 2006 The Android Open Source Project
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #ifndef SkFloatingPoint_DEFINED
  8. #define SkFloatingPoint_DEFINED
  9. #include "include/core/SkTypes.h"
  10. #include "include/private/SkFloatBits.h"
  11. #include "include/private/SkSafe_math.h"
  12. #include <float.h>
  13. #include <math.h>
  14. #include <cmath>
  15. #include <cstring>
  16. #include <limits>
  17. #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
  18. #include <xmmintrin.h>
  19. #elif defined(SK_ARM_HAS_NEON)
  20. #include <arm_neon.h>
  21. #endif
  22. // For _POSIX_VERSION
  23. #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
  24. #include <unistd.h>
  25. #endif
  26. constexpr float SK_FloatSqrt2 = 1.41421356f;
  27. constexpr float SK_FloatPI = 3.14159265f;
  28. // C++98 cmath std::pow seems to be the earliest portable way to get float pow.
  29. // However, on Linux including cmath undefines isfinite.
  30. // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14608
  31. static inline float sk_float_pow(float base, float exp) {
  32. return powf(base, exp);
  33. }
  34. #define sk_float_sqrt(x) sqrtf(x)
  35. #define sk_float_sin(x) sinf(x)
  36. #define sk_float_cos(x) cosf(x)
  37. #define sk_float_tan(x) tanf(x)
  38. #define sk_float_floor(x) floorf(x)
  39. #define sk_float_ceil(x) ceilf(x)
  40. #define sk_float_trunc(x) truncf(x)
  41. #ifdef SK_BUILD_FOR_MAC
  42. # define sk_float_acos(x) static_cast<float>(acos(x))
  43. # define sk_float_asin(x) static_cast<float>(asin(x))
  44. #else
  45. # define sk_float_acos(x) acosf(x)
  46. # define sk_float_asin(x) asinf(x)
  47. #endif
  48. #define sk_float_atan2(y,x) atan2f(y,x)
  49. #define sk_float_abs(x) fabsf(x)
  50. #define sk_float_copysign(x, y) copysignf(x, y)
  51. #define sk_float_mod(x,y) fmodf(x,y)
  52. #define sk_float_exp(x) expf(x)
  53. #define sk_float_log(x) logf(x)
  54. constexpr float sk_float_degrees_to_radians(float degrees) {
  55. return degrees * (SK_FloatPI / 180);
  56. }
  57. constexpr float sk_float_radians_to_degrees(float radians) {
  58. return radians * (180 / SK_FloatPI);
  59. }
  60. #define sk_float_round(x) sk_float_floor((x) + 0.5f)
  61. // can't find log2f on android, but maybe that just a tool bug?
  62. #ifdef SK_BUILD_FOR_ANDROID
  63. static inline float sk_float_log2(float x) {
  64. const double inv_ln_2 = 1.44269504088896;
  65. return (float)(log(x) * inv_ln_2);
  66. }
  67. #else
  68. #define sk_float_log2(x) log2f(x)
  69. #endif
  70. static inline bool sk_float_isfinite(float x) {
  71. return SkFloatBits_IsFinite(SkFloat2Bits(x));
  72. }
  73. static inline bool sk_floats_are_finite(float a, float b) {
  74. return sk_float_isfinite(a) && sk_float_isfinite(b);
  75. }
  76. static inline bool sk_floats_are_finite(const float array[], int count) {
  77. float prod = 0;
  78. for (int i = 0; i < count; ++i) {
  79. prod *= array[i];
  80. }
  81. // At this point, prod will either be NaN or 0
  82. return prod == 0; // if prod is NaN, this check will return false
  83. }
  84. static inline bool sk_float_isinf(float x) {
  85. return SkFloatBits_IsInf(SkFloat2Bits(x));
  86. }
  87. static inline bool sk_float_isnan(float x) {
  88. return !(x == x);
  89. }
  90. #define sk_double_isnan(a) sk_float_isnan(a)
  91. #define SK_MaxS32FitsInFloat 2147483520
  92. #define SK_MinS32FitsInFloat -SK_MaxS32FitsInFloat
  93. #define SK_MaxS64FitsInFloat (SK_MaxS64 >> (63-24) << (63-24)) // 0x7fffff8000000000
  94. #define SK_MinS64FitsInFloat -SK_MaxS64FitsInFloat
  95. /**
  96. * Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.
  97. */
  98. static inline int sk_float_saturate2int(float x) {
  99. x = SkTMin<float>(x, SK_MaxS32FitsInFloat);
  100. x = SkTMax<float>(x, SK_MinS32FitsInFloat);
  101. return (int)x;
  102. }
  103. /**
  104. * Return the closest int for the given double. Returns SK_MaxS32 for NaN.
  105. */
  106. static inline int sk_double_saturate2int(double x) {
  107. x = SkTMin<double>(x, SK_MaxS32);
  108. x = SkTMax<double>(x, SK_MinS32);
  109. return (int)x;
  110. }
  111. /**
  112. * Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.
  113. */
  114. static inline int64_t sk_float_saturate2int64(float x) {
  115. x = SkTMin<float>(x, SK_MaxS64FitsInFloat);
  116. x = SkTMax<float>(x, SK_MinS64FitsInFloat);
  117. return (int64_t)x;
  118. }
  119. #define sk_float_floor2int(x) sk_float_saturate2int(sk_float_floor(x))
  120. #define sk_float_round2int(x) sk_float_saturate2int(sk_float_floor((x) + 0.5f))
  121. #define sk_float_ceil2int(x) sk_float_saturate2int(sk_float_ceil(x))
  122. #define sk_float_floor2int_no_saturate(x) (int)sk_float_floor(x)
  123. #define sk_float_round2int_no_saturate(x) (int)sk_float_floor((x) + 0.5f)
  124. #define sk_float_ceil2int_no_saturate(x) (int)sk_float_ceil(x)
  125. #define sk_double_floor(x) floor(x)
  126. #define sk_double_round(x) floor((x) + 0.5)
  127. #define sk_double_ceil(x) ceil(x)
  128. #define sk_double_floor2int(x) (int)floor(x)
  129. #define sk_double_round2int(x) (int)floor((x) + 0.5)
  130. #define sk_double_ceil2int(x) (int)ceil(x)
  131. // Cast double to float, ignoring any warning about too-large finite values being cast to float.
  132. // Clang thinks this is undefined, but it's actually implementation defined to return either
  133. // the largest float or infinity (one of the two bracketing representable floats). Good enough!
  134. #if defined(__clang__) && (__clang_major__ * 1000 + __clang_minor__) >= 3007
  135. __attribute__((no_sanitize("float-cast-overflow")))
  136. #endif
  137. static inline float sk_double_to_float(double x) {
  138. return static_cast<float>(x);
  139. }
  140. #define SK_FloatNaN std::numeric_limits<float>::quiet_NaN()
  141. #define SK_FloatInfinity (+std::numeric_limits<float>::infinity())
  142. #define SK_FloatNegativeInfinity (-std::numeric_limits<float>::infinity())
  143. #define SK_DoubleNaN std::numeric_limits<double>::quiet_NaN()
  144. // Returns false if any of the floats are outside of [0...1]
  145. // Returns true if count is 0
  146. bool sk_floats_are_unit(const float array[], size_t count);
  147. static inline float sk_float_rsqrt_portable(float x) {
  148. // Get initial estimate.
  149. int i;
  150. memcpy(&i, &x, 4);
  151. i = 0x5F1FFFF9 - (i>>1);
  152. float estimate;
  153. memcpy(&estimate, &i, 4);
  154. // One step of Newton's method to refine.
  155. const float estimate_sq = estimate*estimate;
  156. estimate *= 0.703952253f*(2.38924456f-x*estimate_sq);
  157. return estimate;
  158. }
  159. // Fast, approximate inverse square root.
  160. // Compare to name-brand "1.0f / sk_float_sqrt(x)". Should be around 10x faster on SSE, 2x on NEON.
  161. static inline float sk_float_rsqrt(float x) {
  162. // We want all this inlined, so we'll inline SIMD and just take the hit when we don't know we've got
  163. // it at compile time. This is going to be too fast to productively hide behind a function pointer.
  164. //
  165. // We do one step of Newton's method to refine the estimates in the NEON and portable paths. No
  166. // refinement is faster, but very innacurate. Two steps is more accurate, but slower than 1/sqrt.
  167. //
  168. // Optimized constants in the portable path courtesy of http://rrrola.wz.cz/inv_sqrt.html
  169. #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
  170. return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x)));
  171. #elif defined(SK_ARM_HAS_NEON)
  172. // Get initial estimate.
  173. const float32x2_t xx = vdup_n_f32(x); // Clever readers will note we're doing everything 2x.
  174. float32x2_t estimate = vrsqrte_f32(xx);
  175. // One step of Newton's method to refine.
  176. const float32x2_t estimate_sq = vmul_f32(estimate, estimate);
  177. estimate = vmul_f32(estimate, vrsqrts_f32(xx, estimate_sq));
  178. return vget_lane_f32(estimate, 0); // 1 will work fine too; the answer's in both places.
  179. #else
  180. return sk_float_rsqrt_portable(x);
  181. #endif
  182. }
  183. // This is the number of significant digits we can print in a string such that when we read that
  184. // string back we get the floating point number we expect. The minimum value C requires is 6, but
  185. // most compilers support 9
  186. #ifdef FLT_DECIMAL_DIG
  187. #define SK_FLT_DECIMAL_DIG FLT_DECIMAL_DIG
  188. #else
  189. #define SK_FLT_DECIMAL_DIG 9
  190. #endif
  191. // IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not
  192. // so we have a helper that suppresses the possible undefined-behavior warnings.
  193. #ifdef __clang__
  194. __attribute__((no_sanitize("float-divide-by-zero")))
  195. #endif
  196. static inline float sk_ieee_float_divide(float numer, float denom) {
  197. return numer / denom;
  198. }
  199. #ifdef __clang__
  200. __attribute__((no_sanitize("float-divide-by-zero")))
  201. #endif
  202. static inline double sk_ieee_double_divide(double numer, double denom) {
  203. return numer / denom;
  204. }
  205. // While we clean up divide by zero, we'll replace places that do divide by zero with this TODO.
  206. static inline float sk_ieee_float_divide_TODO_IS_DIVIDE_BY_ZERO_SAFE_HERE(float n, float d) {
  207. return sk_ieee_float_divide(n,d);
  208. }
  209. static inline float sk_ieee_double_divide_TODO_IS_DIVIDE_BY_ZERO_SAFE_HERE(double n, double d) {
  210. return sk_ieee_double_divide(n,d);
  211. }
  212. static inline float sk_fmaf(float f, float m, float a) {
  213. #if defined(FP_FAST_FMA)
  214. return std::fmaf(f,m,a);
  215. #else
  216. return f*m+a;
  217. #endif
  218. }
  219. #endif