pbio/math: Keep implementation in source.

This makes everything easier to find, and ensures that Doxygen does
not ignore them.

We can do things like f4dacb1
when we are 20 bytes short or if there is a major runtime difference.

Author: laurensvalk

lib/pbio/include/pbio/math.h

@@ -14,81 +14,15 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-/**
- * Gets the absolute value.
- *
- * @param [in]  value   The value.
- * @return              The absolute (positive) value.
- */
-static inline int32_t pbio_math_abs(int32_t value) {
-    return __builtin_abs(value);
-}
-
-/**
- * Gets the maximum of two values.
- *
- * @param [in]  a       Value.
- * @param [in]  b       Value.
- * @return              a if it is greater than b, else b.
- */
-static inline int32_t pbio_math_max(int32_t a, int32_t b) {
-    if (a > b) {
-        return a;
-    }
-
-    return b;
-}
-
-/**
- * Gets the minimum of two values.
- *
- * @param [in]  a       Value.
- * @param [in]  b       Value.
- * @return              a if it is less than b, else b.
- */
-static inline int32_t pbio_math_min(int32_t a, int32_t b) {
-    if (a < b) {
-        return a;
-    }
-
-    return b;
-}
-
-/**
- * Get the sign of @p a.
- *
- * @param [in]  a   A signed integer value.
- * @return          1 if @p a is positive, -1 if @p a is negative or 0 if @p a
- *                  is 0.
- */
-static inline int32_t pbio_math_sign(int32_t a) {
-    if (a == 0) {
-        return 0;
-    }
-
-    return a > 0 ? 1 : -1;
-}
-
-/**
- * Checks that the signs of @p a and @p b are not opposite.
- *
- * @param [in]  a   A signed integer value.
- * @param [in]  b   A signed integer value.
- * @return          True if either value is zero or if the signs are the same,
- *                  else false.
- */
-static inline bool pbio_math_sign_not_opposite(int32_t a, int32_t b) {
-    if (a == 0 || b == 0) {
-        return true;
-    }
-
-    return (a > 0) == (b > 0);
-}
-
+bool pbio_math_sign_not_opposite(int32_t a, int32_t b);
+int32_t pbio_math_abs(int32_t value);
 int32_t pbio_math_atan2(int32_t y, int32_t x);
 int32_t pbio_math_bind(int32_t value, int32_t min, int32_t max);
 int32_t pbio_math_clamp(int32_t value, int32_t abs_max);
+int32_t pbio_math_max(int32_t a, int32_t b);
+int32_t pbio_math_min(int32_t a, int32_t b);
 int32_t pbio_math_mult_then_div(int32_t a, int32_t b, int32_t c);
+int32_t pbio_math_sign(int32_t a);
 int32_t pbio_math_sqrt(int32_t n);
 
 #endif // _PBIO_MATH_H_

lib/pbio/src/math.c

@@ -8,6 +8,73 @@
 #include <pbio/math.h>
 #include <pbio/util.h>
 
+/**
+ * Gets the absolute value.
+ *
+ * @param [in]  value   The value.
+ * @return              The absolute (positive) value.
+ */
+int32_t pbio_math_abs(int32_t value) {
+    return __builtin_abs(value);
+}
+
+/**
+ * Gets the maximum of two values.
+ *
+ * @param [in]  a       Value.
+ * @param [in]  b       Value.
+ * @return              a if it is greater than b, else b.
+ */
+int32_t pbio_math_max(int32_t a, int32_t b) {
+    if (a > b) {
+        return a;
+    }
+    return b;
+}
+
+/**
+ * Gets the minimum of two values.
+ *
+ * @param [in]  a       Value.
+ * @param [in]  b       Value.
+ * @return              a if it is less than b, else b.
+ */
+int32_t pbio_math_min(int32_t a, int32_t b) {
+    if (a < b) {
+        return a;
+    }
+    return b;
+}
+
+/**
+ * Get the sign of @p a.
+ *
+ * @param [in]  a   A signed integer value.
+ * @return          1 if @p a is positive, -1 if @p a is negative or 0 if @p a
+ *                  is 0.
+ */
+int32_t pbio_math_sign(int32_t a) {
+    if (a == 0) {
+        return 0;
+    }
+    return a > 0 ? 1 : -1;
+}
+
+/**
+ * Checks that the signs of @p a and @p b are not opposite.
+ *
+ * @param [in]  a   A signed integer value.
+ * @param [in]  b   A signed integer value.
+ * @return          True if either value is zero or if the signs are the same,
+ *                  else false.
+ */
+bool pbio_math_sign_not_opposite(int32_t a, int32_t b) {
+    if (a == 0 || b == 0) {
+        return true;
+    }
+    return (a > 0) == (b > 0);
+}
+
 /**
  * Binds a value between a lower and upper limit.
  *