Revert experimental NAN patch

Hold changes from #21575 (24a095c) for more testing.

Marlin/src/core/macros.h

 #define SIGN(a) ({__typeof__(a) _a = (a); (_a>0)-(_a<0);})
 #define IS_POWER_OF_2(x) ((x) && !((x) & ((x) - 1)))
 
-#define MFNAN 999999.0f
-#define ISNAN(V) ((V) == MFNAN)
-
 // Macros to constrain values
 #ifdef __cplusplus
 

Marlin/src/feature/bedlevel/abl/abl.cpp

  * Extrapolate a single point from its neighbors
  */
 static void extrapolate_one_point(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir) {
-  if (!ISNAN(z_values[x][y])) return;
+  if (!isnan(z_values[x][y])) return;
   if (DEBUGGING(LEVELING)) {
     DEBUG_ECHOPGM("Extrapolate [");
     if (x < 10) DEBUG_CHAR(' ');
         c1 = z_values[x1][y1], c2 = z_values[x2][y2];
 
   // Treat far unprobed points as zero, near as equal to far
-  if (ISNAN(a2)) a2 = 0.0;
-  if (ISNAN(a1)) a1 = a2;
-  if (ISNAN(b2)) b2 = 0.0;
-  if (ISNAN(b1)) b1 = b2;
-  if (ISNAN(c2)) c2 = 0.0;
-  if (ISNAN(c1)) c1 = c2;
+  if (isnan(a2)) a2 = 0.0;
+  if (isnan(a1)) a1 = a2;
+  if (isnan(b2)) b2 = 0.0;
+  if (isnan(b1)) b1 = b2;
+  if (isnan(c2)) c2 = 0.0;
+  if (isnan(c1)) c1 = c2;
 
   const float a = 2 * a1 - a2, b = 2 * b1 - b2, c = 2 * c1 - c2;
 

Marlin/src/feature/bedlevel/bedlevel.cpp

       bilinear_start.reset();
       bilinear_grid_spacing.reset();
       GRID_LOOP(x, y) {
-        z_values[x][y] = MFNAN;
+        z_values[x][y] = NAN;
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, 0));
       }
     #elif ABL_PLANAR
       LOOP_L_N(x, sx) {
         SERIAL_CHAR(' ');
         const float offset = fn(x, y);
-        if (!ISNAN(offset)) {
+        if (!isnan(offset)) {
           if (offset >= 0) SERIAL_CHAR('+');
           SERIAL_ECHO_F(offset, int(precision));
         }

Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h

   static inline xy_int8_t probe_indexes(const xy_pos_t &xy) { return probe_indexes(xy.x, xy.y); }
 
   static float calc_z0(const_float_t a0, const_float_t a1, const_float_t z1, const_float_t a2, const_float_t z2) {
-    if (ISNAN(a0) || ISNAN(a1) || ISNAN(z1) || ISNAN(a2) || ISNAN(z2)) return MFNAN;
     const float delta_z = (z2 - z1) / (a2 - a1),
                 delta_a = a0 - a1;
     return z1 + delta_a * delta_z;
                 z2 = calc_z0(pos.x, x1, z_values[ind.x][ind.y+1], x2, z_values[ind.x+1][ind.y+1]),
                 zf = calc_z0(pos.y, y1, z1, y2, z2);
 
-
-    return ISNAN(zf) ? zf : z_offset + zf * factor;
+    return z_offset + zf * factor;
   }
 
   #if IS_CARTESIAN && DISABLED(SEGMENT_LEVELED_MOVES)

Marlin/src/feature/bedlevel/ubl/ubl.cpp

   if (!leveling_is_valid()) return;
   SERIAL_ECHO_MSG("  G29 I999");
   GRID_LOOP(x, y)
-    if (!ISNAN(z_values[x][y])) {
+    if (!isnan(z_values[x][y])) {
       SERIAL_ECHO_START();
       SERIAL_ECHOPAIR("  M421 I", x, " J", y);
       SERIAL_ECHOLNPAIR_F_P(SP_Z_STR, z_values[x][y], 4);
 
 void unified_bed_leveling::invalidate() {
   set_bed_leveling_enabled(false);
-  set_all_mesh_points_to_value(MFNAN);
+  set_all_mesh_points_to_value(NAN);
 }
 
 void unified_bed_leveling::set_all_mesh_points_to_value(const_float_t value) {
 
   void unified_bed_leveling::set_store_from_mesh(const bed_mesh_t &in_values, mesh_store_t &stored_values) {
     auto z_to_store = [](const_float_t z) {
-      if (ISNAN(z)) return Z_STEPS_NAN;
+      if (isnan(z)) return Z_STEPS_NAN;
       const int32_t z_scaled = TRUNC(z * mesh_store_scaling);
       if (z_scaled == Z_STEPS_NAN || !WITHIN(z_scaled, INT16_MIN, INT16_MAX))
         return Z_STEPS_NAN; // If Z is out of range, return our custom 'NaN'
 
   void unified_bed_leveling::set_mesh_from_store(const mesh_store_t &stored_values, bed_mesh_t &out_values) {
     auto store_to_z = [](const int16_t z_scaled) {
-      return z_scaled == Z_STEPS_NAN ? MFNAN : z_scaled / mesh_store_scaling;
+      return z_scaled == Z_STEPS_NAN ? NAN : z_scaled / mesh_store_scaling;
     };
     GRID_LOOP(x, y) out_values[x][y] = store_to_z(stored_values[x][y]);
   }
       if (lcd) {
         // TODO: Display on Graphical LCD
       }
-      else if (ISNAN(f))
+      else if (isnan(f))
         SERIAL_ECHOPGM_P(human ? PSTR("  .   ") : PSTR("NAN"));
       else if (human || csv) {
         if (human && f >= 0.0) SERIAL_CHAR(f > 0 ? '+' : ' ');  // Display sign also for positive numbers (' ' for 0)

Marlin/src/feature/bedlevel/ubl/ubl.h

   #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
     #define _UBL_OUTER_Z_RAISE UBL_Z_RAISE_WHEN_OFF_MESH
   #else
-    #define _UBL_OUTER_Z_RAISE MFNAN
+    #define _UBL_OUTER_Z_RAISE NAN
   #endif
 
   /**
     const float z2 = calc_z0(rx0, mesh_index_to_xpos(cx), z_values[cx][my], mesh_index_to_xpos(cx + 1), z_values[mx][my]);
     float z0 = calc_z0(ry0, mesh_index_to_ypos(cy), z1, mesh_index_to_ypos(cy + 1), z2);
 
-    if (ISNAN(z0)) { // if part of the Mesh is undefined, it will show up as MFNAN
+    if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
       z0 = 0.0;      // in ubl.z_values[][] and propagate through the
                      // calculations. If our correction is NAN, we throw it out
                      // because part of the Mesh is undefined and we don't have the
   #endif
 
   static inline bool mesh_is_valid() {
-    GRID_LOOP(x, y) if (ISNAN(z_values[x][y])) return false;
+    GRID_LOOP(x, y) if (isnan(z_values[x][y])) return false;
     return true;
   }
 

Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

         // to invalidate the ENTIRE mesh, which can't be done with
         // find_closest_mesh_point (which only returns REAL points).
         if (closest.pos.x < 0) { invalidate_all = true; break; }
-        z_values[closest.pos.x][closest.pos.y] = MFNAN;
+        z_values[closest.pos.x][closest.pos.y] = NAN;
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(closest.pos, 0.0f));
       }
     }
               if (cpos.x < 0) {
                 // No more REAL INVALID mesh points to populate, so we ASSUME
                 // user meant to populate ALL INVALID mesh points to value
-                GRID_LOOP(x, y) if (ISNAN(z_values[x][y])) z_values[x][y] = param.C_constant;
+                GRID_LOOP(x, y) if (isnan(z_values[x][y])) z_values[x][y] = param.C_constant;
                 break; // No more invalid Mesh Points to populate
               }
               else {
   float sum = 0;
   int n = 0;
   GRID_LOOP(x, y)
-    if (!ISNAN(z_values[x][y])) {
+    if (!isnan(z_values[x][y])) {
       sum += z_values[x][y];
       n++;
     }
   //
   float sum_of_diff_squared = 0;
   GRID_LOOP(x, y)
-    if (!ISNAN(z_values[x][y]))
+    if (!isnan(z_values[x][y]))
       sum_of_diff_squared += sq(z_values[x][y] - mean);
 
   SERIAL_ECHOLNPAIR("# of samples: ", n);
 
   if (cflag)
     GRID_LOOP(x, y)
-      if (!ISNAN(z_values[x][y])) {
+      if (!isnan(z_values[x][y])) {
         z_values[x][y] -= mean + offset;
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
       }
  */
 void unified_bed_leveling::shift_mesh_height() {
   GRID_LOOP(x, y)
-    if (!ISNAN(z_values[x][y])) {
+    if (!isnan(z_values[x][y])) {
       z_values[x][y] += param.C_constant;
       TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
     }
       ui.refresh();
 
       float new_z = z_values[lpos.x][lpos.y];
-      if (ISNAN(new_z)) new_z = 0;                        // Invalid points begin at 0
+      if (isnan(new_z)) new_z = 0;                        // Invalid points begin at 0
       new_z = FLOOR(new_z * 1000) * 0.001f;               // Chop off digits after the 1000ths place
 
       ui.ubl_mesh_edit_start(new_z);
   mesh_index_pair farthest { -1, -1, -99999.99 };
 
   GRID_LOOP(i, j) {
-    if (!ISNAN(z_values[i][j])) continue;  // Skip valid mesh points
+    if (!isnan(z_values[i][j])) continue;  // Skip valid mesh points
 
     // Skip unreachable points
     if (!probe.can_reach(mesh_index_to_xpos(i), mesh_index_to_ypos(j)))
     xy_int8_t nearby { -1, -1 };
     float d1, d2 = 99999.9f;
     GRID_LOOP(k, l) {
-      if (ISNAN(z_values[k][l])) continue;
+      if (isnan(z_values[k][l])) continue;
 
       found_a_real = true;
 
 
   static bool test_func(uint8_t i, uint8_t j, void *data) {
     find_closest_t *d = (find_closest_t*)data;
-    if ( (d->type == (ISNAN(ubl.z_values[i][j]) ? INVALID : REAL))
+    if ( (d->type == (isnan(ubl.z_values[i][j]) ? INVALID : REAL))
       || (d->type == SET_IN_BITMAP && !d->done_flags->marked(i, j))
     ) {
       // Found a Mesh Point of the specified type!
     float best_so_far = 99999.99f;
 
     GRID_LOOP(i, j) {
-      if ( (type == (ISNAN(z_values[i][j]) ? INVALID : REAL))
+      if ( (type == (isnan(z_values[i][j]) ? INVALID : REAL))
         || (type == SET_IN_BITMAP && !done_flags->marked(i, j))
       ) {
         // Found a Mesh Point of the specified type!
 
 bool unified_bed_leveling::smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir) {
   const float v = z_values[x][y];
-  if (ISNAN(v)) {                           // A NAN...
+  if (isnan(v)) {                           // A NAN...
     const int8_t dx = x + xdir, dy = y + ydir;
     const float v1 = z_values[dx][dy];
-    if (!ISNAN(v1)) {                       // ...next to a pair of real values?
+    if (!isnan(v1)) {                       // ...next to a pair of real values?
       const float v2 = z_values[dx + xdir][dy + ydir];
-      if (!ISNAN(v2)) {
+      if (!isnan(v2)) {
         z_values[x][y] = v1 < v2 ? v1 : v1 + v1 - v2;
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(x, y, z_values[x][y]));
         return true;
       TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " 1/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
 
       measured_z = probe.probe_at_point(points[0], PROBE_PT_RAISE, param.V_verbosity);
-      if (ISNAN(measured_z))
+      if (isnan(measured_z))
         abort_flag = true;
       else {
         measured_z -= get_z_correction(points[0]);
         #ifdef VALIDATE_MESH_TILT
           z2 = measured_z;
         #endif
-        if (ISNAN(measured_z))
+        if (isnan(measured_z))
           abort_flag = true;
         else {
           measured_z -= get_z_correction(points[1]);
         #ifdef VALIDATE_MESH_TILT
           z3 = measured_z;
         #endif
-        if (ISNAN(measured_z))
+        if (isnan(measured_z))
           abort_flag = true;
         else {
           measured_z -= get_z_correction(points[2]);
 
             measured_z = probe.probe_at_point(rpos, parser.seen('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity); // TODO: Needs error handling
 
-            abort_flag = ISNAN(measured_z);
+            abort_flag = isnan(measured_z);
 
             #if ENABLED(DEBUG_LEVELING_FEATURE)
               if (DEBUGGING(LEVELING)) {
 
     const float weight_scaled = weight_factor * _MAX(MESH_X_DIST, MESH_Y_DIST);
 
-    GRID_LOOP(jx, jy) if (!ISNAN(z_values[jx][jy])) SBI(bitmap[jx], jy);
+    GRID_LOOP(jx, jy) if (!isnan(z_values[jx][jy])) SBI(bitmap[jx], jy);
 
     xy_pos_t ppos;
     LOOP_L_N(ix, GRID_MAX_POINTS_X) {
       ppos.x = mesh_index_to_xpos(ix);
       LOOP_L_N(iy, GRID_MAX_POINTS_Y) {
         ppos.y = mesh_index_to_ypos(iy);
-        if (ISNAN(z_values[ix][iy])) {
+        if (isnan(z_values[ix][iy])) {
           // undefined mesh point at (ppos.x,ppos.y), compute weighted LSF from original valid mesh points.
           incremental_LSF_reset(&lsf_results);
           xy_pos_t rpos;

Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

 
       // Undefined parts of the Mesh in z_values[][] are NAN.
       // Replace NAN corrections with 0.0 to prevent NAN propagation.
-      if (!ISNAN(z0)) end.z += z0;
+      if (!isnan(z0)) end.z += z0;
       planner.buffer_segment(end, scaled_fr_mm_s, extruder);
       current_position = destination;
       return;
 
         // Undefined parts of the Mesh in z_values[][] are NAN.
         // Replace NAN corrections with 0.0 to prevent NAN propagation.
-        if (ISNAN(z0)) z0 = 0.0;
+        if (isnan(z0)) z0 = 0.0;
 
         const float ry = mesh_index_to_ypos(icell.y);
 
 
         // Undefined parts of the Mesh in z_values[][] are NAN.
         // Replace NAN corrections with 0.0 to prevent NAN propagation.
-        if (ISNAN(z0)) z0 = 0.0;
+        if (isnan(z0)) z0 = 0.0;
 
         /**
          * Without this check, it's possible to generate a zero length move, as in the case where
 
         // Undefined parts of the Mesh in z_values[][] are NAN.
         // Replace NAN corrections with 0.0 to prevent NAN propagation.
-        if (ISNAN(z0)) z0 = 0.0;
+        if (isnan(z0)) z0 = 0.0;
 
         if (!inf_normalized_flag) {
           on_axis_distance = use_x_dist ? rx - start.x : next_mesh_line_y - start.y;
 
         // Undefined parts of the Mesh in z_values[][] are NAN.
         // Replace NAN corrections with 0.0 to prevent NAN propagation.
-        if (ISNAN(z0)) z0 = 0.0;
+        if (isnan(z0)) z0 = 0.0;
 
         if (!inf_normalized_flag) {
           on_axis_distance = use_x_dist ? next_mesh_line_x - start.x : ry - start.y;
             z_x0y1 = z_values[icell.x  ][icell.y+1],  // z at lower right corner
             z_x1y1 = z_values[icell.x+1][icell.y+1];  // z at upper right corner
 
-      if (ISNAN(z_x0y0)) z_x0y0 = 0;              // ideally activating planner.leveling_active (G29 A)
-      if (ISNAN(z_x1y0)) z_x1y0 = 0;              //   should refuse if any invalid mesh points
-      if (ISNAN(z_x0y1)) z_x0y1 = 0;              //   in order to avoid ISNAN tests per cell,
-      if (ISNAN(z_x1y1)) z_x1y1 = 0;              //   thus guessing zero for undefined points
+      if (isnan(z_x0y0)) z_x0y0 = 0;              // ideally activating planner.leveling_active (G29 A)
+      if (isnan(z_x1y0)) z_x1y0 = 0;              //   should refuse if any invalid mesh points
+      if (isnan(z_x0y1)) z_x0y1 = 0;              //   in order to avoid isnan tests per cell,
+      if (isnan(z_x1y1)) z_x1y1 = 0;              //   thus guessing zero for undefined points
 
       const xy_pos_t pos = { mesh_index_to_xpos(icell.x), mesh_index_to_ypos(icell.y) };
       xy_pos_t cell = raw - pos;

Marlin/src/gcode/bedlevel/G35.cpp

     do_blocking_move_to_z(SUM_TERN(BLTOUCH_HS_MODE, Z_CLEARANCE_BETWEEN_PROBES, 7));
     const float z_probed_height = probe.probe_at_point(screws_tilt_adjust_pos[i], PROBE_PT_RAISE, 0, true);
 
-    if (ISNAN(z_probed_height)) {
+    if (isnan(z_probed_height)) {
       SERIAL_ECHOPAIR("G35 failed at point ", i, " (");
       SERIAL_ECHOPGM_P((char *)pgm_read_ptr(&tramming_point_name[i]));
       SERIAL_CHAR(')');

Marlin/src/gcode/bedlevel/abl/G29.cpp

           G29_RETURN(false);
         }
 
-        const float rx = RAW_X_POSITION(parser.linearval('X', MFNAN)),
-                    ry = RAW_Y_POSITION(parser.linearval('Y', MFNAN));
+        const float rx = RAW_X_POSITION(parser.linearval('X', NAN)),
+                    ry = RAW_Y_POSITION(parser.linearval('Y', NAN));
         int8_t i = parser.byteval('I', -1), j = parser.byteval('J', -1);
 
-        if (!ISNAN(rx) && !ISNAN(ry)) {
+        if (!isnan(rx) && !isnan(ry)) {
           // Get nearest i / j from rx / ry
           i = (rx - bilinear_start.x + 0.5 * abl.gridSpacing.x) / abl.gridSpacing.x;
           j = (ry - bilinear_start.y + 0.5 * abl.gridSpacing.y) / abl.gridSpacing.y;
 
       // Outer loop is X with PROBE_Y_FIRST enabled
       // Outer loop is Y with PROBE_Y_FIRST disabled
-      for (PR_OUTER_VAR = 0; PR_OUTER_VAR < PR_OUTER_SIZE && !ISNAN(abl.measured_z); PR_OUTER_VAR++) {
+      for (PR_OUTER_VAR = 0; PR_OUTER_VAR < PR_OUTER_SIZE && !isnan(abl.measured_z); PR_OUTER_VAR++) {
 
         int8_t inStart, inStop, inInc;
 
 
           abl.measured_z = faux ? 0.001f * random(-100, 101) : probe.probe_at_point(abl.probePos, raise_after, abl.verbose_level);
 
-          if (ISNAN(abl.measured_z)) {
+          if (isnan(abl.measured_z)) {
             set_bed_leveling_enabled(abl.reenable);
             break; // Breaks out of both loops
           }
         // Retain the last probe position
         abl.probePos = points[i];
         abl.measured_z = faux ? 0.001 * random(-100, 101) : probe.probe_at_point(abl.probePos, raise_after, abl.verbose_level);
-        if (ISNAN(abl.measured_z)) {
+        if (isnan(abl.measured_z)) {
           set_bed_leveling_enabled(abl.reenable);
           break;
         }
         points[i].z = abl.measured_z;
       }
 
-      if (!abl.dryrun && !ISNAN(abl.measured_z)) {
+      if (!abl.dryrun && !isnan(abl.measured_z)) {
         vector_3 planeNormal = vector_3::cross(points[0] - points[1], points[2] - points[1]).get_normal();
         if (planeNormal.z < 0) planeNormal *= -1;
         planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
     // Stow the probe. No raise for FIX_MOUNTED_PROBE.
     if (probe.stow()) {
       set_bed_leveling_enabled(abl.reenable);
-      abl.measured_z = MFNAN;
+      abl.measured_z = NAN;
     }
   }
   #endif // !PROBE_MANUALLY
   #endif
 
   // Calculate leveling, print reports, correct the position
-  if (!ISNAN(abl.measured_z)) {
+  if (!isnan(abl.measured_z)) {
     #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
       if (!abl.dryrun) extrapolate_unprobed_bed_level();
 
     // Auto Bed Leveling is complete! Enable if possible.
     planner.leveling_active = !abl.dryrun || abl.reenable;
-  } // !ISNAN(abl.measured_z)
+  } // !isnan(abl.measured_z)
 
   // Restore state after probing
   if (!faux) restore_feedrate_and_scaling();
 
   TERN_(FULL_REPORT_TO_HOST_FEATURE, set_and_report_grblstate(M_IDLE));
 
-  G29_RETURN(ISNAN(abl.measured_z));
+  G29_RETURN(isnan(abl.measured_z));
 }
 
 #endif // HAS_ABL_NOT_UBL

Marlin/src/gcode/bedlevel/ubl/M421.cpp

     SERIAL_ERROR_MSG(STR_ERR_MESH_XY);
   else {
     float &zval = ubl.z_values[ij.x][ij.y];
-    zval = hasN ? MFNAN : parser.value_linear_units() + (hasQ ? zval : 0);
+    zval = hasN ? NAN : parser.value_linear_units() + (hasQ ? zval : 0);
     TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ij.x, ij.y, zval));
   }
 }

Marlin/src/gcode/calibrate/G33.cpp

     if (!_7p_no_intermediates && !_7p_4_intermediates && !_7p_11_intermediates) { // probe the center
       const xy_pos_t center{0};
       z_pt[CEN] += calibration_probe(center, stow_after_each);
-      if (ISNAN(z_pt[CEN])) return false;
+      if (isnan(z_pt[CEN])) return false;
     }
 
     if (_7p_calibration) { // probe extra center points
                     r = dcr * 0.1;
         const xy_pos_t vec = { cos(a), sin(a) };
         z_pt[CEN] += calibration_probe(vec * r, stow_after_each);
-        if (ISNAN(z_pt[CEN])) return false;
+        if (isnan(z_pt[CEN])) return false;
      }
       z_pt[CEN] /= float(_7p_2_intermediates ? 7 : probe_points);
     }
                       interpol = FMOD(rad, 1);
           const xy_pos_t vec = { cos(a), sin(a) };
           const float z_temp = calibration_probe(vec * r, stow_after_each);
-          if (ISNAN(z_temp)) return false;
+          if (isnan(z_temp)) return false;
           // split probe point to neighbouring calibration points
           z_pt[uint8_t(LROUND(rad - interpol + NPP - 1)) % NPP + 1] += z_temp * sq(cos(RADIANS(interpol * 90)));
           z_pt[uint8_t(LROUND(rad - interpol))           % NPP + 1] += z_temp * sq(sin(RADIANS(interpol * 90)));

Marlin/src/gcode/calibrate/G34_M422.cpp

           // Probing sanity check is disabled, as it would trigger even in normal cases because
           // current_position.z has been manually altered in the "dirty trick" above.
           const float z_probed_height = probe.probe_at_point(z_stepper_align.xy[iprobe], raise_after, 0, true, false);
-          if (ISNAN(z_probed_height)) {
+          if (isnan(z_probed_height)) {
             SERIAL_ECHOLNPGM("Probing failed");
             LCD_MESSAGEPGM(MSG_LCD_PROBING_FAILED);
             err_break = true;

Marlin/src/gcode/calibrate/G76_M192_M871.cpp

   auto g76_probe = [](const TempSensorID sid, uint16_t &targ, const xy_pos_t &nozpos) {
     do_z_clearance(5.0); // Raise nozzle before probing
     const float measured_z = probe.probe_at_point(nozpos, PROBE_PT_STOW, 0, false);  // verbose=0, probe_relative=false
-    if (ISNAN(measured_z))
+    if (isnan(measured_z))
       SERIAL_ECHOLNPGM("!Received NAN. Aborting.");
     else {
       SERIAL_ECHOLNPAIR_F("Measured: ", measured_z);
         report_temps(next_temp_report);
 
       const float measured_z = g76_probe(TSI_BED, target_bed, noz_pos_xyz);
-      if (ISNAN(measured_z) || target_bed > BED_MAX_TARGET) break;
+      if (isnan(measured_z) || target_bed > BED_MAX_TARGET) break;
     }
 
     SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index());
       if (timeout) break;
 
       const float measured_z = g76_probe(TSI_PROBE, target_probe, noz_pos_xyz);
-      if (ISNAN(measured_z) || target_probe > cali_info_init[TSI_PROBE].end_temp) break;
+      if (isnan(measured_z) || target_probe > cali_info_init[TSI_PROBE].end_temp) break;
     }
 
     SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index());

Marlin/src/gcode/calibrate/M48.cpp

 
   // Move to the first point, deploy, and probe
   const float t = probe.probe_at_point(test_position, raise_after, verbose_level);
-  bool probing_good = !ISNAN(t);
+  bool probing_good = !isnan(t);
 
   if (probing_good) {
     randomSeed(millis());
       const float pz = probe.probe_at_point(test_position, raise_after, 0);
 
       // Break the loop if the probe fails
-      probing_good = !ISNAN(pz);
+      probing_good = !isnan(pz);
       if (!probing_good) break;
 
       // Store the new sample

Marlin/src/gcode/probe/G30.cpp

 
   const ProbePtRaise raise_after = parser.boolval('E', true) ? PROBE_PT_STOW : PROBE_PT_NONE;
   const float measured_z = probe.probe_at_point(pos, raise_after, 1);
-  if (!ISNAN(measured_z))
+  if (!isnan(measured_z))
     SERIAL_ECHOLNPAIR("Bed X: ", pos.x, " Y: ", pos.y, " Z: ", measured_z);
 
   restore_feedrate_and_scaling();

Marlin/src/lcd/HD44780/marlinui_HD44780.cpp

          * Print Z values
          */
         _ZLABEL(_LCD_W_POS, 1);
-        if (!ISNAN(ubl.z_values[x_plot][y_plot]))
+        if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
           lcd_put_u8str_P(PSTR(" -----"));
          * Show the location value
          */
         _ZLABEL(_LCD_W_POS, 3);
-        if (!ISNAN(ubl.z_values[x_plot][y_plot]))
+        if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
           lcd_put_u8str_P(PSTR(" -----"));

Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp

       // Show the location value
       lcd.setCursor(_LCD_W_POS, 3); lcd_put_u8str_P(PSTR("Z:"));
 
-      if (!ISNAN(ubl.z_values[x_plot][y_plot]))
+      if (!isnan(ubl.z_values[x_plot][y_plot]))
         lcd.print(ftostr43sign(ubl.z_values[x_plot][y_plot]));
       else
         lcd_put_u8str_P(PSTR(" -----"));

Marlin/src/lcd/dogm/marlinui_DOGM.cpp

 
         // Show the location value
         lcd_put_u8str_P(74, LCD_PIXEL_HEIGHT, Z_LBL);
-        if (!ISNAN(ubl.z_values[x_plot][y_plot]))
+        if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
           lcd_put_u8str_P(PSTR(" -----"));

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extended/adjuster_widget.cpp

 namespace FTDI {
   void draw_adjuster_value(CommandProcessor& cmd, int16_t x, int16_t y, int16_t w, int16_t h, float value, progmem_str units, int8_t width, uint8_t precision) {
     char str[width + precision + 10 + (units ? strlen_P((const char*) units) : 0)];
-    if (ISNAN(value))
+    if (isnan(value))
       strcpy_P(str, PSTR("-"));
     else
       dtostrf(value, width, precision, str);

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_base.cpp

   constexpr uint8_t cols = GRID_MAX_POINTS_X;
 
   #define VALUE(X,Y)  (func ? func(X,Y,data) : 0)
-  #define ISVAL(X,Y)  (func ? !ISNAN(VALUE(X,Y)) : true)
+  #define ISVAL(X,Y)  (func ? !isnan(VALUE(X,Y)) : true)
   #define HEIGHT(X,Y) (ISVAL(X,Y) ? (VALUE(X,Y) - val_min) * scale_z : 0)
 
   // Compute the mean, min and max for the points

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/bed_mesh_edit_screen.cpp

 
 float BedMeshEditScreen::getHighlightedValue() {
   const float val = ExtUI::getMeshPoint(mydata.highlight);
-  return (ISNAN(val) ? 0 : val) + mydata.zAdjustment;
+  return (isnan(val) ? 0 : val) + mydata.zAdjustment;
 }
 
 void BedMeshEditScreen::setHighlightedValue(float value) {

Marlin/src/lcd/extui/ui_api.cpp

         #if AXIS_IS_TMC(Z2)
           case Z2: return stepperZ2.getMilliamps();
         #endif
-        default: return MFNAN;
+        default: return NAN;
       };
     }
 
         #if AXIS_IS_TMC(E7)
           case E7: return stepperE7.getMilliamps();
         #endif
-        default: return MFNAN;
+        default: return NAN;
       };
     }
 

Marlin/src/lcd/menu/menu_tramming.cpp

   z_measured[tram_index] = z_probed_height;
   move_to_tramming_wait_pos();
 
-  return !ISNAN(z_probed_height);
+  return !isnan(z_probed_height);
 }
 
 static void _menu_single_probe(const uint8_t point) {

Marlin/src/lcd/tft/ui_1024x600.cpp

     tft.set_background(COLOR_BACKGROUND);
     tft_string.set(Z_LBL);
     tft.add_text(0, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
-    tft_string.set(ISNAN(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
+    tft_string.set(isnan(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
     tft_string.trim();
     tft.add_text(120 - tft_string.width(), MENU_TEXT_Y_OFFSET, COLOR_MENU_VALUE, tft_string);
 

Marlin/src/lcd/tft/ui_320x240.cpp

     tft.set_background(COLOR_BACKGROUND);
     tft_string.set(Z_LBL);
     tft.add_text(0, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
-    tft_string.set(ISNAN(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
+    tft_string.set(isnan(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
     tft_string.trim();
     tft.add_text(96 - tft_string.width(), MENU_TEXT_Y_OFFSET, COLOR_MENU_VALUE, tft_string);
 

Marlin/src/lcd/tft/ui_480x320.cpp

     tft.set_background(COLOR_BACKGROUND);
     tft_string.set(Z_LBL);
     tft.add_text(0, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
-    tft_string.set(ISNAN(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
+    tft_string.set(isnan(ubl.z_values[x_plot][y_plot]) ? "-----" : ftostr43sign(ubl.z_values[x_plot][y_plot]));
     tft_string.trim();
     tft.add_text(120 - tft_string.width(), MENU_TEXT_Y_OFFSET, COLOR_MENU_VALUE, tft_string);
 

Marlin/src/module/probe.cpp

  * @details Used by probe_at_point to get the bed Z height at the current XY.
  *          Leaves current_position.z at the height where the probe triggered.
  *
- * @return The Z position of the bed at the current XY or MFNAN on error.
+ * @return The Z position of the bed at the current XY or NAN on error.
  */
 float Probe::run_z_probe(const bool sanity_check/*=true*/) {
   DEBUG_SECTION(log_probe, "Probe::run_z_probe", DEBUGGING(LEVELING));
   #if TOTAL_PROBING == 2
 
     // Attempt to tare the probe
-    if (TERN0(PROBE_TARE, tare())) return MFNAN;
+    if (TERN0(PROBE_TARE, tare())) return NAN;
 
     // Do a first probe at the fast speed
     if (try_to_probe(PSTR("FAST"), z_probe_low_point, z_probe_fast_mm_s,
-                     sanity_check, Z_CLEARANCE_BETWEEN_PROBES) ) return MFNAN;
+                     sanity_check, Z_CLEARANCE_BETWEEN_PROBES) ) return NAN;
 
     const float first_probe_z = current_position.z;
 
 
       // Probe downward slowly to find the bed
       if (try_to_probe(PSTR("SLOW"), z_probe_low_point, MMM_TO_MMS(Z_PROBE_FEEDRATE_SLOW),
-                       sanity_check, Z_CLEARANCE_MULTI_PROBE) ) return MFNAN;
+                       sanity_check, Z_CLEARANCE_MULTI_PROBE) ) return NAN;
 
       TERN_(MEASURE_BACKLASH_WHEN_PROBING, backlash.measure_with_probe());
 
   if (probe_relative) {                                     // The given position is in terms of the probe
     if (!can_reach(npos)) {
       if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Position Not Reachable");
-      return MFNAN;
+      return NAN;
     }
     npos -= offset_xy;                                      // Get the nozzle position
   }
-  else if (!position_is_reachable(npos)) return MFNAN;      // The given position is in terms of the nozzle
+  else if (!position_is_reachable(npos)) return NAN;        // The given position is in terms of the nozzle
 
   // Move the probe to the starting XYZ
   do_blocking_move_to(npos, feedRate_t(XY_PROBE_FEEDRATE_MM_S));
 
-  float measured_z = MFNAN;
+  float measured_z = NAN;
   if (!deploy()) measured_z = run_z_probe(sanity_check) + offset.z;
-  if (!ISNAN(measured_z)) {
+  if (!isnan(measured_z)) {
     const bool big_raise = raise_after == PROBE_PT_BIG_RAISE;
     if (big_raise || raise_after == PROBE_PT_RAISE)
       do_blocking_move_to_z(current_position.z + (big_raise ? 25 : Z_CLEARANCE_BETWEEN_PROBES), z_probe_fast_mm_s);
     else if (raise_after == PROBE_PT_STOW)
-      if (stow()) measured_z = MFNAN;   // Error on stow?
+      if (stow()) measured_z = NAN;   // Error on stow?
 
     if (verbose_level > 2)
       SERIAL_ECHOLNPAIR("Bed X: ", LOGICAL_X_POSITION(rx), " Y: ", LOGICAL_Y_POSITION(ry), " Z: ", measured_z);
   }
 
-  if (ISNAN(measured_z)) {
+  if (isnan(measured_z)) {
     stow();
     LCD_MESSAGEPGM(MSG_LCD_PROBING_FAILED);
     #if DISABLED(G29_RETRY_AND_RECOVER)

Marlin/src/module/settings.cpp

       HOTEND_LOOP() {
         PIDCF_t pidcf = {
           #if DISABLED(PIDTEMP)
-            MFNAN, MFNAN, MFNAN,
-            MFNAN, MFNAN
+            NAN, NAN, NAN,
+            NAN, NAN
           #else
                          PID_PARAM(Kp, e),
             unscalePID_i(PID_PARAM(Ki, e)),
 
       const PID_t bed_pid = {
         #if DISABLED(PIDTEMPBED)
-          MFNAN, MFNAN, MFNAN
+          NAN, NAN, NAN
         #else
           // Store the unscaled PID values
           thermalManager.temp_bed.pid.Kp,
 
       const PID_t chamber_pid = {
         #if DISABLED(PIDTEMPCHAMBER)
-          MFNAN, MFNAN, MFNAN
+          NAN, NAN, NAN
         #else
           // Store the unscaled PID values
           thermalManager.temp_chamber.pid.Kp,
           PIDCF_t pidcf;
           EEPROM_READ(pidcf);
           #if ENABLED(PIDTEMP)
-            if (!validating && !ISNAN(pidcf.Kp)) {
+            if (!validating && !isnan(pidcf.Kp)) {
               // Scale PID values since EEPROM values are unscaled
               PID_PARAM(Kp, e) = pidcf.Kp;
               PID_PARAM(Ki, e) = scalePID_i(pidcf.Ki);
         PID_t pid;
         EEPROM_READ(pid);
         #if ENABLED(PIDTEMPBED)
-          if (!validating && !ISNAN(pid.Kp)) {
+          if (!validating && !isnan(pid.Kp)) {
             // Scale PID values since EEPROM values are unscaled
             thermalManager.temp_bed.pid.Kp = pid.Kp;
             thermalManager.temp_bed.pid.Ki = scalePID_i(pid.Ki);
         PID_t pid;
         EEPROM_READ(pid);
         #if ENABLED(PIDTEMPCHAMBER)
-          if (!validating && !ISNAN(pid.Kp)) {
+          if (!validating && !isnan(pid.Kp)) {
             // Scale PID values since EEPROM values are unscaled
             thermalManager.temp_chamber.pid.Kp = pid.Kp;
             thermalManager.temp_chamber.pid.Ki = scalePID_i(pid.Ki);

Marlin/src/module/temperature.h

 #endif
 
 #define PID_PARAM(F,H) _PID_##F(TERN(PID_PARAMS_PER_HOTEND, H, 0 & H)) // Always use 'H' to suppress warning
-#define _PID_Kp(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kp, MFNAN)
-#define _PID_Ki(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Ki, MFNAN)
-#define _PID_Kd(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kd, MFNAN)
+#define _PID_Kp(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kp, NAN)
+#define _PID_Ki(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Ki, NAN)
+#define _PID_Kd(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kd, NAN)
 #if ENABLED(PIDTEMP)
   #define _PID_Kc(H) TERN(PID_EXTRUSION_SCALING, Temperature::temp_hotend[H].pid.Kc, 1)
   #define _PID_Kf(H) TERN(PID_FAN_SCALING,       Temperature::temp_hotend[H].pid.Kf, 0)

platformio.ini

 # The 'common' values are used for most Marlin builds
 #
 [common]
-build_flags        = -fmax-errors=5 -g3 -D__MARLIN_FIRMWARE__ -fmerge-constants -fno-signed-zeros -ffinite-math-only
+build_flags        = -fmax-errors=5 -g3 -D__MARLIN_FIRMWARE__ -fmerge-constants
 extra_scripts      =
   pre:buildroot/share/PlatformIO/scripts/common-dependencies.py
   pre:buildroot/share/PlatformIO/scripts/common-cxxflags.py