aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--host/include/uhd/config.hpp10
-rw-r--r--host/include/uhd/types/CMakeLists.txt1
-rw-r--r--host/include/uhd/types/ranges.hpp41
-rw-r--r--host/include/uhd/types/ranges.ipp188
-rw-r--r--host/include/uhd/utils/gain_group.hpp11
-rw-r--r--host/lib/CMakeLists.txt1
-rw-r--r--host/lib/ranges.cpp163
-rw-r--r--host/lib/types.cpp9
-rw-r--r--host/lib/usrp/dboard/db_xcvr2450.cpp10
-rw-r--r--host/lib/utils/gain_group.cpp18
-rw-r--r--host/test/gain_group_test.cpp20
-rw-r--r--host/test/ranges_test.cpp12
12 files changed, 219 insertions, 265 deletions
diff --git a/host/include/uhd/config.hpp b/host/include/uhd/config.hpp
index 62c2504e1..f7ccb62e5 100644
--- a/host/include/uhd/config.hpp
+++ b/host/include/uhd/config.hpp
@@ -89,14 +89,4 @@ typedef ptrdiff_t ssize_t;
#define UHD_PLATFORM_BSD
#endif
-//On macos platform, explicit templates must be:
-// - defined with extern in the header file
-// - defined as a symbol in the source file
-#if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
- #define UHD_EXIM_TMPL extern
- #define UHD_USE_EXIM_TMPL
-#else
- #define UHD_EXIM_TMPL
-#endif
-
#endif /* INCLUDED_UHD_CONFIG_HPP */
diff --git a/host/include/uhd/types/CMakeLists.txt b/host/include/uhd/types/CMakeLists.txt
index 1d2c0c41c..a96976b5e 100644
--- a/host/include/uhd/types/CMakeLists.txt
+++ b/host/include/uhd/types/CMakeLists.txt
@@ -25,7 +25,6 @@ INSTALL(FILES
mac_addr.hpp
metadata.hpp
otw_type.hpp
- ranges.ipp
ranges.hpp
serial.hpp
stream_cmd.hpp
diff --git a/host/include/uhd/types/ranges.hpp b/host/include/uhd/types/ranges.hpp
index 366efb1f3..5bb74f976 100644
--- a/host/include/uhd/types/ranges.hpp
+++ b/host/include/uhd/types/ranges.hpp
@@ -30,14 +30,15 @@ namespace uhd{
* A range object describes a set of discrete values of the form:
* y = start + step*n, where n is an integer between 0 and (stop - start)/step
*/
- template <typename T> class range_t{
+ class UHD_API range_t{
public:
+
/*!
* Create a range from a single value.
* The step size will be taken as zero.
* \param value the only possible value in this range
*/
- range_t(const T &value = T(0));
+ range_t(double value = 0);
/*!
* Create a range from a full set of values.
@@ -46,28 +47,27 @@ namespace uhd{
* \param stop the maximum value for this range
* \param step the step size for this range
*/
- range_t(const T &start, const T &stop, const T &step = T(0));
+ range_t(double start, double stop, double step = 0);
//! Get the start value for this range.
- const T start(void) const;
+ double start(void) const;
//! Get the stop value for this range.
- const T stop(void) const;
+ double stop(void) const;
//! Get the step value for this range.
- const T step(void) const;
+ double step(void) const;
//! Convert this range to a printable string
const std::string to_pp_string(void) const;
- private:
- UHD_PIMPL_DECL(impl) _impl;
+ private: UHD_PIMPL_DECL(impl) _impl;
};
/*!
* A meta-range object holds a list of individual ranges.
*/
- template <typename T> struct meta_range_t : std::vector<range_t<T> >{
+ struct UHD_API meta_range_t : std::vector<range_t>{
//! A default constructor for an empty meta-range
meta_range_t(void);
@@ -79,7 +79,8 @@ namespace uhd{
* \param last the end iterator
*/
template <typename InputIterator>
- meta_range_t(InputIterator first, InputIterator last);
+ meta_range_t(InputIterator first, InputIterator last):
+ std::vector<range_t>(first, last){ /* NOP */ }
/*!
* A convenience constructor for a single range.
@@ -88,16 +89,16 @@ namespace uhd{
* \param stop the maximum value for this range
* \param step the step size for this range
*/
- meta_range_t(const T &start, const T &stop, const T &step = T(0));
+ meta_range_t(double start, double stop, double step = 0);
//! Get the overall start value for this meta-range.
- const T start(void) const;
+ double start(void) const;
//! Get the overall stop value for this meta-range.
- const T stop(void) const;
+ double stop(void) const;
//! Get the overall step value for this meta-range.
- const T step(void) const;
+ double step(void) const;
/*!
* Clip the target value to a possible range value.
@@ -105,22 +106,16 @@ namespace uhd{
* \param clip_step if true, clip to steps as well
* \return a value that is in one of the ranges
*/
- const T clip(const T &value, bool clip_step = false) const;
+ double clip(double value, bool clip_step = false) const;
//! Convert this meta-range to a printable string
const std::string to_pp_string(void) const;
};
- //!typedef for a gain meta-range
- typedef meta_range_t<float> gain_range_t;
-
- //!typedef for a frequency meta-range
- typedef meta_range_t<double> freq_range_t;
-
+ typedef meta_range_t gain_range_t;
+ typedef meta_range_t freq_range_t;
} //namespace uhd
-#include <uhd/types/ranges.ipp>
-
#endif /* INCLUDED_UHD_TYPES_RANGES_HPP */
diff --git a/host/include/uhd/types/ranges.ipp b/host/include/uhd/types/ranges.ipp
deleted file mode 100644
index 944ada51f..000000000
--- a/host/include/uhd/types/ranges.ipp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// Copyright 2010 Ettus Research LLC
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <http://www.gnu.org/licenses/>.
-//
-
-#ifndef INCLUDED_UHD_TYPES_RANGES_IPP
-#define INCLUDED_UHD_TYPES_RANGES_IPP
-
-#include <boost/math/special_functions/round.hpp>
-#include <boost/foreach.hpp>
-#include <algorithm>
-#include <stdexcept>
-#include <sstream>
-
-namespace uhd{
-
- /*******************************************************************
- * range_t implementation code
- ******************************************************************/
- template <typename T> struct range_t<T>::impl{
- impl(const T &start, const T &stop, const T &step):
- start(start), stop(stop), step(step)
- {
- /* NOP */
- }
- const T start, stop, step;
- };
-
- template <typename T> range_t<T>::range_t(const T &value):
- _impl(UHD_PIMPL_MAKE(impl, (value, value, T(0))))
- {
- /* NOP */
- }
-
- template <typename T> range_t<T>::range_t(
- const T &start, const T &stop, const T &step
- ):
- _impl(UHD_PIMPL_MAKE(impl, (start, stop, step)))
- {
- if (stop < start){
- throw std::invalid_argument("cannot make range where stop < start");
- }
- }
-
- template <typename T> const T range_t<T>::start(void) const{
- return _impl->start;
- }
-
- template <typename T> const T range_t<T>::stop(void) const{
- return _impl->stop;
- }
-
- template <typename T> const T range_t<T>::step(void) const{
- return _impl->step;
- }
-
- template <typename T> const std::string range_t<T>::to_pp_string(void) const{
- std::stringstream ss;
- ss << "(" << this->start();
- if (this->start() != this->stop()) ss << ", " << this->stop();
- if (this->step() != T(0)) ss << ", " << this->step();
- ss << ")";
- return ss.str();
- }
-
- /*******************************************************************
- * meta_range_t implementation code
- ******************************************************************/
-
- namespace /*anon*/{
- template <typename T> inline
- void check_meta_range_monotonic(const meta_range_t<T> &mr){
- if (mr.empty()){
- throw std::runtime_error("meta-range cannot be empty");
- }
- for (size_t i = 1; i < mr.size(); i++){
- if (mr.at(i).start() < mr.at(i-1).stop()){
- throw std::runtime_error("meta-range is not monotonic");
- }
- }
- }
- } //namespace /*anon*/
-
-
- template <typename T> meta_range_t<T>::meta_range_t(void){
- /* NOP */
- }
-
- template <typename T> template <typename InputIterator>
- meta_range_t<T>::meta_range_t(
- InputIterator first, InputIterator last
- ):
- std::vector<range_t<T> >(first, last)
- {
- /* NOP */
- }
-
- template <typename T> meta_range_t<T>::meta_range_t(
- const T &start, const T &stop, const T &step
- ):
- std::vector<range_t<T> > (1, range_t<T>(start, stop, step))
- {
- /* NOP */
- }
-
- template <typename T> const T meta_range_t<T>::start(void) const{
- check_meta_range_monotonic(*this);
- T min_start = this->front().start();
- BOOST_FOREACH(const range_t<T> &r, (*this)){
- min_start = std::min(min_start, r.start());
- }
- return min_start;
- }
-
- template <typename T> const T meta_range_t<T>::stop(void) const{
- check_meta_range_monotonic(*this);
- T max_stop = this->front().stop();
- BOOST_FOREACH(const range_t<T> &r, (*this)){
- max_stop = std::max(max_stop, r.stop());
- }
- return max_stop;
- }
-
- template <typename T> const T meta_range_t<T>::step(void) const{
- check_meta_range_monotonic(*this);
- std::vector<T> non_zero_steps;
- range_t<T> last = this->front();
- BOOST_FOREACH(const range_t<T> &r, (*this)){
- //steps at each range
- if (r.step() > T(0)) non_zero_steps.push_back(r.step());
- //and steps in-between ranges
- T ibtw_step = r.start() - last.stop();
- if (ibtw_step > T(0)) non_zero_steps.push_back(ibtw_step);
- //store ref to last
- last = r;
- }
- if (non_zero_steps.empty()) return T(0); //all zero steps, its zero...
- return *std::min_element(non_zero_steps.begin(), non_zero_steps.end());
- }
-
- template <typename T> const T meta_range_t<T>::clip(
- const T &value, bool clip_step
- ) const{
- check_meta_range_monotonic(*this);
- T last_stop = this->front().stop();
- BOOST_FOREACH(const range_t<T> &r, (*this)){
- //in-between ranges, clip to nearest
- if (value < r.start()){
- return (std::abs(value - r.start()) < std::abs(value - last_stop))?
- r.start() : last_stop;
- }
- //in this range, clip here
- if (value <= r.stop()){
- if (not clip_step or r.step() == T(0)) return value;
- return boost::math::round((value - r.start())/r.step())*r.step() + r.start();
- }
- //continue on to the next range
- last_stop = r.stop();
- }
- return last_stop;
- }
-
- template <typename T> const std::string meta_range_t<T>::to_pp_string(void) const{
- std::stringstream ss;
- BOOST_FOREACH(const range_t<T> &r, (*this)){
- ss << r.to_pp_string() << std::endl;
- }
- return ss.str();
- }
-
- UHD_EXIM_TMPL template struct UHD_API meta_range_t<float>;
- UHD_EXIM_TMPL template struct UHD_API meta_range_t<double>;
-
-} //namespace uhd
-
-#endif /* INCLUDED_UHD_TYPES_RANGES_IPP */
diff --git a/host/include/uhd/utils/gain_group.hpp b/host/include/uhd/utils/gain_group.hpp
index c863248ce..c4115f224 100644
--- a/host/include/uhd/utils/gain_group.hpp
+++ b/host/include/uhd/utils/gain_group.hpp
@@ -28,13 +28,16 @@
namespace uhd{
+//! the data type that represents a gain
+typedef double gain_t;
+
/*!
* A set of function to control a gain element.
*/
struct UHD_API gain_fcns_t{
boost::function<gain_range_t(void)> get_range;
- boost::function<float(void)> get_value;
- boost::function<void(float)> set_value;
+ boost::function<gain_t(void)> get_value;
+ boost::function<void(gain_t)> set_value;
};
class UHD_API gain_group : boost::noncopyable{
@@ -56,7 +59,7 @@ public:
* \param name name of the gain element (optional)
* \return a gain value of the element or all elements
*/
- virtual float get_value(const std::string &name = "") = 0;
+ virtual gain_t get_value(const std::string &name = "") = 0;
/*!
* Set the gain value for the gain element specified by name.
@@ -66,7 +69,7 @@ public:
* \param gain the gain to set for the lement or across the group
* \param name name of the gain element (optional)
*/
- virtual void set_value(float gain, const std::string &name = "") = 0;
+ virtual void set_value(gain_t gain, const std::string &name = "") = 0;
/*!
* Get a list of names of registered gain elements.
diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt
index 9ab121df5..43a29df59 100644
--- a/host/lib/CMakeLists.txt
+++ b/host/lib/CMakeLists.txt
@@ -117,6 +117,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
LIBUHD_APPEND_SOURCES(
${CMAKE_CURRENT_BINARY_DIR}/constants.hpp
${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ranges.cpp
${CMAKE_CURRENT_SOURCE_DIR}/types.cpp
${CMAKE_CURRENT_SOURCE_DIR}/version.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wax.cpp
diff --git a/host/lib/ranges.cpp b/host/lib/ranges.cpp
new file mode 100644
index 000000000..0503cc71c
--- /dev/null
+++ b/host/lib/ranges.cpp
@@ -0,0 +1,163 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/types/ranges.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <boost/foreach.hpp>
+#include <algorithm>
+#include <stdexcept>
+#include <sstream>
+
+using namespace uhd;
+
+/***********************************************************************
+ * range_t implementation code
+ **********************************************************************/
+struct range_t::impl{
+ impl(double start, double stop, double step):
+ start(start), stop(stop), step(step)
+ {
+ /* NOP */
+ }
+ double start, stop, step;
+};
+
+range_t::range_t(double value):
+ _impl(UHD_PIMPL_MAKE(impl, (value, value, 0)))
+{
+ /* NOP */
+}
+
+range_t::range_t(
+ double start, double stop, double step
+):
+ _impl(UHD_PIMPL_MAKE(impl, (start, stop, step)))
+{
+ if (stop < start){
+ throw std::invalid_argument("cannot make range where stop < start");
+ }
+}
+
+double range_t::start(void) const{
+ return _impl->start;
+}
+
+double range_t::stop(void) const{
+ return _impl->stop;
+}
+
+double range_t::step(void) const{
+ return _impl->step;
+}
+
+const std::string range_t::to_pp_string(void) const{
+ std::stringstream ss;
+ ss << "(" << this->start();
+ if (this->start() != this->stop()) ss << ", " << this->stop();
+ if (this->step() != 0) ss << ", " << this->step();
+ ss << ")";
+ return ss.str();
+}
+
+/***********************************************************************
+ * meta_range_t implementation code
+ **********************************************************************/
+void check_meta_range_monotonic(const meta_range_t &mr){
+ if (mr.empty()){
+ throw std::runtime_error("meta-range cannot be empty");
+ }
+ for (size_t i = 1; i < mr.size(); i++){
+ if (mr.at(i).start() < mr.at(i-1).stop()){
+ throw std::runtime_error("meta-range is not monotonic");
+ }
+ }
+}
+
+meta_range_t::meta_range_t(void){
+ /* NOP */
+}
+
+meta_range_t::meta_range_t(
+ double start, double stop, double step
+):
+ std::vector<range_t > (1, range_t(start, stop, step))
+{
+ /* NOP */
+}
+
+double meta_range_t::start(void) const{
+ check_meta_range_monotonic(*this);
+ double min_start = this->front().start();
+ BOOST_FOREACH(const range_t &r, (*this)){
+ min_start = std::min(min_start, r.start());
+ }
+ return min_start;
+}
+
+double meta_range_t::stop(void) const{
+ check_meta_range_monotonic(*this);
+ double max_stop = this->front().stop();
+ BOOST_FOREACH(const range_t &r, (*this)){
+ max_stop = std::max(max_stop, r.stop());
+ }
+ return max_stop;
+}
+
+double meta_range_t::step(void) const{
+ check_meta_range_monotonic(*this);
+ std::vector<double> non_zero_steps;
+ range_t last = this->front();
+ BOOST_FOREACH(const range_t &r, (*this)){
+ //steps at each range
+ if (r.step() > 0) non_zero_steps.push_back(r.step());
+ //and steps in-between ranges
+ double ibtw_step = r.start() - last.stop();
+ if (ibtw_step > 0) non_zero_steps.push_back(ibtw_step);
+ //store ref to last
+ last = r;
+ }
+ if (non_zero_steps.empty()) return 0; //all zero steps, its zero...
+ return *std::min_element(non_zero_steps.begin(), non_zero_steps.end());
+}
+
+double meta_range_t::clip(double value, bool clip_step) const{
+ check_meta_range_monotonic(*this);
+ double last_stop = this->front().stop();
+ BOOST_FOREACH(const range_t &r, (*this)){
+ //in-between ranges, clip to nearest
+ if (value < r.start()){
+ return (std::abs(value - r.start()) < std::abs(value - last_stop))?
+ r.start() : last_stop;
+ }
+ //in this range, clip here
+ if (value <= r.stop()){
+ if (not clip_step or r.step() == 0) return value;
+ return boost::math::round((value - r.start())/r.step())*r.step() + r.start();
+ }
+ //continue on to the next range
+ last_stop = r.stop();
+ }
+ return last_stop;
+}
+
+const std::string meta_range_t::to_pp_string(void) const{
+ std::stringstream ss;
+ BOOST_FOREACH(const range_t &r, (*this)){
+ ss << r.to_pp_string() << std::endl;
+ }
+ return ss.str();
+}
diff --git a/host/lib/types.cpp b/host/lib/types.cpp
index 9e4a26c23..8ccb664d5 100644
--- a/host/lib/types.cpp
+++ b/host/lib/types.cpp
@@ -21,7 +21,6 @@
#include <uhd/types/clock_config.hpp>
#include <uhd/types/stream_cmd.hpp>
#include <uhd/types/metadata.hpp>
-#include <uhd/types/ranges.hpp>
#include <uhd/types/time_spec.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/mac_addr.hpp>
@@ -41,14 +40,6 @@
using namespace uhd;
/***********************************************************************
- * ranges template instantiation
- **********************************************************************/
-#ifdef UHD_USE_EXIM_TMPL
-template struct uhd::meta_range_t<float>;
-template struct uhd::meta_range_t<double>;
-#endif
-
-/***********************************************************************
* tune request
**********************************************************************/
tune_request_t::tune_request_t(double target_freq):
diff --git a/host/lib/usrp/dboard/db_xcvr2450.cpp b/host/lib/usrp/dboard/db_xcvr2450.cpp
index e76727bec..6fdac7c6f 100644
--- a/host/lib/usrp/dboard/db_xcvr2450.cpp
+++ b/host/lib/usrp/dboard/db_xcvr2450.cpp
@@ -73,8 +73,8 @@ using namespace boost::assign;
static const bool xcvr2450_debug = false;
static const freq_range_t xcvr_freq_range = list_of
- (range_t<double>(2.4e9, 2.5e9))
- (range_t<double>(4.9e9, 6.0e9))
+ (range_t(2.4e9, 2.5e9))
+ (range_t(4.9e9, 6.0e9))
;
static const prop_names_t xcvr_antennas = list_of("J1")("J2");
@@ -85,9 +85,9 @@ static const uhd::dict<std::string, gain_range_t> xcvr_tx_gain_ranges = map_list
;
static const uhd::dict<std::string, gain_range_t> xcvr_rx_gain_ranges = map_list_of
("LNA", gain_range_t(list_of
- (range_t<float>(0))
- (range_t<float>(15))
- (range_t<float>(30.5))
+ (range_t(0))
+ (range_t(15))
+ (range_t(30.5))
))
("VGA", gain_range_t(0, 62, 2.0))
;
diff --git a/host/lib/utils/gain_group.cpp b/host/lib/utils/gain_group.cpp
index 11bbb8c0a..cba5056ea 100644
--- a/host/lib/utils/gain_group.cpp
+++ b/host/lib/utils/gain_group.cpp
@@ -39,7 +39,7 @@ static bool compare_by_step_size(
* Get a multiple of step with the following relation:
* result = step*floor(num/step)
*
- * Due to small floating-point inaccuracies:
+ * Due to small gain_ting-point inaccuracies:
* num = n*step + e, where e is a small inaccuracy.
* When e is negative, floor would yeild (n-1)*step,
* despite that n*step is really the desired result.
@@ -66,7 +66,7 @@ public:
gain_range_t get_range(const std::string &name){
if (not name.empty()) return _name_to_fcns[name].get_range();
- float overall_min = 0, overall_max = 0, overall_step = 0;
+ gain_t overall_min = 0, overall_max = 0, overall_step = 0;
BOOST_FOREACH(const gain_fcns_t &fcns, get_all_fcns()){
const gain_range_t range = fcns.get_range();
overall_min += range.start();
@@ -78,33 +78,33 @@ public:
return gain_range_t(overall_min, overall_max, overall_step);
}
- float get_value(const std::string &name){
+ gain_t get_value(const std::string &name){
if (not name.empty()) return _name_to_fcns[name].get_value();
- float overall_gain = 0;
+ gain_t overall_gain = 0;
BOOST_FOREACH(const gain_fcns_t &fcns, get_all_fcns()){
overall_gain += fcns.get_value();
}
return overall_gain;
}
- void set_value(float gain, const std::string &name){
+ void set_value(gain_t gain, const std::string &name){
if (not name.empty()) return _name_to_fcns[name].set_value(gain);
std::vector<gain_fcns_t> all_fcns = get_all_fcns();
if (all_fcns.size() == 0) return; //nothing to set!
//get the max step size among the gains
- float max_step = 0;
+ gain_t max_step = 0;
BOOST_FOREACH(const gain_fcns_t &fcns, all_fcns){
max_step = std::max(max_step, fcns.get_range().step());
}
//create gain bucket to distribute power
- std::vector<float> gain_bucket;
+ std::vector<gain_t> gain_bucket;
//distribute power according to priority (round to max step)
- float gain_left_to_distribute = gain;
+ gain_t gain_left_to_distribute = gain;
BOOST_FOREACH(const gain_fcns_t &fcns, all_fcns){
const gain_range_t range = fcns.get_range();
gain_bucket.push_back(floor_step(std::clip(
@@ -131,7 +131,7 @@ public:
//fill in the largest step sizes first that are less than the remainder
BOOST_FOREACH(size_t i, indexes_step_size_dec){
const gain_range_t range = all_fcns.at(i).get_range();
- float additional_gain = floor_step(std::clip(
+ gain_t additional_gain = floor_step(std::clip(
gain_bucket.at(i) + gain_left_to_distribute, range.start(), range.stop()
), range.step()) - gain_bucket.at(i);
gain_bucket.at(i) += additional_gain;
diff --git a/host/test/gain_group_test.cpp b/host/test/gain_group_test.cpp
index dbb585987..79487b2ba 100644
--- a/host/test/gain_group_test.cpp
+++ b/host/test/gain_group_test.cpp
@@ -52,7 +52,7 @@ class gain_element2{
public:
gain_range_t get_range(void){
- return gain_range_t(-20, 10, float(0.1));
+ return gain_range_t(-20, 10, 0.1);
}
float get_value(void){
@@ -94,17 +94,17 @@ static gain_group::sptr get_gain_group(size_t pri1 = 0, size_t pri2 = 0){
/***********************************************************************
* Test cases
**********************************************************************/
-static const float tolerance = float(0.001);
+static const double tolerance = 0.001;
BOOST_AUTO_TEST_CASE(test_gain_group_overall){
gain_group::sptr gg = get_gain_group();
//test the overall stuff
gg->set_value(80);
- BOOST_CHECK_CLOSE(gg->get_value(), float(80), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().start(), float(-20), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().stop(), float(100), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().step(), float(0.1), tolerance);
+ BOOST_CHECK_CLOSE(gg->get_value(), 80, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().start(), -20, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().stop(), 100, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().step(), 0.1, tolerance);
}
BOOST_AUTO_TEST_CASE(test_gain_group_priority){
@@ -112,10 +112,10 @@ BOOST_AUTO_TEST_CASE(test_gain_group_priority){
//test the overall stuff
gg->set_value(80);
- BOOST_CHECK_CLOSE(gg->get_value(), float(80), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().start(), float(-20), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().stop(), float(100), tolerance);
- BOOST_CHECK_CLOSE(gg->get_range().step(), float(0.1), tolerance);
+ BOOST_CHECK_CLOSE(gg->get_value(), 80, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().start(), -20, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().stop(), 100, tolerance);
+ BOOST_CHECK_CLOSE(gg->get_range().step(), 0.1, tolerance);
//test the the higher priority gain got filled first (gain 2)
BOOST_CHECK_CLOSE(g2.get_value(), g2.get_range().stop(), tolerance);
diff --git a/host/test/ranges_test.cpp b/host/test/ranges_test.cpp
index ad61867e1..bbc7f4661 100644
--- a/host/test/ranges_test.cpp
+++ b/host/test/ranges_test.cpp
@@ -24,13 +24,13 @@ using namespace uhd;
static const double tolerance = 0.001;
BOOST_AUTO_TEST_CASE(test_ranges_bounds){
- meta_range_t<double> mr;
- mr.push_back(range_t<double>(-1.0, +1.0, 0.1));
+ meta_range_t mr;
+ mr.push_back(range_t(-1.0, +1.0, 0.1));
BOOST_CHECK_CLOSE(mr.start(), -1.0, tolerance);
BOOST_CHECK_CLOSE(mr.stop(), +1.0, tolerance);
BOOST_CHECK_CLOSE(mr.step(), 0.1, tolerance);
- mr.push_back(range_t<double>(40.0, 60.0, 1.0));
+ mr.push_back(range_t(40.0, 60.0, 1.0));
BOOST_CHECK_CLOSE(mr.start(), -1.0, tolerance);
BOOST_CHECK_CLOSE(mr.stop(), 60.0, tolerance);
BOOST_CHECK_CLOSE(mr.step(), 0.1, tolerance);
@@ -43,9 +43,9 @@ BOOST_AUTO_TEST_CASE(test_ranges_bounds){
}
BOOST_AUTO_TEST_CASE(test_ranges_clip){
- meta_range_t<double> mr;
- mr.push_back(range_t<double>(-1.0, +1.0, 0.1));
- mr.push_back(range_t<double>(40.0, 60.0, 1.0));
+ meta_range_t mr;
+ mr.push_back(range_t(-1.0, +1.0, 0.1));
+ mr.push_back(range_t(40.0, 60.0, 1.0));
BOOST_CHECK_CLOSE(mr.clip(-30.0), -1.0, tolerance);
BOOST_CHECK_CLOSE(mr.clip(70.0), 60.0, tolerance);
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 10:20:48 +0000