Place fixed_point class in namespaces

Author: ckormanyos

ref_app/src/app/benchmark/app_benchmark_fixed_point.cpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-//  Copyright Christopher Kormanyos 2010 - 2019.
+//  Copyright Christopher Kormanyos 2010 - 2025.
 //  Distributed under the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt
 //  or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,7 @@
 
 namespace
 {
-  using fixed_point_type = fixed_point<std::int32_t>;
+  using fixed_point_type = ::math::fixed::fixed_point<std::int32_t>;
 }
 
 extern fixed_point_type global_a;

ref_app/src/math/fixed_point/fixed_point.h

@@ -23,6 +23,19 @@
     #include <ostream>
   #endif
 
+  namespace math { namespace fixed {
+
+  // Forward declaration of the fixed_point template class.
+  template<typename integer_type>
+  class fixed_point;
+
+  } // namespace fixed
+  } // namespace math
+
+  namespace math { namespace fixed {
+
+  namespace detail {
+
   // Utility structure to help with the epsilon limits for fixed_point.
   // These special numbers represent the smallest value for a decimal part
   // that differs from 1 for the corresponding decimal-part width.
@@ -32,9 +45,7 @@
   template<>                  struct epsilon_helper<16U> { static const std::size_t epsilon_value = std::size_t(7U); };
   template<>                  struct epsilon_helper<32U> { static const std::size_t epsilon_value = std::size_t(44U); };
 
-  // Forward declaration of the fixed_point template class.
-  template<typename integer_type>
-  class fixed_point;
+  } // namespace detail
 
   // The scalable fixed_point template class.
   template<typename integer_type>
@@ -322,7 +333,7 @@
     static fixed_point value_max         () { return fixed_point(internal(), signed_value_type((unsigned_value_type(-1LL) - 1U) / 2U)); }
     static fixed_point value_min         () { return fixed_point(internal(), signed_value_type(2L)); }
     static fixed_point value_half        () { return fixed_point(internal(), signed_value_type(1ULL << (decimal_split - 1U))); }
-    static fixed_point value_eps         () { return fixed_point(internal(), signed_value_type(epsilon_helper<decimal_split>::epsilon_value)); }
+    static fixed_point value_eps         () { return fixed_point(internal(), signed_value_type(detail::epsilon_helper<decimal_split>::epsilon_value)); }
     static fixed_point value_pi          () { return fixed_point(internal(), signed_value_type(0x3243f6A88ULL >> (32U - decimal_split))); }
     static fixed_point value_pi_half     () { return fixed_point(internal(), signed_value_type(0x1921FB544ULL >> (32U - decimal_split))); }
     static fixed_point value_two_over_pi () { return fixed_point(internal(), signed_value_type(0x0A2F98370ULL >> (32U - decimal_split))); }
@@ -545,6 +556,11 @@
     template<typename other_signed_type> friend inline bool operator> (const fixed_point<other_signed_type>& b, const fixed_point& a) { return (std::int_least8_t(-a.cmp(b)) >  std::int_least8_t(0)); }
 
     // Include a few global sample fixed_point functions.
+    friend inline int fpclassify(const fixed_point& x)
+    {
+      return (x.data == signed_value_type(0) ? FP_ZERO : FP_NORMAL);
+    }
+
     friend inline fixed_point fabs(const fixed_point& x)
     {
       return fixed_point(internal(), (x.data < signed_value_type(0) ? -x.data : x.data));
@@ -941,11 +957,14 @@
     #endif // !FIXED_POINT_DISABLE_IOSTREAM
   };
 
+  } // namespace fixed
+  } // namespace math
+
   // Define the four scalable fixed_point types.
-  typedef fixed_point<std::int8_t>  fixed_point_3pt4;
-  typedef fixed_point<std::int16_t> fixed_point_7pt8;
-  typedef fixed_point<std::int32_t> fixed_point_15pt16;
-  typedef fixed_point<std::int64_t> fixed_point_31pt32;
+  typedef math::fixed::fixed_point<std::int8_t>  fixed_point_3pt4;
+  typedef math::fixed::fixed_point<std::int16_t> fixed_point_7pt8;
+  typedef math::fixed::fixed_point<std::int32_t> fixed_point_15pt16;
+  typedef math::fixed::fixed_point<std::int64_t> fixed_point_31pt32;
 
   namespace std
   {
@@ -956,6 +975,8 @@
     template<> class numeric_limits<fixed_point_31pt32> : public fixed_point_31pt32::my_numeric_limits { };
   }
 
+  namespace math { namespace fixed {
+
   // Include a few more global sample fixed_point functions.
   template<typename fixed_point_type>
   inline fixed_point_type sqrt(const fixed_point_type& x) { return fixed_point_type(x).calculate_sqrt(); }
@@ -973,4 +994,7 @@
     return sqrt<fixed_point_type>((x * x) + (y * y));
   }
 
+  } // namespace fixed
+  } // namespace math
+
 #endif // FIXED_POINT_2011_02_22_H