tdf#130977 replace `rtl::math::isFinite` with `std::isfinite`.

- make all calls look like `std::isfinite`.
- change the comments referring `rtl::math::isFinite`.

Change-Id: I0cde9ceb9f20150467b454cddde5e62003cfde1a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/90234
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>

36 files changed, 156 insertions, 156 deletions

diff --git a/basic/source/comp/exprnode.cxx b/basic/source/comp/exprnode.cxx
index 3d2cee0d20fc..9e4c6ea2e6b3 100644
--- a/basic/source/comp/exprnode.cxx
+++ b/basic/source/comp/exprnode.cxx
@@ -402,7 +402,7 @@ void SbiExprNode::FoldConstantsBinaryNode(SbiParser* pParser)
                 default: break;
             }
 
-            if( !::rtl::math::isFinite( nVal ) )
+            if( !std::isfinite( nVal ) )
                 pParser->Error( ERRCODE_BASIC_MATH_OVERFLOW );
 
             // Recover the data type to kill rounding error
diff --git a/basic/source/inc/runtime.hxx b/basic/source/inc/runtime.hxx
index b56f87288753..1b0a3309367d 100644
--- a/basic/source/inc/runtime.hxx
+++ b/basic/source/inc/runtime.hxx
@@ -374,7 +374,7 @@ public:
 
 inline void checkArithmeticOverflow( double d )
 {
-    if( !::rtl::math::isFinite( d ) )
+    if( !std::isfinite( d ) )
         StarBASIC::Error( ERRCODE_BASIC_MATH_OVERFLOW );
 }
 
diff --git a/canvas/source/tools/verifyinput.cxx b/canvas/source/tools/verifyinput.cxx
index 16fc3f8d6a10..b454c0bb593a 100644
--- a/canvas/source/tools/verifyinput.cxx
+++ b/canvas/source/tools/verifyinput.cxx
@@ -54,14 +54,14 @@ namespace canvas::tools
                           ::sal_Int16                               nArgPos )
         {
 #if OSL_DEBUG_LEVEL > 0
-            if( !::rtl::math::isFinite( rPoint.X ) )
+            if( !std::isfinite( rPoint.X ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) + ": verifyInput(): point X value contains infinite or NAN",
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rPoint.Y ) )
+            if( !std::isfinite( rPoint.Y ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) + ": verifyInput(): point X value contains infinite or NAN",
@@ -69,8 +69,8 @@ namespace canvas::tools
             }
 #else
             (void)pStr; (void)xIf; (void)nArgPos;
-            if( !::rtl::math::isFinite( rPoint.X ) ||
-                !::rtl::math::isFinite( rPoint.Y ) )
+            if( !std::isfinite( rPoint.X ) ||
+                !std::isfinite( rPoint.Y ) )
             {
                 throw lang::IllegalArgumentException();
             }
