[math] percent_t unit can be float since C++20

Author: salkinium

src/modm/math/units.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Niklas Hauser
+ * Copyright (c) 2019, 2024, Niklas Hauser
  *
  * This file is part of the modm project.
  *
@@ -36,7 +36,7 @@ namespace modm
 	template<typename T> constexpr bitrate_t kbps(T value);
 	template<typename T> constexpr bitrate_t Mbps(T value);
 
-	using percent_t = uint16_t;
+	using percent_t = float;
 	template<typename T> constexpr percent_t pct(T value);
 	/// @}
 
@@ -63,8 +63,7 @@ namespace modm
 
 #else
 
-#define MODM_LITERAL_DEFINITION(type, name, symbol) \
-namespace modm { \
+#define MODM_UNITS_LITERAL_DEFINITION(type, name, symbol) \
 using MODM_CONCAT(name, _t) = type; \
 template<typename T> constexpr MODM_CONCAT(name, _t) symbol(T value) { return value; } \
 template<typename T> constexpr MODM_CONCAT(name, _t) MODM_CONCAT(k, symbol)(T value) { return value * 1'000ul; } \
@@ -75,16 +74,19 @@ namespace literals { \
 	constexpr MODM_CONCAT(name, _t) MODM_CONCAT(operator""_k, symbol)(long double value)            { return MODM_CONCAT(k, symbol)(value); } \
 	constexpr MODM_CONCAT(name, _t) MODM_CONCAT(operator""_M, symbol)(unsigned long long int value) { return MODM_CONCAT(M, symbol)(value); } \
 	constexpr MODM_CONCAT(name, _t) MODM_CONCAT(operator""_M, symbol)(long double value)            { return MODM_CONCAT(M, symbol)(value); } \
-}}
+}
+
+namespace modm
+{
 
-MODM_LITERAL_DEFINITION(uint32_t, frequency, Hz)
-MODM_LITERAL_DEFINITION(uint32_t, baudrate, Bd)
-MODM_LITERAL_DEFINITION(uint32_t, bitrate, bps)
+MODM_UNITS_LITERAL_DEFINITION(uint32_t, frequency, Hz)
+MODM_UNITS_LITERAL_DEFINITION(uint32_t, baudrate, Bd)
+MODM_UNITS_LITERAL_DEFINITION(uint32_t, bitrate, bps)
 
-namespace modm {
-enum class percent_t : uint16_t {};
-template<typename T> constexpr percent_t pct(T value) { return percent_t(uint16_t(value * 600ul)); }
-constexpr float pct2f(percent_t value) { return uint16_t(value) / 60'000.f; }
+using percent_t = float;
+template<typename T> constexpr percent_t pct(T value) { return value / 100.f; }
+// DEPRECATED: 2025q1
+modm_deprecated("Access the value directly.") constexpr float pct2f(percent_t value) { return value; }
 namespace literals
 {
 	constexpr percent_t operator""_pct(long double value) { return pct(value); }

src/modm/math/units.lb

@@ -45,25 +45,20 @@ bitrate_t bitrate = modm::kbps(125);
 frequency = 4295_MHz; // OVERFLOW at 2^32 units!
 ```
 
-## Integral Percentages
 
-Since `float` cannot be used as a non-type template argument, an integer type
-for providing tolerances in `percent_t` is available.
-Note that `percent_t` is implemented as an enum class, which prevents implicit
-conversions, since the base for this is not 1.
-You must therefore use the `modm::pct(T value)` or `_pct` constructors.
+## Percentages
+
+Percentages are stored as normalized floating point numbers and can be converted
+using these convenience constructors:
 
 ```cpp
 using namespace modm::literals;
 
 percent_t tolerance = modm::pct(10);
           tolerance = 10_pct;
-
-// convert back to float. *internal use only*
-float percent = modm::pct2f(tolerance);
+          tolerance = 0.1f;
 ```
 
-!!! warning "This type is not guaranteed to hold more than 100 percent!"
 
 """
 

src/modm/platform/can/common/can_bit_timings.hpp

@@ -115,7 +115,7 @@ class CanBitTiming
 	template<percent_t tolerance>
 	static constexpr void assertBitrateInTolerance()
 	{
-		static_assert(pct2f(tolerance) >= BestConfig.error,
+		static_assert(tolerance >= BestConfig.error,
 			"The closest available bitrate exceeds the specified maximum tolerance!");
 	}
 

src/modm/platform/i2c/sam_x7x/i2c_master.hpp.in

@@ -61,7 +61,7 @@ private:
 		const float freq = 1.f / (tHigh + tLow);
 		const float error = std::fabs(1.f - freq / baudrate);
 
-		return error < pct2f(tolerance);
+		return error < tolerance;
 	}
 
 	template<class SystemClock, baudrate_t baudrate, percent_t tolerance>

src/modm/platform/i2c/stm32-extended/i2c_timing_calculator.hpp

@@ -97,7 +97,7 @@ class I2cTimingCalculator
 				float speed = calculateSpeed(prescaler, sclLow, sclHigh);
 				auto error = std::fabs((speed / params.targetSpeed) - 1.0f);
 				// modm::Tolerance value is in unit [1/1000]
-				if ((error < pct2f(params.tolerance)) && (error <= lastError) && (prescaler <= bestPrescaler)) {
+				if ((error < params.tolerance) && (error <= lastError) && (prescaler <= bestPrescaler)) {
 					lastError = error;
 					bestPrescaler = prescaler;
 					bestSclLow = sclLow;
@@ -290,7 +290,7 @@ class I2cTimingCalculator
 		auto clockPeriod = float(prescaler + 1) / params.peripheralClock;
 
 		auto targetSclTime = 1.f / params.targetSpeed;
-		auto sclTimeMax = targetSclTime * (1.f + pct2f(params.tolerance));
+		auto sclTimeMax = targetSclTime * (1.f + params.tolerance);
 		auto maxSclSum = ((sclTimeMax - params.riseTime - params.fallTime - 2*SyncTime)
 				/ clockPeriod) - 2;