Use std::min()/std::max() where it improves readability.

Author: hzeller

.clang-tidy

@@ -27,6 +27,7 @@ Checks: >
   performance-*,
   -performance-enum-size,
   readability-*,
+  -readability-avoid-unconditional-preprocessor-if,
   -readability-braces-around-statements,
   -readability-convert-member-functions-to-static,
   -readability-else-after-return,

src/common/linebuf-reader_test.cc

@@ -44,7 +44,7 @@ class InputStreamSimulator {
     for (const char *line : kSampleLines) {
       if (line == nullptr) break;
       buffer_.append(line).append(endline);
-      if (strlen(line) > longest_line_len_) longest_line_len_ = strlen(line);
+      longest_line_len_ = std::max(strlen(line), longest_line_len_);
     }
   }
 

src/determine-print-stats.cc

@@ -23,6 +23,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <algorithm>
 #include <cstring>
 
 #include "gcode-machine-control.h"
@@ -79,8 +80,8 @@ class StatsCollectingEventDelegator : public GCodeParser::EventReceiver {
 
  private:
   static void set_min_max(float value, float *min, float *max) {
-    if (value < *min) *min = value;
-    if (value > *max) *max = value;
+    *min = std::min(value, *min);
+    *max = std::max(value, *max);
   }
   void update_coordinate_stats(const AxesRegister &axis) {
     set_min_max(axis[AXIS_X], &stats_->x_min, &stats_->x_max);
@@ -104,7 +105,7 @@ class StatsSegmentQueue : public SegmentQueue {
     int max_steps = 0;
     for (int i = 0; i < BEAGLEG_NUM_MOTORS; ++i) {
       const int steps = abs(param.steps[i]);
-      if (steps > max_steps) max_steps = steps;
+      max_steps = std::max(steps, max_steps);
     }
 
     // max_steps = a/2*t^2 + v0*t; a = (v1-v0)/t

src/gcode-machine-control.cc

@@ -34,6 +34,7 @@
 #include <time.h>
 #include <unistd.h>
 
+#include <algorithm>
 #include <string>
 
 #include "adc.h"
@@ -218,9 +219,8 @@ bool GCodeMachineControl::Impl::Init() {
   }
 
   for (const GCodeParserAxis axis : AllAxes()) {
-    if (cfg_.max_feedrate[axis] > g0_feedrate_mm_per_sec_) {
-      g0_feedrate_mm_per_sec_ = cfg_.max_feedrate[axis];
-    }
+    g0_feedrate_mm_per_sec_ =
+      std::max(cfg_.max_feedrate[axis], g0_feedrate_mm_per_sec_);
   }
   prog_speed_factor_ = 1.0f;
 
@@ -992,7 +992,7 @@ int GCodeMachineControl::Impl::move_to_probe(enum GCodeParserAxis axis,
   int total_movement = 0;
   float v0 = 0;
   float v1 = feedrate;
-  if (v1 > cfg_.max_probe_feedrate[axis]) v1 = cfg_.max_probe_feedrate[axis];
+  v1 = std::min(v1, cfg_.max_probe_feedrate[axis]);
   while (!hardware_mapping_->TestProbeSwitch()) {
     total_movement += planner_->DirectDrive(axis, dir * kProbeMM, v0, v1);
     v0 = v1;  // TODO: possibly acceleration over multiple segments.

src/gcode-print-stats.cc

@@ -23,6 +23,8 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <algorithm>
+
 #include "common/logging.h"
 #include "config-parser.h"
 #include "determine-print-stats.h"
@@ -115,7 +117,7 @@ int main(int argc, char *argv[]) {
   int longest_filename = strlen("#[filename]");  // table header
   for (int i = optind; i < argc; ++i) {
     const int len = strlen(argv[i]);
-    if (len > longest_filename) longest_filename = len;
+    longest_filename = std::max(len, longest_filename);
   }
   if (print_header) {
     printf("%-*s %10s %7s %7s %7s %7s %7s %7s %7s %7s\n", longest_filename,

src/gcode2ps.cc

@@ -119,12 +119,12 @@ class AxesRange {
 
   // Update with a range we should cover at least.
   void Update(const AxesRegister &axes) {
-    if (axes[AXIS_X] < min_[AXIS_X]) min_[AXIS_X] = axes[AXIS_X];
-    if (axes[AXIS_Y] < min_[AXIS_Y]) min_[AXIS_Y] = axes[AXIS_Y];
-    if (axes[AXIS_Z] < min_[AXIS_Z]) min_[AXIS_Z] = axes[AXIS_Z];
-    if (axes[AXIS_X] > max_[AXIS_X]) max_[AXIS_X] = axes[AXIS_X];
-    if (axes[AXIS_Y] > max_[AXIS_Y]) max_[AXIS_Y] = axes[AXIS_Y];
-    if (axes[AXIS_Z] > max_[AXIS_Z]) max_[AXIS_Z] = axes[AXIS_Z];
+    min_[AXIS_X] = std::min(axes[AXIS_X], min_[AXIS_X]);
+    min_[AXIS_Y] = std::min(axes[AXIS_Y], min_[AXIS_Y]);
+    min_[AXIS_Z] = std::min(axes[AXIS_Z], min_[AXIS_Z]);
+    max_[AXIS_X] = std::max(axes[AXIS_X], max_[AXIS_X]);
+    max_[AXIS_Y] = std::max(axes[AXIS_Y], max_[AXIS_Y]);
+    max_[AXIS_Z] = std::max(axes[AXIS_Z], max_[AXIS_Z]);
   }
 
   void ZeroUnusedAxes() {
@@ -772,8 +772,8 @@ class GCodePrintVisualizer : public GCodeParser::EventReceiver {
   void change_spindle_speed(float value) final {
     // Hack to visualize brightness in lasing applications.
     laser_intensity_ = value;
-    if (laser_intensity_ < laser_min_) laser_min_ = laser_intensity_;
-    if (laser_intensity_ > laser_max_) laser_max_ = laser_intensity_;
+    laser_min_ = std::min(laser_intensity_, laser_min_);
+    laser_max_ = std::max(laser_intensity_, laser_max_);
   }
 
   const char *unprocessed(char letter, float value, const char *remain) final {
@@ -871,8 +871,8 @@ class SegmentQueuePrinter final : public SegmentQueue {
   }
 
   void RememberMinMax(float v) {
-    if (v > max_v_) max_v_ = v;
-    if (v < min_v_) min_v_ = v;
+    max_v_ = std::max(v, max_v_);
+    min_v_ = std::min(v, min_v_);
   }
 
   bool Enqueue(const LinearSegmentSteps &param) final {

src/motion-queue-motor-operations.cc

@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <algorithm>
 #include <deque>
 
 #include "hardware-mapping.h"
@@ -255,9 +256,7 @@ void MotionQueueMotorOperations::SetExternalPosition(int axis, int steps) {
 static int get_defining_axis_steps(const LinearSegmentSteps &param) {
   int defining_axis_steps = abs(param.steps[0]);
   for (int i = 1; i < BEAGLEG_NUM_MOTORS; ++i) {
-    if (abs(param.steps[i]) > defining_axis_steps) {
-      defining_axis_steps = abs(param.steps[i]);
-    }
+    defining_axis_steps = std::max(abs(param.steps[i]), defining_axis_steps);
   }
   return defining_axis_steps;
 }

src/planner.cc

@@ -385,7 +385,7 @@ static double determine_joining_speed(const struct AxisTarget *from,
     const double goal = to_speed * speed_conversion;
     if (goal < 0.0) return 0.0;
     if (is_first || within_acceptable_range(goal, from_defining_speed, 1e-5)) {
-      if (goal < from_defining_speed) from_defining_speed = goal;
+      from_defining_speed = std::min(goal, from_defining_speed);
       is_first = false;
     } else {
       return 0.0;  // Too far off.
@@ -646,15 +646,14 @@ bool Planner::Impl::machine_move(const AxesRegister &axis, float feedrate) {
 
   // Clamp the next speed to insure that this segment does not go over.
   // The new target speed must be equal or lower than the previously planned.
-  if (new_previous_speed < new_pos->start_speed)
-    new_pos->start_speed = new_previous_speed;
+  new_pos->start_speed = std::min(new_previous_speed, new_pos->start_speed);
 
   // Make sure the target feedrate for the move is clamped to what all the
   // moving axes can reach.
   const double max_speed =
     clamp_defining_axis_limit(new_pos->delta_steps, cfg_->max_feedrate,
                               defining_axis, cfg_->steps_per_mm);
-  if (max_speed < new_pos->speed) new_pos->speed = max_speed;
+  new_pos->speed = std::min(max_speed, new_pos->speed);
 
   // Define the maximum acceleration given the following motion angles and
   // defining axis.
@@ -914,11 +913,9 @@ int Planner::Impl::DirectDrive(GCodeParserAxis axis, float distance, float v0,
   struct LinearSegmentSteps move_command = {};
 
   move_command.v0 = v0 * steps_per_mm;
-  if (move_command.v0 > max_axis_speed_[axis])
-    move_command.v0 = max_axis_speed_[axis];
+  move_command.v0 = std::min(move_command.v0, max_axis_speed_[axis]);
   move_command.v1 = v1 * steps_per_mm;
-  if (move_command.v1 > max_axis_speed_[axis])
-    move_command.v1 = max_axis_speed_[axis];
+  move_command.v1 = std::min(move_command.v1, max_axis_speed_[axis]);
 
   move_command.aux_bits = hardware_mapping_->GetAuxBits();