STYLE: Replace std::pow(x, 2) calls with Math::sqr(x)

N-Dekker · dzenanz · commit 20e2f6df788e · 2025-02-22T11:34:33.000-05:00
`Math::sqr(x)` appears slightly more readable than `std::pow(x, 2)`.
diff --git a/Modules/Core/Common/include/itkEllipsoidInteriorExteriorSpatialFunction.hxx b/Modules/Core/Common/include/itkEllipsoidInteriorExteriorSpatialFunction.hxx
@@ -18,6 +18,7 @@
 #ifndef itkEllipsoidInteriorExteriorSpatialFunction_hxx
 #define itkEllipsoidInteriorExteriorSpatialFunction_hxx
 
+#include "itkMath.h"
 #include <cmath>
 
 namespace itk
@@ -43,8 +44,7 @@ EllipsoidInteriorExteriorSpatialFunction<VDimension, TInput>::Evaluate(const Inp
     {
       orientationVector[j] = m_Orientations[i][j];
     }
-    distanceSquared +=
-      std::pow(static_cast<double>((orientationVector * pointVector) / (.5 * m_Axes[i])), static_cast<double>(2));
+    distanceSquared += Math::sqr(static_cast<double>((orientationVector * pointVector) / (.5 * m_Axes[i])));
   }
 
   if (distanceSquared <= 1)
diff --git a/Modules/Core/Common/include/itkFiniteCylinderSpatialFunction.hxx b/Modules/Core/Common/include/itkFiniteCylinderSpatialFunction.hxx
@@ -19,6 +19,7 @@
 #define itkFiniteCylinderSpatialFunction_hxx
 
 #include "itkFloatingPointExceptions.h"
+#include "itkMath.h"
 #include <cmath>
 
 namespace itk
@@ -102,7 +103,7 @@ FiniteCylinderSpatialFunction<VDimension, TInput>::Evaluate(const InputType & po
   }
 
   if (itk::Math::abs(distanceFromCenter) <= (halfAxisLength) &&
-      m_Radius >= std::sqrt(std::pow(pointVector.GetNorm(), 2.0) - std::pow(distanceFromCenter, 2.0)))
+      m_Radius >= std::sqrt(Math::sqr(pointVector.GetNorm()) - Math::sqr(distanceFromCenter)))
   {
     return 1;
   }
diff --git a/Modules/Core/Common/include/itkSymmetricEllipsoidInteriorExteriorSpatialFunction.hxx b/Modules/Core/Common/include/itkSymmetricEllipsoidInteriorExteriorSpatialFunction.hxx
@@ -18,6 +18,7 @@
 #ifndef itkSymmetricEllipsoidInteriorExteriorSpatialFunction_hxx
 #define itkSymmetricEllipsoidInteriorExteriorSpatialFunction_hxx
 
+#include "itkMath.h"
 #include <cmath>
 
 namespace itk
@@ -48,11 +49,9 @@ SymmetricEllipsoidInteriorExteriorSpatialFunction<VDimension, TInput>::Evaluate(
     pointVector[i] = position[i] - m_Center[i];
   }
 
-  uniqueTerm =
-    std::pow(static_cast<double>(((pointVector * m_Orientation) / (.5 * m_UniqueAxis))), static_cast<double>(2));
+  uniqueTerm = Math::sqr(static_cast<double>(((pointVector * m_Orientation) / (.5 * m_UniqueAxis))));
   symmetricVector = pointVector - (m_Orientation * (pointVector * m_Orientation));
