Continue moving math calls to utilities

3 files changed, 170 insertions, 35 deletions

diff --git a/GcodeProcessorLib/gcode_position.cpp b/GcodeProcessorLib/gcode_position.cpp
index 444a879..daf66e4 100644
--- a/GcodeProcessorLib/gcode_position.cpp
+++ b/GcodeProcessorLib/gcode_position.cpp
@@ -616,7 +616,7 @@ void gcode_position::update(parsed_command& command, const long file_line_number
 			{
 				double r;
 				r = snapshot_x_max_; // good stand in for radius
-				const double dist = sqrt(p_current_pos->x*p_current_pos->x + p_current_pos->y*p_current_pos->y);
+				const double dist = utilities::sqrt(p_current_pos->x*p_current_pos->x + p_current_pos->y*p_current_pos->y);
 				is_in_bounds = utilities::less_than_or_equal(dist, r);
 
 			}
diff --git a/GcodeProcessorLib/utilities.cpp b/GcodeProcessorLib/utilities.cpp
index c1ac9fc..c53ddf8 100644
--- a/GcodeProcessorLib/utilities.cpp
+++ b/GcodeProcessorLib/utilities.cpp
@@ -38,11 +38,11 @@ namespace utilities {
 
 bool utilities::is_zero(double x, double tolerance)
 {
-	return fabs(x) < tolerance;
+	return utilities::abs(x) < tolerance;
 }
 bool utilities::is_zero(double x)
 {
-	return fabs(x) < ZERO_TOLERANCE;
+	return utilities::abs(x) < ZERO_TOLERANCE;
 }
 
 int utilities::round_up_to_int(double x, double tolerance)
@@ -57,13 +57,13 @@ int utilities::round_up_to_int(double x)
 
 bool utilities::is_equal(double x, double y, double tolerance)
 {
-	double abs_difference = fabs(x - y);
+	double abs_difference = utilities::abs(x - y);
 	return abs_difference < tolerance;
 }
 
 bool utilities::is_equal(double x, double y)
 {
-	double abs_difference = fabs(x - y);
+	double abs_difference = utilities::abs(x - y);
 	return abs_difference < ZERO_TOLERANCE;
 }
 
@@ -114,7 +114,7 @@ double utilities::get_cartesian_distance(double x1, double y1, double x2, double
 	double xdif = x1 - x2;
 	double ydif = y1 - y2;
 	double dist_squared = xdif * xdif + ydif * ydif;
-	return sqrt(dist_squared);
+	return utilities::sqrt(dist_squared);
 }
 
 double utilities::get_cartesian_distance(double x1, double y1, double z1, double x2, double y2, double z2)
@@ -124,30 +124,30 @@ double utilities::get_cartesian_distance(double x1, double y1, double z1, double
 	double ydif = y1 - y2;
 	double zdif = z1 - z2;
 	double dist_squared = xdif * xdif + ydif * ydif + zdif * zdif;
-	return sqrt(dist_squared);
+	return utilities::sqrt(dist_squared);
 }
 
 double utilities::get_arc_distance(double x1, double y1, double z1, double x2, double y2, double z2, double i, double j, double r, bool is_clockwise)
 {
 	double center_x = x1 - i;
 	double center_y = y1 - j;
-	double radius = hypot(i, j);
+	double radius = utilities::hypot(i, j);
 	double z_dist = z2 - z1;
 	double rt_x = x2 - center_x;
 	double rt_y = y2 - center_y;
-	double angular_travel_total = atan2(i * rt_y - j * rt_x, i * rt_x + j * rt_y);
-	if (angular_travel_total < 0) { angular_travel_total += (double)(2.0 * PI_DOUBLE); }
+	double angular_travel_total = utilities::atan2(i * rt_y - j * rt_x, i * rt_x + j * rt_y);
+	if (angular_travel_total < 0) { angular_travel_total += 2.0 * PI_DOUBLE; }
 	// Adjust the angular travel if the direction is clockwise
-	if (is_clockwise) { angular_travel_total -= (float)(2 * PI_DOUBLE); }
+	if (is_clockwise) { angular_travel_total -= 2.0 * PI_DOUBLE; }
 	// Full circle fix.
 	if (x1 == x2 && y1 == y2 && angular_travel_total == 0)
 	{
-		angular_travel_total += (float)(2 * PI_DOUBLE);
+		angular_travel_total += 2.0 * PI_DOUBLE;
 	}
 
 	// 20200417 - FormerLurker - rename millimeters_of_travel to millimeters_of_travel_arc to better describe what we are
 	// calculating here
-	return hypot(angular_travel_total * radius, fabs(z_dist));
+	return utilities::hypot(angular_travel_total * radius, utilities::abs(z_dist));
 
 }
 
@@ -298,7 +298,7 @@ std::string utilities::get_percent_change_string(int v1, int v2, int precision)
 
 int utilities::get_num_digits(int x)
 {
-	x = (int)abs(x);
+	x = utilities::abs(x);
 	return (x < 10 ? 1 :
 		(x < 100 ? 2 :
 			(x < 1000 ? 3 :
@@ -314,8 +314,8 @@ int utilities::get_num_digits(int x)
 int utilities::get_num_digits(double x, int precision)
 {
 	return get_num_digits(
-		(int)ceil(x * pow(10, (double)precision) - .4999999999999)
-		/ pow(10, (double)precision)
+		(int)utilities::ceil(x * utilities::pow(10, precision) - .4999999999999)
+		/ utilities::pow(10, precision)
 	);
 }
 
@@ -398,7 +398,20 @@ double utilities::hypot(double x, double y)
 	}
 	if (y == 0.0) return x;
 	y /= x;
-	return x * sqrt(1.0 + y * y);
+	return x * utilities::sqrt(1.0 + y * y);
+}
+
+float utilities::hypotf(float x, float y)
+{
+	if (x < 0.0f) x = -x;
+	if (y < 0.0f) y = -y;
+	if (x < y) {
+		float tmp = x;
+		x = y; y = tmp;
+	}
+	if (y == 0.0f) return x;
+	y /= x;
+	return x * utilities::sqrtf(1.0f + y * y);
 }
 
 double utilities::atan2(double y, double x)
@@ -406,7 +419,7 @@ double utilities::atan2(double y, double x)
 	return std::atan2(y, x);
 }
 
-double utilities::atan2f(double y, double x)
+float utilities::atan2f(float y, float x)
 {
 	return std::atan2(y, x);
 }
@@ -416,7 +429,7 @@ double utilities::floor(double x)
 	return std::floor(x);
 }
 
-double utilities::floorf(double x)
+float utilities::floorf(float x)
 {
 	return std::floor(x);
 }
@@ -426,22 +439,27 @@ double utilities::ceil(double x)
 	return std::ceil(x);
 }
 
+float utilities::ceilf(float x)
+{
+	return std::ceil(x);
+}
+
 double utilities::cos(double x)
 {
 	return std::cos(x);
 }
 
-double utilities::sin(double x)
+float utilities::cosf(float x)
 {
-	return std::sin(x);
+	return std::cos(x);
 }
 
-double utilities::cosf(double x)
+double utilities::sin(double x)
 {
-	return std::cos(x);
+	return std::sin(x);
 }
 
-double utilities::sinf(double x)
+float utilities::sinf(float x)
 {
 	return std::sin(x);
 }
@@ -451,12 +469,22 @@ double utilities::abs(double x)
 	return std::abs(x);
 }
 
