diff --git a/MathNet.Numerics.sln.DotSettings b/MathNet.Numerics.sln.DotSettings index db547745..a97eba6c 100644 --- a/MathNet.Numerics.sln.DotSettings +++ b/MathNet.Numerics.sln.DotSettings @@ -63,6 +63,7 @@ OTHER DEALINGS IN THE SOFTWARE. SAS SPSS SSD + SVD TFQMR WH <data /> diff --git a/src/Numerics/Complex32.cs b/src/Numerics/Complex32.cs index 3940d721..9a41fab9 100644 --- a/src/Numerics/Complex32.cs +++ b/src/Numerics/Complex32.cs @@ -72,7 +72,7 @@ namespace MathNet.Numerics /// [Serializable] [StructLayout(LayoutKind.Sequential)] - public struct Complex32 : IFormattable, IEquatable, IPrecisionSupport + public struct Complex32 : IFormattable, IEquatable { /// /// The real component of the complex number. @@ -792,37 +792,6 @@ namespace MathNet.Numerics #endregion - #region IPrecisionSupport - - /// - /// Returns a Norm of a value of this type, which is appropriate for measuring how - /// close this value is to zero. - /// - /// - /// A norm of this value. - /// - double IPrecisionSupport.Norm() - { - return MagnitudeSquared; - } - - /// - /// Returns a Norm of the difference of two values of this type, which is - /// appropriate for measuring how close together these two values are. - /// - /// - /// The value to compare with. - /// - /// - /// A norm of the difference between this and the other value. - /// - double IPrecisionSupport.NormOfDifference(Complex32 otherValue) - { - return (this - otherValue).MagnitudeSquared; - } - - #endregion - #region Parse Functions /// diff --git a/src/Numerics/ComplexExtensions.cs b/src/Numerics/ComplexExtensions.cs index 3cc80638..4808ff67 100644 --- a/src/Numerics/ComplexExtensions.cs +++ b/src/Numerics/ComplexExtensions.cs @@ -376,25 +376,38 @@ namespace MathNet.Numerics /// Returns a Norm of a value of this type, which is appropriate for measuring how /// close this value is to zero. /// - /// The number to perfom this operation on. - /// A norm of this value. public static double Norm(this Complex complex) { return complex.MagnitudeSquared(); } + /// + /// Returns a Norm of a value of this type, which is appropriate for measuring how + /// close this value is to zero. + /// + public static double Norm(this Complex32 complex) + { + return complex.MagnitudeSquared; + } + /// /// Returns a Norm of the difference of two values of this type, which is /// appropriate for measuring how close together these two values are. /// - /// The number to perfom this operation on. - /// The value to compare with. - /// A norm of the difference between this and the other value. public static double NormOfDifference(this Complex complex, Complex otherValue) { return (complex - otherValue).MagnitudeSquared(); } + /// + /// Returns a Norm of the difference of two values of this type, which is + /// appropriate for measuring how close together these two values are. + /// + public static double NormOfDifference(this Complex32 complex, Complex32 otherValue) + { + return (complex - otherValue).MagnitudeSquared; + } + /// /// Creates a complex number based on a string. The string can be in the /// following formats (without the quotes): 'n', 'ni', 'n +/- ni', diff --git a/src/Numerics/Distributions/Dirichlet.cs b/src/Numerics/Distributions/Dirichlet.cs index 72c9d607..d67da14a 100644 --- a/src/Numerics/Distributions/Dirichlet.cs +++ b/src/Numerics/Distributions/Dirichlet.cs @@ -303,7 +303,7 @@ namespace MathNet.Numerics.Distributions term += (_alpha[_alpha.Length - 1] - 1.0)*Math.Log(1.0 - sumxi) - SpecialFunctions.GammaLn(_alpha[_alpha.Length - 1]); sumalpha += _alpha[_alpha.Length - 1]; } - else if (!sumxi.AlmostEqualInDecimalPlaces(1.0, 8)) + else if (!sumxi.AlmostEqualRelative(1.0, 8)) { return 0.0; } diff --git a/src/Numerics/Integration/NewtonCotesTrapeziumRule.cs b/src/Numerics/Integration/NewtonCotesTrapeziumRule.cs index 59f18eb4..d02037f5 100644 --- a/src/Numerics/Integration/NewtonCotesTrapeziumRule.cs +++ b/src/Numerics/Integration/NewtonCotesTrapeziumRule.cs @@ -124,7 +124,7 @@ namespace MathNet.Numerics.Integration step *= 0.5; numberOfPartitions *= 2; - if (sum.AlmostEqualWithError(midpointsum, targetError)) + if (sum.AlmostEqualRelative(midpointsum, targetError)) { break; } @@ -222,7 +222,7 @@ namespace MathNet.Numerics.Integration delta = Math.Sqrt(delta); } - if (sum.AlmostEqualWithRelativeError(midpointsum, delta, targetRelativeError)) + if (sum.AlmostEqualNormRelative(midpointsum, delta, targetRelativeError)) { break; } diff --git a/src/Numerics/LinearAlgebra/Complex/Factorization/UserSvd.cs b/src/Numerics/LinearAlgebra/Complex/Factorization/UserSvd.cs index 7c95bf3a..fae5f588 100644 --- a/src/Numerics/LinearAlgebra/Complex/Factorization/UserSvd.cs +++ b/src/Numerics/LinearAlgebra/Complex/Factorization/UserSvd.cs @@ -369,7 +369,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization { test = s[l].Magnitude + s[l + 1].Magnitude; ztest = test + e[l].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { e[l] = Complex.Zero; break; @@ -398,7 +398,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization } ztest = test + s[ls].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { s[ls] = Complex.Zero; break; diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/BiCgStab.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/BiCgStab.cs index b09df01e..8ec28c16 100644 --- a/src/Numerics/LinearAlgebra/Complex/Solvers/BiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Complex/Solvers/BiCgStab.cs @@ -164,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // if (rho_(i-1) == 0) // METHOD FAILS // If rho is only 1 ULP from zero then we fail. - if (currentRho.Real.AlmostEqual(0, 1) && currentRho.Imaginary.AlmostEqual(0, 1)) + if (currentRho.Real.AlmostEqualNumbersBetween(0, 1) && currentRho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // Rho-type breakdown throw new Exception("Iterative solver experience a numerical break down"); @@ -258,7 +258,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // for continuation it is necessary that omega_i != 0.0 // If omega is only 1 ULP from zero then we fail. - if (omega.Real.AlmostEqual(0, 1) && omega.Imaginary.AlmostEqual(0, 1)) + if (omega.Real.AlmostEqualNumbersBetween(0, 1) && omega.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // Omega-type breakdown throw new Exception("Iterative solver experience a numerical break down"); diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/GpBiCg.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/GpBiCg.cs index 1644b7bc..af1fcd99 100644 --- a/src/Numerics/LinearAlgebra/Complex/Solvers/GpBiCg.cs +++ b/src/Numerics/LinearAlgebra/Complex/Solvers/GpBiCg.cs @@ -267,7 +267,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // We'll set cDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // c.DotProduct(t) will be zero and so will c.DotProduct(y) - if (cdot.Real.AlmostEqual(0, 1) && cdot.Imaginary.AlmostEqual(0, 1)) + if (cdot.Real.AlmostEqualNumbersBetween(0, 1) && cdot.Imaginary.AlmostEqualNumbersBetween(0, 1)) { cdot = 1.0; } @@ -295,7 +295,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // We'll set yDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // y.DotProduct(t) will be zero and so will c.DotProduct(y) - if (ydot.Real.AlmostEqual(0, 1) && ydot.Imaginary.AlmostEqual(0, 1)) + if (ydot.Real.AlmostEqualNumbersBetween(0, 1) && ydot.Imaginary.AlmostEqualNumbersBetween(0, 1)) { ydot = 1.0; } @@ -355,7 +355,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k) // But first we check if there is a possible NaN. If so just reset beta to zero. - beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha/sigma*rdash.ConjugateDotProduct(residuals)/rdash.ConjugateDotProduct(t0) : 0; + beta = (!sigma.Real.AlmostEqualNumbersBetween(0, 1) || !sigma.Imaginary.AlmostEqualNumbersBetween(0, 1)) ? alpha/sigma*rdash.ConjugateDotProduct(residuals)/rdash.ConjugateDotProduct(t0) : 0; // w_k = c_k + beta_k s_k s.Multiply(beta, temp2); diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/MlkBiCgStab.cs index 28a992a4..1339c6db 100644 --- a/src/Numerics/LinearAlgebra/Complex/Solvers/MlkBiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Complex/Solvers/MlkBiCgStab.cs @@ -343,7 +343,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // c_((j-1)k+k) = q^T_1 w_((j-1)k+k) c[k - 1] = _startingVectors[0].ConjugateDotProduct(w[k - 1]); - if (c[k - 1].Real.AlmostEqual(0, 1) && c[k - 1].Imaginary.AlmostEqual(0, 1)) + if (c[k - 1].Real.AlmostEqualNumbersBetween(0, 1) && c[k - 1].Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -366,7 +366,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // If rho is zero then temp is a zero vector and we're probably // about to have zero residuals (i.e. an exact solution). // So set rho to 1.0 because in the next step it will turn to zero. - if (rho.Real.AlmostEqual(0, 1) && rho.Imaginary.AlmostEqual(0, 1)) + if (rho.Real.AlmostEqualNumbersBetween(0, 1) && rho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { rho = 1.0; } @@ -444,7 +444,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers } beta = rho*c[k - 1]; - if (beta.Real.AlmostEqual(0, 1) && beta.Imaginary.AlmostEqual(0, 1)) + if (beta.Real.AlmostEqualNumbersBetween(0, 1) && beta.Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -496,7 +496,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers { // c_(jk+1) = q^T_i+1 d_(jk+i) c[i] = _startingVectors[i + 1].ConjugateDotProduct(d[i]); - if (c[i].Real.AlmostEqual(0, 1) && c[i].Imaginary.AlmostEqual(0, 1)) + if (c[i].Real.AlmostEqualNumbersBetween(0, 1) && c[i].Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs index 38854692..ee442ea4 100644 --- a/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs +++ b/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs @@ -233,7 +233,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // ||r_i|| <= stop_tol * ||b|| // Stop the calculation if it's clearly smaller than the tolerance var decimalMagnitude = Math.Abs(stopCriterium.Magnitude()) + 1; - if (residualNorm.IsSmallerWithDecimalPlaces(stopCriterium, decimalMagnitude)) + if (residualNorm.IsSmallerDecimal(stopCriterium, decimalMagnitude)) { if (_lastIteration <= iterationNumber) { diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/TFQMR.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/TFQMR.cs index fe11bb58..0cee1ca4 100644 --- a/src/Numerics/LinearAlgebra/Complex/Solvers/TFQMR.cs +++ b/src/Numerics/LinearAlgebra/Complex/Solvers/TFQMR.cs @@ -167,7 +167,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers { // sigma = (v, r) var sigma = r.ConjugateDotProduct(v); - if (sigma.Real.AlmostEqual(0, 1) && sigma.Imaginary.AlmostEqual(0, 1)) + if (sigma.Real.AlmostEqualNumbersBetween(0, 1) && sigma.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); @@ -240,7 +240,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers // The odd step if (!IsEven(iterationNumber)) { - if (rho.Real.AlmostEqual(0, 1) && rho.Imaginary.AlmostEqual(0, 1)) + if (rho.Real.AlmostEqualNumbersBetween(0, 1) && rho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); diff --git a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserSvd.cs b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserSvd.cs index 5987de87..b2acf111 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserSvd.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserSvd.cs @@ -364,7 +364,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization { test = s[l].Magnitude + s[l + 1].Magnitude; ztest = test + e[l].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { e[l] = Complex32.Zero; break; @@ -393,7 +393,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization } ztest = test + s[ls].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { s[ls] = Complex32.Zero; break; diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/BiCgStab.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/BiCgStab.cs index f6eedb5d..756a076d 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Solvers/BiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/BiCgStab.cs @@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // if (rho_(i-1) == 0) // METHOD FAILS // If rho is only 1 ULP from zero then we fail. - if (currentRho.Real.AlmostEqual(0, 1) && currentRho.Imaginary.AlmostEqual(0, 1)) + if (currentRho.Real.AlmostEqualNumbersBetween(0, 1) && currentRho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // Rho-type breakdown throw new Exception("Iterative solver experience a numerical break down"); @@ -251,7 +251,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // for continuation it is necessary that omega_i != 0.0f // If omega is only 1 ULP from zero then we fail. - if (omega.Real.AlmostEqual(0, 1) && omega.Imaginary.AlmostEqual(0, 1)) + if (omega.Real.AlmostEqualNumbersBetween(0, 1) && omega.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // Omega-type breakdown throw new Exception("Iterative solver experience a numerical break down"); diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/GpBiCg.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/GpBiCg.cs index 65817d2c..5218ba17 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Solvers/GpBiCg.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/GpBiCg.cs @@ -265,7 +265,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // We'll set cDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // c.DotProduct(t) will be zero and so will c.DotProduct(y) - if (cdot.Real.AlmostEqual(0, 1) && cdot.Imaginary.AlmostEqual(0, 1)) + if (cdot.Real.AlmostEqualNumbersBetween(0, 1) && cdot.Imaginary.AlmostEqualNumbersBetween(0, 1)) { cdot = 1.0f; } @@ -293,7 +293,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // We'll set yDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // y.DotProduct(t) will be zero and so will c.DotProduct(y) - if (ydot.Real.AlmostEqual(0, 1) && ydot.Imaginary.AlmostEqual(0, 1)) + if (ydot.Real.AlmostEqualNumbersBetween(0, 1) && ydot.Imaginary.AlmostEqualNumbersBetween(0, 1)) { ydot = 1.0f; } @@ -353,7 +353,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k) // But first we check if there is a possible NaN. If so just reset beta to zero. - beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha/sigma*rdash.ConjugateDotProduct(residuals)/rdash.ConjugateDotProduct(t0) : 0; + beta = (!sigma.Real.AlmostEqualNumbersBetween(0, 1) || !sigma.Imaginary.AlmostEqualNumbersBetween(0, 1)) ? alpha/sigma*rdash.ConjugateDotProduct(residuals)/rdash.ConjugateDotProduct(t0) : 0; // w_k = c_k + beta_k s_k s.Multiply(beta, temp2); diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/MlkBiCgStab.cs index 181c50dd..8fba9de9 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Solvers/MlkBiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/MlkBiCgStab.cs @@ -341,7 +341,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // c_((j-1)k+k) = q^T_1 w_((j-1)k+k) c[k - 1] = _startingVectors[0].ConjugateDotProduct(w[k - 1]); - if (c[k - 1].Real.AlmostEqual(0, 1) && c[k - 1].Imaginary.AlmostEqual(0, 1)) + if (c[k - 1].Real.AlmostEqualNumbersBetween(0, 1) && c[k - 1].Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -364,7 +364,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // If rho is zero then temp is a zero vector and we're probably // about to have zero residuals (i.e. an exact solution). // So set rho to 1.0 because in the next step it will turn to zero. - if (rho.Real.AlmostEqual(0, 1) && rho.Imaginary.AlmostEqual(0, 1)) + if (rho.Real.AlmostEqualNumbersBetween(0, 1) && rho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { rho = 1.0f; } @@ -442,7 +442,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers } beta = rho*c[k - 1]; - if (beta.Real.AlmostEqual(0, 1) && beta.Imaginary.AlmostEqual(0, 1)) + if (beta.Real.AlmostEqualNumbersBetween(0, 1) && beta.Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -494,7 +494,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers { // c_(jk+1) = q^T_i+1 d_(jk+i) c[i] = _startingVectors[i + 1].ConjugateDotProduct(d[i]); - if (c[i].Real.AlmostEqual(0, 1) && c[i].Imaginary.AlmostEqual(0, 1)) + if (c[i].Real.AlmostEqualNumbersBetween(0, 1) && c[i].Imaginary.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs index d174ce8d..7f402be0 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs @@ -228,7 +228,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // ||r_i|| <= stop_tol * ||b|| // Stop the calculation if it's clearly smaller than the tolerance var decimalMagnitude = Math.Abs(stopCriterium.Magnitude()) + 1; - if (residualNorm.IsSmallerWithDecimalPlaces(stopCriterium, decimalMagnitude)) + if (residualNorm.IsSmallerDecimal(stopCriterium, decimalMagnitude)) { if (_lastIteration <= iterationNumber) { diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/TFQMR.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/TFQMR.cs index 3608f74a..1c77e259 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Solvers/TFQMR.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/TFQMR.cs @@ -164,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers { // sigma = (v, r) var sigma = r.ConjugateDotProduct(v); - if (sigma.Real.AlmostEqual(0, 1) && sigma.Imaginary.AlmostEqual(0, 1)) + if (sigma.Real.AlmostEqualNumbersBetween(0, 1) && sigma.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); @@ -237,7 +237,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers // The odd step if (!IsEven(iterationNumber)) { - if (rho.Real.AlmostEqual(0, 1) && rho.Imaginary.AlmostEqual(0, 1)) + if (rho.Real.AlmostEqualNumbersBetween(0, 1) && rho.Imaginary.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); diff --git a/src/Numerics/LinearAlgebra/Double/Factorization/UserSvd.cs b/src/Numerics/LinearAlgebra/Double/Factorization/UserSvd.cs index b92b5cf9..186b799d 100644 --- a/src/Numerics/LinearAlgebra/Double/Factorization/UserSvd.cs +++ b/src/Numerics/LinearAlgebra/Double/Factorization/UserSvd.cs @@ -348,7 +348,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization { test = Math.Abs(s[l]) + Math.Abs(s[l + 1]); ztest = test + Math.Abs(e[l]); - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { e[l] = 0.0; break; @@ -377,7 +377,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization } ztest = test + Math.Abs(s[ls]); - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { s[ls] = 0.0; break; diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/BiCgStab.cs b/src/Numerics/LinearAlgebra/Double/Solvers/BiCgStab.cs index 7443ef50..50ca954c 100644 --- a/src/Numerics/LinearAlgebra/Double/Solvers/BiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Double/Solvers/BiCgStab.cs @@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // if (rho_(i-1) == 0) // METHOD FAILS // If rho is only 1 ULP from zero then we fail. - if (currentRho.AlmostEqual(0, 1)) + if (currentRho.AlmostEqualNumbersBetween(0, 1)) { // Rho-type breakdown throw new Exception("Iterative solver experience a numerical break down"); @@ -251,7 +251,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // for continuation it is necessary that omega_i != 0.0 // If omega is only 1 ULP from zero then we fail. - if (omega.AlmostEqual(0, 1)) + if (omega.AlmostEqualNumbersBetween(0, 1)) { // Omega-type breakdown throw new Exception("Iterative solver experience a numerical break down"); diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/GpBiCg.cs b/src/Numerics/LinearAlgebra/Double/Solvers/GpBiCg.cs index e5154630..ab7513f0 100644 --- a/src/Numerics/LinearAlgebra/Double/Solvers/GpBiCg.cs +++ b/src/Numerics/LinearAlgebra/Double/Solvers/GpBiCg.cs @@ -271,7 +271,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // We'll set cDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // c.DotProduct(t) will be zero and so will c.DotProduct(y) - if (cdot.AlmostEqual(0, 1)) + if (cdot.AlmostEqualNumbersBetween(0, 1)) { cdot = 1.0; } @@ -299,7 +299,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // We'll set yDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // y.DotProduct(t) will be zero and so will c.DotProduct(y) - if (ydot.AlmostEqual(0, 1)) + if (ydot.AlmostEqualNumbersBetween(0, 1)) { ydot = 1.0; } @@ -359,7 +359,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k) // But first we check if there is a possible NaN. If so just reset beta to zero. - beta = (!sigma.AlmostEqual(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0; + beta = (!sigma.AlmostEqualNumbersBetween(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0; // w_k = c_k + beta_k s_k s.Multiply(beta, temp2); diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Double/Solvers/MlkBiCgStab.cs index d3e9eb25..446ba02a 100644 --- a/src/Numerics/LinearAlgebra/Double/Solvers/MlkBiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Double/Solvers/MlkBiCgStab.cs @@ -341,7 +341,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // c_((j-1)k+k) = q^T_1 w_((j-1)k+k) c[k - 1] = _startingVectors[0].DotProduct(w[k - 1]); - if (c[k - 1].AlmostEqual(0, 1)) + if (c[k - 1].AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -364,7 +364,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // If rho is zero then temp is a zero vector and we're probably // about to have zero residuals (i.e. an exact solution). // So set rho to 1.0 because in the next step it will turn to zero. - if (rho.AlmostEqual(0, 1)) + if (rho.AlmostEqualNumbersBetween(0, 1)) { rho = 1.0; } @@ -442,7 +442,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers } beta = rho*c[k - 1]; - if (beta.AlmostEqual(0, 1)) + if (beta.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -494,7 +494,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers { // c_(jk+1) = q^T_i+1 d_(jk+i) c[i] = _startingVectors[i + 1].DotProduct(d[i]); - if (c[i].AlmostEqual(0, 1)) + if (c[i].AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs index 02b9f2d8..4ebce201 100644 --- a/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs +++ b/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs @@ -226,7 +226,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // ||r_i|| <= stop_tol * ||b|| // Stop the calculation if it's clearly smaller than the tolerance var decimalMagnitude = Math.Abs(stopCriterium.Magnitude()) + 1; - if (residualNorm.IsSmallerWithDecimalPlaces(stopCriterium, decimalMagnitude)) + if (residualNorm.IsSmallerDecimal(stopCriterium, decimalMagnitude)) { if (_lastIteration <= iterationNumber) { diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/TFQMR.cs b/src/Numerics/LinearAlgebra/Double/Solvers/TFQMR.cs index bf33f8de..6c803d74 100644 --- a/src/Numerics/LinearAlgebra/Double/Solvers/TFQMR.cs +++ b/src/Numerics/LinearAlgebra/Double/Solvers/TFQMR.cs @@ -164,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers { // sigma = (v, r) var sigma = v.DotProduct(r); - if (sigma.AlmostEqual(0, 1)) + if (sigma.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); @@ -237,7 +237,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers // The odd step if (!IsEven(iterationNumber)) { - if (rho.AlmostEqual(0, 1)) + if (rho.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); diff --git a/src/Numerics/LinearAlgebra/Single/Factorization/UserSvd.cs b/src/Numerics/LinearAlgebra/Single/Factorization/UserSvd.cs index ce0753a4..2d8098a2 100644 --- a/src/Numerics/LinearAlgebra/Single/Factorization/UserSvd.cs +++ b/src/Numerics/LinearAlgebra/Single/Factorization/UserSvd.cs @@ -348,7 +348,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization { test = Math.Abs(s[l]) + Math.Abs(s[l + 1]); ztest = test + Math.Abs(e[l]); - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { e[l] = 0.0f; break; @@ -377,7 +377,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization } ztest = test + Math.Abs(s[ls]); - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { s[ls] = 0.0f; break; diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/BiCgStab.cs b/src/Numerics/LinearAlgebra/Single/Solvers/BiCgStab.cs index 066c300f..5874afc9 100644 --- a/src/Numerics/LinearAlgebra/Single/Solvers/BiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Single/Solvers/BiCgStab.cs @@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // if (rho_(i-1) == 0) // METHOD FAILS // If rho is only 1 ULP from zero then we fail. - if (currentRho.AlmostEqual(0, 1)) + if (currentRho.AlmostEqualNumbersBetween(0, 1)) { // Rho-type breakdown throw new Exception("Iterative solver experience a numerical break down"); @@ -251,7 +251,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // for continuation it is necessary that omega_i != 0.0 // If omega is only 1 ULP from zero then we fail. - if (omega.AlmostEqual(0, 1)) + if (omega.AlmostEqualNumbersBetween(0, 1)) { // Omega-type breakdown throw new Exception("Iterative solver experience a numerical break down"); diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/GpBiCg.cs b/src/Numerics/LinearAlgebra/Single/Solvers/GpBiCg.cs index 246044fa..ebb486fa 100644 --- a/src/Numerics/LinearAlgebra/Single/Solvers/GpBiCg.cs +++ b/src/Numerics/LinearAlgebra/Single/Solvers/GpBiCg.cs @@ -265,7 +265,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // We'll set cDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // c.DotProduct(t) will be zero and so will c.DotProduct(y) - if (cdot.AlmostEqual(0, 1)) + if (cdot.AlmostEqualNumbersBetween(0, 1)) { cdot = 1.0f; } @@ -293,7 +293,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // We'll set yDot to 1 if it is zero to prevent NaN's // Note that the calculation should continue fine because // y.DotProduct(t) will be zero and so will c.DotProduct(y) - if (ydot.AlmostEqual(0, 1)) + if (ydot.AlmostEqualNumbersBetween(0, 1)) { ydot = 1.0f; } @@ -353,7 +353,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k) // But first we check if there is a possible NaN. If so just reset beta to zero. - beta = (!sigma.AlmostEqual(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0; + beta = (!sigma.AlmostEqualNumbersBetween(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0; // w_k = c_k + beta_k s_k s.Multiply(beta, temp2); diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Single/Solvers/MlkBiCgStab.cs index c0f5555a..25fa5230 100644 --- a/src/Numerics/LinearAlgebra/Single/Solvers/MlkBiCgStab.cs +++ b/src/Numerics/LinearAlgebra/Single/Solvers/MlkBiCgStab.cs @@ -344,7 +344,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // c_((j-1)k+k) = q^T_1 w_((j-1)k+k) c[k - 1] = _startingVectors[0].DotProduct(w[k - 1]); - if (c[k - 1].AlmostEqual(0, 1)) + if (c[k - 1].AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -367,7 +367,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // If rho is zero then temp is a zero vector and we're probably // about to have zero residuals (i.e. an exact solution). // So set rho to 1.0 because in the next step it will turn to zero. - if (rho.AlmostEqual(0, 1)) + if (rho.AlmostEqualNumbersBetween(0, 1)) { rho = 1.0f; } @@ -445,7 +445,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers } beta = rho*c[k - 1]; - if (beta.AlmostEqual(0, 1)) + if (beta.AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } @@ -497,7 +497,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers { // c_(jk+1) = q^T_i+1 d_(jk+i) c[i] = _startingVectors[i + 1].DotProduct(d[i]); - if (c[i].AlmostEqual(0, 1)) + if (c[i].AlmostEqualNumbersBetween(0, 1)) { throw new Exception("Iterative solver experience a numerical break down"); } diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs index e55391cd..ed3dc421 100644 --- a/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs +++ b/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs @@ -226,7 +226,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // ||r_i|| <= stop_tol * ||b|| // Stop the calculation if it's clearly smaller than the tolerance var decimalMagnitude = Math.Abs(stopCriterium.Magnitude()) + 1; - if (residualNorm.IsSmallerWithDecimalPlaces(stopCriterium, decimalMagnitude)) + if (residualNorm.IsSmallerDecimal(stopCriterium, decimalMagnitude)) { if (_lastIteration <= iterationNumber) { diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/TFQMR.cs b/src/Numerics/LinearAlgebra/Single/Solvers/TFQMR.cs index efc774e3..2420bc33 100644 --- a/src/Numerics/LinearAlgebra/Single/Solvers/TFQMR.cs +++ b/src/Numerics/LinearAlgebra/Single/Solvers/TFQMR.cs @@ -164,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers { // sigma = (v, r) var sigma = v.DotProduct(r); - if (sigma.AlmostEqual(0, 1)) + if (sigma.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); @@ -237,7 +237,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers // The odd step if (!IsEven(iterationNumber)) { - if (rho.AlmostEqual(0, 1)) + if (rho.AlmostEqualNumbersBetween(0, 1)) { // FAIL HERE iterator.Cancel(); diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj index c29be0c3..bbd56164 100644 --- a/src/Numerics/Numerics.csproj +++ b/src/Numerics/Numerics.csproj @@ -86,6 +86,7 @@ + diff --git a/src/Numerics/Precision.Equality.cs b/src/Numerics/Precision.Equality.cs new file mode 100644 index 00000000..c1ed6dfc --- /dev/null +++ b/src/Numerics/Precision.Equality.cs @@ -0,0 +1,1049 @@ +// +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// +// Copyright (c) 2009-2010 Math.NET +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// + +using System; +using System.Collections.Generic; +#if PORTABLE +using System.Runtime.InteropServices; +#endif +using MathNet.Numerics.LinearAlgebra; + +namespace MathNet.Numerics +{ + +#if !NOSYSNUMERICS + using Complex = System.Numerics.Complex; +#endif + + public static partial class Precision + { + /// + /// Compares two doubles and determines if they are equal + /// within the specified maximum absolute error. + /// + /// The norm of the first value (can be negative). + /// The norm of the second value (can be negative). + /// The norm of the difference of the two values (can be negative). + /// The absolute accuracy required for being almost equal. + /// True if both doubles are almost equal up to the specified maximum absolute error, false otherwise. + public static bool AlmostEqualNorm(this double a, double b, double diff, double maximumAbsoluteError) + { + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + return Math.Abs(diff) < maximumAbsoluteError; + } + + /// + /// Compares two doubles and determines if they are equal + /// within the specified maximum absolute error. + /// + /// The first value. + /// The second value. + /// The absolute accuracy required for being almost equal. + /// True if both doubles are almost equal up to the specified maximum absolute error, false otherwise. + public static bool AlmostEqualNorm(this T a, T b, double maximumAbsoluteError) + where T : IPrecisionSupport + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumAbsoluteError); + } + + /// + /// Compares two doubles and determines if they are equal + /// within the specified maximum error. + /// + /// The norm of the first value (can be negative). + /// The norm of the second value (can be negative). + /// The norm of the difference of the two values (can be negative). + /// The accuracy required for being almost equal. + /// True if both doubles are almost equal up to the specified maximum error, false otherwise. + public static bool AlmostEqualNormRelative(this double a, double b, double diff, double maximumError) + { + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + // If one is almost zero, fall back to absolute equality + if (Math.Abs(a) < DoublePrecision || Math.Abs(b) < DoublePrecision) + { + return AlmostEqualNorm(a, b, diff, maximumError); + } + + if ((a == 0 && Math.Abs(b) < maximumError) || (b == 0 && Math.Abs(a) < maximumError)) + { + return true; + } + + return Math.Abs(diff) < maximumError * Math.Max(Math.Abs(a), Math.Abs(b)); + } + + /// + /// Compares two doubles and determines if they are equal + /// within the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + /// True if both doubles are almost equal up to the specified maximum error, false otherwise. + public static bool AlmostEqualNormRelative(this T a, T b, double maximumError) + where T : IPrecisionSupport + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumError); + } + + /// + /// Compares two doubles and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqual(this double a, double b, double maximumAbsoluteError) + { + return AlmostEqualNorm(a, b, a - b, maximumAbsoluteError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqual(this float a, float b, double maximumAbsoluteError) + { + return AlmostEqualNorm(a, b, a - b, maximumAbsoluteError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqual(this Complex a, Complex b, double maximumAbsoluteError) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumAbsoluteError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqual(this Complex32 a, Complex32 b, double maximumAbsoluteError) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumAbsoluteError); + } + + /// + /// Compares two doubles and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqualRelative(this double a, double b, double maximumError) + { + return AlmostEqualNormRelative(a, b, a - b, maximumError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqualRelative(this float a, float b, double maximumError) + { + return AlmostEqualNormRelative(a, b, a - b, maximumError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqualRelative(this Complex a, Complex b, double maximumError) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumError); + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqualRelative(this Complex32 a, Complex32 b, double maximumError) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumError); + } + + /// + /// Checks whether two real numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqual(this double a, double b) + { + return AlmostEqualNorm(a, b, a - b, DefaultDoubleAccuracy); + } + + /// + /// Checks whether two real numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqual(this float a, float b) + { + return AlmostEqualNorm(a, b, a - b, DefaultSingleAccuracy); + } + + /// + /// Checks whether two Compex numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqual(this Complex a, Complex b) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), DefaultDoubleAccuracy); + } + + /// + /// Checks whether two Compex numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqual(this Complex32 a, Complex32 b) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), DefaultSingleAccuracy); + } + + /// + /// Checks whether two real numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqualRelative(this double a, double b) + { + return AlmostEqualNormRelative(a, b, a - b, DefaultDoubleAccuracy); + } + + /// + /// Checks whether two real numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqualRelative(this float a, float b) + { + return AlmostEqualNormRelative(a, b, a - b, DefaultSingleAccuracy); + } + + /// + /// Checks whether two Compex numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqualRelative(this Complex a, Complex b) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), DefaultDoubleAccuracy); + } + + /// + /// Checks whether two Compex numbers are almost equal. + /// + /// The first number + /// The second number + /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. + public static bool AlmostEqualRelative(this Complex32 a, Complex32 b) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), DefaultSingleAccuracy); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// + /// + /// The values are equal if the difference between the two numbers is smaller than 0.5e-decimalPlaces. We divide by + /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + /// 0.005 and 0.015, but not 0.02 and not 0.00 + /// + /// + /// The norm of the first value (can be negative). + /// The norm of the second value (can be negative). + /// The norm of the difference of the two values (can be negative). + /// The number of decimal places. + public static bool AlmostEqualNorm(this double a, double b, double diff, int decimalPlaces) + { + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + // The values are equal if the difference between the two numbers is smaller than + // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range + // on each side of the numbers, e.g. if decimalPlaces == 2, + // then 0.01 will equal between 0.005 and 0.015, but not 0.02 and not 0.00 + double decimalPlaceMagnitude = Math.Pow(10, -decimalPlaces) / 2d; + return Math.Abs(diff) < decimalPlaceMagnitude; + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// + /// + /// The values are equal if the difference between the two numbers is smaller than 0.5e-decimalPlaces. We divide by + /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + /// 0.005 and 0.015, but not 0.02 and not 0.00 + /// + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualNorm(this T a, T b, int decimalPlaces) + where T : IPrecisionSupport + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// + /// + /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + /// 0.005 and 0.015, but not 0.02 and not 0.00 + /// + /// + /// The norm of the first value (can be negative). + /// The norm of the second value (can be negative). + /// The norm of the difference of the two values (can be negative). + /// Thrown if is smaller than zero. + public static bool AlmostEqualNormRelative(this double a, double b, double diff, int decimalPlaces) + { + if (decimalPlaces < 0) + { + // Can't have a negative number of decimal places + throw new ArgumentOutOfRangeException("decimalPlaces"); + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + // If both numbers are equal, get out now. This should remove the possibility of both numbers being zero + // and any problems associated with that. + if (a.Equals(b)) + { + return true; + } + + // If one is almost zero, fall back to absolute equality + if (Math.Abs(a) < DoublePrecision || Math.Abs(b) < DoublePrecision) + { + // The values are equal if the difference between the two numbers is smaller than + // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range + // on each side of the numbers, e.g. if decimalPlaces == 2, + // then 0.01 will equal between 0.005 and 0.015, but not 0.02 and not 0.00 + double decimalPlaceMagnitude = Math.Pow(10, -decimalPlaces) / 2d; + return Math.Abs(diff) < decimalPlaceMagnitude; + } + + // If the magnitudes of the two numbers are equal to within one magnitude the numbers could potentially be equal + int magnitudeOfFirst = Magnitude(a); + int magnitudeOfSecond = Magnitude(b); + int magnitudeOfMax = Math.Max(magnitudeOfFirst, magnitudeOfSecond); + if (magnitudeOfMax > (Math.Min(magnitudeOfFirst, magnitudeOfSecond) + 1)) + { + return false; + } + + // The values are equal if the difference between the two numbers is smaller than + // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range + // on each side of the numbers, e.g. if decimalPlaces == 2, + // then 0.01 will equal between 0.00995 and 0.01005, but not 0.0015 and not 0.0095 + double decimalPlaceMagnitude1 = Math.Pow(10, magnitudeOfMax - decimalPlaces) / 2d; + return Math.Abs(diff) < decimalPlaceMagnitude1; + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// + /// + /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + /// 0.005 and 0.015, but not 0.02 and not 0.00 + /// + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualNormRelative(this T a, T b, int decimalPlaces) + where T : IPrecisionSupport + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqual(this double a, double b, int decimalPlaces) + { + return AlmostEqualNorm(a, b, a - b, decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqual(this float a, float b, int decimalPlaces) + { + return AlmostEqualNorm(a, b, a - b, decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqual(this Complex a, Complex b, int decimalPlaces) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqual(this Complex32 a, Complex32 b, int decimalPlaces) + { + return AlmostEqualNorm(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualRelative(this double a, double b, int decimalPlaces) + { + return AlmostEqualNormRelative(a, b, a - b, decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualRelative(this float a, float b, int decimalPlaces) + { + return AlmostEqualNormRelative(a, b, a - b, decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualRelative(this Complex a, Complex b, int decimalPlaces) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualRelative(this Complex32 a, Complex32 b, int decimalPlaces) + { + return AlmostEqualNormRelative(a.Norm(), b.Norm(), a.NormOfDifference(b), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. + /// + /// + /// + /// Determines the 'number' of floating point numbers between two values (i.e. the number of discrete steps + /// between the two numbers) and then checks if that is within the specified tolerance. So if a tolerance + /// of 1 is passed then the result will be true only if the two numbers have the same binary representation + /// OR if they are two adjacent numbers that only differ by one step. + /// + /// + /// The comparison method used is explained in http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm . The article + /// at http://www.extremeoptimization.com/resources/Articles/FPDotNetConceptsAndFormats.aspx explains how to transform the C code to + /// .NET enabled code without using pointers and unsafe code. + /// + /// + /// The first value. + /// The second value. + /// The maximum number of floating point values between the two values. Must be 1 or larger. + /// Thrown if is smaller than one. + public static bool AlmostEqualNumbersBetween(this double a, double b, long maxNumbersBetween) + { + // Make sure maxNumbersBetween is non-negative and small enough that the + // default NAN won't compare as equal to anything. + if (maxNumbersBetween < 1) + { + throw new ArgumentOutOfRangeException("maxNumbersBetween"); + } + + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + // Get the first double and convert it to an integer value (by using the binary representation) + long firstUlong = AsDirectionalInt64(a); + + // Get the second double and convert it to an integer value (by using the binary representation) + long secondUlong = AsDirectionalInt64(b); + + // Now compare the values. + // Note that this comparison can overflow so we'll approach this differently + // Do note that we could overflow this way too. We should probably check that we don't. + return (a > b) ? (secondUlong + maxNumbersBetween >= firstUlong) : (firstUlong + maxNumbersBetween >= secondUlong); + } + + /// + /// Compares two floats and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. + /// + /// The first value. + /// The second value. + /// The maximum number of floating point values between the two values. Must be 1 or larger. + /// Thrown if is smaller than one. + public static bool AlmostEqualNumbersBetween(this float a, float b, int maxNumbersBetween) + { + // Make sure maxNumbersBetween is non-negative and small enough that the + // default NAN won't compare as equal to anything. + if (maxNumbersBetween < 1) + { + throw new ArgumentOutOfRangeException("maxNumbersBetween"); + } + + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (float.IsInfinity(a) || float.IsInfinity(b)) + { + return a == b; + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (float.IsNaN(a) || float.IsNaN(b)) + { + return false; + } + + // Get the first float and convert it to an integer value (by using the binary representation) + int firstUlong = AsDirectionalInt32(a); + + // Get the second float and convert it to an integer value (by using the binary representation) + int secondUlong = AsDirectionalInt32(b); + + // Now compare the values. + // Note that this comparison can overflow so we'll approach this differently + // Do note that we could overflow this way too. We should probably check that we don't. + return (a > b) ? (secondUlong + maxNumbersBetween >= firstUlong) : (firstUlong + maxNumbersBetween >= secondUlong); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqual(this IList a, IList b, double maximumAbsoluteError) + { + return ListForAll(a, b, AlmostEqual, maximumAbsoluteError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqual(this IList a, IList b, double maximumAbsoluteError) + { + return ListForAll(a, b, AlmostEqual, maximumAbsoluteError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqual(this IList a, IList b, double maximumAbsoluteError) + { + return ListForAll(a, b, AlmostEqual, maximumAbsoluteError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqual(this IList a, IList b, double maximumAbsoluteError) + { + return ListForAll(a, b, AlmostEqual, maximumAbsoluteError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualRelative(this IList a, IList b, double maximumError) + { + return ListForAll(a, b, AlmostEqualRelative, maximumError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualRelative(this IList a, IList b, double maximumError) + { + return ListForAll(a, b, AlmostEqualRelative, maximumError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualRelative(this IList a, IList b, double maximumError) + { + return ListForAll(a, b, AlmostEqualRelative, maximumError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualRelative(this IList a, IList b, double maximumError) + { + return ListForAll(a, b, AlmostEqualRelative, maximumError); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqual(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqual, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqual(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqual, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqual(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqual, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqual(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqual, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqualRelative(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqualRelative, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqualRelative(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqualRelative, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqualRelative(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqualRelative, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + public static bool ListAlmostEqualRelative(this IList a, IList b, int decimalPlaces) + { + return ListForAll(a, b, AlmostEqualRelative, decimalPlaces); + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualNorm(this IList a, IList b, double maximumAbsoluteError) + where T : IPrecisionSupport + { + if (a == null && b == null) + { + return true; + } + + if (a == null || b == null || a.Count != b.Count) + { + return false; + } + + for (int i = 0; i < a.Count; i++) + { + if (!AlmostEqualNorm(a[i], b[i], maximumAbsoluteError)) + { + return false; + } + } + + return true; + } + + /// + /// Compares two lists of doubles and determines if they are equal within the + /// specified maximum error. + /// + /// The first value list. + /// The second value list. + /// The accuracy required for being almost equal. + public static bool ListAlmostEqualNormRelative(this IList a, IList b, double maximumError) + where T : IPrecisionSupport + { + if (a == null && b == null) + { + return true; + } + + if (a == null || b == null || a.Count != b.Count) + { + return false; + } + + for (int i = 0; i < a.Count; i++) + { + if (!AlmostEqualNormRelative(a[i], b[i], maximumError)) + { + return false; + } + } + + return true; + } + + private static bool ListForAll(IList a, IList b, Func predicate, TP parameter) + { + if (a == null && b == null) + { + return true; + } + + if (a == null || b == null || a.Count != b.Count) + { + return false; + } + + for (int i = 0; i < a.Count; i++) + { + if (!predicate(a[i], b[i], parameter)) + { + return false; + } + } + + return true; + } + + /// + /// Compares two complex and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqual(this Vector a, Vector b, double maximumAbsoluteError) + where T : struct, IEquatable, IFormattable + { + return AlmostEqualNorm(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), maximumAbsoluteError); + } + + /// + /// Compares two doubles and determines if they are equal within + /// the specified maximum error. + /// + /// The first value. + /// The second value. + /// The accuracy required for being almost equal. + public static bool AlmostEqualRelative(this Vector a, Vector b, double maximumError) + where T : struct, IEquatable, IFormattable + { + return AlmostEqualNormRelative(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), maximumError); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + /// number of decimal places as an absolute measure. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqual(this Vector a, Vector b, int decimalPlaces) + where T : struct, IEquatable, IFormattable + { + return AlmostEqualNorm(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), decimalPlaces); + } + + /// + /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// + /// The first value. + /// The second value. + /// The number of decimal places. + public static bool AlmostEqualRelative(this Vector a, Vector b, int decimalPlaces) + where T : struct, IEquatable, IFormattable + { + return AlmostEqualNormRelative(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), decimalPlaces); + } + + ///// + ///// Compares two complex and determines if they are equal within + ///// the specified maximum error. + ///// + ///// The first value. + ///// The second value. + ///// The accuracy required for being almost equal. + //public static bool AlmostEqual(this Matrix a, Matrix b, double maximumAbsoluteError) + // where T : struct, IEquatable, IFormattable + //{ + // return AlmostEqualNorm(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), maximumAbsoluteError); + //} + + ///// + ///// Compares two doubles and determines if they are equal within + ///// the specified maximum error. + ///// + ///// The first value. + ///// The second value. + ///// The accuracy required for being almost equal. + //public static bool AlmostEqualRelative(this Matrix a, Matrix b, double maximumError) + // where T : struct, IEquatable, IFormattable + //{ + // return AlmostEqualNormRelative(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), maximumError); + //} + + ///// + ///// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + ///// number of decimal places as an absolute measure. + ///// + ///// The first value. + ///// The second value. + ///// The number of decimal places. + //public static bool AlmostEqual(this Matrix a, Matrix b, int decimalPlaces) + // where T : struct, IEquatable, IFormattable + //{ + // return AlmostEqualNorm(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), decimalPlaces); + //} + + ///// + ///// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + ///// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + ///// + ///// The first value. + ///// The second value. + ///// The number of decimal places. + //public static bool AlmostEqualRelative(this Matrix a, Matrix b, int decimalPlaces) + // where T : struct, IEquatable, IFormattable + //{ + // return AlmostEqualNormRelative(a.L2Norm(), b.L2Norm(), (a - b).L2Norm(), decimalPlaces); + //} + } +} diff --git a/src/Numerics/Precision.cs b/src/Numerics/Precision.cs index 3beafb3a..5e06f718 100644 --- a/src/Numerics/Precision.cs +++ b/src/Numerics/Precision.cs @@ -28,15 +28,15 @@ // OTHER DEALINGS IN THE SOFTWARE. // -namespace MathNet.Numerics -{ - using System; - using System.Collections.Generic; +using System; #if PORTABLE - using System.Runtime.InteropServices; +using System.Runtime.InteropServices; #endif +namespace MathNet.Numerics +{ + #if !NOSYSNUMERICS using Complex = System.Numerics.Complex; #endif @@ -79,21 +79,21 @@ namespace MathNet.Numerics /// /// /// - public static class Precision + public static partial class Precision { /// /// The number of binary digits used to represent the binary number for a double precision floating /// point value. i.e. there are this many digits used to represent the /// actual number, where in a number as: 0.134556 * 10^5 the digits are 0.134556 and the exponent is 5. /// - private const int DoubleWidth = 53; + const int DoubleWidth = 53; /// /// The number of binary digits used to represent the binary number for a single precision floating /// point value. i.e. there are this many digits used to represent the /// actual number, where in a number as: 0.134556 * 10^5 the digits are 0.134556 and the exponent is 5. /// - private const int SingleWidth = 24; + const int SingleWidth = 24; /// /// The maximum relative precision of of double-precision floating numbers (64 bit) @@ -116,14 +116,14 @@ namespace MathNet.Numerics public static readonly int SingleDecimalPlaces = (int) Math.Floor(Math.Abs(Math.Log10(SinglePrecision))); /// - /// Value representing 10 * 2^(-52) + /// Value representing 10 * 2^(-53) = 1.11022302462516E-15 /// - private static readonly double DefaultDoubleRelativeAccuracy = DoublePrecision * 10; + static readonly double DefaultDoubleAccuracy = DoublePrecision*10; /// - /// Value representing 10 * 2^(-24) + /// Value representing 10 * 2^(-24) = 5.96046447753906E-07 /// - private static readonly float DefaultSingleRelativeAccuracy = (float)(SinglePrecision * 10); + static readonly float DefaultSingleAccuracy = (float) (SinglePrecision*10); /// /// Returns the magnitude of the number. @@ -145,7 +145,7 @@ namespace MathNet.Numerics #if PORTABLE var truncated = (int)Truncate(magnitude); #else - var truncated = (int)Math.Truncate(magnitude); + var truncated = (int) Math.Truncate(magnitude); #endif // To get the right number we need to know if the value is negative or positive @@ -177,7 +177,7 @@ namespace MathNet.Numerics #if PORTABLE var truncated = (int)Truncate(magnitude); #else - var truncated = (int)Math.Truncate(magnitude); + var truncated = (int) Math.Truncate(magnitude); #endif // To get the right number we need to know if the value is negative or positive @@ -201,7 +201,7 @@ namespace MathNet.Numerics } int magnitude = Magnitude(value); - return value * Math.Pow(10, -magnitude); + return value*Math.Pow(10, -magnitude); } /// @@ -211,7 +211,7 @@ namespace MathNet.Numerics /// /// The resulting long value. /// - private static long AsInt64(double value) + static long AsInt64(double value) { #if PORTABLE return DoubleToInt64Bits(value); @@ -227,11 +227,11 @@ namespace MathNet.Numerics /// /// The input double value. /// A long value which is roughly the equivalent of the double value. - private static long AsDirectionalInt64(double value) + static long AsDirectionalInt64(double value) { // Convert in the normal way. long result = AsInt64(value); - + // Now find out where we're at in the range // If the value is larger/equal to zero then we can just return the value // if the value is negative we subtract long.MinValue from it. @@ -245,7 +245,7 @@ namespace MathNet.Numerics /// /// The input float value. /// An int value which is roughly the equivalent of the double value. - private static int AsDirectionalInt32(float value) + static int AsDirectionalInt32(float value) { // Convert in the normal way. int result = FloatToInt32Bits(value); @@ -306,7 +306,7 @@ namespace MathNet.Numerics return Int64BitsToDouble(intValue); #else return BitConverter.Int64BitsToDouble(intValue); -#endif +#endif } /// @@ -362,7 +362,7 @@ namespace MathNet.Numerics return Int64BitsToDouble(intValue); #else return BitConverter.Int64BitsToDouble(intValue); -#endif +#endif } /// @@ -375,7 +375,7 @@ namespace MathNet.Numerics /// public static double CoerceZero(this double a, int maxNumbersBetween) { - return CoerceZero(a, (long)maxNumbersBetween); + return CoerceZero(a, (long) maxNumbersBetween); } /// @@ -403,7 +403,7 @@ namespace MathNet.Numerics // We allow maxNumbersBetween between 0 and the number so // we need to check if there a - if (NumbersBetween(0.0, a) <= (ulong)maxNumbersBetween) + if (NumbersBetween(0.0, a) <= (ulong) maxNumbersBetween) { return 0.0; } @@ -426,7 +426,7 @@ namespace MathNet.Numerics { throw new ArgumentOutOfRangeException("maximumAbsoluteError"); } - + if (double.IsInfinity(a) || double.IsNaN(a)) { return a; @@ -455,12 +455,11 @@ namespace MathNet.Numerics /// /// The value. /// The ulps difference. - /// The bottom range end. - /// The top range end. /// /// Thrown if is smaller than zero. /// - public static void RangeOfMatchingFloatingPointNumbers(this double value, long maxNumbersBetween, out double bottomRangeEnd, out double topRangeEnd) + /// Tuple of the bottom and top range ends. + public static Tuple RangeOfMatchingFloatingPointNumbers(this double value, long maxNumbersBetween) { // Make sure ulpDifference is non-negative if (maxNumbersBetween < 1) @@ -472,17 +471,13 @@ namespace MathNet.Numerics // return the same infinity for the range. if (double.IsInfinity(value)) { - topRangeEnd = value; - bottomRangeEnd = value; - return; + return new Tuple(value, value); } // If the value is a NaN then the range is a NaN too. if (double.IsNaN(value)) { - topRangeEnd = double.NaN; - bottomRangeEnd = double.NaN; - return; + return new Tuple(double.NaN, double.NaN); } // Translate the bit pattern of the double to an integer. @@ -494,14 +489,14 @@ namespace MathNet.Numerics long intValue = AsInt64(value); #if PORTABLE - // We need to protect against over- and under-flow of the intValue when - // we start to add the ulpsDifference. + // We need to protect against over- and under-flow of the intValue when + // we start to add the ulpsDifference. if (intValue < 0) { // Note that long.MinValue has the same bit pattern as // -0.0. Therefore we're working in opposite direction (i.e. add if we want to // go more negative and subtract if we want to go less negative) - topRangeEnd = Math.Abs(long.MinValue - intValue) < maxNumbersBetween + var topRangeEnd = Math.Abs(long.MinValue - intValue) < maxNumbersBetween // Got underflow, which can be fixed by splitting the calculation into two bits // first get the remainder of the intValue after subtracting it from the long.MinValue // and add that to the ulpsDifference. That way we'll turn positive without underflow @@ -509,18 +504,20 @@ namespace MathNet.Numerics // No problems here, move along. : Int64BitsToDouble(intValue - maxNumbersBetween); - bottomRangeEnd = Math.Abs(intValue) < maxNumbersBetween + var bottomRangeEnd = Math.Abs(intValue) < maxNumbersBetween // Underflow, which means we'd have to go further than a long would allow us. // Also we couldn't translate it back to a double, so we'll return -Double.MaxValue ? -double.MaxValue // intValue is negative. Adding the positive ulpsDifference means that it gets less negative. // However due to the conversion way this means that the actual double value gets more negative :-S : Int64BitsToDouble(intValue + maxNumbersBetween); + + return new Tuple(bottomRangeEnd, topRangeEnd); } else { // IntValue is positive - topRangeEnd = long.MaxValue - intValue < maxNumbersBetween + var topRangeEnd = long.MaxValue - intValue < maxNumbersBetween // Overflow, which means we'd have to go further than a long would allow us. // Also we couldn't translate it back to a double, so we'll return Double.MaxValue ? double.MaxValue @@ -528,13 +525,15 @@ namespace MathNet.Numerics : Int64BitsToDouble(intValue + maxNumbersBetween); // Check the bottom range end for underflows - bottomRangeEnd = intValue > maxNumbersBetween + var bottomRangeEnd = intValue > maxNumbersBetween // No problems here. IntValue is larger than ulpsDifference so we'll end up with a // positive number. ? Int64BitsToDouble(intValue - maxNumbersBetween) // Int value is bigger than zero but smaller than the ulpsDifference. So we'll need to deal with // the reversal at the negative end : Int64BitsToDouble(long.MinValue + (maxNumbersBetween - intValue)); + + return new Tuple(bottomRangeEnd, topRangeEnd); } #else // We need to protect against over- and under-flow of the intValue when @@ -544,7 +543,7 @@ namespace MathNet.Numerics // Note that long.MinValue has the same bit pattern as // -0.0. Therefore we're working in opposite direction (i.e. add if we want to // go more negative and subtract if we want to go less negative) - topRangeEnd = Math.Abs(long.MinValue - intValue) < maxNumbersBetween + var topRangeEnd = Math.Abs(long.MinValue - intValue) < maxNumbersBetween // Got underflow, which can be fixed by splitting the calculation into two bits // first get the remainder of the intValue after subtracting it from the long.MinValue // and add that to the ulpsDifference. That way we'll turn positive without underflow @@ -552,18 +551,20 @@ namespace MathNet.Numerics // No problems here, move along. : BitConverter.Int64BitsToDouble(intValue - maxNumbersBetween); - bottomRangeEnd = Math.Abs(intValue) < maxNumbersBetween + var bottomRangeEnd = Math.Abs(intValue) < maxNumbersBetween // Underflow, which means we'd have to go further than a long would allow us. // Also we couldn't translate it back to a double, so we'll return -Double.MaxValue ? -double.MaxValue // intValue is negative. Adding the positive ulpsDifference means that it gets less negative. // However due to the conversion way this means that the actual double value gets more negative :-S : BitConverter.Int64BitsToDouble(intValue + maxNumbersBetween); + + return new Tuple(bottomRangeEnd, topRangeEnd); } else { // IntValue is positive - topRangeEnd = long.MaxValue - intValue < maxNumbersBetween + var topRangeEnd = long.MaxValue - intValue < maxNumbersBetween // Overflow, which means we'd have to go further than a long would allow us. // Also we couldn't translate it back to a double, so we'll return Double.MaxValue ? double.MaxValue @@ -571,13 +572,15 @@ namespace MathNet.Numerics : BitConverter.Int64BitsToDouble(intValue + maxNumbersBetween); // Check the bottom range end for underflows - bottomRangeEnd = intValue > maxNumbersBetween + var bottomRangeEnd = intValue > maxNumbersBetween // No problems here. IntValue is larger than ulpsDifference so we'll end up with a // positive number. ? BitConverter.Int64BitsToDouble(intValue - maxNumbersBetween) // Int value is bigger than zero but smaller than the ulpsDifference. So we'll need to deal with // the reversal at the negative end : BitConverter.Int64BitsToDouble(long.MinValue + (maxNumbersBetween - intValue)); + + return new Tuple(bottomRangeEnd, topRangeEnd); } #endif } @@ -591,9 +594,7 @@ namespace MathNet.Numerics /// The maximum floating point number which is larger than the given . public static double MaximumMatchingFloatingPointNumber(this double value, long maxNumbersBetween) { - double topRangeEnd, bottomRangeEnd; - RangeOfMatchingFloatingPointNumbers(value, maxNumbersBetween, out bottomRangeEnd, out topRangeEnd); - return topRangeEnd; + return RangeOfMatchingFloatingPointNumbers(value, maxNumbersBetween).Item2; } /// @@ -605,9 +606,7 @@ namespace MathNet.Numerics /// The minimum floating point number which is smaller than the given . public static double MinimumMatchingFloatingPointNumber(this double value, long maxNumbersBetween) { - double topRangeEnd, bottomRangeEnd; - RangeOfMatchingFloatingPointNumbers(value, maxNumbersBetween, out bottomRangeEnd, out topRangeEnd); - return bottomRangeEnd; + return RangeOfMatchingFloatingPointNumbers(value, maxNumbersBetween).Item1; } /// @@ -615,8 +614,6 @@ namespace MathNet.Numerics /// /// The value. /// The relative difference. - /// The number of ULPS between the value and the value - relativeDifference. - /// The number of ULPS between the value and the value + relativeDifference. /// /// Thrown if is smaller than zero. /// @@ -626,7 +623,11 @@ namespace MathNet.Numerics /// /// Thrown if is double.NaN. /// - public static void RangeOfMatchingNumbers(this double value, double relativeDifference, out long bottomRangeEnd, out long topRangeEnd) + /// + /// Tuple with the number of ULPS between the value and the value - relativeDifference as first, + /// and the number of ULPS between the value and the value + relativeDifference as second value. + /// + public static Tuple RangeOfMatchingNumbers(this double value, double relativeDifference) { // Make sure the relative is non-negative if (relativeDifference < 0) @@ -651,22 +652,20 @@ namespace MathNet.Numerics // so return the ulps counts for the difference. if (value.Equals(0)) { - topRangeEnd = AsInt64(relativeDifference); - bottomRangeEnd = topRangeEnd; - return; + var v = AsInt64(relativeDifference); + return new Tuple(v, v); } // Calculate the ulps for the maximum and minimum values // Note that these can overflow - long max = AsDirectionalInt64(value + (relativeDifference * Math.Abs(value))); - long min = AsDirectionalInt64(value - (relativeDifference * Math.Abs(value))); + long max = AsDirectionalInt64(value + (relativeDifference*Math.Abs(value))); + long min = AsDirectionalInt64(value - (relativeDifference*Math.Abs(value))); // Calculate the ulps from the value long intValue = AsDirectionalInt64(value); // Determine the ranges - topRangeEnd = Math.Abs(max - intValue); - bottomRangeEnd = Math.Abs(intValue - min); + return new Tuple(Math.Abs(intValue - min), Math.Abs(max - intValue)); } /// @@ -708,633 +707,54 @@ namespace MathNet.Numerics // Now find the number of values between the two doubles. This should not overflow // given that there are more long values than there are double values - return (a >= b) ? (ulong)(intA - intB) : (ulong)(intB - intA); - } - - /// - /// Checks whether two real numbers are almost equal. - /// - /// The first number - /// The second number - /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. - public static bool AlmostEqual(this double a, double b) - { - double diff = a - b; - return AlmostEqualWithError(a, b, diff, DefaultDoubleRelativeAccuracy); - } - - /// - /// Checks whether two real numbers are almost equal. - /// - /// The first number - /// The second number - /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. - public static bool AlmostEqual(this float a, float b) - { - double diff = a - b; - return AlmostEqualWithError(a, b, diff, DefaultSingleRelativeAccuracy); - } - - /// - /// Checks whether two Compex numbers are almost equal. - /// - /// The first number - /// The second number - /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. - public static bool AlmostEqual(this Complex a, Complex b) - { - double diff = a.NormOfDifference(b); - return AlmostEqualWithError(a.Norm(), b.Norm(), diff, DefaultDoubleRelativeAccuracy); - } - - /// - /// Checks whether two Compex numbers are almost equal. - /// - /// The first number - /// The second number - /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. - public static bool AlmostEqual(this Complex32 a, Complex32 b) - { - double diff = ((IPrecisionSupport)a).NormOfDifference(b); - return AlmostEqualWithError(((IPrecisionSupport)a).Norm(), ((IPrecisionSupport)b).Norm(), diff, DefaultSingleRelativeAccuracy); - } - /// - /// Checks whether two structures with precision support are almost equal. - /// - /// The type of the structures. Must implement . - /// The first structure - /// The second structure - /// true if the two values differ by no more than 10 * 2^(-52); false otherwise. - public static bool AlmostEqual(this T a, T b) - where T : IPrecisionSupport - { - double diff = a.NormOfDifference(b); - return AlmostEqualWithError(a.Norm(), b.Norm(), diff, DefaultDoubleRelativeAccuracy); - } - - /// - /// Compares two complex and determines if they are equal within - /// the specified maximum error. - /// - /// The first value. - /// The second value. - /// The accuracy required for being almost equal. - /// - /// if both complex are almost equal up to the - /// specified maximum error, otherwise. - /// - public static bool AlmostEqualWithError(this Complex a, Complex b, double maximumError) - { - double diff = a.NormOfDifference(b); - return AlmostEqualWithError(a.Norm(), b.Norm(), diff, maximumError); - } - - /// - /// Compares two complex and determines if they are equal within - /// the specified maximum error. - /// - /// The first value. - /// The second value. - /// The accuracy required for being almost equal. - /// - /// if both complex are almost equal up to the - /// specified maximum error, otherwise. - /// - public static bool AlmostEqualWithError(this float a, float b, double maximumError) - { - return AlmostEqualWithError(a, b, a - b, maximumError); - } - - /// - /// Compares two doubles and determines if they are equal within - /// the specified maximum error. - /// - /// The first value. - /// The second value. - /// The accuracy required for being almost equal. - /// - /// if both doubles are almost equal up to the - /// specified maximum error, otherwise. - /// - public static bool AlmostEqualWithError(this double a, double b, double maximumError) - { - return AlmostEqualWithError(a, b, a - b, maximumError); - } - - /// - /// Compares two lists of doubles and determines if they are equal within the - /// specified maximum error. - /// - /// The first value list. - /// The second value list. - /// - /// The accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum error, otherwise. - /// - public static bool AlmostEqualListWithError(this IList a, IList b, double maximumError) - { - if (a == null && b == null) - { - return true; - } - - if (a == null || b == null || a.Count != b.Count) - { - return false; - } - - for (int i = 0; i < a.Count; i++) - { - if (!AlmostEqualWithError(a[i], b[i], a[i] - b[i], maximumError)) - { - return false; - } - } - - return true; - } - - /// - /// Compares two lists of doubles and determines if they are equal within the - /// specified maximum error. - /// - /// The first value list. - /// The second value list. - /// - /// The accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum error, otherwise. - /// - public static bool AlmostEqualListWithError(this IList a, IList b, double maximumError) - { - if (a == null && b == null) - { - return true; - } - - if (a == null || b == null || a.Count != b.Count) - { - return false; - } - - for (int i = 0; i < a.Count; i++) - { - if (!AlmostEqualWithError(a[i].Norm(), b[i].Norm(), a[i].NormOfDifference(b[i]), maximumError)) - { - return false; - } - } - - return true; - } - - /// - /// Compares two structure with precision support and determines if they are equal - /// within the specified maximum relative error. - /// - /// - /// The type of the structures. Must implement . - /// - /// The first structure. - /// The second structure. - /// - /// The accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum relative error, otherwise. - /// - public static bool AlmostEqualWithError(this T a, T b, double maximumError) - where T : IPrecisionSupport - { - return AlmostEqualWithError(a.Norm(), b.Norm(), a.NormOfDifference(b), maximumError); - } - - /// - /// Compares two lists of structures with precision support and determines if they - /// are equal within the specified maximum error. - /// - /// - /// The type of the structures. Must implement . - /// - /// The first structure list. - /// The second structure list. - /// - /// The accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum error, otherwise. - /// - public static bool AlmostEqualListWithError(this IList a, IList b, double maximumError) - where T : IPrecisionSupport - { - if (a == null && b == null) - { - return true; - } - - if (a == null || b == null || a.Count != b.Count) - { - return false; - } - - for (int i = 0; i < a.Count; i++) - { - if (!AlmostEqualWithError(a[i].Norm(), b[i].Norm(), a[i].NormOfDifference(b[i]), maximumError)) - { - return false; - } - } - - return true; - } - - /// - /// Compares two doubles and determines if they are equal within the specified - /// maximum error. - /// - /// The first value. - /// The second value. - /// - /// The difference of the two values (according to some norm). - /// - /// - /// The accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum error, otherwise. - /// - public static bool AlmostEqualWithError(this double a, double b, double diff, double maximumError) - { - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - if (Math.Abs(a) < DoublePrecision || Math.Abs(b) < DoublePrecision) - { - return AlmostEqualWithAbsoluteError(a, b, diff, maximumError); - } - - return AlmostEqualWithRelativeError(a, b, diff, maximumError); - } - - /// - /// Compares two doubles and determines if they are equal within the specified - /// maximum absolute error. - /// - /// The first value. - /// The second value. - /// - /// The difference of the two values (according to some norm). - /// - /// - /// The absolute accuracy required for being almost equal. - /// - /// - /// if both doubles are almost equal up to the specified - /// maximum absolute error, otherwise. - /// - public static bool AlmostEqualWithAbsoluteError(this double a, double b, double diff, double maximumAbsoluteError) - { - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - return Math.Abs(diff) < maximumAbsoluteError; - } - - /// - /// Compares two doubles and determines if they are equal within the specified - /// maximum relative error. - /// - /// The first value. - /// The second value. - /// The difference of the two values (according to some norm). - /// - /// The relative accuracy required for being - /// almost equal. - /// - /// if both doubles are almost equal up to the specified - /// maximum relative error, otherwise. - /// - public static bool AlmostEqualWithRelativeError(this double a, double b, double diff, double maximumRelativeError) - { - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - if ((a == 0 && Math.Abs(b) < maximumRelativeError) - || (b == 0 && Math.Abs(a) < maximumRelativeError)) - { - return true; - } - - return Math.Abs(diff) < maximumRelativeError * Math.Max(Math.Abs(a), Math.Abs(b)); - } - - /// - /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers - /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. - /// - /// - /// - /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by - /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between - /// 0.005 and 0.015, but not 0.02 and not 0.00 - /// - /// - /// The first value. - /// The second value. - /// The number of decimal places. - /// if both doubles are equal to each other within the specified number of decimal places; otherwise . - /// - /// Thrown if is smaller than zero. - /// - public static bool AlmostEqualInDecimalPlaces(this double a, double b, int decimalPlaces) - { - if (decimalPlaces < 0) - { - // Can't have a negative number of decimal places - throw new ArgumentOutOfRangeException("decimalPlaces"); - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - if (Math.Abs(a) < DoublePrecision || Math.Abs(b) < DoublePrecision) - { - return AlmostEqualInAbsoluteDecimalPlaces(a, b, decimalPlaces); - } - - // If both numbers are equal, get out now. This should remove the possibility of both numbers being zero - // and any problems associated with that. - if (a.Equals(b)) - { - return true; - } - - return AlmostEqualInRelativeDecimalPlaces(a, b, decimalPlaces); - } - - /// - /// Compares two floats and determines if they are equal to within the specified number of decimal places or not. If the numbers - /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. - /// - /// - /// - /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by - /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between - /// 0.005 and 0.015, but not 0.02 and not 0.00 - /// - /// - /// The first value. - /// The second value. - /// The number of decimal places. - /// if both doubles are equal to each other within the specified number of decimal places; otherwise . - /// - /// Thrown if is smaller than zero. - /// - public static bool AlmostEqualInDecimalPlaces(this float a, float b, int decimalPlaces) - { - if (decimalPlaces < 0) - { - // Can't have a negative number of decimal places - throw new ArgumentOutOfRangeException("decimalPlaces"); - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (float.IsNaN(a) || float.IsNaN(b)) - { - return false; - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (float.IsInfinity(a) || float.IsInfinity(b)) - { - return a == b; - } - - if (Math.Abs(a) < SinglePrecision || Math.Abs(b) < SinglePrecision) - { - return AlmostEqualInAbsoluteDecimalPlaces(a, b, decimalPlaces); - } - - // If both numbers are equal, get out now. This should remove the possibility of both numbers being zero - // and any problems associated with that. - if (a.Equals(b)) - { - return true; - } - - return AlmostEqualInRelativeDecimalPlaces(a, b, decimalPlaces); + return (a >= b) ? (ulong) (intA - intB) : (ulong) (intB - intA); } /// - /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. + /// Compares two doubles and determines if the first value is larger than the second + /// value to within the tolerance or not. Equality comparison is based on the binary representation. /// - /// - /// - /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by - /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between - /// 0.005 and 0.015, but not 0.02 and not 0.00 - /// - /// /// The first value. /// The second value. - /// The number of decimal places. - /// if both doubles are equal to each other within the specified number of decimal places; otherwise . - public static bool AlmostEqualInRelativeDecimalPlaces(this double a, double b, int decimalPlaces) + /// The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + /// true if the first value is larger than the second value; otherwise false. + public static bool IsLarger(this double a, double b, long maxNumbersBetween) { - if (decimalPlaces < 0) - { - // Can't have a negative number of decimal places - throw new ArgumentOutOfRangeException("decimalPlaces"); - } - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. + // not even themselves, and thus they're not bigger or + // smaller than anything either if (double.IsNaN(a) || double.IsNaN(b)) { return false; } - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // If the magnitudes of the two numbers are equal to within one magnitude the numbers could potentially be equal - int magnitudeOfFirst = Magnitude(a); - int magnitudeOfSecond = Magnitude(b); - int magnitudeOfMax = Math.Max(magnitudeOfFirst, magnitudeOfSecond); - if (magnitudeOfMax > (Math.Min(magnitudeOfFirst, magnitudeOfSecond) + 1)) - { - return false; - } - - // The values are equal if the difference between the two numbers is smaller than - // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range - // on each side of the numbers, e.g. if decimalPlaces == 2, - // then 0.01 will equal between 0.00995 and 0.01005, but not 0.0015 and not 0.0095 - double decimalPlaceMagnitude = Math.Pow(10, magnitudeOfMax - decimalPlaces)/2d; - return Math.Abs((a - b)) < decimalPlaceMagnitude; + return CompareTo(a, b, maxNumbersBetween) > 0; } /// - /// Compares two floats and determines if they are equal to within the specified number of decimal places or not. + /// Compares two doubles and determines if the first value is larger than the second + /// value to within the tolerance or not. Equality comparison is based on the binary representation. /// - /// - /// - /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by - /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between - /// 0.005 and 0.015, but not 0.02 and not 0.00 - /// - /// /// The first value. /// The second value. - /// The number of decimal places. - /// if both floats are equal to each other within the specified number of decimal places; otherwise . - public static bool AlmostEqualInRelativeDecimalPlaces(this float a, float b, int decimalPlaces) + /// The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + /// true if the first value is larger than the second value; otherwise false. + public static bool IsLarger(this float a, float b, long maxNumbersBetween) { - if (decimalPlaces < 0) - { - // Can't have a negative number of decimal places - throw new ArgumentOutOfRangeException("decimalPlaces"); - } - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. + // not even themselves, and thus they're not bigger or + // smaller than anything either if (float.IsNaN(a) || float.IsNaN(b)) { return false; } - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (float.IsInfinity(a) || float.IsInfinity(b)) - { - return a == b; - } - - // If the magnitudes of the two numbers are equal to within one magnitude the numbers could potentially be equal - int magnitudeOfFirst = Magnitude(a); - int magnitudeOfSecond = Magnitude(b); - int magnitudeOfMax = Math.Max(magnitudeOfFirst, magnitudeOfSecond); - if (magnitudeOfMax > (Math.Min(magnitudeOfFirst, magnitudeOfSecond) + 1)) - { - return false; - } - - // The values are equal if the difference between the two numbers is smaller than - // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range - // on each side of the numbers, e.g. if decimalPlaces == 2, - // then 0.01 will equal between 0.00995 and 0.01005, but not 0.0015 and not 0.0095 - var decimalPlaceMagnitude = (float) Math.Pow(10, magnitudeOfMax - decimalPlaces)/2d; - return Math.Abs((a - b)) < decimalPlaceMagnitude; - } - - /// - /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the - /// number of decimal places as an absolute measure. - /// - /// - /// - /// The values are equal if the difference between the two numbers is smaller than 0.5e-decimalPlaces. We divide by - /// two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between - /// 0.005 and 0.015, but not 0.02 and not 0.00 - /// - /// - /// The first value. - /// The second value. - /// The number of decimal places. - /// if both doubles are equal to each other within the specified number of decimal places; otherwise . - public static bool AlmostEqualInAbsoluteDecimalPlaces(this double a, double b, int decimalPlaces) - { - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // The values are equal if the difference between the two numbers is smaller than - // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range - // on each side of the numbers, e.g. if decimalPlaces == 2, - // then 0.01 will equal between 0.005 and 0.015, but not 0.02 and not 0.00 - double decimalPlaceMagnitude = Math.Pow(10, -decimalPlaces)/2d; - return Math.Abs((a - b)) < decimalPlaceMagnitude; + return CompareTo(a, b, maxNumbersBetween) > 0; } /// - /// Compares two floats and determines if they are equal to within the specified number of decimal places or not, using the - /// number of decimal places as an absolute measure. + /// Compares two doubles and determines if the first value is larger than the second + /// value to within the specified number of decimal places or not. /// /// /// @@ -1346,146 +766,8 @@ namespace MathNet.Numerics /// The first value. /// The second value. /// The number of decimal places. - /// if both floats are equal to each other within the specified number of decimal places; otherwise . - public static bool AlmostEqualInAbsoluteDecimalPlaces(this float a, float b, int decimalPlaces) - { - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (float.IsNaN(a) || float.IsNaN(b)) - { - return false; - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (float.IsInfinity(a) || float.IsInfinity(b)) - { - return a == b; - } - - // The values are equal if the difference between the two numbers is smaller than - // 10^(-numberOfDecimalPlaces). We divide by two so that we have half the range - // on each side of the numbers, e.g. if decimalPlaces == 2, - // then 0.01 will equal between 0.005 and 0.015, but not 0.02 and not 0.00 - var decimalPlaceMagnitude = (float) Math.Pow(10, -decimalPlaces)/2f; - return Math.Abs((a - b)) < decimalPlaceMagnitude; - } - - /// - /// Compares two doubles and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. - /// - /// - /// - /// Determines the 'number' of floating point numbers between two values (i.e. the number of discrete steps - /// between the two numbers) and then checks if that is within the specified tolerance. So if a tolerance - /// of 1 is passed then the result will be true only if the two numbers have the same binary representation - /// OR if they are two adjacent numbers that only differ by one step. - /// - /// - /// The comparison method used is explained in http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm . The article - /// at http://www.extremeoptimization.com/resources/Articles/FPDotNetConceptsAndFormats.aspx explains how to transform the C code to - /// .NET enabled code without using pointers and unsafe code. - /// - /// - /// The first value. - /// The second value. - /// The maximum number of floating point values between the two values. Must be 1 or larger. - /// if both doubles are equal to each other within the specified tolerance; otherwise . - /// - /// Thrown if is smaller than one. - /// - public static bool AlmostEqual(this double a, double b, long maxNumbersBetween) - { - // Make sure maxNumbersBetween is non-negative and small enough that the - // default NAN won't compare as equal to anything. - if (maxNumbersBetween < 1) - { - throw new ArgumentOutOfRangeException("maxNumbersBetween"); - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (double.IsInfinity(a) || double.IsInfinity(b)) - { - return a == b; - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (double.IsNaN(a) || double.IsNaN(b)) - { - return false; - } - - // Get the first double and convert it to an integer value (by using the binary representation) - long firstUlong = AsDirectionalInt64(a); - - // Get the second double and convert it to an integer value (by using the binary representation) - long secondUlong = AsDirectionalInt64(b); - - // Now compare the values. - // Note that this comparison can overflow so we'll approach this differently - // Do note that we could overflow this way too. We should probably check that we don't. - return (a > b) ? (secondUlong + maxNumbersBetween >= firstUlong) : (firstUlong + maxNumbersBetween >= secondUlong); - } - - /// - /// Compares two floats and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. - /// - /// The first value. - /// The second value. - /// The maximum number of floating point values between the two values. Must be 1 or larger. - /// if both floats are equal to each other within the specified tolerance; otherwise . - /// - /// Thrown if is smaller than one. - /// - public static bool AlmostEqual(this float a, float b, int maxNumbersBetween) - { - // Make sure maxNumbersBetween is non-negative and small enough that the - // default NAN won't compare as equal to anything. - if (maxNumbersBetween < 1) - { - throw new ArgumentOutOfRangeException("maxNumbersBetween"); - } - - // If A or B are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - if (float.IsInfinity(a) || float.IsInfinity(b)) - { - return a == b; - } - - // If A or B are a NAN, return false. NANs are equal to nothing, - // not even themselves. - if (float.IsNaN(a) || float.IsNaN(b)) - { - return false; - } - - // Get the first float and convert it to an integer value (by using the binary representation) - int firstUlong = AsDirectionalInt32(a); - - // Get the second float and convert it to an integer value (by using the binary representation) - int secondUlong = AsDirectionalInt32(b); - - // Now compare the values. - // Note that this comparison can overflow so we'll approach this differently - // Do note that we could overflow this way too. We should probably check that we don't. - return (a > b) ? (secondUlong + maxNumbersBetween >= firstUlong) : (firstUlong + maxNumbersBetween >= secondUlong); - } - - /// - /// Compares two doubles and determines if the first value is larger than the second - /// value to within the tolerance or not. Equality comparison is based on the binary representation. - /// - /// The first value. - /// The second value. - /// The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. /// true if the first value is larger than the second value; otherwise false. - public static bool IsLarger(this double a, double b, long maxNumbersBetween) + public static bool IsLargerDecimal(this double a, double b, int decimalPlaces) { // If A or B are a NAN, return false. NANs are equal to nothing, // not even themselves, and thus they're not bigger or @@ -1495,7 +777,7 @@ namespace MathNet.Numerics return false; } - return CompareTo(a, b, maxNumbersBetween) > 0; + return CompareToDecimal(a, b, decimalPlaces) > 0; } /// @@ -1513,17 +795,17 @@ namespace MathNet.Numerics /// The second value. /// The number of decimal places. /// true if the first value is larger than the second value; otherwise false. - public static bool IsLargerWithDecimalPlaces(this double a, double b, int decimalPlaces) + public static bool IsLargerDecimal(this float a, float b, int decimalPlaces) { // If A or B are a NAN, return false. NANs are equal to nothing, // not even themselves, and thus they're not bigger or // smaller than anything either - if (double.IsNaN(a) || double.IsNaN(b)) + if (float.IsNaN(a) || float.IsNaN(b)) { return false; } - return CompareToInDecimalPlaces(a, b, decimalPlaces) > 0; + return CompareToDecimal(a, b, decimalPlaces) > 0; } /// @@ -1583,7 +865,7 @@ namespace MathNet.Numerics /// The second value. /// The number of decimal places. /// true if the first value is smaller than the second value; otherwise false. - public static bool IsSmallerWithDecimalPlaces(this double a, double b, int decimalPlaces) + public static bool IsSmallerDecimal(this double a, double b, int decimalPlaces) { // If A or B are a NAN, return false. NANs are equal to nothing, // not even themselves, and thus they're not bigger or @@ -1593,9 +875,9 @@ namespace MathNet.Numerics return false; } - return CompareToInDecimalPlaces(a, b, decimalPlaces) < 0; + return CompareToDecimal(a, b, decimalPlaces) < 0; } - + /// /// Compares two floats and determines if the first value is smaller than the second /// value to within the specified number of decimal places or not. @@ -1611,17 +893,17 @@ namespace MathNet.Numerics /// The second value. /// The number of decimal places. /// true if the first value is smaller than the second value; otherwise false. - public static bool IsSmallerWithDecimalPlaces(this float a, float b, int decimalPlaces) + public static bool IsSmallerDecimal(this float a, float b, int decimalPlaces) { // If A or B are a NAN, return false. NANs are equal to nothing, // not even themselves, and thus they're not bigger or // smaller than anything either - if (double.IsNaN(a) || double.IsNaN(b)) + if (float.IsNaN(a) || float.IsNaN(b)) { return false; } - return CompareToInDecimalPlaces(a, b, decimalPlaces) < 0; + return CompareToDecimal(a, b, decimalPlaces) < 0; } /// @@ -1669,7 +951,7 @@ namespace MathNet.Numerics // If the numbers are equal to within the tolerance then // there's technically no difference - if (AlmostEqual(a, b, maxNumbersBetween)) + if (AlmostEqualNumbersBetween(a, b, maxNumbersBetween)) { return 0; } @@ -1703,7 +985,7 @@ namespace MathNet.Numerics /// /// /// - public static int CompareToInDecimalPlaces(this double a, double b, int decimalPlaces) + public static int CompareToDecimal(this double a, double b, int decimalPlaces) { // If A or B are a NAN, return false. NANs are equal to nothing, // not even themselves, and thus they're not bigger or @@ -1722,7 +1004,7 @@ namespace MathNet.Numerics // If the numbers are equal to within the number of decimal places // then there's technically no difference - if (AlmostEqualInDecimalPlaces(a, b, decimalPlaces)) + if (AlmostEqualRelative(a, b, decimalPlaces)) { return 0; } @@ -1785,7 +1067,7 @@ namespace MathNet.Numerics /// public static double PositiveEpsilonOf(this double value) { - return 2 * EpsilonOf(value); + return 2*EpsilonOf(value); } /// diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs index db67e7eb..770ffc4b 100644 --- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs +++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs @@ -2581,7 +2581,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra { test = stemp[l].Magnitude + stemp[l + 1].Magnitude; ztest = test + e[l].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { e[l] = 0.0; break; @@ -2610,7 +2610,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra } ztest = test + stemp[ls].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { stemp[ls] = 0.0; break; diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs index 757bb555..d986454f 100644 --- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs +++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs @@ -2579,7 +2579,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra { test = stemp[l].Magnitude + stemp[l + 1].Magnitude; ztest = test + e[l].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { e[l] = 0.0f; break; @@ -2608,7 +2608,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra } ztest = test + stemp[ls].Magnitude; - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { stemp[ls] = 0.0f; break; diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs index d22dc12e..10a0dfbc 100644 --- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs +++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs @@ -2469,7 +2469,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra { test = Math.Abs(stemp[l]) + Math.Abs(stemp[l + 1]); ztest = test + Math.Abs(e[l]); - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { e[l] = 0.0; break; @@ -2498,7 +2498,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra } ztest = test + Math.Abs(stemp[ls]); - if (ztest.AlmostEqualInDecimalPlaces(test, 15)) + if (ztest.AlmostEqualRelative(test, 15)) { stemp[ls] = 0.0; break; diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs index 0db34a31..87e7860b 100644 --- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs +++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs @@ -2471,7 +2471,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra { test = Math.Abs(stemp[l]) + Math.Abs(stemp[l + 1]); ztest = test + Math.Abs(e[l]); - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { e[l] = 0.0f; break; @@ -2500,7 +2500,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra } ztest = test + Math.Abs(stemp[ls]); - if (ztest.AlmostEqualInDecimalPlaces(test, 7)) + if (ztest.AlmostEqualRelative(test, 7)) { stemp[ls] = 0.0f; break; diff --git a/src/Numerics/RootFinding/Bisection.cs b/src/Numerics/RootFinding/Bisection.cs index a2b8cac8..d9701ad2 100644 --- a/src/Numerics/RootFinding/Bisection.cs +++ b/src/Numerics/RootFinding/Bisection.cs @@ -107,7 +107,7 @@ namespace MathNet.Numerics.RootFinding for (int i = 0; i <= maxIterations; i++) { - if (Math.Abs(fmax - fmin) < 0.5*accuracy && upperBound.AlmostEqual(lowerBound)) + if (Math.Abs(fmax - fmin) < 0.5*accuracy && upperBound.AlmostEqualRelative(lowerBound)) { return true; } diff --git a/src/Numerics/RootFinding/Brent.cs b/src/Numerics/RootFinding/Brent.cs index 41c103b6..ac1c6b13 100644 --- a/src/Numerics/RootFinding/Brent.cs +++ b/src/Numerics/RootFinding/Brent.cs @@ -100,7 +100,7 @@ namespace MathNet.Numerics.RootFinding double xMidOld = xMid; xMid = (upperBound - root)/2.0; - if (Math.Abs(xMid) <= xAcc1 && froot.AlmostEqualWithAbsoluteError(0, froot, accuracy)) + if (Math.Abs(xMid) <= xAcc1 && froot.AlmostEqualNormRelative(0, froot, accuracy)) { return true; } @@ -117,7 +117,7 @@ namespace MathNet.Numerics.RootFinding double s = froot/fmin; double p; double q; - if (lowerBound.AlmostEqual(upperBound)) + if (lowerBound.AlmostEqualRelative(upperBound)) { p = 2.0*xMid*s; q = 1.0 - s; diff --git a/src/UnitTests/AssertHelpers.cs b/src/UnitTests/AssertHelpers.cs index 49d5ed34..5a0c2f7f 100644 --- a/src/UnitTests/AssertHelpers.cs +++ b/src/UnitTests/AssertHelpers.cs @@ -40,10 +40,7 @@ namespace MathNet.Numerics.UnitTests /// internal class AssertHelpers { - /// - /// Asserts that the expected value and the actual value are equal. - /// - public static void AreEqual(Complex expected, Complex actual) + public static void AlmostEqual(Complex expected, Complex actual) { if (expected.IsNaN() && actual.IsNaN() || expected.IsInfinity() && expected.IsInfinity()) { @@ -61,10 +58,7 @@ namespace MathNet.Numerics.UnitTests } } - /// - /// Asserts that the expected value and the actual value are equal. - /// - public static void AreEqual(Complex32 expected, Complex32 actual) + public static void AlmostEqual(Complex32 expected, Complex32 actual) { if (expected.IsNaN() && actual.IsNaN() || expected.IsInfinity() && expected.IsInfinity()) { @@ -82,10 +76,7 @@ namespace MathNet.Numerics.UnitTests } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both - /// and are NaN then no assert is thrown. - /// + public static void AlmostEqual(double expected, double actual, int decimalPlaces) { if (double.IsNaN(expected) && double.IsNaN(actual)) @@ -93,16 +84,12 @@ namespace MathNet.Numerics.UnitTests return; } - if (!expected.AlmostEqualInDecimalPlaces(actual, decimalPlaces)) + if (!expected.AlmostEqual(actual, decimalPlaces)) { Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both - /// and are NaN then no assert is thrown. - /// public static void AlmostEqual(float expected, float actual, int decimalPlaces) { if (float.IsNaN(expected) && float.IsNaN(actual)) @@ -110,187 +97,175 @@ namespace MathNet.Numerics.UnitTests return; } - if (!expected.AlmostEqualInDecimalPlaces(actual, decimalPlaces)) + if (!expected.AlmostEqual(actual, decimalPlaces)) { Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. - /// public static void AlmostEqual(Complex expected, Complex actual, int decimalPlaces) { - if (!expected.Real.AlmostEqualInDecimalPlaces(actual.Real, decimalPlaces)) + if (!expected.Real.AlmostEqual(actual.Real, decimalPlaces)) { Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); } - if (!expected.Imaginary.AlmostEqualInDecimalPlaces(actual.Imaginary, decimalPlaces)) + if (!expected.Imaginary.AlmostEqual(actual.Imaginary, decimalPlaces)) { Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. - /// public static void AlmostEqual(Complex32 expected, Complex32 actual, int decimalPlaces) { - if (!expected.Real.AlmostEqualInDecimalPlaces(actual.Real, decimalPlaces)) + if (!expected.Real.AlmostEqual(actual.Real, decimalPlaces)) { Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); } - if (!expected.Imaginary.AlmostEqualInDecimalPlaces(actual.Imaginary, decimalPlaces)) + if (!expected.Imaginary.AlmostEqual(actual.Imaginary, decimalPlaces)) { Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both - /// and are NaN then no assert is thrown. - /// - public static void AlmostEqualAbsolute(double expected, double actual, int decimalPlaces) + public static void AlmostEqualRelative(double expected, double actual, int decimalPlaces) { if (double.IsNaN(expected) && double.IsNaN(actual)) { return; } - if (!expected.AlmostEqualInAbsoluteDecimalPlaces(actual, decimalPlaces)) + if (!expected.AlmostEqualRelative(actual, decimalPlaces)) { Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both - /// and are NaN then no assert is thrown. - /// - public static void AlmostEqualAbsolute(float expected, float actual, int decimalPlaces) + public static void AlmostEqualRelative(float expected, float actual, int decimalPlaces) { if (float.IsNaN(expected) && float.IsNaN(actual)) { return; } - if (!expected.AlmostEqualInAbsoluteDecimalPlaces(actual, decimalPlaces)) + if (!expected.AlmostEqualRelative(actual, decimalPlaces)) { Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. - /// - public static void AlmostEqualAbsolute(Complex expected, Complex actual, int decimalPlaces) + public static void AlmostEqualRelative(Complex expected, Complex actual, int decimalPlaces) { - if (!expected.Real.AlmostEqualInAbsoluteDecimalPlaces(actual.Real, decimalPlaces)) + if (!expected.Real.AlmostEqualRelative(actual.Real, decimalPlaces)) { Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); } - if (!expected.Imaginary.AlmostEqualInAbsoluteDecimalPlaces(actual.Imaginary, decimalPlaces)) + if (!expected.Imaginary.AlmostEqualRelative(actual.Imaginary, decimalPlaces)) { Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. - /// - public static void AlmostEqualAbsolute(Complex32 expected, Complex32 actual, int decimalPlaces) + public static void AlmostEqualRelative(Complex32 expected, Complex32 actual, int decimalPlaces) { - if (!expected.Real.AlmostEqualInAbsoluteDecimalPlaces(actual.Real, decimalPlaces)) + if (!expected.Real.AlmostEqualRelative(actual.Real, decimalPlaces)) { Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); } - if (!expected.Imaginary.AlmostEqualInAbsoluteDecimalPlaces(actual.Imaginary, decimalPlaces)) + if (!expected.Imaginary.AlmostEqualRelative(actual.Imaginary, decimalPlaces)) { Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain - /// maximum error. - /// - /// The type of the structures. Must implement - /// . - /// The expected value. - /// The actual value. - /// The accuracy required for being almost equal. - public static void AlmostEqual(T expected, T actual, double maximumError) - where T : IPrecisionSupport + + public static void ListAlmostEqual(IList expected, IList actual, int decimalPlaces) { - if (!actual.AlmostEqualWithError(expected, maximumError)) + for (var i = 0; i < expected.Count; i++) { - Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected, actual); + if (!actual[i].AlmostEqual(expected[i], decimalPlaces)) + { + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); + } + } + } + + public static void ListAlmostEqual(IList expected, IList actual, int decimalPlaces) + { + for (var i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqual(expected[i], decimalPlaces)) + { + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); + } + } + } + + public static void ListAlmostEqual(IList expected, IList actual, int decimalPlaces) + { + for (var i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqual(expected[i], decimalPlaces)) + { + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); + } + } + } + + public static void ListAlmostEqual(IList expected, IList actual, int decimalPlaces) + { + for (var i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqual(expected[i], decimalPlaces)) + { + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); + } } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain - /// maximum error. - /// - public static void AlmostEqualList(IList expected, IList actual, double maximumError) + public static void ListAlmostEqualRelative(IList expected, IList actual, int decimalPlaces) { for (var i = 0; i < expected.Count; i++) { - if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + if (!actual[i].AlmostEqualRelative(expected[i], decimalPlaces)) { - Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); } } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain - /// maximum error. - /// - public static void AlmostEqualList(IList expected, IList actual, double maximumError) + public static void ListAlmostEqualRelative(IList expected, IList actual, int decimalPlaces) { for (var i = 0; i < expected.Count; i++) { - if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + if (!actual[i].AlmostEqualRelative(expected[i], decimalPlaces)) { - Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); } } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain - /// maximum error. - /// - /// The type of the structures. Must implement - /// . - public static void AlmostEqualList(IList expected, IList actual, double maximumError) - where T : IPrecisionSupport + public static void ListAlmostEqualRelative(IList expected, IList actual, int decimalPlaces) { for (var i = 0; i < expected.Count; i++) { - if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + if (!actual[i].AlmostEqualRelative(expected[i], decimalPlaces)) { - Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); } } } - /// - /// Asserts that the expected value and the actual value are equal up to a certain - /// maximum error. - /// - public static void AlmostEqualList(IList expected, IList actual, double maximumError) + public static void ListAlmostEqualRelative(IList expected, IList actual, int decimalPlaces) { for (var i = 0; i < expected.Count; i++) { - if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + if (!actual[i].AlmostEqualRelative(expected[i], decimalPlaces)) { - Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected[i], actual[i]); } } } diff --git a/src/UnitTests/ComplexTests/Complex32Test.cs b/src/UnitTests/ComplexTests/Complex32Test.cs index 64bf0154..0acccf26 100644 --- a/src/UnitTests/ComplexTests/Complex32Test.cs +++ b/src/UnitTests/ComplexTests/Complex32Test.cs @@ -121,7 +121,7 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var value = new Complex32(real, imag); var expected = new Complex32(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, value.Exponential(), 7); + AssertHelpers.AlmostEqualRelative(expected, value.Exponential(), 6); } /// @@ -140,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var value = new Complex32(real, imag); var expected = new Complex32(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, value.NaturalLogarithm(), 7); + AssertHelpers.AlmostEqualRelative(expected, value.NaturalLogarithm(), 7); } /// @@ -151,38 +151,38 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var a = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); var b = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual( - new Complex32(9.99998047207974718744e-1f, -1.76553541154378695012e-6f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative( + new Complex32(9.99998047207974718744e-1f, -1.76553541154378695012e-6f), a.Power(b), 6); a = new Complex32(0.0f, 1.19209289550780998537e-7f); b = new Complex32(0.0f, -1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(1.00000018725172576491f, 1.90048076369011843105e-6f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(1.00000018725172576491f, 1.90048076369011843105e-6f), a.Power(b), 6); a = new Complex32(0.0f, -1.19209289550780998537e-7f); b = new Complex32(0.0f, 0.5f); - AssertHelpers.AlmostEqual(new Complex32(-2.56488189382693049636e-1f, -2.17823120666116144959f), a.Power(b), 5); + AssertHelpers.AlmostEqualRelative(new Complex32(-2.56488189382693049636e-1f, -2.17823120666116144959f), a.Power(b), 4); a = new Complex32(0.0f, 0.5f); b = new Complex32(0.0f, -0.5f); - AssertHelpers.AlmostEqual(new Complex32(2.06287223508090495171f, 7.45007062179724087859e-1f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(2.06287223508090495171f, 7.45007062179724087859e-1f), a.Power(b), 6); a = new Complex32(0.0f, -0.5f); b = new Complex32(0.0f, 1.0f); - AssertHelpers.AlmostEqual(new Complex32(3.70040633557002510874f, -3.07370876701949232239f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(3.70040633557002510874f, -3.07370876701949232239f), a.Power(b), 6); a = new Complex32(0.0f, 2.0f); b = new Complex32(0.0f, -2.0f); - AssertHelpers.AlmostEqual(new Complex32(4.24532146387429353891f, -2.27479427903521192648e1f), a.Power(b), 6); + AssertHelpers.AlmostEqualRelative(new Complex32(4.24532146387429353891f, -2.27479427903521192648e1f), a.Power(b), 5); a = new Complex32(0.0f, -8.388608e6f); b = new Complex32(1.19209289550780998537e-7f, 0.0f); - AssertHelpers.AlmostEqual(new Complex32(1.00000190048219620166f, -1.87253870018168043834e-7f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(1.00000190048219620166f, -1.87253870018168043834e-7f), a.Power(b), 6); a = new Complex32(0.0f, 0.0f); b = new Complex32(0.0f, 0.0f); - AssertHelpers.AlmostEqual(new Complex32(1.0f, 0.0f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(1.0f, 0.0f), a.Power(b), 6); a = new Complex32(0.0f, 0.0f); b = new Complex32(1.0f, 0.0f); - AssertHelpers.AlmostEqual(new Complex32(0.0f, 0.0f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.0f, 0.0f), a.Power(b), 6); a = new Complex32(0.0f, 0.0f); b = new Complex32(-1.0f, 0.0f); - AssertHelpers.AlmostEqual(new Complex32(float.PositiveInfinity, 0.0f), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(float.PositiveInfinity, 0.0f), a.Power(b), 6); a = new Complex32(0.0f, 0.0f); b = new Complex32(-1.0f, 1.0f); - AssertHelpers.AlmostEqual(new Complex32(float.PositiveInfinity, float.PositiveInfinity), a.Power(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(float.PositiveInfinity, float.PositiveInfinity), a.Power(b), 6); a = new Complex32(0.0f, 0.0f); b = new Complex32(0.0f, 1.0f); Assert.That(a.Power(b).IsNaN()); @@ -196,22 +196,22 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var a = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); var b = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(0.0f, 0.0f), a.Root(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.0f, 0.0f), a.Root(b), 6); a = new Complex32(0.0f, -1.19209289550780998537e-7f); b = new Complex32(0.0f, 0.5f); - AssertHelpers.AlmostEqual(new Complex32(0.038550761943650161f, 0.019526430428319544f), a.Root(b), 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.038550761943650161f, 0.019526430428319544f), a.Root(b), 5); a = new Complex32(0.0f, 0.5f); b = new Complex32(0.0f, -0.5f); - AssertHelpers.AlmostEqual(new Complex32(0.007927894711475968f, -0.042480480425152213f), a.Root(b), 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.007927894711475968f, -0.042480480425152213f), a.Root(b), 5); a = new Complex32(0.0f, -0.5f); b = new Complex32(0.0f, 1.0f); - AssertHelpers.AlmostEqual(new Complex32(0.15990905692806806f, 0.13282699942462053f), a.Root(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.15990905692806806f, 0.13282699942462053f), a.Root(b), 6); a = new Complex32(0.0f, 2.0f); b = new Complex32(0.0f, -2.0f); - AssertHelpers.AlmostEqual(new Complex32(0.42882900629436788f, 0.15487175246424678f), a.Root(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.42882900629436788f, 0.15487175246424678f), a.Root(b), 6); a = new Complex32(0.0f, -8.388608e6f); b = new Complex32(1.19209289550780998537e-7f, 0.0f); - AssertHelpers.AlmostEqual(new Complex32(float.PositiveInfinity, float.NegativeInfinity), a.Root(b), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(float.PositiveInfinity, float.NegativeInfinity), a.Root(b), 6); } /// @@ -221,17 +221,17 @@ namespace MathNet.Numerics.UnitTests.ComplexTests public void CanComputeSquare() { var complex = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(0, 2.8421709430403888e-14f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0, 2.8421709430403888e-14f), complex.Square(), 7); complex = new Complex32(0.0f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(-1.4210854715201944e-14f, 0.0f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(-1.4210854715201944e-14f, 0.0f), complex.Square(), 7); complex = new Complex32(0.0f, -1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(-1.4210854715201944e-14f, 0.0f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(-1.4210854715201944e-14f, 0.0f), complex.Square(), 7); complex = new Complex32(0.0f, 0.5f); - AssertHelpers.AlmostEqual(new Complex32(-0.25f, 0.0f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(-0.25f, 0.0f), complex.Square(), 7); complex = new Complex32(0.0f, -0.5f); - AssertHelpers.AlmostEqual(new Complex32(-0.25f, 0.0f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(-0.25f, 0.0f), complex.Square(), 7); complex = new Complex32(0.0f, -8.388608e6f); - AssertHelpers.AlmostEqual(new Complex32(-70368744177664.0f, 0.0f), complex.Square(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(-70368744177664.0f, 0.0f), complex.Square(), 7); } /// @@ -241,24 +241,24 @@ namespace MathNet.Numerics.UnitTests.ComplexTests public void CanComputeSquareRoot() { var complex = new Complex32(1.19209289550780998537e-7f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual( + AssertHelpers.AlmostEqualRelative( new Complex32(0.00037933934912842666f, 0.00015712750315077684f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual( + AssertHelpers.AlmostEqualRelative( new Complex32(0.00024414062499999973f, 0.00024414062499999976f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, -1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual( + AssertHelpers.AlmostEqualRelative( new Complex32(0.00024414062499999973f, -0.00024414062499999976f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, 0.5f); - AssertHelpers.AlmostEqual(new Complex32(0.5f, 0.5f), complex.SquareRoot(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.5f, 0.5f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, -0.5f); - AssertHelpers.AlmostEqual(new Complex32(0.5f, -0.5f), complex.SquareRoot(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.5f, -0.5f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, -8.388608e6f); - AssertHelpers.AlmostEqual(new Complex32(2048.0f, -2048.0f), complex.SquareRoot(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(2048.0f, -2048.0f), complex.SquareRoot(), 7); complex = new Complex32(8.388608e6f, 1.19209289550780998537e-7f); - AssertHelpers.AlmostEqual(new Complex32(2896.3093757400989f, 2.0579515874459933e-11f), complex.SquareRoot(), 7); + AssertHelpers.AlmostEqualRelative(new Complex32(2896.3093757400989f, 2.0579515874459933e-11f), complex.SquareRoot(), 7); complex = new Complex32(0.0f, 0.0f); - AssertHelpers.AlmostEqual(Complex32.Zero, complex.SquareRoot(), 7); + AssertHelpers.AlmostEqualRelative(Complex32.Zero, complex.SquareRoot(), 7); } /// diff --git a/src/UnitTests/ComplexTests/ComplexTest.cs b/src/UnitTests/ComplexTests/ComplexTest.cs index dc10b314..9e4f7701 100644 --- a/src/UnitTests/ComplexTests/ComplexTest.cs +++ b/src/UnitTests/ComplexTests/ComplexTest.cs @@ -55,7 +55,7 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var value = new Complex(real, imag); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, value.Exp(), 15); + AssertHelpers.AlmostEqualRelative(expected, value.Exp(), 15); } /// @@ -74,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var value = new Complex(real, imag); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, value.Ln(), 15); + AssertHelpers.AlmostEqualRelative(expected, value.Ln(), 14); } /// @@ -85,39 +85,39 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var a = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); var b = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual( - new Complex(9.99998047207974718744e-1, -1.76553541154378695012e-6), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative( + new Complex(9.99998047207974718744e-1, -1.76553541154378695012e-6), a.Power(b), 14); a = new Complex(0.0, 1.19209289550780998537e-7); b = new Complex(0.0, -1.19209289550780998537e-7); - AssertHelpers.AlmostEqual(new Complex(1.00000018725172576491, 1.90048076369011843105e-6), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(1.00000018725172576491, 1.90048076369011843105e-6), a.Power(b), 14); a = new Complex(0.0, -1.19209289550780998537e-7); b = new Complex(0.0, 0.5); - AssertHelpers.AlmostEqual(new Complex(-2.56488189382693049636e-1, -2.17823120666116144959), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-2.56488189382693049636e-1, -2.17823120666116144959), a.Power(b), 14); a = new Complex(0.0, 0.5); b = new Complex(0.0, -0.5); - AssertHelpers.AlmostEqual(new Complex(2.06287223508090495171, 7.45007062179724087859e-1), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(2.06287223508090495171, 7.45007062179724087859e-1), a.Power(b), 14); a = new Complex(0.0, -0.5); b = new Complex(0.0, 1.0); - AssertHelpers.AlmostEqual(new Complex(3.70040633557002510874, -3.07370876701949232239), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(3.70040633557002510874, -3.07370876701949232239), a.Power(b), 14); a = new Complex(0.0, 2.0); b = new Complex(0.0, -2.0); - AssertHelpers.AlmostEqual(new Complex(4.24532146387429353891, -2.27479427903521192648e1), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(4.24532146387429353891, -2.27479427903521192648e1), a.Power(b), 14); a = new Complex(0.0, -8.388608e6); b = new Complex(1.19209289550780998537e-7, 0.0); - AssertHelpers.AlmostEqual(new Complex(1.00000190048219620166, -1.87253870018168043834e-7), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(1.00000190048219620166, -1.87253870018168043834e-7), a.Power(b), 14); a = new Complex(0.0, 0.0); b = new Complex(0.0, 0.0); - AssertHelpers.AlmostEqual(new Complex(1.0, 0.0), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(1.0, 0.0), a.Power(b), 14); a = new Complex(0.0, 0.0); b = new Complex(1.0, 0.0); - AssertHelpers.AlmostEqual(new Complex(0.0, 0.0), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(0.0, 0.0), a.Power(b), 14); a = new Complex(0.0, 0.0); b = new Complex(-1.0, 0.0); - AssertHelpers.AlmostEqual(new Complex(double.PositiveInfinity, 0.0), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(double.PositiveInfinity, 0.0), a.Power(b), 14); a = new Complex(0.0, 0.0); b = new Complex(-1.0, 1.0); - AssertHelpers.AlmostEqual(new Complex(double.PositiveInfinity, double.PositiveInfinity), a.Power(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(double.PositiveInfinity, double.PositiveInfinity), a.Power(b), 14); a = new Complex(0.0, 0.0); b = new Complex(0.0, 1.0); Assert.That(a.Power(b).IsNaN()); @@ -131,23 +131,23 @@ namespace MathNet.Numerics.UnitTests.ComplexTests { var a = new Complex(0.0, -1.19209289550780998537e-7); var b = new Complex(0.0, 0.5); - AssertHelpers.AlmostEqual(new Complex(0.038550761943650161, 0.019526430428319544), a.Root(b), 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.038550761943650161, 0.019526430428319544), a.Root(b), 13); a = new Complex(0.0, 0.5); b = new Complex(0.0, -0.5); - AssertHelpers.AlmostEqual(new Complex(0.007927894711475968, -0.042480480425152213), a.Root(b), 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.007927894711475968, -0.042480480425152213), a.Root(b), 13); a = new Complex(0.0, -0.5); b = new Complex(0.0, 1.0); - AssertHelpers.AlmostEqual(new Complex(0.15990905692806806, 0.13282699942462053), a.Root(b), 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.15990905692806806, 0.13282699942462053), a.Root(b), 13); a = new Complex(0.0, 2.0); b = new Complex(0.0, -2.0); - AssertHelpers.AlmostEqual(new Complex(0.42882900629436788, 0.15487175246424678), a.Root(b), 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.42882900629436788, 0.15487175246424678), a.Root(b), 13); //a = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); //b = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); //AssertHelpers.AlmostEqual(new Complex(0.0, 0.0), a.Root(b), 15); a = new Complex(0.0, -8.388608e6); b = new Complex(1.19209289550780998537e-7, 0.0); - AssertHelpers.AlmostEqual(new Complex(double.PositiveInfinity, double.NegativeInfinity), a.Root(b), 15); + AssertHelpers.AlmostEqualRelative(new Complex(double.PositiveInfinity, double.NegativeInfinity), a.Root(b), 14); } /// @@ -157,17 +157,17 @@ namespace MathNet.Numerics.UnitTests.ComplexTests public void CanComputeSquare() { var complex = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual(new Complex(0, 2.8421709430403888e-14), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(0, 2.8421709430403888e-14), complex.Square(), 15); complex = new Complex(0.0, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual(new Complex(-1.4210854715201944e-14, 0.0), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-1.4210854715201944e-14, 0.0), complex.Square(), 15); complex = new Complex(0.0, -1.19209289550780998537e-7); - AssertHelpers.AlmostEqual(new Complex(-1.4210854715201944e-14, 0.0), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-1.4210854715201944e-14, 0.0), complex.Square(), 15); complex = new Complex(0.0, 0.5); - AssertHelpers.AlmostEqual(new Complex(-0.25, 0.0), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-0.25, 0.0), complex.Square(), 15); complex = new Complex(0.0, -0.5); - AssertHelpers.AlmostEqual(new Complex(-0.25, 0.0), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-0.25, 0.0), complex.Square(), 15); complex = new Complex(0.0, -8.388608e6); - AssertHelpers.AlmostEqual(new Complex(-70368744177664.0, 0.0), complex.Square(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(-70368744177664.0, 0.0), complex.Square(), 15); } /// @@ -177,24 +177,24 @@ namespace MathNet.Numerics.UnitTests.ComplexTests public void CanComputeSquareRoot() { var complex = new Complex(1.19209289550780998537e-7, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual( - new Complex(0.00037933934912842666, 0.00015712750315077684), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative( + new Complex(0.00037933934912842666, 0.00015712750315077684), complex.SquareRoot(), 14); complex = new Complex(0.0, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual( - new Complex(0.00024414062499999973, 0.00024414062499999976), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative( + new Complex(0.00024414062499999973, 0.00024414062499999976), complex.SquareRoot(), 14); complex = new Complex(0.0, -1.19209289550780998537e-7); - AssertHelpers.AlmostEqual( - new Complex(0.00024414062499999973, -0.00024414062499999976), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative( + new Complex(0.00024414062499999973, -0.00024414062499999976), complex.SquareRoot(), 14); complex = new Complex(0.0, 0.5); - AssertHelpers.AlmostEqual(new Complex(0.5, 0.5), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(0.5, 0.5), complex.SquareRoot(), 14); complex = new Complex(0.0, -0.5); - AssertHelpers.AlmostEqual(new Complex(0.5, -0.5), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(0.5, -0.5), complex.SquareRoot(), 14); complex = new Complex(0.0, -8.388608e6); - AssertHelpers.AlmostEqual(new Complex(2048.0, -2048.0), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(2048.0, -2048.0), complex.SquareRoot(), 14); complex = new Complex(8.388608e6, 1.19209289550780998537e-7); - AssertHelpers.AlmostEqual(new Complex(2896.3093757400989, 2.0579515874459933e-11), complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative(new Complex(2896.3093757400989, 2.0579515874459933e-11), complex.SquareRoot(), 14); complex = new Complex(0.0, 0.0); - AssertHelpers.AlmostEqual(Complex.Zero, complex.SquareRoot(), 15); + AssertHelpers.AlmostEqualRelative(Complex.Zero, complex.SquareRoot(), 14); } /// diff --git a/src/UnitTests/DistributionTests/Continuous/BetaTests.cs b/src/UnitTests/DistributionTests/Continuous/BetaTests.cs index 7694e583..c245d636 100644 --- a/src/UnitTests/DistributionTests/Continuous/BetaTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/BetaTests.cs @@ -191,7 +191,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateEntropy(double a, double b, double entropy) { var n = new Beta(a, b); - AssertHelpers.AlmostEqual(entropy, n.Entropy, 14); + AssertHelpers.AlmostEqualRelative(entropy, n.Entropy, 13); } /// @@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(double a, double b, double skewness) { var n = new Beta(a, b); - AssertHelpers.AlmostEqual(skewness, n.Skewness, 15); + AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 14); } /// @@ -368,8 +368,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(double a, double b, double x, double pdf) { var n = new Beta(a, b); - AssertHelpers.AlmostEqual(pdf, n.Density(x), 13); - AssertHelpers.AlmostEqual(pdf, Beta.PDF(a, b, x), 13); + AssertHelpers.AlmostEqualRelative(pdf, n.Density(x), 12); + AssertHelpers.AlmostEqualRelative(pdf, Beta.PDF(a, b, x), 12); } /// @@ -414,8 +414,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(double a, double b, double x, double pdfln) { var n = new Beta(a, b); - AssertHelpers.AlmostEqual(pdfln, n.DensityLn(x), 14); - AssertHelpers.AlmostEqual(pdfln, Beta.PDFLn(a, b, x), 14); + AssertHelpers.AlmostEqualRelative(pdfln, n.DensityLn(x), 13); + AssertHelpers.AlmostEqualRelative(pdfln, Beta.PDFLn(a, b, x), 13); } /// @@ -458,8 +458,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double a, double b, double x, double cdf) { var n = new Beta(a, b); - AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 13); - AssertHelpers.AlmostEqual(cdf, Beta.CDF(a, b, x), 13); + AssertHelpers.AlmostEqualRelative(cdf, n.CumulativeDistribution(x), 13); + AssertHelpers.AlmostEqualRelative(cdf, Beta.CDF(a, b, x), 13); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/ErlangTests.cs b/src/UnitTests/DistributionTests/Continuous/ErlangTests.cs index 60b52b21..dba3872b 100644 --- a/src/UnitTests/DistributionTests/Continuous/ErlangTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/ErlangTests.cs @@ -240,7 +240,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateVariance(int shape, double invScale, double var) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(var, n.Variance, 15); + AssertHelpers.AlmostEqualRelative(var, n.Variance, 15); } /// @@ -258,7 +258,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateStdDev(int shape, double invScale, double sdev) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(sdev, n.StdDev, 15); + AssertHelpers.AlmostEqualRelative(sdev, n.StdDev, 15); } /// @@ -276,7 +276,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateEntropy(int shape, double invScale, double entropy) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(entropy, n.Entropy, 13); + AssertHelpers.AlmostEqualRelative(entropy, n.Entropy, 12); } /// @@ -294,7 +294,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(int shape, double invScale, double skewness) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(skewness, n.Skewness, 15); + AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 15); } /// @@ -372,8 +372,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(int shape, double invScale, double x, double pdf) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(pdf, n.Density(x), 14); - AssertHelpers.AlmostEqual(pdf, Erlang.PDF(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(pdf, n.Density(x), 13); + AssertHelpers.AlmostEqualRelative(pdf, Erlang.PDF(shape, invScale, x), 13); } /// @@ -404,8 +404,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(int shape, double invScale, double x, double pdfln) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(pdfln, n.DensityLn(x), 14); - AssertHelpers.AlmostEqual(pdfln, Erlang.PDFLn(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(pdfln, n.DensityLn(x), 13); + AssertHelpers.AlmostEqualRelative(pdfln, Erlang.PDFLn(shape, invScale, x), 13); } /// @@ -457,8 +457,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(int shape, double invScale, double x, double cdf) { var n = new Erlang(shape, invScale); - AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 14); - AssertHelpers.AlmostEqual(cdf, Erlang.CDF(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(cdf, n.CumulativeDistribution(x), 13); + AssertHelpers.AlmostEqualRelative(cdf, Erlang.CDF(shape, invScale, x), 13); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/GammaTests.cs b/src/UnitTests/DistributionTests/Continuous/GammaTests.cs index 6442a3d1..98e2e07f 100644 --- a/src/UnitTests/DistributionTests/Continuous/GammaTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/GammaTests.cs @@ -244,7 +244,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateVariance(double shape, double invScale, double var) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(var, n.Variance, 15); + AssertHelpers.AlmostEqualRelative(var, n.Variance, 15); } /// @@ -262,7 +262,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateStdDev(double shape, double invScale, double sdev) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(sdev, n.StdDev, 15); + AssertHelpers.AlmostEqualRelative(sdev, n.StdDev, 15); } /// @@ -280,7 +280,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateEntropy(double shape, double invScale, double entropy) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(entropy, n.Entropy, 13); + AssertHelpers.AlmostEqualRelative(entropy, n.Entropy, 12); } /// @@ -298,7 +298,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(double shape, double invScale, double skewness) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(skewness, n.Skewness, 15); + AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 15); } /// @@ -377,8 +377,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(int shape, double invScale, double x, double pdf) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(pdf, n.Density(x), 14); - AssertHelpers.AlmostEqual(pdf, Gamma.PDF(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(pdf, n.Density(x), 13); + AssertHelpers.AlmostEqualRelative(pdf, Gamma.PDF(shape, invScale, x), 13); } /// @@ -409,8 +409,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(int shape, double invScale, double x, double pdfln) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(pdfln, n.DensityLn(x), 14); - AssertHelpers.AlmostEqual(pdfln, Gamma.PDFLn(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(pdfln, n.DensityLn(x), 13); + AssertHelpers.AlmostEqualRelative(pdfln, Gamma.PDFLn(shape, invScale, x), 13); } /// @@ -499,8 +499,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(int shape, double invScale, double x, double cdf) { var n = new Gamma(shape, invScale); - AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 14); - AssertHelpers.AlmostEqual(cdf, Gamma.CDF(shape, invScale, x), 14); + AssertHelpers.AlmostEqualRelative(cdf, n.CumulativeDistribution(x), 13); + AssertHelpers.AlmostEqualRelative(cdf, Gamma.CDF(shape, invScale, x), 13); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/LogNormalTests.cs b/src/UnitTests/DistributionTests/Continuous/LogNormalTests.cs index eee3f768..d348eee3 100644 --- a/src/UnitTests/DistributionTests/Continuous/LogNormalTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/LogNormalTests.cs @@ -172,7 +172,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateEntropy(double mu, double sigma, double entropy) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(entropy, n.Entropy, 14); + AssertHelpers.AlmostEqualRelative(entropy, n.Entropy, 14); } /// @@ -208,7 +208,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(double mu, double sigma, double skewness) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(skewness, n.Skewness, 14); + AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 13); } /// @@ -316,7 +316,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateMean(double mu, double sigma, double mean) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(mean, n.Mean, 14); + AssertHelpers.AlmostEqualRelative(mean, n.Mean, 14); } /// @@ -377,8 +377,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(double mu, double sigma, double x, double p) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(p, n.Density(x), 14); - AssertHelpers.AlmostEqual(p, LogNormal.PDF(mu, sigma, x), 14); + AssertHelpers.AlmostEqualRelative(p, n.Density(x), 13); + AssertHelpers.AlmostEqualRelative(p, LogNormal.PDF(mu, sigma, x), 13); } /// @@ -419,8 +419,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(double mu, double sigma, double x, double p) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(p, n.DensityLn(x), 14); - AssertHelpers.AlmostEqual(p, LogNormal.PDFLn(mu, sigma, x), 14); + AssertHelpers.AlmostEqualRelative(p, n.DensityLn(x), 13); + AssertHelpers.AlmostEqualRelative(p, LogNormal.PDFLn(mu, sigma, x), 13); } /// @@ -519,8 +519,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double mu, double sigma, double x, double f) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(f, n.CumulativeDistribution(x), 8); - AssertHelpers.AlmostEqual(f, LogNormal.CDF(mu, sigma, x), 8); + AssertHelpers.AlmostEqualRelative(f, n.CumulativeDistribution(x), 7); + AssertHelpers.AlmostEqualRelative(f, LogNormal.CDF(mu, sigma, x), 7); } /// @@ -553,8 +553,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateInverseCumulativeDistribution(double mu, double sigma, double x, double f) { var n = new LogNormal(mu, sigma); - AssertHelpers.AlmostEqual(x, n.InverseCumulativeDistribution(f), 8); - AssertHelpers.AlmostEqual(x, LogNormal.InvCDF(mu, sigma, f), 8); + AssertHelpers.AlmostEqualRelative(x, n.InverseCumulativeDistribution(f), 8); + AssertHelpers.AlmostEqualRelative(x, LogNormal.InvCDF(mu, sigma, f), 8); } /// @@ -570,8 +570,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous var original = new LogNormal(mu, sigma, new Random(100)); var estimated = LogNormal.Estimate(original.Samples().Take(10000)); - AssertHelpers.AlmostEqual(mu, estimated.Mu, 2); - AssertHelpers.AlmostEqual(sigma, estimated.Sigma, 2); + AssertHelpers.AlmostEqualRelative(mu, estimated.Mu, 1); + AssertHelpers.AlmostEqualRelative(sigma, estimated.Sigma, 1); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/NormalTests.cs b/src/UnitTests/DistributionTests/Continuous/NormalTests.cs index 55e19e18..c44cef16 100644 --- a/src/UnitTests/DistributionTests/Continuous/NormalTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/NormalTests.cs @@ -123,8 +123,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void CanCreateNormalFromMeanAndVariance(double mean, double var) { var n = Normal.WithMeanVariance(mean, var); - AssertHelpers.AlmostEqual(mean, n.Mean, 16); - AssertHelpers.AlmostEqual(var, n.Variance, 16); + AssertHelpers.AlmostEqualRelative(mean, n.Mean, 15); + AssertHelpers.AlmostEqualRelative(var, n.Variance, 15); } /// @@ -141,8 +141,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void CanCreateNormalFromMeanAndPrecision(double mean, double prec) { var n = Normal.WithMeanPrecision(mean, prec); - AssertHelpers.AlmostEqual(mean, n.Mean, 15); - AssertHelpers.AlmostEqual(prec, n.Precision, 15); + AssertHelpers.AlmostEqualRelative(mean, n.Mean, 15); + AssertHelpers.AlmostEqualRelative(prec, n.Precision, 15); } /// @@ -472,8 +472,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double x, double f) { var n = Normal.WithMeanStdDev(5.0, 2.0); - AssertHelpers.AlmostEqual(f, n.CumulativeDistribution(x), 10); - AssertHelpers.AlmostEqual(f, Normal.CDF(5.0, 2.0, x), 10); + AssertHelpers.AlmostEqualRelative(f, n.CumulativeDistribution(x), 9); + AssertHelpers.AlmostEqualRelative(f, Normal.CDF(5.0, 2.0, x), 9); } /// @@ -494,8 +494,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateInverseCumulativeDistribution(double x, double f) { var n = Normal.WithMeanStdDev(5.0, 2.0); - AssertHelpers.AlmostEqual(x, n.InverseCumulativeDistribution(f), 15); - AssertHelpers.AlmostEqual(x, Normal.InvCDF(5.0, 2.0, f), 15); + AssertHelpers.AlmostEqualRelative(x, n.InverseCumulativeDistribution(f), 14); + AssertHelpers.AlmostEqualRelative(x, Normal.InvCDF(5.0, 2.0, f), 14); } /// @@ -511,8 +511,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous var original = new Normal(mean, stddev, new Random(100)); var estimated = Normal.Estimate(original.Samples().Take(10000)); - AssertHelpers.AlmostEqual(mean, estimated.Mean, 2); - AssertHelpers.AlmostEqual(stddev, estimated.StdDev, 2); + AssertHelpers.AlmostEqualRelative(mean, estimated.Mean, 1); + AssertHelpers.AlmostEqualRelative(stddev, estimated.StdDev, 1); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/RayleighTests.cs b/src/UnitTests/DistributionTests/Continuous/RayleighTests.cs index 6a87b93c..9c18612b 100644 --- a/src/UnitTests/DistributionTests/Continuous/RayleighTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/RayleighTests.cs @@ -182,7 +182,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(double scale, double skn) { var n = new Rayleigh(scale); - AssertHelpers.AlmostEqual(skn, n.Skewness, 17); + AssertHelpers.AlmostEqualRelative(skn, n.Skewness, 17); } /// diff --git a/src/UnitTests/DistributionTests/Continuous/StableTests.cs b/src/UnitTests/DistributionTests/Continuous/StableTests.cs index dfb0dcdb..0eeba6b9 100644 --- a/src/UnitTests/DistributionTests/Continuous/StableTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/StableTests.cs @@ -341,7 +341,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(double alpha, double beta, double scale, double location, double x, double d) { var n = new Stable(alpha, beta, scale, location); - AssertHelpers.AlmostEqual(d, n.Density(x), 15); + AssertHelpers.AlmostEqualRelative(d, n.Density(x), 15); } /// @@ -365,7 +365,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(double alpha, double beta, double scale, double location, double x, double dln) { var n = new Stable(alpha, beta, scale, location); - AssertHelpers.AlmostEqual(dln, n.DensityLn(x), 15); + AssertHelpers.AlmostEqualRelative(dln, n.DensityLn(x), 15); } /// @@ -410,7 +410,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double alpha, double beta, double scale, double location, double x, double cdf) { var n = new Stable(alpha, beta, scale, location); - AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 15); + AssertHelpers.AlmostEqualRelative(cdf, n.CumulativeDistribution(x), 15); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/StudentTTests.cs b/src/UnitTests/DistributionTests/Continuous/StudentTTests.cs index 22d19b02..c75ddcf4 100644 --- a/src/UnitTests/DistributionTests/Continuous/StudentTTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/StudentTTests.cs @@ -341,7 +341,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(double location, double scale, double dof, double x, double p) { var n = new StudentT(location, scale, dof); - AssertHelpers.AlmostEqual(p, n.Density(x), 13); + AssertHelpers.AlmostEqualRelative(p, n.Density(x), 13); } /// @@ -368,7 +368,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(double location, double scale, double dof, double x, double p) { var n = new StudentT(location, scale, dof); - AssertHelpers.AlmostEqual(p, n.DensityLn(x), 13); + AssertHelpers.AlmostEqualRelative(p, n.DensityLn(x), 13); } /// @@ -454,7 +454,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double location, double scale, double dof, double x, double c) { var n = new StudentT(location, scale, dof); - AssertHelpers.AlmostEqual(c, n.CumulativeDistribution(x), 13); + AssertHelpers.AlmostEqualRelative(c, n.CumulativeDistribution(x), 13); } } } diff --git a/src/UnitTests/DistributionTests/Continuous/WeibullTests.cs b/src/UnitTests/DistributionTests/Continuous/WeibullTests.cs index c67426fb..bb76f330 100644 --- a/src/UnitTests/DistributionTests/Continuous/WeibullTests.cs +++ b/src/UnitTests/DistributionTests/Continuous/WeibullTests.cs @@ -164,7 +164,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateMean(double shape, double scale, double mean) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(mean, n.Mean, 13); + AssertHelpers.AlmostEqualRelative(mean, n.Mean, 13); } /// @@ -180,7 +180,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateVariance(double shape, double scale, double var) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(var, n.Variance, 13); + AssertHelpers.AlmostEqualRelative(var, n.Variance, 12); } /// @@ -196,7 +196,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateStdDev(double shape, double scale, double sdev) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(sdev, n.StdDev, 13); + AssertHelpers.AlmostEqualRelative(sdev, n.StdDev, 12); } /// @@ -212,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateSkewness(double shape, double scale, double skewness) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(skewness, n.Skewness, 11); + AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 10); } /// @@ -244,7 +244,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateMedian(double shape, double scale, double median) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(median, n.Median, 13); + AssertHelpers.AlmostEqualRelative(median, n.Median, 13); } /// @@ -289,7 +289,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensity(double shape, double scale, double x, double pdf) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(pdf, n.Density(x), 14); + AssertHelpers.AlmostEqualRelative(pdf, n.Density(x), 13); } /// @@ -314,7 +314,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateDensityLn(double shape, double scale, double x, double pdfln) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(pdfln, n.DensityLn(x), 14); + AssertHelpers.AlmostEqualRelative(pdfln, n.DensityLn(x), 14); } /// @@ -397,7 +397,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Continuous public void ValidateCumulativeDistribution(double shape, double scale, double x, double cdf) { var n = new Weibull(shape, scale); - AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 15); + AssertHelpers.AlmostEqualRelative(cdf, n.CumulativeDistribution(x), 14); } } } diff --git a/src/UnitTests/DistributionTests/Discrete/BernoulliTests.cs b/src/UnitTests/DistributionTests/Discrete/BernoulliTests.cs index 293ee42d..2c2b260b 100644 --- a/src/UnitTests/DistributionTests/Discrete/BernoulliTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/BernoulliTests.cs @@ -119,7 +119,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateEntropy(double p) { var b = new Bernoulli(p); - AssertHelpers.AlmostEqual(-((1.0 - p) * Math.Log(1.0 - p)) - (p * Math.Log(p)), b.Entropy, 14); + AssertHelpers.AlmostEqualRelative(-((1.0 - p) * Math.Log(1.0 - p)) - (p * Math.Log(p)), b.Entropy, 14); } /// diff --git a/src/UnitTests/DistributionTests/Discrete/BinomialTests.cs b/src/UnitTests/DistributionTests/Discrete/BinomialTests.cs index 12b5f49e..98cc03b1 100644 --- a/src/UnitTests/DistributionTests/Discrete/BinomialTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/BinomialTests.cs @@ -125,7 +125,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateEntropy(double p, int n, double e) { var b = new Binomial(p, n); - AssertHelpers.AlmostEqual(e, b.Entropy, 14); + AssertHelpers.AlmostEqualRelative(e, b.Entropy, 14); } /// @@ -211,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateProbability(double p, int n, int x, double d) { var b = new Binomial(p, n); - AssertHelpers.AlmostEqual(d, b.Probability(x), 14); + AssertHelpers.AlmostEqualRelative(d, b.Probability(x), 14); } /// @@ -248,7 +248,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateProbabilityLn(double p, int n, int x, double dln) { var b = new Binomial(p, n); - AssertHelpers.AlmostEqual(dln, b.ProbabilityLn(x), 14); + AssertHelpers.AlmostEqualRelative(dln, b.ProbabilityLn(x), 14); } /// diff --git a/src/UnitTests/DistributionTests/Discrete/ConwayMaxwellPoissonTests.cs b/src/UnitTests/DistributionTests/Discrete/ConwayMaxwellPoissonTests.cs index 43b5c113..9c2d7c53 100644 --- a/src/UnitTests/DistributionTests/Discrete/ConwayMaxwellPoissonTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/ConwayMaxwellPoissonTests.cs @@ -197,7 +197,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateMean(int lambda, int nu, double mean) { var d = new ConwayMaxwellPoisson(lambda, nu); - AssertHelpers.AlmostEqual(mean, d.Mean, 10); + AssertHelpers.AlmostEqualRelative(mean, d.Mean, 10); } /// @@ -236,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateProbability(double lambda, double nu, int x, double p) { var d = new ConwayMaxwellPoisson(lambda, nu); - AssertHelpers.AlmostEqual(p, d.Probability(x), 13); + AssertHelpers.AlmostEqualRelative(p, d.Probability(x), 12); } /// @@ -255,7 +255,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateProbabilityLn(double lambda, double nu, int x, double pln) { var d = new ConwayMaxwellPoisson(lambda, nu); - AssertHelpers.AlmostEqual(pln, d.ProbabilityLn(x), 13); + AssertHelpers.AlmostEqualRelative(pln, d.ProbabilityLn(x), 12); } /// @@ -295,7 +295,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateCumulativeDistribution(double lambda, double nu, int x, double cdf) { var d = new ConwayMaxwellPoisson(lambda, nu); - AssertHelpers.AlmostEqual(cdf, d.CumulativeDistribution(x), 13); + AssertHelpers.AlmostEqualRelative(cdf, d.CumulativeDistribution(x), 12); } } } diff --git a/src/UnitTests/DistributionTests/Discrete/DiscreteUniformTests.cs b/src/UnitTests/DistributionTests/Discrete/DiscreteUniformTests.cs index cf740cb4..16f2ef56 100644 --- a/src/UnitTests/DistributionTests/Discrete/DiscreteUniformTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/DiscreteUniformTests.cs @@ -151,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateEntropy(int l, int u, double e) { var du = new DiscreteUniform(l, u); - AssertHelpers.AlmostEqual(e, du.Entropy, 14); + AssertHelpers.AlmostEqualRelative(e, du.Entropy, 14); } /// diff --git a/src/UnitTests/DistributionTests/Discrete/HypergeometricTests.cs b/src/UnitTests/DistributionTests/Discrete/HypergeometricTests.cs index 28a4dbcf..b3c6c366 100644 --- a/src/UnitTests/DistributionTests/Discrete/HypergeometricTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/HypergeometricTests.cs @@ -355,7 +355,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateCumulativeDistribution(int population, int success, int draws, double x, double cdf) { var d = new Hypergeometric(population, success, draws); - AssertHelpers.AlmostEqual(cdf, d.CumulativeDistribution(x), 10); + AssertHelpers.AlmostEqualRelative(cdf, d.CumulativeDistribution(x), 9); } [Test] diff --git a/src/UnitTests/DistributionTests/Discrete/ZipfTests.cs b/src/UnitTests/DistributionTests/Discrete/ZipfTests.cs index de92ba6a..39ba4470 100644 --- a/src/UnitTests/DistributionTests/Discrete/ZipfTests.cs +++ b/src/UnitTests/DistributionTests/Discrete/ZipfTests.cs @@ -153,7 +153,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete public void ValidateEntropy(double s, int n, double e) { var d = new Zipf(s, n); - AssertHelpers.AlmostEqual(e, d.Entropy, 15); + AssertHelpers.AlmostEqualRelative(e, d.Entropy, 15); } /// @@ -292,7 +292,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Discrete { var d = new Zipf(s, n); var cdf = SpecialFunctions.GeneralHarmonic(x, s) / SpecialFunctions.GeneralHarmonic(n, s); - AssertHelpers.AlmostEqual(cdf, d.CumulativeDistribution(x), 14); + AssertHelpers.AlmostEqualRelative(cdf, d.CumulativeDistribution(x), 14); } } } diff --git a/src/UnitTests/DistributionTests/Multivariate/DirichletTests.cs b/src/UnitTests/DistributionTests/Multivariate/DirichletTests.cs index a03f1622..d8b08bbc 100644 --- a/src/UnitTests/DistributionTests/Multivariate/DirichletTests.cs +++ b/src/UnitTests/DistributionTests/Multivariate/DirichletTests.cs @@ -172,7 +172,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate for (var i = 0; i < 5; i++) { - AssertHelpers.AlmostEqual(0.3 / 1.5, d.Mean[i], 15); + AssertHelpers.AlmostEqualRelative(0.3 / 1.5, d.Mean[i], 15); } } @@ -193,7 +193,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate var d = new Dirichlet(alpha); for (var i = 0; i < 10; i++) { - AssertHelpers.AlmostEqual(i * (sum - i) / (sum * sum * (sum + 1.0)), d.Variance[i], 15); + AssertHelpers.AlmostEqualRelative(i * (sum - i) / (sum * sum * (sum + 1.0)), d.Variance[i], 15); } } @@ -210,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate public void ValidateDensity(double[] x, double res) { var d = new Dirichlet(new[] { 0.1, 0.3, 0.5, 0.8 }); - AssertHelpers.AlmostEqual(res, d.Density(x), 12); + AssertHelpers.AlmostEqualRelative(res, d.Density(x), 12); } /// @@ -222,7 +222,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate public void ValidateDensityLn(double[] x) { var d = new Dirichlet(new[] { 0.1, 0.3, 0.5, 0.8 }); - AssertHelpers.AlmostEqual(d.DensityLn(x), Math.Log(d.Density(x)), 12); + AssertHelpers.AlmostEqualRelative(d.DensityLn(x), Math.Log(d.Density(x)), 12); } /// @@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate { var d = new Dirichlet(new[] { 0.1, 0.3 }); var beta = new Beta(0.1, 0.3); - AssertHelpers.AlmostEqual(d.DensityLn(new[] { x }), beta.DensityLn(x), 10); + AssertHelpers.AlmostEqualRelative(d.DensityLn(new[] { x }), beta.DensityLn(x), 10); } /// @@ -252,7 +252,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate var sum = x.Sum(t => (t - 1) * SpecialFunctions.DiGamma(t)); var res = SpecialFunctions.GammaLn(x.Sum()) + ((x.Sum() - x.Length) * SpecialFunctions.DiGamma(x.Sum())) - sum; - AssertHelpers.AlmostEqual(res, d.Entropy, 12); + AssertHelpers.AlmostEqualRelative(res, d.Entropy, 12); } /// diff --git a/src/UnitTests/DistributionTests/Multivariate/InverseWishartTests.cs b/src/UnitTests/DistributionTests/Multivariate/InverseWishartTests.cs index 96447ab0..4d50814f 100644 --- a/src/UnitTests/DistributionTests/Multivariate/InverseWishartTests.cs +++ b/src/UnitTests/DistributionTests/Multivariate/InverseWishartTests.cs @@ -284,7 +284,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate x[0, 0] = 5; var d = new InverseWishart(nu, matrix); - AssertHelpers.AlmostEqual(density, d.Density(x), 16); + AssertHelpers.AlmostEqualRelative(density, d.Density(x), 16); } /// diff --git a/src/UnitTests/DistributionTests/Multivariate/MatrixNormalTests.cs b/src/UnitTests/DistributionTests/Multivariate/MatrixNormalTests.cs index 8353faa1..8275162b 100644 --- a/src/UnitTests/DistributionTests/Multivariate/MatrixNormalTests.cs +++ b/src/UnitTests/DistributionTests/Multivariate/MatrixNormalTests.cs @@ -294,7 +294,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate x[0, 0] = 2; x[0, 1] = 2; - AssertHelpers.AlmostEqual(0.00015682927366491211, d.Density(x), 16); + AssertHelpers.AlmostEqualRelative(0.00015682927366491211, d.Density(x), 16); } /// diff --git a/src/UnitTests/DistributionTests/Multivariate/MultinomialTests.cs b/src/UnitTests/DistributionTests/Multivariate/MultinomialTests.cs index 8c3b27a1..26df25d9 100644 --- a/src/UnitTests/DistributionTests/Multivariate/MultinomialTests.cs +++ b/src/UnitTests/DistributionTests/Multivariate/MultinomialTests.cs @@ -149,7 +149,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate var b = new Multinomial(p, n); for (var i = 0; i < b.P.Length; i++) { - AssertHelpers.AlmostEqual(res[i], b.Skewness[i], 12); + AssertHelpers.AlmostEqualRelative(res[i], b.Skewness[i], 12); } } @@ -167,7 +167,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate var b = new Multinomial(p, n); for (var i = 0; i < b.P.Length; i++) { - AssertHelpers.AlmostEqual(res[i], b.Variance[i], 12); + AssertHelpers.AlmostEqualRelative(res[i], b.Variance[i], 12); } } @@ -185,7 +185,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate var b = new Multinomial(p, n); for (var i = 0; i < b.P.Length; i++) { - AssertHelpers.AlmostEqual(res[i], b.Mean[i], 12); + AssertHelpers.AlmostEqualRelative(res[i], b.Mean[i], 12); } } @@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate public void ValidateProbability(double[] p, int[] x, double res) { var b = new Multinomial(p, x.Sum()); - AssertHelpers.AlmostEqual(b.Probability(x), res, 12); + AssertHelpers.AlmostEqualRelative(b.Probability(x), res, 12); } /// @@ -214,7 +214,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate public void ValidateProbabilityLn(int[] x) { var b = new Multinomial(_largeP, x.Sum()); - AssertHelpers.AlmostEqual(b.ProbabilityLn(x), Math.Log(b.Probability(x)), 12); + AssertHelpers.AlmostEqualRelative(b.ProbabilityLn(x), Math.Log(b.Probability(x)), 12); } /// diff --git a/src/UnitTests/DistributionTests/Multivariate/WishartTests.cs b/src/UnitTests/DistributionTests/Multivariate/WishartTests.cs index b7387841..4c6dd717 100644 --- a/src/UnitTests/DistributionTests/Multivariate/WishartTests.cs +++ b/src/UnitTests/DistributionTests/Multivariate/WishartTests.cs @@ -286,7 +286,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate x[0, 0] = 5; var d = new Wishart(nu, matrix); - AssertHelpers.AlmostEqual(density, d.Density(x), 16); + AssertHelpers.AlmostEqualRelative(density, d.Density(x), 16); } /// diff --git a/src/UnitTests/FinancialTests/CompoundMonthlyReturnTests.cs b/src/UnitTests/FinancialTests/CompoundMonthlyReturnTests.cs index 5343c525..40386709 100644 --- a/src/UnitTests/FinancialTests/CompoundMonthlyReturnTests.cs +++ b/src/UnitTests/FinancialTests/CompoundMonthlyReturnTests.cs @@ -68,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.FinancialTests //act var cmpdReturn = inputData.CompoundMonthlyReturn(); //assert - AssertHelpers.AlmostEqual(0.0870999982199265, cmpdReturn, 15); + AssertHelpers.AlmostEqualRelative(0.0870999982199265, cmpdReturn, 14); } //Definitly need more tests here. Would love to find test data for these stats similar to the .dat files used for other tests. diff --git a/src/UnitTests/IntegralTransformsTests/FourierTest.cs b/src/UnitTests/IntegralTransformsTests/FourierTest.cs index 61ca37c4..0ac02a4c 100644 --- a/src/UnitTests/IntegralTransformsTests/FourierTest.cs +++ b/src/UnitTests/IntegralTransformsTests/FourierTest.cs @@ -101,20 +101,10 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests var dft = new DiscreteFourierTransform(); - Assert.Throws( - typeof (ArgumentException), - () => dft.Radix2Forward(samples, FourierOptions.Default)); - - Assert.Throws( - typeof (ArgumentException), - () => dft.Radix2Inverse(samples, FourierOptions.Default)); - - Assert.Throws( - typeof (ArgumentException), - () => DiscreteFourierTransform.Radix2(samples, -1)); - Assert.Throws( - typeof (ArgumentException), - () => DiscreteFourierTransform.Radix2Parallel(samples, -1)); + Assert.Throws(typeof (ArgumentException), () => dft.Radix2Forward(samples, FourierOptions.Default)); + Assert.Throws(typeof (ArgumentException), () => dft.Radix2Inverse(samples, FourierOptions.Default)); + Assert.Throws(typeof (ArgumentException), () => DiscreteFourierTransform.Radix2(samples, -1)); + Assert.Throws(typeof (ArgumentException), () => DiscreteFourierTransform.Radix2Parallel(samples, -1)); } } } diff --git a/src/UnitTests/IntegralTransformsTests/HartleyTest.cs b/src/UnitTests/IntegralTransformsTests/HartleyTest.cs index e364e1a0..cf1a86f4 100644 --- a/src/UnitTests/IntegralTransformsTests/HartleyTest.cs +++ b/src/UnitTests/IntegralTransformsTests/HartleyTest.cs @@ -58,14 +58,9 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests /// /// Verify if matches DFT. /// - /// Samples array. - /// Maximum error value. - /// Is inverse. - /// DFT function delegate. - /// Hartley transform delegate. static void VerifyMatchesDft( double[] samples, - double maximumError, + int maximumErrorDecimalPlaces, bool inverse, Action dft, Func hartley) @@ -76,7 +71,7 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests dft(fourierComplex); var fourierReal = ArrayHelpers.ConvertAll(fourierComplex, s => s.Real); - AssertHelpers.AlmostEqualList(fourierReal, hartleyReal, maximumError); + AssertHelpers.ListAlmostEqual(fourierReal, hartleyReal, maximumErrorDecimalPlaces); } /// @@ -94,13 +89,13 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesDft( samples, - 1e-5, + 5, false, s => Transform.FourierForward(s, fourierOptions), s => dht.NaiveForward(s, hartleyOptions)); VerifyMatchesDft( samples, - 1e-5, + 5, true, s => Transform.FourierInverse(s, fourierOptions), s => dht.NaiveInverse(s, hartleyOptions)); diff --git a/src/UnitTests/IntegralTransformsTests/InverseTransformTest.cs b/src/UnitTests/IntegralTransformsTests/InverseTransformTest.cs index 9fef9cdf..d6be87dc 100644 --- a/src/UnitTests/IntegralTransformsTests/InverseTransformTest.cs +++ b/src/UnitTests/IntegralTransformsTests/InverseTransformTest.cs @@ -24,7 +24,6 @@ // OTHER DEALINGS IN THE SOFTWARE. // -using System; using MathNet.Numerics.Distributions; using MathNet.Numerics.IntegralTransforms; using MathNet.Numerics.IntegralTransforms.Algorithms; @@ -55,58 +54,6 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests return new ContinuousUniform(-1, 1, new Random(seed)); } - /// - /// Verify if is reversible complex. - /// - /// Samples count. - /// Maximum error value. - /// Forward delegate. - /// Inverse delegate. - void VerifyIsReversibleComplex( - int count, - double maximumError, - Func forward, - Func inverse) - { - var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), count); - var work = new Complex[samples.Length]; - samples.CopyTo(work, 0); - - work = forward(work); - - Assert.IsFalse(work.AlmostEqualListWithError(samples, maximumError)); - - work = inverse(work); - - AssertHelpers.AlmostEqualList(samples, work, maximumError); - } - - /// - /// Verify if is reversible real. - /// - /// Samples count. - /// Maximum error value. - /// Forward delegate. - /// Inverse delegate. - void VerifyIsReversibleReal( - int count, - double maximumError, - Func forward, - Func inverse) - { - var samples = SignalGenerator.Random(x => x, GetUniform(1), count); - var work = new double[samples.Length]; - samples.CopyTo(work, 0); - - work = forward(work); - - Assert.IsFalse(work.AlmostEqualListWithError(samples, maximumError)); - - work = inverse(work); - - AssertHelpers.AlmostEqualList(samples, work, maximumError); - } - /// /// Fourier naive is reversible. /// @@ -117,11 +64,15 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests { var dft = new DiscreteFourierTransform(); - VerifyIsReversibleComplex( - 0x80, - 1e-12, - s => dft.NaiveForward(s, options), - s => dft.NaiveInverse(s, options)); + var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x80); + var work = new Complex[samples.Length]; + samples.CopyTo(work, 0); + + work = dft.NaiveForward(work, options); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); + + work = dft.NaiveInverse(work, options); + AssertHelpers.ListAlmostEqual(samples, work, 12); } /// @@ -134,19 +85,15 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests { var dft = new DiscreteFourierTransform(); - VerifyIsReversibleComplex( - 0x8000, - 1e-12, - s => - { - dft.Radix2Forward(s, options); - return s; - }, - s => - { - dft.Radix2Inverse(s, options); - return s; - }); + var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x8000); + var work = new Complex[samples.Length]; + samples.CopyTo(work, 0); + + dft.Radix2Forward(work, options); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); + + dft.Radix2Inverse(work, options); + AssertHelpers.ListAlmostEqual(samples, work, 12); } /// @@ -159,19 +106,15 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests { var dft = new DiscreteFourierTransform(); - VerifyIsReversibleComplex( - 0x7FFF, - 1e-12, - s => - { - dft.BluesteinForward(s, options); - return s; - }, - s => - { - dft.BluesteinInverse(s, options); - return s; - }); + var samples = SignalGenerator.Random((u, v) => new Complex(u, v), GetUniform(1), 0x7FFF); + var work = new Complex[samples.Length]; + samples.CopyTo(work, 0); + + dft.BluesteinForward(work, options); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); + + dft.BluesteinInverse(work, options); + AssertHelpers.ListAlmostEqual(samples, work, 10); } /// @@ -184,11 +127,15 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests { var dht = new DiscreteHartleyTransform(); - VerifyIsReversibleReal( - 0x80, - 1e-9, - s => dht.NaiveForward(s, options), - s => dht.NaiveInverse(s, options)); + var samples = SignalGenerator.Random(x => x, GetUniform(1), 0x80); + var work = new double[samples.Length]; + samples.CopyTo(work, 0); + + work = dht.NaiveForward(work, options); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); + + work = dht.NaiveInverse(work, options); + AssertHelpers.ListAlmostEqual(samples, work, 12); } /// @@ -202,19 +149,16 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests samples.CopyTo(work, 0); Transform.FourierForward(work); - - Assert.IsFalse(work.AlmostEqualListWithError(samples, 1e-12)); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); Transform.FourierInverse(work); - - AssertHelpers.AlmostEqualList(samples, work, 1e-12); + AssertHelpers.ListAlmostEqual(samples, work, 10); Transform.FourierInverse(work, FourierOptions.Default); - - Assert.IsFalse(work.AlmostEqualListWithError(samples, 1e-12)); + Assert.IsFalse(work.ListAlmostEqual(samples, 6)); Transform.FourierForward(work, FourierOptions.Default); - AssertHelpers.AlmostEqualList(samples, work, 1e-12); + AssertHelpers.ListAlmostEqual(samples, work, 10); } } } diff --git a/src/UnitTests/IntegralTransformsTests/MatchingNaiveTransformTest.cs b/src/UnitTests/IntegralTransformsTests/MatchingNaiveTransformTest.cs index c9164f6a..ff0f1bf8 100644 --- a/src/UnitTests/IntegralTransformsTests/MatchingNaiveTransformTest.cs +++ b/src/UnitTests/IntegralTransformsTests/MatchingNaiveTransformTest.cs @@ -58,13 +58,9 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests /// /// Verify matches naive complex. /// - /// Samples count. - /// Maximum error. - /// Naive transform. - /// Fast delegate. static void VerifyMatchesNaiveComplex( Complex[] samples, - double maximumError, + int maximumErrorDecimalPlaces, Func naive, Action fast) { @@ -74,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests samples.CopyTo(spectrumFast, 0); fast(spectrumFast); - AssertHelpers.AlmostEqualList(spectrumNaive, spectrumFast, maximumError); + AssertHelpers.ListAlmostEqual(spectrumNaive, spectrumFast, maximumErrorDecimalPlaces); } /// @@ -91,13 +87,13 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesNaiveComplex( samples, - 1e-12, + 12, s => dft.NaiveForward(s, options), s => dft.Radix2Forward(s, options)); VerifyMatchesNaiveComplex( samples, - 1e-12, + 12, s => dft.NaiveInverse(s, options), s => dft.Radix2Inverse(s, options)); } @@ -116,13 +112,13 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveForward(s, options), s => dft.Radix2Forward(s, options)); VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveInverse(s, options), s => dft.Radix2Inverse(s, options)); } @@ -141,13 +137,13 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesNaiveComplex( samples, - 1e-12, + 12, s => dft.NaiveForward(s, options), s => dft.BluesteinForward(s, options)); VerifyMatchesNaiveComplex( samples, - 1e-12, + 12, s => dft.NaiveInverse(s, options), s => dft.BluesteinInverse(s, options)); } @@ -166,13 +162,13 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveForward(s, options), s => dft.BluesteinForward(s, options)); VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveInverse(s, options), s => dft.BluesteinInverse(s, options)); } @@ -191,12 +187,12 @@ namespace MathNet.Numerics.UnitTests.IntegralTransformsTests VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveForward(s, options), s => dft.BluesteinForward(s, options)); VerifyMatchesNaiveComplex( samples, - 1e-12, + 10, s => dft.NaiveInverse(s, options), s => dft.BluesteinInverse(s, options)); } diff --git a/src/UnitTests/LinearAlgebraProviderTests/Complex/LinearAlgebraProviderTests.cs b/src/UnitTests/LinearAlgebraProviderTests/Complex/LinearAlgebraProviderTests.cs index 41f2ae7d..02c5545c 100644 --- a/src/UnitTests/LinearAlgebraProviderTests/Complex/LinearAlgebraProviderTests.cs +++ b/src/UnitTests/LinearAlgebraProviderTests/Complex/LinearAlgebraProviderTests.cs @@ -137,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex public void CanComputeDotProduct() { var result = Control.LinearAlgebraProvider.DotProduct(_x, _y); - AssertHelpers.AlmostEqual(152.35, result, 15); + AssertHelpers.AlmostEqualRelative(152.35, result, 15); } /// @@ -205,7 +205,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var matrix = _matrices["Square3x3"]; var work = new double[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 6); } /// @@ -217,7 +217,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var matrix = _matrices["Square3x3"]; var work = new double[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqualRelative(10.777754868246, norm, 8); } /// @@ -241,7 +241,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var matrix = _matrices["Square3x3"]; var work = new double[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 6); } /// @@ -253,7 +253,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var matrix = _matrices["Square3x3"]; var work = new double[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqualRelative(10.777754868246, norm, 8); } /// @@ -284,7 +284,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -305,7 +305,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -326,7 +326,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -347,7 +347,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -368,7 +368,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -389,7 +389,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 15); } } } @@ -408,15 +408,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -4.4, 15); - AssertHelpers.AlmostEqual(a[1], 0.25, 15); - AssertHelpers.AlmostEqual(a[2], 0, 15); - AssertHelpers.AlmostEqual(a[3], 5.5, 15); - AssertHelpers.AlmostEqual(a[4], -3.575, 15); - AssertHelpers.AlmostEqual(a[5], -0.307692307692308, 15); - AssertHelpers.AlmostEqual(a[6], 6.6, 15); - AssertHelpers.AlmostEqual(a[7], -4.95, 15); - AssertHelpers.AlmostEqual(a[8], 0.676923076923077, 15); + AssertHelpers.AlmostEqualRelative(a[0], -4.4, 15); + AssertHelpers.AlmostEqualRelative(a[1], 0.25, 15); + AssertHelpers.AlmostEqualRelative(a[2], 0, 15); + AssertHelpers.AlmostEqualRelative(a[3], 5.5, 15); + AssertHelpers.AlmostEqualRelative(a[4], -3.575, 15); + AssertHelpers.AlmostEqualRelative(a[5], -0.307692307692308, 14); + AssertHelpers.AlmostEqualRelative(a[6], 6.6, 15); + AssertHelpers.AlmostEqualRelative(a[7], -4.95, 14); + AssertHelpers.AlmostEqualRelative(a[8], 0.676923076923077, 14); Assert.AreEqual(ipiv[0], 2); Assert.AreEqual(ipiv[1], 2); Assert.AreEqual(ipiv[2], 2); @@ -434,15 +434,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -461,15 +461,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -486,15 +486,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var work = new Complex[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -515,15 +515,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var work = new Complex[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -539,12 +539,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var b = new[] {new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 14); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 14); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 14); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 14); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 14); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 14); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 14); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 14); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 14); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 14); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 14); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 14); NotModified(matrix.RowCount, matrix.ColumnCount, a, matrix); } @@ -565,12 +565,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var b = new[] {new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.LUSolveFactored(2, a, matrix.RowCount, ipiv, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 14); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 14); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 14); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 14); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 14); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 14); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 14); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 14); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 14); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 14); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 14); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 14); } /// @@ -611,12 +611,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var b = new[] {new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.CholeskySolve(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 14); - AssertHelpers.AlmostEqual(b[1], 1, 14); - AssertHelpers.AlmostEqual(b[2], 0, 14); - AssertHelpers.AlmostEqual(b[3], 3, 14); - AssertHelpers.AlmostEqual(b[4], 1, 14); - AssertHelpers.AlmostEqual(b[5], 0, 14); + AssertHelpers.AlmostEqualRelative(b[0], 0, 14); + AssertHelpers.AlmostEqualRelative(b[1], 1, 14); + AssertHelpers.AlmostEqualRelative(b[2], 0, 14); + AssertHelpers.AlmostEqualRelative(b[3], 3, 14); + AssertHelpers.AlmostEqualRelative(b[4], 1, 14); + AssertHelpers.AlmostEqualRelative(b[5], 0, 14); NotModified(3, 3, a, matrix); } @@ -634,12 +634,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var b = new[] {new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.CholeskySolveFactored(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 14); - AssertHelpers.AlmostEqual(b[1], 1, 14); - AssertHelpers.AlmostEqual(b[2], 0, 14); - AssertHelpers.AlmostEqual(b[3], 3, 14); - AssertHelpers.AlmostEqual(b[4], 1, 14); - AssertHelpers.AlmostEqual(b[5], 0, 14); + AssertHelpers.AlmostEqualRelative(b[0], 0, 14); + AssertHelpers.AlmostEqualRelative(b[1], 1, 14); + AssertHelpers.AlmostEqualRelative(b[2], 0, 14); + AssertHelpers.AlmostEqualRelative(b[3], 3, 14); + AssertHelpers.AlmostEqualRelative(b[4], 1, 14); + AssertHelpers.AlmostEqualRelative(b[5], 0, 14); } /// @@ -664,7 +664,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -691,7 +691,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -718,7 +718,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -746,7 +746,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -774,7 +774,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -802,7 +802,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -829,7 +829,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -856,7 +856,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -884,7 +884,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -911,7 +911,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -934,12 +934,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -961,10 +961,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -988,12 +988,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1017,10 +1017,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1045,12 +1045,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1075,10 +1075,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1104,12 +1104,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1135,10 +1135,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1160,12 +1160,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1187,10 +1187,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1214,12 +1214,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1243,10 +1243,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1271,12 +1271,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1301,10 +1301,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1330,12 +1330,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1361,10 +1361,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1393,15 +1393,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 13); } /// @@ -1430,12 +1430,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); } /// @@ -1464,12 +1464,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); } /// @@ -1500,15 +1500,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 13); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 13); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 13); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 13); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 13); } /// @@ -1539,12 +1539,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); } /// @@ -1575,12 +1575,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); } /// @@ -1602,12 +1602,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1629,10 +1629,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } /// @@ -1659,12 +1659,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1691,10 +1691,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 13); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 13); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 13); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 13); } [TestCase("Wide10x50000", "Tall50000x10")] diff --git a/src/UnitTests/LinearAlgebraProviderTests/Complex32/LinearAlgebraProviderTests.cs b/src/UnitTests/LinearAlgebraProviderTests/Complex32/LinearAlgebraProviderTests.cs index 91ea6a57..88dc2659 100644 --- a/src/UnitTests/LinearAlgebraProviderTests/Complex32/LinearAlgebraProviderTests.cs +++ b/src/UnitTests/LinearAlgebraProviderTests/Complex32/LinearAlgebraProviderTests.cs @@ -100,7 +100,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 Control.LinearAlgebraProvider.AddVectorToScaledVector(result, (Complex32) Math.PI, _x, result); for (var i = 0; i < _y.Length; i++) { - AssertHelpers.AlmostEqual(_y[i] + ((Complex32) Math.PI*_x[i]), result[i], 6); + AssertHelpers.AlmostEqualRelative(_y[i] + ((Complex32) Math.PI*_x[i]), result[i], 5); } } @@ -122,7 +122,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 Control.LinearAlgebraProvider.ScaleArray((Complex32) Math.PI, result, result); for (var i = 0; i < _y.Length; i++) { - AssertHelpers.AlmostEqual(_y[i]*(Complex32) Math.PI, result[i], 6); + AssertHelpers.AlmostEqualRelative(_y[i]*(Complex32) Math.PI, result[i], 5); } } @@ -133,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 public void CanComputeDotProduct() { var result = Control.LinearAlgebraProvider.DotProduct(_x, _y); - AssertHelpers.AlmostEqual(152.35f, result, 6); + AssertHelpers.AlmostEqualRelative(152.35f, result, 5); } /// @@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var matrix = _matrices["Square3x3"]; var work = new float[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1f, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1f, norm, 5); } /// @@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var matrix = _matrices["Square3x3"]; var work = new float[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246f, norm, 6); + AssertHelpers.AlmostEqualRelative(10.777754868246f, norm, 5); } /// @@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var matrix = _matrices["Square3x3"]; var work = new float[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1f, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1f, norm, 5); } /// @@ -249,7 +249,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var matrix = _matrices["Square3x3"]; var work = new float[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246f, norm, 6); + AssertHelpers.AlmostEqualRelative(10.777754868246f, norm, 5); } /// @@ -280,7 +280,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -301,7 +301,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -322,7 +322,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -343,7 +343,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -364,7 +364,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -393,7 +393,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 continue; } - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -412,15 +412,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -4.4f, 6); - AssertHelpers.AlmostEqual(a[1], 0.25f, 6); - AssertHelpers.AlmostEqual(a[2], 0f, 6); - AssertHelpers.AlmostEqual(a[3], 5.5f, 6); - AssertHelpers.AlmostEqual(a[4], -3.575f, 6); - AssertHelpers.AlmostEqual(a[5], -0.307692307692308f, 6); - AssertHelpers.AlmostEqual(a[6], 6.6f, 6); - AssertHelpers.AlmostEqual(a[7], -4.95f, 6); - AssertHelpers.AlmostEqual(a[8], 0.676923076923077f, 6); + AssertHelpers.AlmostEqualRelative(a[0], -4.4f, 5); + AssertHelpers.AlmostEqualRelative(a[1], 0.25f, 5); + AssertHelpers.AlmostEqualRelative(a[2], 0f, 5); + AssertHelpers.AlmostEqualRelative(a[3], 5.5f, 5); + AssertHelpers.AlmostEqualRelative(a[4], -3.575f, 5); + AssertHelpers.AlmostEqualRelative(a[5], -0.307692307692308f, 5); + AssertHelpers.AlmostEqualRelative(a[6], 6.6f, 5); + AssertHelpers.AlmostEqualRelative(a[7], -4.95f, 5); + AssertHelpers.AlmostEqualRelative(a[8], 0.676923076923077f, 5); Assert.AreEqual(ipiv[0], 2); Assert.AreEqual(ipiv[1], 2); Assert.AreEqual(ipiv[2], 2); @@ -438,15 +438,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908f, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090f, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543f, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726f, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364f, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727f, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364f, 6); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908f, 5); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090f, 5); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543f, 5); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364f, 5); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727f, 5); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364f, 5); } /// @@ -465,15 +465,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908f, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090f, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543f, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726f, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364f, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727f, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364f, 6); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908f, 5); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090f, 5); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543f, 5); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364f, 5); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727f, 5); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364f, 5); } /// @@ -490,15 +490,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var work = new Complex32[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908f, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090f, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543f, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726f, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364f, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727f, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364f, 6); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908f, 5); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090f, 5); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543f, 5); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364f, 5); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727f, 5); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364f, 5); } /// @@ -519,15 +519,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var work = new Complex32[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908f, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454f, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090f, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543f, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726f, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364f, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727f, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364f, 6); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908f, 5); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454f, 5); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090f, 5); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543f, 5); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364f, 5); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727f, 5); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364f, 5); } /// @@ -543,12 +543,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var b = new[] {new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726f, 6); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815f, 6); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816f, 6); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451f, 6); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989f, 6); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266f, 6); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815f, 5); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816f, 5); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451f, 5); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989f, 5); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266f, 5); NotModified(matrix.RowCount, matrix.ColumnCount, a, matrix); } @@ -569,12 +569,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var b = new[] {new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.LUSolveFactored(2, a, matrix.RowCount, ipiv, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726f, 6); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815f, 6); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816f, 6); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451f, 6); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989f, 6); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266f, 6); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726f, 5); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815f, 5); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816f, 5); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451f, 5); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989f, 5); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266f, 5); } /// @@ -615,12 +615,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var b = new[] {new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.CholeskySolve(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 6); - AssertHelpers.AlmostEqual(b[1], 1, 6); - AssertHelpers.AlmostEqual(b[2], 0, 6); - AssertHelpers.AlmostEqual(b[3], 3, 6); - AssertHelpers.AlmostEqual(b[4], 1, 6); - AssertHelpers.AlmostEqual(b[5], 0, 6); + AssertHelpers.AlmostEqualRelative(b[0], 0, 5); + AssertHelpers.AlmostEqualRelative(b[1], 1, 5); + AssertHelpers.AlmostEqualRelative(b[2], 0, 5); + AssertHelpers.AlmostEqualRelative(b[3], 3, 5); + AssertHelpers.AlmostEqualRelative(b[4], 1, 5); + AssertHelpers.AlmostEqualRelative(b[5], 0, 5); NotModified(3, 3, a, matrix); } @@ -638,12 +638,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var b = new[] {new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.CholeskySolveFactored(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 6); - AssertHelpers.AlmostEqual(b[1], 1, 6); - AssertHelpers.AlmostEqual(b[2], 0, 6); - AssertHelpers.AlmostEqual(b[3], 3, 6); - AssertHelpers.AlmostEqual(b[4], 1, 6); - AssertHelpers.AlmostEqual(b[5], 0, 6); + AssertHelpers.AlmostEqualRelative(b[0], 0, 5); + AssertHelpers.AlmostEqualRelative(b[1], 1, 5); + AssertHelpers.AlmostEqualRelative(b[2], 0, 5); + AssertHelpers.AlmostEqualRelative(b[3], 3, 5); + AssertHelpers.AlmostEqualRelative(b[4], 1, 5); + AssertHelpers.AlmostEqualRelative(b[5], 0, 5); } /// @@ -668,7 +668,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -695,7 +695,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -722,7 +722,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -750,7 +750,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -778,7 +778,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -806,7 +806,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -833,7 +833,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -860,7 +860,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -888,7 +888,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -915,7 +915,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -939,12 +939,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -966,10 +966,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -993,12 +993,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1022,10 +1022,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1050,12 +1050,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1080,10 +1080,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1109,12 +1109,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1140,10 +1140,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1165,12 +1165,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1192,10 +1192,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1219,12 +1219,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1248,10 +1248,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1276,12 +1276,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1306,10 +1306,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1335,12 +1335,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1366,10 +1366,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1398,15 +1398,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 6); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 6); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 5); } /// @@ -1435,12 +1435,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 4); } /// @@ -1469,12 +1469,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 4); } /// @@ -1505,15 +1505,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 6); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 6); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 5); } /// @@ -1544,12 +1544,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 4); } /// @@ -1580,12 +1580,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 4); } /// @@ -1607,12 +1607,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 6); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 6); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 4); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 4); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1634,10 +1634,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 5); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 5); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 5); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 5); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1664,12 +1664,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 4); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 4); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1696,10 +1696,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32 var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 5); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 5); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 5); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 5); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } [TestCase("Wide10x50000", "Tall50000x10")] diff --git a/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs b/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs index 3128006b..346dd5f0 100644 --- a/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs +++ b/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs @@ -131,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double public void CanComputeDotProduct() { var result = Control.LinearAlgebraProvider.DotProduct(_x, _y); - AssertHelpers.AlmostEqual(152.35, result, 15); + AssertHelpers.AlmostEqualRelative(152.35, result, 14); } /// @@ -199,7 +199,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var matrix = _matrices["Square3x3"]; var work = new double[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 6); } /// @@ -211,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var matrix = _matrices["Square3x3"]; var work = new double[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqualRelative(10.777754868246, norm, 8); } /// @@ -235,7 +235,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var matrix = _matrices["Square3x3"]; var work = new double[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 6); } /// @@ -247,7 +247,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var matrix = _matrices["Square3x3"]; var work = new double[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqualRelative(10.777754868246, norm, 8); } /// @@ -278,7 +278,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -299,7 +299,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -320,7 +320,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -341,7 +341,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -362,7 +362,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -383,7 +383,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2*x.Row(i)*y.Column(j), c[i, j], 15); + AssertHelpers.AlmostEqualRelative(2.2*x.Row(i)*y.Column(j), c[i, j], 14); } } } @@ -402,15 +402,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -4.4, 15); - AssertHelpers.AlmostEqual(a[1], 0.25, 15); - AssertHelpers.AlmostEqual(a[2], 0, 15); - AssertHelpers.AlmostEqual(a[3], 5.5, 15); - AssertHelpers.AlmostEqual(a[4], -3.575, 15); - AssertHelpers.AlmostEqual(a[5], -0.307692307692308, 15); - AssertHelpers.AlmostEqual(a[6], 6.6, 15); - AssertHelpers.AlmostEqual(a[7], -4.95, 15); - AssertHelpers.AlmostEqual(a[8], 0.676923076923077, 15); + AssertHelpers.AlmostEqualRelative(a[0], -4.4, 14); + AssertHelpers.AlmostEqualRelative(a[1], 0.25, 14); + AssertHelpers.AlmostEqualRelative(a[2], 0, 14); + AssertHelpers.AlmostEqualRelative(a[3], 5.5, 14); + AssertHelpers.AlmostEqualRelative(a[4], -3.575, 14); + AssertHelpers.AlmostEqualRelative(a[5], -0.307692307692308, 14); + AssertHelpers.AlmostEqualRelative(a[6], 6.6, 14); + AssertHelpers.AlmostEqualRelative(a[7], -4.95, 14); + AssertHelpers.AlmostEqualRelative(a[8], 0.676923076923077, 14); Assert.AreEqual(ipiv[0], 2); Assert.AreEqual(ipiv[1], 2); Assert.AreEqual(ipiv[2], 2); @@ -428,15 +428,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -455,15 +455,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -480,15 +480,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var work = new double[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -509,15 +509,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var work = new double[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 14); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 14); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 14); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 14); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 14); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 14); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 14); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 14); + AssertHelpers.AlmostEqualRelative(a[0], -0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[1], -0.909090909090908, 13); + AssertHelpers.AlmostEqualRelative(a[2], 0.454545454545454, 13); + AssertHelpers.AlmostEqualRelative(a[3], -0.340909090909090, 13); + AssertHelpers.AlmostEqualRelative(a[4], -2.045454545454543, 13); + AssertHelpers.AlmostEqualRelative(a[5], 1.477272727272726, 13); + AssertHelpers.AlmostEqualRelative(a[6], -0.113636363636364, 13); + AssertHelpers.AlmostEqualRelative(a[7], 0.227272727272727, 13); + AssertHelpers.AlmostEqualRelative(a[8], -0.113636363636364, 13); } /// @@ -533,12 +533,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var b = new[] {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 14); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 14); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 14); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 14); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 14); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 14); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 14); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 14); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 14); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 14); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 14); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 14); NotModified(matrix.RowCount, matrix.ColumnCount, a, matrix); } @@ -559,12 +559,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var b = new[] {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.LUSolveFactored(2, a, matrix.RowCount, ipiv, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 14); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 14); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 14); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 14); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 14); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 14); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 14); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 14); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 14); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 14); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 14); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 14); } /// @@ -605,12 +605,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var b = new[] {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.CholeskySolve(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 14); - AssertHelpers.AlmostEqual(b[1], 1, 14); - AssertHelpers.AlmostEqual(b[2], 0, 14); - AssertHelpers.AlmostEqual(b[3], 3, 14); - AssertHelpers.AlmostEqual(b[4], 1, 14); - AssertHelpers.AlmostEqual(b[5], 0, 14); + AssertHelpers.AlmostEqualRelative(b[0], 0, 14); + AssertHelpers.AlmostEqualRelative(b[1], 1, 14); + AssertHelpers.AlmostEqualRelative(b[2], 0, 14); + AssertHelpers.AlmostEqualRelative(b[3], 3, 14); + AssertHelpers.AlmostEqualRelative(b[4], 1, 14); + AssertHelpers.AlmostEqualRelative(b[5], 0, 14); NotModified(3, 3, a, matrix); } @@ -628,12 +628,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var b = new[] {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; Control.LinearAlgebraProvider.CholeskySolveFactored(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 14); - AssertHelpers.AlmostEqual(b[1], 1, 14); - AssertHelpers.AlmostEqual(b[2], 0, 14); - AssertHelpers.AlmostEqual(b[3], 3, 14); - AssertHelpers.AlmostEqual(b[4], 1, 14); - AssertHelpers.AlmostEqual(b[5], 0, 14); + AssertHelpers.AlmostEqualRelative(b[0], 0, 14); + AssertHelpers.AlmostEqualRelative(b[1], 1, 14); + AssertHelpers.AlmostEqualRelative(b[2], 0, 14); + AssertHelpers.AlmostEqualRelative(b[3], 3, 14); + AssertHelpers.AlmostEqualRelative(b[4], 1, 14); + AssertHelpers.AlmostEqualRelative(b[5], 0, 14); } /// @@ -658,7 +658,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -685,7 +685,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -712,7 +712,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -740,7 +740,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -768,7 +768,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -796,7 +796,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -823,7 +823,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -850,7 +850,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -879,7 +879,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -906,7 +906,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 14); } } } @@ -930,12 +930,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -957,10 +957,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -984,12 +984,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1013,10 +1013,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1041,12 +1041,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1071,10 +1071,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1100,12 +1100,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1131,10 +1131,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1156,12 +1156,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1183,10 +1183,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1210,12 +1210,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1239,10 +1239,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1267,12 +1267,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1297,10 +1297,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1326,12 +1326,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1357,10 +1357,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1389,15 +1389,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 14); } /// @@ -1426,12 +1426,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); } /// @@ -1460,12 +1460,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); } /// @@ -1496,15 +1496,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 14); } /// @@ -1535,12 +1535,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 14); } /// @@ -1571,12 +1571,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 14); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 14); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 14); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 14); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 14); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 14); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 14); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 14); } /// @@ -1598,12 +1598,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1625,10 +1625,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } /// @@ -1655,12 +1655,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 14); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 14); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 14); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 14); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 14); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 14); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 13); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 13); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 13); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 13); } /// @@ -1687,10 +1687,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 14); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 14); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 14); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 14); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 14); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 14); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 14); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 14); } [TestCase("Wide10x50000", "Tall50000x10")] diff --git a/src/UnitTests/LinearAlgebraProviderTests/Single/LinearAlgebraProviderTests.cs b/src/UnitTests/LinearAlgebraProviderTests/Single/LinearAlgebraProviderTests.cs index ce4e2369..4480759c 100644 --- a/src/UnitTests/LinearAlgebraProviderTests/Single/LinearAlgebraProviderTests.cs +++ b/src/UnitTests/LinearAlgebraProviderTests/Single/LinearAlgebraProviderTests.cs @@ -98,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single Control.LinearAlgebraProvider.AddVectorToScaledVector(result, (float) Math.PI, _x, result); for (var i = 0; i < _y.Length; i++) { - AssertHelpers.AlmostEqual(_y[i] + ((float) Math.PI*_x[i]), result[i], 6); + AssertHelpers.AlmostEqualRelative(_y[i] + ((float) Math.PI*_x[i]), result[i], 5); } } @@ -120,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single Control.LinearAlgebraProvider.ScaleArray((float) Math.PI, result, result); for (var i = 0; i < _y.Length; i++) { - AssertHelpers.AlmostEqual(_y[i]*(float) Math.PI, result[i], 6); + AssertHelpers.AlmostEqualRelative(_y[i]*(float) Math.PI, result[i], 5); } } @@ -131,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single public void CanComputeDotProduct() { var result = Control.LinearAlgebraProvider.DotProduct(_x, _y); - AssertHelpers.AlmostEqual(152.35, result, 6); + AssertHelpers.AlmostEqualRelative(152.35, result, 5); } /// @@ -199,7 +199,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var matrix = _matrices["Square3x3"]; var work = new float[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 5); } /// @@ -211,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var matrix = _matrices["Square3x3"]; var work = new float[matrix.RowCount]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqual(10.777754868246, norm, 5); } /// @@ -235,7 +235,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var matrix = _matrices["Square3x3"]; var work = new float[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(12.1, norm, 6); + AssertHelpers.AlmostEqualRelative(12.1, norm, 5); } /// @@ -247,7 +247,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var matrix = _matrices["Square3x3"]; var work = new float[18]; var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work); - AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + AssertHelpers.AlmostEqual(10.777754868246, norm, 5); } /// @@ -278,7 +278,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -299,7 +299,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -320,7 +320,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -341,7 +341,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -362,7 +362,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var j = 0; j < c.ColumnCount; j++) { - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -391,7 +391,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single continue; } - AssertHelpers.AlmostEqual(2.2f*x.Row(i)*y.Column(j), c[i, j], 6); + AssertHelpers.AlmostEqualRelative(2.2f*x.Row(i)*y.Column(j), c[i, j], 5); } } } @@ -410,15 +410,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -4.4, 6); - AssertHelpers.AlmostEqual(a[1], 0.25, 6); - AssertHelpers.AlmostEqual(a[2], 0, 6); - AssertHelpers.AlmostEqual(a[3], 5.5, 6); - AssertHelpers.AlmostEqual(a[4], -3.575, 6); - AssertHelpers.AlmostEqual(a[5], -0.307692307692308, 6); - AssertHelpers.AlmostEqual(a[6], 6.6, 6); - AssertHelpers.AlmostEqual(a[7], -4.95, 6); - AssertHelpers.AlmostEqual(a[8], 0.676923076923077, 6); + AssertHelpers.AlmostEqual(a[0], -4.4, 5); + AssertHelpers.AlmostEqual(a[1], 0.25, 5); + AssertHelpers.AlmostEqual(a[2], 0, 5); + AssertHelpers.AlmostEqual(a[3], 5.5, 5); + AssertHelpers.AlmostEqual(a[4], -3.575, 5); + AssertHelpers.AlmostEqual(a[5], -0.307692307692308, 5); + AssertHelpers.AlmostEqual(a[6], 6.6, 5); + AssertHelpers.AlmostEqual(a[7], -4.95, 5); + AssertHelpers.AlmostEqual(a[8], 0.676923076923077, 5); Assert.AreEqual(ipiv[0], 2); Assert.AreEqual(ipiv[1], 2); Assert.AreEqual(ipiv[2], 2); @@ -436,15 +436,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 6); + AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 5); + AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 5); + AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 5); + AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 5); + AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 5); + AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 5); + AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 5); } /// @@ -463,15 +463,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv); Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 6); + AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 5); + AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 5); + AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 5); + AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 5); + AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 5); + AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 5); + AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 5); } /// @@ -488,15 +488,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var work = new float[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 6); + AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 5); + AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 5); + AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 5); + AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 5); + AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 5); + AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 5); + AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 5); } /// @@ -517,15 +517,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var work = new float[matrix.RowCount]; Control.LinearAlgebraProvider.LUInverseFactored(a, matrix.RowCount, ipiv, work); - AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 6); - AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 6); - AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 6); - AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 6); - AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 6); - AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 6); - AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 6); - AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 6); + AssertHelpers.AlmostEqual(a[0], -0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[1], -0.909090909090908, 5); + AssertHelpers.AlmostEqual(a[2], 0.454545454545454, 5); + AssertHelpers.AlmostEqual(a[3], -0.340909090909090, 5); + AssertHelpers.AlmostEqual(a[4], -2.045454545454543, 5); + AssertHelpers.AlmostEqual(a[5], 1.477272727272726, 5); + AssertHelpers.AlmostEqual(a[6], -0.113636363636364, 5); + AssertHelpers.AlmostEqual(a[7], 0.227272727272727, 5); + AssertHelpers.AlmostEqual(a[8], -0.113636363636364, 5); } /// @@ -541,12 +541,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var b = new[] {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 6); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 6); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 6); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 6); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 6); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 6); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 5); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 5); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 5); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 5); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 5); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 5); NotModified(matrix.RowCount, matrix.ColumnCount, a, matrix); } @@ -567,12 +567,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var b = new[] {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.LUSolveFactored(2, a, matrix.RowCount, ipiv, b); - AssertHelpers.AlmostEqual(b[0], -1.477272727272726, 6); - AssertHelpers.AlmostEqual(b[1], -4.318181818181815, 6); - AssertHelpers.AlmostEqual(b[2], 3.068181818181816, 6); - AssertHelpers.AlmostEqual(b[3], -4.204545454545451, 6); - AssertHelpers.AlmostEqual(b[4], -12.499999999999989, 6); - AssertHelpers.AlmostEqual(b[5], 8.522727272727266, 6); + AssertHelpers.AlmostEqualRelative(b[0], -1.477272727272726, 5); + AssertHelpers.AlmostEqualRelative(b[1], -4.318181818181815, 5); + AssertHelpers.AlmostEqualRelative(b[2], 3.068181818181816, 5); + AssertHelpers.AlmostEqualRelative(b[3], -4.204545454545451, 5); + AssertHelpers.AlmostEqualRelative(b[4], -12.499999999999989, 5); + AssertHelpers.AlmostEqualRelative(b[5], 8.522727272727266, 5); } /// @@ -613,12 +613,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var b = new[] {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.CholeskySolve(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 6); - AssertHelpers.AlmostEqual(b[1], 1, 6); - AssertHelpers.AlmostEqual(b[2], 0, 6); - AssertHelpers.AlmostEqual(b[3], 3, 6); - AssertHelpers.AlmostEqual(b[4], 1, 6); - AssertHelpers.AlmostEqual(b[5], 0, 6); + AssertHelpers.AlmostEqualRelative(b[0], 0, 5); + AssertHelpers.AlmostEqualRelative(b[1], 1, 5); + AssertHelpers.AlmostEqualRelative(b[2], 0, 5); + AssertHelpers.AlmostEqualRelative(b[3], 3, 5); + AssertHelpers.AlmostEqualRelative(b[4], 1, 5); + AssertHelpers.AlmostEqualRelative(b[5], 0, 5); NotModified(3, 3, a, matrix); } @@ -636,12 +636,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var b = new[] {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; Control.LinearAlgebraProvider.CholeskySolveFactored(a, 3, b, 2); - AssertHelpers.AlmostEqual(b[0], 0, 6); - AssertHelpers.AlmostEqual(b[1], 1, 6); - AssertHelpers.AlmostEqual(b[2], 0, 6); - AssertHelpers.AlmostEqual(b[3], 3, 6); - AssertHelpers.AlmostEqual(b[4], 1, 6); - AssertHelpers.AlmostEqual(b[5], 0, 6); + AssertHelpers.AlmostEqualRelative(b[0], 0, 5); + AssertHelpers.AlmostEqualRelative(b[1], 1, 5); + AssertHelpers.AlmostEqualRelative(b[2], 0, 5); + AssertHelpers.AlmostEqualRelative(b[3], 3, 5); + AssertHelpers.AlmostEqualRelative(b[4], 1, 5); + AssertHelpers.AlmostEqualRelative(b[5], 0, 5); } /// @@ -666,7 +666,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -693,7 +693,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -720,7 +720,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -748,7 +748,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -776,7 +776,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -804,7 +804,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -831,7 +831,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -858,7 +858,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -886,7 +886,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -913,7 +913,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single { for (var col = 0; col < matrix.ColumnCount; col++) { - AssertHelpers.AlmostEqual(matrix[row, col], a[row, col], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, col], a[row, col], 5); } } } @@ -937,12 +937,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -964,10 +964,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -991,12 +991,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1020,10 +1020,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1048,12 +1048,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1078,10 +1078,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1107,12 +1107,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1138,10 +1138,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1163,12 +1163,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1190,10 +1190,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1217,12 +1217,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1246,10 +1246,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1274,12 +1274,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1304,10 +1304,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1333,12 +1333,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 5); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 5); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 4); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 4); } /// @@ -1364,10 +1364,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1396,15 +1396,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 6); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 6); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 5); } /// @@ -1433,12 +1433,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); } /// @@ -1467,12 +1467,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); } /// @@ -1503,15 +1503,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 6); - AssertHelpers.AlmostEqual(matrix[2, 2], result[2, 2], 6); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 2], result[2, 2], 5); } /// @@ -1542,12 +1542,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[2, 0], result[2, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[2, 1], result[2, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 0], result[2, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[2, 1], result[2, 1], 5); } /// @@ -1578,12 +1578,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mV = new DenseMatrix(matrix.ColumnCount, matrix.ColumnCount, vt); var result = mU*w*mV; - AssertHelpers.AlmostEqual(matrix[0, 0], result[0, 0], 6); - AssertHelpers.AlmostEqual(matrix[1, 0], result[1, 0], 6); - AssertHelpers.AlmostEqual(matrix[0, 1], result[0, 1], 6); - AssertHelpers.AlmostEqual(matrix[1, 1], result[1, 1], 6); - AssertHelpers.AlmostEqual(matrix[0, 2], result[0, 2], 6); - AssertHelpers.AlmostEqual(matrix[1, 2], result[1, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 0], result[0, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 0], result[1, 0], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 1], result[0, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 1], result[1, 1], 5); + AssertHelpers.AlmostEqualRelative(matrix[0, 2], result[0, 2], 5); + AssertHelpers.AlmostEqualRelative(matrix[1, 2], result[1, 2], 5); } /// @@ -1605,12 +1605,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 6); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 6); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 4); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 4); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 5); } /// @@ -1632,10 +1632,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } /// @@ -1662,12 +1662,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mx = new DenseMatrix(matrix.ColumnCount, 2, x); var mb = matrix*mx; - AssertHelpers.AlmostEqual(mb[0, 0], b[0], 6); - AssertHelpers.AlmostEqual(mb[1, 0], b[1], 6); - AssertHelpers.AlmostEqual(mb[2, 0], b[2], 5); - AssertHelpers.AlmostEqual(mb[0, 1], b[3], 5); - AssertHelpers.AlmostEqual(mb[1, 1], b[4], 5); - AssertHelpers.AlmostEqual(mb[2, 1], b[5], 5); + AssertHelpers.AlmostEqualRelative(mb[0, 0], b[0], 5); + AssertHelpers.AlmostEqualRelative(mb[1, 0], b[1], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 0], b[2], 4); + AssertHelpers.AlmostEqualRelative(mb[0, 1], b[3], 4); + AssertHelpers.AlmostEqualRelative(mb[1, 1], b[4], 5); + AssertHelpers.AlmostEqualRelative(mb[2, 1], b[5], 5); } /// @@ -1694,10 +1694,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single var mb = new DenseMatrix(matrix.RowCount, 2, b); var test = (matrix.Transpose()*matrix).Inverse()*matrix.Transpose()*mb; - AssertHelpers.AlmostEqual(test[0, 0], x[0], 6); - AssertHelpers.AlmostEqual(test[1, 0], x[1], 6); - AssertHelpers.AlmostEqual(test[0, 1], x[2], 6); - AssertHelpers.AlmostEqual(test[1, 1], x[3], 6); + AssertHelpers.AlmostEqualRelative(test[0, 0], x[0], 5); + AssertHelpers.AlmostEqualRelative(test[1, 0], x[1], 5); + AssertHelpers.AlmostEqualRelative(test[0, 1], x[2], 5); + AssertHelpers.AlmostEqualRelative(test[1, 1], x[3], 5); } [TestCase("Wide10x50000", "Tall50000x10")] diff --git a/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorTests.cs index 0cb3f4ee..fe342e98 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorTests.cs @@ -298,13 +298,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex(2.0, 1), vector[i], 14); } vector = vector/1.0; for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex(2.0, 1), vector[i], 14); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs index cdcad687..fc265c89 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs @@ -226,7 +226,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); } } } @@ -284,15 +284,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); } /// @@ -302,15 +302,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); } /// @@ -320,15 +320,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); } /// @@ -338,15 +338,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); } /// @@ -357,11 +357,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); matrix = TestMatrices["Square4x4"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Square4x4"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs index ab55e25f..06bfde90 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs @@ -136,7 +136,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixXfromC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixX[i, j], matrixXfromC[i, j], 8); + AssertHelpers.AlmostEqualRelative(matrixX[i, j], matrixXfromC[i, j], 8); } } } @@ -166,7 +166,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(matrixB[i], matrixBReconstruct[i], 8); + AssertHelpers.AlmostEqual(matrixB[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -208,7 +208,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -249,7 +249,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(matrixB[i], matrixBReconstruct[i], 8); + AssertHelpers.AlmostEqual(matrixB[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -299,7 +299,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs index cc71a1f8..92526c37 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs @@ -97,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixAv.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixAv[i, j], matrixLv[i, j], 7); + AssertHelpers.AlmostEqualRelative(matrixAv[i, j], matrixLv[i, j], 7); } } } @@ -133,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix[i, j], matrixA[i, j], 7); + AssertHelpers.AlmostEqualRelative(matrix[i, j], matrixA[i, j], 7); } } } @@ -221,7 +221,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 7); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -268,7 +268,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -309,7 +309,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 7); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -365,7 +365,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs index e72836b5..70da2c43 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs @@ -157,7 +157,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } @@ -169,11 +169,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { if (i == j) { - AssertHelpers.AlmostEqual(matrixQсtQ[i, j], Complex.One, 9); + AssertHelpers.AlmostEqualRelative(matrixQсtQ[i, j], Complex.One, 9); } else { - AssertHelpers.AlmostEqual(matrixQсtQ[i, j], Complex.Zero, 9); + AssertHelpers.AlmostEqualRelative(matrixQсtQ[i, j], Complex.Zero, 9); } } } @@ -205,7 +205,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -250,7 +250,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -291,7 +291,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -345,7 +345,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -393,7 +393,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 12); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 12); } } @@ -427,7 +427,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 12); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 12); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/LUTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/LUTests.cs index a0b6e241..e4c9bc27 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/LUTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/LUTests.cs @@ -152,7 +152,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixXfromLU.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixX[i, j], matrixXfromLU[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixX[i, j], matrixXfromLU[i, j], 9); } } } @@ -183,7 +183,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -228,7 +228,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -269,7 +269,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -323,7 +323,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -382,7 +382,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check if multiplication of A and AI produced identity matrix. for (var i = 0; i < matrixIdentity.RowCount; i++) { - AssertHelpers.AlmostEqual(matrixIdentity[i, i], Complex.One, 9); + AssertHelpers.AlmostEqualRelative(matrixIdentity[i, i], Complex.One, 9); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs index eb579144..21ac2793 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs @@ -174,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } @@ -242,7 +242,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } @@ -292,7 +292,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -337,7 +337,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -378,7 +378,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -432,7 +432,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -481,7 +481,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -526,7 +526,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -567,7 +567,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -621,7 +621,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -671,7 +671,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 12); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 12); } } @@ -707,7 +707,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 9); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 9); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs index 6eb2b4fb..abff8f0f 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs @@ -111,7 +111,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrix[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrix[i, j], 9); } } } @@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -283,7 +283,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -323,7 +323,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -378,7 +378,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs index b44e2785..4d3286b2 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs @@ -135,7 +135,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixXfromC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixX[i, j], matrixXfromC[i, j], 8); + AssertHelpers.AlmostEqualRelative(matrixX[i, j], matrixXfromC[i, j], 8); } } } @@ -165,7 +165,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(b[i], matrixBReconstruct[i], 8); + AssertHelpers.AlmostEqual(b[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -207,7 +207,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 8); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -248,7 +248,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(b[i], matrixBReconstruct[i], 8); + AssertHelpers.AlmostEqual(b[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -298,7 +298,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 8); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs index f4380ebc..fbe64015 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://numerics.mathdotnet.com // http://github.com/mathnet/mathnet-numerics @@ -97,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixAv.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixAv[i, j], matrixLv[i, j], 7); + AssertHelpers.AlmostEqualRelative(matrixAv[i, j], matrixLv[i, j], 7); } } } @@ -132,7 +132,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix[i, j], matrixA[i, j], 7); + AssertHelpers.AlmostEqualRelative(matrix[i, j], matrixA[i, j], 7); } } } @@ -218,7 +218,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 7); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -263,7 +263,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -302,7 +302,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 7); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -356,7 +356,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 7); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs index ed133826..6b9bf761 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs @@ -156,7 +156,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } @@ -168,11 +168,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { if (i == j) { - AssertHelpers.AlmostEqual(matrixQсtQ[i, j], Complex.One, 9); + AssertHelpers.AlmostEqualRelative(matrixQсtQ[i, j], Complex.One, 9); } else { - AssertHelpers.AlmostEqual(matrixQсtQ[i, j], Complex.Zero, 9); + AssertHelpers.AlmostEqualRelative(matrixQсtQ[i, j], Complex.Zero, 9); } } } @@ -204,7 +204,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -249,7 +249,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -290,7 +290,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -344,7 +344,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserLUTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserLUTests.cs index 95692113..2d5c2274 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserLUTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserLUTests.cs @@ -151,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixXfromLU.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixX[i, j], matrixXfromLU[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixX[i, j], matrixXfromLU[i, j], 9); } } } @@ -182,7 +182,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -227,7 +227,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -268,7 +268,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -322,7 +322,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -381,7 +381,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check if multiplication of A and AI produced identity matrix. for (var i = 0; i < matrixIdentity.RowCount; i++) { - AssertHelpers.AlmostEqual(matrixIdentity[i, i], Complex.One, 9); + AssertHelpers.AlmostEqualRelative(matrixIdentity[i, i], Complex.One, 9); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs index 0746e26d..fedc66c5 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs @@ -174,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } } @@ -223,7 +223,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixQfromR.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrixQfromR[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrixQfromR[i, j], 9); } } } @@ -254,7 +254,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -299,7 +299,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -340,7 +340,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -394,7 +394,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -443,7 +443,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -488,7 +488,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -529,7 +529,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -583,7 +583,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs index 25446922..55ed360e 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs @@ -110,7 +110,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA[i, j], matrix[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixA[i, j], matrix[i, j], 9); } } } @@ -236,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -282,7 +282,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } @@ -322,7 +322,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10); } // Make sure A didn't change. @@ -377,7 +377,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 10); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.Arithmetic.cs index ca8923b5..2d450e16 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.Arithmetic.cs @@ -429,7 +429,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -455,7 +455,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -489,7 +489,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -527,7 +527,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -567,7 +567,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -666,7 +666,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -704,7 +704,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -843,7 +843,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex for (var j = 0; j < result.ColumnCount; j++) { var col = result.Column(j); - AssertHelpers.AlmostEqual(Complex.One, col.Norm(p), 12); + AssertHelpers.AlmostEqualRelative(Complex.One, col.Norm(p), 12); } } @@ -868,7 +868,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex for (var i = 0; i < matrix.RowCount; i++) { var row = matrix.Row(i); - AssertHelpers.AlmostEqual(Complex.One, row.Norm(p), 12); + AssertHelpers.AlmostEqualRelative(Complex.One, row.Norm(p), 12); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs index b352dceb..039435c4 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs @@ -92,13 +92,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public virtual void CanComputeFrobeniusNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(11.1427106217473, matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(11.1427106217473, matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.29055762656452, matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(5.29055762656452, matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.86574853399217, matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(7.86574853399217, matrix.FrobeniusNorm(), 14); } /// @@ -108,13 +108,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public virtual void CanComputeInfinityNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(16.7777033201323, matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(16.7777033201323, matrix.InfinityNorm(), 14); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(7.3514039993641, matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(7.3514039993641, matrix.InfinityNorm(), 14); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(10.1023756128209, matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(10.1023756128209, matrix.InfinityNorm(), 14); } /// @@ -124,13 +124,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public virtual void CanComputeL1Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(12.5401248319437, matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(12.5401248319437, matrix.L1Norm(), 14); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.86479712463225, matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(5.86479712463225, matrix.L1Norm(), 14); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(9.49338601320024, matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(9.49338601320024, matrix.L1Norm(), 14); } /// @@ -140,12 +140,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public virtual void CanComputeL2Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.638175225153, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(10.638175225153, matrix.L2Norm(), 14); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.2058554445283, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(5.2058554445283, matrix.L2Norm(), 14); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.35826643761172, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(7.35826643761172, matrix.L2Norm(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs index 95104328..38fe0eea 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs @@ -76,8 +76,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs index 383bb537..03689e2c 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs @@ -188,8 +188,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } @@ -266,7 +266,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi { for (var j = i + 1; j < l.RowCount; j++) { - Assert.IsTrue(0.0.AlmostEqual(l[i, j].Magnitude, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(l[i, j].Magnitude, -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } @@ -277,7 +277,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi { for (var j = 0; j < i; j++) { - Assert.IsTrue(0.0.AlmostEqual(u[i, j].Magnitude, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(u[i, j].Magnitude, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } @@ -286,8 +286,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#03-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#04-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#03-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#04-" + i + "-" + j); } } } @@ -330,8 +330,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs index db6f37d2..501a5f43 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs @@ -119,8 +119,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } @@ -148,8 +148,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorTest.cs index 421c17bd..7b7d4d8a 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorTest.cs @@ -219,13 +219,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex(2.0, 1), vector[i], 14); } vector = vector/1.0; for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex(2.0, 1), vector[i], 14); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.Norm.cs b/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.Norm.cs index c37926b3..3bf9bf35 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.Norm.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.Norm.cs @@ -46,8 +46,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public void CanComputeNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(7.74596669241483, vector.L2Norm(), 15); - AssertHelpers.AlmostEqual(7.74596669241483, vector.Norm(2), 15); + AssertHelpers.AlmostEqualRelative(7.74596669241483, vector.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(7.74596669241483, vector.Norm(2), 14); } /// @@ -57,8 +57,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public void CanComputeNorm1() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(16.0346843392517, vector.L1Norm(), 15); - AssertHelpers.AlmostEqual(16.0346843392517, vector.Norm(1), 15); + AssertHelpers.AlmostEqualRelative(16.0346843392517, vector.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(16.0346843392517, vector.Norm(1), 14); } /// @@ -68,8 +68,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public void CanComputeSquareNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(60.0, vector.L2Norm() * vector.L2Norm(), 15); - AssertHelpers.AlmostEqual(60.0, vector.Norm(2) * vector.Norm(2), 15); + AssertHelpers.AlmostEqualRelative(60.0, vector.L2Norm() * vector.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(60.0, vector.Norm(2) * vector.Norm(2), 14); } /// @@ -84,7 +84,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public void CanComputeNormP(int p, double expected) { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(expected, vector.Norm(p), 15); + AssertHelpers.AlmostEqualRelative(expected, vector.Norm(p), 14); } /// @@ -94,8 +94,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public void CanComputeNormInfinity() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(5.09901951359279, vector.InfinityNorm(), 14); - AssertHelpers.AlmostEqual(5.09901951359279, vector.Norm(double.PositiveInfinity), 14); + AssertHelpers.AlmostEqualRelative(5.09901951359279, vector.InfinityNorm(), 13); + AssertHelpers.AlmostEqualRelative(5.09901951359279, vector.Norm(double.PositiveInfinity), 13); } /// @@ -106,11 +106,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex { var vector = CreateVector(Data); var result = vector.Normalize(2); - AssertHelpers.AlmostEqual(new Complex(0.129099444873581, 0.129099444873581), result[0], 14); - AssertHelpers.AlmostEqual(new Complex(0.258198889747161, 0.129099444873581), result[1], 14); - AssertHelpers.AlmostEqual(new Complex(0.387298334620742, 0.129099444873581), result[2], 14); - AssertHelpers.AlmostEqual(new Complex(0.516397779494322, 0.129099444873581), result[3], 14); - AssertHelpers.AlmostEqual(new Complex(0.645497224367903, 0.129099444873581), result[4], 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.129099444873581, 0.129099444873581), result[0], 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.258198889747161, 0.129099444873581), result[1], 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.387298334620742, 0.129099444873581), result[2], 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.516397779494322, 0.129099444873581), result[3], 14); + AssertHelpers.AlmostEqualRelative(new Complex(0.645497224367903, 0.129099444873581), result[4], 14); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs index f0b149dc..264c018f 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs @@ -107,11 +107,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex vector.CopySubVectorTo(other, 2, 2, 2); - AssertHelpers.AreEqual(Complex.Zero, other[0]); - AssertHelpers.AreEqual(Complex.Zero, other[1]); - AssertHelpers.AreEqual(new Complex(3, 1), other[2]); - AssertHelpers.AreEqual(new Complex(4, 1), other[3]); - AssertHelpers.AreEqual(Complex.Zero, other[4]); + AssertHelpers.AlmostEqual(Complex.Zero, other[0]); + AssertHelpers.AlmostEqual(Complex.Zero, other[1]); + AssertHelpers.AlmostEqual(new Complex(3, 1), other[2]); + AssertHelpers.AlmostEqual(new Complex(4, 1), other[3]); + AssertHelpers.AlmostEqual(Complex.Zero, other[4]); } /// @@ -123,11 +123,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex var vector = CreateVector(Data); vector.CopySubVectorTo(vector, 0, 2, 2); - AssertHelpers.AreEqual(new Complex(1, 1), vector[0]); - AssertHelpers.AreEqual(new Complex(2, 1), vector[1]); - AssertHelpers.AreEqual(new Complex(1, 1), vector[2]); - AssertHelpers.AreEqual(new Complex(2, 1), vector[3]); - AssertHelpers.AreEqual(new Complex(5, 1), vector[4]); + AssertHelpers.AlmostEqual(new Complex(1, 1), vector[0]); + AssertHelpers.AlmostEqual(new Complex(2, 1), vector[1]); + AssertHelpers.AlmostEqual(new Complex(1, 1), vector[2]); + AssertHelpers.AlmostEqual(new Complex(2, 1), vector[3]); + AssertHelpers.AlmostEqual(new Complex(5, 1), vector[4]); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorTests.cs index b8340c2a..542aed16 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorTests.cs @@ -294,13 +294,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } vector = vector/1.0f; for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs index 6b0c4dbc..1e3058e3 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs @@ -222,7 +222,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); } } } @@ -280,15 +280,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); } /// @@ -298,15 +298,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); } /// @@ -316,15 +316,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); } /// @@ -334,15 +334,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); } /// @@ -353,11 +353,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); matrix = TestMatrices["Square4x4"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Square4x4"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs index 7b78ea87..a729d164 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs @@ -131,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix[i, j], matrixA[i, j], 3); + AssertHelpers.AlmostEqualRelative(matrix[i, j], matrixA[i, j], 3); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs index 92e00cfb..99e358df 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs @@ -396,7 +396,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 6); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 6); } } @@ -430,7 +430,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 6); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 6); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs index 58096ce3..d3817b2f 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs @@ -484,7 +484,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 3); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 3); } // Make sure A didn't change. @@ -571,7 +571,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 3); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 3); } // Make sure A didn't change. @@ -676,7 +676,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 6); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 6); } } @@ -712,7 +712,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqual(test[i], vectorX[i], 4); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 6); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.Arithmetic.cs index 16e9609f..98aecf1e 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.Arithmetic.cs @@ -425,7 +425,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -451,7 +451,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -485,7 +485,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -523,7 +523,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -563,7 +563,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -584,7 +584,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var ar = matrix.Column(j); var dot = ar * x; - AssertHelpers.AlmostEqual(dot, y[j], 6); + AssertHelpers.AlmostEqualRelative(dot, y[j], 6); } } @@ -603,7 +603,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var ar = matrix.Column(j); var dot = ar * x; - AssertHelpers.AlmostEqual(dot, y[j], 6); + AssertHelpers.AlmostEqualRelative(dot, y[j], 6); } } @@ -625,7 +625,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var ar = matrix.Column(j); var dot = ar * y; - AssertHelpers.AlmostEqual(dot, x[j], 6); + AssertHelpers.AlmostEqualRelative(dot, x[j], 6); } } @@ -662,7 +662,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -700,7 +700,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -839,7 +839,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 for (var j = 0; j < result.ColumnCount; j++) { var col = result.Column(j); - AssertHelpers.AlmostEqual(1d, col.Norm(p), 6); + AssertHelpers.AlmostEqualRelative(1d, col.Norm(p), 6); } } @@ -864,7 +864,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 for (var i = 0; i < matrix.RowCount; i++) { var row = matrix.Row(i); - AssertHelpers.AlmostEqual(1d, row.Norm(p), 6); + AssertHelpers.AlmostEqualRelative(1d, row.Norm(p), 6); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs index d17093e0..011394dc 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs @@ -92,13 +92,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public virtual void CanComputeFrobeniusNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(11.1427106217473f, matrix.FrobeniusNorm().Real, 7); + AssertHelpers.AlmostEqualRelative(11.1427106217473f, matrix.FrobeniusNorm().Real, 6); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.29055762656452f, matrix.FrobeniusNorm().Real, 6); + AssertHelpers.AlmostEqualRelative(5.29055762656452f, matrix.FrobeniusNorm().Real, 6); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.86574853399217, matrix.FrobeniusNorm().Real, 7); + AssertHelpers.AlmostEqualRelative(7.86574853399217, matrix.FrobeniusNorm().Real, 6); } /// @@ -108,13 +108,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public virtual void CanComputeInfinityNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(16.7777033f, matrix.InfinityNorm().Real, 6); + AssertHelpers.AlmostEqualRelative(16.7777033f, matrix.InfinityNorm().Real, 6); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(7.3514039f, matrix.InfinityNorm().Real, 6); + AssertHelpers.AlmostEqualRelative(7.3514039f, matrix.InfinityNorm().Real, 6); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(10.1023756f, matrix.InfinityNorm().Real, 6); + AssertHelpers.AlmostEqualRelative(10.1023756f, matrix.InfinityNorm().Real, 6); } /// @@ -124,13 +124,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public virtual void CanComputeL1Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(12.5401248f, matrix.L1Norm().Real, 7); + AssertHelpers.AlmostEqualRelative(12.5401248f, matrix.L1Norm().Real, 7); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.8647971f, matrix.L1Norm().Real, 7); + AssertHelpers.AlmostEqualRelative(5.8647971f, matrix.L1Norm().Real, 7); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(9.4933860f, matrix.L1Norm().Real, 7); + AssertHelpers.AlmostEqualRelative(9.4933860f, matrix.L1Norm().Real, 7); } /// @@ -140,12 +140,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public virtual void CanComputeL2Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.6381752f, matrix.L2Norm().Real, 6); + AssertHelpers.AlmostEqualRelative(10.6381752f, matrix.L2Norm().Real, 6); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(5.2058554f, matrix.L2Norm().Real, 6); + AssertHelpers.AlmostEqualRelative(5.2058554f, matrix.L2Norm().Real, 6); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.3582664f, matrix.L2Norm().Real, 6); + AssertHelpers.AlmostEqualRelative(7.3582664f, matrix.L2Norm().Real, 6); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs index 87536c57..079f5493 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs @@ -70,8 +70,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs index d3e30a61..8df2f8a7 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs @@ -183,8 +183,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } @@ -261,7 +261,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon { for (var j = i + 1; j < l.RowCount; j++) { - Assert.IsTrue(0.0.AlmostEqual(l[i, j].Magnitude, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(l[i, j].Magnitude, -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } @@ -272,7 +272,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon { for (var j = 0; j < i; j++) { - Assert.IsTrue(0.0.AlmostEqual(u[i, j].Magnitude, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(u[i, j].Magnitude, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } @@ -281,8 +281,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#03-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#04-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#03-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#04-" + i + "-" + j); } } } @@ -325,8 +325,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs index d7a7d90a..b9fb8197 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs @@ -114,8 +114,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].Real.AlmostEqual(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); - Assert.IsTrue(vector[i].Imaginary.AlmostEqual(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); + Assert.IsTrue(vector[i].Real.AlmostEqualNumbersBetween(product[i].Real, -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].Imaginary.AlmostEqualNumbersBetween(product[i].Imaginary, -Epsilon.Magnitude()), "#03-" + i); } } @@ -142,8 +142,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqual(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); - Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqual(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Real.AlmostEqualNumbersBetween(original[i, j].Real, -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].Imaginary.AlmostEqualNumbersBetween(original[i, j].Imaginary, -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorTest.cs index b6516615..ad20d01a 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorTest.cs @@ -215,13 +215,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } vector = vector/1.0f; for (var i = 0; i < Data.Length; i++) { - AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7); + AssertHelpers.AlmostEqualRelative(Data[i]/new Complex32(2.0f, 1), vector[i], 6); } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.Norm.cs b/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.Norm.cs index e2e523b9..ad7800e3 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.Norm.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.Norm.cs @@ -42,8 +42,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public void CanComputeNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(7.745966692414833770f, vector.L2Norm(), 6); - AssertHelpers.AlmostEqual(7.745966692414833770f, vector.Norm(2), 6); + AssertHelpers.AlmostEqualRelative(7.745966692414833770f, vector.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(7.745966692414833770f, vector.Norm(2), 6); } /// @@ -53,8 +53,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public void CanComputeNorm1() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(16.0346843392517094570f, vector.L1Norm(), 7); - AssertHelpers.AlmostEqual(16.0346843392517094570f, vector.Norm(1), 7); + AssertHelpers.AlmostEqualRelative(16.0346843392517094570f, vector.L1Norm(), 6); + AssertHelpers.AlmostEqualRelative(16.0346843392517094570f, vector.Norm(1), 6); } /// @@ -64,8 +64,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public void CanComputeSquareNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(60f, vector.L2Norm() * vector.L2Norm(), 6); - AssertHelpers.AlmostEqual(60f, vector.Norm(2) * vector.Norm(2), 6); + AssertHelpers.AlmostEqualRelative(60f, vector.L2Norm() * vector.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(60f, vector.Norm(2) * vector.Norm(2), 6); } /// @@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public void CanComputeNormP(int p, float expected) { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(expected, (float) vector.Norm(p), 5); + AssertHelpers.AlmostEqualRelative(expected, (float) vector.Norm(p), 5); } /// @@ -90,8 +90,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public void CanComputeNormInfinity() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(5.0990195, vector.InfinityNorm(), 7); - AssertHelpers.AlmostEqual(5.0990195, vector.Norm(Single.PositiveInfinity), 7); + AssertHelpers.AlmostEqualRelative(5.0990195, vector.InfinityNorm(), 6); + AssertHelpers.AlmostEqualRelative(5.0990195, vector.Norm(Single.PositiveInfinity), 6); } /// @@ -102,11 +102,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 { var vector = CreateVector(Data); var result = vector.Normalize(2); - AssertHelpers.AlmostEqual(new Complex32(0.12909944f, 0.12909944f), result[0], 7); - AssertHelpers.AlmostEqual(new Complex32(0.25819888f, 0.12909944f), result[1], 7); - AssertHelpers.AlmostEqual(new Complex32(0.38729833f, 0.12909944f), result[2], 7); - AssertHelpers.AlmostEqual(new Complex32(0.51639777f, 0.12909944f), result[3], 7); - AssertHelpers.AlmostEqual(new Complex32(0.64549722f, 0.12909944f), result[4], 7); + AssertHelpers.AlmostEqualRelative(new Complex32(0.12909944f, 0.12909944f), result[0], 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.25819888f, 0.12909944f), result[1], 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.38729833f, 0.12909944f), result[2], 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.51639777f, 0.12909944f), result[3], 6); + AssertHelpers.AlmostEqualRelative(new Complex32(0.64549722f, 0.12909944f), result[4], 6); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs index 049dfbe3..b47d5a49 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs @@ -103,11 +103,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 vector.CopySubVectorTo(other, 2, 2, 2); - AssertHelpers.AreEqual(Complex32.Zero, other[0]); - AssertHelpers.AreEqual(Complex32.Zero, other[1]); - AssertHelpers.AreEqual(new Complex32(3, 1), other[2]); - AssertHelpers.AreEqual(new Complex32(4, 1), other[3]); - AssertHelpers.AreEqual(Complex32.Zero, other[4]); + AssertHelpers.AlmostEqual(Complex32.Zero, other[0]); + AssertHelpers.AlmostEqual(Complex32.Zero, other[1]); + AssertHelpers.AlmostEqual(new Complex32(3, 1), other[2]); + AssertHelpers.AlmostEqual(new Complex32(4, 1), other[3]); + AssertHelpers.AlmostEqual(Complex32.Zero, other[4]); } /// @@ -119,11 +119,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 var vector = CreateVector(Data); vector.CopySubVectorTo(vector, 0, 2, 2); - AssertHelpers.AreEqual(new Complex32(1, 1), vector[0]); - AssertHelpers.AreEqual(new Complex32(2, 1), vector[1]); - AssertHelpers.AreEqual(new Complex32(1, 1), vector[2]); - AssertHelpers.AreEqual(new Complex32(2, 1), vector[3]); - AssertHelpers.AreEqual(new Complex32(5, 1), vector[4]); + AssertHelpers.AlmostEqual(new Complex32(1, 1), vector[0]); + AssertHelpers.AlmostEqual(new Complex32(2, 1), vector[1]); + AssertHelpers.AlmostEqual(new Complex32(1, 1), vector[2]); + AssertHelpers.AlmostEqual(new Complex32(2, 1), vector[3]); + AssertHelpers.AlmostEqual(new Complex32(5, 1), vector[4]); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTest.TextHandling.cs b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTest.TextHandling.cs index b6648ee8..61417d5f 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTest.TextHandling.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTest.TextHandling.cs @@ -121,11 +121,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double DenseVector vector; var ret = DenseVector.TryParse(text, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, (double[])vector, 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, (double[])vector, 14); ret = DenseVector.TryParse(text, CultureInfo.CurrentCulture, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, (double[])vector, 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, (double[])vector, 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs index 85ab8dc0..171cfe35 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs @@ -220,7 +220,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); } } } @@ -278,15 +278,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); } /// @@ -296,15 +296,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); } /// @@ -314,15 +314,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14); } /// @@ -332,15 +332,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14); } /// @@ -351,11 +351,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); matrix = TestMatrices["Square4x4"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Square4x4"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs index cbcdb2b8..51cb712d 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs @@ -370,7 +370,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 12); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 12); } } @@ -404,7 +404,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 12); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 12); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs index 8c695804..2f3f905c 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs @@ -471,7 +471,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 9); } // Make sure A didn't change. @@ -516,7 +516,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixB[i, j], matrixBReconstruct[i, j], 9); } } @@ -557,7 +557,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 9); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 9); } // Make sure A didn't change. @@ -611,7 +611,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { for (var j = 0; j < matrixB.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixB[i, j], matrixBReconstruct[i, j], 9); + AssertHelpers.AlmostEqualRelative(matrixB[i, j], matrixBReconstruct[i, j], 9); } } @@ -661,7 +661,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 12); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 12); } } @@ -697,7 +697,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqual(test[i], vectorX[i], 9); + AssertHelpers.AlmostEqualRelative(test[i], vectorX[i], 9); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs index 0ecda380..39e8b59f 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs @@ -419,7 +419,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -445,7 +445,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -479,7 +479,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -517,7 +517,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15); } } } @@ -557,7 +557,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -656,7 +656,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -694,7 +694,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 15); } } } @@ -1021,7 +1021,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2, mod[row, column], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2, mod[row, column], 14); } } } @@ -1040,7 +1040,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2, mod[row, column], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2, mod[row, column], 14); } } } @@ -1059,7 +1059,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(data[row, column] % 3.2, matrix[row, column], 14); + AssertHelpers.AlmostEqualRelative(data[row, column] % 3.2, matrix[row, column], 14); } } } @@ -1076,7 +1076,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2, mod[row, column], 14); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2, mod[row, column], 14); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs index 94edad1f..105e918f 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs @@ -66,13 +66,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public virtual void CanComputeFrobeniusNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.77775486824598, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(10.77775486824598, matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(4.79478883789474, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(4.79478883789474, matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.54122006044115, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(7.54122006044115, matrix.FrobeniusNorm(), 7); } /// @@ -114,12 +114,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public virtual void CanComputeL2Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.391347375312632, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(10.391347375312632, matrix.L2Norm(), 14); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(4.7540849434107635, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(4.7540849434107635, matrix.L2Norm(), 14); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.182727033856683, matrix.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(7.182727033856683, matrix.L2Norm(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs index 1c8b3032..a0617abb 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs @@ -68,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs index 70873a67..2379c634 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs @@ -181,7 +181,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } @@ -258,7 +258,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit { for (var j = i + 1; j < l.RowCount; j++) { - Assert.IsTrue(0.0.AlmostEqual(l[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(l[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } @@ -269,7 +269,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit { for (var j = 0; j < i; j++) { - Assert.IsTrue(0.0.AlmostEqual(u[i, j], -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(u[i, j], -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } @@ -278,7 +278,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#03-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].AlmostEqualNumbersBetween(original[i, j], -Epsilon.Magnitude()), "#03-" + i + "-" + j); } } } @@ -321,7 +321,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].AlmostEqualNumbersBetween(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs index 7cf086c8..a0de16eb 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs @@ -112,7 +112,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(vector[i].AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } @@ -139,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(sparseMatrix[i, j].AlmostEqualNumbersBetween(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.TextHandling.cs b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.TextHandling.cs index 8da4eb1c..04858361 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.TextHandling.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.TextHandling.cs @@ -120,11 +120,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double SparseVector vector; var ret = SparseVector.TryParse(text, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, vector.ToArray(), 14); ret = SparseVector.TryParse(text, CultureInfo.CurrentCulture, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, vector.ToArray(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Arithmetic.cs index 8c1f344c..04751103 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Arithmetic.cs @@ -800,7 +800,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double var mod = vector.Modulus(3.2); for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 14); + AssertHelpers.AlmostEqualRelative(Data[index] % 3.2, mod[index], 14); } } @@ -816,7 +816,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 14); + AssertHelpers.AlmostEqualRelative(Data[index] % 3.2, mod[index], 14); } } @@ -831,7 +831,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, vector[index], 14); + AssertHelpers.AlmostEqualRelative(Data[index] % 3.2, vector[index], 14); } } @@ -845,7 +845,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double var mod = vector % 4.5; for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 4.5, mod[index], 14); + AssertHelpers.AlmostEqualRelative(Data[index] % 4.5, mod[index], 14); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Norm.cs b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Norm.cs index b6276e2a..bbd3ffee 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Norm.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.Norm.cs @@ -41,8 +41,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public void CanComputeNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(7.416198487095663, vector.L2Norm(), 15); - AssertHelpers.AlmostEqual(7.416198487095663, vector.Norm(2), 15); + AssertHelpers.AlmostEqualRelative(7.416198487095663, vector.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(7.416198487095663, vector.Norm(2), 14); } /// @@ -52,8 +52,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public void CanComputeNorm1() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(15.0, vector.L1Norm(), 15); - AssertHelpers.AlmostEqual(15.0, vector.Norm(1), 15); + AssertHelpers.AlmostEqualRelative(15.0, vector.L1Norm(), 14); + AssertHelpers.AlmostEqualRelative(15.0, vector.Norm(1), 14); } /// @@ -63,8 +63,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public void CanComputeSquareNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(55.0, vector.L2Norm() * vector.L2Norm(), 15); - AssertHelpers.AlmostEqual(55.0, vector.Norm(2) * vector.Norm(2), 15); + AssertHelpers.AlmostEqualRelative(55.0, vector.L2Norm() * vector.L2Norm(), 14); + AssertHelpers.AlmostEqualRelative(55.0, vector.Norm(2) * vector.Norm(2), 14); } /// @@ -79,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public void CanComputeNormP(int p, double expected) { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(expected, vector.Norm(p), 15); + AssertHelpers.AlmostEqualRelative(expected, vector.Norm(p), 14); } /// @@ -89,8 +89,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public void CanComputeNormInfinity() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(5.0, vector.InfinityNorm(), 15); - AssertHelpers.AlmostEqual(5.0, vector.Norm(Double.PositiveInfinity), 15); + AssertHelpers.AlmostEqualRelative(5.0, vector.InfinityNorm(), 14); + AssertHelpers.AlmostEqualRelative(5.0, vector.Norm(Double.PositiveInfinity), 14); } /// @@ -101,11 +101,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double { var vector = CreateVector(Data); var result = vector.Normalize(2); - AssertHelpers.AlmostEqual(0.134839972492648, result[0], 14); - AssertHelpers.AlmostEqual(0.269679944985297, result[1], 14); - AssertHelpers.AlmostEqual(0.404519917477945, result[2], 14); - AssertHelpers.AlmostEqual(0.539359889970594, result[3], 14); - AssertHelpers.AlmostEqual(0.674199862463242, result[4], 14); + AssertHelpers.AlmostEqualRelative(0.134839972492648, result[0], 14); + AssertHelpers.AlmostEqualRelative(0.269679944985297, result[1], 14); + AssertHelpers.AlmostEqualRelative(0.404519917477945, result[2], 14); + AssertHelpers.AlmostEqualRelative(0.539359889970594, result[3], 14); + AssertHelpers.AlmostEqualRelative(0.674199862463242, result[4], 14); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/DenseVectorTest.TextHandling.cs b/src/UnitTests/LinearAlgebraTests/Single/DenseVectorTest.TextHandling.cs index 1e03e2c3..889a8432 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/DenseVectorTest.TextHandling.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/DenseVectorTest.TextHandling.cs @@ -121,11 +121,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single DenseVector vector; var ret = DenseVector.TryParse(text, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, (float[])vector, 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, (float[])vector, 14); ret = DenseVector.TryParse(text, CultureInfo.CurrentCulture, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, (float[])vector, 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, (float[])vector, 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs index 6281e7a2..26ae0809 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs @@ -220,7 +220,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i)*matrixB.Column(j), matrixC[i, j], 15); } } } @@ -278,15 +278,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 7); } /// @@ -296,15 +296,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 7); } /// @@ -314,15 +314,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 7); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 7); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 7); } /// @@ -332,15 +332,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 7); matrix = TestMatrices["Wide2x3"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 7); matrix = TestMatrices["Tall3x2"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]); - AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 7); } /// @@ -351,11 +351,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { var matrix = TestMatrices["Square3x3"]; var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 7); matrix = TestMatrices["Square4x4"]; denseMatrix = DenseMatrix.OfArray(TestData2D["Square4x4"]); - AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 7); + AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 7); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs index f6bc5739..b98a1273 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs @@ -370,7 +370,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 6); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 6); } } @@ -404,7 +404,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 6); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 6); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs index 4a2e2bbf..78429ec7 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs @@ -472,7 +472,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization // Check the reconstruction. for (var i = 0; i < order; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 3); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 3); } // Make sure A didn't change. @@ -558,7 +558,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization // Check the reconstruction. for (var i = 0; i < vectorb.Count; i++) { - AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 3); + AssertHelpers.AlmostEqualRelative(vectorb[i], matrixBReconstruct[i], 3); } // Make sure A didn't change. @@ -662,7 +662,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { for (var j = 0; j < matrixX.ColumnCount; j++) { - AssertHelpers.AlmostEqualAbsolute(test[i, j], matrixX[i, j], 6); + AssertHelpers.AlmostEqual(test[i, j], matrixX[i, j], 6); } } @@ -698,7 +698,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization for (var i = 0; i < vectorX.Count; i++) { - AssertHelpers.AlmostEqualAbsolute(test[i], vectorX[i], 6); + AssertHelpers.AlmostEqual(test[i], vectorX[i], 6); } // Make sure A didn't change. diff --git a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.Arithmetic.cs index 7358a313..bb4e35e8 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.Arithmetic.cs @@ -419,7 +419,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -445,7 +445,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -479,7 +479,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -517,7 +517,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 6); } } } @@ -557,7 +557,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -576,7 +576,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix.Column(j) * x, y[j], 6); + AssertHelpers.AlmostEqualRelative(matrix.Column(j) * x, y[j], 6); } } @@ -593,7 +593,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix.Column(j) * x, y[j], 6); + AssertHelpers.AlmostEqualRelative(matrix.Column(j) * x, y[j], 6); } } @@ -613,7 +613,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single y = new DenseVector(new[] { 1.0f, 2.0f, 3.0f }); for (var j = 0; j < matrix.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrix.Column(j) * y, x[j], 6); + AssertHelpers.AlmostEqualRelative(matrix.Column(j) * y, x[j], 6); } } @@ -650,7 +650,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -688,7 +688,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var j = 0; j < matrixC.ColumnCount; j++) { - AssertHelpers.AlmostEqual(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); + AssertHelpers.AlmostEqualRelative(matrixA.Column(i) * matrixB.Column(j), matrixC[i, j], 6); } } } @@ -1015,7 +1015,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2f, mod[row, column], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2f, mod[row, column], 6); } } } @@ -1034,7 +1034,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2f, mod[row, column], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2f, mod[row, column], 6); } } } @@ -1053,7 +1053,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(data[row, column] % 3.2f, matrix[row, column], 6); + AssertHelpers.AlmostEqualRelative(data[row, column] % 3.2f, matrix[row, column], 6); } } } @@ -1070,7 +1070,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single { for (var column = 0; column < matrix.ColumnCount; column++) { - AssertHelpers.AlmostEqual(matrix[row, column] % 3.2f, mod[row, column], 6); + AssertHelpers.AlmostEqualRelative(matrix[row, column] % 3.2f, mod[row, column], 6); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs index e229e022..1f1aeb09 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs @@ -66,13 +66,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public virtual void CanComputeFrobeniusNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.77775486824598f, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(10.77775486824598f, matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(4.79478883789474f, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(4.79478883789474f, matrix.FrobeniusNorm(), 7); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.54122006044115f, matrix.FrobeniusNorm(), 7); + AssertHelpers.AlmostEqualRelative(7.54122006044115f, matrix.FrobeniusNorm(), 7); } /// @@ -82,13 +82,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public virtual void CanComputeInfinityNorm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(16.5f, matrix.InfinityNorm(), 6); + AssertHelpers.AlmostEqualRelative(16.5f, matrix.InfinityNorm(), 6); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(6.6f, matrix.InfinityNorm(), 6); + AssertHelpers.AlmostEqualRelative(6.6f, matrix.InfinityNorm(), 6); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(9.9f, matrix.InfinityNorm(), 6); + AssertHelpers.AlmostEqualRelative(9.9f, matrix.InfinityNorm(), 6); } /// @@ -114,12 +114,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public virtual void CanComputeL2Norm() { var matrix = TestMatrices["Square3x3"]; - AssertHelpers.AlmostEqual(10.391347375312632f, matrix.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(10.391347375312632f, matrix.L2Norm(), 6); matrix = TestMatrices["Wide2x3"]; - AssertHelpers.AlmostEqual(4.7540849434107635f, matrix.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(4.7540849434107635f, matrix.L2Norm(), 6); matrix = TestMatrices["Tall3x2"]; - AssertHelpers.AlmostEqual(7.182727033856683f, matrix.L2Norm(), 5); + AssertHelpers.AlmostEqualRelative(7.182727033856683f, matrix.L2Norm(), 5); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs index e375e91d..7c1f9afe 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs @@ -69,7 +69,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(((double) vector[i]).AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs index 53e828d5..c6952d98 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs @@ -181,7 +181,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit matrix.Multiply(result, product); for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(((double) vector[i]).AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } @@ -258,7 +258,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit { for (var j = i + 1; j < l.RowCount; j++) { - Assert.IsTrue(0.0.AlmostEqual(l[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(l[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } @@ -269,7 +269,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit { for (var j = 0; j < i; j++) { - Assert.IsTrue(0.0.AlmostEqual(u[i, j], -Epsilon.Magnitude()), "#02-" + i + "-" + j); + Assert.IsTrue(0.0.AlmostEqualNumbersBetween(u[i, j], -Epsilon.Magnitude()), "#02-" + i + "-" + j); } } @@ -278,7 +278,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqualInDecimalPlaces(original[i, j], 5), "#03-" + i + "-" + j); + Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqualRelative(original[i, j], 5), "#03-" + i + "-" + j); } } } @@ -321,7 +321,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); + Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqualNumbersBetween(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs index e21142b3..6f16d3b0 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs @@ -112,7 +112,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit for (var i = 0; i < product.Count; i++) { - Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); + Assert.IsTrue(((double) vector[i]).AlmostEqualNumbersBetween(product[i], -Epsilon.Magnitude()), "#02-" + i); } } @@ -140,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit { for (var j = 0; j < sparseMatrix.ColumnCount; j++) { - Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j]), "#01-" + i + "-" + j); + AssertHelpers.AlmostEqualRelative(sparseMatrix[i, j], original[i, j], 5); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/SparseVectorTest.TextHandling.cs b/src/UnitTests/LinearAlgebraTests/Single/SparseVectorTest.TextHandling.cs index 902ef820..32d5c7bd 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/SparseVectorTest.TextHandling.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/SparseVectorTest.TextHandling.cs @@ -120,11 +120,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single SparseVector vector; var ret = SparseVector.TryParse(text, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, vector.ToArray(), 14); ret = SparseVector.TryParse(text, CultureInfo.CurrentCulture, out vector); Assert.IsTrue(ret); - AssertHelpers.AlmostEqualList(data, vector.ToArray(), 1e-15); + AssertHelpers.ListAlmostEqualRelative(data, vector.ToArray(), 14); } /// diff --git a/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Arithmetic.cs index a36a326c..315c077d 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Arithmetic.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Arithmetic.cs @@ -800,7 +800,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single var mod = vector.Modulus(3.2f); for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 7); + AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 6); } } @@ -816,7 +816,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 7); + AssertHelpers.AlmostEqual(Data[index] % 3.2, mod[index], 6); } } @@ -831,7 +831,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 3.2, vector[index], 7); + AssertHelpers.AlmostEqual(Data[index] % 3.2, vector[index], 6); } } @@ -845,7 +845,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single var mod = vector % 4.5f; for (var index = 0; index < Data.Length; index++) { - AssertHelpers.AlmostEqual(Data[index] % 4.5, mod[index], 7); + AssertHelpers.AlmostEqual(Data[index] % 4.5, mod[index], 6); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Norm.cs b/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Norm.cs index 97ec4d7e..f262e69f 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Norm.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/VectorTests.Norm.cs @@ -41,8 +41,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public void CanComputeNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(7.416198487095663f, vector.L2Norm(), 6); - AssertHelpers.AlmostEqual(7.416198487095663f, vector.Norm(2), 6); + AssertHelpers.AlmostEqualRelative(7.416198487095663f, vector.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(7.416198487095663f, vector.Norm(2), 6); } /// @@ -52,8 +52,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public void CanComputeNorm1() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(15.0f, vector.L1Norm(), 7); - AssertHelpers.AlmostEqual(15.0f, vector.Norm(1), 7); + AssertHelpers.AlmostEqualRelative(15.0f, vector.L1Norm(), 7); + AssertHelpers.AlmostEqualRelative(15.0f, vector.Norm(1), 7); } /// @@ -63,8 +63,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public void CanComputeSquareNorm() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(55.0f, vector.L2Norm() * vector.L2Norm(), 6); - AssertHelpers.AlmostEqual(55.0f, vector.Norm(2) * vector.Norm(2), 6); + AssertHelpers.AlmostEqualRelative(55.0f, vector.L2Norm() * vector.L2Norm(), 6); + AssertHelpers.AlmostEqualRelative(55.0f, vector.Norm(2) * vector.Norm(2), 6); } /// @@ -79,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public void CanComputeNormP(int p, float expected) { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(expected, vector.Norm(p), 5); + AssertHelpers.AlmostEqualRelative(expected, vector.Norm(p), 5); } /// @@ -89,8 +89,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public void CanComputeNormInfinity() { var vector = CreateVector(Data); - AssertHelpers.AlmostEqual(5.0f, vector.InfinityNorm(), 7); - AssertHelpers.AlmostEqual(5.0f, vector.Norm(Single.PositiveInfinity), 7); + AssertHelpers.AlmostEqualRelative(5.0f, vector.InfinityNorm(), 7); + AssertHelpers.AlmostEqualRelative(5.0f, vector.Norm(Single.PositiveInfinity), 7); } /// diff --git a/src/UnitTests/PrecisionTest.cs b/src/UnitTests/PrecisionTest.cs index b39be434..024f32a4 100644 --- a/src/UnitTests/PrecisionTest.cs +++ b/src/UnitTests/PrecisionTest.cs @@ -35,11 +35,6 @@ namespace MathNet.Numerics.UnitTests [TestFixture] public sealed class PrecisionTest { - /// - /// Acceptable error. - /// - private const double AcceptableError = 1e-12; - /// /// Double precision. /// @@ -119,44 +114,44 @@ namespace MathNet.Numerics.UnitTests /// Get magnitude scaled value. /// [Test] - public void Value() + public void ScaleUnitMagnitude() { - Assert.AreEqual(0, Precision.GetMagnitudeScaledValue(0), AcceptableError); - - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(1), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(10), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(100), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(1000), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(10000), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(100000), AcceptableError); - Assert.AreEqual(1, Precision.GetMagnitudeScaledValue(1000000), AcceptableError); - - Assert.AreEqual(1.1, 1.1e5.GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(2.2, 2.2e-5.GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(3.3, 3.3e9.GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(4.4, 4.4e-11.GetMagnitudeScaledValue(), AcceptableError); + Assert.AreEqual(0, Precision.ScaleUnitMagnitude(0), 1e-12); + + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(10), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(100), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1000), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(10000), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(100000), 1e-12); + Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1000000), 1e-12); + + Assert.AreEqual(1.1, 1.1e5.ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(2.2, 2.2e-5.ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(3.3, 3.3e9.ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(4.4, 4.4e-11.ScaleUnitMagnitude(), 1e-12); } /// /// Can get magnitude scaled value with a negative values. /// [Test] - public void ValueWithNegativeValues() + public void ScaleUnitMagnitudeWithNegativeValues() { - Assert.AreEqual(0, Precision.GetMagnitudeScaledValue(0), AcceptableError); - - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-1), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-10), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-100), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-1000), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-10000), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-100000), AcceptableError); - Assert.AreEqual(-1, Precision.GetMagnitudeScaledValue(-1000000), AcceptableError); - - Assert.AreEqual(-1.1, (-1.1e5).GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(-2.2, (-2.2e-5).GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(-3.3, (-3.3e9).GetMagnitudeScaledValue(), AcceptableError); - Assert.AreEqual(-4.4, (-4.4e-11).GetMagnitudeScaledValue(), AcceptableError); + Assert.AreEqual(0, Precision.ScaleUnitMagnitude(0), 1e-12); + + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-10), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-100), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1000), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-10000), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-100000), 1e-12); + Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1000000), 1e-12); + + Assert.AreEqual(-1.1, (-1.1e5).ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(-2.2, (-2.2e-5).ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(-3.3, (-3.3e9).ScaleUnitMagnitude(), 1e-12); + Assert.AreEqual(-4.4, (-4.4e-11).ScaleUnitMagnitude(), 1e-12); } /// @@ -250,7 +245,7 @@ namespace MathNet.Numerics.UnitTests /// Coerce zero based on max numbers between. /// [Test] - public void CoerceZeroBasedOnMaxNumbersBetween() + public void CoerceZeroNumbersBetween() { Assert.AreEqual(0.0, (5 * double.Epsilon).CoerceZero(5)); Assert.AreEqual(0.0, (-5 * double.Epsilon).CoerceZero(5)); @@ -263,7 +258,7 @@ namespace MathNet.Numerics.UnitTests /// Coerce zero based on relative tolerance. /// [Test] - public void CoerceZeroBasedOnRelativeTolerance() + public void CoerceZeroRelativeTolerance() { Assert.AreEqual(0.0, 1e-6.CoerceZero(1e-5)); Assert.AreEqual(0.0, (-1e-6).CoerceZero(1e-5)); @@ -286,9 +281,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void RangeOfMatchingFloatingPointNumbersWithNegativeUlps() { - double max; - double min; - Assert.Throws(() => Precision.RangeOfMatchingFloatingPointNumbers(10, -1, out min, out max)); + Assert.Throws(() => Precision.RangeOfMatchingFloatingPointNumbers(10, -1)); } /// @@ -297,16 +290,13 @@ namespace MathNet.Numerics.UnitTests [Test] public void RangeOfMatchingFloatingPointNumbersWithValueAtInfinity() { - double max; - double min; + var minmax = double.PositiveInfinity.RangeOfMatchingFloatingPointNumbers(1); + Assert.AreEqual(double.PositiveInfinity, minmax.Item1); + Assert.AreEqual(double.PositiveInfinity, minmax.Item2); - double.PositiveInfinity.RangeOfMatchingFloatingPointNumbers(1, out min, out max); - Assert.AreEqual(double.PositiveInfinity, min); - Assert.AreEqual(double.PositiveInfinity, max); - - double.NegativeInfinity.RangeOfMatchingFloatingPointNumbers(1, out min, out max); - Assert.AreEqual(double.NegativeInfinity, min); - Assert.AreEqual(double.NegativeInfinity, max); + minmax = double.NegativeInfinity.RangeOfMatchingFloatingPointNumbers(1); + Assert.AreEqual(double.NegativeInfinity, minmax.Item1); + Assert.AreEqual(double.NegativeInfinity, minmax.Item2); } /// @@ -315,12 +305,9 @@ namespace MathNet.Numerics.UnitTests [Test] public void RangeOfMatchingFloatingPointNumbersWithValueAtNaN() { - double max; - double min; - - double.NaN.RangeOfMatchingFloatingPointNumbers(1, out min, out max); - Assert.IsTrue(double.IsNaN(min)); - Assert.IsTrue(double.IsNaN(max)); + var minmax = double.NaN.RangeOfMatchingFloatingPointNumbers(1); + Assert.IsTrue(double.IsNaN(minmax.Item1)); + Assert.IsTrue(double.IsNaN(minmax.Item2)); } /// @@ -341,12 +328,9 @@ namespace MathNet.Numerics.UnitTests [TestCase(8.0, 7.9999999999999911, 8.0000000000000178)] public void RangeOfMatchingFloatingPointNumbersWithPositiveValue(double input, double expectedMin, double expectedMax) { - double max; - double min; - - input.RangeOfMatchingFloatingPointNumbers(10, out min, out max); - Assert.AreEqual(expectedMin, min); - Assert.AreEqual(expectedMax, max); + var minmax = input.RangeOfMatchingFloatingPointNumbers(10); + Assert.AreEqual(expectedMin, minmax.Item1); + Assert.AreEqual(expectedMax, minmax.Item2); } /// @@ -367,12 +351,9 @@ namespace MathNet.Numerics.UnitTests [TestCase(-8.0, -8.0000000000000178, -7.9999999999999911)] public void RangeOfMatchingFloatingPointNumbersWithNegativeValue(double input, double expectedMin, double expectedMax) { - double max; - double min; - - input.RangeOfMatchingFloatingPointNumbers(10, out min, out max); - Assert.AreEqual(expectedMin, min); - Assert.AreEqual(expectedMax, max); + var minmax = input.RangeOfMatchingFloatingPointNumbers(10); + Assert.AreEqual(expectedMin, minmax.Item1); + Assert.AreEqual(expectedMax, minmax.Item2); } /// @@ -459,33 +440,27 @@ namespace MathNet.Numerics.UnitTests /// Range of matching Ulps with negative relative difference throws ArgumentOutOfRangeException. /// [Test] - public void RangeOfMatchingUlpsWithNegativeRelativeDifferenceThrowsArgumentOutOfRangeException() + public void RangeOfMatchingUlpsWithNegativeRelativeDifferenceThrows() { - long min; - long max; - Assert.Throws(() => Precision.RangeOfMatchingNumbers(1, -1, out min, out max)); + Assert.Throws(() => 1d.RangeOfMatchingNumbers(-1d)); } /// /// Range of matching Ulps with value at infinity throws ArgumentOutOfRangeException. /// [Test] - public void RangeOfMatchingUlpsWithValueAtInfinityThrowsArgumentOutOfRangeException() + public void RangeOfMatchingUlpsWithValueAtInfinityThrows() { - long min; - long max; - Assert.Throws(() => double.PositiveInfinity.RangeOfMatchingNumbers(-1, out min, out max)); + Assert.Throws(() => double.PositiveInfinity.RangeOfMatchingNumbers(-1d)); } /// /// Range of matching Ulps with value at Nan throws ArgumentOutOfRangeException. /// [Test] - public void RangeOfMatchingUlpsWithValueAtNaNThrowsArgumentOutOfRangeException() + public void RangeOfMatchingUlpsWithValueAtNaNThrows() { - long min; - long max; - Assert.Throws(() => double.NaN.RangeOfMatchingNumbers(-1, out min, out max)); + Assert.Throws(() => double.NaN.RangeOfMatchingNumbers(-1d)); } /// @@ -506,12 +481,9 @@ namespace MathNet.Numerics.UnitTests [TestCase(8.0, (8.0000000000000178 - 8.0) / 8.0, 20, 10)] public void RangeOfMatchingUlpsWithPositiveValue(double input, double relativeDifference, long expectedMin, long expectedMax) { - long min; - long max; - - input.RangeOfMatchingNumbers(relativeDifference, out min, out max); - Assert.AreEqual(expectedMin, min); - Assert.AreEqual(expectedMax, max); + var minmax = input.RangeOfMatchingNumbers(relativeDifference); + Assert.AreEqual(expectedMin, minmax.Item1); + Assert.AreEqual(expectedMax, minmax.Item2); } /// @@ -532,19 +504,16 @@ namespace MathNet.Numerics.UnitTests [TestCase(-8.0, (8.0000000000000178 - 8.0) / 8.0, 10, 20)] public void RangeOfMatchingUlpsWithNegativeValue(double input, double relativeDifference, long expectedMin, long expectedMax) { - long min; - long max; - - input.RangeOfMatchingNumbers(relativeDifference, out min, out max); - Assert.AreEqual(expectedMin, min); - Assert.AreEqual(expectedMax, max); + var minmax = input.RangeOfMatchingNumbers(relativeDifference); + Assert.AreEqual(expectedMin, minmax.Item1); + Assert.AreEqual(expectedMax, minmax.Item2); } /// /// Test numbers between. /// [Test] - public void TestNumbersBetween() + public void NumbersBetween() { Assert.AreEqual(0, 1.0.NumbersBetween(1.0)); Assert.AreEqual(0, Precision.NumbersBetween(0, 0)); @@ -566,275 +535,224 @@ namespace MathNet.Numerics.UnitTests /// AlmostEqual with max numbers between with less than one number throws ArgumentOutOfRangeException. /// [Test] - public void AlmostEqualWithMaxNumbersBetweenWithLessThanOneNumberThrowsArgumentOutOfRangeException() + public void AlmostEqualWithMaxNumbersBetweenWithLessThanOneNumberThrows() { - Assert.Throws(() => Precision.AlmostEqual(1, 2, 0)); + Assert.Throws(() => Precision.AlmostEqualNumbersBetween(1, 2, 0)); } - /// - /// Almost Equal. - /// [Test] public void AlmostEqual() { Assert.That(1.0.AlmostEqual(1.0), "1.0 equals 1.0."); Assert.That(1.0.AlmostEqual(1.0 + _doublePrecision), "1.0 equals 1.0 + 2^(-53)."); - Assert.That(1.0.AlmostEqual(1.0 + (_doublePrecision * 10)), "1.0 equals 1.0 + 2^(-52)."); + Assert.That(1.0.AlmostEqual(1.0 + (_doublePrecision * 5)), "1.0 equals 1.0 + 5*2^(-53)."); Assert.That(!1.0.AlmostEqual(1.0 + (_doublePrecision * 100)), "1.0 does not equal 1.0 + 2^(-51)."); Assert.That(!1.0.AlmostEqual(2.0), "1.0 does not equal 2.0"); } - /// - /// AlmostEqual with relative error. - /// [Test] - public void AlmostEqualWithRelativeError() + public void AlmostEqualRelative() { // compare zero and negative zero - Assert.IsTrue(0.0.AlmostEqualWithError(-0.0, 1e-5)); - Assert.IsTrue(0.0.AlmostEqualWithError(-0.0, 1e-15)); + Assert.IsTrue(0.0.AlmostEqualRelative(-0.0, 1e-5)); + Assert.IsTrue(0.0.AlmostEqualRelative(-0.0, 1e-15)); // compare two nearby numbers - Assert.IsTrue(1.0.AlmostEqualWithError(1.0 + (3 * _doublePrecision), 1e-15)); - Assert.IsTrue(1.0.AlmostEqualWithError(1.0 + _doublePrecision, 1e-15)); - Assert.IsTrue(1.0.AlmostEqualWithError(1.0 + 1e-16, 1e-15)); - Assert.IsFalse(1.0.AlmostEqualWithError(1.0 + 1e-15, 1e-15)); - Assert.IsFalse(1.0.AlmostEqualWithError(1.0 + 1e-14, 1e-15)); + Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + (3 * _doublePrecision), 1e-15)); + Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + _doublePrecision, 1e-15)); + Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + 1e-16, 1e-15)); + Assert.IsFalse(1.0.AlmostEqualRelative(1.0 + 1e-15, 1e-15)); + Assert.IsFalse(1.0.AlmostEqualRelative(1.0 + 1e-14, 1e-15)); // compare with the two numbers reversed in compare order - Assert.IsTrue((1.0 + (3 * _doublePrecision)).AlmostEqualWithError(1.0, 1e-15)); - Assert.IsTrue((1.0 + _doublePrecision).AlmostEqualWithError(1.0, 1e-15)); - Assert.IsTrue((1.0 + 1e-16).AlmostEqualWithError(1.0, 1e-15)); - Assert.IsFalse((1.0 + 1e-15).AlmostEqualWithError(1.0, 1e-15)); - Assert.IsFalse((1.0 + 1e-14).AlmostEqualWithError(1.0, 1e-15)); + Assert.IsTrue((1.0 + (3 * _doublePrecision)).AlmostEqualRelative(1.0, 1e-15)); + Assert.IsTrue((1.0 + _doublePrecision).AlmostEqualRelative(1.0, 1e-15)); + Assert.IsTrue((1.0 + 1e-16).AlmostEqualRelative(1.0, 1e-15)); + Assert.IsFalse((1.0 + 1e-15).AlmostEqualRelative(1.0, 1e-15)); + Assert.IsFalse((1.0 + 1e-14).AlmostEqualRelative(1.0, 1e-15)); // compare different numbers - Assert.IsFalse(2.0.AlmostEqualWithError(1.0, 1e-15)); - Assert.IsFalse(1.0.AlmostEqualWithError(2.0, 1e-15)); + Assert.IsFalse(2.0.AlmostEqualRelative(1.0, 1e-15)); + Assert.IsFalse(1.0.AlmostEqualRelative(2.0, 1e-15)); // compare different numbers with large tolerance - Assert.IsFalse(2.0.AlmostEqualWithError(1.0, 1e-5)); - Assert.IsFalse(1.0.AlmostEqualWithError(2.0, 1e-5)); - Assert.IsTrue(2.0.AlmostEqualWithError(1.0, 1e+1)); - Assert.IsTrue(1.0.AlmostEqualWithError(2.0, 1e+1)); + Assert.IsFalse(2.0.AlmostEqualRelative(1.0, 1e-5)); + Assert.IsFalse(1.0.AlmostEqualRelative(2.0, 1e-5)); + Assert.IsTrue(2.0.AlmostEqualRelative(1.0, 1e+1)); + Assert.IsTrue(1.0.AlmostEqualRelative(2.0, 1e+1)); // compare inf & inf - Assert.IsTrue(double.PositiveInfinity.AlmostEqualWithError(double.PositiveInfinity, 1e-15)); - Assert.IsTrue(double.NegativeInfinity.AlmostEqualWithError(double.NegativeInfinity, 1e-15)); + Assert.IsTrue(double.PositiveInfinity.AlmostEqualRelative(double.PositiveInfinity, 1e-15)); + Assert.IsTrue(double.NegativeInfinity.AlmostEqualRelative(double.NegativeInfinity, 1e-15)); // compare -inf and inf - Assert.IsFalse(double.PositiveInfinity.AlmostEqualWithError(double.NegativeInfinity, 1e-15)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqualWithError(double.PositiveInfinity, 1e-15)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(double.NegativeInfinity, 1e-15)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(double.PositiveInfinity, 1e-15)); // compare inf and non-inf - Assert.IsFalse(double.PositiveInfinity.AlmostEqualWithError(1.0, 1e-15)); - Assert.IsFalse(1.0.AlmostEqualWithError(double.PositiveInfinity, 1e-15)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqualWithError(1.0, 1e-15)); - Assert.IsFalse(1.0.AlmostEqualWithError(double.NegativeInfinity, 1e-15)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(1.0, 1e-15)); + Assert.IsFalse(1.0.AlmostEqualRelative(double.PositiveInfinity, 1e-15)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(1.0, 1e-15)); + Assert.IsFalse(1.0.AlmostEqualRelative(double.NegativeInfinity, 1e-15)); // compare tiny numbers with opposite signs - Assert.IsFalse(1e-12.AlmostEqualWithError(-1e-12, 1e-14)); - Assert.IsFalse((-1e-12).AlmostEqualWithError(1e-12, 1e-14)); + Assert.IsFalse(1e-12.AlmostEqualRelative(-1e-12, 1e-14)); + Assert.IsFalse((-1e-12).AlmostEqualRelative(1e-12, 1e-14)); - Assert.IsFalse((-2.0).AlmostEqualWithError(2.0, 1e-14)); - Assert.IsFalse(2.0.AlmostEqualWithError(-2.0, 1e-14)); + Assert.IsFalse((-2.0).AlmostEqualRelative(2.0, 1e-14)); + Assert.IsFalse(2.0.AlmostEqualRelative(-2.0, 1e-14)); } - /// - /// AlmostEqual with max numbers between. - /// [Test] - public void AlmostEqualWithMaxNumbersBetween() + public void AlmostEqualNumbersBetween() { // compare zero and negative zero - Assert.IsTrue(Precision.AlmostEqual(0, -0, 1)); + Assert.IsTrue(Precision.AlmostEqualNumbersBetween(0, -0, 1)); // compare two nearby numbers - Assert.IsFalse(1.0.AlmostEqual(1.0 + (3 * _doublePrecision), 1)); - Assert.IsTrue(1.0.AlmostEqual(1.0 + _doublePrecision, 1)); - Assert.IsTrue(1.0.AlmostEqual(1.0 - _doublePrecision, 1)); - Assert.IsFalse(1.0.AlmostEqual(1.0 - (3 * _doublePrecision), 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (3 * _doublePrecision), 1)); + Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 + _doublePrecision, 1)); + Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - _doublePrecision, 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (3 * _doublePrecision), 1)); // compare with the two numbers reversed in compare order - Assert.IsFalse((1.0 + (3 * _doublePrecision)).AlmostEqual(1.0, 1)); - Assert.IsTrue((1.0 + _doublePrecision).AlmostEqual(1.0, 1)); - Assert.IsTrue((1.0 - _doublePrecision).AlmostEqual(1.0, 1)); - Assert.IsFalse((1.0 - (3 * _doublePrecision)).AlmostEqual(1.0, 1)); + Assert.IsFalse((1.0 + (3 * _doublePrecision)).AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsTrue((1.0 + _doublePrecision).AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsTrue((1.0 - _doublePrecision).AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsFalse((1.0 - (3 * _doublePrecision)).AlmostEqualNumbersBetween(1.0, 1)); // compare two slightly more different numbers - Assert.IsFalse(1.0.AlmostEqual(1.0 + (10 * _doublePrecision), 1)); - Assert.IsTrue(1.0.AlmostEqual(1.0 + (10 * _doublePrecision), 10)); - Assert.IsTrue(1.0.AlmostEqual(1.0 - (10 * _doublePrecision), 10)); - Assert.IsFalse(1.0.AlmostEqual(1.0 - (10 * _doublePrecision), 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (10 * _doublePrecision), 1)); + Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 + (10 * _doublePrecision), 10)); + Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - (10 * _doublePrecision), 10)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (10 * _doublePrecision), 1)); // compare different numbers - Assert.IsFalse(2.0.AlmostEqual(1.0, 1)); - Assert.IsFalse(1.0.AlmostEqual(2.0, 1)); + Assert.IsFalse(2.0.AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(2.0, 1)); // compare different numbers with large tolerance - Assert.IsFalse(1.0.AlmostEqual(1.0 + (1e5 * _doublePrecision), 1)); - Assert.IsTrue(1.0.AlmostEqual(1.0 - (1e5 * _doublePrecision), 200000)); - Assert.IsFalse(1.0.AlmostEqual(1.0 - (1e5 * _doublePrecision), 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (1e5 * _doublePrecision), 1)); + Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - (1e5 * _doublePrecision), 200000)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (1e5 * _doublePrecision), 1)); // compare inf & inf - Assert.IsTrue(double.PositiveInfinity.AlmostEqual(double.PositiveInfinity, 1)); - Assert.IsTrue(double.NegativeInfinity.AlmostEqual(double.NegativeInfinity, 1)); + Assert.IsTrue(double.PositiveInfinity.AlmostEqualNumbersBetween(double.PositiveInfinity, 1)); + Assert.IsTrue(double.NegativeInfinity.AlmostEqualNumbersBetween(double.NegativeInfinity, 1)); // compare -inf and inf - Assert.IsFalse(double.PositiveInfinity.AlmostEqual(double.NegativeInfinity, 1)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqual(double.PositiveInfinity, 1)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualNumbersBetween(double.NegativeInfinity, 1)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqualNumbersBetween(double.PositiveInfinity, 1)); // compare inf and non-inf - Assert.IsFalse(double.PositiveInfinity.AlmostEqual(1.0, 1)); - Assert.IsFalse(1.0.AlmostEqual(double.PositiveInfinity, 1)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(double.PositiveInfinity, 1)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqual(1.0, 1)); - Assert.IsFalse(1.0.AlmostEqual(double.NegativeInfinity, 1)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqualNumbersBetween(1.0, 1)); + Assert.IsFalse(1.0.AlmostEqualNumbersBetween(double.NegativeInfinity, 1)); // compare tiny numbers with opposite signs - Assert.IsFalse(double.Epsilon.AlmostEqual(-double.Epsilon, 1)); - Assert.IsFalse((-double.Epsilon).AlmostEqual(double.Epsilon, 1)); + Assert.IsFalse(double.Epsilon.AlmostEqualNumbersBetween(-double.Epsilon, 1)); + Assert.IsFalse((-double.Epsilon).AlmostEqualNumbersBetween(double.Epsilon, 1)); - Assert.IsFalse((-2.0).AlmostEqual(2.0, 1)); - Assert.IsFalse(2.0.AlmostEqual(-2.0, 1)); + Assert.IsFalse((-2.0).AlmostEqualNumbersBetween(2.0, 1)); + Assert.IsFalse(2.0.AlmostEqualNumbersBetween(-2.0, 1)); } - /// - /// AlmostEqual within absolute decimal places. - /// [Test] - public void AlmostEqualInAbsoluteDecimalPlaces() + public void AlmostEqualDecimalPlaces() { - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(double.NaN, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInAbsoluteDecimalPlaces(2d, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInAbsoluteDecimalPlaces(double.NaN, 2)); - - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInAbsoluteDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInAbsoluteDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInAbsoluteDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInAbsoluteDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsTrue(double.PositiveInfinity.AlmostEqualInAbsoluteDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsTrue(double.NegativeInfinity.AlmostEqualInAbsoluteDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsFalse(1d.AlmostEqual(double.NaN, 2)); + Assert.IsFalse(double.NaN.AlmostEqual(2d, 2)); + Assert.IsFalse(double.NaN.AlmostEqual(double.NaN, 2)); + + Assert.IsFalse(double.NegativeInfinity.AlmostEqual(2, 2)); + Assert.IsFalse(1d.AlmostEqual(double.NegativeInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqual(2, 2)); + Assert.IsFalse(1d.AlmostEqual(double.PositiveInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqual(double.PositiveInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqual(double.NegativeInfinity, 2)); + Assert.IsTrue(double.PositiveInfinity.AlmostEqual(double.PositiveInfinity, 2)); + Assert.IsTrue(double.NegativeInfinity.AlmostEqual(double.NegativeInfinity, 2)); // 1 -> +/- 0.05 (0.5e-1) - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(1.06, 1)); - Assert.IsTrue(1d.AlmostEqualInAbsoluteDecimalPlaces(1.04, 1)); - Assert.IsTrue(1d.AlmostEqualInAbsoluteDecimalPlaces(1.00, 1)); - Assert.IsTrue(1d.AlmostEqualInAbsoluteDecimalPlaces(0.96, 1)); - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(0.94, 1)); - Assert.IsFalse(1d.AlmostEqualInAbsoluteDecimalPlaces(0.0, 1)); + Assert.IsFalse(1d.AlmostEqual(1.06, 1)); + Assert.IsTrue(1d.AlmostEqual(1.04, 1)); + Assert.IsTrue(1d.AlmostEqual(1.00, 1)); + Assert.IsTrue(1d.AlmostEqual(0.96, 1)); + Assert.IsFalse(1d.AlmostEqual(0.94, 1)); + Assert.IsFalse(1d.AlmostEqual(0.0, 1)); // -1 -> +/- 5 (0.5e+1) - Assert.IsFalse(100d.AlmostEqualInAbsoluteDecimalPlaces(106.0, -1)); - Assert.IsTrue(100d.AlmostEqualInAbsoluteDecimalPlaces(104.0, -1)); - Assert.IsTrue(100d.AlmostEqualInAbsoluteDecimalPlaces(100.0, -1)); - Assert.IsTrue(100d.AlmostEqualInAbsoluteDecimalPlaces(96.0, -1)); - Assert.IsFalse(100d.AlmostEqualInAbsoluteDecimalPlaces(94.0, -1)); - Assert.IsFalse(100d.AlmostEqualInAbsoluteDecimalPlaces(0.0, -1)); + Assert.IsFalse(100d.AlmostEqual(106.0, -1)); + Assert.IsTrue(100d.AlmostEqual(104.0, -1)); + Assert.IsTrue(100d.AlmostEqual(100.0, -1)); + Assert.IsTrue(100d.AlmostEqual(96.0, -1)); + Assert.IsFalse(100d.AlmostEqual(94.0, -1)); + Assert.IsFalse(100d.AlmostEqual(0.0, -1)); // 3 -> +/- 0.0005 (0.5e-3) - Assert.IsFalse(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0106, 3)); - Assert.IsTrue(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0104, 3)); - Assert.IsTrue(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0100, 3)); - Assert.IsTrue(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0096, 3)); - Assert.IsFalse(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0094, 3)); - Assert.IsFalse(0.01.AlmostEqualInAbsoluteDecimalPlaces(0.0, 3)); + Assert.IsFalse(0.01.AlmostEqual(0.0106, 3)); + Assert.IsTrue(0.01.AlmostEqual(0.0104, 3)); + Assert.IsTrue(0.01.AlmostEqual(0.0100, 3)); + Assert.IsTrue(0.01.AlmostEqual(0.0096, 3)); + Assert.IsFalse(0.01.AlmostEqual(0.0094, 3)); + Assert.IsFalse(0.01.AlmostEqual(0.0, 3)); // 12 -> +/- 0.5e-12 - Assert.IsTrue(0d.AlmostEqualInAbsoluteDecimalPlaces(4 * _doublePrecision, 12)); - Assert.IsTrue(0d.AlmostEqualInAbsoluteDecimalPlaces(-4 * _doublePrecision, 12)); + Assert.IsTrue(0d.AlmostEqual(4 * _doublePrecision, 12)); + Assert.IsTrue(0d.AlmostEqual(-4 * _doublePrecision, 12)); } /// /// AlmostEqual within relative decimal places. /// [Test] - public void AlmostEqualInRelativeDecimalPlaces() + public void AlmostEqualRelativeDecimalPlaces() { - Assert.IsFalse(1d.AlmostEqualInRelativeDecimalPlaces(double.NaN, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInRelativeDecimalPlaces(2d, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInRelativeDecimalPlaces(double.NaN, 2)); - - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInRelativeDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInRelativeDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInRelativeDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInRelativeDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInRelativeDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInRelativeDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsTrue(double.PositiveInfinity.AlmostEqualInRelativeDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsTrue(double.NegativeInfinity.AlmostEqualInRelativeDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsFalse(1d.AlmostEqualRelative(double.NaN, 2)); + Assert.IsFalse(double.NaN.AlmostEqualRelative(2d, 2)); + Assert.IsFalse(double.NaN.AlmostEqualRelative(double.NaN, 2)); + + Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(2, 2)); + Assert.IsFalse(1d.AlmostEqualRelative(double.NegativeInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(2, 2)); + Assert.IsFalse(1d.AlmostEqualRelative(double.PositiveInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(double.PositiveInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(double.NegativeInfinity, 2)); + Assert.IsTrue(double.PositiveInfinity.AlmostEqualRelative(double.PositiveInfinity, 2)); + Assert.IsTrue(double.NegativeInfinity.AlmostEqualRelative(double.NegativeInfinity, 2)); // 1 -> +/- max * 0.05 (0.5e-1) - Assert.IsTrue(1d.AlmostEqualInRelativeDecimalPlaces(1.04, 1)); - Assert.IsFalse(1d.AlmostEqualInRelativeDecimalPlaces(1.06, 1)); - Assert.IsTrue(1d.AlmostEqualInRelativeDecimalPlaces(0.96, 1)); - Assert.IsFalse(1d.AlmostEqualInRelativeDecimalPlaces(0.94, 1)); + Assert.IsTrue(1d.AlmostEqualRelative(1.04, 1)); + Assert.IsFalse(1d.AlmostEqualRelative(1.06, 1)); + Assert.IsTrue(1d.AlmostEqualRelative(0.96, 1)); + Assert.IsFalse(1d.AlmostEqualRelative(0.94, 1)); // 1 -> +/- max * 0.05 (0.5e-1) - Assert.IsTrue(100d.AlmostEqualInRelativeDecimalPlaces(104.00, 1)); - Assert.IsFalse(100d.AlmostEqualInRelativeDecimalPlaces(106.00, 1)); - Assert.IsTrue(100d.AlmostEqualInRelativeDecimalPlaces(96.000, 1)); - Assert.IsFalse(100d.AlmostEqualInRelativeDecimalPlaces(94.000, 1)); + Assert.IsTrue(100d.AlmostEqualRelative(104.00, 1)); + Assert.IsFalse(100d.AlmostEqualRelative(106.00, 1)); + Assert.IsTrue(100d.AlmostEqualRelative(96.000, 1)); + Assert.IsFalse(100d.AlmostEqualRelative(94.000, 1)); // 0 -> +/- max * 0.5 (0.5e-0) - Assert.IsTrue(0.01.AlmostEqualInRelativeDecimalPlaces(0.014, 0)); - Assert.IsFalse(0.01.AlmostEqualInRelativeDecimalPlaces(0.016, 0)); - Assert.IsTrue(0.01.AlmostEqualInRelativeDecimalPlaces(0.006, 0)); - Assert.IsFalse(0.01.AlmostEqualInRelativeDecimalPlaces(0.004, 0)); - } + Assert.IsTrue(0.01.AlmostEqualRelative(0.014, 0)); + Assert.IsFalse(0.01.AlmostEqualRelative(0.016, 0)); + Assert.IsTrue(0.01.AlmostEqualRelative(0.006, 0)); + Assert.IsFalse(0.01.AlmostEqualRelative(0.004, 0)); - /// - /// AlmostEqual within decimal places with negative decimal places throws ArgumentOutOfRangeException. - /// - [Test] - public void AlmostEqualInRelativeDecimalPlacesWithNegativeDecimalPlacesThrowsArgumentOutOfRangeException() - { - Assert.Throws(() => Precision.AlmostEqualInDecimalPlaces(1, 2, -1)); - Assert.Throws(() => Precision.AlmostEqualInRelativeDecimalPlaces(1, 2, -1)); - Assert.DoesNotThrow(() => Precision.AlmostEqualInAbsoluteDecimalPlaces(1, 2, -1)); + Assert.IsTrue(0d.AlmostEqualRelative(4 * _doublePrecision, 12)); + Assert.IsTrue(0d.AlmostEqualRelative(-4 * _doublePrecision, 12)); } /// - /// AlmostEqual within decimal places. + /// AlmostEqual within decimal places with negative decimal places throws ArgumentOutOfRangeException. /// [Test] - public void AlmostEqualInDecimalPlaces() + public void AlmostEqualRelativeDecimalPlacesWithNegativeDecimalPlacesThrows() { - Assert.IsFalse(1d.AlmostEqualInDecimalPlaces(double.NaN, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInDecimalPlaces(2, 2)); - Assert.IsFalse(double.NaN.AlmostEqualInDecimalPlaces(double.NaN, 2)); - - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInDecimalPlaces(2, 2)); - Assert.IsFalse(1d.AlmostEqualInDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.AlmostEqualInDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.AlmostEqualInDecimalPlaces(double.NegativeInfinity, 2)); - Assert.IsTrue(double.PositiveInfinity.AlmostEqualInDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsTrue(double.NegativeInfinity.AlmostEqualInDecimalPlaces(double.NegativeInfinity, 2)); - - // 1 -> +/- max * 0.05 (0.5e-1) - Assert.IsTrue(1d.AlmostEqualInDecimalPlaces(1.04, 1)); - Assert.IsFalse(1d.AlmostEqualInDecimalPlaces(1.06, 1)); - Assert.IsTrue(1d.AlmostEqualInDecimalPlaces(0.96, 1)); - Assert.IsFalse(1d.AlmostEqualInDecimalPlaces(0.94, 1)); - - // 1 -> +/- max * 0.05 (0.5e-1) - Assert.IsTrue(100d.AlmostEqualInDecimalPlaces(104.00, 1)); - Assert.IsFalse(100d.AlmostEqualInDecimalPlaces(106.00, 1)); - Assert.IsTrue(100d.AlmostEqualInDecimalPlaces(96.000, 1)); - Assert.IsFalse(100d.AlmostEqualInDecimalPlaces(94.000, 1)); - - // 0 -> +/- max * 0.5 (0.5e-0) - Assert.IsTrue(0.01.AlmostEqualInDecimalPlaces(0.014, 0)); - Assert.IsFalse(0.01.AlmostEqualInDecimalPlaces(0.016, 0)); - Assert.IsTrue(0.01.AlmostEqualInDecimalPlaces(0.006, 0)); - Assert.IsFalse(0.01.AlmostEqualInDecimalPlaces(0.004, 0)); - - Assert.IsTrue(0d.AlmostEqualInDecimalPlaces(4 * _doublePrecision, 12)); - Assert.IsTrue(0d.AlmostEqualInDecimalPlaces(-4 * _doublePrecision, 12)); + Assert.Throws(() => Precision.AlmostEqualRelative(1, 2, -1)); + Assert.DoesNotThrow(() => Precision.AlmostEqual(1, 2, -1)); } /// @@ -843,14 +761,14 @@ namespace MathNet.Numerics.UnitTests [Test] public void AlmostEqualWithSmallNumbersAndSmallNumberOfDecimalPlaces() { - Assert.IsTrue(0.0.AlmostEqualInDecimalPlaces(1e-12, 1)); - Assert.IsTrue(0.0.AlmostEqualInDecimalPlaces(-1e-12, 1)); + Assert.IsTrue(0.0.AlmostEqualRelative(1e-12, 1)); + Assert.IsTrue(0.0.AlmostEqualRelative(-1e-12, 1)); - Assert.IsFalse(0.0.AlmostEqualInDecimalPlaces(1e-12, 13)); - Assert.IsFalse(0.0.AlmostEqualInDecimalPlaces(-1e-12, 13)); + Assert.IsFalse(0.0.AlmostEqualRelative(1e-12, 13)); + Assert.IsFalse(0.0.AlmostEqualRelative(-1e-12, 13)); - Assert.IsFalse(0.0.AlmostEqualInDecimalPlaces(1, 1)); - Assert.IsFalse(0.0.AlmostEqualInDecimalPlaces(-1, 1)); + Assert.IsFalse(0.0.AlmostEqualRelative(1, 1)); + Assert.IsFalse(0.0.AlmostEqualRelative(-1, 1)); } /// @@ -859,7 +777,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void AlmostEqualWithDecimalPlacesWithSignRevert() { - Assert.IsFalse(0.5.AlmostEqualInDecimalPlaces(0.3, 1)); + Assert.IsFalse(0.5.AlmostEqualRelative(0.3, 1)); } /// @@ -924,39 +842,39 @@ namespace MathNet.Numerics.UnitTests [Test] public void IsLargerWithDecimalPlaces() { - Assert.IsFalse(Precision.IsLargerWithDecimalPlaces(1, double.NaN, 2)); - Assert.IsFalse(double.NaN.IsLargerWithDecimalPlaces(2, 2)); - Assert.IsFalse(double.NaN.IsLargerWithDecimalPlaces(double.NaN, 2)); + Assert.IsFalse(Precision.IsLargerDecimal(1, double.NaN, 2)); + Assert.IsFalse(double.NaN.IsLargerDecimal(2, 2)); + Assert.IsFalse(double.NaN.IsLargerDecimal(double.NaN, 2)); - Assert.IsFalse(double.NegativeInfinity.IsLargerWithDecimalPlaces(2, 2)); - Assert.IsTrue(Precision.IsLargerWithDecimalPlaces(1, double.NegativeInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.IsLargerDecimal(2, 2)); + Assert.IsTrue(Precision.IsLargerDecimal(1, double.NegativeInfinity, 2)); - Assert.IsTrue(double.PositiveInfinity.IsLargerWithDecimalPlaces(2, 2)); - Assert.IsFalse(Precision.IsLargerWithDecimalPlaces(1, double.PositiveInfinity, 2)); + Assert.IsTrue(double.PositiveInfinity.IsLargerDecimal(2, 2)); + Assert.IsFalse(Precision.IsLargerDecimal(1, double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.IsLargerWithDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsTrue(double.PositiveInfinity.IsLargerWithDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.IsLargerDecimal(double.PositiveInfinity, 2)); + Assert.IsTrue(double.PositiveInfinity.IsLargerDecimal(double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.IsLargerWithDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.IsLargerWithDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.IsLargerDecimal(double.PositiveInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.IsLargerDecimal(double.NegativeInfinity, 2)); - Assert.IsFalse(1.0.IsLargerWithDecimalPlaces(1.006, 2)); - Assert.IsFalse(1.0.IsLargerWithDecimalPlaces(1.004, 2)); - Assert.IsFalse(1.0.IsLargerWithDecimalPlaces(0.996, 2)); - Assert.IsTrue(1.0.IsLargerWithDecimalPlaces(0.994, 2)); + Assert.IsFalse(1.0.IsLargerDecimal(1.006, 2)); + Assert.IsFalse(1.0.IsLargerDecimal(1.004, 2)); + Assert.IsFalse(1.0.IsLargerDecimal(0.996, 2)); + Assert.IsTrue(1.0.IsLargerDecimal(0.994, 2)); - Assert.IsFalse(100.0.IsLargerWithDecimalPlaces(100.6, 2)); - Assert.IsFalse(100.0.IsLargerWithDecimalPlaces(100.4, 2)); - Assert.IsFalse(100.0.IsLargerWithDecimalPlaces(99.6, 2)); - Assert.IsTrue(100.0.IsLargerWithDecimalPlaces(99.4, 2)); + Assert.IsFalse(100.0.IsLargerDecimal(100.6, 2)); + Assert.IsFalse(100.0.IsLargerDecimal(100.4, 2)); + Assert.IsFalse(100.0.IsLargerDecimal(99.6, 2)); + Assert.IsTrue(100.0.IsLargerDecimal(99.4, 2)); var max = 0.4 * Math.Pow(10, _doublePrecision.Magnitude()); - Assert.IsFalse(0.0.IsLargerWithDecimalPlaces(max, -_doublePrecision.Magnitude())); - Assert.IsFalse(0.0.IsLargerWithDecimalPlaces(-max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsLargerDecimal(max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsLargerDecimal(-max, -_doublePrecision.Magnitude())); max = 0.6 * Math.Pow(10, _doublePrecision.Magnitude()); - Assert.IsFalse(0.0.IsLargerWithDecimalPlaces(max, -_doublePrecision.Magnitude())); - Assert.IsTrue(0.0.IsLargerWithDecimalPlaces(-max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsLargerDecimal(max, -_doublePrecision.Magnitude())); + Assert.IsTrue(0.0.IsLargerDecimal(-max, -_doublePrecision.Magnitude())); } /// @@ -1021,46 +939,46 @@ namespace MathNet.Numerics.UnitTests [Test] public void IsSmallerWithDecimalPlaces() { - Assert.IsFalse(Precision.IsSmallerWithDecimalPlaces(1, double.NaN, 2)); - Assert.IsFalse(double.NaN.IsSmallerWithDecimalPlaces(2, 2)); - Assert.IsFalse(double.NaN.IsSmallerWithDecimalPlaces(double.NaN, 2)); + Assert.IsFalse(Precision.IsSmallerDecimal(1, double.NaN, 2)); + Assert.IsFalse(double.NaN.IsSmallerDecimal(2, 2)); + Assert.IsFalse(double.NaN.IsSmallerDecimal(double.NaN, 2)); - Assert.IsTrue(double.NegativeInfinity.IsSmallerWithDecimalPlaces(2, 2)); - Assert.IsFalse(Precision.IsSmallerWithDecimalPlaces(1, double.NegativeInfinity, 2)); + Assert.IsTrue(double.NegativeInfinity.IsSmallerDecimal(2, 2)); + Assert.IsFalse(Precision.IsSmallerDecimal(1, double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.IsSmallerWithDecimalPlaces(2, 2)); - Assert.IsTrue(Precision.IsSmallerWithDecimalPlaces(1, double.PositiveInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.IsSmallerDecimal(2, 2)); + Assert.IsTrue(Precision.IsSmallerDecimal(1, double.PositiveInfinity, 2)); - Assert.IsTrue(double.NegativeInfinity.IsSmallerWithDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.IsSmallerWithDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsTrue(double.NegativeInfinity.IsSmallerDecimal(double.PositiveInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.IsSmallerDecimal(double.NegativeInfinity, 2)); - Assert.IsFalse(double.PositiveInfinity.IsSmallerWithDecimalPlaces(double.PositiveInfinity, 2)); - Assert.IsFalse(double.NegativeInfinity.IsSmallerWithDecimalPlaces(double.NegativeInfinity, 2)); + Assert.IsFalse(double.PositiveInfinity.IsSmallerDecimal(double.PositiveInfinity, 2)); + Assert.IsFalse(double.NegativeInfinity.IsSmallerDecimal(double.NegativeInfinity, 2)); - Assert.IsTrue(1.0.IsSmallerWithDecimalPlaces(1.006, 2)); - Assert.IsFalse(1.0.IsSmallerWithDecimalPlaces(1.004, 2)); - Assert.IsFalse(1.0.IsSmallerWithDecimalPlaces(0.996, 2)); - Assert.IsFalse(1.0.IsSmallerWithDecimalPlaces(0.994, 2)); + Assert.IsTrue(1.0.IsSmallerDecimal(1.006, 2)); + Assert.IsFalse(1.0.IsSmallerDecimal(1.004, 2)); + Assert.IsFalse(1.0.IsSmallerDecimal(0.996, 2)); + Assert.IsFalse(1.0.IsSmallerDecimal(0.994, 2)); - Assert.IsTrue(100.0.IsSmallerWithDecimalPlaces(100.6, 2)); - Assert.IsFalse(100.0.IsSmallerWithDecimalPlaces(100.4, 2)); - Assert.IsFalse(100.0.IsSmallerWithDecimalPlaces(99.6, 2)); - Assert.IsFalse(100.0.IsSmallerWithDecimalPlaces(99.4, 2)); + Assert.IsTrue(100.0.IsSmallerDecimal(100.6, 2)); + Assert.IsFalse(100.0.IsSmallerDecimal(100.4, 2)); + Assert.IsFalse(100.0.IsSmallerDecimal(99.6, 2)); + Assert.IsFalse(100.0.IsSmallerDecimal(99.4, 2)); var max = 0.4 * Math.Pow(10, _doublePrecision.Magnitude()); - Assert.IsFalse(0.0.IsSmallerWithDecimalPlaces(max, -_doublePrecision.Magnitude())); - Assert.IsFalse(0.0.IsSmallerWithDecimalPlaces(-max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsSmallerDecimal(max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsSmallerDecimal(-max, -_doublePrecision.Magnitude())); max = 0.6 * Math.Pow(10, _doublePrecision.Magnitude()); - Assert.IsTrue(0.0.IsSmallerWithDecimalPlaces(max, -_doublePrecision.Magnitude())); - Assert.IsFalse(0.0.IsSmallerWithDecimalPlaces(-max, -_doublePrecision.Magnitude())); + Assert.IsTrue(0.0.IsSmallerDecimal(max, -_doublePrecision.Magnitude())); + Assert.IsFalse(0.0.IsSmallerDecimal(-max, -_doublePrecision.Magnitude())); } /// /// Compare to with max numbers between with negative number throws ArgumentOutOfRangeException. /// [Test] - public void CompareToWithMaxNumbersBetweenWithNegativeNumberThrowsArgumentOutOfRangeException() + public void CompareToWithMaxNumbersBetweenWithNegativeNumberThrows() { const double Value = 10.0; Assert.Throws(() => Value.CompareTo(Value, -1)); @@ -1070,7 +988,7 @@ namespace MathNet.Numerics.UnitTests /// Compare to with max numbers between with zero number throws ArgumentOutOfRangeException. /// [Test] - public void CompareToWithMaxNumbersBetweenWithZeroNumberThrowsArgumentOutOfRangeException() + public void CompareToWithMaxNumbersBetweenWithZeroNumberThrows() { const double Value = 10.0; Assert.Throws(() => Value.CompareTo(Value, 0)); @@ -1180,50 +1098,50 @@ namespace MathNet.Numerics.UnitTests public void CompareToWithDecimalPlaces() { // compare zero and negative zero - Assert.AreEqual(0, Precision.CompareToInDecimalPlaces(0, -0, 1)); - Assert.AreEqual(0, Precision.CompareToInDecimalPlaces(0, -0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, Precision.CompareToInDecimalPlaces(0, -0, Precision.SingleDecimalPlaces)); + Assert.AreEqual(0, Precision.CompareToDecimal(0, -0, 1)); + Assert.AreEqual(0, Precision.CompareToDecimal(0, -0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, Precision.CompareToDecimal(0, -0, Precision.SingleDecimalPlaces)); // compare two nearby numbers - Assert.AreEqual(-1, 1.0.CompareToInDecimalPlaces(1.0 + 10*_doublePrecision, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, 1.0.CompareToInDecimalPlaces(1.0 + _doublePrecision, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, 1.0.CompareToInDecimalPlaces(1.0 - _doublePrecision, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(1, 1.0.CompareToInDecimalPlaces(1.0 - 10*_doublePrecision, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, 1.0.CompareToDecimal(1.0 + 10*_doublePrecision, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, 1.0.CompareToDecimal(1.0 + _doublePrecision, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, 1.0.CompareToDecimal(1.0 - _doublePrecision, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, 1.0.CompareToDecimal(1.0 - 10*_doublePrecision, Precision.DoubleDecimalPlaces)); // compare with the two numbers reversed in compare order - Assert.AreEqual(1, (1.0 + 10*_doublePrecision).CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, (1.0 + _doublePrecision).CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, (1.0 - _doublePrecision).CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(-1, (1.0 - 10*_doublePrecision).CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, (1.0 + 10*_doublePrecision).CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, (1.0 + _doublePrecision).CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, (1.0 - _doublePrecision).CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, (1.0 - 10*_doublePrecision).CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); // compare two slightly more different numbers - Assert.AreEqual(-1, 1.0.CompareToInDecimalPlaces(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, 1.0.CompareToInDecimalPlaces(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2)); - Assert.AreEqual(0, 1.0.CompareToInDecimalPlaces(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2)); - Assert.AreEqual(1, 1.0.CompareToInDecimalPlaces(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, 1.0.CompareToDecimal(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, 1.0.CompareToDecimal(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2)); + Assert.AreEqual(0, 1.0.CompareToDecimal(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2)); + Assert.AreEqual(1, 1.0.CompareToDecimal(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces)); // compare different numbers - Assert.AreEqual(1, 2.0.CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(-1, 1.0.CompareToInDecimalPlaces(2.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, 2.0.CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, 1.0.CompareToDecimal(2.0, Precision.DoubleDecimalPlaces)); // compare different numbers with large tolerance - Assert.AreEqual(-1, 1.0.CompareToInDecimalPlaces(1.0 + (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, 1.0.CompareToInDecimalPlaces(1.0 - (1e5 * _doublePrecision), 10)); - Assert.AreEqual(1, 1.0.CompareToInDecimalPlaces(1.0 - (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, 1.0.CompareToDecimal(1.0 + (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, 1.0.CompareToDecimal(1.0 - (1e5 * _doublePrecision), 10)); + Assert.AreEqual(1, 1.0.CompareToDecimal(1.0 - (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces)); // compare inf & inf - Assert.AreEqual(0, double.PositiveInfinity.CompareToInDecimalPlaces(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(0, double.NegativeInfinity.CompareToInDecimalPlaces(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, double.PositiveInfinity.CompareToDecimal(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(0, double.NegativeInfinity.CompareToDecimal(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); // compare -inf and inf - Assert.AreEqual(1, double.PositiveInfinity.CompareToInDecimalPlaces(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(-1, double.NegativeInfinity.CompareToInDecimalPlaces(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, double.PositiveInfinity.CompareToDecimal(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, double.NegativeInfinity.CompareToDecimal(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); // compare inf and non-inf - Assert.AreEqual(1, double.PositiveInfinity.CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(-1, 1.0.CompareToInDecimalPlaces(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(-1, double.NegativeInfinity.CompareToInDecimalPlaces(1.0, Precision.DoubleDecimalPlaces)); - Assert.AreEqual(1, 1.0.CompareToInDecimalPlaces(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, double.PositiveInfinity.CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, 1.0.CompareToDecimal(double.PositiveInfinity, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(-1, double.NegativeInfinity.CompareToDecimal(1.0, Precision.DoubleDecimalPlaces)); + Assert.AreEqual(1, 1.0.CompareToDecimal(double.NegativeInfinity, Precision.DoubleDecimalPlaces)); } } } diff --git a/src/UnitTests/RootFindingTests/BisectionTest.cs b/src/UnitTests/RootFindingTests/BisectionTest.cs index 9919a275..02c6e04e 100644 --- a/src/UnitTests/RootFindingTests/BisectionTest.cs +++ b/src/UnitTests/RootFindingTests/BisectionTest.cs @@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests double x = Bisection.FindRoot(f1, 0.1, 1); Assert.AreEqual(0.174749531708621, x, 1e-5); - Assert.AreEqual(0, f1(x), 1e-13); + Assert.AreEqual(0, f1(x), 1e-12); } [Test] @@ -255,7 +255,7 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests double x = Bisection.FindRoot(f1, 0.01, 1); Assert.AreEqual(0.842524411168525, x, 1e-2); - Assert.AreEqual(0, f1(x), 1e-13); + Assert.AreEqual(0, f1(x), 1e-12); } [Test] @@ -416,13 +416,13 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests double x = Bisection.FindRoot(f1, -2, 0); Assert.AreEqual(-0.795219754733581, x, 1e-5); - Assert.AreEqual(0, f1(x), 1e-14); + Assert.AreEqual(0, f1(x), 1e-13); x = Bisection.FindRoot(f1, 0, 2); Assert.AreEqual(1.13413784566692, x, 1e-5); - Assert.AreEqual(0, f1(x), 1e-14); + Assert.AreEqual(0, f1(x), 1e-13); x = Bisection.FindRoot(f1, 2, 5); Assert.AreEqual(2.66108192383197, x, 1e-5); - Assert.AreEqual(0, f1(x), 1e-14); + Assert.AreEqual(0, f1(x), 1e-13); } [Test] diff --git a/src/UnitTests/RootFindingTests/FindRootsTest.cs b/src/UnitTests/RootFindingTests/FindRootsTest.cs index 5eb83081..5321fb27 100644 --- a/src/UnitTests/RootFindingTests/FindRootsTest.cs +++ b/src/UnitTests/RootFindingTests/FindRootsTest.cs @@ -129,8 +129,8 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests double x = FindRoots.OfFunction(f1, 0.1, 1); Assert.AreEqual(0.174749531708621, x, 1e-5); - Assert.AreEqual(0, f1(x), 1e-13); - } + Assert.AreEqual(0, f1(x), 1e-12); + } [Test] public void Oneeq7() @@ -157,7 +157,7 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests double x = FindRoots.OfFunction(f1, 0.01, 1); Assert.AreEqual(0.842524411168525, x, 1e-2); - Assert.AreEqual(0, f1(x), 1e-13); + Assert.AreEqual(0, f1(x), 1e-12); } private void AssertComplexEqual(Complex expected, Complex actual, double delta) @@ -179,8 +179,8 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests // Expected Roots: -u, -v Complex r1 = new Complex(-u, 0d), r2 = new Complex(-v, 0d); - Assert.IsTrue(x1.AlmostEqualWithError(r1, 1e-14) && x2.AlmostEqualWithError(r2, 1e-14) - || x1.AlmostEqualWithError(r2, 1e-14) && x2.AlmostEqualWithError(r1, 1e-14)); + Assert.IsTrue(x1.AlmostEqualRelative(r1, 1e-14) && x2.AlmostEqualRelative(r2, 1e-14) + || x1.AlmostEqualRelative(r2, 1e-14) && x2.AlmostEqualRelative(r1, 1e-14)); // Verify they really are roots AssertComplexEqual(Complex.Zero, c + b*x1 + a*x1*x1, 1e-14); @@ -199,8 +199,8 @@ namespace MathNet.Numerics.UnitTests.RootFindingTests // Expected roots? Complex r1 = new Complex(x1R, x1I), r2 = new Complex(x2R, x2I); - Assert.IsTrue(x1.AlmostEqualWithError(r1, 1e-14) && x2.AlmostEqualWithError(r2, 1e-14) - || x1.AlmostEqualWithError(r2, 1e-14) && x2.AlmostEqualWithError(r1, 1e-14)); + Assert.IsTrue(x1.AlmostEqualRelative(r1, 1e-14) && x2.AlmostEqualRelative(r2, 1e-14) + || x1.AlmostEqualRelative(r2, 1e-14) && x2.AlmostEqualRelative(r1, 1e-14)); // Verify they really are roots AssertComplexEqual(Complex.Zero, c + b*x1 + a*x1*x1, 1e-14); diff --git a/src/UnitTests/SpecialFunctionsTests/ErfTests.cs b/src/UnitTests/SpecialFunctionsTests/ErfTests.cs index e0a385e7..b7198d25 100644 --- a/src/UnitTests/SpecialFunctionsTests/ErfTests.cs +++ b/src/UnitTests/SpecialFunctionsTests/ErfTests.cs @@ -64,7 +64,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(double.NegativeInfinity, -1.0)] public void ErfCanMatchLargePrecision(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.Erf(x), 15); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.Erf(x), 15); } /// @@ -98,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(double.NegativeInfinity, 2.0)] public void ErfcCanMatchLargePrecision(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.Erfc(x), 13); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.Erfc(x), 13); } /// @@ -120,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(2.0, double.NegativeInfinity)] public void ErfcInvCanMatchLargePrecision(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.ErfcInv(x), 8); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.ErfcInv(x), 7); } /// @@ -148,7 +148,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(double.NegativeInfinity, -1.0)] public void ErfInv(double x, double f) { - AssertHelpers.AlmostEqual(x, SpecialFunctions.ErfInv(f), 6); + AssertHelpers.AlmostEqualRelative(x, SpecialFunctions.ErfInv(f), 5); } } } diff --git a/src/UnitTests/SpecialFunctionsTests/FactorialTest.cs b/src/UnitTests/SpecialFunctionsTests/FactorialTest.cs index 7bd777b8..c228333a 100644 --- a/src/UnitTests/SpecialFunctionsTests/FactorialTest.cs +++ b/src/UnitTests/SpecialFunctionsTests/FactorialTest.cs @@ -50,16 +50,16 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests for (var i = 1; i < 23; i++) { factorial *= i; - AssertHelpers.AlmostEqual(factorial, SpecialFunctions.Factorial(i), 14); - AssertHelpers.AlmostEqual(Math.Log(factorial), SpecialFunctions.FactorialLn(i), 14); + AssertHelpers.AlmostEqualRelative(factorial, SpecialFunctions.Factorial(i), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(factorial), SpecialFunctions.FactorialLn(i), 14); } // approximation for (var i = 23; i < 171; i++) { factorial *= i; - AssertHelpers.AlmostEqual(factorial, SpecialFunctions.Factorial(i), 14); - AssertHelpers.AlmostEqual(Math.Log(factorial), SpecialFunctions.FactorialLn(i), 14); + AssertHelpers.AlmostEqualRelative(factorial, SpecialFunctions.Factorial(i), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(factorial), SpecialFunctions.FactorialLn(i), 14); } } @@ -90,10 +90,10 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void FactorialLnDoesNotOverflow() { - AssertHelpers.AlmostEqual(6078.2118847500501140, SpecialFunctions.FactorialLn(1 << 10), 14); - AssertHelpers.AlmostEqual(29978.648060844048236, SpecialFunctions.FactorialLn(1 << 12), 14); - AssertHelpers.AlmostEqual(307933.81973375485425, SpecialFunctions.FactorialLn(1 << 15), 14); - AssertHelpers.AlmostEqual(1413421.9939462073242, SpecialFunctions.FactorialLn(1 << 17), 14); + AssertHelpers.AlmostEqualRelative(6078.2118847500501140, SpecialFunctions.FactorialLn(1 << 10), 14); + AssertHelpers.AlmostEqualRelative(29978.648060844048236, SpecialFunctions.FactorialLn(1 << 12), 14); + AssertHelpers.AlmostEqualRelative(307933.81973375485425, SpecialFunctions.FactorialLn(1 << 15), 14); + AssertHelpers.AlmostEqualRelative(1413421.9939462073242, SpecialFunctions.FactorialLn(1 << 17), 14); } /// @@ -102,13 +102,13 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void CanComputeBinomial() { - AssertHelpers.AlmostEqual(1, SpecialFunctions.Binomial(1, 1), 14); - AssertHelpers.AlmostEqual(10, SpecialFunctions.Binomial(5, 2), 14); - AssertHelpers.AlmostEqual(35, SpecialFunctions.Binomial(7, 3), 14); - AssertHelpers.AlmostEqual(1, SpecialFunctions.Binomial(1, 0), 14); - AssertHelpers.AlmostEqual(0, SpecialFunctions.Binomial(0, 1), 14); - AssertHelpers.AlmostEqual(0, SpecialFunctions.Binomial(5, 7), 14); - AssertHelpers.AlmostEqual(0, SpecialFunctions.Binomial(5, -7), 14); + AssertHelpers.AlmostEqualRelative(1, SpecialFunctions.Binomial(1, 1), 14); + AssertHelpers.AlmostEqualRelative(10, SpecialFunctions.Binomial(5, 2), 14); + AssertHelpers.AlmostEqualRelative(35, SpecialFunctions.Binomial(7, 3), 14); + AssertHelpers.AlmostEqualRelative(1, SpecialFunctions.Binomial(1, 0), 14); + AssertHelpers.AlmostEqualRelative(0, SpecialFunctions.Binomial(0, 1), 14); + AssertHelpers.AlmostEqualRelative(0, SpecialFunctions.Binomial(5, 7), 14); + AssertHelpers.AlmostEqualRelative(0, SpecialFunctions.Binomial(5, -7), 14); } /// @@ -117,13 +117,13 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void CanComputeBinomialLn() { - AssertHelpers.AlmostEqual(Math.Log(1), SpecialFunctions.BinomialLn(1, 1), 14); - AssertHelpers.AlmostEqual(Math.Log(10), SpecialFunctions.BinomialLn(5, 2), 14); - AssertHelpers.AlmostEqual(Math.Log(35), SpecialFunctions.BinomialLn(7, 3), 14); - AssertHelpers.AlmostEqual(Math.Log(1), SpecialFunctions.BinomialLn(1, 0), 14); - AssertHelpers.AlmostEqual(Math.Log(0), SpecialFunctions.BinomialLn(0, 1), 14); - AssertHelpers.AlmostEqual(Math.Log(0), SpecialFunctions.BinomialLn(5, 7), 14); - AssertHelpers.AlmostEqual(Math.Log(0), SpecialFunctions.BinomialLn(5, -7), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(1), SpecialFunctions.BinomialLn(1, 1), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(10), SpecialFunctions.BinomialLn(5, 2), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(35), SpecialFunctions.BinomialLn(7, 3), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(1), SpecialFunctions.BinomialLn(1, 0), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(0), SpecialFunctions.BinomialLn(0, 1), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(0), SpecialFunctions.BinomialLn(5, 7), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(0), SpecialFunctions.BinomialLn(5, -7), 14); } /// @@ -132,10 +132,10 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void CanComputeMultinomial() { - AssertHelpers.AlmostEqual(1, SpecialFunctions.Multinomial(1, new[] { 1, 0 }), 14); - AssertHelpers.AlmostEqual(10, SpecialFunctions.Multinomial(5, new[] { 3, 2 }), 14); - AssertHelpers.AlmostEqual(10, SpecialFunctions.Multinomial(5, new[] { 2, 3 }), 14); - AssertHelpers.AlmostEqual(35, SpecialFunctions.Multinomial(7, new[] { 3, 4 }), 14); + AssertHelpers.AlmostEqualRelative(1, SpecialFunctions.Multinomial(1, new[] { 1, 0 }), 14); + AssertHelpers.AlmostEqualRelative(10, SpecialFunctions.Multinomial(5, new[] { 3, 2 }), 14); + AssertHelpers.AlmostEqualRelative(10, SpecialFunctions.Multinomial(5, new[] { 2, 3 }), 14); + AssertHelpers.AlmostEqualRelative(35, SpecialFunctions.Multinomial(7, new[] { 3, 4 }), 14); } } } diff --git a/src/UnitTests/SpecialFunctionsTests/GammaTests.cs b/src/UnitTests/SpecialFunctionsTests/GammaTests.cs index 0bbaea59..848a6133 100644 --- a/src/UnitTests/SpecialFunctionsTests/GammaTests.cs +++ b/src/UnitTests/SpecialFunctionsTests/GammaTests.cs @@ -61,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(10.1, 13.02752673863323715481371189614224148681183971709386)] public void GammaLn(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLn(x), 14); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.GammaLn(x), 13); } /// @@ -88,25 +88,25 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(10.1, 454760.75144158558537612486797710217749925965322893332)] public void Gamma(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.Gamma(x), 13); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.Gamma(x), 12); } /// /// Gamma lower regularized. /// [TestCase(double.NaN, Double.NaN, Double.NaN, 14)] - [TestCase(0.1, 1.0, 0.97587265627367222115949155252812057714751052498477013, 14)] - [TestCase(0.1, 2.0, 0.99432617602018847196075251078067514034772764693462125, 14)] - [TestCase(0.1, 8.0, 0.99999507519205198048686442150578226823401842046310854, 14)] - [TestCase(1.5, 1.0, 0.42759329552912016600095238564127189392715996802703368, 14)] - [TestCase(1.5, 2.0, 0.73853587005088937779717792402407879809718939080920993, 14)] - [TestCase(1.5, 8.0, 0.99886601571021467734329986257903021041757398191304284, 14)] - [TestCase(2.5, 1.0, 0.15085496391539036377410688601371365034788861473418704, 14)] - [TestCase(2.5, 2.0, 0.45058404864721976739416885516693969548484517509263197, 14)] - [TestCase(2.5, 8.0, 0.99315592607757956900093935107222761316136944145439676, 14)] - [TestCase(5.5, 1.0, 0.0015041182825838038421585211353488839717739161316985392, 14)] - [TestCase(5.5, 2.0, 0.030082976121226050615171484772387355162056796585883967, 14)] - [TestCase(5.5, 8.0, 0.85886911973294184646060071855669224657735916933487681, 14)] + [TestCase(0.1, 1.0, 0.97587265627367222115949155252812057714751052498477013, 13)] + [TestCase(0.1, 2.0, 0.99432617602018847196075251078067514034772764693462125, 13)] + [TestCase(0.1, 8.0, 0.99999507519205198048686442150578226823401842046310854, 13)] + [TestCase(1.5, 1.0, 0.42759329552912016600095238564127189392715996802703368, 13)] + [TestCase(1.5, 2.0, 0.73853587005088937779717792402407879809718939080920993, 13)] + [TestCase(1.5, 8.0, 0.99886601571021467734329986257903021041757398191304284, 13)] + [TestCase(2.5, 1.0, 0.15085496391539036377410688601371365034788861473418704, 13)] + [TestCase(2.5, 2.0, 0.45058404864721976739416885516693969548484517509263197, 13)] + [TestCase(2.5, 8.0, 0.99315592607757956900093935107222761316136944145439676, 13)] + [TestCase(5.5, 1.0, 0.0015041182825838038421585211353488839717739161316985392, 13)] + [TestCase(5.5, 2.0, 0.030082976121226050615171484772387355162056796585883967, 13)] + [TestCase(5.5, 8.0, 0.85886911973294184646060071855669224657735916933487681, 13)] [TestCase(100, 0.5, 0.0, 14)] [TestCase(100, 1.5, 0.0, 14)] [TestCase(100, 90, 0.1582209891864301681049696996709105316998233457433473, 12)] @@ -125,7 +125,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(1e+50, 1e+52, 1.0, 14)] public void GammaLowerRegularized(double a, double x, double f, int digits) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLowerRegularized(a, x), digits); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.GammaLowerRegularized(a, x), digits); } /// @@ -146,25 +146,25 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(5.5, 8.0, 44.955595480196465884619737757794960132425035578313584)] public void GammaLowerIncomplete(double a, double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaLowerIncomplete(a, x), 14); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.GammaLowerIncomplete(a, x), 13); } /// /// Gamma upper regularized. /// [TestCase(double.NaN, Double.NaN, Double.NaN, 14)] - [TestCase(0.1, 1.0, 0.0241273437263277773829694356333550393309597428392044, 14)] - [TestCase(0.1, 2.0, 0.0056738239798115280392474892193248596522723530653781, 14)] - [TestCase(0.1, 8.0, 0.0000049248079480195131355784942177317659815795368919702, 14)] - [TestCase(1.5, 1.0, 0.57240670447087983399904761435872810607284003197297, 14)] - [TestCase(1.5, 2.0, 0.26146412994911062220282207597592120190281060919079, 14)] - [TestCase(1.5, 8.0, 0.0011339842897853226567001374209697895824260180869567, 14)] - [TestCase(2.5, 1.0, 0.84914503608460963622589311398628634965211138526581, 14)] - [TestCase(2.5, 2.0, 0.54941595135278023260583114483306030451515482490737, 14)] - [TestCase(2.5, 8.0, 0.0068440739224204309990606489277723868386305585456026, 14)] - [TestCase(5.5, 1.0, 0.9984958817174161961578414788646511160282260838683, 14)] - [TestCase(5.5, 2.0, 0.96991702387877394938482851522761264483794320341412, 14)] - [TestCase(5.5, 8.0, 0.14113088026705815353939928144330775342264083066512, 14)] + [TestCase(0.1, 1.0, 0.0241273437263277773829694356333550393309597428392044, 13)] + [TestCase(0.1, 2.0, 0.0056738239798115280392474892193248596522723530653781, 13)] + [TestCase(0.1, 8.0, 0.0000049248079480195131355784942177317659815795368919702, 13)] + [TestCase(1.5, 1.0, 0.57240670447087983399904761435872810607284003197297, 13)] + [TestCase(1.5, 2.0, 0.26146412994911062220282207597592120190281060919079, 13)] + [TestCase(1.5, 8.0, 0.0011339842897853226567001374209697895824260180869567, 13)] + [TestCase(2.5, 1.0, 0.84914503608460963622589311398628634965211138526581, 13)] + [TestCase(2.5, 2.0, 0.54941595135278023260583114483306030451515482490737, 13)] + [TestCase(2.5, 8.0, 0.0068440739224204309990606489277723868386305585456026, 13)] + [TestCase(5.5, 1.0, 0.9984958817174161961578414788646511160282260838683, 13)] + [TestCase(5.5, 2.0, 0.96991702387877394938482851522761264483794320341412, 13)] + [TestCase(5.5, 8.0, 0.14113088026705815353939928144330775342264083066512, 13)] [TestCase(100, 0.5, 1.0, 14)] [TestCase(100, 1.5, 1.0, 14)] [TestCase(100, 90, 0.8417790108135698318950303003290894683001766542566526, 12)] @@ -183,7 +183,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(1e+50, 1e+52, 0.0, 14)] public void GammaUpperRegularized(double a, double x, double f, int digits) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaUpperRegularized(a, x), digits); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.GammaUpperRegularized(a, x), digits); } /// @@ -204,7 +204,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(5.5, 8.0, 7.3871823043570542965292707346232335470650967978006)] public void GammaUpperIncomplete(double a, double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.GammaUpperIncomplete(a, x), 14); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.GammaUpperIncomplete(a, x), 13); } } } diff --git a/src/UnitTests/SpecialFunctionsTests/ModifiedBesselTests.cs b/src/UnitTests/SpecialFunctionsTests/ModifiedBesselTests.cs index 00d996dd..9205ab71 100644 --- a/src/UnitTests/SpecialFunctionsTests/ModifiedBesselTests.cs +++ b/src/UnitTests/SpecialFunctionsTests/ModifiedBesselTests.cs @@ -56,7 +56,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(-10.0, 2815.716628466254)] public void BesselI0Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselI0(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselI0(x), 14); } [Test] @@ -76,7 +76,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(-10.0, -2670.988303701255)] public void BesselI1Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselI1(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselI1(x), 14); } [Test] @@ -95,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(100.0, 4.656628229175902e-45)] public void BesselK0Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselK0(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselK0(x), 14); } [Test] @@ -114,7 +114,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(100.0, 4.679853735636909e-45)] public void BesselK1Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselK1(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselK1(x), 14); } } } diff --git a/src/UnitTests/SpecialFunctionsTests/ModifiedStruveTests.cs b/src/UnitTests/SpecialFunctionsTests/ModifiedStruveTests.cs index 047a14de..219d84c7 100644 --- a/src/UnitTests/SpecialFunctionsTests/ModifiedStruveTests.cs +++ b/src/UnitTests/SpecialFunctionsTests/ModifiedStruveTests.cs @@ -48,7 +48,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(-10.0, -2815.652249374595)] public void StruveL0Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.StruveL0(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.StruveL0(x), 13); } [TestCase(0.0, 0.0)] @@ -61,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(-10.0, 2670.358285208483)] public void StruveL1Exact(double x, double expected) { - AssertHelpers.AlmostEqual(expected, SpecialFunctions.StruveL1(x), 14); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.StruveL1(x), 14); } [TestCase(0.0, 1.0)] @@ -77,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests public void BesselI0MStruveL0Exact(double x, double expected) { // Abramowitz/Stegun Table 12.1, 12.2 - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselI0MStruveL0(x), 5); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselI0MStruveL0(x), 4); } [TestCase(0.0, 0.0)] @@ -93,7 +93,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests public void BesselI1MStruveL1Exact(double x, double expected) { // Abramowitz/Stegun Table 12.1, 12.2 - AssertHelpers.AlmostEqual(expected, SpecialFunctions.BesselI1MStruveL1(x), 5); + AssertHelpers.AlmostEqualRelative(expected, SpecialFunctions.BesselI1MStruveL1(x), 5); } } } diff --git a/src/UnitTests/SpecialFunctionsTests/SpecialFunctionsTests.cs b/src/UnitTests/SpecialFunctionsTests/SpecialFunctionsTests.cs index 88de0202..52cd0b31 100644 --- a/src/UnitTests/SpecialFunctionsTests/SpecialFunctionsTests.cs +++ b/src/UnitTests/SpecialFunctionsTests/SpecialFunctionsTests.cs @@ -62,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(10.1, 2.2622143570941481235561593642219403924532310597356171)] public void DiGamma(double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.DiGamma(x), 13); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.DiGamma(x), 12); } /// @@ -88,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(10.1, 2.2622143570941481235561593642219403924532310597356171)] public void DiGammaInv(double x, double f) { - AssertHelpers.AlmostEqual(x, SpecialFunctions.DiGammaInv(f), 13); + AssertHelpers.AlmostEqualRelative(x, SpecialFunctions.DiGammaInv(f), 13); } /// @@ -123,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(1000000)] public void Harmonic(int i) { - AssertHelpers.AlmostEqual(ExactHarmonic(i), SpecialFunctions.Harmonic(i), 13); + AssertHelpers.AlmostEqualRelative(ExactHarmonic(i), SpecialFunctions.Harmonic(i), 12); } /// @@ -132,8 +132,8 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void BetaLn() { - AssertHelpers.AlmostEqual(Math.Log(0.5), SpecialFunctions.BetaLn(1.0, 2.0), 14); - AssertHelpers.AlmostEqual(Math.Log(1.0), SpecialFunctions.BetaLn(1.0, 1.0), 14); + AssertHelpers.AlmostEqualRelative(Math.Log(0.5), SpecialFunctions.BetaLn(1.0, 2.0), 13); + AssertHelpers.AlmostEqualRelative(Math.Log(1.0), SpecialFunctions.BetaLn(1.0, 1.0), 13); } /// @@ -142,8 +142,8 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [Test] public void Beta() { - AssertHelpers.AlmostEqual(0.5, SpecialFunctions.Beta(1.0, 2.0), 14); - AssertHelpers.AlmostEqual(1.0, SpecialFunctions.Beta(1.0, 1.0), 14); + AssertHelpers.AlmostEqualRelative(0.5, SpecialFunctions.Beta(1.0, 2.0), 13); + AssertHelpers.AlmostEqualRelative(1.0, SpecialFunctions.Beta(1.0, 1.0), 13); } /// @@ -203,7 +203,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(5.500000, 5.500000, 0.800000, 0.00074361660080007708142054771607396897718180545812717)] public void BetaIncomplete(double a, double b, double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.BetaIncomplete(a, b, x), 12); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.BetaIncomplete(a, b, x), 11); } /// @@ -263,7 +263,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(5.500000, 5.500000, 0.800000, 0.98491460241721309518021565227501009891015897915977)] public void BetaRegularized(double a, double b, double x, double f) { - AssertHelpers.AlmostEqual(f, SpecialFunctions.BetaRegularized(a, b, x), 12); + AssertHelpers.AlmostEqualRelative(f, SpecialFunctions.BetaRegularized(a, b, x), 11); } /// @@ -282,7 +282,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(1.000000, Double.PositiveInfinity)] public void Logit(double p, double x) { - AssertHelpers.AlmostEqual(x, SpecialFunctions.Logit(p), 15); + AssertHelpers.AlmostEqualRelative(x, SpecialFunctions.Logit(p), 15); } /// @@ -301,7 +301,7 @@ namespace MathNet.Numerics.UnitTests.SpecialFunctionsTests [TestCase(Double.PositiveInfinity, 1.000000)] public void Logistic(double p, double x) { - AssertHelpers.AlmostEqual(x, SpecialFunctions.Logistic(p), 15); + AssertHelpers.AlmostEqualRelative(x, SpecialFunctions.Logistic(p), 14); } } } diff --git a/src/UnitTests/StatisticsTests/CorrelationTests.cs b/src/UnitTests/StatisticsTests/CorrelationTests.cs index a333acb7..ed88e38b 100644 --- a/src/UnitTests/StatisticsTests/CorrelationTests.cs +++ b/src/UnitTests/StatisticsTests/CorrelationTests.cs @@ -71,7 +71,7 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests var dataB = _data["lew"].Data.Take(200); var corr = Correlation.Pearson(dataA, dataB); - AssertHelpers.AlmostEqual(-0.029470861580726, corr, 13); + AssertHelpers.AlmostEqual(-0.029470861580726, corr, 14); } /// @@ -86,7 +86,7 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests var direct = Correlation.Pearson(dataA, dataB); var covariance = dataA.Covariance(dataB)/(dataA.StandardDeviation()*dataB.StandardDeviation()); - AssertHelpers.AlmostEqual(covariance, direct, 13); + AssertHelpers.AlmostEqual(covariance, direct, 14); } /// @@ -110,7 +110,7 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests var dataB = _data["lew"].Data.Take(200); var corr = Correlation.Spearman(dataA, dataB); - AssertHelpers.AlmostEqual(-0.0382856977898528, corr, 13); + AssertHelpers.AlmostEqual(-0.0382856977898528, corr, 14); } /// diff --git a/src/UnitTests/StatisticsTests/DescriptiveStatisticsTests.cs b/src/UnitTests/StatisticsTests/DescriptiveStatisticsTests.cs index ae22faf3..1e1c4f46 100644 --- a/src/UnitTests/StatisticsTests/DescriptiveStatisticsTests.cs +++ b/src/UnitTests/StatisticsTests/DescriptiveStatisticsTests.cs @@ -54,24 +54,15 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests /// public DescriptiveStatisticsTests() { - var lottery = new StatTestData("./data/NIST/Lottery.dat"); - _data.Add("lottery", lottery); - var lew = new StatTestData("./data/NIST/Lew.dat"); - _data.Add("lew", lew); - var mavro = new StatTestData("./data/NIST/Mavro.dat"); - _data.Add("mavro", mavro); - var michelso = new StatTestData("./data/NIST/Michelso.dat"); - _data.Add("michelso", michelso); - var numacc1 = new StatTestData("./data/NIST/NumAcc1.dat"); - _data.Add("numacc1", numacc1); - var numacc2 = new StatTestData("./data/NIST/NumAcc2.dat"); - _data.Add("numacc2", numacc2); - var numacc3 = new StatTestData("./data/NIST/NumAcc3.dat"); - _data.Add("numacc3", numacc3); - var numacc4 = new StatTestData("./data/NIST/NumAcc4.dat"); - _data.Add("numacc4", numacc4); - var meixner = new StatTestData("./data/NIST/Meixner.dat"); - _data.Add("meixner", meixner); + _data.Add("lottery", new StatTestData("./data/NIST/Lottery.dat")); + _data.Add("lew", new StatTestData("./data/NIST/Lew.dat")); + _data.Add("mavro", new StatTestData("./data/NIST/Mavro.dat")); + _data.Add("michelso", new StatTestData("./data/NIST/Michelso.dat")); + _data.Add("numacc1", new StatTestData("./data/NIST/NumAcc1.dat")); + _data.Add("numacc2", new StatTestData("./data/NIST/NumAcc2.dat")); + _data.Add("numacc3", new StatTestData("./data/NIST/NumAcc3.dat")); + _data.Add("numacc4", new StatTestData("./data/NIST/NumAcc4.dat")); + _data.Add("meixner", new StatTestData("./data/NIST/Meixner.dat")); } /// @@ -100,24 +91,24 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests /// Min value. /// Max value. /// Count value. - [TestCase("lottery", 15, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] - [TestCase("lew", 15, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] - [TestCase("mavro", 12, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] - [TestCase("michelso", 12, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] + [TestCase("lottery", 12, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] + [TestCase("lew", 12, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] + [TestCase("mavro", 11, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] + [TestCase("michelso", 11, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] [TestCase("numacc1", 15, 0, 0, 10000002, 10000001, 10000003, 3)] [TestCase("numacc2", 13, 0, -2.003003003003, 1.2, 1.1, 1.3, 1001)] [TestCase("numacc3", 9, 0, -2.003003003003, 1000000.2, 1000000.1, 1000000.3, 1001)] - [TestCase("numacc4", 8, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] + [TestCase("numacc4", 7, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] [TestCase("meixner", 8, -0.016649617280859657, 0.8171318629552635, -0.002042931016531602, -4.825626912281697, 5.3018298664184913, 10000)] public void IEnumerableDouble(string dataSet, int digits, double skewness, double kurtosis, double median, double min, double max, int count) { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.Data); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, digits); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 7); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 7); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 10); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, digits); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 8); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 8); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); @@ -145,10 +136,10 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.Data, true); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, 15); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 9); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 9); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 14); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, 14); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 9); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 9); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); @@ -165,22 +156,22 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests /// Min value. /// Max value. /// Count value. - [TestCase("lottery", 15, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] - [TestCase("lew", 15, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] - [TestCase("mavro", 12, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] - [TestCase("michelso", 12, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] + [TestCase("lottery", 14, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] + [TestCase("lew", 14, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] + [TestCase("mavro", 11, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] + [TestCase("michelso", 11, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] [TestCase("numacc1", 15, 0, 0, 10000002, 10000001, 10000003, 3)] [TestCase("numacc2", 13, 0, -2.003003003003, 1.2, 1.1, 1.3, 1001)] [TestCase("numacc3", 9, 0, -2.003003003003, 1000000.2, 1000000.1, 1000000.3, 1001)] - [TestCase("numacc4", 8, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] + [TestCase("numacc4", 7, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] public void IEnumerableDoubleLowAccuracy(string dataSet, int digits, double skewness, double kurtosis, double median, double min, double max, int count) { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.Data, false); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, digits); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 7); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 7); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 14); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, digits); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 7); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 7); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); @@ -197,22 +188,22 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests /// Min value. /// Max value. /// Count value. - [TestCase("lottery", 15, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] - [TestCase("lew", 15, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] - [TestCase("mavro", 12, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] - [TestCase("michelso", 12, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] + [TestCase("lottery", 14, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] + [TestCase("lew", 14, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] + [TestCase("mavro", 11, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] + [TestCase("michelso", 11, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] [TestCase("numacc1", 15, 0, 0, 10000002, 10000001, 10000003, 3)] [TestCase("numacc2", 13, 0, -2.003003003003, 1.2, 1.1, 1.3, 1001)] [TestCase("numacc3", 9, 0, -2.003003003003, 1000000.2, 1000000.1, 1000000.3, 1001)] - [TestCase("numacc4", 8, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] + [TestCase("numacc4", 7, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] public void IEnumerableNullableDouble(string dataSet, int digits, double skewness, double kurtosis, double median, double min, double max, int count) { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.DataWithNulls); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, digits); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 7); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 7); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 14); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, digits); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 7); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 7); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); @@ -240,10 +231,10 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.DataWithNulls, true); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, 15); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 9); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 9); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 14); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, 14); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 9); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 9); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); @@ -260,22 +251,22 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests /// Min value. /// Max value. /// Count value. - [TestCase("lottery", 15, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] - [TestCase("lew", 15, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] - [TestCase("mavro", 12, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] - [TestCase("michelso", 12, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] + [TestCase("lottery", 14, -0.09333165310779, -1.19256091074856, 522.5, 4, 999, 218)] + [TestCase("lew", 14, -0.050606638756334, -1.49604979214447, -162, -579, 300, 200)] + [TestCase("mavro", 11, 0.64492948110824, -0.82052379677456, 2.0018, 2.0013, 2.0027, 50)] + [TestCase("michelso", 11, -0.0185388637725746, 0.33968459842539, 299.85, 299.62, 300.07, 100)] [TestCase("numacc1", 15, 0, 0, 10000002, 10000001, 10000003, 3)] [TestCase("numacc2", 13, 0, -2.003003003003, 1.2, 1.1, 1.3, 1001)] [TestCase("numacc3", 9, 0, -2.003003003003, 1000000.2, 1000000.1, 1000000.3, 1001)] - [TestCase("numacc4", 8, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] + [TestCase("numacc4", 7, 0, -2.00300300299913, 10000000.2, 10000000.1, 10000000.3, 1001)] public void IEnumerableNullableDoubleLowAccuracy(string dataSet, int digits, double skewness, double kurtosis, double median, double min, double max, int count) { var data = _data[dataSet]; var stats = new DescriptiveStatistics(data.DataWithNulls, false); - AssertHelpers.AlmostEqual(data.Mean, stats.Mean, 15); - AssertHelpers.AlmostEqual(data.StandardDeviation, stats.StandardDeviation, digits); - AssertHelpers.AlmostEqual(skewness, stats.Skewness, 7); - AssertHelpers.AlmostEqual(kurtosis, stats.Kurtosis, 7); + AssertHelpers.AlmostEqualRelative(data.Mean, stats.Mean, 14); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, stats.StandardDeviation, digits); + AssertHelpers.AlmostEqualRelative(skewness, stats.Skewness, 7); + AssertHelpers.AlmostEqualRelative(kurtosis, stats.Kurtosis, 7); Assert.AreEqual(stats.Minimum, min); Assert.AreEqual(stats.Maximum, max); Assert.AreEqual(stats.Count, count); diff --git a/src/UnitTests/StatisticsTests/StatisticsTests.cs b/src/UnitTests/StatisticsTests/StatisticsTests.cs index 5132dbdc..bbc18e88 100644 --- a/src/UnitTests/StatisticsTests/StatisticsTests.cs +++ b/src/UnitTests/StatisticsTests/StatisticsTests.cs @@ -177,12 +177,12 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests public void MeanConsistentWithNistData(string dataSet) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(data.Mean, Statistics.Mean(data.Data), 15); - AssertHelpers.AlmostEqual(data.Mean, ArrayStatistics.Mean(data.Data), 15); - AssertHelpers.AlmostEqual(data.Mean, StreamingStatistics.Mean(data.Data), 15); - AssertHelpers.AlmostEqual(data.Mean, Statistics.MeanVariance(data.Data).Item1, 15); - AssertHelpers.AlmostEqual(data.Mean, ArrayStatistics.MeanVariance(data.Data).Item1, 15); - AssertHelpers.AlmostEqual(data.Mean, StreamingStatistics.MeanVariance(data.Data).Item1, 15); + AssertHelpers.AlmostEqualRelative(data.Mean, Statistics.Mean(data.Data), 14); + AssertHelpers.AlmostEqualRelative(data.Mean, ArrayStatistics.Mean(data.Data), 14); + AssertHelpers.AlmostEqualRelative(data.Mean, StreamingStatistics.Mean(data.Data), 14); + AssertHelpers.AlmostEqualRelative(data.Mean, Statistics.MeanVariance(data.Data).Item1, 14); + AssertHelpers.AlmostEqualRelative(data.Mean, ArrayStatistics.MeanVariance(data.Data).Item1, 14); + AssertHelpers.AlmostEqualRelative(data.Mean, StreamingStatistics.MeanVariance(data.Data).Item1, 14); } [TestCase("lottery")] @@ -196,40 +196,40 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests public void NullableMeanConsistentWithNistData(string dataSet) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(data.Mean, Statistics.Mean(data.DataWithNulls), 15); + AssertHelpers.AlmostEqualRelative(data.Mean, Statistics.Mean(data.DataWithNulls), 14); } - [TestCase("lottery", 15)] - [TestCase("lew", 15)] - [TestCase("mavro", 12)] - [TestCase("michelso", 12)] + [TestCase("lottery", 14)] + [TestCase("lew", 14)] + [TestCase("mavro", 11)] + [TestCase("michelso", 11)] [TestCase("numacc1", 15)] [TestCase("numacc2", 13)] [TestCase("numacc3", 9)] - [TestCase("numacc4", 8)] + [TestCase("numacc4", 7)] public void StandardDeviationConsistentWithNistData(string dataSet, int digits) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(data.StandardDeviation, Statistics.StandardDeviation(data.Data), digits); - AssertHelpers.AlmostEqual(data.StandardDeviation, ArrayStatistics.StandardDeviation(data.Data), digits); - AssertHelpers.AlmostEqual(data.StandardDeviation, StreamingStatistics.StandardDeviation(data.Data), digits); - AssertHelpers.AlmostEqual(data.StandardDeviation, Math.Sqrt(Statistics.MeanVariance(data.Data).Item2), digits); - AssertHelpers.AlmostEqual(data.StandardDeviation, Math.Sqrt(ArrayStatistics.MeanVariance(data.Data).Item2), digits); - AssertHelpers.AlmostEqual(data.StandardDeviation, Math.Sqrt(StreamingStatistics.MeanVariance(data.Data).Item2), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Statistics.StandardDeviation(data.Data), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, ArrayStatistics.StandardDeviation(data.Data), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, StreamingStatistics.StandardDeviation(data.Data), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(Statistics.MeanVariance(data.Data).Item2), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(ArrayStatistics.MeanVariance(data.Data).Item2), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(StreamingStatistics.MeanVariance(data.Data).Item2), digits); } - [TestCase("lottery", 15)] - [TestCase("lew", 15)] - [TestCase("mavro", 12)] - [TestCase("michelso", 12)] + [TestCase("lottery", 14)] + [TestCase("lew", 14)] + [TestCase("mavro", 11)] + [TestCase("michelso", 11)] [TestCase("numacc1", 15)] [TestCase("numacc2", 13)] [TestCase("numacc3", 9)] - [TestCase("numacc4", 8)] + [TestCase("numacc4", 7)] public void NullableStandardDeviationConsistentWithNistData(string dataSet, int digits) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(data.StandardDeviation, Statistics.StandardDeviation(data.DataWithNulls), digits); + AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Statistics.StandardDeviation(data.DataWithNulls), digits); } [Test] @@ -568,17 +568,17 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests // Test around 10^9, potential stability issues var gaussian = new Normal(1e+9, 2, new MersenneTwister(100)); - AssertHelpers.AlmostEqual(1e+9, Statistics.Mean(gaussian.Samples().Take(10000)), 11); - AssertHelpers.AlmostEqual(4d, Statistics.Variance(gaussian.Samples().Take(10000)), 1); - AssertHelpers.AlmostEqual(2d, Statistics.StandardDeviation(gaussian.Samples().Take(10000)), 2); + AssertHelpers.AlmostEqualRelative(1e+9, Statistics.Mean(gaussian.Samples().Take(10000)), 10); + AssertHelpers.AlmostEqualRelative(4d, Statistics.Variance(gaussian.Samples().Take(10000)), 0); + AssertHelpers.AlmostEqualRelative(2d, Statistics.StandardDeviation(gaussian.Samples().Take(10000)), 1); - AssertHelpers.AlmostEqual(1e+9, ArrayStatistics.Mean(gaussian.Samples().Take(10000).ToArray()), 11); - AssertHelpers.AlmostEqual(4d, ArrayStatistics.Variance(gaussian.Samples().Take(10000).ToArray()), 1); - AssertHelpers.AlmostEqual(2d, ArrayStatistics.StandardDeviation(gaussian.Samples().Take(10000).ToArray()), 2); + AssertHelpers.AlmostEqualRelative(1e+9, ArrayStatistics.Mean(gaussian.Samples().Take(10000).ToArray()), 10); + AssertHelpers.AlmostEqualRelative(4d, ArrayStatistics.Variance(gaussian.Samples().Take(10000).ToArray()), 0); + AssertHelpers.AlmostEqualRelative(2d, ArrayStatistics.StandardDeviation(gaussian.Samples().Take(10000).ToArray()), 1); - AssertHelpers.AlmostEqual(1e+9, StreamingStatistics.Mean(gaussian.Samples().Take(10000)), 11); - AssertHelpers.AlmostEqual(4d, StreamingStatistics.Variance(gaussian.Samples().Take(10000)), 1); - AssertHelpers.AlmostEqual(2d, StreamingStatistics.StandardDeviation(gaussian.Samples().Take(10000)), 2); + AssertHelpers.AlmostEqualRelative(1e+9, StreamingStatistics.Mean(gaussian.Samples().Take(10000)), 10); + AssertHelpers.AlmostEqualRelative(4d, StreamingStatistics.Variance(gaussian.Samples().Take(10000)), 0); + AssertHelpers.AlmostEqualRelative(2d, StreamingStatistics.StandardDeviation(gaussian.Samples().Take(10000)), 1); } [TestCase("lottery")] @@ -589,9 +589,9 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests public void CovarianceConsistentWithVariance(string dataSet) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(Statistics.Variance(data.Data), Statistics.Covariance(data.Data, data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.Variance(data.Data), ArrayStatistics.Covariance(data.Data, data.Data), 10); - AssertHelpers.AlmostEqual(StreamingStatistics.Variance(data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(Statistics.Variance(data.Data), Statistics.Covariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.Variance(data.Data), ArrayStatistics.Covariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(StreamingStatistics.Variance(data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10); } [TestCase("lottery")] @@ -602,9 +602,9 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests public void PopulationCovarianceConsistentWithPopulationVariance(string dataSet) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(Statistics.PopulationVariance(data.Data), Statistics.PopulationCovariance(data.Data, data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.PopulationVariance(data.Data), ArrayStatistics.PopulationCovariance(data.Data, data.Data), 10); - AssertHelpers.AlmostEqual(StreamingStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(Statistics.PopulationVariance(data.Data), Statistics.PopulationCovariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.PopulationVariance(data.Data), ArrayStatistics.PopulationCovariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(StreamingStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10); } [Test] @@ -613,13 +613,13 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests var dataA = _data["lottery"].Data.Take(200); var dataB = _data["lew"].Data.Take(200); - AssertHelpers.AlmostEqual(Statistics.Covariance(dataA, dataB), Statistics.Covariance(dataB, dataA), 12); - AssertHelpers.AlmostEqual(StreamingStatistics.Covariance(dataA, dataB), StreamingStatistics.Covariance(dataB, dataA), 12); - AssertHelpers.AlmostEqual(ArrayStatistics.Covariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.Covariance(dataB.ToArray(), dataA.ToArray()), 12); + AssertHelpers.AlmostEqualRelative(Statistics.Covariance(dataA, dataB), Statistics.Covariance(dataB, dataA), 12); + AssertHelpers.AlmostEqualRelative(StreamingStatistics.Covariance(dataA, dataB), StreamingStatistics.Covariance(dataB, dataA), 12); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.Covariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.Covariance(dataB.ToArray(), dataA.ToArray()), 12); - AssertHelpers.AlmostEqual(Statistics.PopulationCovariance(dataA, dataB), Statistics.PopulationCovariance(dataB, dataA), 12); - AssertHelpers.AlmostEqual(StreamingStatistics.PopulationCovariance(dataA, dataB), StreamingStatistics.PopulationCovariance(dataB, dataA), 12); - AssertHelpers.AlmostEqual(ArrayStatistics.PopulationCovariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.PopulationCovariance(dataB.ToArray(), dataA.ToArray()), 12); + AssertHelpers.AlmostEqualRelative(Statistics.PopulationCovariance(dataA, dataB), Statistics.PopulationCovariance(dataB, dataA), 12); + AssertHelpers.AlmostEqualRelative(StreamingStatistics.PopulationCovariance(dataA, dataB), StreamingStatistics.PopulationCovariance(dataB, dataA), 12); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.PopulationCovariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.PopulationCovariance(dataB.ToArray(), dataA.ToArray()), 12); } [TestCase("lottery")] @@ -630,13 +630,13 @@ namespace MathNet.Numerics.UnitTests.StatisticsTests public void ArrayStatisticsConsistentWithStreamimgStatistics(string dataSet) { var data = _data[dataSet]; - AssertHelpers.AlmostEqual(ArrayStatistics.Mean(data.Data), StreamingStatistics.Mean(data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.Variance(data.Data), StreamingStatistics.Variance(data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.StandardDeviation(data.Data), StreamingStatistics.StandardDeviation(data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationVariance(data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.PopulationStandardDeviation(data.Data), StreamingStatistics.PopulationStandardDeviation(data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.Covariance(data.Data, data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10); - AssertHelpers.AlmostEqual(ArrayStatistics.PopulationCovariance(data.Data, data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.Mean(data.Data), StreamingStatistics.Mean(data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.Variance(data.Data), StreamingStatistics.Variance(data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.StandardDeviation(data.Data), StreamingStatistics.StandardDeviation(data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationVariance(data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.PopulationStandardDeviation(data.Data), StreamingStatistics.PopulationStandardDeviation(data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.Covariance(data.Data, data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10); + AssertHelpers.AlmostEqualRelative(ArrayStatistics.PopulationCovariance(data.Data, data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10); } [Test] diff --git a/src/UnitTests/TrigonometryTest.cs b/src/UnitTests/TrigonometryTest.cs index 0ddd0141..da8940c1 100644 --- a/src/UnitTests/TrigonometryTest.cs +++ b/src/UnitTests/TrigonometryTest.cs @@ -59,7 +59,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Cos(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Sin(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -101,7 +101,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Tan(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -117,7 +117,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeCosecant(double value, double expected) { var actual = Trig.Csc(value); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -133,7 +133,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeCosine(double value, double expected) { var actual = Trig.Cos(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -149,7 +149,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeCotangent(double value, double expected) { var actual = Trig.Cot(value); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -165,7 +165,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicCosecant(double value, double expected) { var actual = Trig.Csch(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -181,7 +181,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicCosine(double value, double expected) { var actual = Trig.Cosh(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 15); } /// @@ -197,7 +197,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicCotangent(double value, double expected) { var actual = Trig.Coth(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicSecant(double value, double expected) { var actual = Trig.Sech(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 15); } /// @@ -228,7 +228,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicSine(double value, double expected) { var actual = Trig.Sinh(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 15); } /// @@ -244,7 +244,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeHyperbolicTangent(double value, double expected) { var actual = Trig.Tanh(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 15); } /// @@ -259,7 +259,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseCosecant(double value, double expected) { var actual = Trig.Acsc(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -274,7 +274,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseCosine(double value, double expected) { var actual = Trig.Acos(value); - AssertHelpers.AlmostEqual(expected, actual, 15); + AssertHelpers.AlmostEqualRelative(expected, actual, 15); } /// @@ -290,7 +290,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseCotangent(double value, double expected) { var actual = Trig.Acot(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -306,7 +306,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicCosecant(double value, double expected) { var actual = Trig.Acsch(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -319,7 +319,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicCosine(double value, double expected) { var actual = Trig.Acosh(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -334,7 +334,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicCotangent(double value, double expected) { var actual = Trig.Acoth(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -348,7 +348,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicSecant(double value, double expected) { var actual = Trig.Asech(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -364,7 +364,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicSine(double value, double expected) { var actual = Trig.Asinh(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -380,7 +380,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseHyperbolicTangent(double value, double expected) { var actual = Trig.Atanh(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -395,7 +395,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseSecant(double value, double expected) { var actual = Trig.Asec(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -411,7 +411,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseSine(double value, double expected) { var actual = Trig.Asin(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -427,7 +427,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeInverseTangent(double value, double expected) { var actual = Trig.Atan(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -443,7 +443,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeSecant(double value, double expected) { var actual = Trig.Sec(value); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -459,7 +459,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeSine(double value, double expected) { var actual = Trig.Sin(value); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -475,7 +475,7 @@ namespace MathNet.Numerics.UnitTests public void CanComputeTangent(double value, double expected) { var actual = Trig.Tan(value); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -484,7 +484,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertDegreeToGrad() { - AssertHelpers.AlmostEqual(90 / .9, Trig.DegreeToGrad(90), 15); + AssertHelpers.AlmostEqualRelative(90 / .9, Trig.DegreeToGrad(90), 15); } /// @@ -493,7 +493,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertDegreeToRadian() { - AssertHelpers.AlmostEqual(Math.PI / 2, Trig.DegreeToRadian(90), 15); + AssertHelpers.AlmostEqualRelative(Math.PI / 2, Trig.DegreeToRadian(90), 15); } /// @@ -502,7 +502,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertGradToDegree() { - AssertHelpers.AlmostEqual(180, Trig.GradToDegree(200), 15); + AssertHelpers.AlmostEqualRelative(180, Trig.GradToDegree(200), 15); } /// @@ -511,7 +511,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertGradToRadian() { - AssertHelpers.AlmostEqual(Math.PI, Trig.GradToRadian(200), 15); + AssertHelpers.AlmostEqualRelative(Math.PI, Trig.GradToRadian(200), 15); } /// @@ -520,7 +520,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertRadianToDegree() { - AssertHelpers.AlmostEqual(60.0, Trig.RadianToDegree(Math.PI / 3.0), 15); + AssertHelpers.AlmostEqualRelative(60.0, Trig.RadianToDegree(Math.PI / 3.0), 14); } /// @@ -529,7 +529,7 @@ namespace MathNet.Numerics.UnitTests [Test] public void CanConvertRadianToGrad() { - AssertHelpers.AlmostEqual(200.0 / 3.0, Trig.RadianToGrad(Math.PI / 3.0), 15); + AssertHelpers.AlmostEqualRelative(200.0 / 3.0, Trig.RadianToGrad(Math.PI / 3.0), 14); } /// @@ -550,7 +550,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Cot(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -571,7 +571,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Sec(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -592,7 +592,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Csc(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 13); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -614,7 +614,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Sinh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -636,7 +636,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Cosh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -658,7 +658,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Tanh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -680,7 +680,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Coth(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -702,7 +702,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Sech(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -724,7 +724,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Csch(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -748,7 +748,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Asin(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } /// @@ -772,7 +772,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acos(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -794,7 +794,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Atan(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -816,7 +816,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acot(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -837,7 +837,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Asec(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -858,7 +858,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acsc(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -879,7 +879,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Asinh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 12); } /// @@ -900,7 +900,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acosh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -921,7 +921,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Atanh(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -942,7 +942,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acoth(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -963,7 +963,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Asech(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 14); } /// @@ -984,7 +984,7 @@ namespace MathNet.Numerics.UnitTests { var actual = new Complex(real, imag).Acsch(); var expected = new Complex(expectedReal, expectedImag); - AssertHelpers.AlmostEqual(expected, actual, 14); + AssertHelpers.AlmostEqualRelative(expected, actual, 13); } } }