| /* |
| * erf function: Copyright (c) 2006 John Maddock |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| /** |
| * @file |
| * Replacements for frequently missing libm functions |
| */ |
| |
| #ifndef AVUTIL_LIBM_H |
| #define AVUTIL_LIBM_H |
| |
| #include <math.h> |
| #include "config.h" |
| #include "attributes.h" |
| #include "intfloat.h" |
| #include "mathematics.h" |
| |
| #if HAVE_MIPSFPU && HAVE_INLINE_ASM |
| #include "libavutil/mips/libm_mips.h" |
| #endif /* HAVE_MIPSFPU && HAVE_INLINE_ASM*/ |
| |
| #if !HAVE_ATANF |
| #undef atanf |
| #define atanf(x) ((float)atan(x)) |
| #endif /* HAVE_ATANF */ |
| |
| #if !HAVE_ATAN2F |
| #undef atan2f |
| #define atan2f(y, x) ((float)atan2(y, x)) |
| #endif /* HAVE_ATAN2F */ |
| |
| #if !HAVE_POWF |
| #undef powf |
| #define powf(x, y) ((float)pow(x, y)) |
| #endif /* HAVE_POWF */ |
| |
| #if !HAVE_CBRT |
| static av_always_inline double cbrt(double x) |
| { |
| return x < 0 ? -pow(-x, 1.0 / 3.0) : pow(x, 1.0 / 3.0); |
| } |
| #endif /* HAVE_CBRT */ |
| |
| #if !HAVE_CBRTF |
| static av_always_inline float cbrtf(float x) |
| { |
| return x < 0 ? -powf(-x, 1.0 / 3.0) : powf(x, 1.0 / 3.0); |
| } |
| #endif /* HAVE_CBRTF */ |
| |
| #if !HAVE_COPYSIGN |
| static av_always_inline double copysign(double x, double y) |
| { |
| uint64_t vx = av_double2int(x); |
| uint64_t vy = av_double2int(y); |
| return av_int2double((vx & UINT64_C(0x7fffffffffffffff)) | (vy & UINT64_C(0x8000000000000000))); |
| } |
| #endif /* HAVE_COPYSIGN */ |
| |
| #if !HAVE_COSF |
| #undef cosf |
| #define cosf(x) ((float)cos(x)) |
| #endif /* HAVE_COSF */ |
| |
| #if !HAVE_ERF |
| static inline double ff_eval_poly(const double *coeff, int size, double x) { |
| double sum = coeff[size-1]; |
| int i; |
| for (i = size-2; i >= 0; --i) { |
| sum *= x; |
| sum += coeff[i]; |
| } |
| return sum; |
| } |
| |
| /** |
| * erf function |
| * Algorithm taken from the Boost project, source: |
| * http://www.boost.org/doc/libs/1_46_1/boost/math/special_functions/erf.hpp |
| * Use, modification and distribution are subject to the |
| * Boost Software License, Version 1.0 (see notice below). |
| * Boost Software License - Version 1.0 - August 17th, 2003 |
| Permission is hereby granted, free of charge, to any person or organization |
| obtaining a copy of the software and accompanying documentation covered by |
| this license (the "Software") to use, reproduce, display, distribute, |
| execute, and transmit the Software, and to prepare derivative works of the |
| Software, and to permit third-parties to whom the Software is furnished to |
| do so, all subject to the following: |
| |
| The copyright notices in the Software and this entire statement, including |
| the above license grant, this restriction and the following disclaimer, |
| must be included in all copies of the Software, in whole or in part, and |
| all derivative works of the Software, unless such copies or derivative |
| works are solely in the form of machine-executable object code generated by |
| a source language processor. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT |
| SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE |
| FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, |
| ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| DEALINGS IN THE SOFTWARE. |
| */ |
| static inline double erf(double z) |
| { |
| #ifndef FF_ARRAY_ELEMS |
| #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) |
| #endif |
| double result; |
| |
| /* handle the symmetry: erf(-x) = -erf(x) */ |
| if (z < 0) |
| return -erf(-z); |
| |
| /* branch based on range of z, and pick appropriate approximation */ |
| if (z == 0) |
| return 0; |
| else if (z < 1e-10) |
| return z * 1.125 + z * 0.003379167095512573896158903121545171688; |
| else if (z < 0.5) { |
| // Maximum Deviation Found: 1.561e-17 |
| // Expected Error Term: 1.561e-17 |
| // Maximum Relative Change in Control Points: 1.155e-04 |
| // Max Error found at double precision = 2.961182e-17 |
| |
| static const double y = 1.044948577880859375; |
| static const double p[] = { |
| 0.0834305892146531832907, |
| -0.338165134459360935041, |
| -0.0509990735146777432841, |
| -0.00772758345802133288487, |
| -0.000322780120964605683831, |
| }; |
| static const double q[] = { |
| 1, |
| 0.455004033050794024546, |
| 0.0875222600142252549554, |
| 0.00858571925074406212772, |
| 0.000370900071787748000569, |
| }; |
| double zz = z * z; |
| return z * (y + ff_eval_poly(p, FF_ARRAY_ELEMS(p), zz) / ff_eval_poly(q, FF_ARRAY_ELEMS(q), zz)); |
| } |
| /* here onwards compute erfc */ |
| else if (z < 1.5) { |
| // Maximum Deviation Found: 3.702e-17 |
| // Expected Error Term: 3.702e-17 |
| // Maximum Relative Change in Control Points: 2.845e-04 |
| // Max Error found at double precision = 4.841816e-17 |
| static const double y = 0.405935764312744140625; |
| static const double p[] = { |
| -0.098090592216281240205, |
| 0.178114665841120341155, |
| 0.191003695796775433986, |
| 0.0888900368967884466578, |
| 0.0195049001251218801359, |
| 0.00180424538297014223957, |
| }; |
| static const double q[] = { |
| 1, |
| 1.84759070983002217845, |
| 1.42628004845511324508, |
| 0.578052804889902404909, |
| 0.12385097467900864233, |
| 0.0113385233577001411017, |
| 0.337511472483094676155e-5, |
| }; |
| result = y + ff_eval_poly(p, FF_ARRAY_ELEMS(p), z - 0.5) / ff_eval_poly(q, FF_ARRAY_ELEMS(q), z - 0.5); |
| result *= exp(-z * z) / z; |
| return 1 - result; |
| } |
| else if (z < 2.5) { |
| // Max Error found at double precision = 6.599585e-18 |
| // Maximum Deviation Found: 3.909e-18 |
| // Expected Error Term: 3.909e-18 |
| // Maximum Relative Change in Control Points: 9.886e-05 |
| static const double y = 0.50672817230224609375; |
| static const double p[] = { |
| -0.0243500476207698441272, |
| 0.0386540375035707201728, |
| 0.04394818964209516296, |
| 0.0175679436311802092299, |
| 0.00323962406290842133584, |
| 0.000235839115596880717416, |
| }; |
| static const double q[] = { |
| 1, |
| 1.53991494948552447182, |
| 0.982403709157920235114, |
| 0.325732924782444448493, |
| 0.0563921837420478160373, |
| 0.00410369723978904575884, |
| }; |
| result = y + ff_eval_poly(p, FF_ARRAY_ELEMS(p), z - 1.5) / ff_eval_poly(q, FF_ARRAY_ELEMS(q), z - 1.5); |
| result *= exp(-z * z) / z; |
| return 1 - result; |
| } |
| else if (z < 4.5) { |
| // Maximum Deviation Found: 1.512e-17 |
| // Expected Error Term: 1.512e-17 |
| // Maximum Relative Change in Control Points: 2.222e-04 |
| // Max Error found at double precision = 2.062515e-17 |
| static const double y = 0.5405750274658203125; |
| static const double p[] = { |
| 0.00295276716530971662634, |
| 0.0137384425896355332126, |
| 0.00840807615555585383007, |
| 0.00212825620914618649141, |
| 0.000250269961544794627958, |
| 0.113212406648847561139e-4, |
| }; |
| static const double q[] = { |
| 1, |
| 1.04217814166938418171, |
| 0.442597659481563127003, |
| 0.0958492726301061423444, |
| 0.0105982906484876531489, |
| 0.000479411269521714493907, |
| }; |
| result = y + ff_eval_poly(p, FF_ARRAY_ELEMS(p), z - 3.5) / ff_eval_poly(q, FF_ARRAY_ELEMS(q), z - 3.5); |
| result *= exp(-z * z) / z; |
| return 1 - result; |
| } |
| /* differ from Boost here, the claim of underflow of erfc(x) past 5.8 is |
| * slightly incorrect, change to 5.92 |
| * (really somewhere between 5.9125 and 5.925 is when it saturates) */ |
| else if (z < 5.92) { |
| // Max Error found at double precision = 2.997958e-17 |
| // Maximum Deviation Found: 2.860e-17 |
| // Expected Error Term: 2.859e-17 |
| // Maximum Relative Change in Control Points: 1.357e-05 |
| static const double y = 0.5579090118408203125; |
| static const double p[] = { |
| 0.00628057170626964891937, |
| 0.0175389834052493308818, |
| -0.212652252872804219852, |
| -0.687717681153649930619, |
| -2.5518551727311523996, |
| -3.22729451764143718517, |
| -2.8175401114513378771, |
| }; |
| static const double q[] = { |
| 1, |
| 2.79257750980575282228, |
| 11.0567237927800161565, |
| 15.930646027911794143, |
| 22.9367376522880577224, |
| 13.5064170191802889145, |
| 5.48409182238641741584, |
| }; |
| result = y + ff_eval_poly(p, FF_ARRAY_ELEMS(p), 1 / z) / ff_eval_poly(q, FF_ARRAY_ELEMS(q), 1 / z); |
| result *= exp(-z * z) / z; |
| return 1 - result; |
| } |
| /* handle the nan case, but don't use isnan for max portability */ |
| else if (z != z) |
| return z; |
| /* finally return saturated result */ |
| else |
| return 1; |
| } |
| #endif /* HAVE_ERF */ |
| |
| #if !HAVE_EXPF |
| #undef expf |
| #define expf(x) ((float)exp(x)) |
| #endif /* HAVE_EXPF */ |
| |
| #if !HAVE_EXP2 |
| #undef exp2 |
| #define exp2(x) exp((x) * M_LN2) |
| #endif /* HAVE_EXP2 */ |
| |
| #if !HAVE_EXP2F |
| #undef exp2f |
| #define exp2f(x) ((float)exp2(x)) |
| #endif /* HAVE_EXP2F */ |
| |
| #if !HAVE_ISINF |
| #undef isinf |
| /* Note: these do not follow the BSD/Apple/GNU convention of returning -1 for |
| -Inf, +1 for Inf, 0 otherwise, but merely follow the POSIX/ISO mandated spec of |
| returning a non-zero value for +/-Inf, 0 otherwise. */ |
| static av_always_inline av_const int avpriv_isinff(float x) |
| { |
| uint32_t v = av_float2int(x); |
| if ((v & 0x7f800000) != 0x7f800000) |
| return 0; |
| return !(v & 0x007fffff); |
| } |
| |
| static av_always_inline av_const int avpriv_isinf(double x) |
| { |
| uint64_t v = av_double2int(x); |
| if ((v & 0x7ff0000000000000) != 0x7ff0000000000000) |
| return 0; |
| return !(v & 0x000fffffffffffff); |
| } |
| |
| #define isinf(x) \ |
| (sizeof(x) == sizeof(float) \ |
| ? avpriv_isinff(x) \ |
| : avpriv_isinf(x)) |
| #endif /* HAVE_ISINF */ |
| |
| #if !HAVE_ISNAN |
| static av_always_inline av_const int avpriv_isnanf(float x) |
| { |
| uint32_t v = av_float2int(x); |
| if ((v & 0x7f800000) != 0x7f800000) |
| return 0; |
| return v & 0x007fffff; |
| } |
| |
| static av_always_inline av_const int avpriv_isnan(double x) |
| { |
| uint64_t v = av_double2int(x); |
| if ((v & 0x7ff0000000000000) != 0x7ff0000000000000) |
| return 0; |
| return (v & 0x000fffffffffffff) && 1; |
| } |
| |
| #define isnan(x) \ |
| (sizeof(x) == sizeof(float) \ |
| ? avpriv_isnanf(x) \ |
| : avpriv_isnan(x)) |
| #endif /* HAVE_ISNAN */ |
| |
| #if !HAVE_ISFINITE |
| static av_always_inline av_const int avpriv_isfinitef(float x) |
| { |
| uint32_t v = av_float2int(x); |
| return (v & 0x7f800000) != 0x7f800000; |
| } |
| |
| static av_always_inline av_const int avpriv_isfinite(double x) |
| { |
| uint64_t v = av_double2int(x); |
| return (v & 0x7ff0000000000000) != 0x7ff0000000000000; |
| } |
| |
| #define isfinite(x) \ |
| (sizeof(x) == sizeof(float) \ |
| ? avpriv_isfinitef(x) \ |
| : avpriv_isfinite(x)) |
| #endif /* HAVE_ISFINITE */ |
| |
| #if !HAVE_HYPOT |
| static inline av_const double hypot(double x, double y) |
| { |
| double ret, temp; |
| x = fabs(x); |
| y = fabs(y); |
| |
| if (isinf(x) || isinf(y)) |
| return av_int2double(0x7ff0000000000000); |
| if (x == 0 || y == 0) |
| return x + y; |
| if (x < y) { |
| temp = x; |
| x = y; |
| y = temp; |
| } |
| |
| y = y/x; |
| return x*sqrt(1 + y*y); |
| } |
| #endif /* HAVE_HYPOT */ |
| |
| #if !HAVE_LDEXPF |
| #undef ldexpf |
| #define ldexpf(x, exp) ((float)ldexp(x, exp)) |
| #endif /* HAVE_LDEXPF */ |
| |
| #if !HAVE_LLRINT |
| #undef llrint |
| #define llrint(x) ((long long)rint(x)) |
| #endif /* HAVE_LLRINT */ |
| |
| #if !HAVE_LLRINTF |
| #undef llrintf |
| #define llrintf(x) ((long long)rint(x)) |
| #endif /* HAVE_LLRINT */ |
| |
| #if !HAVE_LOG2 |
| #undef log2 |
| #define log2(x) (log(x) * 1.44269504088896340736) |
| #endif /* HAVE_LOG2 */ |
| |
| #if !HAVE_LOG2F |
| #undef log2f |
| #define log2f(x) ((float)log2(x)) |
| #endif /* HAVE_LOG2F */ |
| |
| #if !HAVE_LOG10F |
| #undef log10f |
| #define log10f(x) ((float)log10(x)) |
| #endif /* HAVE_LOG10F */ |
| |
| #if !HAVE_SINF |
| #undef sinf |
| #define sinf(x) ((float)sin(x)) |
| #endif /* HAVE_SINF */ |
| |
| #if !HAVE_RINT |
| static inline double rint(double x) |
| { |
| return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); |
| } |
| #endif /* HAVE_RINT */ |
| |
| #if !HAVE_LRINT |
| static av_always_inline av_const long int lrint(double x) |
| { |
| return rint(x); |
| } |
| #endif /* HAVE_LRINT */ |
| |
| #if !HAVE_LRINTF |
| static av_always_inline av_const long int lrintf(float x) |
| { |
| return (int)(rint(x)); |
| } |
| #endif /* HAVE_LRINTF */ |
| |
| #if !HAVE_ROUND |
| static av_always_inline av_const double round(double x) |
| { |
| return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5); |
| } |
| #endif /* HAVE_ROUND */ |
| |
| #if !HAVE_ROUNDF |
| static av_always_inline av_const float roundf(float x) |
| { |
| return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5); |
| } |
| #endif /* HAVE_ROUNDF */ |
| |
| #if !HAVE_TRUNC |
| static av_always_inline av_const double trunc(double x) |
| { |
| return (x > 0) ? floor(x) : ceil(x); |
| } |
| #endif /* HAVE_TRUNC */ |
| |
| #if !HAVE_TRUNCF |
| static av_always_inline av_const float truncf(float x) |
| { |
| return (x > 0) ? floor(x) : ceil(x); |
| } |
| #endif /* HAVE_TRUNCF */ |
| |
| #endif /* AVUTIL_LIBM_H */ |
