uhd: replaced templated ranges with one range thing using doubles only to avoid trouble with compiler portability

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);