unsgined scaling

Author: TomSaw

src/modm/math/filter/s_curve_controller_impl.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) 2021, Thomas Sommer
  *
  * This file is part of the modm project.
  *
@@ -60,65 +61,51 @@ pow(uint32_t base, uint8_t exponent)
 }
 
 /**
- * @brief This does what you think it does.
- *
- * @param  a  A thing of arbitrary type.
- * @param  b  Another thing of arbitrary type.
- * @return   The lesser of the parameters.
+ * @brief 		Variadic min for 2-∞ objects
  *
- * This is the simple classic generic implementation.  It will work on
- * temporary expressions, since they are only evaluated once, unlike a
- * preprocessor macro.
+ * @param  a 	first object to compare
+ * @param  b  	second object to compare
+ * @param  cs  	More optional objects to compare
+ * @return   	The smallest object
+ * 
+ * @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;
 }
 
-/**
- * @brief 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, std::forward<Ts>(cs)...) : 
+            vmin(b, std::forward<Ts>(cs)...);
 }
 
 /**
- * @brief This does what you think it does.
+ * @brief 		Variadic max for 2-∞ objects
  *
- * @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.
- *
- * This is the simple classic generic implementation.  It will work on
- * temporary expressions, since they are only evaluated once, unlike a
- * preprocessor macro.
+ * @param  a 	first object to compare
+ * @param  b  	second object to compare
+ * @param  cs  	More optional objects to compare
+ * @return   	The greatest 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 a > b ? a : b;
+}
+
+template<typename T, typename... Ts>
+constexpr T vmax(T& a, T& b, Ts&... cs)
 {
-	return ( ( (b > c) ? b : c ) > a ) ?
-	         ( (b > c) ? b : c) : a;
+    return a > b ?
+        vmax(a, std::forward<Ts>(cs)...) : 
+            vmax(b, std::forward<Ts>(cs)...);
 }
 
 /**
@@ -136,10 +123,7 @@ 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;
 }
 
 /**
@@ -157,24 +141,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;
 }
 
 /**
  * @brief 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;
 }
 
 /// @}

src/modm/ui/color/concepts.hpp

@@ -1,7 +1,17 @@
+/*
+ * Copyright (c) 2021, Thomas Sommer
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
 #pragma once
 
 #include <bit>
-#include <modm/ui/shape/point.hpp>
 
 namespace modm::color {
 
@@ -28,7 +38,7 @@ template<class C>
 concept ColorGray = is_instance<C, GrayD>::value;
 
 template<class C>
-concept ColorGrayBase2 = ColorGray<C> && std::popcount(unsigned(C::Wide)) == 1;
+concept ColorGrayBase2 = ColorGray<C> && std::popcount(unsigned(C::Digits)) == 1;
 
 template<class C>
 concept ColorRgb = is_instance<C, RgbD>::value;
@@ -43,15 +53,4 @@ template<class C>
 // concept Color = std::convertible_to<C, RgbD<8,8,8> >; // convertability
 concept Color = ColorGray<C> || ColorRgb<C> || ColorHsv<C> || ColorRgbStacked<C>; // conjunction of types
 
-/**
- * @brief 		Concept for a function or functor, that returns a Color for a Point
- * 
- * @tparam F 
- */
-template <typename F>
-concept ColorPattern = requires(F p)
-{
-    { p.operator()(modm::shape::Point()) } -> Color; // -> std::convertible_to<modm::color::Rgb888>;
-};
-
 }