USRP Hardware Driver and USRP Manual Version: 4.1.0.3
UHD and USRP Manual
math.hpp
Go to the documentation of this file.
1//
2// Copyright 2014-2015 Ettus Research LLC
3// Copyright 2018 Ettus Research, a National Instruments Company
4//
5// SPDX-License-Identifier: GPL-3.0-or-later
6//
7
8#pragma once
9
10#include <uhd/config.hpp>
11#include <uhd/exception.hpp>
12#include <stdint.h>
13#include <boost/numeric/conversion/bounds.hpp>
14#include <cmath>
15#if BOOST_VERSION >= 106700
16# include <boost/integer/common_factor.hpp>
17// "bmint" for "boost math integer"
18namespace _bmint = boost::integer;
19#else
20# include <boost/math/common_factor.hpp>
21namespace _bmint = boost::math;
22#endif
23
24
25namespace uhd {
26
31namespace math {
32
33static const double PI = 3.14159265358979323846;
34
51static const float SINGLE_PRECISION_EPSILON = 1.19e-7f;
52static const double DOUBLE_PRECISION_EPSILON = 2.22e-16;
53
54namespace fp_compare {
55
69template <typename float_t>
71{
72public:
74 UHD_INLINE fp_compare_epsilon(float_t value, float_t epsilon);
77 UHD_INLINE void operator=(const fp_compare_epsilon& copy);
78
79 float_t _value;
80 float_t _epsilon;
81};
82
83/* A Note on Floating Point Equality with Epsilons
84 *
85 * There are obviously a lot of strategies for defining floating point
86 * equality, and in the end it all comes down to the domain at hand. UHD's
87 * floating-point-with-epsilon comparison algorithm is based on the method
88 * presented in Knuth's "The Art of Computer Science" called "very close
89 * with tolerance epsilon".
90 *
91 * [(|u - v| / |u|) <= e] && [(|u - v| / |v|) <= e]
92 *
93 * UHD's modification to this algorithm is using the denominator's epsilon
94 * value (since each float_t object has its own epsilon) for each
95 * comparison.
96 */
97
98template <typename float_t>
101template <typename float_t>
104template <typename float_t>
107template <typename float_t>
110template <typename float_t>
113template <typename float_t>
116
117/* If these operators are used with floats, we rely on type promotion to
118 * double. */
119template <typename float_t>
121template <typename float_t>
123template <typename float_t>
125template <typename float_t>
127template <typename float_t>
129template <typename float_t>
131
132template <typename float_t>
134template <typename float_t>
136template <typename float_t>
138template <typename float_t>
140template <typename float_t>
142template <typename float_t>
144
145} // namespace fp_compare
146
147
154static const float SINGLE_PRECISION_DELTA = 1e-3f;
155static const double DOUBLE_PRECISION_DELTA = 1e-5;
156
158static const double FREQ_COMPARISON_DELTA_HZ = 0.1;
159
160
161namespace fp_compare {
162
176template <typename float_t>
178{
179public:
181 UHD_INLINE fp_compare_delta(float_t value, float_t delta);
184 UHD_INLINE void operator=(const fp_compare_delta& copy);
185
186 float_t _value;
187 float_t _delta;
188};
189
190template <typename float_t>
192template <typename float_t>
194template <typename float_t>
196template <typename float_t>
198template <typename float_t>
200template <typename float_t>
202
203/* If these operators are used with floats, we rely on type promotion to
204 * double. */
205template <typename float_t>
207template <typename float_t>
209template <typename float_t>
211template <typename float_t>
213template <typename float_t>
215template <typename float_t>
217
218template <typename float_t>
220template <typename float_t>
222template <typename float_t>
224template <typename float_t>
226template <typename float_t>
228template <typename float_t>
230
231} // namespace fp_compare
232
233UHD_INLINE bool frequencies_are_equal(double lhs, double rhs)
234{
235 return (fp_compare::fp_compare_delta<double>(lhs, FREQ_COMPARISON_DELTA_HZ)
236 == fp_compare::fp_compare_delta<double>(rhs, FREQ_COMPARISON_DELTA_HZ));
237}
238
239inline double dB_to_lin(const double dB_val)
240{
241 return std::pow(10, (dB_val) / 10.0);
242}
243
244inline double lin_to_dB(const double val)
245{
246 return 10 * std::log10(val);
247}
248
249
251template <typename IntegerType>
252inline IntegerType lcm(IntegerType x, IntegerType y)
253{
254 // Note: _bmint is defined conditionally at the top of the file
255 return _bmint::lcm<IntegerType>(x, y);
256}
257
259template <typename IntegerType>
260inline IntegerType gcd(IntegerType x, IntegerType y)
261{
262 // Note: _bmint is defined conditionally at the top of the file
263 return _bmint::gcd<IntegerType>(x, y);
264}
265
266} // namespace math
267} // namespace uhd
268
UHD_INLINE fp_compare_delta(float_t value)
float_t _delta
Definition: math.hpp:187
UHD_INLINE void operator=(const fp_compare_delta &copy)
Definition: fp_compare_delta.ipp:52
UHD_INLINE ~fp_compare_delta()
Definition: fp_compare_delta.ipp:48
float_t _value
Definition: math.hpp:186
float_t _epsilon
Definition: math.hpp:80
UHD_INLINE ~fp_compare_epsilon()
Definition: fp_compare_epsilon.ipp:43
UHD_INLINE void operator=(const fp_compare_epsilon &copy)
Definition: fp_compare_epsilon.ipp:47
float_t _value
Definition: math.hpp:79
UHD_INLINE fp_compare_epsilon(float_t value)
#define UHD_INLINE
Definition: config.h:55
UHD_INLINE bool operator!=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:64
UHD_INLINE bool operator<=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:75
UHD_INLINE bool operator==(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:58
UHD_INLINE bool operator<(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:69
UHD_INLINE bool operator>(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:80
UHD_INLINE bool operator>=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition: fp_compare_delta.ipp:86
IntegerType lcm(IntegerType x, IntegerType y)
Portable version of lcm() across Boost versions.
Definition: math.hpp:252
UHD_INLINE bool frequencies_are_equal(double lhs, double rhs)
Definition: math.hpp:233
double dB_to_lin(const double dB_val)
Definition: math.hpp:239
IntegerType gcd(IntegerType x, IntegerType y)
Portable version of gcd() across Boost versions.
Definition: math.hpp:260
double lin_to_dB(const double val)
Definition: math.hpp:244
Definition: build_info.hpp:12