improved math/misc.hpp

Author: TomSaw

src/modm/math/filter/s_curve_controller_impl.hpp

@@ -19,7 +19,7 @@
 	#error	"Don't include this file directly, use 's_curve_controller.hpp' instead!"
 #endif
 
-
+#include <algorithm>
 #include <modm/math/utils.hpp>
 
 // ----------------------------------------------------------------------------
@@ -113,9 +113,9 @@ modm::SCurveController<T>::update(T error, const T& speed)
 		outputDecrement = std::sqrt(error * parameter.decreaseFactor * 2);
 	}
 
-	output = modm::min(outputIncrement, outputDecrement);
+	output = std::min(outputIncrement, outputDecrement);
 	// TODO smooth breaking if the speedMaximum has changed to a lower value
-	output = modm::min(output, parameter.speedMaximum);
+	output = std::min(output, parameter.speedMaximum);
 
 	if (output < parameter.speedMinimum) {
 		output = parameter.speedMinimum;

src/modm/math/utils/misc.hpp

@@ -4,6 +4,7 @@
  * Copyright (c) 2011-2012, 2014-2015, Niklas Hauser
  * Copyright (c) 2015, Sascha Schade
  * Copyright (c) 2020, Christopher Durand
+ * Copyright (c) 2022, Thomas Sommer
  *
  * This file is part of the modm project.
  *
@@ -13,13 +14,13 @@
  */
 // ----------------------------------------------------------------------------
 
-#ifndef	MODM_MATH_UTILS_MISC_HPP
-#define	MODM_MATH_UTILS_MISC_HPP
+#pragma once
 
 #include <cstddef>
 #include <cmath>
 #include <stdint.h>
 #include <type_traits>
+#include <utility>
 
 #include <modm/architecture/utils.hpp>
 
@@ -56,74 +57,58 @@ pow(uint32_t base, uint8_t exponent)
 }
 
 /**
- * This does what you think it does.
+ * @brief 		Variadic min for 2-∞ objects
+ *
+ * @param  a 	first object to compare
+ * @param  b  	second object to compare
+ * @param  cs  	Further objects for comparison
  *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
- * @return   The lesser of the parameters.
+ * @return   	The smallest object
  *
- * This is the simple classic generic implementation.  It will work on
- * temporary expressions, since they are only evaluated once, unlike a
- * preprocessor macro.
+ * @see			https://stackoverflow.com/questions/23815138/implementing-variadic-min-max-functions
  */
 template<typename T>
-inline const T&
-min(const T& a, const T& b)
+constexpr T vmin(T a, T b)
 {
-	if (b < a)
-		return b;
-	else
-		return a;
+    return a < b ? a : b;
 }
 
-/**
- * This does what you think it does.
- *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
- * @return   The greater of the parameters.
- *
- * This is the simple classic generic implementation.  It will work on
- * temporary expressions, since they are only evaluated once, unlike a
- * preprocessor macro.
- */
-template<typename T>
-inline const T&
-max(const T& a, const T& b)
+template<typename T, typename... Ts>
+constexpr T vmin(T a, T b, Ts&&... cs)
 {
-	if (a < b)
-		return b;
-	else
-		return a;
+    return a < b ? vmin(a, cs...) : vmin(b, cs...);
 }
 
 /**
  * This does what you think it does.
  *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
- * @param  c  Something else of arbitrary type.
- * @return   The greater of the three parameters.
+ * @param  a 	first object to compare
+ * @param  b  	second object to compare
+ * @param  cs  	Further objects to compare
  *
- * This is the simple classic generic implementation.  It will work on
- * temporary expressions, since they are only evaluated once, unlike a
- * preprocessor macro.
+ * @return   	The biggest object
+ *
+ * @see			https://stackoverflow.com/questions/23815138/implementing-variadic-min-max-functions
  */
 template<typename T>
-constexpr T
-max(const T a, const T b, const T c)
+constexpr T vmax(T& a, T& b)
 {
-	return ( ( (b > c) ? b : c ) > a ) ?
-	         ( (b > c) ? b : c) : a;
+    return a > b ? a : b;
+}
+
+template<typename T, typename... Ts>
+constexpr T vmax(T& a, T& b, Ts&... cs)
+{
+    return a > b ? vmax(a, cs...) : vmax(b, cs...);
 }
 
 /**
  * This does what you think it does.
  *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
+ * @param  a		A thing of arbitrary type.
+ * @param  b		Another thing of arbitrary type.
  * @param  compare  A comparison functor.
- * @return   The lesser of the parameters.
+ * @return   		The lesser of the parameters.
  *
  * This will work on temporary expressions, since they are only evaluated
  * once, unlike a preprocessor macro.
@@ -132,19 +117,16 @@ template<typename T, typename Compare>
 inline const T&
 min(const T& a, const T& b, Compare compare)
 {
-	if (compare(b, a))
-		return b;
-	else
-		return a;
+	return compare(b, a) ? b : a;
 }
 
 /**
  * This does what you think it does.
  *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
- * @param  compare  A comparison functor.
- * @return   The greater of the parameters.
+ * @param  a		A thing of arbitrary type.
+ * @param  b		Another thing of arbitrary type.
+ * @param  compare	A comparison functor.
+ * @return			The greater of the parameters.
  *
  * This will work on temporary expressions, since they are only evaluated
  * once, unlike a preprocessor macro.
@@ -153,25 +135,16 @@ template<typename T, typename Compare>
 inline const T&
 max(const T& a, const T& b, Compare compare)
 {
-	if (compare(a, b))
-		return b;
-	else
-		return a;
+	return compare(a, b) ? b : a;
 }
 
 /// constexpr implementation of fabs
-template <typename Float>
-    requires std::is_floating_point_v<Float>
+template <std::floating_point Float>
 constexpr Float constexpr_fabs(Float number)
 {
-    if (number >= 0) {
-        return number;
-    } else {
-        return -number;
-    }
+	return number >= 0 ? number : -number;
 }
 
 /// @}
-}	// namespace modm
 
-#endif
+} // namespace modm