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>

20 files changed, 58 insertions, 58 deletions

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 )