+int utilities::abs(int x)
+{
+	return std::abs(x);
+}
+
+float utilities::absf(float x)
+{
+	return std::abs(x);
+}
+
 double utilities::fabs(double x)
 {
 	return std::fabs(x);
 }
 
-double utilities::fabsf(double x)
+float utilities::fabsf(float x)
 {
 	return std::fabs(x);
 }
@@ -466,7 +494,7 @@ double utilities::sqrt(double x)
 	return std::sqrt(x);
 }
 
-double utilities::sqrtf(double x)
+float utilities::sqrtf(float x)
 {
 	return std::sqrt(x);
 }
@@ -476,11 +504,81 @@ double utilities::pow(int e, double x)
 	return std::pow(e, x);
 }
 
-double utilities::min(float x, float y)
+double utilities::pow(int e, int x)
+{
+	return std::pow(e, x);
+}
+
+double utilities::min(double x, double y)
+{
+	return std::min(x, y);
+}
+
+float utilities::minf(float x, float y)
 {
 	return std::min(x, y);
 }
 
+double utilities::max(double x, double y)
+{
+	return std::max(x, y);
+}
+
+float utilities::maxf(float x, float y)
+{
+	return std::max(x, y);
+}
+
+double utilities::radians(double x)
+{
+	return (x * PI_DOUBLE) / 180.0;
+}
+
+float utilities::radiansf(float x)
+{
+	return (x * PI_FLOAT) / 180.0f;
+}
+
+double utilities::sq(double x)
+{
+	return x * x;
+}
+
+float utilities::sqf(float x)
+{
+	return x * x;
+}
+
+bool utilities::within(double value, double min, double max)
+{
+	return ((value) >= (min) && (value) <= (max));
+}
+
+bool utilities::withinf(float value, float min, float max)
+{
+	return ((value) >= (min) && (value) <= (max));
+}
+
+double utilities::constrain(double value, double arg_min, double arg_max)
+{
+	return ((value) < (arg_min) ? (arg_min) : ((value) > (arg_max) ? (arg_max) : (value)));
+}
+
+float utilities::constrainf(float value, float arg_min, float arg_max)
+{
+	return ((value) < (arg_min) ? (arg_min) : ((value) > (arg_max) ? (arg_max) : (value)));
+}
+
+double utilities::reciprocal(double x)
+{
+	return 1.0 / x;
+}
+
+float utilities::reciprocalf(float x)
+{
+	return 1.0f / x;
+}
+
 void* utilities::memcpy(void* dest, const void* src, size_t n)
 {
 	return std::memcpy(dest, src, n);
diff --git a/GcodeProcessorLib/utilities.h b/GcodeProcessorLib/utilities.h
index 7e2f80b..88e8c40 100644
--- a/GcodeProcessorLib/utilities.h
+++ b/GcodeProcessorLib/utilities.h
@@ -38,6 +38,7 @@
 // retract enough while wiping.
 #define ZERO_TOLERANCE 0.000005
 #define PI_DOUBLE 3.14159265358979323846264338327950288
+#define PI_FLOAT 3.14159265358979323846264338327950288f
 
 namespace utilities{
 	extern const std::string WHITESPACE_;
@@ -107,38 +108,74 @@ namespace utilities{
 	bool get_temp_file_path_for_file(const std::string& file_path, std::string& temp_file_path);
 
 	double hypot(double x, double y);
+	
+	float hypotf(float x, float y);
 
 	double atan2(double y, double x);
 
-	double atan2f(double y, double x);
+	float atan2f(float y, float x);
 
 	double floor(double x);
 
-	double floorf(double x);
+	float floorf(float x);
 
 	double ceil(double x);
+	
+	float ceilf(float x);
 
 	double cos(double x);
 
-	double sin(double x);
+	float cosf(float x);
 
-	double cosf(double x);
+	double sin(double x);
 
-	double sinf(double x);
+	float sinf(float x);
 
 	double abs(double x);
 
+	int abs(int x);
+
+	float absf(float x);
+
 	double fabs(double x);
 
-	double fabsf(double x);
+	float fabsf(float x);
 
 	double sqrt(double x);
 
-	double sqrtf(double x);
+	float sqrtf(float x);
 
 	double pow(int e, double x);
 
-	double min(float x, float y);
+	double pow(int e, int x);
+
+	double min(double x, double y);
+	
+	float minf(float x, float y);
+	
+	double max(double x, double y);
+	
+	float maxf(float x, float y);
+
+	double radians(double x);
+	
+	float radiansf(float x);
+
+	double sq(double x);
+
+	float sqf(float x);
+
+	bool within(double n, double l, double h);
+
+	bool withinf(float n, float l, float h);
+
+	double constrain(double value, double arg_min, double arg_max);
+
+	float constrainf(float value, float arg_min, float arg_max);
+
+	double reciprocal(double x);
+
+	float reciprocalf(float x);
 
 	void* memcpy(void* dest, const void* src, size_t n);