diff --git a/Common/Core/Testing/Cxx/TestMath.cxx b/Common/Core/Testing/Cxx/TestMath.cxx
index 5e19cb46e322c2b35f12f550243c08f1df6402b5..b587df17ba7fd9bb0fe2dc89e35878f453b8f110 100644
--- a/Common/Core/Testing/Cxx/TestMath.cxx
+++ b/Common/Core/Testing/Cxx/TestMath.cxx
@@ -5,22 +5,19 @@
 #include "vtkMathConfigure.h"
 
 #include <array>
+#include <cmath>
 #include <limits>
 
-#ifndef ABS
-#define ABS(x) ((x) < 0 ? -(x) : (x))
-#endif
-
 template <class A>
 bool fuzzyCompare1DWeak(A a, A b)
 {
-  return ABS(a - b) < .0001;
+  return std::abs(a - b) < .0001;
 }
 
 template <class A>
 bool fuzzyCompare1D(A a, A b)
 {
-  return ABS(a - b) < std::numeric_limits<A>::epsilon();
+  return std::abs(a - b) < std::numeric_limits<A>::epsilon();
 }
 
 template <class A>
@@ -67,12 +64,12 @@ public:
   bool operator==(const Triple& triple) const { return *this == triple.data; }
   bool operator==(const double* triple) const
   {
-    return ((this->data[0] - triple[0] <= 0.01 * ABS(data[0]) + 0.02) &&
-      (this->data[0] - triple[0] >= -0.01 * ABS(data[0]) - 0.02) &&
-      (this->data[1] - triple[1] <= 0.01 * ABS(data[1]) + 0.02) &&
-      (this->data[1] - triple[1] >= -0.01 * ABS(data[1]) - 0.02) &&
-      (this->data[2] - triple[2] <= 0.01 * ABS(data[2]) + 0.02) &&
-      (this->data[2] - triple[2] >= -0.01 * ABS(data[2]) - 0.02));
+    return ((this->data[0] - triple[0] <= 0.01 * std::abs(data[0]) + 0.02) &&
+      (this->data[0] - triple[0] >= -0.01 * std::abs(data[0]) - 0.02) &&
+      (this->data[1] - triple[1] <= 0.01 * std::abs(data[1]) + 0.02) &&
+      (this->data[1] - triple[1] >= -0.01 * std::abs(data[1]) - 0.02) &&
+      (this->data[2] - triple[2] <= 0.01 * std::abs(data[2]) + 0.02) &&
+      (this->data[2] - triple[2] >= -0.01 * std::abs(data[2]) - 0.02));
   }
   bool operator!=(const Triple& triple) const { return *this != triple.data; }
   bool operator!=(const double* triple) const { return !(*this == triple); }
diff --git a/Common/Core/vtkLargeInteger.cxx b/Common/Core/vtkLargeInteger.cxx
index 78d79d2ee380a3f85ee6774c96185f48c690ef4b..1b90b4d8f1592b988496336fc805dc60452872dc 100644
--- a/Common/Core/vtkLargeInteger.cxx
+++ b/Common/Core/vtkLargeInteger.cxx
@@ -10,6 +10,7 @@
 #include "vtkLargeInteger.h"
 
 #include <algorithm>
+#include <cmath>
 
 VTK_ABI_NAMESPACE_BEGIN
 const unsigned int BIT_INCREMENT = 32;
