Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1321)

Unified Diff: third_party/WebKit/Source/wtf/MathExtras.h

Issue 2764243002: Move files in wtf/ to platform/wtf/ (Part 9). (Closed)
Patch Set: Rebase. Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/WebKit/Source/wtf/HexNumber.h ('k') | third_party/WebKit/Source/wtf/RetainPtr.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/wtf/MathExtras.h
diff --git a/third_party/WebKit/Source/wtf/MathExtras.h b/third_party/WebKit/Source/wtf/MathExtras.h
index efcd871bb32a0639202c4fbc81e024b16cf7925c..b263df226ca6b1979ef34132c78f229238ff1a87 100644
--- a/third_party/WebKit/Source/wtf/MathExtras.h
+++ b/third_party/WebKit/Source/wtf/MathExtras.h
@@ -1,435 +1,9 @@
-/*
- * 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.
- */
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
-#ifndef WTF_MathExtras_h
-#define WTF_MathExtras_h
+#include "platform/wtf/MathExtras.h"
-#include "wtf/Allocator.h"
-#include "wtf/Assertions.h"
-#include "wtf/CPU.h"
-#include <cmath>
-#include <cstddef>
-#include <limits>
-
-#if COMPILER(MSVC)
-// Make math.h behave like other platforms.
-#define _USE_MATH_DEFINES
-// Even if math.h was already included, including math.h again with
-// _USE_MATH_DEFINES adds the extra defines.
-#include <math.h>
-#include <stdint.h>
-#endif
-
-#if OS(OPENBSD)
-#include <machine/ieee.h>
-#include <sys/types.h>
-#endif
-
-const double piDouble = M_PI;
-const float piFloat = static_cast<float>(M_PI);
-
-const double piOverTwoDouble = M_PI_2;
-const float piOverTwoFloat = static_cast<float>(M_PI_2);
-
-const double piOverFourDouble = M_PI_4;
-const float piOverFourFloat = static_cast<float>(M_PI_4);
-
-const double twoPiDouble = piDouble * 2.0;
-const float twoPiFloat = piFloat * 2.0f;
-
-#if COMPILER(MSVC)
-
-// VS2013 has most of the math functions now, but we still need to work
-// around various differences in behavior of Inf.
-
-// 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 (!std::isinf(x) && std::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 double turn2grad(double t) {
- return t * 400;
-}
-inline double grad2turn(double g) {
- return g / 400;
-}
-
-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;
-}
-inline float turn2grad(float t) {
- return t * 400;
-}
-inline float grad2turn(float g) {
- return g / 400;
-}
-
-// clampTo() is implemented by templated helper classes (to allow for partial
-// template specialization) as well as several helper functions.
-
-// This helper function can be called when we know that:
-// (1) The type signednesses match so the compiler will not produce signed vs.
-// unsigned warnings
-// (2) The default type promotions/conversions are sufficient to handle things
-// correctly
-template <typename LimitType, typename ValueType>
-inline LimitType clampToDirectComparison(ValueType value,
- LimitType min,
- LimitType max) {
- if (value >= max)
- return max;
- return (value <= min) ? min : static_cast<LimitType>(value);
-}
-
-// For any floating-point limits, or integral limits smaller than long long, we
-// can cast the limits to double without losing precision; then the only cases
-// where |value| can't be represented accurately as a double are the ones where
-// it's outside the limit range anyway. So doing all comparisons as doubles
-// will give correct results.
-//
-// In some cases, we can get better performance by using
-// clampToDirectComparison(). We use a templated class to switch between these
-// two cases (instead of simply using a conditional within one function) in
-// order to only compile the clampToDirectComparison() code for cases where it
-// will actually be used; this prevents the compiler from emitting warnings
-// about unsafe code (even though we wouldn't actually be executing that code).
-template <bool canUseDirectComparison, typename LimitType, typename ValueType>
-class ClampToNonLongLongHelper;
-template <typename LimitType, typename ValueType>
-class ClampToNonLongLongHelper<true, LimitType, ValueType> {
- STATIC_ONLY(ClampToNonLongLongHelper);
-
- public:
- static inline LimitType clampTo(ValueType value,
- LimitType min,
- LimitType max) {
- return clampToDirectComparison(value, min, max);
- }
-};
-
-template <typename LimitType, typename ValueType>
-class ClampToNonLongLongHelper<false, LimitType, ValueType> {
- STATIC_ONLY(ClampToNonLongLongHelper);
-
- public:
- static inline LimitType clampTo(ValueType value,
- LimitType min,
- LimitType max) {
- const double doubleValue = static_cast<double>(value);
- if (doubleValue >= static_cast<double>(max))
- return max;
- if (doubleValue <= static_cast<double>(min))
- return min;
- // If the limit type is integer, we might get better performance by
- // casting |value| (as opposed to |doubleValue|) to the limit type.
- return std::numeric_limits<LimitType>::is_integer
- ? static_cast<LimitType>(value)
- : static_cast<LimitType>(doubleValue);
- }
-};
-
-// The unspecialized version of this templated class handles clamping to
-// anything other than [unsigned] long long int limits. It simply uses the
-// class above to toggle between the "fast" and "safe" clamp implementations.
-template <typename LimitType, typename ValueType>
-class ClampToHelper {
- public:
- static inline LimitType clampTo(ValueType value,
- LimitType min,
- LimitType max) {
- // We only use clampToDirectComparison() when the integerness and
- // signedness of the two types matches.
- //
- // If the integerness of the types doesn't match, then at best
- // clampToDirectComparison() won't be much more efficient than the
- // cast-everything-to-double method, since we'll need to convert to
- // floating point anyway; at worst, we risk incorrect results when
- // clamping a float to a 32-bit integral type due to potential precision
- // loss.
- //
- // If the signedness doesn't match, clampToDirectComparison() will
- // produce warnings about comparing signed vs. unsigned, which are apt
- // since negative signed values will be converted to large unsigned ones
- // and we'll get incorrect results.
- return ClampToNonLongLongHelper <
- std::numeric_limits<LimitType>::is_integer ==
- std::numeric_limits<ValueType>::is_integer &&
- std::numeric_limits<LimitType>::is_signed ==
- std::numeric_limits<ValueType>::is_signed,
- LimitType, ValueType > ::clampTo(value, min, max);
- }
-};
-
-// Clamping to [unsigned] long long int limits requires more care. These may
-// not be accurately representable as doubles, so instead we cast |value| to the
-// limit type. But that cast is undefined if |value| is floating point and
-// outside the representable range of the limit type, so we also have to check
-// for that case explicitly.
-template <typename ValueType>
-class ClampToHelper<long long int, ValueType> {
- STATIC_ONLY(ClampToHelper);
-
- public:
- static inline long long int clampTo(ValueType value,
- long long int min,
- long long int max) {
- if (!std::numeric_limits<ValueType>::is_integer) {
- if (value > 0) {
- if (static_cast<double>(value) >=
- static_cast<double>(std::numeric_limits<long long int>::max()))
- return max;
- } else if (static_cast<double>(value) <=
- static_cast<double>(
- std::numeric_limits<long long int>::min())) {
- return min;
- }
- }
- // Note: If |value| were unsigned long long int, it could be larger than
- // the largest long long int, and this code would be wrong; we handle
- // this case with a separate full specialization below.
- return clampToDirectComparison(static_cast<long long int>(value), min, max);
- }
-};
-
-// This specialization handles the case where the above partial specialization
-// would be potentially incorrect.
-template <>
-class ClampToHelper<long long int, unsigned long long int> {
- STATIC_ONLY(ClampToHelper);
-
- public:
- static inline long long int clampTo(unsigned long long int value,
- long long int min,
- long long int max) {
- if (max <= 0 || value >= static_cast<unsigned long long int>(max))
- return max;
- const long long int longLongValue = static_cast<long long int>(value);
- return (longLongValue <= min) ? min : longLongValue;
- }
-};
-
-// This is similar to the partial specialization that clamps to long long int,
-// but because the lower-bound check is done for integer value types as well, we
-// don't need a <unsigned long long int, long long int> full specialization.
-template <typename ValueType>
-class ClampToHelper<unsigned long long int, ValueType> {
- STATIC_ONLY(ClampToHelper);
-
- public:
- static inline unsigned long long int clampTo(ValueType value,
- unsigned long long int min,
- unsigned long long int max) {
- if (value <= 0)
- return min;
- if (!std::numeric_limits<ValueType>::is_integer) {
- if (static_cast<double>(value) >=
- static_cast<double>(
- std::numeric_limits<unsigned long long int>::max()))
- return max;
- }
- return clampToDirectComparison(static_cast<unsigned long long int>(value),
- min, max);
- }
-};
-
-template <typename T>
-inline T defaultMaximumForClamp() {
- return std::numeric_limits<T>::max();
-}
-// This basically reimplements C++11's std::numeric_limits<T>::lowest().
-template <typename T>
-inline T defaultMinimumForClamp() {
- return std::numeric_limits<T>::min();
-}
-template <>
-inline float defaultMinimumForClamp<float>() {
- return -std::numeric_limits<float>::max();
-}
-template <>
-inline double defaultMinimumForClamp<double>() {
- return -std::numeric_limits<double>::max();
-}
-
-// And, finally, the actual function for people to call.
-template <typename LimitType, typename ValueType>
-inline LimitType clampTo(ValueType value,
- LimitType min = defaultMinimumForClamp<LimitType>(),
- LimitType max = defaultMaximumForClamp<LimitType>()) {
- DCHECK(!std::isnan(static_cast<double>(value)));
- DCHECK_LE(min, max); // This also ensures |min| and |max| aren't NaN.
- return ClampToHelper<LimitType, ValueType>::clampTo(value, min, max);
-}
-
-inline bool isWithinIntRange(float x) {
- return x > static_cast<float>(std::numeric_limits<int>::min()) &&
- x < static_cast<float>(std::numeric_limits<int>::max());
-}
-
-static size_t greatestCommonDivisor(size_t a, size_t b) {
- return b ? greatestCommonDivisor(b, a % b) : a;
-}
-
-inline size_t lowestCommonMultiple(size_t a, size_t b) {
- return a && b ? a / greatestCommonDivisor(a, b) * b : 0;
-}
-
-#ifndef UINT64_C
-#if COMPILER(MSVC)
-#define UINT64_C(c) c##ui64
-#else
-#define UINT64_C(c) c##ull
-#endif
-#endif
-
-// Calculate d % 2^{64}.
-inline void doubleToInteger(double d, unsigned long long& value) {
- if (std::isnan(d) || std::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;
- }
- }
-}
-
-namespace WTF {
-
-inline unsigned fastLog2(unsigned i) {
- unsigned log2 = 0;
- if (i & (i - 1))
- log2 += 1;
- if (i >> 16)
- log2 += 16, i >>= 16;
- if (i >> 8)
- log2 += 8, i >>= 8;
- if (i >> 4)
- log2 += 4, i >>= 4;
- if (i >> 2)
- log2 += 2, i >>= 2;
- if (i >> 1)
- log2 += 1;
- return log2;
-}
-
-} // namespace WTF
-
-#endif // #ifndef WTF_MathExtras_h
+// The contents of this header was moved to platform/wtf as part of
+// WTF migration project. See the following post for details:
+// https://groups.google.com/a/chromium.org/d/msg/blink-dev/tLdAZCTlcAA/bYXVT8gYCAAJ
« no previous file with comments | « third_party/WebKit/Source/wtf/HexNumber.h ('k') | third_party/WebKit/Source/wtf/RetainPtr.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698