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>

5 files changed, 23 insertions, 23 deletions

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();