-  symmetricTerm =
-    std::pow(static_cast<double>(((symmetricVector.GetNorm()) / (.5 * m_SymmetricAxes))), static_cast<double>(2));
+  symmetricTerm = Math::sqr(static_cast<double>(((symmetricVector.GetNorm()) / (.5 * m_SymmetricAxes))));
 
   if ((uniqueTerm + symmetricTerm) >= 0 && (uniqueTerm + symmetricTerm) <= 1)
   {
diff --git a/Modules/Core/Common/include/itkTorusInteriorExteriorSpatialFunction.hxx b/Modules/Core/Common/include/itkTorusInteriorExteriorSpatialFunction.hxx
@@ -18,6 +18,8 @@
 #ifndef itkTorusInteriorExteriorSpatialFunction_hxx
 #define itkTorusInteriorExteriorSpatialFunction_hxx
 
+#include "itkMath.h"
+
 
 namespace itk
 {
@@ -29,7 +31,7 @@ TorusInteriorExteriorSpatialFunction<VDimension, TInput>::Evaluate(const InputTy
   const double y = position[1] - m_Origin[1];
   const double z = position[2] - m_Origin[2];
 
-  const double k = std::pow(m_MajorRadius - std::sqrt(x * x + y * y), 2.0) + z * z;
+  const double k = Math::sqr(m_MajorRadius - std::sqrt(x * x + y * y)) + z * z;
 
   if (k <= (m_MinorRadius * m_MinorRadius))
   {
diff --git a/Modules/Filtering/DisplacementField/include/itkIterativeInverseDisplacementFieldImageFilter.hxx b/Modules/Filtering/DisplacementField/include/itkIterativeInverseDisplacementFieldImageFilter.hxx
@@ -143,7 +143,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat
         smallestError = 0;
         for (unsigned int j = 0; j < ImageDimension; ++j)
         {
-          smallestError += std::pow(mappedPoint[j] + forwardVector[j] - originalPoint[j], 2);
+          smallestError += Math::sqr(mappedPoint[j] + forwardVector[j] - originalPoint[j]);
         }
         smallestError = std::sqrt(smallestError);
       }
@@ -167,7 +167,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat
             double                      tmp = 0;
             for (unsigned int l = 0; l < ImageDimension; ++l)
             {
-              tmp += std::pow(mappedPoint[l] + forwardVector[l] - originalPoint[l], 2);
+              tmp += Math::sqr(mappedPoint[l] + forwardVector[l] - originalPoint[l]);
             }
             tmp = std::sqrt(tmp);
             if (tmp < smallestError)
@@ -187,7 +187,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat
             double                      tmp = 0;
             for (unsigned int l = 0; l < ImageDimension; ++l)
             {
-              tmp += std::pow(mappedPoint[l] + forwardVector[l] - originalPoint[l], 2);
+              tmp += Math::sqr(mappedPoint[l] + forwardVector[l] - originalPoint[l]);
             }
             tmp = std::sqrt(tmp);
             if (tmp < smallestError)
diff --git a/Modules/Filtering/LabelMap/include/itkShapeLabelMapFilter.hxx b/Modules/Filtering/LabelMap/include/itkShapeLabelMapFilter.hxx
@@ -475,7 +475,7 @@ ShapeLabelMapFilter<TImage, TLabelImage>::ComputeFeretDiameter(LabelObjectType *
       for (unsigned int i = 0; i < ImageDimension; ++i)
       {
         const OffsetValueType indexDifference = (iIt1->operator[](i) - iIt2->operator[](i));
-        length += std::pow(indexDifference * spacing[i], 2);
+        length += Math::sqr(indexDifference * spacing[i]);
       }
       if (feretDiameter < length)
       {
diff --git a/Modules/Filtering/LabelMap/include/itkStatisticsLabelMapFilter.hxx b/Modules/Filtering/LabelMap/include/itkStatisticsLabelMapFilter.hxx
@@ -128,7 +128,7 @@ StatisticsLabelMapFilter<TImage, TFeatureImage>::ThreadedProcessLabelObject(Labe
 
     // increase the sums
     sum += v;
-    sum2 += std::pow(static_cast<double>(v), 2);
+    sum2 += Math::sqr(static_cast<double>(v));
     sum3 += std::pow(static_cast<double>(v), 3);
     sum4 += std::pow(static_cast<double>(v), 4);
 
@@ -154,7 +154,7 @@ StatisticsLabelMapFilter<TImage, TFeatureImage>::ThreadedProcessLabelObject(Labe
   const double                                          mean = sum / totalFreq;
   // Note that totalFreq could be 1. Stats on a population of size 1 are not useful.
   // We protect against dividing by 0 in that case.
-  const double variance = (totalFreq > 1) ? (sum2 - (std::pow(sum, 2) / totalFreq)) / (totalFreq - 1) : 0;
+  const double variance = (totalFreq > 1) ? (sum2 - (Math::sqr(sum) / totalFreq)) / (totalFreq - 1) : 0;
   const double sigma = std::sqrt(variance);
   const double mean2 = mean * mean;
   double       skewness;
diff --git a/Modules/Numerics/Optimizers/src/itkCumulativeGaussianCostFunction.cxx b/Modules/Numerics/Optimizers/src/itkCumulativeGaussianCostFunction.cxx
@@ -50,7 +50,7 @@ CumulativeGaussianCostFunction::CalculateFitError(MeasureType * setTestArray)
   double fitError = 0.0;
   for (int i = 0; i < static_cast<int>(numberOfElements); ++i)
   {
-    fitError += std::pow((setTestArray->get(i) - m_OriginalDataArray.get(i)), 2);
+    fitError += Math::sqr(setTestArray->get(i) - m_OriginalDataArray.get(i));
   }
   return (std::sqrt((1 / numberOfElements) * fitError));
 }
diff --git a/Modules/Numerics/Optimizers/src/itkCumulativeGaussianOptimizer.cxx b/Modules/Numerics/Optimizers/src/itkCumulativeGaussianOptimizer.cxx
@@ -57,7 +57,7 @@ CumulativeGaussianOptimizer::ExtendGaussian(MeasureType * originalArray,
 
   for (int i = 0; i < static_cast<int>(extendedArray->GetNumberOfElements()); ++i)
   {
-    extendedArray->put(i, amplitude * std::exp(-(std::pow((i - mean), 2) / (2 * std::pow(sd, 2)))));
+    extendedArray->put(i, amplitude * std::exp(-(Math::sqr(i - mean) / (2 * Math::sqr(sd)))));
   }
   // Then insert the originalArray over the middle section of extendedArray.
   for (int i = 0; i < static_cast<int>(originalArray->GetNumberOfElements()); ++i)
@@ -185,7 +185,7 @@ CumulativeGaussianOptimizer::MeasureGaussianParameters(MeasureType * array)
   // Calculate the standard deviation
   for (int i = 0; i < static_cast<int>(array->GetNumberOfElements()); ++i)
   {
-    m_ComputedStandardDeviation += array->get(i) * std::pow((i - m_ComputedMean), 2);
+    m_ComputedStandardDeviation += array->get(i) * Math::sqr(i - m_ComputedMean);
   }
   m_ComputedStandardDeviation = std::sqrt(m_ComputedStandardDeviation / sum);
 
@@ -232,7 +232,7 @@ CumulativeGaussianOptimizer::RecalculateExtendedArrayFromGaussianParameters(Meas
     if (i < startingPointForInsertion ||
         i >= startingPointForInsertion + static_cast<int>(originalArray->GetNumberOfElements()))
     {
-      extendedArray->put(i, amplitude * std::exp(-(std::pow((i - mean), 2) / (2 * std::pow(sd, 2)))));
+      extendedArray->put(i, amplitude * std::exp(-(Math::sqr(i - mean) / (2 * Math::sqr(sd)))));
     }
   }
   return extendedArray;
@@ -283,9 +283,9 @@ CumulativeGaussianOptimizer::StartOptimization()
   // Generate new Gaussian array with final parameters.
   for (int i = 0; i < sampledGaussianArraySize; ++i)
   {
-    sampledGaussianArray->put(i,
-                              m_ComputedAmplitude * std::exp(-(std::pow((i - m_ComputedMean), 2) /
-                                                               (2 * std::pow(m_ComputedStandardDeviation, 2)))));
+    sampledGaussianArray->put(
+      i,
+      m_ComputedAmplitude * std::exp(-(Math::sqr(i - m_ComputedMean) / (2 * Math::sqr(m_ComputedStandardDeviation)))));
   }
   // Add 0.5 to the mean of the sampled Gaussian curve to make up for the 0.5
   // shift during derivation, then take the integral of the Gaussian sample
diff --git a/Modules/Registration/Common/include/itkCorrelationCoefficientHistogramImageToImageMetric.hxx b/Modules/Registration/Common/include/itkCorrelationCoefficientHistogramImageToImageMetric.hxx
@@ -18,6 +18,7 @@
 #ifndef itkCorrelationCoefficientHistogramImageToImageMetric_hxx
 #define itkCorrelationCoefficientHistogramImageToImageMetric_hxx
 
+#include "itkMath.h"
 
 namespace itk
 {
@@ -81,10 +82,10 @@ CorrelationCoefficientHistogramImageToImageMetric<TFixedImage, TMovingImage>::Va
   for (unsigned int i = 0; i < this->m_HistogramSize[0]; ++i)
   {
     varX += static_cast<double>(histogram.GetFrequency(i, 0)) / histogram.GetTotalFrequency() *
-            std::pow(histogram.GetMeasurement(i, 0), 2);
+            Math::sqr(histogram.GetMeasurement(i, 0));
   }
 
-  return varX - std::pow(MeanX(histogram), 2);
+  return varX - Math::sqr(MeanX(histogram));
 }
 
 template <typename TFixedImage, typename TMovingImage>
@@ -97,10 +98,10 @@ CorrelationCoefficientHistogramImageToImageMetric<TFixedImage, TMovingImage>::Va
   for (unsigned int i = 0; i < this->m_HistogramSize[1]; ++i)
   {
     varY += static_cast<double>(histogram.GetFrequency(i, 1)) / histogram.GetTotalFrequency() *
-            std::pow(histogram.GetMeasurement(i, 1), 2);
+            Math::sqr(histogram.GetMeasurement(i, 1));
   }
 
-  return varY - std::pow(MeanY(histogram), 2);
+  return varY - Math::sqr(MeanY(histogram));
 }
 
 template <typename TFixedImage, typename TMovingImage>
diff --git a/Modules/Registration/Common/include/itkMeanReciprocalSquareDifferencePointSetToImageMetric.hxx b/Modules/Registration/Common/include/itkMeanReciprocalSquareDifferencePointSetToImageMetric.hxx
@@ -19,6 +19,7 @@
 #define itkMeanReciprocalSquareDifferencePointSetToImageMetric_hxx
 
 #include "itkImageRegionConstIteratorWithIndex.h"
+#include "itkMath.h"
 
 namespace itk
 {
@@ -51,7 +52,7 @@ MeanReciprocalSquareDifferencePointSetToImageMetric<TFixedPointSet, TMovingImage
   MeasureType measure{};
 
   this->m_NumberOfPixelsCounted = 0;
-  const double lambdaSquared = std::pow(this->m_Lambda, 2);
+  const double lambdaSquared = Math::sqr(this->m_Lambda);
 
   this->SetTransformParameters(parameters);
 
@@ -107,7 +108,7 @@ MeanReciprocalSquareDifferencePointSetToImageMetric<TFixedPointSet, TMovingImage
 
   this->m_NumberOfPixelsCounted = 0;
 
-  const double lambdaSquared = std::pow(this->m_Lambda, 2);
+  const double lambdaSquared = Math::sqr(this->m_Lambda);
 
   this->SetTransformParameters(parameters);
 
@@ -161,7 +162,7 @@ MeanReciprocalSquareDifferencePointSetToImageMetric<TFixedPointSet, TMovingImage
         {
           // Will it be computationally more efficient to instead calculate the
           // derivative using finite differences ?
-          sum -= jacobian(dim, par) * gradient[dim] / (std::pow(lambdaSquared + diffSquared, 2));
+          sum -= jacobian(dim, par) * gradient[dim] / Math::sqr(lambdaSquared + diffSquared);
         }
         derivative[par] += diff * sum;
       }
@@ -207,7 +208,7 @@ MeanReciprocalSquareDifferencePointSetToImageMetric<TFixedPointSet, TMovingImage
   MeasureType measure{};
 
   this->SetTransformParameters(parameters);
-  const double lambdaSquared = std::pow(this->m_Lambda, 2);
+  const double lambdaSquared = Math::sqr(this->m_Lambda);
 
   const unsigned int ParametersDimension = this->GetNumberOfParameters();
   derivative = DerivativeType(ParametersDimension);
@@ -258,7 +259,7 @@ MeanReciprocalSquareDifferencePointSetToImageMetric<TFixedPointSet, TMovingImage
         RealType sum{};
         for (unsigned int dim = 0; dim < Self::FixedPointSetDimension; ++dim)
         {
-          sum -= jacobian(dim, par) * gradient[dim] * std::pow(lambdaSquared + diffSquared, 2);
+          sum -= jacobian(dim, par) * gradient[dim] * Math::sqr(lambdaSquared + diffSquared);
         }
         derivative[par] += diff * sum;
       }

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`#ifndef itkEllipsoidInteriorExteriorSpatialFunction_hxx`
`19`	`19`	`#define itkEllipsoidInteriorExteriorSpatialFunction_hxx`
`20`	`20`
	`21`	`+#include "itkMath.h"`
`21`	`22`	`#include <cmath>`
`22`	`23`
`23`	`24`	`namespace itk`
`@@ -43,8 +44,7 @@ EllipsoidInteriorExteriorSpatialFunction<VDimension, TInput>::Evaluate(const Inp`
`43`	`44`	`{`
`44`	`45`	`orientationVector[j] = m_Orientations[i][j];`
`45`	`46`	`}`
`46`		`- distanceSquared +=`
`47`		`- std::pow(static_cast<double>((orientationVector * pointVector) / (.5 * m_Axes[i])), static_cast<double>(2));`
	`47`	`+ distanceSquared += Math::sqr(static_cast<double>((orientationVector * pointVector) / (.5 * m_Axes[i])));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`if (distanceSquared <= 1)`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`#define itkFiniteCylinderSpatialFunction_hxx`
`20`	`20`
`21`	`21`	`#include "itkFloatingPointExceptions.h"`
	`22`	`+#include "itkMath.h"`
`22`	`23`	`#include <cmath>`
`23`	`24`
`24`	`25`	`namespace itk`
`@@ -102,7 +103,7 @@ FiniteCylinderSpatialFunction<VDimension, TInput>::Evaluate(const InputType & po`
`102`	`103`	`}`
`103`	`104`
`104`	`105`	`if (itk::Math::abs(distanceFromCenter) <= (halfAxisLength) &&`
`105`		`- m_Radius >= std::sqrt(std::pow(pointVector.GetNorm(), 2.0) - std::pow(distanceFromCenter, 2.0)))`
	`106`	`+ m_Radius >= std::sqrt(Math::sqr(pointVector.GetNorm()) - Math::sqr(distanceFromCenter)))`
`106`	`107`	`{`
`107`	`108`	`return 1;`
`108`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,8 @@`
`18`	`18`	`#ifndef itkTorusInteriorExteriorSpatialFunction_hxx`
`19`	`19`	`#define itkTorusInteriorExteriorSpatialFunction_hxx`
`20`	`20`
	`21`	`+#include "itkMath.h"`
	`22`	`+`
`21`	`23`
`22`	`24`	`namespace itk`
`23`	`25`	`{`
`@@ -29,7 +31,7 @@ TorusInteriorExteriorSpatialFunction<VDimension, TInput>::Evaluate(const InputTy`
`29`	`31`	`const double y = position[1] - m_Origin[1];`
`30`	`32`	`const double z = position[2] - m_Origin[2];`
`31`	`33`
`32`		`- const double k = std::pow(m_MajorRadius - std::sqrt(x * x + y * y), 2.0) + z * z;`
	`34`	`+ const double k = Math::sqr(m_MajorRadius - std::sqrt(x * x + y * y)) + z * z;`
`33`	`35`
`34`	`36`	`if (k <= (m_MinorRadius * m_MinorRadius))`
`35`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat`
`143`	`143`	`smallestError = 0;`
`144`	`144`	`for (unsigned int j = 0; j < ImageDimension; ++j)`
`145`	`145`	`{`
`146`		`- smallestError += std::pow(mappedPoint[j] + forwardVector[j] - originalPoint[j], 2);`
	`146`	`+ smallestError += Math::sqr(mappedPoint[j] + forwardVector[j] - originalPoint[j]);`
`147`	`147`	`}`
`148`	`148`	`smallestError = std::sqrt(smallestError);`
`149`	`149`	`}`
`@@ -167,7 +167,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat`
`167`	`167`	`double tmp = 0;`
`168`	`168`	`for (unsigned int l = 0; l < ImageDimension; ++l)`
`169`	`169`	`{`
`170`		`- tmp += std::pow(mappedPoint[l] + forwardVector[l] - originalPoint[l], 2);`
	`170`	`+ tmp += Math::sqr(mappedPoint[l] + forwardVector[l] - originalPoint[l]);`
`171`	`171`	`}`
`172`	`172`	`tmp = std::sqrt(tmp);`
`173`	`173`	`if (tmp < smallestError)`
`@@ -187,7 +187,7 @@ IterativeInverseDisplacementFieldImageFilter<TInputImage, TOutputImage>::Generat`
`187`	`187`	`double tmp = 0;`
`188`	`188`	`for (unsigned int l = 0; l < ImageDimension; ++l)`
`189`	`189`	`{`
`190`		`- tmp += std::pow(mappedPoint[l] + forwardVector[l] - originalPoint[l], 2);`
	`190`	`+ tmp += Math::sqr(mappedPoint[l] + forwardVector[l] - originalPoint[l]);`
`191`	`191`	`}`
`192`	`192`	`tmp = std::sqrt(tmp);`
`193`	`193`	`if (tmp < smallestError)`
Original file line number	Diff line number	Diff line change
`@@ -475,7 +475,7 @@ ShapeLabelMapFilter<TImage, TLabelImage>::ComputeFeretDiameter(LabelObjectType *`
`475`	`475`	`for (unsigned int i = 0; i < ImageDimension; ++i)`
`476`	`476`	`{`
`477`	`477`	`const OffsetValueType indexDifference = (iIt1->operator[](i) - iIt2->operator[](i));`
`478`		`- length += std::pow(indexDifference * spacing[i], 2);`
	`478`	`+ length += Math::sqr(indexDifference * spacing[i]);`
`479`	`479`	`}`
`480`	`480`	`if (feretDiameter < length)`
`481`	`481`	`{`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ CumulativeGaussianCostFunction::CalculateFitError(MeasureType * setTestArray)`
`50`	`50`	`double fitError = 0.0;`
`51`	`51`	`for (int i = 0; i < static_cast<int>(numberOfElements); ++i)`
`52`	`52`	`{`
`53`		`- fitError += std::pow((setTestArray->get(i) - m_OriginalDataArray.get(i)), 2);`
	`53`	`+ fitError += Math::sqr(setTestArray->get(i) - m_OriginalDataArray.get(i));`
`54`	`54`	`}`
`55`	`55`	`return (std::sqrt((1 / numberOfElements) * fitError));`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ CumulativeGaussianOptimizer::ExtendGaussian(MeasureType * originalArray,`
`57`	`57`
`58`	`58`	`for (int i = 0; i < static_cast<int>(extendedArray->GetNumberOfElements()); ++i)`
`59`	`59`	`{`
`60`		`- extendedArray->put(i, amplitude * std::exp(-(std::pow((i - mean), 2) / (2 * std::pow(sd, 2)))));`
	`60`	`+ extendedArray->put(i, amplitude * std::exp(-(Math::sqr(i - mean) / (2 * Math::sqr(sd)))));`
`61`	`61`	`}`
`62`	`62`	`// Then insert the originalArray over the middle section of extendedArray.`
`63`	`63`	`for (int i = 0; i < static_cast<int>(originalArray->GetNumberOfElements()); ++i)`
`@@ -185,7 +185,7 @@ CumulativeGaussianOptimizer::MeasureGaussianParameters(MeasureType * array)`
`185`	`185`	`// Calculate the standard deviation`
`186`	`186`	`for (int i = 0; i < static_cast<int>(array->GetNumberOfElements()); ++i)`
`187`	`187`	`{`
`188`		`- m_ComputedStandardDeviation += array->get(i) * std::pow((i - m_ComputedMean), 2);`
	`188`	`+ m_ComputedStandardDeviation += array->get(i) * Math::sqr(i - m_ComputedMean);`
`189`	`189`	`}`
`190`	`190`	`m_ComputedStandardDeviation = std::sqrt(m_ComputedStandardDeviation / sum);`
`191`	`191`
`@@ -232,7 +232,7 @@ CumulativeGaussianOptimizer::RecalculateExtendedArrayFromGaussianParameters(Meas`
`232`	`232`	`if (i < startingPointForInsertion \|\|`
`233`	`233`	`i >= startingPointForInsertion + static_cast<int>(originalArray->GetNumberOfElements()))`
`234`	`234`	`{`
`235`		`- extendedArray->put(i, amplitude * std::exp(-(std::pow((i - mean), 2) / (2 * std::pow(sd, 2)))));`
	`235`	`+ extendedArray->put(i, amplitude * std::exp(-(Math::sqr(i - mean) / (2 * Math::sqr(sd)))));`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`	`return extendedArray;`
`@@ -283,9 +283,9 @@ CumulativeGaussianOptimizer::StartOptimization()`
`283`	`283`	`// Generate new Gaussian array with final parameters.`
`284`	`284`	`for (int i = 0; i < sampledGaussianArraySize; ++i)`
`285`	`285`	`{`
`286`		`- sampledGaussianArray->put(i,`
`287`		`- m_ComputedAmplitude * std::exp(-(std::pow((i - m_ComputedMean), 2) /`
`288`		`- (2 * std::pow(m_ComputedStandardDeviation, 2)))));`
	`286`	`+ sampledGaussianArray->put(`
	`287`	`+ i,`
	`288`	`+ m_ComputedAmplitude * std::exp(-(Math::sqr(i - m_ComputedMean) / (2 * Math::sqr(m_ComputedStandardDeviation)))));`
`289`	`289`	`}`
`290`	`290`	`// Add 0.5 to the mean of the sampled Gaussian curve to make up for the 0.5`
`291`	`291`	`// shift during derivation, then take the integral of the Gaussian sample`