diff options
Diffstat (limited to 'Source/JavaScriptCore/wtf/MathExtras.h')
| -rw-r--r-- | Source/JavaScriptCore/wtf/MathExtras.h | 331 |
1 files changed, 0 insertions, 331 deletions
diff --git a/Source/JavaScriptCore/wtf/MathExtras.h b/Source/JavaScriptCore/wtf/MathExtras.h deleted file mode 100644 index e8ebd6ba1..000000000 --- a/Source/JavaScriptCore/wtf/MathExtras.h +++ /dev/null @@ -1,331 +0,0 @@ -/* - * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. 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. - * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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. - */ - -#ifndef WTF_MathExtras_h -#define WTF_MathExtras_h - -#include <algorithm> -#include <cmath> -#include <float.h> -#include <limits> -#include <stdint.h> -#include <stdlib.h> -#include <wtf/StdLibExtras.h> - -#if OS(SOLARIS) -#include <ieeefp.h> -#endif - -#if OS(OPENBSD) -#include <sys/types.h> -#include <machine/ieee.h> -#endif - -#if COMPILER(MSVC) -#if OS(WINCE) -#include <stdlib.h> -#endif -#include <limits> -#endif - -#if OS(QNX) -// FIXME: Look into a way to have cmath import its functions into both the standard and global -// namespace. For now, we include math.h since the QNX cmath header only imports its functions -// into the standard namespace. -#include <math.h> -#endif - -#ifndef M_PI -const double piDouble = 3.14159265358979323846; -const float piFloat = 3.14159265358979323846f; -#else -const double piDouble = M_PI; -const float piFloat = static_cast<float>(M_PI); -#endif - -#ifndef M_PI_2 -const double piOverTwoDouble = 1.57079632679489661923; -const float piOverTwoFloat = 1.57079632679489661923f; -#else -const double piOverTwoDouble = M_PI_2; -const float piOverTwoFloat = static_cast<float>(M_PI_2); -#endif - -#ifndef M_PI_4 -const double piOverFourDouble = 0.785398163397448309616; -const float piOverFourFloat = 0.785398163397448309616f; -#else -const double piOverFourDouble = M_PI_4; -const float piOverFourFloat = static_cast<float>(M_PI_4); -#endif - -#if OS(DARWIN) - -// Work around a bug in the Mac OS X libc where ceil(-0.1) return +0. -inline double wtf_ceil(double x) { return copysign(ceil(x), x); } - -#define ceil(x) wtf_ceil(x) - -#endif - -#if OS(SOLARIS) - -#ifndef isfinite -inline bool isfinite(double x) { return finite(x) && !isnand(x); } -#endif -#ifndef isinf -inline bool isinf(double x) { return !finite(x) && !isnand(x); } -#endif -#ifndef signbit -inline bool signbit(double x) { return copysign(1.0, x) < 0; } -#endif - -#endif - -#if OS(OPENBSD) - -#ifndef isfinite -inline bool isfinite(double x) { return finite(x); } -#endif -#ifndef signbit -inline bool signbit(double x) { struct ieee_double *p = (struct ieee_double *)&x; return p->dbl_sign; } -#endif - -#endif - -#if COMPILER(MSVC) || (COMPILER(RVCT) && !(RVCT_VERSION_AT_LEAST(3, 0, 0, 0))) - -// We must not do 'num + 0.5' or 'num - 0.5' because they can cause precision loss. -static double round(double num) -{ - double integer = ceil(num); - if (num > 0) - return integer - num > 0.5 ? integer - 1.0 : integer; - return integer - num >= 0.5 ? integer - 1.0 : integer; -} -static float roundf(float num) -{ - float integer = ceilf(num); - if (num > 0) - return integer - num > 0.5f ? integer - 1.0f : integer; - return integer - num >= 0.5f ? integer - 1.0f : integer; -} -inline long long llround(double num) { return static_cast<long long>(round(num)); } -inline long long llroundf(float num) { return static_cast<long long>(roundf(num)); } -inline long lround(double num) { return static_cast<long>(round(num)); } -inline long lroundf(float num) { return static_cast<long>(roundf(num)); } -inline double trunc(double num) { return num > 0 ? floor(num) : ceil(num); } - -#endif - -#if COMPILER(GCC) && OS(QNX) -// The stdlib on QNX doesn't contain long abs(long). See PR #104666. -inline long long abs(long num) { return labs(num); } -#endif - -#if COMPILER(MSVC) -// The 64bit version of abs() is already defined in stdlib.h which comes with VC10 -#if COMPILER(MSVC9_OR_LOWER) -inline long long abs(long long num) { return _abs64(num); } -#endif - -inline bool isinf(double num) { return !_finite(num) && !_isnan(num); } -inline bool isnan(double num) { return !!_isnan(num); } -inline bool signbit(double num) { return _copysign(1.0, num) < 0; } - -inline double nextafter(double x, double y) { return _nextafter(x, y); } -inline float nextafterf(float x, float y) { return x > y ? x - FLT_EPSILON : x + FLT_EPSILON; } - -inline double copysign(double x, double y) { return _copysign(x, y); } -inline int isfinite(double x) { return _finite(x); } - -// MSVC's math.h does not currently supply log2 or log2f. -inline double log2(double num) -{ - // This constant is roughly M_LN2, which is not provided by default on Windows. - return log(num) / 0.693147180559945309417232121458176568; -} - -inline float log2f(float num) -{ - // This constant is roughly M_LN2, which is not provided by default on Windows. - return logf(num) / 0.693147180559945309417232121458176568f; -} - -// Work around a bug in Win, where atan2(+-infinity, +-infinity) yields NaN instead of specific values. -inline double wtf_atan2(double x, double y) -{ - double posInf = std::numeric_limits<double>::infinity(); - double negInf = -std::numeric_limits<double>::infinity(); - double nan = std::numeric_limits<double>::quiet_NaN(); - - double result = nan; - - if (x == posInf && y == posInf) - result = piOverFourDouble; - else if (x == posInf && y == negInf) - result = 3 * piOverFourDouble; - else if (x == negInf && y == posInf) - result = -piOverFourDouble; - else if (x == negInf && y == negInf) - result = -3 * piOverFourDouble; - else - result = ::atan2(x, y); - - return result; -} - -// Work around a bug in the Microsoft CRT, where fmod(x, +-infinity) yields NaN instead of x. -inline double wtf_fmod(double x, double y) { return (!isinf(x) && isinf(y)) ? x : fmod(x, y); } - -// Work around a bug in the Microsoft CRT, where pow(NaN, 0) yields NaN instead of 1. -inline double wtf_pow(double x, double y) { return y == 0 ? 1 : pow(x, y); } - -#define atan2(x, y) wtf_atan2(x, y) -#define fmod(x, y) wtf_fmod(x, y) -#define pow(x, y) wtf_pow(x, y) - -#endif // COMPILER(MSVC) - -inline double deg2rad(double d) { return d * piDouble / 180.0; } -inline double rad2deg(double r) { return r * 180.0 / piDouble; } -inline double deg2grad(double d) { return d * 400.0 / 360.0; } -inline double grad2deg(double g) { return g * 360.0 / 400.0; } -inline double turn2deg(double t) { return t * 360.0; } -inline double deg2turn(double d) { return d / 360.0; } -inline double rad2grad(double r) { return r * 200.0 / piDouble; } -inline double grad2rad(double g) { return g * piDouble / 200.0; } - -inline float deg2rad(float d) { return d * piFloat / 180.0f; } -inline float rad2deg(float r) { return r * 180.0f / piFloat; } -inline float deg2grad(float d) { return d * 400.0f / 360.0f; } -inline float grad2deg(float g) { return g * 360.0f / 400.0f; } -inline float turn2deg(float t) { return t * 360.0f; } -inline float deg2turn(float d) { return d / 360.0f; } -inline float rad2grad(float r) { return r * 200.0f / piFloat; } -inline float grad2rad(float g) { return g * piFloat / 200.0f; } - -// std::numeric_limits<T>::min() returns the smallest positive value for floating point types -template<typename T> inline T defaultMinimumForClamp() { return std::numeric_limits<T>::min(); } -template<> inline float defaultMinimumForClamp() { return -std::numeric_limits<float>::max(); } -template<> inline double defaultMinimumForClamp() { return -std::numeric_limits<double>::max(); } -template<typename T> inline T defaultMaximumForClamp() { return std::numeric_limits<T>::max(); } - -template<typename T> inline T clampTo(double value, T min = defaultMinimumForClamp<T>(), T max = defaultMaximumForClamp<T>()) -{ - if (value >= static_cast<double>(max)) - return max; - if (value <= static_cast<double>(min)) - return min; - return static_cast<T>(value); -} -template<> inline long long int clampTo(double, long long int, long long int); // clampTo does not support long long ints. - -inline int clampToInteger(double value) -{ - return clampTo<int>(value); -} - -inline float clampToFloat(double value) -{ - return clampTo<float>(value); -} - -inline int clampToPositiveInteger(double value) -{ - return clampTo<int>(value, 0); -} - -inline int clampToInteger(float value) -{ - return clampTo<int>(value); -} - -inline int clampToInteger(unsigned x) -{ - const unsigned intMax = static_cast<unsigned>(std::numeric_limits<int>::max()); - - if (x >= intMax) - return std::numeric_limits<int>::max(); - return static_cast<int>(x); -} - -inline bool isWithinIntRange(float x) -{ - return x > static_cast<float>(std::numeric_limits<int>::min()) && x < static_cast<float>(std::numeric_limits<int>::max()); -} - -#if !COMPILER(MSVC) && !COMPILER(RVCT) && !OS(SOLARIS) -using std::isfinite; -using std::isinf; -using std::isnan; -using std::signbit; -#endif - -// decompose 'number' to its sign, exponent, and mantissa components. -// The result is interpreted as: -// (sign ? -1 : 1) * pow(2, exponent) * (mantissa / (1 << 52)) -inline void decomposeDouble(double number, bool& sign, int32_t& exponent, uint64_t& mantissa) -{ - ASSERT(isfinite(number)); - - sign = signbit(number); - - uint64_t bits = WTF::bitwise_cast<uint64_t>(number); - exponent = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff; - mantissa = bits & 0xFFFFFFFFFFFFFull; - - // Check for zero/denormal values; if so, adjust the exponent, - // if not insert the implicit, omitted leading 1 bit. - if (exponent == -0x3ff) - exponent = mantissa ? -0x3fe : 0; - else - mantissa |= 0x10000000000000ull; -} - -// Calculate d % 2^{64}. -inline void doubleToInteger(double d, unsigned long long& value) -{ - if (isnan(d) || isinf(d)) - value = 0; - else { - // -2^{64} < fmodValue < 2^{64}. - double fmodValue = fmod(trunc(d), std::numeric_limits<unsigned long long>::max() + 1.0); - if (fmodValue >= 0) { - // 0 <= fmodValue < 2^{64}. - // 0 <= value < 2^{64}. This cast causes no loss. - value = static_cast<unsigned long long>(fmodValue); - } else { - // -2^{64} < fmodValue < 0. - // 0 < fmodValueInUnsignedLongLong < 2^{64}. This cast causes no loss. - unsigned long long fmodValueInUnsignedLongLong = static_cast<unsigned long long>(-fmodValue); - // -1 < (std::numeric_limits<unsigned long long>::max() - fmodValueInUnsignedLongLong) < 2^{64} - 1. - // 0 < value < 2^{64}. - value = std::numeric_limits<unsigned long long>::max() - fmodValueInUnsignedLongLong + 1; - } - } -} - -#endif // #ifndef WTF_MathExtras_h |