USRP Hardware Driver and USRP Manual Version: 20250207.0.git0dede88c.fc40
UHD and USRP Manual
 
Loading...
Searching...
No Matches
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 <cmath>
12
13
14namespace uhd {
15
20namespace math {
21
22static const double PI = 3.14159265358979323846;
23
40static const float SINGLE_PRECISION_EPSILON = 1.19e-7f;
41static const double DOUBLE_PRECISION_EPSILON = 2.22e-16;
42
44//
45// Note that this is a UHD/USRP-specific constant. In UHD, frequencies are on
46// the order of 1e9 (GHz) or below. We will declare frequencies as equal if they
47// are within a millihertz. For the purpose of
48// comparing frequencies, we "lose" 9 decimal places for the integer
49// component of the frequency, so we choose this epsilon value for floating
50// point comparison of frequencies.
51static constexpr double FREQ_COMPARE_EPSILON = 1e-12;
52
53namespace fp_compare {
54
68template <typename float_t>
70{
71public:
73 UHD_INLINE fp_compare_epsilon(float_t value, float_t epsilon);
76 UHD_INLINE void operator=(const fp_compare_epsilon& copy);
77
78 float_t _value;
79 float_t _epsilon;
80};
81
82/* A Note on Floating Point Equality with Epsilons
83 *
84 * There are obviously a lot of strategies for defining floating point
85 * equality, and in the end it all comes down to the domain at hand. UHD's
86 * floating-point-with-epsilon comparison algorithm is based on the method
87 * presented in Knuth's "The Art of Computer Science" called "close enough
88 * with tolerance epsilon".
89 *
90 * [(|u - v| / |u|) <= e] || [(|u - v| / |v|) <= e]
91 *
92 * UHD's modification to this algorithm is using the denominator's epsilon
93 * value (since each float_t object has its own epsilon) for each
94 * comparison.
95 */
96
97template <typename float_t>
100template <typename float_t>
103template <typename float_t>
106template <typename float_t>
109template <typename float_t>
112template <typename float_t>
115
116/* If these operators are used with floats, we rely on type promotion to
117 * double. */
118template <typename float_t>
120template <typename float_t>
122template <typename float_t>
124template <typename float_t>
126template <typename float_t>
128template <typename float_t>
130
131template <typename float_t>
133template <typename float_t>
135template <typename float_t>
137template <typename float_t>
139template <typename float_t>
141template <typename float_t>
143
146{
147public:
149 : fp_compare_epsilon<double>(value, FREQ_COMPARE_EPSILON)
150 {
151 }
152
154 : fp_compare_epsilon<double>(copy)
155 {
156 }
157};
158
159
160} // namespace fp_compare
161
162
169static const float SINGLE_PRECISION_DELTA = 1e-3f;
170static const double DOUBLE_PRECISION_DELTA = 1e-5;
171
173static const double FREQ_COMPARISON_DELTA_HZ = 0.1;
174
175
176namespace fp_compare {
177
191template <typename float_t>
193{
194public:
196 UHD_INLINE fp_compare_delta(float_t value, float_t delta);
199 UHD_INLINE void operator=(const fp_compare_delta& copy);
200
201 float_t _value;
202 float_t _delta;
203};
204
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
218/* If these operators are used with floats, we rely on type promotion to
219 * double. */
220template <typename float_t>
222template <typename float_t>
224template <typename float_t>
226template <typename float_t>
228template <typename float_t>
230template <typename float_t>
232
233template <typename float_t>
235template <typename float_t>
237template <typename float_t>
239template <typename float_t>
241template <typename float_t>
243template <typename float_t>
245
246} // namespace fp_compare
247
248UHD_INLINE bool frequencies_are_equal(double lhs, double rhs)
249{
250 return (fp_compare::fp_compare_delta<double>(lhs, FREQ_COMPARISON_DELTA_HZ)
251 == fp_compare::fp_compare_delta<double>(rhs, FREQ_COMPARISON_DELTA_HZ));
252}
253
254inline double dB_to_lin(const double dB_val)
255{
256 return std::pow(10, (dB_val) / 10.0);
257}
258
259inline double lin_to_dB(const double val)
260{
261 return 10 * std::log10(val);
262}
263
264
266//
267// Note: This is equivalent to the Boost.Math version, but without the
268// dependency.
269//
270// Returns +1 for positive arguments, -1 for negative arguments, and 0 if x is
271// zero.
272template <typename T>
273inline constexpr int sign(T x)
274{
275 // Note: If T is unsigned, then this will compile with a warning. Should
276 // we need that, expand the template logic.
277 return (T(0) < x) - (x < T(0));
278}
279
281// Nyquist zone.
282//
283// Examples:
284// - Just above the sampling rate:
285// wrap_frequency(250e6, 200e6) == 50e6
286// - Just outside the Nyquist zone:
287// wrap_frequency(120e6, 200e6) == -80e6
288// - Also works for negative frequencies:
289// wrap_frequency(-250e6, 200e6) == -50e6
290inline double wrap_frequency(const double requested_freq, const double rate)
291{
292 double freq = std::fmod(requested_freq, rate);
293 if (std::abs(freq) > rate / 2.0)
294 freq -= uhd::math::sign(freq) * rate;
295 return freq;
296}
297
298} // namespace math
299} // namespace uhd
300
UHD_INLINE fp_compare_delta(float_t value)
float_t _delta
Definition math.hpp:202
UHD_INLINE void operator=(const fp_compare_delta &copy)
Definition fp_compare_delta.ipp:56
UHD_INLINE ~fp_compare_delta()
Definition fp_compare_delta.ipp:51
float_t _value
Definition math.hpp:201
float_t _epsilon
Definition math.hpp:79
UHD_INLINE ~fp_compare_epsilon()
Definition fp_compare_epsilon.ipp:46
UHD_INLINE void operator=(const fp_compare_epsilon &copy)
Definition fp_compare_epsilon.ipp:51
float_t _value
Definition math.hpp:78
UHD_INLINE fp_compare_epsilon(float_t value)
An alias for fp_compare_epsilon, but with defaults for frequencies.
Definition math.hpp:146
UHD_INLINE freq_compare_epsilon(const freq_compare_epsilon &copy)
Definition math.hpp:153
UHD_INLINE freq_compare_epsilon(double value)
Definition math.hpp:148
#define UHD_INLINE
Definition config.h:65
UHD_INLINE bool operator!=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition fp_compare_delta.ipp:71
UHD_INLINE bool operator<=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition fp_compare_delta.ipp:84
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:77
UHD_INLINE bool operator>(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition fp_compare_delta.ipp:90
UHD_INLINE bool operator>=(fp_compare_delta< float_t > lhs, fp_compare_delta< float_t > rhs)
Definition fp_compare_delta.ipp:97
UHD_INLINE bool frequencies_are_equal(double lhs, double rhs)
Definition math.hpp:248
double dB_to_lin(const double dB_val)
Definition math.hpp:254
constexpr int sign(T x)
Returns the sign of x.
Definition math.hpp:273
double lin_to_dB(const double val)
Definition math.hpp:259
double wrap_frequency(const double requested_freq, const double rate)
Return a wrapped frequency that is the equivalent frequency in the first.
Definition math.hpp:290
Definition build_info.hpp:12