@@ -83,7 +83,7 @@ namespace canvas::tools
                           ::sal_Int16                               nArgPos )
         {
 #if OSL_DEBUG_LEVEL > 0
-            if( !::rtl::math::isFinite( rSegment.Px ) )
+            if( !std::isfinite( rSegment.Px ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -91,7 +91,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rSegment.Py ) )
+            if( !std::isfinite( rSegment.Py ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -99,7 +99,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rSegment.C1x ) )
+            if( !std::isfinite( rSegment.C1x ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -107,7 +107,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rSegment.C1y ) )
+            if( !std::isfinite( rSegment.C1y ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -115,7 +115,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rSegment.C2x ) )
+            if( !std::isfinite( rSegment.C2x ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -123,7 +123,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rSegment.C2y ) )
+            if( !std::isfinite( rSegment.C2y ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii( pStr ) +
@@ -132,12 +132,12 @@ namespace canvas::tools
             }
 #else
             (void)pStr; (void)xIf; (void)nArgPos;
-            if( !::rtl::math::isFinite( rSegment.Px ) ||
-                !::rtl::math::isFinite( rSegment.Py ) ||
-                !::rtl::math::isFinite( rSegment.C1x ) ||
-                !::rtl::math::isFinite( rSegment.C1y ) ||
-                !::rtl::math::isFinite( rSegment.C2x ) ||
-                !::rtl::math::isFinite( rSegment.C2y ) )
+            if( !std::isfinite( rSegment.Px ) ||
+                !std::isfinite( rSegment.Py ) ||
+                !std::isfinite( rSegment.C1x ) ||
+                !std::isfinite( rSegment.C1y ) ||
+                !std::isfinite( rSegment.C2x ) ||
+                !std::isfinite( rSegment.C2y ) )
             {
                 throw lang::IllegalArgumentException();
             }
@@ -150,7 +150,7 @@ namespace canvas::tools
                           ::sal_Int16                               nArgPos )
         {
 #if OSL_DEBUG_LEVEL > 0
-            if( !::rtl::math::isFinite( rRect.X1 ) )
+            if( !std::isfinite( rRect.X1 ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii(pStr) +
@@ -158,7 +158,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rRect.Y1 ) )
+            if( !std::isfinite( rRect.Y1 ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii(pStr) +
@@ -166,7 +166,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rRect.X2 ) )
+            if( !std::isfinite( rRect.X2 ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii(pStr) +
@@ -174,7 +174,7 @@ namespace canvas::tools
                     xIf, nArgPos );
             }
 
-            if( !::rtl::math::isFinite( rRect.Y2 ) )
+            if( !std::isfinite( rRect.Y2 ) )
             {
                 throw lang::IllegalArgumentException(
                     OUString::createFromAscii(pStr) +
@@ -183,10 +183,10 @@ namespace canvas::tools
             }
 #else
             (void)pStr; (void)xIf; (void)nArgPos;
-            if( !::rtl::math::isFinite( rRect.X1 ) ||
-                !::rtl::math::isFinite( rRect.Y1 ) ||
-                !::rtl::math::isFinite( rRect.X2 ) ||
-                !::rtl::math::isFinite( rRect.Y2 ) )
+            if( !std::isfinite( rRect.X1 ) ||
+                !std::isfinite( rRect.Y1 ) ||
+                !std::isfinite( rRect.X2 ) ||
+                !std::isfinite( rRect.Y2 ) )
             {
                 throw lang::IllegalArgumentException();
             }
@@ -200,12 +200,12 @@ namespace canvas::tools
         {
 #if OSL_DEBUG_LEVEL > 0
             const sal_Int32 nBinaryState(
-                100000 * int(!::rtl::math::isFinite( matrix.m00 )) +
-                 10000 * int(!::rtl::math::isFinite( matrix.m01 )) +
-                  1000 * int(!::rtl::math::isFinite( matrix.m02 )) +
-                   100 * int(!::rtl::math::isFinite( matrix.m10 )) +
-                    10 * int(!::rtl::math::isFinite( matrix.m11 )) +
-                     1 * int(!::rtl::math::isFinite( matrix.m12 )) );
+                100000 * int(!std::isfinite( matrix.m00 )) +
+                 10000 * int(!std::isfinite( matrix.m01 )) +
+                  1000 * int(!std::isfinite( matrix.m02 )) +
+                   100 * int(!std::isfinite( matrix.m10 )) +
+                    10 * int(!std::isfinite( matrix.m11 )) +
+                     1 * int(!std::isfinite( matrix.m12 )) );
 
             if( nBinaryState )
             {
@@ -217,12 +217,12 @@ namespace canvas::tools
             }
 #else
             (void)pStr; (void)xIf; (void)nArgPos;
-            if( !::rtl::math::isFinite( matrix.m00 ) ||
-                !::rtl::math::isFinite( matrix.m01 ) ||
-                !::rtl::math::isFinite( matrix.m02 ) ||
-                !::rtl::math::isFinite( matrix.m10 ) ||
-                !::rtl::math::isFinite( matrix.m11 ) ||
-                !::rtl::math::isFinite( matrix.m12 ) )
+            if( !std::isfinite( matrix.m00 ) ||
+                !std::isfinite( matrix.m01 ) ||
+                !std::isfinite( matrix.m02 ) ||
+                !std::isfinite( matrix.m10 ) ||
+                !std::isfinite( matrix.m11 ) ||
+                !std::isfinite( matrix.m12 ) )
             {
                 throw lang::IllegalArgumentException();
             }
@@ -236,10 +236,10 @@ namespace canvas::tools
         {
 #if OSL_DEBUG_LEVEL > 0
             const sal_Int32 nBinaryState(
-                1000 * int(!::rtl::math::isFinite( matrix.m00 )) +
-                 100 * int(!::rtl::math::isFinite( matrix.m01 )) +
-                  10 * int(!::rtl::math::isFinite( matrix.m10 )) +
-                   1 * int(!::rtl::math::isFinite( matrix.m11 )) );
+                1000 * int(!std::isfinite( matrix.m00 )) +
+                 100 * int(!std::isfinite( matrix.m01 )) +
+                  10 * int(!std::isfinite( matrix.m10 )) +
+                   1 * int(!std::isfinite( matrix.m11 )) );
 
             if( nBinaryState )
             {
@@ -251,10 +251,10 @@ namespace canvas::tools
             }
 #else
             (void)pStr; (void)xIf; (void)nArgPos;
-            if( !::rtl::math::isFinite( matrix.m00 ) ||
-                !::rtl::math::isFinite( matrix.m01 ) ||
-                !::rtl::math::isFinite( matrix.m10 ) ||
-                !::rtl::math::isFinite( matrix.m11 ) )
+            if( !std::isfinite( matrix.m00 ) ||
+                !std::isfinite( matrix.m01 ) ||
+                !std::isfinite( matrix.m10 ) ||
+                !std::isfinite( matrix.m11 ) )
             {
                 throw lang::IllegalArgumentException();
             }
@@ -319,7 +319,7 @@ namespace canvas::tools
             verifyInput( texture.AffineTransform,
                          pStr, xIf, nArgPos );
 
-            if( !::rtl::math::isFinite( texture.Alpha ) ||
+            if( !std::isfinite( texture.Alpha ) ||
                 texture.Alpha < 0.0 ||
                 texture.Alpha > 1.0 )
             {
@@ -392,7 +392,7 @@ namespace canvas::tools
 
                 void operator()( const double& rVal )
                 {
-                    if( !::rtl::math::isFinite( rVal ) || rVal < 0.0 )
+                    if( !std::isfinite( rVal ) || rVal < 0.0 )
                     {
 #if OSL_DEBUG_LEVEL > 0
                         throw lang::IllegalArgumentException(
@@ -417,7 +417,7 @@ namespace canvas::tools
                           const uno::Reference< uno::XInterface >&  xIf,
                           ::sal_Int16                               nArgPos )
         {
-            if( !::rtl::math::isFinite( strokeAttributes.StrokeWidth ) ||
+            if( !std::isfinite( strokeAttributes.StrokeWidth ) ||
                 strokeAttributes.StrokeWidth < 0.0 )
             {
 #if OSL_DEBUG_LEVEL > 0
@@ -432,7 +432,7 @@ namespace canvas::tools
 #endif
             }
 
-            if( !::rtl::math::isFinite( strokeAttributes.MiterLimit ) ||
+            if( !std::isfinite( strokeAttributes.MiterLimit ) ||
                 strokeAttributes.MiterLimit < 0.0 )
             {
 #if OSL_DEBUG_LEVEL > 0
@@ -576,7 +576,7 @@ namespace canvas::tools
             verifyInput( fontRequest.FontDescription,
                          pStr, xIf, nArgPos );
 
-            if( !::rtl::math::isFinite( fontRequest.CellSize ) )
+            if( !std::isfinite( fontRequest.CellSize ) )
             {
 #if OSL_DEBUG_LEVEL > 0
                 throw lang::IllegalArgumentException(
@@ -588,7 +588,7 @@ namespace canvas::tools
 #endif
             }
 
-            if( !::rtl::math::isFinite( fontRequest.ReferenceAdvancement ) )
+            if( !std::isfinite( fontRequest.ReferenceAdvancement ) )
             {
 #if OSL_DEBUG_LEVEL > 0
                 throw lang::IllegalArgumentException(
diff --git a/chart2/source/view/axes/ScaleAutomatism.cxx b/chart2/source/view/axes/ScaleAutomatism.cxx
index a53e625c2a7c..b467af2d16b5 100644
--- a/chart2/source/view/axes/ScaleAutomatism.cxx
+++ b/chart2/source/view/axes/ScaleAutomatism.cxx
@@ -318,13 +318,13 @@ void ScaleAutomatism::calculateExplicitIncrementAndScaleForLogarithmic(
     uno::Reference< XScaling > xInverseScaling = xScaling->getInverseScaling();
 
     fSourceMinimum = xScaling->doScaling( fSourceMinimum );
-    if( !::rtl::math::isFinite( fSourceMinimum ) )
+    if( !std::isfinite( fSourceMinimum ) )
         fSourceMinimum = 0.0;
     else if( ::rtl::math::approxEqual( fSourceMinimum, ::rtl::math::approxFloor( fSourceMinimum ) ) )
         fSourceMinimum = ::rtl::math::approxFloor( fSourceMinimum );
 
     fSourceMaximum = xScaling->doScaling( fSourceMaximum );
-    if( !::rtl::math::isFinite( fSourceMaximum ) )
+    if( !std::isfinite( fSourceMaximum ) )
         fSourceMaximum = 0.0;
     else if( ::rtl::math::approxEqual( fSourceMaximum, ::rtl::math::approxFloor( fSourceMaximum ) ) )
         fSourceMaximum = ::rtl::math::approxFloor( fSourceMaximum );
@@ -454,7 +454,7 @@ void ScaleAutomatism::calculateExplicitIncrementAndScaleForLogarithmic(
             if( !bAutoDistance )
             {
                 double fCheck = xInverseScaling->doScaling( fAxisMinimum );
-                if( !::rtl::math::isFinite( fCheck ) || fCheck <= 0 )
+                if( !std::isfinite( fCheck ) || fCheck <= 0 )
                 {
                     bAutoDistance = true;
                     bHasCalculatedDistance = false;
@@ -470,7 +470,7 @@ void ScaleAutomatism::calculateExplicitIncrementAndScaleForLogarithmic(
             if( !bAutoDistance )
             {
                 double fCheck = xInverseScaling->doScaling( fAxisMaximum );
-                if( !::rtl::math::isFinite( fCheck ) || fCheck <= 0 )
+                if( !std::isfinite( fCheck ) || fCheck <= 0 )
                 {
                     bAutoDistance = true;
                     bHasCalculatedDistance = false;
@@ -505,16 +505,16 @@ void ScaleAutomatism::calculateExplicitIncrementAndScaleForLogarithmic(
         rExplicitScale.Maximum = xInverseScaling->doScaling( rExplicitScale.Maximum );
 
         //ensure valid values after scaling #i100995#
-        if( !::rtl::math::isFinite( rExplicitScale.Minimum ) || rExplicitScale.Minimum <= 0)
+        if( !std::isfinite( rExplicitScale.Minimum ) || rExplicitScale.Minimum <= 0)
         {
             rExplicitScale.Minimum = fInputMinimum;
-            if( !::rtl::math::isFinite( rExplicitScale.Minimum ) || rExplicitScale.Minimum <= 0 )
+            if( !std::isfinite( rExplicitScale.Minimum ) || rExplicitScale.Minimum <= 0 )
                 rExplicitScale.Minimum = 1.0;
         }
-        if( !::rtl::math::isFinite( rExplicitScale.Maximum) || rExplicitScale.Maximum <= 0 )
+        if( !std::isfinite( rExplicitScale.Maximum) || rExplicitScale.Maximum <= 0 )
         {
             rExplicitScale.Maximum= fInputMaximum;
-            if( !::rtl::math::isFinite( rExplicitScale.Maximum) || rExplicitScale.Maximum <= 0 )
+            if( !std::isfinite( rExplicitScale.Maximum) || rExplicitScale.Maximum <= 0 )
                 rExplicitScale.Maximum = 10.0;
         }
         if( rExplicitScale.Maximum < rExplicitScale.Minimum )
@@ -867,7 +867,7 @@ void ScaleAutomatism::calculateExplicitIncrementAndScaleForLinear(
                     fDistanceNormalized = 1.0;
                     fDistanceMagnitude = 1.0e-307;
                 }
-                else if ( !rtl::math::isFinite(fDistance) )
+                else if ( !std::isfinite(fDistance) )
                 {
                     // fdo#43703: Handle values bigger than limits correctly
                     fDistanceNormalized = 1.0;
diff --git a/chart2/source/view/axes/Tickmarks_Equidistant.cxx b/chart2/source/view/axes/Tickmarks_Equidistant.cxx
index 485fbd58b366..d678b58e56ad 100644
--- a/chart2/source/view/axes/Tickmarks_Equidistant.cxx
+++ b/chart2/source/view/axes/Tickmarks_Equidistant.cxx
@@ -112,12 +112,12 @@ EquidistantTickFactory::EquidistantTickFactory(
 
         //check validity of new range: m_fOuterMajorTickBorderMin <-> m_fOuterMajorTickBorderMax
         //it is assumed here, that the original range in the given Scale is valid
-        if( !rtl::math::isFinite(m_fOuterMajorTickBorderMin_Scaled) )
+        if( !std::isfinite(m_fOuterMajorTickBorderMin_Scaled) )
         {
             m_fOuterMajorTickBorderMin += m_rIncrement.Distance;
             m_fOuterMajorTickBorderMin_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMin);
         }
-        if( !rtl::math::isFinite(m_fOuterMajorTickBorderMax_Scaled) )
+        if( !std::isfinite(m_fOuterMajorTickBorderMax_Scaled) )
         {
             m_fOuterMajorTickBorderMax -= m_rIncrement.Distance;
             m_fOuterMajorTickBorderMax_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMax);
@@ -193,7 +193,7 @@ sal_Int32 EquidistantTickFactory::getMaxTickCount( sal_Int32 nDepth ) const
     else
         fSub = approxSub( m_rScale.Maximum, m_rScale.Minimum );
 
-    if (!isFinite(fSub))
+    if (!std::isfinite(fSub))
         return 0;
 
     double fIntervalCount = fSub / m_rIncrement.Distance;
diff --git a/chart2/source/view/charttypes/NetChart.cxx b/chart2/source/view/charttypes/NetChart.cxx
index 2f99bece1cfc..6c4a202a7bc4 100644
--- a/chart2/source/view/charttypes/NetChart.cxx
+++ b/chart2/source/view/charttypes/NetChart.cxx
@@ -125,7 +125,7 @@ bool NetChart::impl_createLine( VDataSeries* pSeries
             double fFirstY = pSeries->getYValue( 0 );
             double fLastY = pSeries->getYValue( VSeriesPlotter::getPointCount() - 1 );
             if( (pSeries->getMissingValueTreatment() != css::chart::MissingValueTreatment::LEAVE_GAP)
-                || (::rtl::math::isFinite( fFirstY ) && ::rtl::math::isFinite( fLastY )) )
+                || (std::isfinite( fFirstY ) && std::isfinite( fLastY )) )
             {
                 // connect last point in last polygon with first point in first polygon
                 ::basegfx::B2DRectangle aScaledLogicClipDoubleRect( pPosHelper->getScaledLogicClipDoubleRect() );
diff --git a/chart2/source/view/charttypes/VSeriesPlotter.cxx b/chart2/source/view/charttypes/VSeriesPlotter.cxx
index c971bf04e1ec..b9affd0e9f88 100644
--- a/chart2/source/view/charttypes/VSeriesPlotter.cxx
+++ b/chart2/source/view/charttypes/VSeriesPlotter.cxx
@@ -871,8 +871,8 @@ double lcl_getErrorBarLogicLength(
                         if(fMaxValue<*pValues)
                             fMaxValue=*pValues;
                     }
-                    if( ::rtl::math::isFinite( fMaxValue ) &&
-                        ::rtl::math::isFinite( fPercent ))
+                    if( std::isfinite( fMaxValue ) &&
+                        std::isfinite( fPercent ))
                     {
                         fResult = fMaxValue * fPercent / 100.0;
                     }
@@ -1039,7 +1039,7 @@ void VSeriesPlotter::createErrorBar(
         if( bShowPositive )
         {
             double fLength = lcl_getErrorBarLogicLength( aData, xErrorBarProperties, nErrorBarStyle, nIndex, true, bYError );
-            if( ::rtl::math::isFinite( fLength ) )
+            if( std::isfinite( fLength ) )
             {
                 double fLocalX = fX;
                 double fLocalY = fY;
@@ -1062,7 +1062,7 @@ void VSeriesPlotter::createErrorBar(
         if( bShowNegative )
         {
             double fLength = lcl_getErrorBarLogicLength( aData, xErrorBarProperties, nErrorBarStyle, nIndex, false, bYError );
-            if( ::rtl::math::isFinite( fLength ) )
+            if( std::isfinite( fLength ) )
             {
                 double fLocalX = fX;
                 double fLocalY = fY;
@@ -1240,10 +1240,10 @@ void VSeriesPlotter::createErrorRectangle(
                                 nErrorBorderStyleY, nIndex, false, true );
         }
 
-        if ( !( ::rtl::math::isFinite( fPosX ) &&
-                ::rtl::math::isFinite( fPosY ) &&
-                ::rtl::math::isFinite( fNegX ) &&
-                ::rtl::math::isFinite( fNegY ) ) )
+        if ( !( std::isfinite( fPosX ) &&
+                std::isfinite( fPosY ) &&
+                std::isfinite( fNegX ) &&
+                std::isfinite( fNegY ) ) )
             return;
 
         drawing::Position3D aBottomLeft( lcl_transformMixedToScene( m_pPosHelper,
diff --git a/chart2/source/view/inc/PlottingPositionHelper.hxx b/chart2/source/view/inc/PlottingPositionHelper.hxx
index 74fc37cdea80..e3d761136fe6 100644
--- a/chart2/source/view/inc/PlottingPositionHelper.hxx
+++ b/chart2/source/view/inc/PlottingPositionHelper.hxx
@@ -247,8 +247,8 @@ void PlottingPositionHelper::setCoordinateSystemResolution( const css::uno::Sequ
 bool PlottingPositionHelper::isSameForGivenResolution( double fX, double fY, double fZ
                                 , double fX2, double fY2, double fZ2 /*these values are all expected tp be scaled already*/ )
 {
-    if( !::rtl::math::isFinite(fX) || !::rtl::math::isFinite(fY) || !::rtl::math::isFinite(fZ)
-        || !::rtl::math::isFinite(fX2) || !::rtl::math::isFinite(fY2) || !::rtl::math::isFinite(fZ2) )
+    if( !std::isfinite(fX) || !std::isfinite(fY) || !std::isfinite(fZ)
+        || !std::isfinite(fX2) || !std::isfinite(fY2) || !std::isfinite(fZ2) )
         return false;
 
     double fScaledMinX = getLogicMinX();
diff --git a/forms/source/xforms/convert.cxx b/forms/source/xforms/convert.cxx
index 86dcdf63c329..55398f8a2c5c 100644
--- a/forms/source/xforms/convert.cxx
+++ b/forms/source/xforms/convert.cxx
@@ -75,7 +75,7 @@ namespace
         double f = 0.0;
         rAny >>= f;
 
-        return rtl::math::isFinite( f )
+        return std::isfinite( f )
             ? rtl::math::doubleToUString( f, rtl_math_StringFormat_Automatic,
                                         rtl_math_DecimalPlaces_Max, '.',
                                         true )
diff --git a/include/formula/errorcodes.hxx b/include/formula/errorcodes.hxx
index 7afce495b6de..a6095678c0e5 100644
--- a/include/formula/errorcodes.hxx
+++ b/include/formula/errorcodes.hxx
@@ -104,7 +104,7 @@ inline double CreateDoubleError( FormulaError nErr )
 /** Recreate the error code of a coded double error, if any. */
 inline FormulaError GetDoubleErrorValue( double fVal )
 {
-    if ( ::rtl::math::isFinite( fVal ) )
+    if ( std::isfinite( fVal ) )
         return FormulaError::NONE;
     if ( ::rtl::math::isInf( fVal ) )
         return FormulaError::IllegalFPOperation;       // normal INF
diff --git a/sal/rtl/math.cxx b/sal/rtl/math.cxx
index af1457eac937..5f52b96a34c7 100644
--- a/sal/rtl/math.cxx
+++ b/sal/rtl/math.cxx
@@ -198,7 +198,7 @@ int findFirstSetBit(unsigned n)
  */
 int getBitsInFracPart(double fAbsValue)
 {
-    assert(rtl::math::isFinite(fAbsValue) && fAbsValue >= 0.0);
+    assert(std::isfinite(fAbsValue) && fAbsValue >= 0.0);
     if (fAbsValue == 0.0)
         return 0;
     auto pValParts = reinterpret_cast< const sal_math_Double * >(&fAbsValue);
@@ -1160,7 +1160,7 @@ double SAL_CALL rtl_math_pow10Exp(double fValue, int nExp) SAL_THROW_EXTERN_C()
 double SAL_CALL rtl_math_approxValue( double fValue ) SAL_THROW_EXTERN_C()
 {
     const double fBigInt = 2199023255552.0; // 2^41 -> only 11 bits left for fractional part, fine as decimal
-    if (fValue == 0.0 || fValue == HUGE_VAL || !::rtl::math::isFinite( fValue) || fValue > fBigInt)
+    if (fValue == 0.0 || fValue == HUGE_VAL || !std::isfinite( fValue) || fValue > fBigInt)
     {
         // We don't handle these conditions.  Bail out.
         return fValue;
@@ -1184,7 +1184,7 @@ double SAL_CALL rtl_math_approxValue( double fValue ) SAL_THROW_EXTERN_C()
     fValue *= fExpValue;
     // If the original value was near DBL_MIN we got an overflow. Restore and
     // bail out.
-    if (!rtl::math::isFinite(fValue))
+    if (!std::isfinite(fValue))
         return fOrigValue;
 
     fValue = rtl_math_round(fValue, 0, rtl_math_RoundingMode_Corrected);
@@ -1192,7 +1192,7 @@ double SAL_CALL rtl_math_approxValue( double fValue ) SAL_THROW_EXTERN_C()
 
     // If the original value was near DBL_MAX we got an overflow. Restore and
     // bail out.
-    if (!rtl::math::isFinite(fValue))
+    if (!std::isfinite(fValue))
         return fOrigValue;
 
     return bSign ? -fValue : fValue;
@@ -1210,7 +1210,7 @@ bool SAL_CALL rtl_math_approxEqual(double a, double b) SAL_THROW_EXTERN_C()
         return false;
 
     const double d = fabs(a - b);
-    if (!rtl::math::isFinite(d))
+    if (!std::isfinite(d))
         return false;   // Nan or Inf involved
 
     if (d > ((a = fabs(a)) * e44) || d > ((b = fabs(b)) * e44))
diff --git a/sc/inc/math.hxx b/sc/inc/math.hxx
index 80b6ed17b68b..5c76a657b381 100644
--- a/sc/inc/math.hxx
+++ b/sc/inc/math.hxx
@@ -53,7 +53,7 @@ inline double divide( const double& fNumerator, const double& fDenominator )
     if (fDenominator == 0.0)
     {
         double fVal;
-        if (rtl::math::isFinite( fNumerator) && fNumerator != 0.0)
+        if (std::isfinite( fNumerator) && fNumerator != 0.0)
         {
             rtl::math::setInf( &fVal, rtl::math::isSignBitSet( fNumerator));
         }
diff --git a/sc/source/core/data/dpoutput.cxx b/sc/source/core/data/dpoutput.cxx
index efda0ab8da23..5e6222b495f6 100644
--- a/sc/source/core/data/dpoutput.cxx
+++ b/sc/source/core/data/dpoutput.cxx
@@ -747,7 +747,7 @@ void ScDPOutput::HeaderCell( SCCOL nCol, SCROW nRow, SCTAB nTab,
     if ( nFlags & sheet::MemberResultFlags::HASMEMBER )
     {
         bool bNumeric = (nFlags & sheet::MemberResultFlags::NUMERIC) != 0;
-        if (bNumeric && rtl::math::isFinite( rData.Value))
+        if (bNumeric && std::isfinite( rData.Value))
         {
             pDoc->SetValue( nCol, nRow, nTab, rData.Value);
         }
diff --git a/sc/source/core/data/formulacell.cxx b/sc/source/core/data/formulacell.cxx
index d1e4a6970c36..90f7c70b01e7 100644
--- a/sc/source/core/data/formulacell.cxx
+++ b/sc/source/core/data/formulacell.cxx
@@ -1418,7 +1418,7 @@ void ScFormulaCell::CalcAfterLoad( sc::CompileFormulaContext& rCxt, bool bStartL
     // On OS/2 with broken FPU exception, we can somehow store /0 without Err503. Later on in
     // the BLC Lib NumberFormatter crashes when doing a fabs (NAN) (# 32739 #).
     // We iron this out here for all systems, such that we also have an Err503 here.
-    if ( aResult.IsValue() && !::rtl::math::isFinite( aResult.GetDouble() ) )
+    if ( aResult.IsValue() && !std::isfinite( aResult.GetDouble() ) )
     {
         OSL_FAIL("Formula cell INFINITY!!! Where does this document come from?");
         aResult.SetResultError( FormulaError::IllegalFPOperation );
@@ -2234,7 +2234,7 @@ void ScFormulaCell::InterpretTail( ScInterpreterContext& rContext, ScInterpretTa
             if( cMatrixFlag != ScMatrixMode::Formula && !pCode->IsHyperLink() )
                 aResult.SetToken( aResult.GetCellResultToken().get());
         }
-        if ( aResult.IsValue() && !::rtl::math::isFinite( aResult.GetDouble() ) )
+        if ( aResult.IsValue() && !std::isfinite( aResult.GetDouble() ) )
         {
             // Coded double error may occur via filter import.
             FormulaError nErr = GetDoubleErrorValue( aResult.GetDouble());
diff --git a/sc/source/core/inc/arraysumfunctor.hxx b/sc/source/core/inc/arraysumfunctor.hxx
index 5006064af9e7..fb3285842812 100644
--- a/sc/source/core/inc/arraysumfunctor.hxx
+++ b/sc/source/core/inc/arraysumfunctor.hxx
@@ -63,7 +63,7 @@ public:
 
         // If the sum is a NaN, some of the terms were empty cells, probably.
         // Re-calculate, carefully
-        if (!rtl::math::isFinite(fSum))
+        if (!std::isfinite(fSum))
         {
             sal_uInt32 nErr = reinterpret_cast< sal_math_Double * >(&fSum)->nan_parts.fraction_lo;
             if (nErr & 0xffff0000)
@@ -71,7 +71,7 @@ public:
                 fSum = 0;
                 for (i = 0; i < mnSize; i++)
                 {
-                    if (!rtl::math::isFinite(mpArray[i]))
+                    if (!std::isfinite(mpArray[i]))
                     {
                         nErr = reinterpret_cast< const sal_math_Double * >(&mpArray[i])->nan_parts.fraction_lo;
                         if (!(nErr & 0xffff0000))
diff --git a/sc/source/core/inc/interpre.hxx b/sc/source/core/inc/interpre.hxx
index f764d7ae1ec2..4cecd7ef3058 100644
--- a/sc/source/core/inc/interpre.hxx
+++ b/sc/source/core/inc/interpre.hxx
@@ -1088,7 +1088,7 @@ inline bool ScInterpreter::MustHaveParamCountMin( short nAct, short nMin )
 
 inline bool ScInterpreter::CheckStringPositionArgument( double & fVal )
 {
-    if (!rtl::math::isFinite( fVal))
+    if (!std::isfinite( fVal))
     {
         fVal = -1.0;
         return false;
@@ -1141,7 +1141,7 @@ inline bool ScInterpreter::CheckStringResultLen( OUStringBuffer& rResult, const
 
 inline void ScInterpreter::TreatDoubleError( double& rVal )
 {
-    if ( !::rtl::math::isFinite( rVal ) )
+    if ( !std::isfinite( rVal ) )
     {
         FormulaError nErr = GetDoubleErrorValue( rVal );
         if ( nErr != FormulaError::NONE )
diff --git a/sc/source/core/tool/compare.cxx b/sc/source/core/tool/compare.cxx
index 2a2cf71ded7c..f1c5fa3979c8 100644
--- a/sc/source/core/tool/compare.cxx
+++ b/sc/source/core/tool/compare.cxx
@@ -57,9 +57,9 @@ double CompareFunc( const Compare& rComp, CompareOptions* pOptions )
 
     // Keep DoubleError if encountered
     // #i40539# if bEmpty is set, bVal/nVal are uninitialized
-    if (!rCell1.mbEmpty && rCell1.mbValue && !rtl::math::isFinite(rCell1.mfValue))
+    if (!rCell1.mbEmpty && rCell1.mbValue && !std::isfinite(rCell1.mfValue))
         return rCell1.mfValue;
-    if (!rCell2.mbEmpty && rCell2.mbValue && !rtl::math::isFinite(rCell2.mfValue))
+    if (!rCell2.mbEmpty && rCell2.mbValue && !std::isfinite(rCell2.mfValue))
         return rCell2.mfValue;
 
     size_t nStringQuery = 0;    // 0:=no, 1:=0, 2:=1
@@ -229,9 +229,9 @@ double CompareFunc( const Compare::Cell& rCell1, double fCell2, const CompareOpt
 {
     // Keep DoubleError if encountered
     // #i40539# if bEmpty is set, bVal/nVal are uninitialized
-    if (!rCell1.mbEmpty && rCell1.mbValue && !rtl::math::isFinite(rCell1.mfValue))
+    if (!rCell1.mbEmpty && rCell1.mbValue && !std::isfinite(rCell1.mfValue))
         return rCell1.mfValue;
-    if (!rtl::math::isFinite(fCell2))
+    if (!std::isfinite(fCell2))
         return fCell2;
 
     bool bStringQuery = false;
@@ -291,9 +291,9 @@ double CompareFunc( double fCell1, double fCell2 )
 {
     // Keep DoubleError if encountered
     // #i40539# if bEmpty is set, bVal/nVal are uninitialized
-    if (!rtl::math::isFinite(fCell1))
+    if (!std::isfinite(fCell1))
         return fCell1;
-    if (!rtl::math::isFinite(fCell2))
+    if (!std::isfinite(fCell2))
         return fCell2;
 
     double fRes = 0.0;
@@ -313,7 +313,7 @@ double CompareEmptyToNumericFunc( double fCell2 )
 {
     // Keep DoubleError if encountered
     // #i40539# if bEmpty is set, bVal/nVal are uninitialized
-    if (!rtl::math::isFinite(fCell2))
+    if (!std::isfinite(fCell2))
         return fCell2;
 
     double fRes = 0;
diff --git a/sc/source/core/tool/interpr1.cxx b/sc/source/core/tool/interpr1.cxx
index ecacb21a1a59..4daf1afaa169 100644
--- a/sc/source/core/tool/interpr1.cxx
+++ b/sc/source/core/tool/interpr1.cxx
@@ -125,7 +125,7 @@ void ScInterpreter::ScIfJump()
                             if (bIsValue)
                             {
                                 fVal = pMat->GetDouble(nC, nR);
-                                bIsValue = ::rtl::math::isFinite(fVal);
+                                bIsValue = std::isfinite(fVal);
                                 bTrue = bIsValue && (fVal != 0.0);
                                 if (bTrue)
                                     fVal = 1.0;
@@ -448,7 +448,7 @@ void ScInterpreter::ScChooseJump()
                             if ( bIsValue )
                             {
                                 fVal = pMat->GetDouble(nC, nR);
-                                bIsValue = ::rtl::math::isFinite( fVal );
+                                bIsValue = std::isfinite( fVal );
                                 if ( bIsValue )
                                 {
                                     fVal = ::rtl::math::approxFloor( fVal);
@@ -3774,7 +3774,7 @@ void ScInterpreter::ScMin( bool bTextAsZero )
     }
     else
     {
-        if (!rtl::math::isFinite(nVal))
+        if (!std::isfinite(nVal))
             PushError( GetDoubleErrorValue( nVal));
         else if ( nVal < nMin  )
             PushDouble(0.0);    // zero or only empty arguments
@@ -3932,7 +3932,7 @@ void ScInterpreter::ScMax( bool bTextAsZero )
     }
     else
     {
-        if (!rtl::math::isFinite(nVal))
+        if (!std::isfinite(nVal))
             PushError( GetDoubleErrorValue( nVal));
         else if ( nVal > nMax  )
             PushDouble(0.0);    // zero or only empty arguments
@@ -4714,7 +4714,7 @@ sal_Int32 lcl_CompareMatrix2Query(
     if (rMat.IsValue(i))
     {
         const double nVal1 = rMat.GetDouble(i);
-        if (!rtl::math::isFinite(nVal1))
+        if (!std::isfinite(nVal1))
         {
             // XXX Querying for error values is not required, otherwise we'd
             // need to check here.
@@ -6867,7 +6867,7 @@ void ScInterpreter::ScLookup()
             for (SCSIZE i=0; i < nElements; ++i)
             {
                 const double fVal = aMatAcc.GetDouble(i);
-                if (rtl::math::isFinite(fVal))
+                if (std::isfinite(fVal))
                 {
                     vArray.push_back(fVal);
                     vIndex.push_back(i);
diff --git a/sc/source/core/tool/interpr4.cxx b/sc/source/core/tool/interpr4.cxx
index 0369ae5f192a..b76837af51c3 100644
--- a/sc/source/core/tool/interpr4.cxx
+++ b/sc/source/core/tool/interpr4.cxx
@@ -2161,7 +2161,7 @@ double ScInterpreter::GetDoubleWithDefault(double nDefault)
 
 sal_Int32 ScInterpreter::double_to_int32(double fVal)
 {
-    if (!rtl::math::isFinite(fVal))
+    if (!std::isfinite(fVal))
     {
         SetError( GetDoubleErrorValue( fVal));
         return SAL_MAX_INT32;
@@ -2204,7 +2204,7 @@ sal_Int32 ScInterpreter::GetInt32WithDefault( sal_Int32 nDefault )
 sal_Int16 ScInterpreter::GetInt16()
 {
     double fVal = GetDouble();
-    if (!rtl::math::isFinite(fVal))
+    if (!std::isfinite(fVal))
     {
         SetError( GetDoubleErrorValue( fVal));
         return SAL_MAX_INT16;
@@ -2233,7 +2233,7 @@ sal_Int16 ScInterpreter::GetInt16()
 sal_uInt32 ScInterpreter::GetUInt32()
 {
     double fVal = rtl::math::approxFloor( GetDouble());
-    if (!rtl::math::isFinite(fVal))
+    if (!std::isfinite(fVal))
     {
         SetError( GetDoubleErrorValue( fVal));
         return SAL_MAX_UINT32;
diff --git a/sc/source/core/tool/interpr6.cxx b/sc/source/core/tool/interpr6.cxx
index 327fff5b0e68..432796a750b2 100644
--- a/sc/source/core/tool/interpr6.cxx
+++ b/sc/source/core/tool/interpr6.cxx
@@ -420,7 +420,7 @@ static void IterateMatrix(
             ScMatrix::IterateResult aRes = pMat->Sum(bTextAsZero, bIgnoreErrVal);
             // If the first value is a NaN, it probably means it was an empty cell,
             // and should be treated as zero.
-            if ( !rtl::math::isFinite(aRes.mfFirst) )
+            if ( !std::isfinite(aRes.mfFirst) )
             {
                 sal_uInt32 nErr = reinterpret_cast< sal_math_Double * >(&aRes.mfFirst)->nan_parts.fraction_lo;
                 if (nErr & 0xffff0000)
diff --git a/sc/source/core/tool/math.cxx b/sc/source/core/tool/math.cxx
index ffedee1514b5..436b24c94f28 100644
--- a/sc/source/core/tool/math.cxx
+++ b/sc/source/core/tool/math.cxx
@@ -55,7 +55,7 @@ double power( const double& fVal1, const double& fVal2 )
     if ((((math_errhandling & MATH_ERRNO) != 0) && (errno == EDOM || errno == ERANGE))
             || (((math_errhandling & MATH_ERREXCEPT) != 0)
                 && std::fetestexcept( FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW))
-            || !rtl::math::isFinite(fPow))
+            || !std::isfinite(fPow))
     {
         fPow = CreateDoubleError( FormulaError::IllegalFPOperation);
     }
diff --git a/sc/source/core/tool/scmatrix.cxx b/sc/source/core/tool/scmatrix.cxx
index 9aa4ad1b6941..b27f73a10b94 100644
--- a/sc/source/core/tool/scmatrix.cxx
+++ b/sc/source/core/tool/scmatrix.cxx
@@ -96,7 +96,7 @@ struct ElemEqualZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val == 0.0 ? 1.0 : 0.0;
     }
@@ -106,7 +106,7 @@ struct ElemNotEqualZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val != 0.0 ? 1.0 : 0.0;
     }
@@ -116,7 +116,7 @@ struct ElemGreaterZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val > 0.0 ? 1.0 : 0.0;
     }
@@ -126,7 +126,7 @@ struct ElemLessZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val < 0.0 ? 1.0 : 0.0;
     }
@@ -136,7 +136,7 @@ struct ElemGreaterEqualZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val >= 0.0 ? 1.0 : 0.0;
     }
@@ -146,7 +146,7 @@ struct ElemLessEqualZero
 {
     double operator() (double val) const
     {
-        if (!::rtl::math::isFinite(val))
+        if (!std::isfinite(val))
             return val;
         return val <= 0.0 ? 1.0 : 0.0;
     }
@@ -1078,7 +1078,7 @@ double EvalMatrix(const MatrixImplType& rMat)
                 return CreateDoubleError(FormulaError::IllegalArgument);
 
             double fVal = rMat.get_numeric(aPos);
-            if (!::rtl::math::isFinite(fVal))
+            if (!std::isfinite(fVal))
                 // DoubleError
                 return fVal;
 
@@ -1142,7 +1142,7 @@ public:
                 block_type::const_iterator itEnd = block_type::end(*node.data);
                 for (; it != itEnd; ++it)
                 {
-                    if (mbIgnoreErrorValues && !rtl::math::isFinite(*it))
+                    if (mbIgnoreErrorValues && !std::isfinite(*it))
                     {
                         ++nIgnored;
                         continue;
@@ -1317,7 +1317,7 @@ public:
                     block_type::const_iterator itEnd = block_type::end(*node.data);
                     for (; it != itEnd; ++it)
                     {
-                        if (!::rtl::math::isFinite(*it))
+                        if (!std::isfinite(*it))
                             --mnCount;
                     }
                 }
@@ -1466,9 +1466,9 @@ struct MaxOp
     static double init() { return -std::numeric_limits<double>::max(); }
     static double compare(double left, double right)
     {
-        if (!rtl::math::isFinite(left))
+        if (!std::isfinite(left))
             return left;
-        if (!rtl::math::isFinite(right))
+        if (!std::isfinite(right))
             return right;
         return std::max(left, right);
     }
@@ -1488,9 +1488,9 @@ struct MinOp
     static double init() { return std::numeric_limits<double>::max(); }
     static double compare(double left, double right)
     {
-        if (!rtl::math::isFinite(left))
+        if (!std::isfinite(left))
             return left;
-        if (!rtl::math::isFinite(right))
+        if (!std::isfinite(right))
             return right;
         return std::min(left, right);
     }
@@ -1572,7 +1572,7 @@ public:
                 {
                     for (; it != itEnd; ++it)
                     {
-                        if (rtl::math::isFinite(*it))
+                        if (std::isfinite(*it))
                             mfVal = Op::compare(mfVal, *it);
                     }
                 }
@@ -1665,7 +1665,7 @@ public:
 
 double evaluate( double fVal, ScQueryOp eOp )
 {
-    if (!rtl::math::isFinite(fVal))
+    if (!std::isfinite(fVal))
         return fVal;
 
     switch (eOp)
diff --git a/sc/source/core/tool/stringutil.cxx b/sc/source/core/tool/stringutil.cxx
index ebca2a7d96c7..685793b3a18a 100644
--- a/sc/source/core/tool/stringutil.cxx
+++ b/sc/source/core/tool/stringutil.cxx
@@ -56,7 +56,7 @@ bool ScStringUtil::parseSimpleNumber(
     // rtl::math::stringToDouble() just after having exchanged ascii space with
     // non-breaking space, if it wasn't for check of grouped digits. The NaN
     // and Inf cases that are accepted by stringToDouble() could be detected
-    // using rtl::math::isFinite() on the result.
+    // using std::isfinite() on the result.
 
     /* TODO: The grouped digits check isn't even valid for locales that do not
      * group in thousands ... e.g. Indian locales. But that's something also
@@ -207,7 +207,7 @@ bool ScStringUtil::parseSimpleNumber(
     // rtl::math::stringToDouble() just after having exchanged ascii space with
     // non-breaking space, if it wasn't for check of grouped digits. The NaN
     // and Inf cases that are accepted by stringToDouble() could be detected
-    // using rtl::math::isFinite() on the result.
+    // using std::isfinite() on the result.
 
     /* TODO: The grouped digits check isn't even valid for locales that do not
      * group in thousands ... e.g. Indian locales. But that's something also
diff --git a/sc/source/core/tool/subtotal.cxx b/sc/source/core/tool/subtotal.cxx
index bc0d085170d5..5fd8d8cd4324 100644
--- a/sc/source/core/tool/subtotal.cxx
+++ b/sc/source/core/tool/subtotal.cxx
@@ -26,7 +26,7 @@ bool SubTotal::SafePlus(double& fVal1, double fVal2)
     bool bOk = true;
     SAL_MATH_FPEXCEPTIONS_OFF();
     fVal1 += fVal2;
-    if (!::rtl::math::isFinite(fVal1))
+    if (!std::isfinite(fVal1))
     {
         bOk = false;
         if (fVal2 > 0.0)
@@ -42,7 +42,7 @@ bool SubTotal::SafeMult(double& fVal1, double fVal2)
     bool bOk = true;
     SAL_MATH_FPEXCEPTIONS_OFF();
     fVal1 *= fVal2;
-    if (!::rtl::math::isFinite(fVal1))
+    if (!std::isfinite(fVal1))
     {
         bOk = false;
         fVal1 = DBL_MAX;
@@ -55,7 +55,7 @@ bool SubTotal::SafeDiv(double& fVal1, double fVal2)
     bool bOk = true;
     SAL_MATH_FPEXCEPTIONS_OFF();
     fVal1 /= fVal2;
-    if (!::rtl::math::isFinite(fVal1))
+    if (!std::isfinite(fVal1))
     {
         bOk = false;
         fVal1 = DBL_MAX;
diff --git a/sc/source/filter/excel/excform.cxx b/sc/source/filter/excel/excform.cxx
index 2d156acf77d9..9a897f9278e8 100644
--- a/sc/source/filter/excel/excform.cxx
+++ b/sc/source/filter/excel/excform.cxx
@@ -131,7 +131,7 @@ void ImportExcel::Formula(
                 rDoc.getDoc().EnsureTable(aScPos.Tab());
                 rDoc.setFormulaCell(aScPos, pCell);
                 pCell->SetNeedNumberFormat(false);
-                if (rtl::math::isFinite(fCurVal))
+                if (std::isfinite(fCurVal))
                     pCell->SetResultDouble(fCurVal);
 
                 GetXFRangeBuffer().SetXF(aScPos, nXF);
@@ -174,7 +174,7 @@ void ImportExcel::Formula(
         if( eErr != ConvErr::OK )
             ExcelToSc::SetError( *pCell, eErr );
 
-        if (rtl::math::isFinite(fCurVal))
+        if (std::isfinite(fCurVal))
             pCell->SetResultDouble(fCurVal);
     }
 
diff --git a/sc/source/filter/excel/impop.cxx b/sc/source/filter/excel/impop.cxx
index 9f94d7b536af..f130a39fccdd 100644
--- a/sc/source/filter/excel/impop.cxx
+++ b/sc/source/filter/excel/impop.cxx
@@ -850,7 +850,7 @@ void ImportExcel::Shrfmla()
     rDoc.getDoc().EnsureTable(aPos.Tab());
     rDoc.setFormulaCell(aPos, pCell);
     pCell->SetNeedNumberFormat(false);
-    if (rtl::math::isFinite(mpLastFormula->mfValue))
+    if (std::isfinite(mpLastFormula->mfValue))
         pCell->SetResultDouble(mpLastFormula->mfValue);
 
     GetXFRangeBuffer().SetXF(aPos, mpLastFormula->mnXF);
diff --git a/sc/source/filter/excel/xelink.cxx b/sc/source/filter/excel/xelink.cxx
index a01448708cd2..c127947a83b9 100644
--- a/sc/source/filter/excel/xelink.cxx
+++ b/sc/source/filter/excel/xelink.cxx
@@ -1198,7 +1198,7 @@ void XclExpCrn::WriteBool( XclExpStream& rStrm, bool bValue )
 
 void XclExpCrn::WriteDouble( XclExpStream& rStrm, double fValue )
 {
-    if( !::rtl::math::isFinite( fValue ) )
+    if( !std::isfinite( fValue ) )
     {
         FormulaError nScError = GetDoubleErrorValue(fValue);
         WriteError( rStrm, XclTools::GetXclErrorCode( nScError ) );
@@ -1239,7 +1239,7 @@ void XclExpCrn::SaveXml( XclExpXmlStream& rStrm )
         if( rValue.has< double >() )
         {
             double fVal = rValue.get< double >();
-            if (rtl::math::isFinite( fVal))
+            if (std::isfinite( fVal))
             {
                 // t='n' is omitted
                 pFS->startElement(XML_cell, XML_r, XclXmlUtils::ToOString(rStrm.GetRoot().GetDoc(), aAdr));
diff --git a/sc/source/filter/excel/xichart.cxx b/sc/source/filter/excel/xichart.cxx
index fa5e5a25834d..7dd250846761 100644
--- a/sc/source/filter/excel/xichart.cxx
+++ b/sc/source/filter/excel/xichart.cxx
@@ -1645,7 +1645,7 @@ Reference< XRegressionCurve > XclImpChSerTrendLine::CreateRegressionCurve() cons
         aPropSet.SetProperty(EXC_CHPROP_EXTRAPOLATE_FORWARD, maData.mfForecastFor);
         aPropSet.SetProperty(EXC_CHPROP_EXTRAPOLATE_BACKWARD, maData.mfForecastBack);
 
-        bool bForceIntercept = rtl::math::isFinite(maData.mfIntercept);
+        bool bForceIntercept = std::isfinite(maData.mfIntercept);
         aPropSet.SetProperty(EXC_CHPROP_FORCE_INTERCEPT, bForceIntercept);
         if (bForceIntercept)
         {
diff --git a/sc/source/filter/orcus/interface.cxx b/sc/source/filter/orcus/interface.cxx
index 05ff16bccfb4..220f7ce057f9 100644
--- a/sc/source/filter/orcus/interface.cxx
+++ b/sc/source/filter/orcus/interface.cxx
@@ -421,7 +421,7 @@ void ScOrcusFactory::finalize()
             }
             case CellStoreToken::Type::FormulaWithResult:
             {
-                if (rtl::math::isFinite(rToken.mfValue))
+                if (std::isfinite(rToken.mfValue))
                     maDoc.setFormulaCell(rToken.maPos, rToken.maStr1, rToken.meGrammar, &rToken.mfValue);
                 else
                     maDoc.setFormulaCell(rToken.maPos, rToken.maStr1, rToken.meGrammar, rToken.maStr2);
@@ -446,7 +446,7 @@ void ScOrcusFactory::finalize()
                 if (!pCell)
                     break;
 
-                if (rtl::math::isFinite(rToken.mfValue))
+                if (std::isfinite(rToken.mfValue))
                     pCell->SetResultDouble(rToken.mfValue);
                 else
                     pCell->SetHybridString(
diff --git a/sc/source/filter/xml/xmlcelli.cxx b/sc/source/filter/xml/xmlcelli.cxx
index 353bdb429f18..e80cacd3bb6b 100644
--- a/sc/source/filter/xml/xmlcelli.cxx
+++ b/sc/source/filter/xml/xmlcelli.cxx
@@ -1008,7 +1008,7 @@ void ScXMLTableRowCellContext::SetFormulaCell(ScFormulaCell* pFCell) const
                 bMayForceNumberformat = false;
             }
         }
-        else if (rtl::math::isFinite(fValue))
+        else if (std::isfinite(fValue))
         {
             pFCell->SetHybridDouble(fValue);
             if (mbPossibleEmptyDisplay && fValue == 0.0)
@@ -1144,7 +1144,7 @@ void ScXMLTableRowCellContext::PutValueCell( const ScAddress& rCurrentPos )
         // fdo#62250 absent values are not NaN, set to 0.0
         // PutValueCell() is called only for a known cell value type,
         // bIsEmpty==false in all these cases, no sense to check it here.
-        if (!::rtl::math::isFinite( fValue))
+        if (!std::isfinite( fValue))
             fValue = 0.0;
 
         // #i62435# Initialize the value cell's script type if the default
@@ -1425,7 +1425,7 @@ void ScXMLTableRowCellContext::AddFormulaCell( const ScAddress& rCellPos )
                             pFCell->ResetDirty();
                         }
                     }
-                    else if (rtl::math::isFinite(fValue))
+                    else if (std::isfinite(fValue))
                     {
                         pFCell->SetResultMatrix(
                             nMatrixCols, nMatrixRows, pMat, new formula::FormulaDoubleToken(fValue));
diff --git a/sc/source/ui/unoobj/dapiuno.cxx b/sc/source/ui/unoobj/dapiuno.cxx
index ad174f970127..fa29ddfbbe36 100644
--- a/sc/source/ui/unoobj/dapiuno.cxx
+++ b/sc/source/ui/unoobj/dapiuno.cxx
@@ -163,7 +163,7 @@ const SfxItemPropertyMapEntry* lcl_GetDataPilotItemMap()
 
 bool lclCheckValidDouble( double fValue, bool bAuto )
 {
-    return bAuto || ::rtl::math::isFinite( fValue );
+    return bAuto || std::isfinite( fValue );
 }
 
 bool lclCheckMinMaxStep( const DataPilotFieldGroupInfo& rInfo )
diff --git a/scaddins/source/analysis/analysisdefs.hxx b/scaddins/source/analysis/analysisdefs.hxx
index 9acef5d76108..4ee96be9ae0d 100644
--- a/scaddins/source/analysis/analysisdefs.hxx
+++ b/scaddins/source/analysis/analysisdefs.hxx
@@ -21,8 +21,8 @@
 #define INCLUDED_SCADDINS_SOURCE_ANALYSIS_ANALYSISDEFS_HXX
 
 #define CHK_Freq            ( nFreq != 1 && nFreq != 2 && nFreq != 4 )
-#define CHK_FINITE(d)       if( !::rtl::math::isFinite( d ) ) throw css::lang::IllegalArgumentException()
-#define RETURN_FINITE(d)    if( !::rtl::math::isFinite( d ) ) throw css::lang::IllegalArgumentException(); return d;
+#define CHK_FINITE(d)       if( !std::isfinite( d ) ) throw css::lang::IllegalArgumentException()
+#define RETURN_FINITE(d)    if( !std::isfinite( d ) ) throw css::lang::IllegalArgumentException(); return d;
 
 #endif
 
diff --git a/scaddins/source/pricing/pricing.hxx b/scaddins/source/pricing/pricing.hxx
index 1ce75c1756e1..54c1e5483d7f 100644
--- a/scaddins/source/pricing/pricing.hxx
+++ b/scaddins/source/pricing/pricing.hxx
@@ -39,7 +39,7 @@
 
 namespace com::sun::star::lang { class XMultiServiceFactory; }
 
-#define RETURN_FINITE(d)    if( !::rtl::math::isFinite( d ) ) throw css::lang::IllegalArgumentException(); return d;
+#define RETURN_FINITE(d)    if( !std::isfinite( d ) ) throw css::lang::IllegalArgumentException(); return d;
 
 
 namespace sca {
diff --git a/slideshow/source/engine/shapeattributelayer.cxx b/slideshow/source/engine/shapeattributelayer.cxx
index d96952f780ca..a688f479caec 100644
--- a/slideshow/source/engine/shapeattributelayer.cxx
+++ b/slideshow/source/engine/shapeattributelayer.cxx
@@ -269,7 +269,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setWidth( const double& rNewWidth )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewWidth),
+            ENSURE_OR_THROW( std::isfinite(rNewWidth),
                               "ShapeAttributeLayer::setWidth(): Invalid width" );
 
             maSize.setX( rNewWidth );
@@ -293,7 +293,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setHeight( const double& rNewHeight )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewHeight),
+            ENSURE_OR_THROW( std::isfinite(rNewHeight),
                               "ShapeAttributeLayer::setHeight(): Invalid height" );
 
             maSize.setY( rNewHeight );
@@ -303,8 +303,8 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setSize( const ::basegfx::B2DSize& rNewSize )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewSize.getX()) &&
-                              ::rtl::math::isFinite(rNewSize.getY()),
+            ENSURE_OR_THROW( std::isfinite(rNewSize.getX()) &&
+                              std::isfinite(rNewSize.getY()),
                               "ShapeAttributeLayer::setSize(): Invalid size" );
 
             maSize = rNewSize;
@@ -328,7 +328,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setPosX( const double& rNewX )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewX),
+            ENSURE_OR_THROW( std::isfinite(rNewX),
                               "ShapeAttributeLayer::setPosX(): Invalid position" );
 
             maPosition.setX( rNewX );
@@ -352,7 +352,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setPosY( const double& rNewY )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewY),
+            ENSURE_OR_THROW( std::isfinite(rNewY),
                               "ShapeAttributeLayer::setPosY(): Invalid position" );
 
             maPosition.setY( rNewY );
@@ -383,7 +383,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setRotationAngle( const double& rNewAngle )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
                               "ShapeAttributeLayer::setRotationAngle(): Invalid angle" );
 
             mnRotationAngle = rNewAngle;
@@ -406,7 +406,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setShearXAngle( const double& rNewAngle )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
                               "ShapeAttributeLayer::setShearXAngle(): Invalid angle" );
 
             mnShearXAngle = rNewAngle;
@@ -429,7 +429,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setShearYAngle( const double& rNewAngle )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
                               "ShapeAttributeLayer::setShearYAngle(): Invalid angle" );
 
             mnShearYAngle = rNewAngle;
@@ -452,7 +452,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setAlpha( const double& rNewValue )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewValue),
+            ENSURE_OR_THROW( std::isfinite(rNewValue),
                               "ShapeAttributeLayer::setAlpha(): Invalid alpha" );
 
             mnAlpha = rNewValue;
@@ -751,7 +751,7 @@ namespace slideshow::internal
 
         void ShapeAttributeLayer::setCharScale( const double& rNewHeight )
         {
-            ENSURE_OR_THROW( ::rtl::math::isFinite(rNewHeight),
+            ENSURE_OR_THROW( std::isfinite(rNewHeight),
                               "ShapeAttributeLayer::setCharScale(): Invalid height" );
 
             mnCharScale = rNewHeight;
diff --git a/svx/source/customshapes/EnhancedCustomShape2d.cxx b/svx/source/customshapes/EnhancedCustomShape2d.cxx
index 619b3c0dc9ca..a6d74d075077 100644
--- a/svx/source/customshapes/EnhancedCustomShape2d.cxx
+++ b/svx/source/customshapes/EnhancedCustomShape2d.cxx
@@ -886,7 +886,7 @@ double EnhancedCustomShape2d::GetEquationValueAsDouble( const sal_Int32 nIndex )
                     SAL_INFO("svx", "equation " << nLevel << " (level: " << seqEquations[nIndex] << "): "
                              << fNumber << " --> " << 180.0*fNumber/10800000.0);
                 }
-                if ( !rtl::math::isFinite( fNumber ) )
+                if ( !std::isfinite( fNumber ) )
                     fNumber = 0.0;
             }
             catch ( ... )
diff --git a/vcl/source/control/field.cxx b/vcl/source/control/field.cxx
index 9d5cb9ca08f5..3d23ee89deda 100644
--- a/vcl/source/control/field.cxx
+++ b/vcl/source/control/field.cxx
@@ -1125,7 +1125,7 @@ static FieldUnit ImplMap2FieldUnit( MapUnit meUnit, long& nDecDigits )
 
 static double nonValueDoubleToValueDouble( double nValue )
 {
-    return rtl::math::isFinite( nValue ) ? nValue : 0.0;
+    return std::isfinite( nValue ) ? nValue : 0.0;
 }
 
 namespace vcl