@@ -34,7 +35,7 @@ vtkLargeInteger::vtkLargeInteger()
 vtkLargeInteger::vtkLargeInteger(long long n)
 {
   this->Negative = n < 0 ? 1 : 0;
-  n = n < 0 ? -n : n; // strip of sign
+  n = std::abs(n); // strip of sign
   this->Number = new char[BIT_INCREMENT];
   for (unsigned int i = 0; i < BIT_INCREMENT; i++)
   {
@@ -63,7 +64,7 @@ vtkLargeInteger::vtkLargeInteger(unsigned long long n)
 vtkLargeInteger::vtkLargeInteger(long n)
 {
   this->Negative = n < 0 ? 1 : 0;
-  n = n < 0 ? -n : n; // strip of sign
+  n = std::abs(n); // strip of sign
   this->Number = new char[BIT_INCREMENT];
   for (unsigned int i = 0; i < BIT_INCREMENT; i++)
   {
@@ -106,7 +107,7 @@ vtkLargeInteger::vtkLargeInteger(unsigned int n)
 vtkLargeInteger::vtkLargeInteger(int n)
 {
   this->Negative = n < 0 ? 1 : 0;
-  n = n < 0 ? -n : n; // strip of sign
+  n = std::abs(n); // strip of sign
   this->Number = new char[BIT_INCREMENT];
   for (unsigned int i = 0; i < BIT_INCREMENT; i++)
   {
diff --git a/Common/DataModel/Testing/Cxx/TestPlane.cxx b/Common/DataModel/Testing/Cxx/TestPlane.cxx
index 59ab42e562b821da6353f6c5b5b611455282d600..b936f251c7a1750e1520856c12db475fc543ebbb 100644
--- a/Common/DataModel/Testing/Cxx/TestPlane.cxx
+++ b/Common/DataModel/Testing/Cxx/TestPlane.cxx
@@ -9,16 +9,13 @@
 #include "vtkPoints.h"
 #include "vtkSmartPointer.h"
 
+#include <cmath>
 #include <limits>
 
-#ifndef ABS
-#define ABS(x) ((x) < 0 ? -(x) : (x))
-#endif
-
 template <class A>
 bool fuzzyCompare1D(A a, A b)
 {
-  return ABS(a - b) < std::numeric_limits<A>::epsilon();
+  return std::abs(a - b) < std::numeric_limits<A>::epsilon();
 }
 
 template <class A>
diff --git a/Common/DataModel/vtkPlane.h b/Common/DataModel/vtkPlane.h
index 0623695137c0ee630f6c9d7873c59b9a17383a71..c0ca0cc926a6d91850304095789d203e276207bb 100644
--- a/Common/DataModel/vtkPlane.h
+++ b/Common/DataModel/vtkPlane.h
@@ -16,6 +16,8 @@
 #include "vtkCommonDataModelModule.h" // For export macro
 #include "vtkImplicitFunction.h"
 
+#include <cmath> // for std::abs
+
 VTK_ABI_NAMESPACE_BEGIN
 class vtkPoints; // forward declaration
 
@@ -226,8 +228,7 @@ inline double vtkPlane::Evaluate(double normal[3], double origin[3], double x[3]
 // Assumes normal is normalized
 inline double vtkPlane::DistanceToPlane(double x[3], double n[3], double p0[3])
 {
-#define vtkPlaneAbs(x) ((x) < 0 ? -(x) : (x))
-  return (vtkPlaneAbs(n[0] * (x[0] - p0[0]) + n[1] * (x[1] - p0[1]) + n[2] * (x[2] - p0[2])));
+  return (std::abs(n[0] * (x[0] - p0[0]) + n[1] * (x[1] - p0[1]) + n[2] * (x[2] - p0[2])));
 }
 
 VTK_ABI_NAMESPACE_END
diff --git a/Common/ExecutionModel/vtkExtentSplitter.cxx b/Common/ExecutionModel/vtkExtentSplitter.cxx
index ad2bd6b8b0c6e224d2b72907b0ae6e8714c7ea64..5f49862d6985b0d4d369ca2efcb7c7ff563446da 100644
--- a/Common/ExecutionModel/vtkExtentSplitter.cxx
+++ b/Common/ExecutionModel/vtkExtentSplitter.cxx
@@ -4,6 +4,7 @@
 
 #include "vtkObjectFactory.h"
 
+#include <algorithm>
 #include <map>
 #include <queue>
 #include <vector>
@@ -435,12 +436,12 @@ int vtkExtentSplitter::IntersectExtents(const int* extent1, const int* extent2,
   }
 
   // Get the intersection of the extents.
-  result[0] = this->Max(extent1[0], extent2[0]);
-  result[1] = this->Min(extent1[1], extent2[1]);
-  result[2] = this->Max(extent1[2], extent2[2]);
-  result[3] = this->Min(extent1[3], extent2[3]);
-  result[4] = this->Max(extent1[4], extent2[4]);
-  result[5] = this->Min(extent1[5], extent2[5]);
+  result[0] = std::max(extent1[0], extent2[0]);
+  result[1] = std::min(extent1[1], extent2[1]);
+  result[2] = std::max(extent1[2], extent2[2]);
+  result[3] = std::min(extent1[3], extent2[3]);
+  result[4] = std::max(extent1[4], extent2[4]);
+  result[5] = std::min(extent1[5], extent2[5]);
 
   return 1;
 }
@@ -448,12 +449,12 @@ int vtkExtentSplitter::IntersectExtents(const int* extent1, const int* extent2,
 //------------------------------------------------------------------------------
 int vtkExtentSplitter::Min(int a, int b)
 {
-  return (a < b) ? a : b;
+  return std::min(a, b);
 }
 
 //------------------------------------------------------------------------------
 int vtkExtentSplitter::Max(int a, int b)
 {
-  return (a > b) ? a : b;
+  return std::max(a, b);
 }
 VTK_ABI_NAMESPACE_END
diff --git a/Common/ExecutionModel/vtkExtentSplitter.h b/Common/ExecutionModel/vtkExtentSplitter.h
index 449910c9a0c450184f32f6230b070b9adcc56522..ab3cf7564af8c57daad0208dc4770732d58c8f0c 100644
--- a/Common/ExecutionModel/vtkExtentSplitter.h
+++ b/Common/ExecutionModel/vtkExtentSplitter.h
@@ -18,6 +18,7 @@
 #define vtkExtentSplitter_h
 
 #include "vtkCommonExecutionModelModule.h" // For export macro
+#include "vtkDeprecation.h"                // For VTK_DEPRECATED_IN_9_5_0
 #include "vtkObject.h"
 
 VTK_ABI_NAMESPACE_BEGIN
@@ -104,7 +105,9 @@ protected:
   // Internal utility methods.
   void SplitExtent(int* extent, int* subextent);
   int IntersectExtents(const int* extent1, const int* extent2, int* result);
+  VTK_DEPRECATED_IN_9_5_0("Use std::min instead")
   int Min(int a, int b);
+  VTK_DEPRECATED_IN_9_5_0("Use std::max instead")
   int Max(int a, int b);
 
   // Internal implementation data.
diff --git a/Documentation/release/dev/custom-min-max-impls.md b/Documentation/release/dev/custom-min-max-impls.md
new file mode 100644
index 0000000000000000000000000000000000000000..20bf0ebaf855115ee2322d5c9eac6ed695077edd
--- /dev/null
+++ b/Documentation/release/dev/custom-min-max-impls.md
@@ -0,0 +1,6 @@
+## custom-min-max-impls
+
+* `vtkExtentSplitter::Min` and `::Max` have been deprecated in favor of
+  `std::min` and `std::max`.
+* `vtkXMLReader::Min` and `::Max` have been deprecated in favor of `std::min`
+  and `std::max`.
diff --git a/IO/MPIImage/vtkMPIImageReader.cxx b/IO/MPIImage/vtkMPIImageReader.cxx
index 8c03e9c1fffacd2e25074c181bf2f30553be9d2e..0dc8a6b51349f5b4adc3975aaaff05d3643220db 100644
--- a/IO/MPIImage/vtkMPIImageReader.cxx
+++ b/IO/MPIImage/vtkMPIImageReader.cxx
@@ -10,6 +10,9 @@
 // Include the MPI headers and then determine if MPIIO is available.
 #include "vtkMPI.h"
 
+#include <algorithm>
+#include <cmath>
+
 #ifdef MPI_VERSION
 #if (MPI_VERSION >= 2)
 #define VTK_USE_MPI_IO 1
@@ -93,24 +96,6 @@ void vtkMPIImageReaderMaskBits(double*, vtkIdType, vtkTypeUInt64)
 }
 #endif // VTK_USE_MPI_IO
 
-//------------------------------------------------------------------------------
-#ifdef VTK_USE_MPI_IO
-namespace
-{
-template <class T>
-inline T MY_ABS(T x)
-{
-  return (x < 0) ? -x : x;
-}
-
-template <class T>
-inline T MY_MIN(T x, T y)
-{
-  return (x < y) ? x : y;
-}
-};
-#endif // VTK_USE_MPI_IO
-
 //=============================================================================
 vtkMPIImageReader::vtkMPIImageReader()
 {
@@ -335,10 +320,10 @@ void vtkMPIImageReader::TransformData(vtkImageData* data)
   vtkIdType fileExtentSize[3];
   for (int i = 0; i < 3; i++)
   {
-    dataMinExtent[i] = MY_MIN(dataExtent[2 * i], dataExtent[2 * i + 1]);
-    fileMinExtent[i] = MY_MIN(fileExtent[2 * i], fileExtent[2 * i + 1]);
-    dataExtentSize[i] = MY_ABS(dataExtent[2 * i + 1] - dataExtent[2 * i]) + 1;
-    fileExtentSize[i] = MY_ABS(fileExtent[2 * i + 1] - fileExtent[2 * i]) + 1;
+    dataMinExtent[i] = std::min(dataExtent[2 * i], dataExtent[2 * i + 1]);
+    fileMinExtent[i] = std::min(fileExtent[2 * i], fileExtent[2 * i + 1]);
+    dataExtentSize[i] = std::abs(dataExtent[2 * i + 1] - dataExtent[2 * i]) + 1;
+    fileExtentSize[i] = std::abs(fileExtent[2 * i + 1] - fileExtent[2 * i]) + 1;
   }
 
   for (vtkIdType file_k = 0; file_k < fileExtentSize[2]; file_k++)
@@ -442,8 +427,8 @@ void vtkMPIImageReader::ExecuteDataWithInformation(vtkDataObject* output, vtkInf
   // Instead, we just recompute them.
   // this->ComputeInverseTransformedIncrements(inIncrements, outIncrements);
   outIncrements[0] = inIncrements[0];
-  outIncrements[1] = outIncrements[0] * (MY_ABS(outExtent[1] - outExtent[0]) + 1);
-  outIncrements[2] = outIncrements[1] * (MY_ABS(outExtent[3] - outExtent[2]) + 1);
+  outIncrements[1] = outIncrements[0] * (std::abs(outExtent[1] - outExtent[0]) + 1);
+  outIncrements[2] = outIncrements[1] * (std::abs(outExtent[3] - outExtent[2]) + 1);
 
   this->ComputeDataIncrements();
 
diff --git a/IO/MPIImage/vtkPNrrdReader.cxx b/IO/MPIImage/vtkPNrrdReader.cxx
index 16d62086c54f4a26f84895ef342c353f54af9511..c20176b7b0cb270a9f674297aa667dad2a345478 100644
--- a/IO/MPIImage/vtkPNrrdReader.cxx
+++ b/IO/MPIImage/vtkPNrrdReader.cxx
@@ -52,6 +52,9 @@
 #include "vtkTransform.h"
 #include "vtkType.h"
 
+#include <algorithm>
+#include <cmath>
+
 // This macro can be wrapped around MPI function calls to easily report errors.
 // Reporting errors is more important with file I/O because, unlike network I/O,
 // they usually don't terminate the program.
@@ -107,24 +110,6 @@ void vtkPNrrdReaderMaskBits(double*, vtkIdType, vtkTypeUInt64)
 }
 #endif // VTK_USE_MPI_IO
 
-//------------------------------------------------------------------------------
-#ifdef VTK_USE_MPI_IO
-namespace
-{
-template <class T>
-inline T MY_ABS(T x)
-{
-  return (x < 0) ? -x : x;
-}
-
-template <class T>
-inline T MY_MIN(T x, T y)
-{
-  return (x < y) ? x : y;
-}
-};
-#endif // VTK_USE_MPI_IO
-
 //------------------------------------------------------------------------------
 vtkPNrrdReader::vtkPNrrdReader()
 {
@@ -347,10 +332,10 @@ void vtkPNrrdReader::TransformData(vtkImageData* data)
   vtkIdType fileExtentSize[3];
   for (int i = 0; i < 3; i++)
   {
-    dataMinExtent[i] = MY_MIN(dataExtent[2 * i], dataExtent[2 * i + 1]);
-    fileMinExtent[i] = MY_MIN(fileExtent[2 * i], fileExtent[2 * i + 1]);
-    dataExtentSize[i] = MY_ABS(dataExtent[2 * i + 1] - dataExtent[2 * i]) + 1;
-    fileExtentSize[i] = MY_ABS(fileExtent[2 * i + 1] - fileExtent[2 * i]) + 1;
+    dataMinExtent[i] = std::min(dataExtent[2 * i], dataExtent[2 * i + 1]);
+    fileMinExtent[i] = std::min(fileExtent[2 * i], fileExtent[2 * i + 1]);
+    dataExtentSize[i] = std::abs(dataExtent[2 * i + 1] - dataExtent[2 * i]) + 1;
+    fileExtentSize[i] = std::abs(fileExtent[2 * i + 1] - fileExtent[2 * i]) + 1;
   }
 
   for (vtkIdType file_k = 0; file_k < fileExtentSize[2]; file_k++)
@@ -454,8 +439,8 @@ void vtkPNrrdReader::ExecuteDataWithInformation(vtkDataObject* output, vtkInform
   // Instead, we just recompute them.
   // this->ComputeInverseTransformedIncrements(inIncrements, outIncrements);
   outIncrements[0] = inIncrements[0];
-  outIncrements[1] = outIncrements[0] * (MY_ABS(outExtent[1] - outExtent[0]) + 1);
-  outIncrements[2] = outIncrements[1] * (MY_ABS(outExtent[3] - outExtent[2]) + 1);
+  outIncrements[1] = outIncrements[0] * (std::abs(outExtent[1] - outExtent[0]) + 1);
+  outIncrements[2] = outIncrements[1] * (std::abs(outExtent[3] - outExtent[2]) + 1);
 
   this->ComputeDataIncrements();
 
diff --git a/IO/XML/vtkXMLReader.cxx b/IO/XML/vtkXMLReader.cxx
index 613c0480c02485e29faf7a3e03cc0539e4919929..36c160b0d4226d2aec7ab546a168480de15d8bba 100644
--- a/IO/XML/vtkXMLReader.cxx
+++ b/IO/XML/vtkXMLReader.cxx
@@ -1621,12 +1621,12 @@ int vtkXMLReader::IntersectExtents(int* extent1, int* extent2, int* result)
   }
 
   // Get the intersection of the extents.
-  result[0] = this->Max(extent1[0], extent2[0]);
-  result[1] = this->Min(extent1[1], extent2[1]);
-  result[2] = this->Max(extent1[2], extent2[2]);
-  result[3] = this->Min(extent1[3], extent2[3]);
-  result[4] = this->Max(extent1[4], extent2[4]);
-  result[5] = this->Min(extent1[5], extent2[5]);
+  result[0] = std::max(extent1[0], extent2[0]);
+  result[1] = std::min(extent1[1], extent2[1]);
+  result[2] = std::max(extent1[2], extent2[2]);
+  result[3] = std::min(extent1[3], extent2[3]);
+  result[4] = std::max(extent1[4], extent2[4]);
+  result[5] = std::min(extent1[5], extent2[5]);
 
   return 1;
 }
@@ -1634,13 +1634,13 @@ int vtkXMLReader::IntersectExtents(int* extent1, int* extent2, int* result)
 //------------------------------------------------------------------------------
 int vtkXMLReader::Min(int a, int b)
 {
-  return (a < b) ? a : b;
+  return std::min(a, b);
 }
 
 //------------------------------------------------------------------------------
 int vtkXMLReader::Max(int a, int b)
 {
-  return (a > b) ? a : b;
+  return std::max(a, b);
 }
 
 //------------------------------------------------------------------------------
diff --git a/IO/XML/vtkXMLReader.h b/IO/XML/vtkXMLReader.h
index bc0a2f7e83443816cd714e167735de593ecad0d8..8940400a8dc4fa1f55a5af176541bbd79bc1ad71 100644
--- a/IO/XML/vtkXMLReader.h
+++ b/IO/XML/vtkXMLReader.h
@@ -13,6 +13,7 @@
 #define vtkXMLReader_h
 
 #include "vtkAlgorithm.h"
+#include "vtkDeprecation.h"  // For VTK_DEPRECATED_IN_9_5_0
 #include "vtkIOXMLModule.h"  // For export macro
 #include "vtkSmartPointer.h" // for vtkSmartPointer.
 
@@ -330,7 +331,9 @@ protected:
    * Utility methods for subclasses.
    */
   int IntersectExtents(int* extent1, int* extent2, int* result);
+  VTK_DEPRECATED_IN_9_5_0("Use std::min instead")
   int Min(int a, int b);
+  VTK_DEPRECATED_IN_9_5_0("Use std::max instead")
   int Max(int a, int b);
   void ComputePointDimensions(int* extent, int* dimensions);
   void ComputePointIncrements(int* extent, vtkIdType* increments);
diff --git a/IO/Xdmf2/vtkXdmfReaderInternal.cxx b/IO/Xdmf2/vtkXdmfReaderInternal.cxx
index 4dab1501a227d6740b98d78ec3ff053dcd9df8d3..5a9275195b1ac7d320bf3118b567c586cefe5708 100644
--- a/IO/Xdmf2/vtkXdmfReaderInternal.cxx
+++ b/IO/Xdmf2/vtkXdmfReaderInternal.cxx
@@ -7,6 +7,8 @@
 #include "vtkVariant.h"
 #include "vtkXdmfDataArray.h"
 
+#include <algorithm>
+
 #define USE_IMAGE_DATA // otherwise uniformgrid
 
 // As soon as num-grids (sub-grids and all) grows beyond this number, we assume
@@ -17,12 +19,6 @@
 using namespace xdmf2;
 
 VTK_ABI_NAMESPACE_BEGIN
-template <class T>
-T vtkMAX(T a, T b)
-{
-  return (a > b ? a : b);
-}
-
 //------------------------------------------------------------------------------
 vtkXdmfDocument::vtkXdmfDocument()
 {
@@ -415,9 +411,9 @@ bool vtkXdmfDomain::GetWholeExtent(XdmfGrid* xmfGrid, int extents[6])
   }
 
   // vtk Dims are i,j,k XDMF are k,j,i
-  extents[5] = vtkMAX(static_cast<XdmfInt64>(0), dimensions[0] - 1);
-  extents[3] = vtkMAX(static_cast<XdmfInt64>(0), dimensions[1] - 1);
-  extents[1] = vtkMAX(static_cast<XdmfInt64>(0), dimensions[2] - 1);
+  extents[5] = std::max<XdmfInt64>(0, dimensions[0] - 1);
+  extents[3] = std::max<XdmfInt64>(0, dimensions[1] - 1);
+  extents[1] = std::max<XdmfInt64>(0, dimensions[2] - 1);
   return true;
 }
 
diff --git a/Infovis/Layout/Testing/Cxx/TestGraphLayoutStrategy.cxx b/Infovis/Layout/Testing/Cxx/TestGraphLayoutStrategy.cxx
index 0e5cca6914c79ae92d25c1a3629536b86a0c7f81..86298abd1cf6d6092c469f28f358f3889bccf70a 100644
--- a/Infovis/Layout/Testing/Cxx/TestGraphLayoutStrategy.cxx
+++ b/Infovis/Layout/Testing/Cxx/TestGraphLayoutStrategy.cxx
@@ -15,6 +15,8 @@
 #include "vtkTestUtilities.h"
 #include "vtkTreeLayoutStrategy.h"
 
+#include <cmath>
+
 #define VTK_CREATE(type, name) vtkSmartPointer<type> name = vtkSmartPointer<type>::New()
 
 int TestGraphLayoutStrategy(int vtkNotUsed(argc), char* vtkNotUsed(argv)[])
@@ -46,7 +48,7 @@ int TestGraphLayoutStrategy(int vtkNotUsed(argc), char* vtkNotUsed(argv)[])
   {
     output->GetPoint(i, pt);
     double dist = pt[0] * pt[0] + pt[1] * pt[1] - 1.0;
-    dist = dist > 0 ? dist : -dist;
+    dist = std::abs(dist);
     if (dist > eps || pt[2] != 0.0)
     {
       cerr << "ERROR: Point " << i << " is not on the unit circle." << endl;
diff --git a/Parallel/Core/vtkSocketCommunicator.cxx b/Parallel/Core/vtkSocketCommunicator.cxx
index b2f3ac859bfd044f63b25ba5d1ad2680f81018d0..e98daea7f23b8b9e9647304128326dce68ddda89 100644
--- a/Parallel/Core/vtkSocketCommunicator.cxx
+++ b/Parallel/Core/vtkSocketCommunicator.cxx
@@ -284,12 +284,6 @@ int vtkSocketCommunicator::SendVoidArray(
   return 1;
 }
 
-//------------------------------------------------------------------------------
-inline vtkIdType vtkSocketCommunicatorMin(vtkIdType a, vtkIdType b)
-{
-  return (a < b) ? a : b;
-}
-
 //------------------------------------------------------------------------------
 int vtkSocketCommunicator::ReceiveVoidArray(
   void* data, vtkIdType length, int type, int remoteProcessId, int tag)
@@ -336,7 +330,7 @@ int vtkSocketCommunicator::ReceiveVoidArray(
   // in an integer, break up the array into pieces.
   int ret = 0;
   while (this->ReceiveTagged(
-    byteData, typeSize, vtkSocketCommunicatorMin(maxReceive, length), tag, typeName.c_str()))
+    byteData, typeSize, std::min<vtkIdType>(maxReceive, length), tag, typeName.c_str()))
   {
     this->Count += this->TagMessageLength;
     byteData += this->TagMessageLength * typeSize;
diff --git a/Parallel/MPI/Testing/Cxx/ExerciseMultiProcessController.cxx b/Parallel/MPI/Testing/Cxx/ExerciseMultiProcessController.cxx
index 2cad45f025d73703b1b81669224036cf5d9ffd79..7889e4e89981291e4b9517dc05e60c20793d69db 100644
--- a/Parallel/MPI/Testing/Cxx/ExerciseMultiProcessController.cxx
+++ b/Parallel/MPI/Testing/Cxx/ExerciseMultiProcessController.cxx
@@ -30,6 +30,7 @@
 #include "vtkUnsignedCharArray.h"
 #include "vtkUnsignedLongArray.h"
 
+#include <cmath>
 #include <string.h>
 #include <time.h>
 #include <vector>
@@ -113,24 +114,18 @@ inline int AreEqual(T a, T b)
   return a == b;
 }
 
-template <class T>
-inline T myAbs(T x)
-{
-  return (x < 0) ? -x : x;
-}
-
 template <>
 inline int AreEqual(float a, float b)
 {
-  float tolerance = myAbs(0.01f * a);
-  return (myAbs(a - b) <= tolerance);
+  float tolerance = std::abs(0.01f * a);
+  return (std::abs(a - b) <= tolerance);
 }
 
 template <>
 inline int AreEqual(double a, double b)
 {
-  double tolerance = myAbs(0.000001f * a);
-  return (myAbs(a - b) <= tolerance);
+  double tolerance = std::abs(0.000001f * a);
+  return (std::abs(a - b) <= tolerance);
 }
 
 //=============================================================================
diff --git a/Parallel/MPI/vtkMPICommunicator.cxx b/Parallel/MPI/vtkMPICommunicator.cxx
index 5e6f318509af9bd2ab7ffaaaa2401fa14861a8c4..202d8a15c2aa8d17c4258e91808ba3c6231d7a20 100644
--- a/Parallel/MPI/vtkMPICommunicator.cxx
+++ b/Parallel/MPI/vtkMPICommunicator.cxx
@@ -13,6 +13,7 @@
 #include "vtkStructuredGrid.h"
 #define VTK_CREATE(type, name) vtkSmartPointer<type> name = vtkSmartPointer<type>::New()
 
+#include <algorithm>
 #include <cassert>
 #include <type_traits> // for std::is_pointer
 #include <vector>
@@ -991,12 +992,6 @@ int vtkMPICommunicator::SendVoidArray(
     tag, mpiType, this->MPIComm->Handle, vtkCommunicator::UseCopy, this->UseSsend));
 }
 
-//------------------------------------------------------------------------------
-inline vtkIdType vtkMPICommunicatorMin(vtkIdType a, vtkIdType b)
-{
-  return (a > b) ? b : a;
-}
-
 //------------------------------------------------------------------------------
 int vtkMPICommunicator::ReceiveVoidArray(
   void* data, vtkIdType maxlength, int type, int remoteProcessId, int tag)
@@ -1042,9 +1037,9 @@ int vtkMPICommunicator::ReceiveVoidArray(
   vtkMPICommunicatorReceiveDataInfo info;
   info.Handle = this->MPIComm->Handle;
   info.DataType = mpiType;
-  while (CheckForMPIError(this->ReceiveDataInternal(byteData,
-           vtkMPICommunicatorMin(maxlength, maxReceive), sizeOfType, remoteProcessId, tag, &info,
-           vtkCommunicator::UseCopy, this->LastSenderId)) != 0)
+  while (
+    CheckForMPIError(this->ReceiveDataInternal(byteData, std::min<vtkIdType>(maxlength, maxReceive),
+      sizeOfType, remoteProcessId, tag, &info, vtkCommunicator::UseCopy, this->LastSenderId)) != 0)
   {
     remoteProcessId = this->LastSenderId;
 
diff --git a/Rendering/Annotation/Testing/Cxx/TestConvexHull2D.cxx b/Rendering/Annotation/Testing/Cxx/TestConvexHull2D.cxx
index c0ad91b31c0b1292fe2f4ad816470d71fa6abea3..fad6666a98e177bb39de9bfbd0a73e8f06f2526e 100644
--- a/Rendering/Annotation/Testing/Cxx/TestConvexHull2D.cxx
+++ b/Rendering/Annotation/Testing/Cxx/TestConvexHull2D.cxx
@@ -5,16 +5,14 @@
 #include "vtkPoints.h"
 #include "vtkSmartPointer.h"
 #include "vtkTestUtilities.h"
-#include <limits>
 
-#ifndef ABS
-#define ABS(x) ((x) < 0 ? -(x) : (x))
-#endif
+#include <cmath>
+#include <limits>
 
 template <class A>
 bool fuzzyCompare1Dweak(A a, A b)
 {
-  return ABS(a - b) < 0.000001;
+  return std::abs(a - b) < 0.000001;
 }
 
 template <class A>
diff --git a/Rendering/Core/vtkColorTransferFunction.cxx b/Rendering/Core/vtkColorTransferFunction.cxx
index bbed3c122e56aec41b14f643be8250d12f582bf0..4ea458c63e0adcc4b849a779b5c7aec2b96302f8 100644
--- a/Rendering/Core/vtkColorTransferFunction.cxx
+++ b/Rendering/Core/vtkColorTransferFunction.cxx
@@ -17,8 +17,6 @@
 VTK_ABI_NAMESPACE_BEGIN
 vtkStandardNewMacro(vtkColorTransferFunction);
 
-#define MY_MAX(x, y) ((x) > (y) ? (x) : (y))
-
 //=============================================================================
 class vtkCTFNode
 {
@@ -159,8 +157,8 @@ inline void vtkColorTransferFunctionInterpolateDiverging(
   {
     // Insert the white midpoint by setting one end to white and adjusting the
     // scalar value.
-    double Mmid = MY_MAX(msh1[0], msh2[0]);
-    Mmid = MY_MAX(88.0, Mmid);
+    double Mmid = std::max(msh1[0], msh2[0]);
+    Mmid = std::max(88.0, Mmid);
     if (s < 0.5)
     {
       msh2[0] = Mmid;
diff --git a/Rendering/Label/vtkDynamic2DLabelMapper.cxx b/Rendering/Label/vtkDynamic2DLabelMapper.cxx
index f56ff4ab74f0cf0dcf6894813ecf46c2a8b1c888..19569df392389ceda289f55942007a313965064c 100644
--- a/Rendering/Label/vtkDynamic2DLabelMapper.cxx
+++ b/Rendering/Label/vtkDynamic2DLabelMapper.cxx
@@ -30,6 +30,7 @@
 #include "vtkViewport.h"
 #include "vtksys/FStream.hxx"
 
+#include <cmath>
 #include <fstream>
 
 VTK_ABI_NAMESPACE_BEGIN
@@ -523,8 +524,8 @@ void vtkDynamic2DLabelMapper::RenderOpaqueGeometry(vtkViewport* viewport, vtkAct
       {
         vtkIdType indexJ = index->GetValue(j);
         float* ptj = reinterpret_cast<float*>(pts->GetVoidPointer(3 * indexJ));
-        float absX = (pti[0] - ptj[0]) > 0 ? (pti[0] - ptj[0]) : -(pti[0] - ptj[0]);
-        float absY = (pti[1] - ptj[1]) > 0 ? (pti[1] - ptj[1]) : -(pti[1] - ptj[1]);
+        float absX = std::abs(pti[0] - ptj[0]);
+        float absY = std::abs(pti[1] - ptj[1]);
         float xScale = 2 * absX / (this->LabelWidth[indexI] + this->LabelWidth[indexJ]);
         float yScale = 2 * absY / (this->LabelHeight[indexI] + this->LabelHeight[indexJ]);
         float maxScale = xScale < yScale ? yScale : xScale;
diff --git a/Rendering/Tk/vtkTkImageViewerWidget.cxx b/Rendering/Tk/vtkTkImageViewerWidget.cxx
index 822a90cc468734e696096664bea603565dd27505..5e35040ed77453a715ba58d9099d3a998e8511ef 100644
--- a/Rendering/Tk/vtkTkImageViewerWidget.cxx
+++ b/Rendering/Tk/vtkTkImageViewerWidget.cxx
@@ -20,6 +20,7 @@
 #endif
 #endif
 
+#include <algorithm>
 #include <cstdlib>
 
 #define VTK_ALL_EVENTS_MASK                                                                        \
@@ -27,8 +28,6 @@
     LeaveWindowMask | PointerMotionMask | ExposureMask | VisibilityChangeMask | FocusChangeMask |  \
     PropertyChangeMask | ColormapChangeMask
 
-#define VTK_MAX(a, b) (((a) > (b)) ? (a) : (b))
-
 // These are the options that can be set when the widget is created
 // or with the command configure.  The only new one is "-rw" which allows
 // the uses to set their own ImageViewer window.
@@ -110,8 +109,8 @@ extern "C"
     Tk_Preserve((ClientData)self);
 
     // Handle render call to the widget
-    if (strncmp(argv[1], "render", VTK_MAX(1, strlen(argv[1]))) == 0 ||
-      strncmp(argv[1], "Render", VTK_MAX(1, strlen(argv[1]))) == 0)
+    if (strncmp(argv[1], "render", std::max<size_t>(1, strlen(argv[1]))) == 0 ||
+      strncmp(argv[1], "Render", std::max<size_t>(1, strlen(argv[1]))) == 0)
     {
       // make sure we have a window
       if (self->ImageViewer == nullptr)
@@ -121,7 +120,7 @@ extern "C"
       self->ImageViewer->Render();
     }
     // Handle configure method
-    else if (!strncmp(argv[1], "configure", VTK_MAX(1, strlen(argv[1]))))
+    else if (!strncmp(argv[1], "configure", std::max<size_t>(1, strlen(argv[1]))))
     {
       if (argc == 2)
       {
diff --git a/Rendering/Tk/vtkTkRenderWidget.cxx b/Rendering/Tk/vtkTkRenderWidget.cxx
index 052e697c57150fa3606ee7e4b5be82b58f506aa6..6ddaa5816aa7ac5f907173c8ea571122adfabe9b 100644
--- a/Rendering/Tk/vtkTkRenderWidget.cxx
+++ b/Rendering/Tk/vtkTkRenderWidget.cxx
@@ -24,6 +24,7 @@
 #endif
 #endif
 
+#include <algorithm>
 #include <cstdint>
 #include <cstdlib>
 #include <vector>
@@ -40,8 +41,6 @@
     LeaveWindowMask | PointerMotionMask | ExposureMask | VisibilityChangeMask | FocusChangeMask |  \
     PropertyChangeMask | ColormapChangeMask
 
-#define VTK_MAX(a, b) (((a) > (b)) ? (a) : (b))
-
 // These are the options that can be set when the widget is created
 // or with the command configure.  The only new one is "-rw" which allows
 // the uses to set their own render window.
@@ -393,8 +392,8 @@ extern "C"
     Tk_Preserve((ClientData)self);
 
     // Handle render call to the widget
-    if (strncmp(argv[1], "render", VTK_MAX(1, strlen(argv[1]))) == 0 ||
-      strncmp(argv[1], "Render", VTK_MAX(1, strlen(argv[1]))) == 0)
+    if (strncmp(argv[1], "render", std::max<size_t>(1, strlen(argv[1]))) == 0 ||
+      strncmp(argv[1], "Render", std::max<size_t>(1, strlen(argv[1]))) == 0)
     {
       // make sure we have a window
       if (self->RenderWindow == nullptr)
@@ -404,7 +403,7 @@ extern "C"
       self->RenderWindow->Render();
     }
     // Handle configure method
-    else if (!strncmp(argv[1], "configure", VTK_MAX(1, strlen(argv[1]))))
+    else if (!strncmp(argv[1], "configure", std::max<size_t>(1, strlen(argv[1]))))
     {
       if (argc == 2)
       {