All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
diy-fp.h
1 // Copyright 2010 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifndef DOUBLE_CONVERSION_DIY_FP_H_
29 #define DOUBLE_CONVERSION_DIY_FP_H_
30 
31 #include "utils.h"
32 
33 #include "pxr/pxr.h"
34 
35 PXR_NAMESPACE_OPEN_SCOPE
36 
37 namespace pxr_double_conversion {
38 
39 // This "Do It Yourself Floating Point" class implements a floating-point number
40 // with a uint64 significand and an int exponent. Normalized DiyFp numbers will
41 // have the most significant bit of the significand set.
42 // Multiplication and Subtraction do not normalize their results.
43 // DiyFp are not designed to contain special doubles (NaN and Infinity).
44 class DiyFp {
45  public:
46  static const int kSignificandSize = 64;
47 
48  DiyFp() : f_(0), e_(0) {}
49  DiyFp(uint64_t significand, int exponent) : f_(significand), e_(exponent) {}
50 
51  // this = this - other.
52  // The exponents of both numbers must be the same and the significand of this
53  // must be bigger than the significand of other.
54  // The result will not be normalized.
55  void Subtract(const DiyFp& other) {
56  ASSERT(e_ == other.e_);
57  ASSERT(f_ >= other.f_);
58  f_ -= other.f_;
59  }
60 
61  // Returns a - b.
62  // The exponents of both numbers must be the same and this must be bigger
63  // than other. The result will not be normalized.
64  static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
65  DiyFp result = a;
66  result.Subtract(b);
67  return result;
68  }
69 
70 
71  // this = this * other.
72  void Multiply(const DiyFp& other);
73 
74  // returns a * b;
75  static DiyFp Times(const DiyFp& a, const DiyFp& b) {
76  DiyFp result = a;
77  result.Multiply(b);
78  return result;
79  }
80 
81  void Normalize() {
82  ASSERT(f_ != 0);
83  uint64_t significand = f_;
84  int exponent = e_;
85 
86  // This method is mainly called for normalizing boundaries. In general
87  // boundaries need to be shifted by 10 bits. We thus optimize for this case.
88  const uint64_t k10MSBits = UINT64_2PART_C(0xFFC00000, 00000000);
89  while ((significand & k10MSBits) == 0) {
90  significand <<= 10;
91  exponent -= 10;
92  }
93  while ((significand & kUint64MSB) == 0) {
94  significand <<= 1;
95  exponent--;
96  }
97  f_ = significand;
98  e_ = exponent;
99  }
100 
101  static DiyFp Normalize(const DiyFp& a) {
102  DiyFp result = a;
103  result.Normalize();
104  return result;
105  }
106 
107  uint64_t f() const { return f_; }
108  int e() const { return e_; }
109 
110  void set_f(uint64_t new_value) { f_ = new_value; }
111  void set_e(int new_value) { e_ = new_value; }
112 
113  private:
114  static const uint64_t kUint64MSB = UINT64_2PART_C(0x80000000, 00000000);
115 
116  uint64_t f_;
117  int e_;
118 };
119 
120 } // namespace pxr_double_conversion
121 
122 PXR_NAMESPACE_CLOSE_SCOPE
123 
124 #endif // DOUBLE_CONVERSION_DIY_FP_H_