1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #ifndef GOOGLE_PROTOBUF_STUBS_MATHUTIL_H_
31 #define GOOGLE_PROTOBUF_STUBS_MATHUTIL_H_
36 #include <google/protobuf/stubs/common.h>
37 #include <google/protobuf/stubs/logging.h>
38 #include <google/protobuf/stubs/mathlimits.h>
44 bool AlmostEquals(T a, T b) {
48 inline bool AlmostEquals(float a, float b) {
49 return fabs(a - b) < 32 * FLT_EPSILON;
53 inline bool AlmostEquals(double a, double b) {
54 return fabs(a - b) < 32 * DBL_EPSILON;
56 } // namespace internal
61 static T Sign(T value) {
62 if (value == T(0) || MathLimits<T>::IsNaN(value)) {
65 return value > T(0) ? 1 : -1;
69 static bool AlmostEquals(T a, T b) {
70 return internal::AlmostEquals(a, b);
73 // Largest of two values.
74 // Works correctly for special floating point values.
75 // Note: 0.0 and -0.0 are not differentiated by Max (Max(0.0, -0.0) is -0.0),
76 // which should be OK because, although they (can) have different
77 // bit representation, they are observably the same when examined
78 // with arithmetic and (in)equality operators.
80 static T Max(const T x, const T y) {
81 return MathLimits<T>::IsNaN(x) || x > y ? x : y;
84 // Absolute value of x
85 // Works correctly for unsigned types and
86 // for special floating point values.
87 // Note: 0.0 and -0.0 are not differentiated by Abs (Abs(0.0) is -0.0),
88 // which should be OK: see the comment for Max above.
90 static T Abs(const T x) {
91 return x > T(0) ? x : -x;
94 // Absolute value of the difference between two numbers.
95 // Works correctly for signed types and special floating point values.
97 static typename MathLimits<T>::UnsignedType AbsDiff(const T x, const T y) {
98 // Carries out arithmetic as unsigned to avoid overflow.
99 typedef typename MathLimits<T>::UnsignedType R;
100 return x > y ? R(x) - R(y) : R(y) - R(x);
103 // If two (usually floating point) numbers are within a certain
104 // fraction of their magnitude or within a certain absolute margin of error.
105 // This is the same as the following but faster:
106 // WithinFraction(x, y, fraction) || WithinMargin(x, y, margin)
107 // E.g. WithinFraction(0.0, 1e-10, 1e-5) is false but
108 // WithinFractionOrMargin(0.0, 1e-10, 1e-5, 1e-5) is true.
110 static bool WithinFractionOrMargin(const T x, const T y,
111 const T fraction, const T margin);
115 bool MathUtil::WithinFractionOrMargin(const T x, const T y,
116 const T fraction, const T margin) {
117 // Not just "0 <= fraction" to fool the compiler for unsigned types.
118 GOOGLE_DCHECK((T(0) < fraction || T(0) == fraction) &&
122 // Template specialization will convert the if() condition to a constant,
123 // which will cause the compiler to generate code for either the "if" part
124 // or the "then" part. In this way we avoid a compiler warning
125 // about a potential integer overflow in crosstool v12 (gcc 4.3.1).
126 if (MathLimits<T>::kIsInteger) {
129 // IsFinite checks are to make kPosInf and kNegInf not within fraction
130 if (!MathLimits<T>::IsFinite(x) && !MathLimits<T>::IsFinite(y)) {
133 T relative_margin = static_cast<T>(fraction * Max(Abs(x), Abs(y)));
134 return AbsDiff(x, y) <= Max(margin, relative_margin);
138 } // namespace protobuf
139 } // namespace google
141 #endif // GOOGLE_PROTOBUF_STUBS_MATHUTIL_H_