From 5d62e334a37844db89dc2fe9d18947ba2e218a70 Mon Sep 17 00:00:00 2001 From: Christoph Ruegg Date: Tue, 26 May 2009 10:50:27 +0200 Subject: [PATCH] major numeric almost-equality refactoring --- .gitignore | 1 + .../Library/ComplexPolynomial.cs | 14 +- .../Library/EqualityComparers.cs | 339 ----------- .../MathNet.Iridium/Library/Iridium.csproj | 1 - .../Library/LinearAlgebra/ComplexMatrix.cs | 12 +- .../Library/LinearAlgebra/ComplexVector.cs | 4 +- .../Library/LinearAlgebra/Matrix.cs | 12 +- .../Library/LinearAlgebra/Vector.cs | 4 +- src/app/MathNet.Iridium/Library/Number.cs | 82 ++- src/app/MathNet.Iridium/Library/Polynomial.cs | 14 +- .../MathNet.Iridium.Test/BugRegression.cs | 38 +- src/test/MathNet.Iridium.Test/CodeSamples.cs | 20 +- .../CombinatoricsTests/CombinatoricsTest.cs | 2 +- .../DistributionTests/DistributionTest.cs | 80 +-- .../InfrastructureTests/AlmostEqualityTest.cs | 48 +- .../InfrastructureTests/ComplexTest.cs | 4 +- .../InfrastructureTests/SerializationTest.cs | 13 +- .../IntegrationTests/IntegrationTest.cs | 146 ++--- .../InterpolationTests/InterpolationTest.cs | 260 ++++---- .../MathNet.Iridium.Test/Iridium.Test.csproj | 2 +- .../ComplexMatrixArithmeticsTest.cs | 166 +++--- .../LinearAlgebraTests/LinearAlgebra.Test.cs | 94 +-- .../LinearAlgebraAlgorithmsTest.cs | 36 +- .../MatrixArithmeticsTest.cs | 93 ++- .../MathNet.Iridium.Test/NumericAssert.cs | 116 ---- src/test/MathNet.Iridium.Test/NumericIs.cs | 152 +++++ .../ExcelStatisticsTests.cs | 62 +- .../SpecialFunctionsTest.cs | 562 +++++++++--------- .../StatisticsTests/StatisticsTest.cs | 32 +- .../TransformationsTests/FftTest.cs | 332 +++++------ 30 files changed, 1211 insertions(+), 1530 deletions(-) delete mode 100644 src/app/MathNet.Iridium/Library/EqualityComparers.cs delete mode 100644 src/test/MathNet.Iridium.Test/NumericAssert.cs create mode 100644 src/test/MathNet.Iridium.Test/NumericIs.cs diff --git a/.gitignore b/.gitignore index 0c385c1..64672eb 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ obj build verification .svn +_ReSharper* diff --git a/src/app/MathNet.Iridium/Library/ComplexPolynomial.cs b/src/app/MathNet.Iridium/Library/ComplexPolynomial.cs index 84a14e0..81fd126 100644 --- a/src/app/MathNet.Iridium/Library/ComplexPolynomial.cs +++ b/src/app/MathNet.Iridium/Library/ComplexPolynomial.cs @@ -1636,7 +1636,7 @@ public static ComplexPolynomial v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(u, v, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -1648,7 +1648,7 @@ public static ComplexPolynomial u, ComplexPolynomial v) { - return EqualityComparers.AlmostEqual(u, v); + return Number.AlmostEqual(u, v); } /// @@ -1657,15 +1657,15 @@ public static public static bool Equal( - ComplexPolynomial polynomial1, - ComplexPolynomial polynomial2) + ComplexPolynomial u, + ComplexPolynomial v) { - if(object.ReferenceEquals(polynomial1, null)) + if(object.ReferenceEquals(u, null)) { - return object.ReferenceEquals(polynomial2, null); + return object.ReferenceEquals(v, null); } - return polynomial1.Equals(polynomial2); + return u.Equals(v); } /// diff --git a/src/app/MathNet.Iridium/Library/EqualityComparers.cs b/src/app/MathNet.Iridium/Library/EqualityComparers.cs deleted file mode 100644 index 32a78f9..0000000 --- a/src/app/MathNet.Iridium/Library/EqualityComparers.cs +++ /dev/null @@ -1,339 +0,0 @@ -//----------------------------------------------------------------------- -// -// Copyright (c) 2002-2009, Christoph Rüegg. -// All Right Reserved. -// -// -// Christoph Rüegg, http://christoph.ruegg.name -// -// -// Math.NET Iridium, part of the Math.NET Project. -// http://mathnet.opensourcedotnet.info -// -// -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published -// by the Free Software Foundation; either version 2 of the License, or -// any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -// -//----------------------------------------------------------------------- - -using System; -using System.Collections.Generic; -using System.Text; -using MathNet.Numerics.LinearAlgebra; - -namespace MathNet.Numerics -{ - /// - /// Factory for equality comparers with a parametric maximum relative error - /// - public static class EqualityComparers - { - /// - /// True if two instances of T are almost equal, up to the default maximum relative error. - /// - public static - bool - AlmostEqual( - T x, - T y) - where T : IAlmostEquatable - { - if(object.ReferenceEquals(x, y)) - { - return true; - } - - if(object.ReferenceEquals(x, null) || object.ReferenceEquals(y, null)) - { - return false; - } - - return x.AlmostEquals(y); - } - - /// - /// True if two instances of T are almost equal, up to the provided maximum relative error. - /// - public static - bool - AlmostEqual( - T x, - T y, - double maximumRelativeError) - where T : IAlmostEquatable - { - if(object.ReferenceEquals(x, y)) - { - return true; - } - - if(object.ReferenceEquals(x, null) || object.ReferenceEquals(y, null)) - { - return false; - } - - return x.AlmostEquals(y, maximumRelativeError); - } - - /// - /// Create an equality comparer for real floating point numbers with a custom maximum relative error. - /// - /// Maximum relative error of the two numbers. - /// - public static - IEqualityComparer - ForDouble(double maximumRelativeError) - { - return new DoubleEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for real floating point numbers with the default maximum relative error. - /// - /// - public static - IEqualityComparer - ForDouble() - { - return new DoubleEqualityComparer(Number.DefaultRelativeAccuracy); - } - - /// - /// Create an equality comparer for complex floating point numbers with a custom maximum relative error. - /// - /// Maximum relative error of the absolute difference. - /// - public static - IEqualityComparer - ForComplex(double maximumRelativeError) - { - return new ComplexEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for complex floating point numbers with the default maximum relative error. - /// - /// - public static - IEqualityComparer - ForComplex() - { - return new ComplexEqualityComparer(Number.DefaultRelativeAccuracy); - } - - /// - /// Create an equality comparer for real vectors with a custom maximum relative error. - /// - /// Maximum relative error of the Vector difference 1-Norm. - /// - public static - IEqualityComparer - ForVector(double maximumRelativeError) - { - return new VectorEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for complex vectors with a custom maximum relative error. - /// - /// Maximum relative error of the Vector difference 1-Norm. - /// - public static - IEqualityComparer - ForComplexVector(double maximumRelativeError) - { - return new ComplexVectorEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for real matrices with a custom maximum relative error. - /// - /// Maximum relative error of the Matrix difference 1-Norm. - /// - public static - IEqualityComparer - ForMatrix(double maximumRelativeError) - { - return new MatrixEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for real matrices with the default maximum relative error. - /// - /// - public static - IEqualityComparer - ForMatrix() - { - return new MatrixEqualityComparer(10 * Number.DefaultRelativeAccuracy); - } - - /// - /// Create an equality comparer for complex matrices with a custom maximum relative error. - /// - /// Maximum relative error of the Matrix difference 1-Norm. - /// - public static - IEqualityComparer - ForComplexMatrix(double maximumRelativeError) - { - return new ComplexMatrixEqualityComparer(maximumRelativeError); - } - - /// - /// Create an equality comparer for complex matrices with the default maximum relative error. - /// - /// - public static - IEqualityComparer - ForComplexMatrix() - { - return new ComplexMatrixEqualityComparer(10 * Number.DefaultRelativeAccuracy); - } - - private class DoubleEqualityComparer : IEqualityComparer - { - private double _maxRelativeError; - - public DoubleEqualityComparer(double maximumRelativeError) - { - _maxRelativeError = maximumRelativeError; - } - - public bool Equals(double x, double y) - { - return Number.AlmostEqual(x, y, _maxRelativeError); - } - - public int GetHashCode(double obj) - { - return ((double)obj).GetHashCode(); - } - } - - private abstract class NormEqualityComparer : IEqualityComparer - { - private double _maxRelativeError; - - public NormEqualityComparer(double maximumRelativeError) - { - _maxRelativeError = maximumRelativeError; - } - - protected abstract double NormOf(T value); - - protected abstract double DifferenceNormOf(T x, T y); - - public bool Equals(T x, T y) - { - return Number.AlmostEqualNorm(NormOf(x), NormOf(y), DifferenceNormOf(x, y), _maxRelativeError); - } - - public int GetHashCode(T obj) - { - return obj.GetHashCode(); - } - } - - private class ComplexEqualityComparer : NormEqualityComparer - { - public ComplexEqualityComparer(double maximumRelativeError) - : base(maximumRelativeError) - { - } - - protected override double NormOf(Complex value) - { - return value.Modulus; - } - - protected override double DifferenceNormOf(Complex x, Complex y) - { - return (x - y).Modulus; - } - } - - private class MatrixEqualityComparer : NormEqualityComparer - { - public MatrixEqualityComparer(double maximumRelativeError) - : base(maximumRelativeError) - { - } - - protected override double NormOf(Matrix value) - { - return value.Norm1(); - } - - protected override double DifferenceNormOf(Matrix x, Matrix y) - { - return (x - y).Norm1(); - } - } - - private class ComplexMatrixEqualityComparer : NormEqualityComparer - { - public ComplexMatrixEqualityComparer(double maximumRelativeError) - : base(maximumRelativeError) - { - } - - protected override double NormOf(ComplexMatrix value) - { - return value.Norm1(); - } - - protected override double DifferenceNormOf(ComplexMatrix x, ComplexMatrix y) - { - return (x - y).Norm1(); - } - } - - private class VectorEqualityComparer : NormEqualityComparer - { - public VectorEqualityComparer(double maximumRelativeError) - : base(maximumRelativeError) - { - } - - protected override double NormOf(Vector value) - { - return value.Norm1(); - } - - protected override double DifferenceNormOf(Vector x, Vector y) - { - return (x - y).Norm1(); - } - } - - private class ComplexVectorEqualityComparer : NormEqualityComparer - { - public ComplexVectorEqualityComparer(double maximumRelativeError) - : base(maximumRelativeError) - { - } - - protected override double NormOf(ComplexVector value) - { - return value.Norm1(); - } - - protected override double DifferenceNormOf(ComplexVector x, ComplexVector y) - { - return (x - y).Norm1(); - } - } - } -} diff --git a/src/app/MathNet.Iridium/Library/Iridium.csproj b/src/app/MathNet.Iridium/Library/Iridium.csproj index 04268fd..9987957 100644 --- a/src/app/MathNet.Iridium/Library/Iridium.csproj +++ b/src/app/MathNet.Iridium/Library/Iridium.csproj @@ -89,7 +89,6 @@ - diff --git a/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexMatrix.cs b/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexMatrix.cs index 117946c..a9321bc 100644 --- a/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexMatrix.cs +++ b/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexMatrix.cs @@ -3085,11 +3085,11 @@ public override public static bool AlmostEqual( - ComplexMatrix x, - ComplexMatrix y, + ComplexMatrix u, + ComplexMatrix v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(x, y, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -3098,10 +3098,10 @@ public static public static bool AlmostEqual( - ComplexMatrix x, - ComplexMatrix y) + ComplexMatrix u, + ComplexMatrix v) { - return EqualityComparers.AlmostEqual(x, y); + return Number.AlmostEqual(u, v); } /// diff --git a/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexVector.cs b/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexVector.cs index e619c0b..a5ea49e 100644 --- a/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexVector.cs +++ b/src/app/MathNet.Iridium/Library/LinearAlgebra/ComplexVector.cs @@ -1536,7 +1536,7 @@ public static ComplexVector v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(u, v, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -1548,7 +1548,7 @@ public static ComplexVector u, ComplexVector v) { - return EqualityComparers.AlmostEqual(u, v); + return Number.AlmostEqual(u, v); } /// diff --git a/src/app/MathNet.Iridium/Library/LinearAlgebra/Matrix.cs b/src/app/MathNet.Iridium/Library/LinearAlgebra/Matrix.cs index 49a4c6e..c2dc382 100644 --- a/src/app/MathNet.Iridium/Library/LinearAlgebra/Matrix.cs +++ b/src/app/MathNet.Iridium/Library/LinearAlgebra/Matrix.cs @@ -2582,11 +2582,11 @@ public override public static bool AlmostEqual( - Matrix x, - Matrix y, + Matrix u, + Matrix v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(x, y, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -2595,10 +2595,10 @@ public static public static bool AlmostEqual( - Matrix x, - Matrix y) + Matrix u, + Matrix v) { - return EqualityComparers.AlmostEqual(x, y); + return Number.AlmostEqual(u, v); } /// diff --git a/src/app/MathNet.Iridium/Library/LinearAlgebra/Vector.cs b/src/app/MathNet.Iridium/Library/LinearAlgebra/Vector.cs index 381345a..b9df2a7 100644 --- a/src/app/MathNet.Iridium/Library/LinearAlgebra/Vector.cs +++ b/src/app/MathNet.Iridium/Library/LinearAlgebra/Vector.cs @@ -1189,7 +1189,7 @@ public static Vector v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(u, v, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -1201,7 +1201,7 @@ public static Vector u, Vector v) { - return EqualityComparers.AlmostEqual(u, v); + return Number.AlmostEqual(u, v); } /// diff --git a/src/app/MathNet.Iridium/Library/Number.cs b/src/app/MathNet.Iridium/Library/Number.cs index 24f3a43..7d2208c 100644 --- a/src/app/MathNet.Iridium/Library/Number.cs +++ b/src/app/MathNet.Iridium/Library/Number.cs @@ -31,6 +31,7 @@ using System.Collections.Generic; using System.Runtime.InteropServices; using System.Text; +using MathNet.Numerics.Properties; namespace MathNet.Numerics { @@ -54,7 +55,7 @@ namespace MathNet.Numerics public static class Number { /// 2^(-1074) - public const double SmallestNumberGreaterThanZero = double.Epsilon; + public const double SmallestNumberGreaterThanZero = Double.Epsilon; /// 2^(-53) public static readonly double RelativeAccuracy = EpsilonOf(1.0); @@ -75,9 +76,9 @@ public static double EpsilonOf(double value) { - if(double.IsInfinity(value) || double.IsNaN(value)) + if(Double.IsInfinity(value) || Double.IsNaN(value)) { - return double.NaN; + return Double.NaN; } long signed64 = BitConverter.DoubleToInt64Bits(value); @@ -120,7 +121,7 @@ public static double Increment(double value) { - if(double.IsInfinity(value) || double.IsNaN(value)) + if(Double.IsInfinity(value) || Double.IsNaN(value)) { return value; } @@ -144,8 +145,8 @@ public static value = BitConverter.Int64BitsToDouble(signed64); - return double.IsNaN(value) - ? double.NaN + return Double.IsNaN(value) + ? Double.NaN : value; } @@ -160,7 +161,7 @@ public static double Decrement(double value) { - if(double.IsInfinity(value) || double.IsNaN(value)) + if(Double.IsInfinity(value) || Double.IsNaN(value)) { return value; } @@ -168,7 +169,7 @@ public static long signed64 = BitConverter.DoubleToInt64Bits(value); if(signed64 == 0) { - return -double.Epsilon; + return -Double.Epsilon; } if(signed64 < 0) @@ -182,8 +183,8 @@ public static value = BitConverter.Int64BitsToDouble(signed64); - return double.IsNaN(value) - ? double.NaN + return Double.IsNaN(value) + ? Double.NaN : value; } @@ -198,14 +199,14 @@ public static double a, double b) { - if(double.IsNaN(a) || double.IsInfinity(a)) + if(Double.IsNaN(a) || Double.IsInfinity(a)) { - throw new ArgumentException(Properties.LocalStrings.ArgumentNotInfinityNaN, "a"); + throw new ArgumentException(LocalStrings.ArgumentNotInfinityNaN, "a"); } - if(double.IsNaN(b) || double.IsInfinity(b)) + if(Double.IsNaN(b) || Double.IsInfinity(b)) { - throw new ArgumentException(Properties.LocalStrings.ArgumentNotInfinityNaN, "b"); + throw new ArgumentException(LocalStrings.ArgumentNotInfinityNaN, "b"); } ulong ua = ToLexicographicalOrderedUInt64(a); @@ -303,11 +304,11 @@ public static { if(maxNumbersBetween < 0) { - throw new ArgumentException(Properties.LocalStrings.ArgumentNotNegative, "maxNumbersBetween"); + throw new ArgumentException(LocalStrings.ArgumentNotNegative, "maxNumbersBetween"); } // NaN's should never equal to anything - if(double.IsNaN(a) || double.IsNaN(b)) + if(Double.IsNaN(a) || Double.IsNaN(b)) { /* (a != a || b != b) */ @@ -320,7 +321,7 @@ public static } // false, if only one of them is infinity or they differ on the infinity sign - if(double.IsInfinity(a) || double.IsInfinity(b)) + if(Double.IsInfinity(a) || Double.IsInfinity(b)) { return false; } @@ -513,5 +514,52 @@ public static return a; } + + /// + /// True if two instances of T are almost equal, up to the default maximum relative error. + /// + public static + bool + AlmostEqual( + T x, + T y) + where T : IAlmostEquatable + { + if(ReferenceEquals(x, y)) + { + return true; + } + + if(ReferenceEquals(x, null) || ReferenceEquals(y, null)) + { + return false; + } + + return x.AlmostEquals(y); + } + + /// + /// True if two instances of T are almost equal, up to the provided maximum relative error. + /// + public static + bool + AlmostEqual( + T x, + T y, + double maximumRelativeError) + where T : IAlmostEquatable + { + if(ReferenceEquals(x, y)) + { + return true; + } + + if(ReferenceEquals(x, null) || ReferenceEquals(y, null)) + { + return false; + } + + return x.AlmostEquals(y, maximumRelativeError); + } } } diff --git a/src/app/MathNet.Iridium/Library/Polynomial.cs b/src/app/MathNet.Iridium/Library/Polynomial.cs index a6339eb..2cfc9e0 100644 --- a/src/app/MathNet.Iridium/Library/Polynomial.cs +++ b/src/app/MathNet.Iridium/Library/Polynomial.cs @@ -1132,7 +1132,7 @@ public static Polynomial v, double maximumRelativeError) { - return EqualityComparers.AlmostEqual(u, v, maximumRelativeError); + return Number.AlmostEqual(u, v, maximumRelativeError); } /// @@ -1144,7 +1144,7 @@ public static Polynomial u, Polynomial v) { - return EqualityComparers.AlmostEqual(u, v); + return Number.AlmostEqual(u, v); } /// @@ -1153,15 +1153,15 @@ public static public static bool Equal( - Polynomial polynomial1, - Polynomial polynomial2) + Polynomial u, + Polynomial v) { - if(object.ReferenceEquals(polynomial1, null)) + if(object.ReferenceEquals(u, null)) { - return object.ReferenceEquals(polynomial2, null); + return object.ReferenceEquals(v, null); } - return polynomial1.Equals(polynomial2); + return u.Equals(v); } /// diff --git a/src/test/MathNet.Iridium.Test/BugRegression.cs b/src/test/MathNet.Iridium.Test/BugRegression.cs index 02804d5..edbe32f 100644 --- a/src/test/MathNet.Iridium.Test/BugRegression.cs +++ b/src/test/MathNet.Iridium.Test/BugRegression.cs @@ -49,14 +49,14 @@ public void IRID77_NegativeComplexLogarithm() Complex minusOne = -Complex.One; Complex piI = minusOne.NaturalLogarithm(); - NumericAssert.AreAlmostEqual(0.0, piI.Real, "Re{ln(-1)} = 0"); - NumericAssert.AreAlmostEqual(Constants.Pi, piI.Imag, "Im{ln(-1)} = Pi"); + Assert.That(piI.Real, NumericIs.AlmostEqualTo(0.0), "Re{ln(-1)} = 0"); + Assert.That(piI.Imag, NumericIs.AlmostEqualTo(Constants.Pi), "Im{ln(-1)} = Pi"); Complex zero = Complex.Zero; Complex lnZero = zero.NaturalLogarithm(); Assert.That(lnZero.Real, Is.EqualTo(double.NegativeInfinity), "Re{ln(0)} = -infinity"); - NumericAssert.AreAlmostEqual(0, lnZero.Imag, "Im{ln(0)} = 0"); + Assert.That(lnZero.Imag, NumericIs.AlmostEqualTo((double) 0), "Im{ln(0)} = 0"); } [Test] @@ -70,9 +70,9 @@ public void IRID90_CholeskySolve() Matrix inv1a = cd1.Solve(i); Matrix test1a = m1 * inv1a; - NumericAssert.AreAlmostEqual(i, test1a, "1A"); + Assert.That(test1a, NumericIs.AlmostEqualTo(i), "1A"); Matrix inv1b = m1.Inverse(); - NumericAssert.AreAlmostEqual(inv1a, inv1b, "1B"); + Assert.That(inv1b, NumericIs.AlmostEqualTo(inv1a), "1B"); double[][] pvals2 = { new double[] { 25, -5, 10 }, new double[] { -5, 17, 10 }, new double[] { 10, 10, 62 } }; Matrix m2 = new Matrix(pvals2); @@ -80,17 +80,17 @@ public void IRID90_CholeskySolve() Matrix inv2a = cd2.Solve(i); Matrix test2a = m2 * inv2a; - NumericAssert.AreAlmostEqual(i, test2a, "2A"); + Assert.That(test2a, NumericIs.AlmostEqualTo(i), "2A"); Matrix inv2b = m2.Inverse(); - NumericAssert.AreAlmostEqual(inv2a, inv2b, "2B"); + Assert.That(inv2b, NumericIs.AlmostEqualTo(inv2a), "2B"); } [Test] public void IRID107_ComplexPowerAtZero() { Complex zeroPowTwo = Complex.Zero.Power(2); - NumericAssert.AreAlmostEqual(0d, zeroPowTwo.Real, "Re{(0)^(2)} = 0"); - NumericAssert.AreAlmostEqual(0d, zeroPowTwo.Imag, "Im{(0)^(2)} = 0"); + Assert.That(zeroPowTwo.Real, NumericIs.AlmostEqualTo(0d), "Re{(0)^(2)} = 0"); + Assert.That(zeroPowTwo.Imag, NumericIs.AlmostEqualTo(0d), "Im{(0)^(2)} = 0"); } [Test] @@ -109,7 +109,7 @@ public void IRID119_PolynomialExtrapolatePositiveDirection() } pia.Prepare(sl); - NumericAssert.AreAlmostEqual(0.9622, pia.Extrapolate(12), 1e-3, "extrapolate(12)"); + Assert.That(pia.Extrapolate(12), NumericIs.AlmostEqualTo(0.9622, 1e-3), "extrapolate(12)"); } [Test] @@ -137,8 +137,8 @@ public void IRID177_MatrixPseudoInverse() new double[] { 0.0265993197732062, -0.114057602060568, -0.0159589740025151 } }); - NumericAssert.AreAlmostEqual(aInverse, a.Inverse(), "A"); - NumericAssert.AreAlmostEqual(Matrix.Transpose(aInverse), Matrix.Transpose(a).Inverse(), "B"); + Assert.That(a.Inverse(), NumericIs.AlmostEqualTo(aInverse, 1e-14), "A"); + Assert.That(Matrix.Transpose(a).Inverse(), NumericIs.AlmostEqualTo(Matrix.Transpose(aInverse), 1e-14), "B"); } [Test] @@ -250,7 +250,7 @@ public void IRID182_Eigenvalues() // Verify the eigen values ComplexVector eigenValues = m.EigenValues; Assert.That(eigenValues.Length, Is.EqualTo(12), "Eigenvalue Length"); - NumericAssert.AreAlmostEqual(expectedEigenValues, eigenValues, 1e-13, "Eigenvalue Values"); + Assert.That(eigenValues, NumericIs.AlmostEqualTo(expectedEigenValues, 1e-13), "Eigenvalue Values"); // verify the eigen vectors, except the first 4 (since their eigen values are 0) Matrix eigenVectors = m.EigenVectors; @@ -273,7 +273,7 @@ public void IRID182_Eigenvalues() } // Compare - NumericAssert.AreAlmostEqual(a, b, 1e-11, "Eigenvector Values: " + i.ToString()); + Assert.That(b, NumericIs.AlmostEqualTo(a, 1e-11), "Eigenvector Values: " + i.ToString()); } } @@ -300,12 +300,12 @@ public void IRID203_PolynomialAddition() [Test] public void IRID204_GammaRegularizedSmallA() { - NumericAssert.AreAlmostEqual(.97815275356248035867, Fn.GammaRegularized(0.1, 1.0625), 1e-13, "A"); - NumericAssert.AreAlmostEqual(.99800133196409378795, Fn.GammaRegularized(0.01, 1.0625), 1e-13, "B"); - NumericAssert.AreAlmostEqual(.99980203148024635861, Fn.GammaRegularized(0.001, 1.0625), 1e-13, "C"); - NumericAssert.AreAlmostEqual(.99998022216513016030, Fn.GammaRegularized(0.0001, 1.0625), 1e-13, "D"); + Assert.That(Fn.GammaRegularized(0.1, 1.0625), NumericIs.AlmostEqualTo(.97815275356248035867, 1e-13), "A"); + Assert.That(Fn.GammaRegularized(0.01, 1.0625), NumericIs.AlmostEqualTo(.99800133196409378795, 1e-13), "B"); + Assert.That(Fn.GammaRegularized(0.001, 1.0625), NumericIs.AlmostEqualTo(.99980203148024635861, 1e-13), "C"); + Assert.That(Fn.GammaRegularized(0.0001, 1.0625), NumericIs.AlmostEqualTo(.99998022216513016030, 1e-13), "D"); - NumericAssert.AreAlmostEqual(.99667704526159905093, Fn.GammaRegularized(0.016512683231958761, 1.0625), 1e-13, "X"); + Assert.That(Fn.GammaRegularized(0.016512683231958761, 1.0625), NumericIs.AlmostEqualTo(.99667704526159905093, 1e-13), "X"); } [Test] diff --git a/src/test/MathNet.Iridium.Test/CodeSamples.cs b/src/test/MathNet.Iridium.Test/CodeSamples.cs index 4009be6..31a61bd 100644 --- a/src/test/MathNet.Iridium.Test/CodeSamples.cs +++ b/src/test/MathNet.Iridium.Test/CodeSamples.cs @@ -46,7 +46,7 @@ public void CodeSample_Combinatorics_Permutation() int[] numbers = new int[] { 1, 2, 3, 4, 5 }; int count = numbers.Length; - NumericAssert.AreAlmostEqual(120.0, Combinatorics.Permutations(count), "perm(5)"); + Assert.That(Combinatorics.Permutations(count), NumericIs.AlmostEqualTo(120.0), "perm(5)"); int[] permutation = new int[count]; Combinatorics.RandomShuffle(numbers, permutation); @@ -61,16 +61,16 @@ public void CodeSample_LinearAlgebra_Eigen() }); ComplexVector eigenValues = m.EigenValues; - NumericAssert.AreAlmostEqual(1.0, eigenValues[0].Real, "Re{eigenvalueA}"); - NumericAssert.AreAlmostEqual(0.0, eigenValues[0].Imag, "Im{eigenvalueA}"); - NumericAssert.AreAlmostEqual(-2.0, eigenValues[1].Real, "Re{eigenvalueB}"); - NumericAssert.AreAlmostEqual(0.0, eigenValues[1].Imag, "Im{eigenvalueB}"); + Assert.That(eigenValues[0].Real, NumericIs.AlmostEqualTo(1.0), "Re{eigenvalueA}"); + Assert.That(eigenValues[0].Imag, NumericIs.AlmostEqualTo(0.0), "Im{eigenvalueA}"); + Assert.That(eigenValues[1].Real, NumericIs.AlmostEqualTo(-2.0), "Re{eigenvalueB}"); + Assert.That(eigenValues[1].Imag, NumericIs.AlmostEqualTo(0.0), "Im{eigenvalueB}"); Matrix eigenVectors = m.EigenVectors; - NumericAssert.AreAlmostEqual(.8944271910, eigenVectors[0, 0], 1e-9, "eigenvectorA[0]"); - NumericAssert.AreAlmostEqual(.4472135955, eigenVectors[1, 0], 1e-9, "eigenvectorA[1]"); - NumericAssert.AreAlmostEqual(6.708203936, eigenVectors[0, 1], 1e-9, "eigenvectorB[0]"); - NumericAssert.AreAlmostEqual(4.472135956, eigenVectors[1, 1], 1e-9, "eigenvectorB[1]"); + Assert.That(eigenVectors[0, 0], NumericIs.AlmostEqualTo(.8944271910, 1e-9), "eigenvectorA[0]"); + Assert.That(eigenVectors[1, 0], NumericIs.AlmostEqualTo(.4472135955, 1e-9), "eigenvectorA[1]"); + Assert.That(eigenVectors[0, 1], NumericIs.AlmostEqualTo(6.708203936, 1e-9), "eigenvectorB[0]"); + Assert.That(eigenVectors[1, 1], NumericIs.AlmostEqualTo(4.472135956, 1e-9), "eigenvectorB[1]"); } [Test] @@ -103,7 +103,7 @@ public void CodeSample_PolynomialRegression() // Verify that the polynomial fits with less than 10% error for all given value pairs. for(int i = 0; i < x.Length; i++) { - NumericAssert.AreAlmostEqual(y[i], polynomial.Evaluate(x[i]), 0.1, i.ToString()); + Assert.That(polynomial.Evaluate(x[i]), NumericIs.AlmostEqualTo(y[i], 0.1), i.ToString()); } } } diff --git a/src/test/MathNet.Iridium.Test/CombinatoricsTests/CombinatoricsTest.cs b/src/test/MathNet.Iridium.Test/CombinatoricsTests/CombinatoricsTest.cs index b7accde..73b3f18 100644 --- a/src/test/MathNet.Iridium.Test/CombinatoricsTests/CombinatoricsTest.cs +++ b/src/test/MathNet.Iridium.Test/CombinatoricsTests/CombinatoricsTest.cs @@ -108,7 +108,7 @@ public void CountingPermutations() Assert.That(Combinatorics.Permutations(8), Is.EqualTo(40320), "Perm(8)"); Assert.That(Combinatorics.Permutations(15), Is.EqualTo(1307674368000), "Perm(15)"); Assert.That(Combinatorics.Permutations(30), Is.EqualTo(265252859812191058636308480000000d), "Perm(30)"); - NumericAssert.AreAlmostEqual(0.3856204824e216, Combinatorics.Permutations(128), 1e-10, "Perm(128)"); + Assert.That(Combinatorics.Permutations(128), NumericIs.AlmostEqualTo(0.3856204824e216, 1e-10), "Perm(128)"); } } } diff --git a/src/test/MathNet.Iridium.Test/DistributionTests/DistributionTest.cs b/src/test/MathNet.Iridium.Test/DistributionTests/DistributionTest.cs index b27a44e..6927119 100644 --- a/src/test/MathNet.Iridium.Test/DistributionTests/DistributionTest.cs +++ b/src/test/MathNet.Iridium.Test/DistributionTests/DistributionTest.cs @@ -252,8 +252,8 @@ public void TestContinuousDistributions_Gaussian() NormalDistribution source = new NormalDistribution(4.0, 2.0); NormalDistribution target = new NormalDistribution(); target.EstimateDistributionParameters(source.EnumerateDoubles(1000)); - NumericAssert.AreAlmostEqual(4.0, target.Mu, 0.1, "Normal Parameter Estimation: Mu"); - NumericAssert.AreAlmostEqual(2.0, target.Sigma, 0.1, "Normal Parameter Estimation: Sigma"); + Assert.That(target.Mu, NumericIs.AlmostEqualTo(4.0, 0.1), "Normal Parameter Estimation: Mu"); + Assert.That(target.Sigma, NumericIs.AlmostEqualTo(2.0, 0.1), "Normal Parameter Estimation: Sigma"); } [Test] @@ -381,7 +381,7 @@ public void TestContinuousDistributions_Rayleigh() RayleighDistribution source = new RayleighDistribution(4.0); RayleighDistribution target = new RayleighDistribution(); target.EstimateDistributionParameters(source.EnumerateDoubles(1000)); - NumericAssert.AreAlmostEqual(4.0, target.Sigma, 0.1, "Rayleigh Parameter Estimation: Sigma"); + Assert.That(target.Sigma, NumericIs.AlmostEqualTo(4.0, 0.1), "Rayleigh Parameter Estimation: Sigma"); } [Test] @@ -399,32 +399,32 @@ public void TestContinuousDistributions_FisherSnedecor() FisherSnedecorDistribution d = new FisherSnedecorDistribution(100, 100); // PDF - Evaluated in Maple with "stats[statevalf,pdf,fratio[100,100]](x);" - NumericAssert.AreAlmostEqual(0.0, d.ProbabilityDensity(0.00), "pdf(0.00)"); - NumericAssert.AreAlmostEqual(0.1102042201e-1, d.ProbabilityDensity(0.50), 1e-9, "pdf(0.50)"); - NumericAssert.AreAlmostEqual(0.9462174566, d.ProbabilityDensity(0.75), 1e-9, "pdf(0.75)"); - NumericAssert.AreAlmostEqual(1.989730935, d.ProbabilityDensity(1.00), 1e-9, "pdf(1.00)"); - NumericAssert.AreAlmostEqual(0.8553281091, d.ProbabilityDensity(1.25), 1e-9, "pdf(1.25)"); - NumericAssert.AreAlmostEqual(0.1722918542, d.ProbabilityDensity(1.50), 1e-9, "pdf(1.50)"); - NumericAssert.AreAlmostEqual(0.2755105502e-2, d.ProbabilityDensity(2.00), 1e-9, "pdf(2.00)"); - NumericAssert.AreAlmostEqual(0.6858025452e-13, d.ProbabilityDensity(5.00), 1e-9, "pdf(5.00)"); + Assert.That(d.ProbabilityDensity(0.00), NumericIs.AlmostEqualTo(0.0), "pdf(0.00)"); + Assert.That(d.ProbabilityDensity(0.50), NumericIs.AlmostEqualTo(0.1102042201e-1, 1e-9), "pdf(0.50)"); + Assert.That(d.ProbabilityDensity(0.75), NumericIs.AlmostEqualTo(0.9462174566, 1e-9), "pdf(0.75)"); + Assert.That(d.ProbabilityDensity(1.00), NumericIs.AlmostEqualTo(1.989730935, 1e-9), "pdf(1.00)"); + Assert.That(d.ProbabilityDensity(1.25), NumericIs.AlmostEqualTo(0.8553281091, 1e-9), "pdf(1.25)"); + Assert.That(d.ProbabilityDensity(1.50), NumericIs.AlmostEqualTo(0.1722918542, 1e-9), "pdf(1.50)"); + Assert.That(d.ProbabilityDensity(2.00), NumericIs.AlmostEqualTo(0.2755105502e-2, 1e-9), "pdf(2.00)"); + Assert.That(d.ProbabilityDensity(5.00), NumericIs.AlmostEqualTo(0.6858025452e-13, 1e-9), "pdf(5.00)"); // CDF - Evaluated in Maple with "stats[statevalf,cdr,fratio[100,100]](x);" - NumericAssert.AreAlmostEqual(0.0, d.CumulativeDistribution(0.00), "cdf(0.00)"); - NumericAssert.AreAlmostEqual(0.309136863e-3, d.CumulativeDistribution(0.50), 1e-8, "cdf(0.50)"); - NumericAssert.AreAlmostEqual(0.7602003436e-1, d.CumulativeDistribution(0.75), 1e-9, "cdf(0.75)"); - NumericAssert.AreAlmostEqual(0.5000000000, d.CumulativeDistribution(1.00), 1e-9, "cdf(1.00)"); - NumericAssert.AreAlmostEqual(0.8668843977, d.CumulativeDistribution(1.25), 1e-9, "cdf(1.25)"); - NumericAssert.AreAlmostEqual(0.9780695579, d.CumulativeDistribution(1.50), 1e-9, "cdf(1.50)"); - NumericAssert.AreAlmostEqual(0.9996908631, d.CumulativeDistribution(2.00), 1e-9, "cdf(2.00)"); - NumericAssert.AreAlmostEqual(1.0, d.CumulativeDistribution(5.00), 1e-9, "cdf(5.00)"); + Assert.That(d.CumulativeDistribution(0.00), NumericIs.AlmostEqualTo(0.0), "cdf(0.00)"); + Assert.That(d.CumulativeDistribution(0.50), NumericIs.AlmostEqualTo(0.309136863e-3, 1e-8), "cdf(0.50)"); + Assert.That(d.CumulativeDistribution(0.75), NumericIs.AlmostEqualTo(0.7602003436e-1, 1e-9), "cdf(0.75)"); + Assert.That(d.CumulativeDistribution(1.00), NumericIs.AlmostEqualTo(0.5000000000, 1e-9), "cdf(1.00)"); + Assert.That(d.CumulativeDistribution(1.25), NumericIs.AlmostEqualTo(0.8668843977, 1e-9), "cdf(1.25)"); + Assert.That(d.CumulativeDistribution(1.50), NumericIs.AlmostEqualTo(0.9780695579, 1e-9), "cdf(1.50)"); + Assert.That(d.CumulativeDistribution(2.00), NumericIs.AlmostEqualTo(0.9996908631, 1e-9), "cdf(2.00)"); + Assert.That(d.CumulativeDistribution(5.00), NumericIs.AlmostEqualTo(1.0, 1e-9), "cdf(5.00)"); FisherSnedecorDistribution dOne = new FisherSnedecorDistribution(1, 5); Assert.That(dOne.ProbabilityDensity(0.00), Is.EqualTo(double.PositiveInfinity), "pdf[1,5](0.00)"); - NumericAssert.AreAlmostEqual(0.0, dOne.CumulativeDistribution(0.00), "cdf[1,5](0.00)"); + Assert.That(dOne.CumulativeDistribution(0.00), NumericIs.AlmostEqualTo(0.0), "cdf[1,5](0.00)"); FisherSnedecorDistribution dTwo = new FisherSnedecorDistribution(2, 5); - NumericAssert.AreAlmostEqual(1.0, dTwo.ProbabilityDensity(0.00), "pdf[2,5](0.00)"); - NumericAssert.AreAlmostEqual(0.0, dTwo.CumulativeDistribution(0.00), "cdf[2,5](0.00)"); + Assert.That(dTwo.ProbabilityDensity(0.00), NumericIs.AlmostEqualTo(1.0), "pdf[2,5](0.00)"); + Assert.That(dTwo.CumulativeDistribution(0.00), NumericIs.AlmostEqualTo(0.0), "cdf[2,5](0.00)"); } [Test] @@ -442,26 +442,26 @@ public void TestContinuousDistributions_StudensT() StudentsTDistribution d = new StudentsTDistribution(2); // PDF - Evaluated in Maple with "stats[statevalf,pdf,studentst[2]](x);" - NumericAssert.AreAlmostEqual(0.3535533906, d.ProbabilityDensity(0.0), 1e-9, "pdf(0)"); - NumericAssert.AreAlmostEqual(0.1924500897, d.ProbabilityDensity(1.0), 1e-9, "pdf(1)"); - NumericAssert.AreAlmostEqual(0.06804138174, d.ProbabilityDensity(2.0), 1e-9, "pdf(2)"); - NumericAssert.AreAlmostEqual(0.02741012223, d.ProbabilityDensity(3.0), 1e-9, "pdf(3)"); - NumericAssert.AreAlmostEqual(0.01309457002, d.ProbabilityDensity(4.0), 1e-9, "pdf(4)"); - NumericAssert.AreAlmostEqual(0.1924500897, d.ProbabilityDensity(-1.0), 1e-9, "pdf(-1)"); - NumericAssert.AreAlmostEqual(0.06804138174, d.ProbabilityDensity(-2.0), 1e-9, "pdf(-2)"); - NumericAssert.AreAlmostEqual(0.02741012223, d.ProbabilityDensity(-3.0), 1e-9, "pdf(-3)"); - NumericAssert.AreAlmostEqual(0.01309457002, d.ProbabilityDensity(-4.0), 1e-9, "pdf(-4)"); + Assert.That(d.ProbabilityDensity(0.0), NumericIs.AlmostEqualTo(0.3535533906, 1e-9), "pdf(0)"); + Assert.That(d.ProbabilityDensity(1.0), NumericIs.AlmostEqualTo(0.1924500897, 1e-9), "pdf(1)"); + Assert.That(d.ProbabilityDensity(2.0), NumericIs.AlmostEqualTo(0.06804138174, 1e-9), "pdf(2)"); + Assert.That(d.ProbabilityDensity(3.0), NumericIs.AlmostEqualTo(0.02741012223, 1e-9), "pdf(3)"); + Assert.That(d.ProbabilityDensity(4.0), NumericIs.AlmostEqualTo(0.01309457002, 1e-9), "pdf(4)"); + Assert.That(d.ProbabilityDensity(-1.0), NumericIs.AlmostEqualTo(0.1924500897, 1e-9), "pdf(-1)"); + Assert.That(d.ProbabilityDensity(-2.0), NumericIs.AlmostEqualTo(0.06804138174, 1e-9), "pdf(-2)"); + Assert.That(d.ProbabilityDensity(-3.0), NumericIs.AlmostEqualTo(0.02741012223, 1e-9), "pdf(-3)"); + Assert.That(d.ProbabilityDensity(-4.0), NumericIs.AlmostEqualTo(0.01309457002, 1e-9), "pdf(-4)"); // CDF - Evaluated in Maple with "stats[statevalf,cdf,studentst[2]](x);" - NumericAssert.AreAlmostEqual(0.5000000000, d.CumulativeDistribution(0.0), "cdf(0)"); - NumericAssert.AreAlmostEqual(0.7886751346, d.CumulativeDistribution(1.0), 1e-9, "cdf(1)"); - NumericAssert.AreAlmostEqual(0.9082482905, d.CumulativeDistribution(2.0), 1e-9, "cdf(2)"); - NumericAssert.AreAlmostEqual(0.9522670169, d.CumulativeDistribution(3.0), 1e-9, "cdf(3)"); - NumericAssert.AreAlmostEqual(0.9714045208, d.CumulativeDistribution(4.0), 1e-9, "cdf(4)"); - NumericAssert.AreAlmostEqual(0.2113248654, d.CumulativeDistribution(-1.0), 1e-9, "cdf(-1)"); - NumericAssert.AreAlmostEqual(0.09175170954, d.CumulativeDistribution(-2.0), 1e-9, "cdf(-2)"); - NumericAssert.AreAlmostEqual(0.04773298313, d.CumulativeDistribution(-3.0), 1e-9, "cdf(-3)"); - NumericAssert.AreAlmostEqual(0.02859547921, d.CumulativeDistribution(-4.0), 1e-9, "cdf(-4)"); + Assert.That(d.CumulativeDistribution(0.0), NumericIs.AlmostEqualTo(0.5000000000), "cdf(0)"); + Assert.That(d.CumulativeDistribution(1.0), NumericIs.AlmostEqualTo(0.7886751346, 1e-9), "cdf(1)"); + Assert.That(d.CumulativeDistribution(2.0), NumericIs.AlmostEqualTo(0.9082482905, 1e-9), "cdf(2)"); + Assert.That(d.CumulativeDistribution(3.0), NumericIs.AlmostEqualTo(0.9522670169, 1e-9), "cdf(3)"); + Assert.That(d.CumulativeDistribution(4.0), NumericIs.AlmostEqualTo(0.9714045208, 1e-9), "cdf(4)"); + Assert.That(d.CumulativeDistribution(-1.0), NumericIs.AlmostEqualTo(0.2113248654, 1e-9), "cdf(-1)"); + Assert.That(d.CumulativeDistribution(-2.0), NumericIs.AlmostEqualTo(0.09175170954, 1e-9), "cdf(-2)"); + Assert.That(d.CumulativeDistribution(-3.0), NumericIs.AlmostEqualTo(0.04773298313, 1e-9), "cdf(-3)"); + Assert.That(d.CumulativeDistribution(-4.0), NumericIs.AlmostEqualTo(0.02859547921, 1e-9), "cdf(-4)"); } } } diff --git a/src/test/MathNet.Iridium.Test/InfrastructureTests/AlmostEqualityTest.cs b/src/test/MathNet.Iridium.Test/InfrastructureTests/AlmostEqualityTest.cs index c29c36e..afc7d22 100644 --- a/src/test/MathNet.Iridium.Test/InfrastructureTests/AlmostEqualityTest.cs +++ b/src/test/MathNet.Iridium.Test/InfrastructureTests/AlmostEqualityTest.cs @@ -123,36 +123,36 @@ public void TestAlmostEqual() { // samle value Assert.That(value, Is.EqualTo(value)); - Assert.That(EqualityComparers.AlmostEqual(value, value), Is.True); - Assert.That(EqualityComparers.AlmostEqual(value, value, 1e-10), Is.True); + Assert.That(Number.AlmostEqual(value, value), Is.True); + Assert.That(Number.AlmostEqual(value, value, 1e-10), Is.True); // default/null value Assert.That(value, Is.Not.EqualTo(default(T))); - Assert.That(EqualityComparers.AlmostEqual(value, default(T)), Is.False); - Assert.That(EqualityComparers.AlmostEqual(value, default(T), 1e-10), Is.False); + Assert.That(Number.AlmostEqual(value, default(T)), Is.False); + Assert.That(Number.AlmostEqual(value, default(T), 1e-10), Is.False); // samle value Assert.That(value, Is.EqualTo(valueClone)); Assert.That(value, Is.Not.SameAs(valueClone)); - Assert.That(EqualityComparers.AlmostEqual(value, valueClone), Is.True); - Assert.That(EqualityComparers.AlmostEqual(value, valueClone, 1e-10), Is.True); + Assert.That(Number.AlmostEqual(value, valueClone), Is.True); + Assert.That(Number.AlmostEqual(value, valueClone, 1e-10), Is.True); // completely different value Assert.That(value, Is.Not.EqualTo(completelyDifferentValue)); - Assert.That(EqualityComparers.AlmostEqual(value, completelyDifferentValue), Is.False); - Assert.That(EqualityComparers.AlmostEqual(value, completelyDifferentValue, 1e-10), Is.False); + Assert.That(Number.AlmostEqual(value, completelyDifferentValue), Is.False); + Assert.That(Number.AlmostEqual(value, completelyDifferentValue, 1e-10), Is.False); // notably different value Assert.That(value, Is.Not.EqualTo(notablyDifferentValue)); - Assert.That(EqualityComparers.AlmostEqual(value, notablyDifferentValue), Is.False); - Assert.That(EqualityComparers.AlmostEqual(value, notablyDifferentValue, 1e-10), Is.False); - Assert.That(EqualityComparers.AlmostEqual(value, notablyDifferentValue, 1e-2), Is.True); + Assert.That(Number.AlmostEqual(value, notablyDifferentValue), Is.False); + Assert.That(Number.AlmostEqual(value, notablyDifferentValue, 1e-10), Is.False); + Assert.That(Number.AlmostEqual(value, notablyDifferentValue, 1e-2), Is.True); // almost (but not) equal value Assert.That(value, Is.Not.EqualTo(almostEqualValue)); - Assert.That(EqualityComparers.AlmostEqual(value, almostEqualValue), Is.True); - Assert.That(EqualityComparers.AlmostEqual(value, almostEqualValue, 1e-10), Is.True); - Assert.That(EqualityComparers.AlmostEqual(value, almostEqualValue, 1e-2), Is.True); + Assert.That(Number.AlmostEqual(value, almostEqualValue), Is.True); + Assert.That(Number.AlmostEqual(value, almostEqualValue, 1e-10), Is.True); + Assert.That(Number.AlmostEqual(value, almostEqualValue, 1e-2), Is.True); } [Test] @@ -176,13 +176,13 @@ public void TestAlmostEquals_Complex() // infinity Assert.That(a1, Is.Not.EqualTo(Complex.Infinity)); - Assert.That(EqualityComparers.AlmostEqual(a1, Complex.Infinity), Is.False); - Assert.That(EqualityComparers.AlmostEqual(a1, Complex.Infinity, 1e-10), Is.False); + Assert.That(Number.AlmostEqual(a1, Complex.Infinity), Is.False); + Assert.That(Number.AlmostEqual(a1, Complex.Infinity, 1e-10), Is.False); // NaN Assert.That(a1, Is.Not.EqualTo(Complex.NaN)); - Assert.That(EqualityComparers.AlmostEqual(a1, Complex.NaN), Is.False); - Assert.That(EqualityComparers.AlmostEqual(a1, Complex.NaN, 1e-10), Is.False); + Assert.That(Number.AlmostEqual(a1, Complex.NaN), Is.False); + Assert.That(Number.AlmostEqual(a1, Complex.NaN, 1e-10), Is.False); } [Test,Repeat(5)] @@ -206,8 +206,8 @@ public void TestAlmostEquals_Matrix() // transpose Assert.That(Matrix.Transpose(a1), Is.Not.EqualTo(a1)); - Assert.That(EqualityComparers.AlmostEqual(a1, Matrix.Transpose(a1)), Is.False); - Assert.That(EqualityComparers.AlmostEqual(a1, Matrix.Transpose(a1), 1e-10), Is.False); + Assert.That(Number.AlmostEqual(a1, Matrix.Transpose(a1)), Is.False); + Assert.That(Number.AlmostEqual(a1, Matrix.Transpose(a1), 1e-10), Is.False); } [Test,Repeat(5)] @@ -231,13 +231,13 @@ public void TestAlmostEquals_ComplexMatrix() // transpose Assert.That(a1.Transpose(), Is.Not.EqualTo(a1)); - Assert.That(EqualityComparers.AlmostEqual(a1, a1.Transpose()), Is.False); - Assert.That(EqualityComparers.AlmostEqual(a1, a1.Transpose(), 1e-10), Is.False); + Assert.That(Number.AlmostEqual(a1, a1.Transpose()), Is.False); + Assert.That(Number.AlmostEqual(a1, a1.Transpose(), 1e-10), Is.False); // hermitian transpose Assert.That(a1.HermitianTranspose(), Is.Not.EqualTo(a1)); - Assert.That(EqualityComparers.AlmostEqual(a1, a1.HermitianTranspose()), Is.False); - Assert.That(EqualityComparers.AlmostEqual(a1, a1.HermitianTranspose(), 1e-10), Is.False); + Assert.That(Number.AlmostEqual(a1, a1.HermitianTranspose()), Is.False); + Assert.That(Number.AlmostEqual(a1, a1.HermitianTranspose(), 1e-10), Is.False); } [Test, Repeat(5)] diff --git a/src/test/MathNet.Iridium.Test/InfrastructureTests/ComplexTest.cs b/src/test/MathNet.Iridium.Test/InfrastructureTests/ComplexTest.cs index e193cd5..2269ae7 100644 --- a/src/test/MathNet.Iridium.Test/InfrastructureTests/ComplexTest.cs +++ b/src/test/MathNet.Iridium.Test/InfrastructureTests/ComplexTest.cs @@ -184,7 +184,7 @@ public void TestPower() // (i)^(1) = i Complex I = Complex.I; Complex IPowOne = I.Power(one); - NumericAssert.AreAlmostEqual(0d, IPowOne.Real, "Re{(i)^(1)} = 0"); + Assert.That(IPowOne.Real, NumericIs.AlmostEqualTo(0d), "Re{(i)^(1)} = 0"); Assert.That(IPowOne.Imag, Is.EqualTo(1d), "Im{(i)^(1)} = 1"); // (1)^(-1) = 1 @@ -195,7 +195,7 @@ public void TestPower() // (i)^(-1) = -i Complex IPowMOne = I.Power(mOne); - NumericAssert.AreAlmostEqual(0d, IPowMOne.Real, "Re{(i)^(-1)} = 0"); + Assert.That(IPowMOne.Real, NumericIs.AlmostEqualTo(0d), "Re{(i)^(-1)} = 0"); Assert.That(IPowMOne.Imag, Is.EqualTo(-1d), "Im{(i)^(-1)} = -1"); // (i)^(-i) = exp(Pi/2) diff --git a/src/test/MathNet.Iridium.Test/InfrastructureTests/SerializationTest.cs b/src/test/MathNet.Iridium.Test/InfrastructureTests/SerializationTest.cs index 9b6ab21..067d071 100644 --- a/src/test/MathNet.Iridium.Test/InfrastructureTests/SerializationTest.cs +++ b/src/test/MathNet.Iridium.Test/InfrastructureTests/SerializationTest.cs @@ -74,7 +74,8 @@ public void TestSerializeComplex() Complex after = SerializeDeserialize(before); Assert.That(after, Is.Not.EqualTo(default(Complex)), "Not Null"); - Assert.That(after, Is.EqualTo(before).Using(EqualityComparers.ForComplex()), "Equal"); + Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -85,6 +86,7 @@ public void TestSerializeVector() Assert.That(after, Is.Not.Null, "Not Null"); Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -95,6 +97,7 @@ public void TestSerializeComplexVector() Assert.That(after, Is.Not.Null, "Not Null"); Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -104,7 +107,8 @@ public void TestSerializeMatrix() Matrix after = SerializeDeserialize(before); Assert.That(after, Is.Not.Null, "Not Null"); - Assert.That(after, Is.EqualTo(before).Using(EqualityComparers.ForMatrix()), "Equal"); + Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -114,7 +118,8 @@ public void TestSerializeComplexMatrix() ComplexMatrix after = SerializeDeserialize(before); Assert.That(after, Is.Not.Null, "Not Null"); - Assert.That(after, Is.EqualTo(before).Using(EqualityComparers.ForComplexMatrix()), "Equal"); + Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -125,6 +130,7 @@ public void TestSerializePolynomial() Assert.That(after, Is.Not.Null, "Not Null"); Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } [Test, Repeat(3)] @@ -135,6 +141,7 @@ public void TestSerializeComplexPolynomial() Assert.That(after, Is.Not.Null, "Not Null"); Assert.That(after, Is.EqualTo(before), "Equal"); + Assert.That(after, NumericIs.AlmostEqualTo(before), "Almost Equal"); } } } diff --git a/src/test/MathNet.Iridium.Test/IntegrationTests/IntegrationTest.cs b/src/test/MathNet.Iridium.Test/IntegrationTests/IntegrationTest.cs index 6665435..36187c9 100644 --- a/src/test/MathNet.Iridium.Test/IntegrationTests/IntegrationTest.cs +++ b/src/test/MathNet.Iridium.Test/IntegrationTests/IntegrationTest.cs @@ -54,77 +54,33 @@ private double TargetFunctionA(double x) [Test] public void TestPortal() { - NumericAssert.AreAlmostEqual( - TargetAreaA, - Integrate.OnClosedInterval(TargetFunctionA, StartA, StopA), - 1e-5, - "Basic"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - Integrate.OnClosedInterval(TargetFunctionA, StartA, StopA, 1e-10), - 1e-10, - "Basic Target 1e-10"); + Assert.That(Integrate.OnClosedInterval(TargetFunctionA, StartA, StopA), NumericIs.AlmostEqualTo(TargetAreaA, 1e-5), "Basic"); + + Assert.That(Integrate.OnClosedInterval(TargetFunctionA, StartA, StopA, 1e-10), NumericIs.AlmostEqualTo(TargetAreaA, 1e-10), "Basic Target 1e-10"); } [Test] public void TestTrapeziumRule() { TrapeziumRule algorithm = new TrapeziumRule(); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateTwoPoint(TargetFunctionA, StartA, StopA), - 2.5e-1, - "Direct (1 Partition)"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1), - 2.5e-1, - "Composite 1 Partition"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 5), - 1e-1, - "Composite 5 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), - 2e-2, - "Composite 10 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), - 6e-4, - "Composite 50 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), - 1.5e-6, - "Composite 1000 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-1), - 1e-1, - "Adaptive Target 1e-1"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-5), - 1e-5, - "Adaptive Target 1e-5"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-10), - 1e-10, - "Adaptive Target 1e-10"); + + Assert.That(algorithm.IntegrateTwoPoint(TargetFunctionA, StartA, StopA), NumericIs.AlmostEqualTo(TargetAreaA, 2.5e-1), "Direct (1 Partition)"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1), NumericIs.AlmostEqualTo(TargetAreaA, 2.5e-1), "Composite 1 Partition"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 5), NumericIs.AlmostEqualTo(TargetAreaA, 1e-1), "Composite 5 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), NumericIs.AlmostEqualTo(TargetAreaA, 2e-2), "Composite 10 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), NumericIs.AlmostEqualTo(TargetAreaA, 6e-4), "Composite 50 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), NumericIs.AlmostEqualTo(TargetAreaA, 1.5e-6), "Composite 1000 Partitions"); + + Assert.That(algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-1), NumericIs.AlmostEqualTo(TargetAreaA, 1e-1), "Adaptive Target 1e-1"); + + Assert.That(algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-5), NumericIs.AlmostEqualTo(TargetAreaA, 1e-5), "Adaptive Target 1e-5"); + + Assert.That(algorithm.IntegrateAdaptive(TargetFunctionA, StartA, StopA, 1e-10), NumericIs.AlmostEqualTo(TargetAreaA, 1e-10), "Adaptive Target 1e-10"); } [Test] @@ -132,41 +88,17 @@ public void TestSimpsonRule() { SimpsonRule algorithm = new SimpsonRule(); - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateThreePoint(TargetFunctionA, StartA, StopA), - 1.7e-1, - "Direct (2 Partitions)"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 2), - 1.7e-1, - "Composite 2 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 6), - 1.2e-1, - "Composite 6 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), - 8e-3, - "Composite 10 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), - 8e-6, - "Composite 50 Partitions"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), - 5e-11, - "Composite 1000 Partitions"); + Assert.That(algorithm.IntegrateThreePoint(TargetFunctionA, StartA, StopA), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Direct (2 Partitions)"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 2), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Composite 2 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 6), NumericIs.AlmostEqualTo(TargetAreaA, 1.2e-1), "Composite 6 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), NumericIs.AlmostEqualTo(TargetAreaA, 8e-3), "Composite 10 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), NumericIs.AlmostEqualTo(TargetAreaA, 8e-6), "Composite 50 Partitions"); + + Assert.That(algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), NumericIs.AlmostEqualTo(TargetAreaA, 5e-11), "Composite 1000 Partitions"); } [Test] @@ -174,17 +106,9 @@ public void TestDoubleExponentialTransformationAlgorithm() { DoubleExponentialTransformation det = new DoubleExponentialTransformation(); - NumericAssert.AreAlmostEqual( - TargetAreaA, - det.Integrate(TargetFunctionA, StartA, StopA, 1e-5), - 1e-5, - "Adaptive Target 1e-5"); - - NumericAssert.AreAlmostEqual( - TargetAreaA, - det.Integrate(TargetFunctionA, StartA, StopA, 1e-10), - 1e-10, - "Adaptive Target 1e-10"); + Assert.That(det.Integrate(TargetFunctionA, StartA, StopA, 1e-5), NumericIs.AlmostEqualTo(TargetAreaA, 1e-5), "Adaptive Target 1e-5"); + + Assert.That(det.Integrate(TargetFunctionA, StartA, StopA, 1e-10), NumericIs.AlmostEqualTo(TargetAreaA, 1e-10), "Adaptive Target 1e-10"); } } } diff --git a/src/test/MathNet.Iridium.Test/InterpolationTests/InterpolationTest.cs b/src/test/MathNet.Iridium.Test/InterpolationTests/InterpolationTest.cs index b6f9480..2a15ed3 100644 --- a/src/test/MathNet.Iridium.Test/InterpolationTests/InterpolationTest.cs +++ b/src/test/MathNet.Iridium.Test/InterpolationTests/InterpolationTest.cs @@ -62,20 +62,20 @@ public void TestInterpolationMethod_NevillePolynomial() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation([[0,0],[1,3],[3,1],[4,3]], x)),20);" - NumericAssert.AreAlmostEqual(.57225000000000000000, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(.57225000000000000000, method.Differentiate(0.1, out dx, out d2x), 1e-15, "B 0.1"); - NumericAssert.AreAlmostEqual(1.8840000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(1.8840000000000000000, method.Differentiate(0.4, out dx, out d2x), 1e-15, "B 0.4"); - NumericAssert.AreAlmostEqual(3.0314166666666666667, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(3.0314166666666666667, method.Differentiate(1.1, out dx, out d2x), 1e-15, "B 1.1"); - NumericAssert.AreAlmostEqual(1.034666666666666667, method.Interpolate(3.2), 1e-15, "A 3.2"); - NumericAssert.AreAlmostEqual(1.034666666666666667, method.Differentiate(3.2, out dx, out d2x), 1e-15, "B 3.2"); - NumericAssert.AreAlmostEqual(6.281250000000000000, method.Interpolate(4.5), 1e-15, "A 4.5"); - NumericAssert.AreAlmostEqual(6.281250000000000000, method.Differentiate(4.5, out dx, out d2x), 1e-15, "B 4.5"); - NumericAssert.AreAlmostEqual(277.50000000000000000, method.Interpolate(10.0), 1e-15, "A 10.0"); - NumericAssert.AreAlmostEqual(277.50000000000000000, method.Differentiate(10.0, out dx, out d2x), 1e-15, "B 10.0"); - NumericAssert.AreAlmostEqual(-1010.8333333333333333, method.Interpolate(-10.0), 1e-15, "A -10.0"); - NumericAssert.AreAlmostEqual(-1010.8333333333333333, method.Differentiate(-10.0, out dx, out d2x), 1e-15, "B -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(.57225000000000000000, 1e-15), "A 0.1"); + Assert.That(method.Differentiate(0.1, out dx, out d2x), NumericIs.AlmostEqualTo(.57225000000000000000, 1e-15), "B 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(1.8840000000000000000, 1e-15), "A 0.4"); + Assert.That(method.Differentiate(0.4, out dx, out d2x), NumericIs.AlmostEqualTo(1.8840000000000000000, 1e-15), "B 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(3.0314166666666666667, 1e-15), "A 1.1"); + Assert.That(method.Differentiate(1.1, out dx, out d2x), NumericIs.AlmostEqualTo(3.0314166666666666667, 1e-15), "B 1.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(1.034666666666666667, 1e-15), "A 3.2"); + Assert.That(method.Differentiate(3.2, out dx, out d2x), NumericIs.AlmostEqualTo(1.034666666666666667, 1e-15), "B 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(6.281250000000000000, 1e-15), "A 4.5"); + Assert.That(method.Differentiate(4.5, out dx, out d2x), NumericIs.AlmostEqualTo(6.281250000000000000, 1e-15), "B 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(277.50000000000000000, 1e-15), "A 10.0"); + Assert.That(method.Differentiate(10.0, out dx, out d2x), NumericIs.AlmostEqualTo(277.50000000000000000, 1e-15), "B 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(-1010.8333333333333333, 1e-15), "A -10.0"); + Assert.That(method.Differentiate(-10.0, out dx, out d2x), NumericIs.AlmostEqualTo(-1010.8333333333333333, 1e-15), "B -10.0"); // Test Linear Case for(int k = 2; k < 7; k++) @@ -85,7 +85,7 @@ public void TestInterpolationMethod_NevillePolynomial() IInterpolationMethod linearMethod = Interpolation.CreatePolynomial(linx, liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } @@ -106,13 +106,13 @@ public void TestInterpolationMethod_EquidistantBarycentricPolynomial() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation([[0,0],[1,3],[2,2.5],[3,1],[4,3]], x)),20);" - NumericAssert.AreAlmostEqual(.48742500000000000000, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(1.6968000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(3.0819250000000000000, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(.940800000000000001, method.Interpolate(3.2), 1e-15, "A 3.2"); - NumericAssert.AreAlmostEqual(7.265625000000000001, method.Interpolate(4.5), 1e-15, "A 4.5"); - NumericAssert.AreAlmostEqual(592.50000000000000000, method.Interpolate(10.0), 1e-13, "A 10.0"); - NumericAssert.AreAlmostEqual(657.50000000000000000, method.Interpolate(-10.0), 1e-12, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(.48742500000000000000, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(1.6968000000000000000, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(3.0819250000000000000, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(.940800000000000001, 1e-15), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(7.265625000000000001, 1e-15), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(592.50000000000000000, 1e-13), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(657.50000000000000000, 1e-12), "A -10.0"); // Test Linear Case for(int k = 2; k < 7; k++) @@ -122,7 +122,7 @@ public void TestInterpolationMethod_EquidistantBarycentricPolynomial() IInterpolationMethod linearMethod = Interpolation.CreateOnEquidistantPoints(2, Math.Max(k, 3), liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } @@ -139,22 +139,22 @@ public void TestInterpolationMethod_Chebyshev1BarycentricPolynomial() for(int i = 0; i < 4; i++) { // verify the generated chebyshev1 points - double tt = 2.0 + (2.0 * Math.Cos(Math.PI * 0.1 * ((2 * i) + 1))); - NumericAssert.AreAlmostEqual(t[i], tt, "Point " + i.ToString()); + double tt = 2.0 + (2.0 * Math.Cos(Math.PI * 0.1 * ((2 * i) + 1))); + Assert.That(tt, NumericIs.AlmostEqualTo(t[i]), "Point " + i.ToString()); // verify the interpolated values exactly at the sample points. - NumericAssert.AreAlmostEqual(x[i], method.Interpolate(tt), "A Exact Point " + i.ToString()); + Assert.That(method.Interpolate(tt), NumericIs.AlmostEqualTo(x[i]), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation(evalf([[2*cos(Pi/10)+2,0],[2*cos(3*Pi/10)+2,3],[2*cos(5*Pi/10)+2,2.5],[2*cos(7*Pi/10)+2,1],[2*cos(9*Pi/10)+2,3]]), x)),20);" - NumericAssert.AreAlmostEqual(2.9882560375702001608, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(1.7097090371118968872, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(1.0462830804302586508, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(2.951922899377369724, method.Interpolate(3.2), 1e-15, "A 3.2"); - NumericAssert.AreAlmostEqual(-5.394317844683536750, method.Interpolate(4.5), 1e-15, "A 4.5"); - NumericAssert.AreAlmostEqual(-228.01438153088988107, method.Interpolate(10.0), 1e-13, "A 10.0"); - NumericAssert.AreAlmostEqual(1979.2646653044133954, method.Interpolate(-10.0), 1e-12, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(2.9882560375702001608, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(1.7097090371118968872, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(1.0462830804302586508, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(2.951922899377369724, 1e-15), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(-5.394317844683536750, 1e-15), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(-228.01438153088988107, 1e-13), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(1979.2646653044133954, 1e-12), "A -10.0"); } [Test] @@ -169,22 +169,22 @@ public void TestInterpolationMethod_Chebyshev2BarycentricPolynomial() for(int i = 0; i < 4; i++) { // verify the generated chebyshev2 points - double tt = 2.0 + (2.0 * Math.Cos(Math.PI * i * 0.25)); - NumericAssert.AreAlmostEqual(t[i], tt, "Point " + i.ToString()); + double tt = 2.0 + (2.0 * Math.Cos(Math.PI * i * 0.25)); + Assert.That(tt, NumericIs.AlmostEqualTo(t[i]), "Point " + i.ToString()); // verify the interpolated values exactly at the sample points. - NumericAssert.AreAlmostEqual(x[i], method.Interpolate(tt), "A Exact Point " + i.ToString()); + Assert.That(method.Interpolate(tt), NumericIs.AlmostEqualTo(x[i]), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation(evalf([[2*cos(0*Pi/4)+2,0],[2*cos(1*Pi/4)+2,3],[2*cos(2*Pi/4)+2,2.5],[2*cos(3*Pi/4)+2,1],[2*cos(4*Pi/4)+2,3]]), x)),20);" - NumericAssert.AreAlmostEqual(2.4826419375703841423, method.Interpolate(0.1), 1e-14, "A 0.1"); - NumericAssert.AreAlmostEqual(1.3814129880730972522, method.Interpolate(0.4), 1e-14, "A 0.4"); - NumericAssert.AreAlmostEqual(.8808232156067110292, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(3.478116015902536997, method.Interpolate(3.2), 1e-15, "A 3.2"); - NumericAssert.AreAlmostEqual(-5.035612822087164912, method.Interpolate(4.5), 1e-15, "A 4.5"); - NumericAssert.AreAlmostEqual(-369.20562748477140583, method.Interpolate(10.0), 1e-13, "A 10.0"); - NumericAssert.AreAlmostEqual(1199.4696961966999204, method.Interpolate(-10.0), 1e-12, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(2.4826419375703841423, 1e-14), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(1.3814129880730972522, 1e-14), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(.8808232156067110292, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(3.478116015902536997, 1e-15), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(-5.035612822087164912, 1e-15), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(-369.20562748477140583, 1e-13), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(1199.4696961966999204, 1e-12), "A -10.0"); } [Test] @@ -208,15 +208,15 @@ public void TestInterpolationMethod_RationalPoleFreeBarycentric() // Maple: "with(CurveFitting);" // Maple: "PolynomialInterpolation([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x);" - NumericAssert.AreAlmostEqual(-4.5968, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.65395, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(0.21875, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-0.84205, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-1.10805, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-1.1248, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(0.5392, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(-4431, method.Interpolate(10.0), 1e-12, "A 10.0"); - NumericAssert.AreAlmostEqual(-5071, method.Interpolate(-10.0), 1e-12, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(-4.5968, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.65395, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(0.21875, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-0.84205, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-1.10805, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-1.1248, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(0.5392, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo((double) (-4431), 1e-12), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo((double) (-5071), 1e-12), "A -10.0"); /****************************************************************************** 2nd: x(t) = 1/(1+t^2), t=-5..5 (polynomial can' t interpolate that function!) @@ -254,7 +254,7 @@ public void TestInterpolationMethod_RationalPoleFreeBarycentric() IInterpolationMethod linearMethod = Interpolation.Create(linx, liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } @@ -275,17 +275,17 @@ public void TestInterpolationMethod_RationalWithPoles() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},RationalInterpolation([[0,0],[1,3],[3,1000],[4,-1000], [5,3]], x)),20);" - NumericAssert.AreAlmostEqual(.19389203383553566255, method.Interpolate(0.1), 1e-14, "A 0.1"); - NumericAssert.AreAlmostEqual(.88132900698869875369, method.Interpolate(0.4), 1e-14, "A 0.4"); - NumericAssert.AreAlmostEqual(3.5057665681580626913, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(1548.7666642693586902, method.Interpolate(3.01), 1e-13, "A 3.01"); - NumericAssert.AreAlmostEqual(3362.2564334253633516, method.Interpolate(3.02), 1e-13, "A 3.02"); - NumericAssert.AreAlmostEqual(-22332.603641443806014, method.Interpolate(3.03), 1e-12, "A 3.03"); - NumericAssert.AreAlmostEqual(-440.30323769822443789, method.Interpolate(3.1), 1e-14, "A 3.1"); - NumericAssert.AreAlmostEqual(-202.42421196280566349, method.Interpolate(3.2), 1e-14, "A 3.2"); - NumericAssert.AreAlmostEqual(21.208249625210155439, method.Interpolate(4.5), 1e-14, "A 4.5"); - NumericAssert.AreAlmostEqual(-4.8936986959784751517, method.Interpolate(10.0), 1e-13, "A 10.0"); - NumericAssert.AreAlmostEqual(-3.6017584308603731307, method.Interpolate(-10.0), 1e-13, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(.19389203383553566255, 1e-14), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(.88132900698869875369, 1e-14), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(3.5057665681580626913, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.01), NumericIs.AlmostEqualTo(1548.7666642693586902, 1e-13), "A 3.01"); + Assert.That(method.Interpolate(3.02), NumericIs.AlmostEqualTo(3362.2564334253633516, 1e-13), "A 3.02"); + Assert.That(method.Interpolate(3.03), NumericIs.AlmostEqualTo(-22332.603641443806014, 1e-12), "A 3.03"); + Assert.That(method.Interpolate(3.1), NumericIs.AlmostEqualTo(-440.30323769822443789, 1e-14), "A 3.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(-202.42421196280566349, 1e-14), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(21.208249625210155439, 1e-14), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(-4.8936986959784751517, 1e-13), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(-3.6017584308603731307, 1e-13), "A -10.0"); // Test Linear Case for(int k = 2; k < 6; k++) @@ -317,13 +317,13 @@ public void TestInterpolationMethod_LimitedOrderPolynomial() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation([[0,0],[1,3],[3,1],[4,3]], x)),20);" - NumericAssert.AreAlmostEqual(.57225000000000000000, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(1.8840000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(3.0314166666666666667, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(1.034666666666666667, method.Interpolate(3.2), 1e-15, "A 3.2"); - NumericAssert.AreAlmostEqual(6.281250000000000000, method.Interpolate(4.5), 1e-15, "A 4.5"); - NumericAssert.AreAlmostEqual(277.50000000000000000, method.Interpolate(10.0), 1e-15, "A 10.0"); - NumericAssert.AreAlmostEqual(-1010.8333333333333333, method.Interpolate(-10.0), 1e-15, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(.57225000000000000000, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(1.8840000000000000000, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(3.0314166666666666667, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(1.034666666666666667, 1e-15), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(6.281250000000000000, 1e-15), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(277.50000000000000000, 1e-15), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(-1010.8333333333333333, 1e-15), "A -10.0"); } [Test] @@ -342,17 +342,17 @@ public void TestInterpolationMethod_LimitedOrderRationalWithPoles() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},RationalInterpolation([[0,0],[1,3],[3,1000],[4,-1000], [5,3]], x)),20);" - NumericAssert.AreAlmostEqual(.19389203383553566255, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(.88132900698869875369, method.Interpolate(0.4), 1e-14, "A 0.4"); - NumericAssert.AreAlmostEqual(3.5057665681580626913, method.Interpolate(1.1), 1e-15, "A 1.1"); - NumericAssert.AreAlmostEqual(1548.7666642693586902, method.Interpolate(3.01), 1e-13, "A 3.01"); - NumericAssert.AreAlmostEqual(3362.2564334253633516, method.Interpolate(3.02), 1e-13, "A 3.02"); - NumericAssert.AreAlmostEqual(-22332.603641443806014, method.Interpolate(3.03), 1e-12, "A 3.03"); - NumericAssert.AreAlmostEqual(-440.30323769822443789, method.Interpolate(3.1), 1e-14, "A 3.1"); - NumericAssert.AreAlmostEqual(-202.42421196280566349, method.Interpolate(3.2), 1e-14, "A 3.2"); - NumericAssert.AreAlmostEqual(21.208249625210155439, method.Interpolate(4.5), 1e-14, "A 4.5"); - NumericAssert.AreAlmostEqual(-4.8936986959784751517, method.Interpolate(10.0), 1e-13, "A 10.0"); - NumericAssert.AreAlmostEqual(-3.6017584308603731307, method.Interpolate(-10.0), 1e-13, "A -10.0"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(.19389203383553566255, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(.88132900698869875369, 1e-14), "A 0.4"); + Assert.That(method.Interpolate(1.1), NumericIs.AlmostEqualTo(3.5057665681580626913, 1e-15), "A 1.1"); + Assert.That(method.Interpolate(3.01), NumericIs.AlmostEqualTo(1548.7666642693586902, 1e-13), "A 3.01"); + Assert.That(method.Interpolate(3.02), NumericIs.AlmostEqualTo(3362.2564334253633516, 1e-13), "A 3.02"); + Assert.That(method.Interpolate(3.03), NumericIs.AlmostEqualTo(-22332.603641443806014, 1e-12), "A 3.03"); + Assert.That(method.Interpolate(3.1), NumericIs.AlmostEqualTo(-440.30323769822443789, 1e-14), "A 3.1"); + Assert.That(method.Interpolate(3.2), NumericIs.AlmostEqualTo(-202.42421196280566349, 1e-14), "A 3.2"); + Assert.That(method.Interpolate(4.5), NumericIs.AlmostEqualTo(21.208249625210155439, 1e-14), "A 4.5"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(-4.8936986959784751517, 1e-13), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(-3.6017584308603731307, 1e-13), "A -10.0"); } [Test] @@ -372,15 +372,15 @@ public void TestInterpolationMethod_LinearSpline() // Maple: "f := x -> piecewise(x<-1,3+x,x<0,-1-3*x,x<1,-1+x,-1+x);" // Maple: "f(x)" - NumericAssert.AreAlmostEqual(.6, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.7, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(.5, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-.7, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-.9, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-.6, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(.2, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(9.0, method.Interpolate(10.0), 1e-15, "A 10.0"); - NumericAssert.AreAlmostEqual(-7.0, method.Interpolate(-10.0), 1e-15, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(.6, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.7, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(.5, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-.7, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-.9, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-.6, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(.2, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(9.0, 1e-15), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(-7.0, 1e-15), "A -10.0"); // Test Linear Case for(int k = 2; k < 6; k++) @@ -390,7 +390,7 @@ public void TestInterpolationMethod_LinearSpline() IInterpolationMethod linearMethod = Interpolation.CreateLinearSpline(linx, liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } @@ -412,15 +412,15 @@ public void TestInterpolationMethod_CubicSpline_BoundaryNatural() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints='natural')),20);" - NumericAssert.AreAlmostEqual(.144000000000000000, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.7906428571428571429, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(.47321428571428571431, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-.80992857142857142857, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-1.1089285714285714286, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-1.0285714285714285714, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(.30285714285714285716, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(189, method.Interpolate(10.0), 1e-15, "A 10.0"); - NumericAssert.AreAlmostEqual(677, method.Interpolate(-10.0), 1e-15, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(.144000000000000000, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.7906428571428571429, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(.47321428571428571431, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-.80992857142857142857, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-1.1089285714285714286, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-1.0285714285714285714, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(.30285714285714285716, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo((double) 189, 1e-15), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo((double) 677, 1e-15), "A -10.0"); // Test Linear Case for(int k = 2; k < 6; k++) @@ -430,7 +430,7 @@ public void TestInterpolationMethod_CubicSpline_BoundaryNatural() IInterpolationMethod linearMethod = Interpolation.CreateNaturalCubicSpline(linx, liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } @@ -452,15 +452,15 @@ public void TestInterpolationMethod_CubicSpline_BoundaryFirstDerivativeFixed() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints=[1,-1])),20);" - NumericAssert.AreAlmostEqual(1.120000000000000001, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.8243928571428571428, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(.54910714285714285715, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-.78903571428571428572, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-1.1304642857142857143, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-1.1040000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(.4148571428571428571, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(-608.14285714285714286, method.Interpolate(10.0), 1e-15, "A 10.0"); - NumericAssert.AreAlmostEqual(1330.1428571428571429, method.Interpolate(-10.0), 1e-15, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(1.120000000000000001, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.8243928571428571428, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(.54910714285714285715, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-.78903571428571428572, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-1.1304642857142857143, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-1.1040000000000000000, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(.4148571428571428571, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo(-608.14285714285714286, 1e-15), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo(1330.1428571428571429, 1e-15), "A -10.0"); } [Test] @@ -480,15 +480,15 @@ public void TestInterpolationMethod_CubicSpline_BoundarySecondDerivativeFixed() // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints=Matrix(2,13,{(1,3)=1,(1,13)=-5,(2,10)=1,(2,13)=-1}))),20);" - NumericAssert.AreAlmostEqual(-.8999999999999999993, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.7590357142857142857, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(.41517857142857142854, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-.82010714285714285714, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-1.1026071428571428572, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-1.0211428571428571429, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(.31771428571428571421, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(39, method.Interpolate(10.0), 1e-14, "A 10.0"); - NumericAssert.AreAlmostEqual(-37, method.Interpolate(-10.0), 1e-14, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(-.8999999999999999993, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.7590357142857142857, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(.41517857142857142854, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-.82010714285714285714, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-1.1026071428571428572, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-1.0211428571428571429, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(.31771428571428571421, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo((double) 39, 1e-14), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo((double) (-37), 1e-14), "A -10.0"); } [Test] @@ -507,15 +507,15 @@ public void TestInterpolationMethod_AkimaSpline() } // TODO: Verify the expected values (that they are really the expected ones) - NumericAssert.AreAlmostEqual(-0.52, method.Interpolate(-2.4), 1e-15, "A -2.4"); - NumericAssert.AreAlmostEqual(1.826, method.Interpolate(-0.9), 1e-15, "A -0.9"); - NumericAssert.AreAlmostEqual(0.25, method.Interpolate(-0.5), 1e-15, "A -0.5"); - NumericAssert.AreAlmostEqual(-1.006, method.Interpolate(-0.1), 1e-15, "A -0.1"); - NumericAssert.AreAlmostEqual(-0.9, method.Interpolate(0.1), 1e-15, "A 0.1"); - NumericAssert.AreAlmostEqual(-0.6, method.Interpolate(0.4), 1e-15, "A 0.4"); - NumericAssert.AreAlmostEqual(0.2, method.Interpolate(1.2), 1e-15, "A 1.2"); - NumericAssert.AreAlmostEqual(9, method.Interpolate(10.0), 1e-14, "A 10.0"); - NumericAssert.AreAlmostEqual(-151, method.Interpolate(-10.0), 1e-14, "A -10.0"); + Assert.That(method.Interpolate(-2.4), NumericIs.AlmostEqualTo(-0.52, 1e-15), "A -2.4"); + Assert.That(method.Interpolate(-0.9), NumericIs.AlmostEqualTo(1.826, 1e-15), "A -0.9"); + Assert.That(method.Interpolate(-0.5), NumericIs.AlmostEqualTo(0.25, 1e-15), "A -0.5"); + Assert.That(method.Interpolate(-0.1), NumericIs.AlmostEqualTo(-1.006, 1e-15), "A -0.1"); + Assert.That(method.Interpolate(0.1), NumericIs.AlmostEqualTo(-0.9, 1e-15), "A 0.1"); + Assert.That(method.Interpolate(0.4), NumericIs.AlmostEqualTo(-0.6, 1e-15), "A 0.4"); + Assert.That(method.Interpolate(1.2), NumericIs.AlmostEqualTo(0.2, 1e-15), "A 1.2"); + Assert.That(method.Interpolate(10.0), NumericIs.AlmostEqualTo((double) 9, 1e-14), "A 10.0"); + Assert.That(method.Interpolate(-10.0), NumericIs.AlmostEqualTo((double) (-151), 1e-14), "A -10.0"); // Test Linear Case for(int k = 2; k < 6; k++) @@ -525,7 +525,7 @@ public void TestInterpolationMethod_AkimaSpline() IInterpolationMethod linearMethod = Interpolation.CreateAkimaCubicSpline(linx, liny); for(int i = 0; i < linxtest.Length; i++) { - NumericAssert.AreAlmostEqual(linytest[i], linearMethod.Interpolate(linxtest[i]), 1e-12, String.Format("Linear k={0} i={1}", k, i)); + Assert.That(linearMethod.Interpolate(linxtest[i]), NumericIs.AlmostEqualTo(linytest[i], 1e-12), String.Format("Linear k={0} i={1}", k, i)); } } } diff --git a/src/test/MathNet.Iridium.Test/Iridium.Test.csproj b/src/test/MathNet.Iridium.Test/Iridium.Test.csproj index edf9803..7b90927 100644 --- a/src/test/MathNet.Iridium.Test/Iridium.Test.csproj +++ b/src/test/MathNet.Iridium.Test/Iridium.Test.csproj @@ -68,7 +68,7 @@ - + diff --git a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/ComplexMatrixArithmeticsTest.cs b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/ComplexMatrixArithmeticsTest.cs index b6b78c7..a3bfa82 100644 --- a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/ComplexMatrixArithmeticsTest.cs +++ b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/ComplexMatrixArithmeticsTest.cs @@ -53,66 +53,72 @@ public class ComplexMatrixArithmeticsTest [SetUp] public void Setup() { - /* - MATLAB: - ma3x2 = [1 -2;-1 4;5 7] - mb3x2 = [10 2.5;-3 -1.5;19 -6] - mc2x2 = [1 2;3 4] - md2x4 = [1 2 -3 12;3 3.1 4 2] - ra3x2 = ma3x2 + 2 - rb3x2 = mb3x2 - 1 - rc2x2 = mc2x2 + 5 - rd2x4 = md2x4 * 2 - ia3x2 = (ra3x2 * 2) * j - ib3x2 = (rb3x2 * 3 + 1) * j - ic2x2 = (rc2x2 + 2) * j - id2x4 = (rd2x4 - 5) * j - ca3x2 = 2*ra3x2 - 2*ia3x2 - cb3x2 = rb3x2 + 3*ib3x2 - cc2x2 = rc2x2 + 2 - 3*ic2x2 - cd2x4 = -2*rd2x4 + id2x4 + 1-j - v2 = [5 -2] - cv2 = [5+j, -2+3j] - */ - + // MATLAB: ma3x2 = [1 -2;-1 4;5 7] ma3x2 = new Matrix(new double[][] { new double[] { 1, -2 }, new double[] { -1, 4 }, new double[] { 5, 7 } }); + // MATLAB: mb3x2 = [10 2.5;-3 -1.5;19 -6] mb3x2 = new Matrix(new double[][] { new double[] { 10, 2.5 }, new double[] { -3, -1.5 }, new double[] { 19, -6 } }); + // MATLAB: mc2x2 = [1 2;3 4] mc2x2 = new Matrix(new double[][] { new double[] { 1, 2 }, new double[] { 3, 4 } }); + // MATLAB: md2x4 = [1 2 -3 12;3 3.1 4 2] md2x4 = new Matrix(new double[][] { new double[] { 1, 2, -3, 12 }, new double[] { 3, 3.1, 4, 2 } }); + // MATLAB: ra3x2 = ma3x2 + 2 ra3x2 = ComplexMatrix.Create(ma3x2) + 2; + + // MATLAB: rb3x2 = mb3x2 - 1 rb3x2 = ComplexMatrix.Create(mb3x2) - 1; + + // MATLAB: rc2x2 = mc2x2 + 5 rc2x2 = ComplexMatrix.Create(mc2x2) + 5; + + // MATLAB: rd2x4 = md2x4 * 2 rd2x4 = ComplexMatrix.Create(md2x4) * 2; + // MATLAB: ia3x2 = (ra3x2 * 2) * j ia3x2 = (ra3x2 * 2) * j; + + // MATLAB: ib3x2 = (rb3x2 * 3 + 1) * j ib3x2 = ((rb3x2 * 3) + 1) * j; + + // MATLAB: ic2x2 = (rc2x2 + 2) * j ic2x2 = (rc2x2 + 2) * j; + + // MATLAB: id2x4 = (rd2x4 - 5) * j id2x4 = (rd2x4 - 5) * j; + // MATLAB: ca3x2 = 2*ra3x2 - 2*ia3x2 ca3x2 = (2 * ra3x2) - (2 * ia3x2); + + // MATLAB: cb3x2 = rb3x2 + 3*ib3x2 cb3x2 = rb3x2 + (3 * ib3x2); + + // MATLAB: cc2x2 = rc2x2 + 2 - 3*ic2x2 cc2x2 = rc2x2 + 2 - (3 * ic2x2); + + // MATLAB: cd2x4 = -2*rd2x4 + id2x4 + 1-j cd2x4 = (-2 * rd2x4) + id2x4 + (1 - j); + // MATLAB: v2 = [5 -2] v2 = new Vector(new double[] { 5, -2 }); + + // MATLAB: cv2 = [5+j, -2+3j] cv2 = new ComplexVector(new Complex[] { 5 + j, -2 + (3 * j) }); } @@ -127,7 +133,7 @@ public void TestComplexMatrix_Transpose() new Complex[] { 0, 12-(24*j), 18-(36*j) } }); - NumericAssert.AreAlmostEqual(trans_c, ca3x2.Transpose(), "trans c 1"); + Assert.That(ca3x2.Transpose(), NumericIs.AlmostEqualTo(trans_c), "trans c 1"); Assert.That(ca3x2.Transpose(), Is.Not.SameAs(ca3x2)); Assert.That(ca3x2.Transpose().GetArray(), Is.Not.SameAs(ca3x2.GetArray())); @@ -139,7 +145,7 @@ public void TestComplexMatrix_Transpose() new Complex[] { 9-(27*j), 11-(33*j) } }); - NumericAssert.AreAlmostEqual(trans_c2, cc2x2.Transpose(), "trans c2 1"); + Assert.That(cc2x2.Transpose(), NumericIs.AlmostEqualTo(trans_c2), "trans c2 1"); Assert.That(cc2x2.Transpose(), Is.Not.SameAs(cc2x2)); Assert.That(cc2x2.Transpose().GetArray(), Is.Not.SameAs(cc2x2.GetArray())); @@ -149,7 +155,7 @@ public void TestComplexMatrix_Transpose() Complex[][] internalArray = trans_c2_inplace.GetArray(); trans_c2_inplace.TransposeInplace(); - NumericAssert.AreAlmostEqual(trans_c2, trans_c2_inplace, "trans c2 2"); + Assert.That(trans_c2_inplace, NumericIs.AlmostEqualTo(trans_c2), "trans c2 2"); Assert.That(trans_c2_inplace.GetArray(), Is.SameAs(internalArray)); } @@ -164,7 +170,7 @@ public void TestComplexMatrix_HermitianTranspose() new Complex[] { 0, 12+(24*j), 18+(36*j) } }); - NumericAssert.AreAlmostEqual(htrans_c, ca3x2.HermitianTranspose(), "htrans c 1"); + Assert.That(ca3x2.HermitianTranspose(), NumericIs.AlmostEqualTo(htrans_c), "htrans c 1"); Assert.That(ca3x2.HermitianTranspose(), Is.Not.SameAs(ca3x2)); Assert.That(ca3x2.HermitianTranspose().GetArray(), Is.Not.SameAs(ca3x2.GetArray())); @@ -176,7 +182,7 @@ public void TestComplexMatrix_HermitianTranspose() new Complex[] { 9+(27*j), 11+(33*j) } }); - NumericAssert.AreAlmostEqual(htrans_c2, cc2x2.HermitianTranspose(), "htrans c2 1"); + Assert.That(cc2x2.HermitianTranspose(), NumericIs.AlmostEqualTo(htrans_c2), "htrans c2 1"); Assert.That(cc2x2.HermitianTranspose(), Is.Not.SameAs(cc2x2)); Assert.That(cc2x2.HermitianTranspose().GetArray(), Is.Not.SameAs(cc2x2.GetArray())); @@ -186,7 +192,7 @@ public void TestComplexMatrix_HermitianTranspose() Complex[][] internalArray = htrans_c2_inplace.GetArray(); htrans_c2_inplace.HermitianTransposeInplace(); - NumericAssert.AreAlmostEqual(htrans_c2, htrans_c2_inplace, "htrans c2 2"); + Assert.That(htrans_c2_inplace, NumericIs.AlmostEqualTo(htrans_c2), "htrans c2 2"); Assert.That(htrans_c2_inplace.GetArray(), Is.SameAs(internalArray)); } @@ -200,14 +206,14 @@ public void TestComplexMatrix_Conjugate() new Complex[] { 14+(28*j), 18+(36*j) } }); - NumericAssert.AreAlmostEqual(conj_c, ca3x2.Conjugate(), "conj c 1"); + Assert.That(ca3x2.Conjugate(), NumericIs.AlmostEqualTo(conj_c), "conj c 1"); Assert.That(ca3x2.Conjugate(), Is.Not.SameAs(ca3x2)); Assert.That(ca3x2.Conjugate().GetArray(), Is.Not.SameAs(ca3x2.GetArray())); ComplexMatrix conj_c_inplace = ca3x2.Clone(); Complex[][] internalArray = conj_c_inplace.GetArray(); conj_c_inplace.ConjugateInplace(); - NumericAssert.AreAlmostEqual(conj_c, conj_c_inplace, "conj c 2"); + Assert.That(conj_c_inplace, NumericIs.AlmostEqualTo(conj_c), "conj c 2"); Assert.That(internalArray, Is.Not.SameAs(ca3x2.GetArray())); Assert.That(internalArray, Is.SameAs(conj_c_inplace.GetArray())); } @@ -233,11 +239,11 @@ public void TestComplexMatrix_Additive() new Complex[] { 32+(137*j), 11-(96*j) } }); - NumericAssert.AreAlmostEqual(sum_cc, ca3x2 + cb3x2, "sum cc 1"); + Assert.That(ca3x2 + cb3x2, NumericIs.AlmostEqualTo(sum_cc), "sum cc 1"); ComplexMatrix sum_cc_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(sum_cc, sum_cc_inplace.Add(cb3x2), "sum cc 2"); + Assert.That(sum_cc_inplace.Add(cb3x2), NumericIs.AlmostEqualTo(sum_cc), "sum cc 2"); sum_cc_inplace.AddInplace(cb3x2); - NumericAssert.AreAlmostEqual(sum_cc, sum_cc_inplace, "sum cc 3"); + Assert.That(sum_cc_inplace, NumericIs.AlmostEqualTo(sum_cc), "sum cc 3"); // ComplexMatrix - ComplexMatrix ComplexMatrix diff_cc = new ComplexMatrix(new Complex[][] { @@ -246,11 +252,11 @@ public void TestComplexMatrix_Additive() new Complex[] { -4-(193*j), 25+(24*j) } }); - NumericAssert.AreAlmostEqual(diff_cc, ca3x2 - cb3x2, "diff cc 1"); + Assert.That(ca3x2 - cb3x2, NumericIs.AlmostEqualTo(diff_cc), "diff cc 1"); ComplexMatrix diff_cc_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(diff_cc, diff_cc_inplace.Subtract(cb3x2), "diff cc 2"); + Assert.That(diff_cc_inplace.Subtract(cb3x2), NumericIs.AlmostEqualTo(diff_cc), "diff cc 2"); diff_cc_inplace.SubtractInplace(cb3x2); - NumericAssert.AreAlmostEqual(diff_cc, diff_cc_inplace, "diff cc 3"); + Assert.That(diff_cc_inplace, NumericIs.AlmostEqualTo(diff_cc), "diff cc 3"); // ComplexMatrix + Matrix ComplexMatrix sum_cm = new ComplexMatrix(new Complex[][] { @@ -259,11 +265,11 @@ public void TestComplexMatrix_Additive() new Complex[] { 33-(28*j), 12-(36*j) } }); - NumericAssert.AreAlmostEqual(sum_cm, ca3x2 + mb3x2, "sum cm 1"); + Assert.That(ca3x2 + mb3x2, NumericIs.AlmostEqualTo(sum_cm), "sum cm 1"); ComplexMatrix sum_cm_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(sum_cm, sum_cm_inplace.Add(mb3x2), "sum cm 2"); + Assert.That(sum_cm_inplace.Add(mb3x2), NumericIs.AlmostEqualTo(sum_cm), "sum cm 2"); sum_cm_inplace.AddInplace(mb3x2); - NumericAssert.AreAlmostEqual(sum_cm, sum_cm_inplace, "sum cm 3"); + Assert.That(sum_cm_inplace, NumericIs.AlmostEqualTo(sum_cm), "sum cm 3"); // ComplexMatrix - Matrix ComplexMatrix diff_cm = new ComplexMatrix(new Complex[][] { @@ -272,11 +278,11 @@ public void TestComplexMatrix_Additive() new Complex[] { -5-(28*j), 24-(36*j) } }); - NumericAssert.AreAlmostEqual(diff_cm, ca3x2 - mb3x2, "diff cm 1"); + Assert.That(ca3x2 - mb3x2, NumericIs.AlmostEqualTo(diff_cm), "diff cm 1"); ComplexMatrix diff_cm_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(diff_cm, diff_cm_inplace.Subtract(mb3x2), "diff cm 2"); + Assert.That(diff_cm_inplace.Subtract(mb3x2), NumericIs.AlmostEqualTo(diff_cm), "diff cm 2"); diff_cm_inplace.SubtractInplace(mb3x2); - NumericAssert.AreAlmostEqual(diff_cm, diff_cm_inplace, "diff cm 3"); + Assert.That(diff_cm_inplace, NumericIs.AlmostEqualTo(diff_cm), "diff cm 3"); // ComplexMatrix + Complex ComplexMatrix sum_cs = new ComplexMatrix(new Complex[][] { @@ -285,11 +291,11 @@ public void TestComplexMatrix_Additive() new Complex[] { 15-(27*j), 19-(35*j) } }); - NumericAssert.AreAlmostEqual(sum_cs, ca3x2 + s, "sum cs 1"); + Assert.That(ca3x2 + s, NumericIs.AlmostEqualTo(sum_cs), "sum cs 1"); ComplexMatrix sum_cs_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(sum_cs, sum_cs_inplace.Add(s), "sum cs 2"); + Assert.That(sum_cs_inplace.Add(s), NumericIs.AlmostEqualTo(sum_cs), "sum cs 2"); sum_cs_inplace.AddInplace(s); - NumericAssert.AreAlmostEqual(sum_cs, sum_cs_inplace, "sum cs 3"); + Assert.That(sum_cs_inplace, NumericIs.AlmostEqualTo(sum_cs), "sum cs 3"); // ComplexMatrix - Complex ComplexMatrix diff_cs = new ComplexMatrix(new Complex[][] { @@ -298,11 +304,11 @@ public void TestComplexMatrix_Additive() new Complex[] { 13-(29*j), 17-(37*j) } }); - NumericAssert.AreAlmostEqual(diff_cs, ca3x2 - s, "diff cs 1"); + Assert.That(ca3x2 - s, NumericIs.AlmostEqualTo(diff_cs), "diff cs 1"); ComplexMatrix diff_cs_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(diff_cs, diff_cs_inplace.Subtract(s), "diff cs 2"); + Assert.That(diff_cs_inplace.Subtract(s), NumericIs.AlmostEqualTo(diff_cs), "diff cs 2"); diff_cs_inplace.SubtractInplace(s); - NumericAssert.AreAlmostEqual(diff_cs, diff_cs_inplace, "diff cs 3"); + Assert.That(diff_cs_inplace, NumericIs.AlmostEqualTo(diff_cs), "diff cs 3"); // ComplexMatrix Negate ComplexMatrix neg_c = new ComplexMatrix(new Complex[][] { @@ -311,11 +317,11 @@ public void TestComplexMatrix_Additive() new Complex[] { -14+(28*j), -18+(36*j) } }); - NumericAssert.AreAlmostEqual(neg_c, -ca3x2, "neg c 1"); + Assert.That(-ca3x2, NumericIs.AlmostEqualTo(neg_c), "neg c 1"); ComplexMatrix neg_c_inplace = ca3x2.Clone(); - NumericAssert.AreAlmostEqual(neg_c, neg_c_inplace.Negate(), "neg c 2"); + Assert.That(neg_c_inplace.Negate(), NumericIs.AlmostEqualTo(neg_c), "neg c 2"); neg_c_inplace.NegateInplace(); - NumericAssert.AreAlmostEqual(neg_c, neg_c_inplace, "neg c 3"); + Assert.That(neg_c_inplace, NumericIs.AlmostEqualTo(neg_c), "neg c 3"); } [Test] @@ -344,8 +350,8 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { -352+(424*j), -352+(582*j), -352+(44*j), -352+(1784*j) } }); - NumericAssert.AreAlmostEqual(prod_cc, ca3x2 * cd2x4, "prod cc 1"); - NumericAssert.AreAlmostEqual(prod_cc, ca3x2.Multiply(cd2x4), "prod cc 2"); + Assert.That(ca3x2 * cd2x4, NumericIs.AlmostEqualTo(prod_cc), "prod cc 1"); + Assert.That(ca3x2.Multiply(cd2x4), NumericIs.AlmostEqualTo(prod_cc), "prod cc 2"); // ComplexMatrix * Matrix ComplexMatrix prod_cm = new ComplexMatrix(new Complex[][] { @@ -354,8 +360,8 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 68-(136*j), 83.8-(167.6*j), 30-(60*j), 204-(408*j) } }); - NumericAssert.AreAlmostEqual(prod_cm, ca3x2 * md2x4, "prod cm 1"); - NumericAssert.AreAlmostEqual(prod_cm, ca3x2.Multiply(md2x4), "prod cm 2"); + Assert.That(ca3x2 * md2x4, NumericIs.AlmostEqualTo(prod_cm), "prod cm 1"); + Assert.That(ca3x2.Multiply(md2x4), NumericIs.AlmostEqualTo(prod_cm), "prod cm 2"); // ComplexMatrix * Complex ComplexMatrix prod_cs = new ComplexMatrix(new Complex[][] { @@ -364,8 +370,8 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 42-(14*j), 54-(18*j) } }); - NumericAssert.AreAlmostEqual(prod_cs, ca3x2 * s, "prod cs 1"); - NumericAssert.AreAlmostEqual(prod_cs, ca3x2.Multiply(s), "prod cs 2"); + Assert.That(ca3x2 * s, NumericIs.AlmostEqualTo(prod_cs), "prod cs 1"); + Assert.That(ca3x2.Multiply(s), NumericIs.AlmostEqualTo(prod_cs), "prod cs 2"); // ComplexMatrix * ComplexMatrix (Square) ComplexMatrix prod_cc2 = new ComplexMatrix(new Complex[][] { @@ -373,11 +379,11 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { -1520-(1140*j), -1688-(1266*j) } }); - NumericAssert.AreAlmostEqual(prod_cc2, cc2x2 * cc2x2, "prod cc2 1"); - NumericAssert.AreAlmostEqual(prod_cc2, cc2x2.Multiply(cc2x2), "prod cc2 2"); + Assert.That(cc2x2 * cc2x2, NumericIs.AlmostEqualTo(prod_cc2), "prod cc2 1"); + Assert.That(cc2x2.Multiply(cc2x2), NumericIs.AlmostEqualTo(prod_cc2), "prod cc2 2"); ComplexMatrix prod_cc2_inplace = cc2x2.Clone(); prod_cc2_inplace.MultiplyInplace(cc2x2); - NumericAssert.AreAlmostEqual(prod_cc2, prod_cc2_inplace, "prod cc2 3"); + Assert.That(prod_cc2_inplace, NumericIs.AlmostEqualTo(prod_cc2), "prod cc2 3"); // ComplexMatrix * Matrix (Square) ComplexMatrix prod_cm2 = new ComplexMatrix(new Complex[][] { @@ -385,11 +391,11 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 43-(129*j), 64-(192*j) } }); - NumericAssert.AreAlmostEqual(prod_cm2, cc2x2 * mc2x2, "prod cm2 1"); - NumericAssert.AreAlmostEqual(prod_cm2, cc2x2.Multiply(mc2x2), "prod cm2 2"); + Assert.That(cc2x2 * mc2x2, NumericIs.AlmostEqualTo(prod_cm2), "prod cm2 1"); + Assert.That(cc2x2.Multiply(mc2x2), NumericIs.AlmostEqualTo(prod_cm2), "prod cm2 2"); ComplexMatrix prod_cm2_inplace = cc2x2.Clone(); prod_cm2_inplace.MultiplyInplace(mc2x2); - NumericAssert.AreAlmostEqual(prod_cm2, prod_cm2_inplace, "prod cm2 3"); + Assert.That(prod_cm2_inplace, NumericIs.AlmostEqualTo(prod_cm2), "prod cm2 3"); // ComplexMatrix * Complex (Square) ComplexMatrix prod_cs2 = new ComplexMatrix(new Complex[][] { @@ -397,21 +403,21 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 40-(20*j), 44-(22*j) } }); - NumericAssert.AreAlmostEqual(prod_cs2, cc2x2 * s, "prod cs2 1"); - NumericAssert.AreAlmostEqual(prod_cs2, cc2x2.Multiply(s), "prod cs2 2"); + Assert.That(cc2x2 * s, NumericIs.AlmostEqualTo(prod_cs2), "prod cs2 1"); + Assert.That(cc2x2.Multiply(s), NumericIs.AlmostEqualTo(prod_cs2), "prod cs2 2"); ComplexMatrix prod_cs2_inplace = cc2x2.Clone(); prod_cs2_inplace.MultiplyInplace(s); - NumericAssert.AreAlmostEqual(prod_cs2, prod_cs2_inplace, "prod cs2 3"); + Assert.That(prod_cs2_inplace, NumericIs.AlmostEqualTo(prod_cs2), "prod cs2 3"); // ComplexMatrix * ComplexVector (Column) ComplexVector prod_ccv = new ComplexVector(new Complex[] { 42 - (54 * j), 62 + (66 * j), 170 }); - NumericAssert.AreAlmostEqual(prod_ccv, ca3x2 * cv2, "prod ccv 1"); - NumericAssert.AreAlmostEqual(prod_ccv, ca3x2.MultiplyRightColumn(cv2), "prod ccv 2"); + Assert.That(ca3x2 * cv2, NumericIs.AlmostEqualTo(prod_ccv), "prod ccv 1"); + Assert.That(ca3x2.MultiplyRightColumn(cv2), NumericIs.AlmostEqualTo(prod_ccv), "prod ccv 2"); // ComplexMatrix * Vector (Column) ComplexVector prod_cv = new ComplexVector(new Complex[] { 30 - (60 * j), -14 + (28 * j), 34 - (68 * j) }); - NumericAssert.AreAlmostEqual(prod_cv, ca3x2 * v2, "prod cv 1"); - NumericAssert.AreAlmostEqual(prod_cv, ca3x2.MultiplyRightColumn(v2), "prod cv 2"); + Assert.That(ca3x2 * v2, NumericIs.AlmostEqualTo(prod_cv), "prod cv 1"); + Assert.That(ca3x2.MultiplyRightColumn(v2), NumericIs.AlmostEqualTo(prod_cv), "prod cv 2"); // ComplexMatrix * ComplexVector (Diagonal, Left) ComplexMatrix prod_ccvdl = new ComplexMatrix(new Complex[][] { @@ -419,11 +425,11 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 70+(90*j), 77+(99*j) } }); - NumericAssert.AreAlmostEqual(prod_ccvdl, cc2x2.MultiplyLeftDiagonal(cv2), "prod ccv dl 1"); + Assert.That(cc2x2.MultiplyLeftDiagonal(cv2), NumericIs.AlmostEqualTo(prod_ccvdl), "prod ccv dl 1"); ComplexMatrix prod_ccvdl_inplace = cc2x2.Clone(); prod_ccvdl_inplace.MultiplyLeftDiagonalInplace(cv2); - NumericAssert.AreAlmostEqual(prod_ccvdl, prod_ccvdl_inplace, "prod ccv dl 2"); - NumericAssert.AreAlmostEqual(prod_ccvdl, ComplexMatrix.Diagonal(cv2) * cc2x2, "prod ccv dl 3"); + Assert.That(prod_ccvdl_inplace, NumericIs.AlmostEqualTo(prod_ccvdl), "prod ccv dl 2"); + Assert.That(ComplexMatrix.Diagonal(cv2) * cc2x2, NumericIs.AlmostEqualTo(prod_ccvdl), "prod ccv dl 3"); // ComplexMatrix * Vector (Diagonal, Left) ComplexMatrix prod_cvdl = new ComplexMatrix(new Complex[][] { @@ -431,10 +437,10 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { -20+(60*j), -22+(66*j) } }); - NumericAssert.AreAlmostEqual(prod_cvdl, cc2x2.MultiplyLeftDiagonal(v2), "prod cv dl 1"); + Assert.That(cc2x2.MultiplyLeftDiagonal(v2), NumericIs.AlmostEqualTo(prod_cvdl), "prod cv dl 1"); ComplexMatrix prod_cvdl_inplace = cc2x2.Clone(); prod_cvdl_inplace.MultiplyLeftDiagonalInplace(v2); - NumericAssert.AreAlmostEqual(prod_cvdl, prod_cvdl_inplace, "prod cv dl 2"); + Assert.That(prod_cvdl_inplace, NumericIs.AlmostEqualTo(prod_cvdl), "prod cv dl 2"); // ComplexMatrix * ComplexVector (Diagonal, Right) ComplexMatrix prod_ccvdr = new ComplexMatrix(new Complex[][] { @@ -442,11 +448,11 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 80-(140*j), 77+(99*j) } }); - NumericAssert.AreAlmostEqual(prod_ccvdr, cc2x2.MultiplyRightDiagonal(cv2), "prod ccv dr 1"); + Assert.That(cc2x2.MultiplyRightDiagonal(cv2), NumericIs.AlmostEqualTo(prod_ccvdr), "prod ccv dr 1"); ComplexMatrix prod_ccvdr_inplace = cc2x2.Clone(); prod_ccvdr_inplace.MultiplyRightDiagonalInplace(cv2); - NumericAssert.AreAlmostEqual(prod_ccvdr, prod_ccvdr_inplace, "prod ccv dr 2"); - NumericAssert.AreAlmostEqual(prod_ccvdr, cc2x2 * ComplexMatrix.Diagonal(cv2), "prod ccv dr 3"); + Assert.That(prod_ccvdr_inplace, NumericIs.AlmostEqualTo(prod_ccvdr), "prod ccv dr 2"); + Assert.That(cc2x2 * ComplexMatrix.Diagonal(cv2), NumericIs.AlmostEqualTo(prod_ccvdr), "prod ccv dr 3"); // ComplexMatrix * Vector (Diagonal, Right) ComplexMatrix prod_cvdr = new ComplexMatrix(new Complex[][] { @@ -454,10 +460,10 @@ public void TestComplexMatrix_Multiplicative() new Complex[] { 50-(150*j), -22+(66*j) } }); - NumericAssert.AreAlmostEqual(prod_cvdr, cc2x2.MultiplyRightDiagonal(v2), "prod cv dr 1"); + Assert.That(cc2x2.MultiplyRightDiagonal(v2), NumericIs.AlmostEqualTo(prod_cvdr), "prod cv dr 1"); ComplexMatrix prod_cvdr_inplace = cc2x2.Clone(); prod_cvdr_inplace.MultiplyRightDiagonalInplace(v2); - NumericAssert.AreAlmostEqual(prod_cvdr, prod_cvdr_inplace, "prod cv dr 2"); + Assert.That(prod_cvdr_inplace, NumericIs.AlmostEqualTo(prod_cvdr), "prod cv dr 2"); } } } diff --git a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebra.Test.cs b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebra.Test.cs index 9ffdc40..b34c725 100644 --- a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebra.Test.cs +++ b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebra.Test.cs @@ -152,8 +152,8 @@ public void SolveRobust() Matrix X1 = A1.SolveRobust(B1); // [vermorel] Values have been computed with LAD function of Systat 12 - NumericAssert.AreAlmostEqual(1.2, X1[0, 0], "#A00 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(0.4, X1[1, 0], "#A01 Unexpected robust regression result."); + Assert.That(X1[0, 0], NumericIs.AlmostEqualTo(1.2), "#A00 Unexpected robust regression result."); + Assert.That(X1[1, 0], NumericIs.AlmostEqualTo(0.4), "#A01 Unexpected robust regression result."); Matrix A2 = Matrix.Create( new double[6, 3] { @@ -178,9 +178,9 @@ public void SolveRobust() Matrix X2 = A2.SolveRobust(B2); // [vermorel] Values have been computed with LAD function of Systat 12 - NumericAssert.AreAlmostEqual(0.667, X2[0, 0], 1e-3, "#A02 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(1.0, X2[1, 0], 1e-5, "#A03 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(-0.167, X2[2, 0], 1e-2, "#A04 Unexpected robust regression result."); + Assert.That(X2[0, 0], NumericIs.AlmostEqualTo(0.667, 1e-3), "#A02 Unexpected robust regression result."); + Assert.That(X2[1, 0], NumericIs.AlmostEqualTo(1.0, 1e-5), "#A03 Unexpected robust regression result."); + Assert.That(X2[2, 0], NumericIs.AlmostEqualTo(-0.167, 1e-2), "#A04 Unexpected robust regression result."); Matrix A3 = Matrix.Create( new double[10, 4] { @@ -213,10 +213,10 @@ public void SolveRobust() Matrix X3 = A3.SolveRobust(B3); // [vermorel] Values have been computed with LAD function of Systat 12 - NumericAssert.AreAlmostEqual(-0.104, X3[0, 0], 1e-2, "#A05 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(-0.216, X3[1, 0], 1e-2, "#A06 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(-0.618, X3[2, 0], 1e-3, "#A07 Unexpected robust regression result."); - NumericAssert.AreAlmostEqual(0.238, X3[3, 0], 1e-3, "#A08 Unexpected robust regression result."); + Assert.That(X3[0, 0], NumericIs.AlmostEqualTo(-0.104, 1e-2), "#A05 Unexpected robust regression result."); + Assert.That(X3[1, 0], NumericIs.AlmostEqualTo(-0.216, 1e-2), "#A06 Unexpected robust regression result."); + Assert.That(X3[2, 0], NumericIs.AlmostEqualTo(-0.618, 1e-3), "#A07 Unexpected robust regression result."); + Assert.That(X3[3, 0], NumericIs.AlmostEqualTo(0.238, 1e-3), "#A08 Unexpected robust regression result."); } /// @@ -240,7 +240,7 @@ public void SingularValueDecomposition() { for(int j = 0; j < matrix.ColumnCount; j++) { - NumericAssert.AreAlmostEqual(matrix[i, j], product[i, j], 1e-10, "#A00"); + Assert.That(product[i, j], NumericIs.AlmostEqualTo(matrix[i, j], 1e-10), "#A00"); } } } @@ -310,7 +310,7 @@ public void AllTests() avals[0][0] = columnwise[0]; I = new Matrix(ivals); - NumericAssert.AreAlmostEqual(I, Matrix.Identity(3, 4), "Identity"); + Assert.That(Matrix.Identity(3, 4), NumericIs.AlmostEqualTo(I), "Identity"); /***** Testing access methods *****/ @@ -343,7 +343,7 @@ public void AllTests() barray = B.Clone(); Assert.That(barray, Is.Not.SameAs(avals), "getArrayCopy"); - NumericAssert.AreAlmostEqual(new Matrix(barray), B, "getArrayCopy II"); + Assert.That(B, NumericIs.AlmostEqualTo(new Matrix(barray)), "getArrayCopy II"); ////double[] bpacked = B.ColumnPackedCopy; ////try @@ -379,25 +379,25 @@ public void AllTests() Assert.That(delegate() { M = B.GetMatrix(ib, ie, jb, je + B.ColumnCount + 1); }, Throws.TypeOf()); M = B.GetMatrix(ib, ie, jb, je); - NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int,int,int,int)"); + Assert.That(M, NumericIs.AlmostEqualTo(SUB), "GetMatrix(int,int,int,int)"); Assert.That(delegate() { M = B.GetMatrix(ib, ie, badcolumnindexset); }, Throws.TypeOf()); Assert.That(delegate() { M = B.GetMatrix(ib, ie + B.RowCount + 1, columnindexset); }, Throws.TypeOf()); M = B.GetMatrix(ib, ie, columnindexset); - NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int,int,int[])"); + Assert.That(M, NumericIs.AlmostEqualTo(SUB), "GetMatrix(int,int,int[])"); Assert.That(delegate() { M = B.GetMatrix(badrowindexset, jb, je); }, Throws.TypeOf()); Assert.That(delegate() { M = B.GetMatrix(rowindexset, jb, je + B.ColumnCount + 1); }, Throws.TypeOf()); M = B.GetMatrix(rowindexset, jb, je); - NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int[],int,int)"); + Assert.That(M, NumericIs.AlmostEqualTo(SUB), "GetMatrix(int[],int,int)"); Assert.That(delegate() { M = B.GetMatrix(badrowindexset, columnindexset); }, Throws.TypeOf()); Assert.That(delegate() { M = B.GetMatrix(rowindexset, badcolumnindexset); }, Throws.TypeOf()); M = B.GetMatrix(rowindexset, columnindexset); - NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int[],int[])"); + Assert.That(M, NumericIs.AlmostEqualTo(SUB), "GetMatrix(int[],int[])"); // Various set methods: Assert.That(delegate() { B[B.RowCount, B.ColumnCount - 1] = 0.0; }, Throws.TypeOf()); @@ -405,7 +405,7 @@ public void AllTests() B[ib, jb] = 0.0; tmp = B[ib, jb]; - NumericAssert.AreAlmostEqual(tmp, 0.0, "set(int,int,double)"); + Assert.That(0.0, NumericIs.AlmostEqualTo(tmp), "set(int,int,double)"); M = new Matrix(2, 3, 0.0); @@ -413,21 +413,21 @@ public void AllTests() Assert.That(delegate() { B.SetMatrix(ib, ie, jb, je + B.ColumnCount + 1, M); }, Throws.TypeOf()); B.SetMatrix(ib, ie, jb, je, M); - NumericAssert.AreAlmostEqual(M - B.GetMatrix(ib, ie, jb, je), M, "SetMatrix(int,int,int,int,Matrix)"); + Assert.That(M, NumericIs.AlmostEqualTo(M - B.GetMatrix(ib, ie, jb, je)), "SetMatrix(int,int,int,int,Matrix)"); B.SetMatrix(ib, ie, jb, je, SUB); Assert.That(delegate() { B.SetMatrix(ib, ie + B.RowCount + 1, columnindexset, M); }, Throws.TypeOf()); Assert.That(delegate() { B.SetMatrix(ib, ie, badcolumnindexset, M); }, Throws.TypeOf()); B.SetMatrix(ib, ie, columnindexset, M); - NumericAssert.AreAlmostEqual(M - B.GetMatrix(ib, ie, columnindexset), M, "SetMatrix(int,int,int[],Matrix)"); + Assert.That(M, NumericIs.AlmostEqualTo(M - B.GetMatrix(ib, ie, columnindexset)), "SetMatrix(int,int,int[],Matrix)"); B.SetMatrix(ib, ie, jb, je, SUB); Assert.That(delegate() { B.SetMatrix(rowindexset, jb, je + B.ColumnCount + 1, M); }, Throws.TypeOf()); Assert.That(delegate() { B.SetMatrix(badrowindexset, jb, je, M); }, Throws.TypeOf()); B.SetMatrix(rowindexset, jb, je, M); - NumericAssert.AreAlmostEqual(M - B.GetMatrix(rowindexset, jb, je), M, "SetMatrix(int[],int,int,Matrix)"); + Assert.That(M, NumericIs.AlmostEqualTo(M - B.GetMatrix(rowindexset, jb, je)), "SetMatrix(int[],int,int,Matrix)"); B.SetMatrix(ib, ie, jb, je, SUB); @@ -435,7 +435,7 @@ public void AllTests() Assert.That(delegate() { B.SetMatrix(badrowindexset, columnindexset, M); }, Throws.TypeOf()); B.SetMatrix(rowindexset, columnindexset, M); - NumericAssert.AreAlmostEqual(M - B.GetMatrix(rowindexset, columnindexset), M, "SetMatrix(int[],int[],Matrix)"); + Assert.That(M, NumericIs.AlmostEqualTo(M - B.GetMatrix(rowindexset, columnindexset)), "SetMatrix(int[],int[],Matrix)"); /***** Testing array-like methods *****/ @@ -476,18 +476,18 @@ public void AllTests() Assert.That(delegate() { S = A + S; }, Throws.TypeOf()); - NumericAssert.AreAlmostEqual(C + B, A, "Add"); + Assert.That(A, NumericIs.AlmostEqualTo(C + B), "Add"); C = A - B; C.AddInplace(B); Assert.That(delegate() { A.AddInplace(S); }, Throws.TypeOf()); - NumericAssert.AreAlmostEqual(C, A, "AddEquals"); + Assert.That(A, NumericIs.AlmostEqualTo(C), "AddEquals"); A = ((Matrix)R.Clone()); A.NegateInplace(); - NumericAssert.AreAlmostEqual(A + R, Z, "UnaryMinus"); + Assert.That(Z, NumericIs.AlmostEqualTo(A + R), "UnaryMinus"); A = (Matrix)R.Clone(); O = new Matrix(A.RowCount, A.ColumnCount, 1.0); @@ -495,12 +495,12 @@ public void AllTests() Assert.That(delegate() { Matrix.ArrayDivide(A, S); }, Throws.TypeOf()); C = Matrix.ArrayDivide(A, R); - NumericAssert.AreAlmostEqual(C, O, "ArrayRightDivide"); + Assert.That(O, NumericIs.AlmostEqualTo(C), "ArrayRightDivide"); Assert.That(delegate() { A.ArrayDivide(S); }, Throws.TypeOf()); A.ArrayDivide(R); - NumericAssert.AreAlmostEqual(A, O, "ArrayRightDivideEquals"); + Assert.That(O, NumericIs.AlmostEqualTo(A), "ArrayRightDivideEquals"); A = (Matrix)R.Clone(); B = Matrix.Random(A.RowCount, A.ColumnCount); @@ -509,13 +509,13 @@ public void AllTests() C = Matrix.ArrayMultiply(A, B); C.ArrayDivide(B); - NumericAssert.AreAlmostEqual(C, A, "arrayTimes"); + Assert.That(A, NumericIs.AlmostEqualTo(C), "arrayTimes"); Assert.That(delegate() { A.ArrayMultiply(S); }, Throws.TypeOf()); A.ArrayMultiply(B); A.ArrayDivide(B); - NumericAssert.AreAlmostEqual(A, R, "ArrayMultiplyEquals"); + Assert.That(R, NumericIs.AlmostEqualTo(A), "ArrayMultiplyEquals"); /***** Testing linear algebra methods *****/ @@ -544,65 +544,65 @@ public void AllTests() A = new Matrix(columnwise, 3); T = new Matrix(tvals); T = Matrix.Transpose(A); - NumericAssert.AreAlmostEqual(Matrix.Transpose(A), T, "Transpose"); - NumericAssert.AreAlmostEqual(A.Norm1(), columnsummax, "Norm1"); - NumericAssert.AreAlmostEqual(A.NormInf(), rowsummax, "NormInf"); - NumericAssert.AreAlmostEqual(A.NormF(), Math.Sqrt(sumofsquares), "NormF"); - NumericAssert.AreAlmostEqual(A.Trace(), sumofdiagonals, "Trace"); - NumericAssert.AreAlmostEqual(A.GetMatrix(0, A.RowCount - 1, 0, A.RowCount - 1).Determinant(), 0.0, "Determinant"); + Assert.That(T, NumericIs.AlmostEqualTo(Matrix.Transpose(A)), "Transpose"); + Assert.That(columnsummax, NumericIs.AlmostEqualTo(A.Norm1()), "Norm1"); + Assert.That(rowsummax, NumericIs.AlmostEqualTo(A.NormInf()), "NormInf"); + Assert.That(Math.Sqrt(sumofsquares), NumericIs.AlmostEqualTo(A.NormF()), "NormF"); + Assert.That(sumofdiagonals, NumericIs.AlmostEqualTo(A.Trace()), "Trace"); + Assert.That(0.0, NumericIs.AlmostEqualTo(A.GetMatrix(0, A.RowCount - 1, 0, A.RowCount - 1).Determinant()), "Determinant"); SQ = new Matrix(square); - NumericAssert.AreAlmostEqual(A * Matrix.Transpose(A), SQ, "Multiply(Matrix)"); - NumericAssert.AreAlmostEqual(0.0 * A, Z, "Multiply(double)"); + Assert.That(SQ, NumericIs.AlmostEqualTo(A * Matrix.Transpose(A)), "Multiply(Matrix)"); + Assert.That(Z, NumericIs.AlmostEqualTo(0.0 * A), "Multiply(double)"); A = new Matrix(columnwise, 4); QRDecomposition QR = A.QRDecomposition; R = QR.R; - NumericAssert.AreAlmostEqual(A, QR.Q * R, "QRDecomposition"); + Assert.That(QR.Q * R, NumericIs.AlmostEqualTo(A), "QRDecomposition"); SingularValueDecomposition SVD = A.SingularValueDecomposition; - NumericAssert.AreAlmostEqual(A, SVD.LeftSingularVectors * (SVD.S * Matrix.Transpose(SVD.RightSingularVectors)), "SingularValueDecomposition"); + Assert.That(SVD.LeftSingularVectors * (SVD.S * Matrix.Transpose(SVD.RightSingularVectors)), NumericIs.AlmostEqualTo(A), "SingularValueDecomposition"); DEF = new Matrix(rankdef); - NumericAssert.AreAlmostEqual(DEF.Rank(), Math.Min(DEF.RowCount, DEF.ColumnCount) - 1, "Rank"); + Assert.That((double) (Math.Min(DEF.RowCount, DEF.ColumnCount) - 1), NumericIs.AlmostEqualTo((double) DEF.Rank()), "Rank"); B = new Matrix(condmat); SVD = B.SingularValueDecomposition; double[] singularvalues = SVD.SingularValues; - NumericAssert.AreAlmostEqual(B.Condition(), singularvalues[0] / singularvalues[Math.Min(B.RowCount, B.ColumnCount) - 1], "Condition"); + Assert.That(singularvalues[0] / singularvalues[Math.Min(B.RowCount, B.ColumnCount) - 1], NumericIs.AlmostEqualTo(B.Condition()), "Condition"); int n = A.ColumnCount; A = A.GetMatrix(0, n - 1, 0, n - 1); A[0, 0] = 0.0; LUDecomposition LU = A.LUDecomposition; - NumericAssert.AreAlmostEqual(A.GetMatrix(LU.Pivot, 0, n - 1), LU.L * LU.U, "LUDecomposition"); + Assert.That(LU.L * LU.U, NumericIs.AlmostEqualTo(A.GetMatrix(LU.Pivot, 0, n - 1)), "LUDecomposition"); X = A.Inverse(); - NumericAssert.AreAlmostEqual(A * X, Matrix.Identity(3, 3), "Inverse"); + Assert.That(Matrix.Identity(3, 3), NumericIs.AlmostEqualTo(A * X, 1e-14), "Inverse"); O = new Matrix(SUB.RowCount, 1, 1.0); SOL = new Matrix(sqSolution); SQ = SUB.GetMatrix(0, SUB.RowCount - 1, 0, SUB.RowCount - 1); - NumericAssert.AreAlmostEqual(SQ.Solve(SOL), O, "Solve"); + Assert.That(O, NumericIs.AlmostEqualTo(SQ.Solve(SOL)), "Solve"); A = new Matrix(pvals); CholeskyDecomposition Chol = A.CholeskyDecomposition; Matrix L = Chol.TriangularFactor; - NumericAssert.AreAlmostEqual(A, L * Matrix.Transpose(L), "CholeskyDecomposition"); + Assert.That(L * Matrix.Transpose(L), NumericIs.AlmostEqualTo(A), "CholeskyDecomposition"); X = Chol.Solve(Matrix.Identity(3, 3)); - NumericAssert.AreAlmostEqual(A * X, Matrix.Identity(3, 3), "CholeskyDecomposition Solve"); + Assert.That(Matrix.Identity(3, 3), NumericIs.AlmostEqualTo(A * X), "CholeskyDecomposition Solve"); EigenvalueDecomposition Eig = A.EigenvalueDecomposition; Matrix D = Eig.BlockDiagonal; Matrix V = Eig.EigenVectors; - NumericAssert.AreAlmostEqual(A * V, V * D, "EigenvalueDecomposition (symmetric)"); + Assert.That(V * D, NumericIs.AlmostEqualTo(A * V), "EigenvalueDecomposition (symmetric)"); A = new Matrix(evals); Eig = A.EigenvalueDecomposition; D = Eig.BlockDiagonal; V = Eig.EigenVectors; - NumericAssert.AreAlmostEqual(A * V, V * D, "EigenvalueDecomposition (nonsymmetric)"); + Assert.That(V * D, NumericIs.AlmostEqualTo(A * V, 1e-14), "EigenvalueDecomposition (nonsymmetric)"); } } } diff --git a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebraAlgorithmsTest.cs b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebraAlgorithmsTest.cs index e226b26..91634f5 100644 --- a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebraAlgorithmsTest.cs +++ b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/LinearAlgebraAlgorithmsTest.cs @@ -51,10 +51,10 @@ public void TestOrthogonalRotation() Vector v = Vector.Random(2, gaussian); Matrix rotation = Orthogonal.Rotation(v); Vector res = rotation * v; - NumericAssert.AreAlmostEqual(Matrix.Identity(2, 2), Matrix.Transpose(rotation) * rotation, "orthogonal rotation matrix"); - NumericAssert.AreAlmostEqual(1, rotation.Norm2(), "rotation matrix norm"); - NumericAssert.AreAlmostEqual(v.Norm(), Math.Abs(res[0]), 1e-12, "res(1)"); - NumericAssert.AreAlmostEqual(0, res[1], 1e-12, "res(2)"); + Assert.That(Matrix.Transpose(rotation) * rotation, NumericIs.AlmostEqualTo(Matrix.Identity(2, 2)), "orthogonal rotation matrix"); + Assert.That(rotation.Norm2(), NumericIs.AlmostEqualTo((double) 1), "rotation matrix norm"); + Assert.That(Math.Abs(res[0]), NumericIs.AlmostEqualTo(v.Norm(), 1e-12), "res(1)"); + Assert.That(res[1], NumericIs.AlmostEqualTo((double) 0, 1e-12), "res(2)"); } } @@ -67,11 +67,11 @@ public void TestOrthogonalRotationComplex() ComplexVector v = new ComplexVector(new Complex[] { Complex.Random(gaussian), Complex.Random(gaussian) }); ComplexMatrix rotation = Orthogonal.Rotation(v); ComplexVector res = rotation * v; - NumericAssert.AreAlmostEqual(ComplexMatrix.Identity(2, 2), rotation.HermitianTranspose() * rotation, "unitary rotation matrix"); + Assert.That(rotation.HermitianTranspose() * rotation, NumericIs.AlmostEqualTo(ComplexMatrix.Identity(2, 2)), "unitary rotation matrix"); Assert.That(rotation[0, 0].IsReal, "c1 real"); Assert.That(rotation[1, 1].IsReal, "c2 real"); - NumericAssert.AreAlmostEqual(v.Norm(), res[0].Modulus, 1e-12, "res(1)"); - NumericAssert.AreAlmostEqual(0, res[1], 1e-12, "res(2)"); + Assert.That(res[0].Modulus, NumericIs.AlmostEqualTo(v.Norm(), 1e-12), "res(1)"); + Assert.That(res[1], NumericIs.AlmostEqualTo((Complex) 0, 1e-12), "res(2)"); } } @@ -84,12 +84,12 @@ public void TestOrthogonalReflection() Vector v = Vector.Random(4, gaussian); Matrix reflection = Orthogonal.Reflection(v); Vector res = reflection * v; - NumericAssert.AreAlmostEqual(Matrix.Identity(4, 4), Matrix.Transpose(reflection) * reflection, "orthogonal reflection matrix"); - NumericAssert.AreAlmostEqual(1, reflection.Norm2(), "reflection matrix norm"); - NumericAssert.AreAlmostEqual(v.Norm(), Math.Abs(res[0]), 1e-12, "res(1)"); - NumericAssert.AreAlmostEqual(0, res[1], 1e-12, "res(2)"); - NumericAssert.AreAlmostEqual(0, res[2], 1e-12, "res(3)"); - NumericAssert.AreAlmostEqual(0, res[3], 1e-12, "res(4)"); + Assert.That(Matrix.Transpose(reflection) * reflection, NumericIs.AlmostEqualTo(Matrix.Identity(4, 4)), "orthogonal reflection matrix"); + Assert.That(reflection.Norm2(), NumericIs.AlmostEqualTo((double) 1), "reflection matrix norm"); + Assert.That(Math.Abs(res[0]), NumericIs.AlmostEqualTo(v.Norm(), 1e-12), "res(1)"); + Assert.That(res[1], NumericIs.AlmostEqualTo((double) 0, 1e-12), "res(2)"); + Assert.That(res[2], NumericIs.AlmostEqualTo((double) 0, 1e-12), "res(3)"); + Assert.That(res[3], NumericIs.AlmostEqualTo((double) 0, 1e-12), "res(4)"); } } @@ -102,15 +102,15 @@ public void TestOrthogonalReflectionComplex() ComplexVector v = new ComplexVector(new Complex[] { Complex.Random(gaussian), Complex.Random(gaussian), Complex.Random(gaussian), Complex.Random(gaussian) }); ComplexMatrix reflection = Orthogonal.Reflection(v); ComplexVector res = reflection * v; - NumericAssert.AreAlmostEqual(ComplexMatrix.Identity(4, 4), reflection.HermitianTranspose() * reflection, "orthogonal reflection matrix"); + Assert.That(reflection.HermitianTranspose() * reflection, NumericIs.AlmostEqualTo(ComplexMatrix.Identity(4, 4)), "orthogonal reflection matrix"); Assert.That(reflection[0, 0].IsReal, "c1 real"); Assert.That(reflection[1, 1].IsReal, "c2 real"); Assert.That(reflection[2, 2].IsReal, "c3 real"); Assert.That(reflection[3, 3].IsReal, "c4 real"); - NumericAssert.AreAlmostEqual(v.Norm(), res[0].Modulus, 1e-12, "res(1)"); - NumericAssert.AreAlmostEqual(0, res[1], 1e-12, "res(2)"); - NumericAssert.AreAlmostEqual(0, res[2], 1e-12, "res(3)"); - NumericAssert.AreAlmostEqual(0, res[3], 1e-12, "res(4)"); + Assert.That(res[0].Modulus, NumericIs.AlmostEqualTo(v.Norm(), 1e-12), "res(1)"); + Assert.That(res[1], NumericIs.AlmostEqualTo((Complex) 0, 1e-12), "res(2)"); + Assert.That(res[2], NumericIs.AlmostEqualTo((Complex) 0, 1e-12), "res(3)"); + Assert.That(res[3], NumericIs.AlmostEqualTo((Complex) 0, 1e-12), "res(4)"); } } } diff --git a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/MatrixArithmeticsTest.cs b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/MatrixArithmeticsTest.cs index 48c0a02..c9a04a0 100644 --- a/src/test/MathNet.Iridium.Test/LinearAlgebraTests/MatrixArithmeticsTest.cs +++ b/src/test/MathNet.Iridium.Test/LinearAlgebraTests/MatrixArithmeticsTest.cs @@ -46,31 +46,27 @@ public class MatrixArithmeticsTest [SetUp] public void Setup() { - /* - MATLAB: - ma3x2 = [1 -2;-1 4;5 7] - mb3x2 = [10 2.5;-3 -1.5;19 -6] - mc2x2 = [1 2;3 4] - md2x4 = [1 2 -3 12;3 3.1 4 2] - */ - + // MATLAB: ma3x2 = [1 -2;-1 4;5 7] ma3x2 = new Matrix(new double[][] { new double[] { 1, -2 }, new double[] { -1, 4 }, new double[] { 5, 7 } }); + // MATLAB: mb3x2 = [10 2.5;-3 -1.5;19 -6] mb3x2 = new Matrix(new double[][] { new double[] { 10, 2.5 }, new double[] { -3, -1.5 }, new double[] { 19, -6 } }); + // MATLAB: mc2x2 = [1 2;3 4] mc2x2 = new Matrix(new double[][] { new double[] { 1, 2 }, new double[] { 3, 4 } }); + // MATLAB: md2x4 = [1 2 -3 12;3 3.1 4 2] md2x4 = new Matrix(new double[][] { new double[] { 1, 2, -3, 12 }, new double[] { 3, 3.1, 4, 2 } @@ -84,7 +80,10 @@ public void TestMatrix_Create() Matrix ma = Matrix.Create(a); double[][] b = { new double[] { 1.0, 2.0 }, new double[] { 2.0, 3.0 } }; Matrix mb = Matrix.Create(a); - Assert.That(ma.Equals(ma), "Matrices should be equal"); + + Assert.That(ma, Is.EqualTo(mb)); + Assert.That(ma.Equals(mb), Is.True); + Assert.That(ma.AlmostEquals(mb), Is.True); } [Test] @@ -98,7 +97,7 @@ public void TestMatrix_Transpose() new double[] { -2, 4, 7 } }); - NumericAssert.AreAlmostEqual(trans_m, Matrix.Transpose(ma3x2), "trans m 1"); + Assert.That(Matrix.Transpose(ma3x2), NumericIs.AlmostEqualTo(trans_m), "trans m 1"); Assert.That(Matrix.Transpose(ma3x2), Is.Not.SameAs(ma3x2)); Assert.That(Matrix.Transpose(ma3x2).GetArray(), Is.Not.SameAs(ma3x2.GetArray())); @@ -108,7 +107,7 @@ public void TestMatrix_Transpose() double[][] internalArray = trans_inplace.GetArray(); trans_inplace.TransposeInplace(); - NumericAssert.AreAlmostEqual(trans_m, trans_inplace, "trans m 2"); + Assert.That(trans_inplace, NumericIs.AlmostEqualTo(trans_m), "trans m 2"); // 2009-05-23: Note, this internal behavior might change in a future release: Assert.That(trans_inplace.GetArray(), Is.Not.SameAs(internalArray)); } @@ -129,10 +128,10 @@ public void TestMatrix_Additive() new double[] { 24, 1 } }); - NumericAssert.AreAlmostEqual(sum, ma3x2 + mb3x2, "sum 1"); + Assert.That(ma3x2 + mb3x2, NumericIs.AlmostEqualTo(sum), "sum 1"); Matrix sum_inplace = ma3x2.Clone(); sum_inplace.AddInplace(mb3x2); - NumericAssert.AreAlmostEqual(sum, sum_inplace, "sum 2"); + Assert.That(sum_inplace, NumericIs.AlmostEqualTo(sum), "sum 2"); Matrix diff = new Matrix(new double[][] { new double[] { -9, -4.5 }, @@ -140,10 +139,10 @@ public void TestMatrix_Additive() new double[] { -14, 13 } }); - NumericAssert.AreAlmostEqual(diff, ma3x2 - mb3x2, "diff 1"); + Assert.That(ma3x2 - mb3x2, NumericIs.AlmostEqualTo(diff), "diff 1"); Matrix diff_inplace = ma3x2.Clone(); diff_inplace.SubtractInplace(mb3x2); - NumericAssert.AreAlmostEqual(diff, diff_inplace, "diff 2"); + Assert.That(diff_inplace, NumericIs.AlmostEqualTo(diff), "diff 2"); Matrix neg_m = new Matrix(new double[][] { new double[] { -1, 2 }, @@ -151,7 +150,7 @@ public void TestMatrix_Additive() new double[] { -5, -7 } }); - NumericAssert.AreAlmostEqual(neg_m, -ma3x2, "neg 1"); + Assert.That(-ma3x2, NumericIs.AlmostEqualTo(neg_m), "neg 1"); } [Test] @@ -169,8 +168,8 @@ public void TestMatrix_Multiplicative() new double[] { 26, 31.7, 13, 74 } }); - NumericAssert.AreAlmostEqual(prod, ma3x2 * md2x4, "prod 1"); - NumericAssert.AreAlmostEqual(prod, ma3x2.Multiply(md2x4), "prod 2"); + Assert.That(ma3x2 * md2x4, NumericIs.AlmostEqualTo(prod), "prod 1"); + Assert.That(ma3x2.Multiply(md2x4), NumericIs.AlmostEqualTo(prod), "prod 2"); Matrix prod_s = new Matrix(new double[][] { new double[] { 2, -4 }, @@ -178,10 +177,10 @@ public void TestMatrix_Multiplicative() new double[] { 10, 14 } }); - NumericAssert.AreAlmostEqual(prod_s, ma3x2 * 2, "prod s 1"); + Assert.That(ma3x2 * 2, NumericIs.AlmostEqualTo(prod_s), "prod s 1"); Matrix prod_s_inplace = ma3x2.Clone(); prod_s_inplace.MultiplyInplace(2); - NumericAssert.AreAlmostEqual(prod_s, prod_s_inplace, "prod s 2"); + Assert.That(prod_s_inplace, NumericIs.AlmostEqualTo(prod_s), "prod s 2"); } [Test] @@ -216,15 +215,15 @@ public void TestMatrix_LUDecomposition() }); Vector P_mcv = new Vector(new double[] { 1, 0 }); - NumericAssert.AreAlmostEqual(L_mc, LU.L, "real LU L-matrix"); - NumericAssert.AreAlmostEqual(U_mc, LU.U, "real LU U-matrix"); - NumericAssert.AreAlmostEqual(P_mc, LU.PermutationMatrix, "real LU permutation matrix"); - NumericAssert.AreAlmostEqual(P_mcv, LU.PivotVector, "real LU pivot"); - NumericAssert.AreAlmostEqual(P_mcv, Array.ConvertAll(LU.Pivot, int2double), "real LU pivot II"); - NumericAssert.AreAlmostEqual(-2, LU.Determinant(), "real LU determinant"); - NumericAssert.AreAlmostEqual(-2, mc2x2.Determinant(), "real LU determinant II"); + Assert.That(LU.L, NumericIs.AlmostEqualTo(L_mc), "real LU L-matrix"); + Assert.That(LU.U, NumericIs.AlmostEqualTo(U_mc), "real LU U-matrix"); + Assert.That(LU.PermutationMatrix, NumericIs.AlmostEqualTo(P_mc), "real LU permutation matrix"); + Assert.That(LU.PivotVector, NumericIs.AlmostEqualTo(P_mcv), "real LU pivot"); + Assert.That((Vector) Array.ConvertAll(LU.Pivot, int2double), NumericIs.AlmostEqualTo(P_mcv), "real LU pivot II"); + Assert.That(LU.Determinant(), NumericIs.AlmostEqualTo((double) (-2)), "real LU determinant"); + Assert.That(mc2x2.Determinant(), NumericIs.AlmostEqualTo((double) (-2)), "real LU determinant II"); Assert.That(LU.IsNonSingular, "real LU non-singular"); - NumericAssert.AreAlmostEqual(LU.PermutationMatrix * mc2x2, LU.L * LU.U, "real LU product"); + Assert.That(LU.L * LU.U, NumericIs.AlmostEqualTo(LU.PermutationMatrix * mc2x2), "real LU product"); Matrix mc2x2h = Matrix.Transpose(mc2x2); LUDecomposition LUH = mc2x2h.LUDecomposition; @@ -244,15 +243,15 @@ public void TestMatrix_LUDecomposition() }); Vector P_mchv = new Vector(new double[] { 1, 0 }); - NumericAssert.AreAlmostEqual(L_mch, LUH.L, "real LU L-matrix (H)"); - NumericAssert.AreAlmostEqual(U_mch, LUH.U, "real LU U-matrix (H)"); - NumericAssert.AreAlmostEqual(P_mch, LUH.PermutationMatrix, "real LU permutation matrix (H)"); - NumericAssert.AreAlmostEqual(P_mchv, LUH.PivotVector, "real LU pivot (H)"); - NumericAssert.AreAlmostEqual(P_mchv, Array.ConvertAll(LUH.Pivot, int2double), "real LU pivot II (H)"); - NumericAssert.AreAlmostEqual(-2, LUH.Determinant(), "real LU determinant (H)"); - NumericAssert.AreAlmostEqual(-2, mc2x2h.Determinant(), "real LU determinant II (H)"); + Assert.That(LUH.L, NumericIs.AlmostEqualTo(L_mch), "real LU L-matrix (H)"); + Assert.That(LUH.U, NumericIs.AlmostEqualTo(U_mch), "real LU U-matrix (H)"); + Assert.That(LUH.PermutationMatrix, NumericIs.AlmostEqualTo(P_mch), "real LU permutation matrix (H)"); + Assert.That(LUH.PivotVector, NumericIs.AlmostEqualTo(P_mchv), "real LU pivot (H)"); + Assert.That((Vector) Array.ConvertAll(LUH.Pivot, int2double), NumericIs.AlmostEqualTo(P_mchv), "real LU pivot II (H)"); + Assert.That(LUH.Determinant(), NumericIs.AlmostEqualTo((double) (-2)), "real LU determinant (H)"); + Assert.That(mc2x2h.Determinant(), NumericIs.AlmostEqualTo((double) (-2)), "real LU determinant II (H)"); Assert.That(LUH.IsNonSingular, "real LU non-singular (H)"); - NumericAssert.AreAlmostEqual(LUH.PermutationMatrix * mc2x2h, LUH.L * LUH.U, "real LU product (H)"); + Assert.That(LUH.L * LUH.U, NumericIs.AlmostEqualTo(LUH.PermutationMatrix * mc2x2h), "real LU product (H)"); } [Test] @@ -289,12 +288,12 @@ public void TestMatrix_QRDecomposition() new double[] { 0.08012826184670, 0.07917266861796, 0.12309456479807, 0.01090084127596 } }); - NumericAssert.AreAlmostEqual(Q_mdh, QRH.Q, "real QR Q-matrix (H)"); - NumericAssert.AreAlmostEqual(R_mdh, QRH.R, "real QR R-matrix (H)"); - NumericAssert.AreAlmostEqual(md2x4h, QRH.Q * QRH.R, "real QR product (H)"); - NumericAssert.AreAlmostEqual(Matrix.Identity(2, 2), Matrix.Transpose(QRH.Q) * QRH.Q, "real QR QHQ=I (H)"); - NumericAssert.AreAlmostEqual(PInv_mdh, QRH.Solve(Matrix.Identity(4, 4)), 1e-13, "real QR Solve/Pseudoinverse (H)"); - NumericAssert.AreAlmostEqual(PInv_mdh, md2x4h.Inverse(), 1e-13, "real pseudoinverse (H)"); + Assert.That(QRH.Q, NumericIs.AlmostEqualTo(Q_mdh, 1e-14), "real QR Q-matrix (H)"); + Assert.That(QRH.R, NumericIs.AlmostEqualTo(R_mdh), "real QR R-matrix (H)"); + Assert.That(QRH.Q * QRH.R, NumericIs.AlmostEqualTo(md2x4h), "real QR product (H)"); + Assert.That(Matrix.Transpose(QRH.Q) * QRH.Q, NumericIs.AlmostEqualTo(Matrix.Identity(2, 2)), "real QR QHQ=I (H)"); + Assert.That(QRH.Solve(Matrix.Identity(4, 4)), NumericIs.AlmostEqualTo(PInv_mdh, 1e-13), "real QR Solve/Pseudoinverse (H)"); + Assert.That(md2x4h.Inverse(), NumericIs.AlmostEqualTo(PInv_mdh, 1e-13), "real pseudoinverse (H)"); QRDecomposition QR = md2x4.QRDecomposition; Matrix Q_md = new Matrix(new double[][] { @@ -314,16 +313,16 @@ public void TestMatrix_QRDecomposition() new double[] { 0.07448672256297, 0.01090084127596 } }); - NumericAssert.AreAlmostEqual(Q_md, QR.Q, "real QR Q-matrix"); - NumericAssert.AreAlmostEqual(R_md, QR.R, "real QR R-matrix"); - NumericAssert.AreAlmostEqual(md2x4, QR.Q * QR.R, "real QR product"); - NumericAssert.AreAlmostEqual(Matrix.Identity(2, 2), Matrix.Transpose(QR.Q) * QR.Q, "real QR QHQ=I"); + Assert.That(QR.Q, NumericIs.AlmostEqualTo(Q_md, 1e-14), "real QR Q-matrix"); + Assert.That(QR.R, NumericIs.AlmostEqualTo(R_md), "real QR R-matrix"); + Assert.That(QR.Q * QR.R, NumericIs.AlmostEqualTo(md2x4), "real QR product"); + Assert.That(Matrix.Transpose(QR.Q) * QR.Q, NumericIs.AlmostEqualTo(Matrix.Identity(2, 2)), "real QR QHQ=I"); /* NOTE: QR.Solve won't work yet (LQ would be required instead of QR). Hence check the matrix Solve instead, which is supposed to compute the transposed QR in this case. NumericAssert.AreAlmostEqual(PInv_md, md2x4.Solve(Matrix.Identity(2, 2)), 1e-13, "real QR Solve/Pseudoinverse"); */ - NumericAssert.AreAlmostEqual(PInv_md, md2x4.Inverse(), 1e-13, "real pseudoinverse"); + Assert.That(md2x4.Inverse(), NumericIs.AlmostEqualTo(PInv_md, 1e-13), "real pseudoinverse"); } [Test] diff --git a/src/test/MathNet.Iridium.Test/NumericAssert.cs b/src/test/MathNet.Iridium.Test/NumericAssert.cs deleted file mode 100644 index 36e77f7..0000000 --- a/src/test/MathNet.Iridium.Test/NumericAssert.cs +++ /dev/null @@ -1,116 +0,0 @@ -//----------------------------------------------------------------------- -// -// Copyright (c) 2002-2009, Christoph Rüegg. -// All Right Reserved. -// -// -// Christoph Rüegg, http://christoph.ruegg.name -// -// -// Math.NET Iridium, part of the Math.NET Project. -// http://mathnet.opensourcedotnet.info -// -// -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published -// by the Free Software Foundation; either version 2 of the License, or -// any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -// -//----------------------------------------------------------------------- - -using System; -using System.Collections.Generic; -using System.Text; - -using NUnit.Framework; -using NUnit.Framework.Constraints; - -using MathNet.Numerics; -using MathNet.Numerics.LinearAlgebra; - -namespace Iridium.Test -{ - public static class NumericAssert - { - public static void AreAlmostEqual(Matrix expected, Matrix actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForMatrix(10 * Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(Matrix expected, Matrix actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForMatrix(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(ComplexMatrix expected, ComplexMatrix actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplexMatrix(10 * Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(ComplexMatrix expected, ComplexMatrix actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplexMatrix(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(Vector expected, Vector actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForDouble(10 * Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(Vector expected, Vector actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForDouble(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(ComplexVector expected, ComplexVector actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplex(10 * Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(ComplexVector expected, ComplexVector actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplex(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(double expected, double actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForDouble(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(double expected, double actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForDouble(Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(Complex expected, Complex actual, double relativeAccuracy, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplex(relativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - - public static void AreAlmostEqual(Complex expected, Complex actual, string message) - { - IEqualityComparer comparer = EqualityComparers.ForComplex(Number.DefaultRelativeAccuracy); - Assert.That(actual, Is.EqualTo(expected).Using(comparer), message); - } - } -} diff --git a/src/test/MathNet.Iridium.Test/NumericIs.cs b/src/test/MathNet.Iridium.Test/NumericIs.cs new file mode 100644 index 0000000..df90466 --- /dev/null +++ b/src/test/MathNet.Iridium.Test/NumericIs.cs @@ -0,0 +1,152 @@ +//----------------------------------------------------------------------- +// +// Copyright (c) 2002-2009, Christoph Rüegg. +// All Right Reserved. +// +// +// Christoph Rüegg, http://christoph.ruegg.name +// +// +// Math.NET Iridium, part of the Math.NET Project. +// http://mathnet.opensourcedotnet.info +// +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published +// by the Free Software Foundation; either version 2 of the License, or +// any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// +//----------------------------------------------------------------------- + +using System; +using System.Collections.Generic; +using System.Text; + +using NUnit.Framework; +using NUnit.Framework.Constraints; + +using MathNet.Numerics; +using MathNet.Numerics.LinearAlgebra; + +namespace Iridium.Test +{ + /// + /// Custom NUnit Assertion Test Constraint Factory + /// + public class NumericIs + { + public static Constraint AlmostEqualTo(double expected) + { + return new AlmostEqualConstraint(expected); + } + + public static Constraint AlmostEqualTo(double expected, double maximumRelativeError) + { + return new AlmostEqualConstraint(expected, maximumRelativeError); + } + + public static Constraint AlmostEqualTo(T expected) + where T : IAlmostEquatable + { + return new AlmostEqualGenericConstraint(expected); + } + + public static Constraint AlmostEqualTo(T expected, double maximumRelativeError) + where T : IAlmostEquatable + { + return new AlmostEqualGenericConstraint(expected, maximumRelativeError); + } + + private class AlmostEqualConstraint : Constraint + { + private readonly double _expected; + private readonly double? _maximumRelativeError; + + public AlmostEqualConstraint(double expected) + : base(expected) + { + _expected = expected; + } + + public AlmostEqualConstraint(double expected, double maximumRelativeError) + : base(expected) + { + _expected = expected; + _maximumRelativeError = maximumRelativeError; + } + + public override bool Matches(object actual) + { + base.actual = actual; + + if(_maximumRelativeError.HasValue) + { + return Number.AlmostEqual(_expected, Convert.ToDouble(actual), _maximumRelativeError.Value); + } + + return Number.AlmostEqual(_expected, Convert.ToDouble(actual)); + } + + public override void WriteDescriptionTo(MessageWriter writer) + { + writer.WriteExpectedValue(_expected); + if(_maximumRelativeError.HasValue) + { + writer.WriteConnector("+/- relative"); + writer.WriteExpectedValue(_maximumRelativeError); + } + } + } + + private class AlmostEqualGenericConstraint : Constraint + where T : IAlmostEquatable + { + private readonly T _expected; + private readonly double? _maximumRelativeError; + + public AlmostEqualGenericConstraint(T expected) + : base(expected) + { + _expected = expected; + } + + public AlmostEqualGenericConstraint(T expected, double maximumRelativeError) + : base(expected) + { + _expected = expected; + _maximumRelativeError = maximumRelativeError; + } + + public override bool Matches(object actual) + { + base.actual = actual; + + if(_maximumRelativeError.HasValue) + { + return Number.AlmostEqual(_expected, (T)actual, _maximumRelativeError.Value); + } + + return Number.AlmostEqual(_expected, (T)actual); + } + + public override void WriteDescriptionTo(MessageWriter writer) + { + writer.WriteExpectedValue(_expected); + if(_maximumRelativeError.HasValue) + { + writer.WriteConnector("+/- relative"); + writer.WriteExpectedValue(_maximumRelativeError); + } + } + } + } +} diff --git a/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/ExcelStatisticsTests.cs b/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/ExcelStatisticsTests.cs index f4d29a7..8233e46 100644 --- a/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/ExcelStatisticsTests.cs +++ b/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/ExcelStatisticsTests.cs @@ -56,19 +56,19 @@ public class ExcelStatisticsTests [Test] public void TestTDIST() { - NumericAssert.AreAlmostEqual(5.000000000000000E-01, TDIST(0, 2, 1), 1e-8, "A1"); - NumericAssert.AreAlmostEqual(4.129611720298140E-01, TDIST(0.25, 2, 1), 1e-8, "B1"); - NumericAssert.AreAlmostEqual(3.333333333480060E-01, TDIST(0.5, 2, 1), 1e-8, "C1"); - NumericAssert.AreAlmostEqual(2.113248654306010E-01, TDIST(1, 2, 1), 1e-8, "D1"); - NumericAssert.AreAlmostEqual(9.175170951687770E-02, TDIST(2, 2, 1), 1e-8, "E1"); - NumericAssert.AreAlmostEqual(4.926228511229080E-03, TDIST(10, 2, 1), 1e-8, "F1"); + Assert.That(TDIST(0, 2, 1), NumericIs.AlmostEqualTo(5.000000000000000E-01, 1e-8), "A1"); + Assert.That(TDIST(0.25, 2, 1), NumericIs.AlmostEqualTo(4.129611720298140E-01, 1e-8), "B1"); + Assert.That(TDIST(0.5, 2, 1), NumericIs.AlmostEqualTo(3.333333333480060E-01, 1e-8), "C1"); + Assert.That(TDIST(1, 2, 1), NumericIs.AlmostEqualTo(2.113248654306010E-01, 1e-8), "D1"); + Assert.That(TDIST(2, 2, 1), NumericIs.AlmostEqualTo(9.175170951687770E-02, 1e-8), "E1"); + Assert.That(TDIST(10, 2, 1), NumericIs.AlmostEqualTo(4.926228511229080E-03, 1e-8), "F1"); - NumericAssert.AreAlmostEqual(1.000000000000000E+00, TDIST(0, 2, 2), 1e-8, "A2"); - NumericAssert.AreAlmostEqual(8.259223440596280E-01, TDIST(0.25, 2, 2), 1e-8, "B2"); - NumericAssert.AreAlmostEqual(6.666666666960120E-01, TDIST(0.5, 2, 2), 1e-8, "C2"); - NumericAssert.AreAlmostEqual(4.226497308612030E-01, TDIST(1, 2, 2), 1e-8, "D2"); - NumericAssert.AreAlmostEqual(1.835034190337550E-01, TDIST(2, 2, 2), 1e-8, "E2"); - NumericAssert.AreAlmostEqual(9.852457022458160E-03, TDIST(10, 2, 2), 1e-8, "F2"); + Assert.That(TDIST(0, 2, 2), NumericIs.AlmostEqualTo(1.000000000000000E+00, 1e-8), "A2"); + Assert.That(TDIST(0.25, 2, 2), NumericIs.AlmostEqualTo(8.259223440596280E-01, 1e-8), "B2"); + Assert.That(TDIST(0.5, 2, 2), NumericIs.AlmostEqualTo(6.666666666960120E-01, 1e-8), "C2"); + Assert.That(TDIST(1, 2, 2), NumericIs.AlmostEqualTo(4.226497308612030E-01, 1e-8), "D2"); + Assert.That(TDIST(2, 2, 2), NumericIs.AlmostEqualTo(1.835034190337550E-01, 1e-8), "E2"); + Assert.That(TDIST(10, 2, 2), NumericIs.AlmostEqualTo(9.852457022458160E-03, 1e-8), "F2"); } double GAMMADIST(double x, double alpha, double beta, bool cumulative) @@ -83,19 +83,19 @@ public void TestTDIST() [Test] public void TestGAMMADIST() { - NumericAssert.AreAlmostEqual(0.000000000000000E+00, GAMMADIST(0, 2, 1.5, true), 1e-8, "A1"); - NumericAssert.AreAlmostEqual(1.243798761594900E-02, GAMMADIST(0.25, 2, 1.5, true), 1e-8, "B1"); - NumericAssert.AreAlmostEqual(4.462491913500840E-02, GAMMADIST(0.5, 2, 1.5, true), 1e-8, "C1"); - NumericAssert.AreAlmostEqual(1.443047990137690E-01, GAMMADIST(1, 2, 1.5, true), 1e-6, "D1"); - NumericAssert.AreAlmostEqual(3.849400091283540E-01, GAMMADIST(2, 2, 1.5, true), 1e-8, "E1"); - NumericAssert.AreAlmostEqual(9.902431408555580E-01, GAMMADIST(10, 2, 1.5, true), 1e-8, "F1"); + Assert.That(GAMMADIST(0, 2, 1.5, true), NumericIs.AlmostEqualTo(0.000000000000000E+00, 1e-8), "A1"); + Assert.That(GAMMADIST(0.25, 2, 1.5, true), NumericIs.AlmostEqualTo(1.243798761594900E-02, 1e-8), "B1"); + Assert.That(GAMMADIST(0.5, 2, 1.5, true), NumericIs.AlmostEqualTo(4.462491913500840E-02, 1e-8), "C1"); + Assert.That(GAMMADIST(1, 2, 1.5, true), NumericIs.AlmostEqualTo(1.443047990137690E-01, 1e-6), "D1"); + Assert.That(GAMMADIST(2, 2, 1.5, true), NumericIs.AlmostEqualTo(3.849400091283540E-01, 1e-8), "E1"); + Assert.That(GAMMADIST(10, 2, 1.5, true), NumericIs.AlmostEqualTo(9.902431408555580E-01, 1e-8), "F1"); - NumericAssert.AreAlmostEqual(0.000000000000000E+00, GAMMADIST(0, 2, 1.5, false), 1e-8, "A2"); - NumericAssert.AreAlmostEqual(9.405352499591280E-02, GAMMADIST(0.25, 2, 1.5, false), 1e-8, "B2"); - NumericAssert.AreAlmostEqual(1.592291801411650E-01, GAMMADIST(0.5, 2, 1.5, false), 1e-8, "C2"); - NumericAssert.AreAlmostEqual(2.281853862562790E-01, GAMMADIST(1, 2, 1.5, false), 1e-8, "D2"); - NumericAssert.AreAlmostEqual(2.343085672340750E-01, GAMMADIST(2, 2, 1.5, false), 1e-8, "E2"); - NumericAssert.AreAlmostEqual(5.656150228662040E-03, GAMMADIST(10, 2, 1.5, false), 1e-8, "F2"); + Assert.That(GAMMADIST(0, 2, 1.5, false), NumericIs.AlmostEqualTo(0.000000000000000E+00, 1e-8), "A2"); + Assert.That(GAMMADIST(0.25, 2, 1.5, false), NumericIs.AlmostEqualTo(9.405352499591280E-02, 1e-8), "B2"); + Assert.That(GAMMADIST(0.5, 2, 1.5, false), NumericIs.AlmostEqualTo(1.592291801411650E-01, 1e-8), "C2"); + Assert.That(GAMMADIST(1, 2, 1.5, false), NumericIs.AlmostEqualTo(2.281853862562790E-01, 1e-8), "D2"); + Assert.That(GAMMADIST(2, 2, 1.5, false), NumericIs.AlmostEqualTo(2.343085672340750E-01, 1e-8), "E2"); + Assert.That(GAMMADIST(10, 2, 1.5, false), NumericIs.AlmostEqualTo(5.656150228662040E-03, 1e-8), "F2"); } double GAMMAINV(double x, double alpha, double beta) @@ -107,13 +107,13 @@ public void TestGAMMADIST() [Test] public void TestGAMMAINV() { - NumericAssert.AreAlmostEqual(0.000000000000000E+00, GAMMAINV(0, 2, 1.5), 1e-8, "A1"); - NumericAssert.AreAlmostEqual(2.228321104302450E-01, GAMMAINV(0.01, 2, 1.5), 1e-8, "B1"); - NumericAssert.AreAlmostEqual(1.441918172091760E+00, GAMMAINV(0.25, 2, 1.5), 1e-6, "C1"); - NumericAssert.AreAlmostEqual(2.517520501047540E+00, GAMMAINV(0.5, 2, 1.5), 1e-8, "D1"); - NumericAssert.AreAlmostEqual(4.038951793510970E+00, GAMMAINV(0.75, 2, 1.5), 1e-8, "E1"); - NumericAssert.AreAlmostEqual(9.957528102138740E+00, GAMMAINV(0.99, 2, 1.5), 1e-8, "F1"); - NumericAssert.AreAlmostEqual(1.763455683388200E+01, GAMMAINV(0.9999, 2, 1.5), 1e-8, "G1"); + Assert.That(GAMMAINV(0, 2, 1.5), NumericIs.AlmostEqualTo(0.000000000000000E+00, 1e-8), "A1"); + Assert.That(GAMMAINV(0.01, 2, 1.5), NumericIs.AlmostEqualTo(2.228321104302450E-01, 1e-8), "B1"); + Assert.That(GAMMAINV(0.25, 2, 1.5), NumericIs.AlmostEqualTo(1.441918172091760E+00, 1e-6), "C1"); + Assert.That(GAMMAINV(0.5, 2, 1.5), NumericIs.AlmostEqualTo(2.517520501047540E+00, 1e-8), "D1"); + Assert.That(GAMMAINV(0.75, 2, 1.5), NumericIs.AlmostEqualTo(4.038951793510970E+00, 1e-8), "E1"); + Assert.That(GAMMAINV(0.99, 2, 1.5), NumericIs.AlmostEqualTo(9.957528102138740E+00, 1e-8), "F1"); + Assert.That(GAMMAINV(0.9999, 2, 1.5), NumericIs.AlmostEqualTo(1.763455683388200E+01, 1e-8), "G1"); } } } diff --git a/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/SpecialFunctionsTest.cs b/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/SpecialFunctionsTest.cs index 973ded5..9657076 100644 --- a/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/SpecialFunctionsTest.cs +++ b/src/test/MathNet.Iridium.Test/SpecialFunctionsTests/SpecialFunctionsTest.cs @@ -162,11 +162,11 @@ public void TestSpecialFunctions_LcmList() public void TestSpecialFunctions_GammaLn_SpecialPoints() { // becomes negative in 1..2 - NumericAssert.AreAlmostEqual(0.0, Fn.GammaLn(1), "A1"); - NumericAssert.AreAlmostEqual(0.0, Fn.GammaLn(2), "A2"); - NumericAssert.AreAlmostEqual(-.1214862905, Fn.GammaLn(1.461632145), 1e-9, "A3"); - NumericAssert.AreAlmostEqual(-0.08537409000331584971970284, Fn.GammaLn(1.2), "A4"); - NumericAssert.AreAlmostEqual(-0.07108387291437216698800249, Fn.GammaLn(1.8), "A5"); + Assert.That(Fn.GammaLn(1), NumericIs.AlmostEqualTo(0.0), "A1"); + Assert.That(Fn.GammaLn(2), NumericIs.AlmostEqualTo(0.0), "A2"); + Assert.That(Fn.GammaLn(1.461632145), NumericIs.AlmostEqualTo(-.1214862905, 1e-9), "A3"); + Assert.That(Fn.GammaLn(1.2), NumericIs.AlmostEqualTo(-0.08537409000331584971970284), "A4"); + Assert.That(Fn.GammaLn(1.8), NumericIs.AlmostEqualTo(-0.07108387291437216698800249), "A5"); // positive infinity at non-positive integers Assert.That(Fn.GammaLn(0.0), Is.EqualTo(double.PositiveInfinity), "A6"); @@ -179,144 +179,144 @@ public void TestSpecialFunctions_GammaLn_SpecialPoints() Assert.That(Fn.GammaLn(-100000), Is.EqualTo(double.PositiveInfinity), "A13"); // continuous at branch points - NumericAssert.AreAlmostEqual(Fn.GammaLn(13), Fn.GammaLn(Number.Increment(13)), "13+"); - NumericAssert.AreAlmostEqual(Fn.GammaLn(13), Fn.GammaLn(Number.Decrement(13)), "13-"); - NumericAssert.AreAlmostEqual(Fn.GammaLn(34), Fn.GammaLn(Number.Increment(34)), "34+"); - NumericAssert.AreAlmostEqual(Fn.GammaLn(34), Fn.GammaLn(Number.Decrement(34)), "34-"); + Assert.That(Fn.GammaLn(Number.Increment(13)), NumericIs.AlmostEqualTo(Fn.GammaLn(13)), "13+"); + Assert.That(Fn.GammaLn(Number.Decrement(13)), NumericIs.AlmostEqualTo(Fn.GammaLn(13)), "13-"); + Assert.That(Fn.GammaLn(Number.Increment(34)), NumericIs.AlmostEqualTo(Fn.GammaLn(34)), "34+"); + Assert.That(Fn.GammaLn(Number.Decrement(34)), NumericIs.AlmostEqualTo(Fn.GammaLn(34)), "34-"); } [Test] public void TestSpecialFunctions_GammaLn_PositiveNumbers() { // Small Positive Numbers - NumericAssert.AreAlmostEqual(2.252712651734205959869702, Fn.GammaLn(1e-1), "A1"); - NumericAssert.AreAlmostEqual(4.599479878042021722513945, Fn.GammaLn(1e-2), "A2"); - NumericAssert.AreAlmostEqual(6.907178885383853682512345, Fn.GammaLn(1e-3), "A3"); - NumericAssert.AreAlmostEqual(9.210282658633962258448658, Fn.GammaLn(1e-4), "A4"); - NumericAssert.AreAlmostEqual(11.51291969289582570742083, Fn.GammaLn(1e-5), "A5"); - NumericAssert.AreAlmostEqual(13.81550998074943166920783, Fn.GammaLn(1e-6), "A6"); - NumericAssert.AreAlmostEqual(16.11809559323676152264259, Fn.GammaLn(1e-7), "A7"); - NumericAssert.AreAlmostEqual(18.42068073818020890537531, Fn.GammaLn(1e-8), "A8"); - NumericAssert.AreAlmostEqual(23.02585092988273527369799, Fn.GammaLn(1e-10), "A10"); - NumericAssert.AreAlmostEqual(34.53877639491068468305421, Fn.GammaLn(1e-15), "A15"); - NumericAssert.AreAlmostEqual(46.05170185988091368035406, Fn.GammaLn(1e-20), "A20"); - NumericAssert.AreAlmostEqual(115.1292546497022842008996, Fn.GammaLn(1e-50), "A50"); - NumericAssert.AreAlmostEqual(230.2585092994045684017991, Fn.GammaLn(1e-100), "A100"); - NumericAssert.AreAlmostEqual(345.3877639491068526026987, Fn.GammaLn(1e-150), "A150"); - NumericAssert.AreAlmostEqual(460.5170185988091368035983, Fn.GammaLn(1e-200), "A200"); - NumericAssert.AreAlmostEqual(690.7755278982137052053974, Fn.GammaLn(1e-300), "A300"); - - NumericAssert.AreAlmostEqual(2.252702228029981864727227, Fn.GammaLn(1.00001e-1), "B1"); - NumericAssert.AreAlmostEqual(4.599469822003483708382914, Fn.GammaLn(1.00001e-2), "B2"); - NumericAssert.AreAlmostEqual(6.907168879678134113205166, Fn.GammaLn(1.00001e-3), "B3"); - NumericAssert.AreAlmostEqual(11.51290969288810545253012, Fn.GammaLn(1.00001e-5), "B5"); - NumericAssert.AreAlmostEqual(23.02584092993273436315149, Fn.GammaLn(1.00001e-10), "B10"); - NumericAssert.AreAlmostEqual(46.05169185993091334702322, Fn.GammaLn(1.00001e-20), "B20"); - NumericAssert.AreAlmostEqual(230.2584992994545680684683, Fn.GammaLn(1.00001e-100), "B100"); - NumericAssert.AreAlmostEqual(690.7755178982637048720666, Fn.GammaLn(1.00001e-300), "B300"); - - NumericAssert.AreAlmostEqual(1.978272496331759309624239, Fn.GammaLn(1.3e-1), "C1"); - NumericAssert.AreAlmostEqual(4.335440242151057465250438, Fn.GammaLn(1.3e-2), "C2"); - NumericAssert.AreAlmostEqual(6.644642023240026191960253, Fn.GammaLn(1.3e-3), "C3"); - NumericAssert.AreAlmostEqual(11.25055369683808969647734, Fn.GammaLn(1.3e-5), "C5"); - NumericAssert.AreAlmostEqual(22.76348666539792775172112, Fn.GammaLn(1.3e-10), "C10"); - NumericAssert.AreAlmostEqual(45.78933759541342262831683, Fn.GammaLn(1.3e-20), "C20"); - NumericAssert.AreAlmostEqual(229.9961450349370773497636, Fn.GammaLn(1.3e-100), "C100"); - NumericAssert.AreAlmostEqual(690.5131636337462141533619, Fn.GammaLn(1.3e-300), "C300"); + Assert.That(Fn.GammaLn(1e-1), NumericIs.AlmostEqualTo(2.252712651734205959869702), "A1"); + Assert.That(Fn.GammaLn(1e-2), NumericIs.AlmostEqualTo(4.599479878042021722513945), "A2"); + Assert.That(Fn.GammaLn(1e-3), NumericIs.AlmostEqualTo(6.907178885383853682512345), "A3"); + Assert.That(Fn.GammaLn(1e-4), NumericIs.AlmostEqualTo(9.210282658633962258448658), "A4"); + Assert.That(Fn.GammaLn(1e-5), NumericIs.AlmostEqualTo(11.51291969289582570742083), "A5"); + Assert.That(Fn.GammaLn(1e-6), NumericIs.AlmostEqualTo(13.81550998074943166920783), "A6"); + Assert.That(Fn.GammaLn(1e-7), NumericIs.AlmostEqualTo(16.11809559323676152264259), "A7"); + Assert.That(Fn.GammaLn(1e-8), NumericIs.AlmostEqualTo(18.42068073818020890537531), "A8"); + Assert.That(Fn.GammaLn(1e-10), NumericIs.AlmostEqualTo(23.02585092988273527369799), "A10"); + Assert.That(Fn.GammaLn(1e-15), NumericIs.AlmostEqualTo(34.53877639491068468305421), "A15"); + Assert.That(Fn.GammaLn(1e-20), NumericIs.AlmostEqualTo(46.05170185988091368035406), "A20"); + Assert.That(Fn.GammaLn(1e-50), NumericIs.AlmostEqualTo(115.1292546497022842008996), "A50"); + Assert.That(Fn.GammaLn(1e-100), NumericIs.AlmostEqualTo(230.2585092994045684017991), "A100"); + Assert.That(Fn.GammaLn(1e-150), NumericIs.AlmostEqualTo(345.3877639491068526026987), "A150"); + Assert.That(Fn.GammaLn(1e-200), NumericIs.AlmostEqualTo(460.5170185988091368035983), "A200"); + Assert.That(Fn.GammaLn(1e-300), NumericIs.AlmostEqualTo(690.7755278982137052053974), "A300"); + + Assert.That(Fn.GammaLn(1.00001e-1), NumericIs.AlmostEqualTo(2.252702228029981864727227), "B1"); + Assert.That(Fn.GammaLn(1.00001e-2), NumericIs.AlmostEqualTo(4.599469822003483708382914), "B2"); + Assert.That(Fn.GammaLn(1.00001e-3), NumericIs.AlmostEqualTo(6.907168879678134113205166), "B3"); + Assert.That(Fn.GammaLn(1.00001e-5), NumericIs.AlmostEqualTo(11.51290969288810545253012), "B5"); + Assert.That(Fn.GammaLn(1.00001e-10), NumericIs.AlmostEqualTo(23.02584092993273436315149), "B10"); + Assert.That(Fn.GammaLn(1.00001e-20), NumericIs.AlmostEqualTo(46.05169185993091334702322), "B20"); + Assert.That(Fn.GammaLn(1.00001e-100), NumericIs.AlmostEqualTo(230.2584992994545680684683), "B100"); + Assert.That(Fn.GammaLn(1.00001e-300), NumericIs.AlmostEqualTo(690.7755178982637048720666), "B300"); + + Assert.That(Fn.GammaLn(1.3e-1), NumericIs.AlmostEqualTo(1.978272496331759309624239), "C1"); + Assert.That(Fn.GammaLn(1.3e-2), NumericIs.AlmostEqualTo(4.335440242151057465250438), "C2"); + Assert.That(Fn.GammaLn(1.3e-3), NumericIs.AlmostEqualTo(6.644642023240026191960253), "C3"); + Assert.That(Fn.GammaLn(1.3e-5), NumericIs.AlmostEqualTo(11.25055369683808969647734), "C5"); + Assert.That(Fn.GammaLn(1.3e-10), NumericIs.AlmostEqualTo(22.76348666539792775172112), "C10"); + Assert.That(Fn.GammaLn(1.3e-20), NumericIs.AlmostEqualTo(45.78933759541342262831683), "C20"); + Assert.That(Fn.GammaLn(1.3e-100), NumericIs.AlmostEqualTo(229.9961450349370773497636), "C100"); + Assert.That(Fn.GammaLn(1.3e-300), NumericIs.AlmostEqualTo(690.5131636337462141533619), "C300"); // Large Positive Numbers - NumericAssert.AreAlmostEqual(12.80182748008146961120772, Fn.GammaLn(1e+1), "D1"); - NumericAssert.AreAlmostEqual(359.1342053695753987760440, Fn.GammaLn(1e+2), "D2"); - NumericAssert.AreAlmostEqual(5905.220423209181211826077, Fn.GammaLn(1e+3), "D3"); - NumericAssert.AreAlmostEqual(82099.71749644237727264896, Fn.GammaLn(1e+4), "D4"); - NumericAssert.AreAlmostEqual(1.051287708973656894900858e+6, Fn.GammaLn(1e+5), "D5"); - NumericAssert.AreAlmostEqual(1.281550456914761165997697e+7, Fn.GammaLn(1e+6), "D6"); - NumericAssert.AreAlmostEqual(1.511809493694739139401056e+8, Fn.GammaLn(1e+7), "D7"); - NumericAssert.AreAlmostEqual(1.742068066103834709276216e+9, Fn.GammaLn(1e+8), "D8"); - NumericAssert.AreAlmostEqual(2.202585092888105814700419e+11, Fn.GammaLn(1e+10), "D10"); - NumericAssert.AreAlmostEqual(3.353877639491066890982021e+16, Fn.GammaLn(1e+15), "D15"); - NumericAssert.AreAlmostEqual(4.505170185988091368013876e+21, Fn.GammaLn(1e+20), "D20"); - NumericAssert.AreAlmostEqual(1.141292546497022842008996e+52, Fn.GammaLn(1e+50), "D50"); - NumericAssert.AreAlmostEqual(2.292585092994045684017991e+102, Fn.GammaLn(1e+100), "D100"); - NumericAssert.AreAlmostEqual(3.443877639491068526026987e+152, Fn.GammaLn(1e+150), "D150"); - NumericAssert.AreAlmostEqual(4.595170185988091368035983e+202, Fn.GammaLn(1e+200), "D200"); - NumericAssert.AreAlmostEqual(6.897755278982137052053974e+302, Fn.GammaLn(1e+300), "D300"); - - NumericAssert.AreAlmostEqual(12.80205265586620612009742, Fn.GammaLn(1.00001e+1), "E1"); - NumericAssert.AreAlmostEqual(359.1388055364532033610289, Fn.GammaLn(1.00001e+2), "E2"); - NumericAssert.AreAlmostEqual(5905.289495811162541447347, Fn.GammaLn(1.00001e+3), "E3"); - NumericAssert.AreAlmostEqual(1.051299221899121865129278e+6, Fn.GammaLn(1.00001e+5), "E5"); - NumericAssert.AreAlmostEqual(2.202608118744035688490926e+11, Fn.GammaLn(1.00001e+10), "E10"); - NumericAssert.AreAlmostEqual(4.505216237694951232260973e+21, Fn.GammaLn(1.00001e+20), "E20"); - NumericAssert.AreAlmostEqual(2.292608118845475622808173e+102, Fn.GammaLn(1.00001e+100), "E100"); - NumericAssert.AreAlmostEqual(6.897824356535426871757837e+302, Fn.GammaLn(1.00001e+300), "E300"); - - NumericAssert.AreAlmostEqual(19.98721449566188614951736, Fn.GammaLn(1.3e+1), "E1"); - NumericAssert.AreAlmostEqual(501.2652908915792927796609, Fn.GammaLn(1.3e+2), "E2"); - NumericAssert.AreAlmostEqual(8018.489349348559232219987, Fn.GammaLn(1.3e+3), "E3"); - NumericAssert.AreAlmostEqual(1.400782696121213042830339e+6, Fn.GammaLn(1.3e+5), "E5"); - NumericAssert.AreAlmostEqual(2.897467975165781535348074e+11, Fn.GammaLn(1.3e+10), "E10"); - NumericAssert.AreAlmostEqual(5.890828596165292615189154e+21, Fn.GammaLn(1.3e+20), "E20"); - NumericAssert.AreAlmostEqual(2.983771356330336772899850e+102, Fn.GammaLn(1.3e+100), "E100"); - NumericAssert.AreAlmostEqual(8.970492598114855551346628e+302, Fn.GammaLn(1.3e+300), "E300"); + Assert.That(Fn.GammaLn(1e+1), NumericIs.AlmostEqualTo(12.80182748008146961120772), "D1"); + Assert.That(Fn.GammaLn(1e+2), NumericIs.AlmostEqualTo(359.1342053695753987760440), "D2"); + Assert.That(Fn.GammaLn(1e+3), NumericIs.AlmostEqualTo(5905.220423209181211826077), "D3"); + Assert.That(Fn.GammaLn(1e+4), NumericIs.AlmostEqualTo(82099.71749644237727264896), "D4"); + Assert.That(Fn.GammaLn(1e+5), NumericIs.AlmostEqualTo(1.051287708973656894900858e+6), "D5"); + Assert.That(Fn.GammaLn(1e+6), NumericIs.AlmostEqualTo(1.281550456914761165997697e+7), "D6"); + Assert.That(Fn.GammaLn(1e+7), NumericIs.AlmostEqualTo(1.511809493694739139401056e+8), "D7"); + Assert.That(Fn.GammaLn(1e+8), NumericIs.AlmostEqualTo(1.742068066103834709276216e+9), "D8"); + Assert.That(Fn.GammaLn(1e+10), NumericIs.AlmostEqualTo(2.202585092888105814700419e+11), "D10"); + Assert.That(Fn.GammaLn(1e+15), NumericIs.AlmostEqualTo(3.353877639491066890982021e+16), "D15"); + Assert.That(Fn.GammaLn(1e+20), NumericIs.AlmostEqualTo(4.505170185988091368013876e+21), "D20"); + Assert.That(Fn.GammaLn(1e+50), NumericIs.AlmostEqualTo(1.141292546497022842008996e+52), "D50"); + Assert.That(Fn.GammaLn(1e+100), NumericIs.AlmostEqualTo(2.292585092994045684017991e+102), "D100"); + Assert.That(Fn.GammaLn(1e+150), NumericIs.AlmostEqualTo(3.443877639491068526026987e+152), "D150"); + Assert.That(Fn.GammaLn(1e+200), NumericIs.AlmostEqualTo(4.595170185988091368035983e+202), "D200"); + Assert.That(Fn.GammaLn(1e+300), NumericIs.AlmostEqualTo(6.897755278982137052053974e+302), "D300"); + + Assert.That(Fn.GammaLn(1.00001e+1), NumericIs.AlmostEqualTo(12.80205265586620612009742), "E1"); + Assert.That(Fn.GammaLn(1.00001e+2), NumericIs.AlmostEqualTo(359.1388055364532033610289), "E2"); + Assert.That(Fn.GammaLn(1.00001e+3), NumericIs.AlmostEqualTo(5905.289495811162541447347), "E3"); + Assert.That(Fn.GammaLn(1.00001e+5), NumericIs.AlmostEqualTo(1.051299221899121865129278e+6), "E5"); + Assert.That(Fn.GammaLn(1.00001e+10), NumericIs.AlmostEqualTo(2.202608118744035688490926e+11), "E10"); + Assert.That(Fn.GammaLn(1.00001e+20), NumericIs.AlmostEqualTo(4.505216237694951232260973e+21), "E20"); + Assert.That(Fn.GammaLn(1.00001e+100), NumericIs.AlmostEqualTo(2.292608118845475622808173e+102), "E100"); + Assert.That(Fn.GammaLn(1.00001e+300), NumericIs.AlmostEqualTo(6.897824356535426871757837e+302), "E300"); + + Assert.That(Fn.GammaLn(1.3e+1), NumericIs.AlmostEqualTo(19.98721449566188614951736), "E1"); + Assert.That(Fn.GammaLn(1.3e+2), NumericIs.AlmostEqualTo(501.2652908915792927796609), "E2"); + Assert.That(Fn.GammaLn(1.3e+3), NumericIs.AlmostEqualTo(8018.489349348559232219987), "E3"); + Assert.That(Fn.GammaLn(1.3e+5), NumericIs.AlmostEqualTo(1.400782696121213042830339e+6), "E5"); + Assert.That(Fn.GammaLn(1.3e+10), NumericIs.AlmostEqualTo(2.897467975165781535348074e+11), "E10"); + Assert.That(Fn.GammaLn(1.3e+20), NumericIs.AlmostEqualTo(5.890828596165292615189154e+21), "E20"); + Assert.That(Fn.GammaLn(1.3e+100), NumericIs.AlmostEqualTo(2.983771356330336772899850e+102), "E100"); + Assert.That(Fn.GammaLn(1.3e+300), NumericIs.AlmostEqualTo(8.970492598114855551346628e+302), "E300"); } [Test] public void TestSpecialFunctions_GammaLn_NegativeNumbers() { // Small Negative Numbers - NumericAssert.AreAlmostEqual(2.368961332728788655206708, Fn.GammaLn(-1e-1), "A1"); - NumericAssert.AreAlmostEqual(4.611024992752801144215290, Fn.GammaLn(-1e-2), "A2"); - NumericAssert.AreAlmostEqual(6.908333317515028431778011, Fn.GammaLn(-1e-3), "A3"); - NumericAssert.AreAlmostEqual(9.210398101767743936293700, Fn.GammaLn(-1e-4), "A4"); - NumericAssert.AreAlmostEqual(11.51293123720912453944932, Fn.GammaLn(-1e-5), "A5"); - NumericAssert.AreAlmostEqual(13.81551113518076147307492, Fn.GammaLn(-1e-6), "A6"); - NumericAssert.AreAlmostEqual(16.11809570867989450294996, Fn.GammaLn(-1e-7), "A7"); - NumericAssert.AreAlmostEqual(18.42068074972452220340596, Fn.GammaLn(-1e-8), "A8"); - NumericAssert.AreAlmostEqual(23.02585092999817840667829, Fn.GammaLn(-1e-10), "A10"); - NumericAssert.AreAlmostEqual(34.53877639491068583748554, Fn.GammaLn(-1e-15), "A15"); - NumericAssert.AreAlmostEqual(46.05170185988091368036560, Fn.GammaLn(-1e-20), "A20"); - NumericAssert.AreAlmostEqual(115.1292546497022842008996, Fn.GammaLn(-1e-50), "A50"); - NumericAssert.AreAlmostEqual(230.2585092994045684017991, Fn.GammaLn(-1e-100), "A100"); - NumericAssert.AreAlmostEqual(345.3877639491068526026987, Fn.GammaLn(-1e-150), "A150"); - NumericAssert.AreAlmostEqual(460.5170185988091368035983, Fn.GammaLn(-1e-200), "A200"); - NumericAssert.AreAlmostEqual(690.7755278982137052053974, Fn.GammaLn(-1e-300), "A300"); - - NumericAssert.AreAlmostEqual(2.368952087706699539440639, Fn.GammaLn(-1.00001e-1), "B1"); - NumericAssert.AreAlmostEqual(4.611015052181439562964888, Fn.GammaLn(-1.00001e-2), "B2"); - NumericAssert.AreAlmostEqual(6.908323323353646201900704, Fn.GammaLn(-1.00001e-3), "B3"); - NumericAssert.AreAlmostEqual(11.51292123731684741756295, Fn.GammaLn(-1.00001e-5), "B5"); - NumericAssert.AreAlmostEqual(23.02584093004817865056312, Fn.GammaLn(-1.00001e-10), "B10"); - NumericAssert.AreAlmostEqual(46.05169185993091334703477, Fn.GammaLn(-1.00001e-20), "B20"); - NumericAssert.AreAlmostEqual(230.2584992994545680684683, Fn.GammaLn(-1.00001e-100), "B100"); - NumericAssert.AreAlmostEqual(690.7755178982637048720666, Fn.GammaLn(-1.00001e-300), "B300"); - - NumericAssert.AreAlmostEqual(2.130124765217041905198028, Fn.GammaLn(-1.3e-1), "C1"); - NumericAssert.AreAlmostEqual(4.350449610205194501037890, Fn.GammaLn(-1.3e-2), "C2"); - NumericAssert.AreAlmostEqual(6.646142785729384394910125, Fn.GammaLn(-1.3e-3), "C3"); - NumericAssert.AreAlmostEqual(11.25056870444537889694439, Fn.GammaLn(-1.3e-5), "C5"); - NumericAssert.AreAlmostEqual(22.76348666554800382459552, Fn.GammaLn(-1.3e-10), "C10"); - NumericAssert.AreAlmostEqual(45.78933759541342262833184, Fn.GammaLn(-1.3e-20), "C20"); - NumericAssert.AreAlmostEqual(229.9961450349370773497636, Fn.GammaLn(-1.3e-100), "C100"); - NumericAssert.AreAlmostEqual(690.5131636337462141533619, Fn.GammaLn(-1.3e-300), "C300"); + Assert.That(Fn.GammaLn(-1e-1), NumericIs.AlmostEqualTo(2.368961332728788655206708), "A1"); + Assert.That(Fn.GammaLn(-1e-2), NumericIs.AlmostEqualTo(4.611024992752801144215290), "A2"); + Assert.That(Fn.GammaLn(-1e-3), NumericIs.AlmostEqualTo(6.908333317515028431778011), "A3"); + Assert.That(Fn.GammaLn(-1e-4), NumericIs.AlmostEqualTo(9.210398101767743936293700), "A4"); + Assert.That(Fn.GammaLn(-1e-5), NumericIs.AlmostEqualTo(11.51293123720912453944932), "A5"); + Assert.That(Fn.GammaLn(-1e-6), NumericIs.AlmostEqualTo(13.81551113518076147307492), "A6"); + Assert.That(Fn.GammaLn(-1e-7), NumericIs.AlmostEqualTo(16.11809570867989450294996), "A7"); + Assert.That(Fn.GammaLn(-1e-8), NumericIs.AlmostEqualTo(18.42068074972452220340596), "A8"); + Assert.That(Fn.GammaLn(-1e-10), NumericIs.AlmostEqualTo(23.02585092999817840667829), "A10"); + Assert.That(Fn.GammaLn(-1e-15), NumericIs.AlmostEqualTo(34.53877639491068583748554), "A15"); + Assert.That(Fn.GammaLn(-1e-20), NumericIs.AlmostEqualTo(46.05170185988091368036560), "A20"); + Assert.That(Fn.GammaLn(-1e-50), NumericIs.AlmostEqualTo(115.1292546497022842008996), "A50"); + Assert.That(Fn.GammaLn(-1e-100), NumericIs.AlmostEqualTo(230.2585092994045684017991), "A100"); + Assert.That(Fn.GammaLn(-1e-150), NumericIs.AlmostEqualTo(345.3877639491068526026987), "A150"); + Assert.That(Fn.GammaLn(-1e-200), NumericIs.AlmostEqualTo(460.5170185988091368035983), "A200"); + Assert.That(Fn.GammaLn(-1e-300), NumericIs.AlmostEqualTo(690.7755278982137052053974), "A300"); + + Assert.That(Fn.GammaLn(-1.00001e-1), NumericIs.AlmostEqualTo(2.368952087706699539440639), "B1"); + Assert.That(Fn.GammaLn(-1.00001e-2), NumericIs.AlmostEqualTo(4.611015052181439562964888), "B2"); + Assert.That(Fn.GammaLn(-1.00001e-3), NumericIs.AlmostEqualTo(6.908323323353646201900704), "B3"); + Assert.That(Fn.GammaLn(-1.00001e-5), NumericIs.AlmostEqualTo(11.51292123731684741756295), "B5"); + Assert.That(Fn.GammaLn(-1.00001e-10), NumericIs.AlmostEqualTo(23.02584093004817865056312), "B10"); + Assert.That(Fn.GammaLn(-1.00001e-20), NumericIs.AlmostEqualTo(46.05169185993091334703477), "B20"); + Assert.That(Fn.GammaLn(-1.00001e-100), NumericIs.AlmostEqualTo(230.2584992994545680684683), "B100"); + Assert.That(Fn.GammaLn(-1.00001e-300), NumericIs.AlmostEqualTo(690.7755178982637048720666), "B300"); + + Assert.That(Fn.GammaLn(-1.3e-1), NumericIs.AlmostEqualTo(2.130124765217041905198028), "C1"); + Assert.That(Fn.GammaLn(-1.3e-2), NumericIs.AlmostEqualTo(4.350449610205194501037890), "C2"); + Assert.That(Fn.GammaLn(-1.3e-3), NumericIs.AlmostEqualTo(6.646142785729384394910125), "C3"); + Assert.That(Fn.GammaLn(-1.3e-5), NumericIs.AlmostEqualTo(11.25056870444537889694439), "C5"); + Assert.That(Fn.GammaLn(-1.3e-10), NumericIs.AlmostEqualTo(22.76348666554800382459552), "C10"); + Assert.That(Fn.GammaLn(-1.3e-20), NumericIs.AlmostEqualTo(45.78933759541342262833184), "C20"); + Assert.That(Fn.GammaLn(-1.3e-100), NumericIs.AlmostEqualTo(229.9961450349370773497636), "C100"); + Assert.That(Fn.GammaLn(-1.3e-300), NumericIs.AlmostEqualTo(690.5131636337462141533619), "C300"); // Large Negative Numbers (no integers!) - NumericAssert.AreAlmostEqual(-12.95985406357513604232074, Fn.GammaLn(0.2 - 1e+1), "C1"); - NumericAssert.AreAlmostEqual(-361.1414188196566873672899, Fn.GammaLn(0.2 - 1e+2), "C2"); - NumericAssert.AreAlmostEqual(-5909.070423939538431502831, Fn.GammaLn(0.2 - 1e+3), "C3"); - NumericAssert.AreAlmostEqual(-82105.40963723920759885737, Fn.GammaLn(0.2 - 1e+4), "C4"); - NumericAssert.AreAlmostEqual(-1.051295243189728041261483e+6, Fn.GammaLn(0.2 - 1e+5), "C5"); - NumericAssert.AreAlmostEqual(-1.281551394543247720078214e+7, Fn.GammaLn(0.2 - 1e+6), "C6"); - NumericAssert.AreAlmostEqual(-1.511809605878269258761394e+8, Fn.GammaLn(0.2 - 1e+7), "C7"); - NumericAssert.AreAlmostEqual(-1.742068079164255802807487e+9, Fn.GammaLn(0.2 - 1e+8), "C8"); - - NumericAssert.AreAlmostEqual(3.316267945701607193755103, Fn.GammaLn(0.9999999 - 1e+1), 1e-8, "D1"); - NumericAssert.AreAlmostEqual(-343.0161101786332478626370, Fn.GammaLn(0.9999999 - 1e+2), 1e-9, "D2"); - NumericAssert.AreAlmostEqual(-5889.102328248948395158494, Fn.GammaLn(0.9999999 - 1e+3), 1e-10, "D3"); - NumericAssert.AreAlmostEqual(-82092.81894980888167293454, Fn.GammaLn(0.999 - 1e+4), 1e-14, "D4"); - NumericAssert.AreAlmostEqual(-1.051280812729653448117716e+6, Fn.GammaLn(0.999 - 1e+5), 1e-14, "D5"); - NumericAssert.AreAlmostEqual(-1.281549767520619780169610e+7, Fn.GammaLn(0.999 - 1e+6), 1e-14, "D6"); - NumericAssert.AreAlmostEqual(-1.511809424778350856243688e+8, Fn.GammaLn(0.999 - 1e+7), "D7"); + Assert.That(Fn.GammaLn(0.2 - 1e+1), NumericIs.AlmostEqualTo(-12.95985406357513604232074), "C1"); + Assert.That(Fn.GammaLn(0.2 - 1e+2), NumericIs.AlmostEqualTo(-361.1414188196566873672899), "C2"); + Assert.That(Fn.GammaLn(0.2 - 1e+3), NumericIs.AlmostEqualTo(-5909.070423939538431502831), "C3"); + Assert.That(Fn.GammaLn(0.2 - 1e+4), NumericIs.AlmostEqualTo(-82105.40963723920759885737), "C4"); + Assert.That(Fn.GammaLn(0.2 - 1e+5), NumericIs.AlmostEqualTo(-1.051295243189728041261483e+6), "C5"); + Assert.That(Fn.GammaLn(0.2 - 1e+6), NumericIs.AlmostEqualTo(-1.281551394543247720078214e+7), "C6"); + Assert.That(Fn.GammaLn(0.2 - 1e+7), NumericIs.AlmostEqualTo(-1.511809605878269258761394e+8), "C7"); + Assert.That(Fn.GammaLn(0.2 - 1e+8), NumericIs.AlmostEqualTo(-1.742068079164255802807487e+9), "C8"); + + Assert.That(Fn.GammaLn(0.9999999 - 1e+1), NumericIs.AlmostEqualTo(3.316267945701607193755103, 1e-8), "D1"); + Assert.That(Fn.GammaLn(0.9999999 - 1e+2), NumericIs.AlmostEqualTo(-343.0161101786332478626370, 1e-9), "D2"); + Assert.That(Fn.GammaLn(0.9999999 - 1e+3), NumericIs.AlmostEqualTo(-5889.102328248948395158494, 1e-10), "D3"); + Assert.That(Fn.GammaLn(0.999 - 1e+4), NumericIs.AlmostEqualTo(-82092.81894980888167293454, 1e-14), "D4"); + Assert.That(Fn.GammaLn(0.999 - 1e+5), NumericIs.AlmostEqualTo(-1.051280812729653448117716e+6, 1e-14), "D5"); + Assert.That(Fn.GammaLn(0.999 - 1e+6), NumericIs.AlmostEqualTo(-1.281549767520619780169610e+7, 1e-14), "D6"); + Assert.That(Fn.GammaLn(0.999 - 1e+7), NumericIs.AlmostEqualTo(-1.511809424778350856243688e+8), "D7"); } [Test] @@ -330,28 +330,28 @@ public void TestSpecialFunctions_Gamma() Assert.That(Fn.Gamma(-20.0000000001), Is.Not.NaN, "A4b"); // Compare Gamma with Maple: "evalf(GAMMA(x),20);" - NumericAssert.AreAlmostEqual(999.42377248459546611, Fn.Gamma(0.001), "B1"); - NumericAssert.AreAlmostEqual(99.432585119150603714, Fn.Gamma(0.01), "B2"); - NumericAssert.AreAlmostEqual(9.5135076986687318363, Fn.Gamma(0.1), "B3"); - NumericAssert.AreAlmostEqual(4.5908437119988030532, Fn.Gamma(0.2), "B4"); - NumericAssert.AreAlmostEqual(2.2181595437576882231, Fn.Gamma(0.4), "B5"); - NumericAssert.AreAlmostEqual(1.4891922488128171024, Fn.Gamma(0.6), "B6"); - NumericAssert.AreAlmostEqual(1.0686287021193193549, Fn.Gamma(0.9), "B7"); - NumericAssert.AreAlmostEqual(1.0005782056293586480, Fn.Gamma(0.999), "B8"); - NumericAssert.AreAlmostEqual(1.0, Fn.Gamma(1.0), "B9"); - NumericAssert.AreAlmostEqual(.99942377248459546611, Fn.Gamma(1.001), "B10"); - NumericAssert.AreAlmostEqual(.88622692545275801365, Fn.Gamma(1.5), "B11"); - NumericAssert.AreAlmostEqual(.96176583190738741941, Fn.Gamma(1.9), "B12"); - NumericAssert.AreAlmostEqual(1.0, Fn.Gamma(2.0), "B13"); - NumericAssert.AreAlmostEqual(362880.0, Fn.Gamma(10.0), "B14"); - NumericAssert.AreAlmostEqual(1159686.4489708177739, Fn.Gamma(10.51), "B15"); - NumericAssert.AreAlmostEqual(.93326215443944152682e156, Fn.Gamma(100), "B16"); - NumericAssert.AreAlmostEqual(-100.58719796441077919, Fn.Gamma(-0.01), 1e-14, "B17"); - NumericAssert.AreAlmostEqual(-10.686287021193193549, Fn.Gamma(-0.1), "B18"); - NumericAssert.AreAlmostEqual(-3.5449077018110320546, Fn.Gamma(-0.5), "B19"); - NumericAssert.AreAlmostEqual(4.8509571405220973902, Fn.Gamma(-1.2), "B20"); - NumericAssert.AreAlmostEqual(-49.547903041431840399, Fn.Gamma(-2.01), 1e-13, "B21"); - NumericAssert.AreAlmostEqual(-.10234011287149294961e-155, Fn.Gamma(-100.01), 1e-12, "B22"); + Assert.That(Fn.Gamma(0.001), NumericIs.AlmostEqualTo(999.42377248459546611), "B1"); + Assert.That(Fn.Gamma(0.01), NumericIs.AlmostEqualTo(99.432585119150603714), "B2"); + Assert.That(Fn.Gamma(0.1), NumericIs.AlmostEqualTo(9.5135076986687318363), "B3"); + Assert.That(Fn.Gamma(0.2), NumericIs.AlmostEqualTo(4.5908437119988030532), "B4"); + Assert.That(Fn.Gamma(0.4), NumericIs.AlmostEqualTo(2.2181595437576882231), "B5"); + Assert.That(Fn.Gamma(0.6), NumericIs.AlmostEqualTo(1.4891922488128171024), "B6"); + Assert.That(Fn.Gamma(0.9), NumericIs.AlmostEqualTo(1.0686287021193193549), "B7"); + Assert.That(Fn.Gamma(0.999), NumericIs.AlmostEqualTo(1.0005782056293586480), "B8"); + Assert.That(Fn.Gamma(1.0), NumericIs.AlmostEqualTo(1.0), "B9"); + Assert.That(Fn.Gamma(1.001), NumericIs.AlmostEqualTo(.99942377248459546611), "B10"); + Assert.That(Fn.Gamma(1.5), NumericIs.AlmostEqualTo(.88622692545275801365), "B11"); + Assert.That(Fn.Gamma(1.9), NumericIs.AlmostEqualTo(.96176583190738741941), "B12"); + Assert.That(Fn.Gamma(2.0), NumericIs.AlmostEqualTo(1.0), "B13"); + Assert.That(Fn.Gamma(10.0), NumericIs.AlmostEqualTo(362880.0), "B14"); + Assert.That(Fn.Gamma(10.51), NumericIs.AlmostEqualTo(1159686.4489708177739), "B15"); + Assert.That(Fn.Gamma(100), NumericIs.AlmostEqualTo(.93326215443944152682e156), "B16"); + Assert.That(Fn.Gamma(-0.01), NumericIs.AlmostEqualTo(-100.58719796441077919, 1e-14), "B17"); + Assert.That(Fn.Gamma(-0.1), NumericIs.AlmostEqualTo(-10.686287021193193549), "B18"); + Assert.That(Fn.Gamma(-0.5), NumericIs.AlmostEqualTo(-3.5449077018110320546), "B19"); + Assert.That(Fn.Gamma(-1.2), NumericIs.AlmostEqualTo(4.8509571405220973902), "B20"); + Assert.That(Fn.Gamma(-2.01), NumericIs.AlmostEqualTo(-49.547903041431840399, 1e-13), "B21"); + Assert.That(Fn.Gamma(-100.01), NumericIs.AlmostEqualTo(-.10234011287149294961e-155, 1e-12), "B22"); } [Test] @@ -366,24 +366,24 @@ public void TestSpecialFunctions_GammaRegularized() Assert.That(Fn.GammaRegularized(0, 0), Is.NaN, "(0,0) -> NaN"); // x axis (a=0) - NumericAssert.AreAlmostEqual(1, Fn.GammaRegularized(0, 1), "(0,1) -> 1"); - NumericAssert.AreAlmostEqual(1, Fn.GammaRegularized(0, 0.5), "(0,1/2) -> 1"); - NumericAssert.AreAlmostEqual(1, Fn.GammaRegularized(0, 0.001), "(0,1/1000) -> 1"); + Assert.That(Fn.GammaRegularized(0, 1), NumericIs.AlmostEqualTo((double) 1), "(0,1) -> 1"); + Assert.That(Fn.GammaRegularized(0, 0.5), NumericIs.AlmostEqualTo((double) 1), "(0,1/2) -> 1"); + Assert.That(Fn.GammaRegularized(0, 0.001), NumericIs.AlmostEqualTo((double) 1), "(0,1/1000) -> 1"); // a axis (x=0) - NumericAssert.AreAlmostEqual(0, Fn.GammaRegularized(1, 0), "(1,0) -> 0"); - NumericAssert.AreAlmostEqual(0, Fn.GammaRegularized(0.5, 0), "(1/2,0) -> 0"); - NumericAssert.AreAlmostEqual(0, Fn.GammaRegularized(0.001, 0), "(1/1000,0) -> 0"); + Assert.That(Fn.GammaRegularized(1, 0), NumericIs.AlmostEqualTo((double) 0), "(1,0) -> 0"); + Assert.That(Fn.GammaRegularized(0.5, 0), NumericIs.AlmostEqualTo((double) 0), "(1/2,0) -> 0"); + Assert.That(Fn.GammaRegularized(0.001, 0), NumericIs.AlmostEqualTo((double) 0), "(1/1000,0) -> 0"); // various points (some with known other representation) - NumericAssert.AreAlmostEqual(0.63212055882855767840, Fn.GammaRegularized(1, 1), "(1,1) -> 1-exp(-1)"); - NumericAssert.AreAlmostEqual(0.95678608173622775023, Fn.GammaRegularized(1, Math.PI), "(1,pi) -> 1-exp(-pi)"); - NumericAssert.AreAlmostEqual(0.84270079294971486934, Fn.GammaRegularized(0.5, 1), "(1/2,1) -> erf(1)"); - NumericAssert.AreAlmostEqual(0.47291074313446191487, Fn.GammaRegularized(0.5, 0.2), "(1/2,1/5) -> erf(sqrt(5)/5)"); - NumericAssert.AreAlmostEqual(0.62890663047730242621, Fn.GammaRegularized(0.5, 0.4), "(1/2,2/5) -> erf(sqrt(10)/5)"); - NumericAssert.AreAlmostEqual(0.79409678926793169113, Fn.GammaRegularized(0.5, 0.8), "(1/2,4/5) -> erf(sqrt(20)/5)"); - NumericAssert.AreAlmostEqual(0.70985103173698245837, Fn.GammaRegularized(0.25, 0.2), "(1/4,1/5)"); - NumericAssert.AreAlmostEqual(0.99999999974603714105, Fn.GammaRegularized(0.5, 20d), "(1/2,20) -> erf(2*5^(1/2))"); + Assert.That(Fn.GammaRegularized(1, 1), NumericIs.AlmostEqualTo(0.63212055882855767840), "(1,1) -> 1-exp(-1)"); + Assert.That(Fn.GammaRegularized(1, Math.PI), NumericIs.AlmostEqualTo(0.95678608173622775023), "(1,pi) -> 1-exp(-pi)"); + Assert.That(Fn.GammaRegularized(0.5, 1), NumericIs.AlmostEqualTo(0.84270079294971486934), "(1/2,1) -> erf(1)"); + Assert.That(Fn.GammaRegularized(0.5, 0.2), NumericIs.AlmostEqualTo(0.47291074313446191487), "(1/2,1/5) -> erf(sqrt(5)/5)"); + Assert.That(Fn.GammaRegularized(0.5, 0.4), NumericIs.AlmostEqualTo(0.62890663047730242621), "(1/2,2/5) -> erf(sqrt(10)/5)"); + Assert.That(Fn.GammaRegularized(0.5, 0.8), NumericIs.AlmostEqualTo(0.79409678926793169113), "(1/2,4/5) -> erf(sqrt(20)/5)"); + Assert.That(Fn.GammaRegularized(0.25, 0.2), NumericIs.AlmostEqualTo(0.70985103173698245837), "(1/4,1/5)"); + Assert.That(Fn.GammaRegularized(0.5, 20d), NumericIs.AlmostEqualTo(0.99999999974603714105), "(1/2,20) -> erf(2*5^(1/2))"); } [Test] @@ -398,9 +398,9 @@ public void TestSpecialFunctions_InverseGammaRegularized() Assert.That(Fn.InverseGammaRegularized(0, 0), Is.NaN, "(0,0) -> NaN"); // a axis (y=0) - NumericAssert.AreAlmostEqual(0, Fn.InverseGammaRegularized(1, 0), "(1,0) -> 0"); - NumericAssert.AreAlmostEqual(0, Fn.InverseGammaRegularized(0.5, 0), "(1/2,0) -> 0"); - NumericAssert.AreAlmostEqual(0, Fn.InverseGammaRegularized(0.001, 0), "(1/1000,0) -> 0"); + Assert.That(Fn.InverseGammaRegularized(1, 0), NumericIs.AlmostEqualTo((double) 0), "(1,0) -> 0"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0), NumericIs.AlmostEqualTo((double) 0), "(1/2,0) -> 0"); + Assert.That(Fn.InverseGammaRegularized(0.001, 0), NumericIs.AlmostEqualTo((double) 0), "(1/1000,0) -> 0"); // shifted a axis (y=1) Assert.That(Fn.InverseGammaRegularized(1, 1), Is.EqualTo(double.PositiveInfinity), "(1,1) -> +infty"); @@ -417,19 +417,19 @@ public void TestSpecialFunctions_InverseGammaRegularized() Assert.That(Fn.InverseGammaRegularized(0, 0.001), Is.NaN, "(0,1/1000) -> NaN"); // various points (some with known other representation) - NumericAssert.AreAlmostEqual(1, Fn.InverseGammaRegularized(1, 0.63212055882855767840), "(1,1-exp(-1)) -> 1"); - NumericAssert.AreAlmostEqual(Math.PI, Fn.InverseGammaRegularized(1, 0.95678608173622775023), "(1,1-exp(-pi)) -> pi"); - NumericAssert.AreAlmostEqual(1, Fn.InverseGammaRegularized(0.5, 0.84270079294971486934), "(1/2,erf(1)) -> 1"); - NumericAssert.AreAlmostEqual(0.2, Fn.InverseGammaRegularized(0.5, 0.47291074313446191487), "(1/2,erf(sqrt(1/5))) -> 1/5"); - NumericAssert.AreAlmostEqual(0.4, Fn.InverseGammaRegularized(0.5, 0.62890663047730242621), "(1/2,erf(sqrt(2/5))) -> 2/5"); - NumericAssert.AreAlmostEqual(0.8, Fn.InverseGammaRegularized(0.5, 0.79409678926793169113), "(1/2,erf(sqrt(8/5))) -> 4/5"); - NumericAssert.AreAlmostEqual(0.2, Fn.InverseGammaRegularized(0.25, 0.70985103173698245837), "(1/4,?) -> 4/5"); - NumericAssert.AreAlmostEqual(10, Fn.InverseGammaRegularized(0.5, 0.99999225578356895592), 1e-12, "(1/2,erf(sqrt(10))) -> 10"); - NumericAssert.AreAlmostEqual(20, Fn.InverseGammaRegularized(0.5, 0.99999999974603714105), 1e-8, "(1/2,erf(sqrt(20))) -> 20"); - NumericAssert.AreAlmostEqual(5.4137830853313661466, Fn.InverseGammaRegularized(0.5, 0.999), "(1/2,0.999)"); - NumericAssert.AreAlmostEqual(0.82118720757490819339, Fn.InverseGammaRegularized(0.5, 0.8), "(1/2,0.8)"); - NumericAssert.AreAlmostEqual(0.35416315040039690443, Fn.InverseGammaRegularized(0.5, 0.6), "(1/2,0.6)"); - NumericAssert.AreAlmostEqual(0.032092377333650790123, Fn.InverseGammaRegularized(0.5, 0.2), "(1/2,0.2)"); + Assert.That(Fn.InverseGammaRegularized(1, 0.63212055882855767840), NumericIs.AlmostEqualTo((double) 1), "(1,1-exp(-1)) -> 1"); + Assert.That(Fn.InverseGammaRegularized(1, 0.95678608173622775023), NumericIs.AlmostEqualTo(Math.PI), "(1,1-exp(-pi)) -> pi"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.84270079294971486934), NumericIs.AlmostEqualTo((double) 1), "(1/2,erf(1)) -> 1"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.47291074313446191487), NumericIs.AlmostEqualTo(0.2), "(1/2,erf(sqrt(1/5))) -> 1/5"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.62890663047730242621), NumericIs.AlmostEqualTo(0.4), "(1/2,erf(sqrt(2/5))) -> 2/5"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.79409678926793169113), NumericIs.AlmostEqualTo(0.8), "(1/2,erf(sqrt(8/5))) -> 4/5"); + Assert.That(Fn.InverseGammaRegularized(0.25, 0.70985103173698245837), NumericIs.AlmostEqualTo(0.2), "(1/4,?) -> 4/5"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.99999225578356895592), NumericIs.AlmostEqualTo((double) 10, 1e-12), "(1/2,erf(sqrt(10))) -> 10"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.99999999974603714105), NumericIs.AlmostEqualTo((double) 20, 1e-8), "(1/2,erf(sqrt(20))) -> 20"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.999), NumericIs.AlmostEqualTo(5.4137830853313661466), "(1/2,0.999)"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.8), NumericIs.AlmostEqualTo(0.82118720757490819339), "(1/2,0.8)"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.6), NumericIs.AlmostEqualTo(0.35416315040039690443), "(1/2,0.6)"); + Assert.That(Fn.InverseGammaRegularized(0.5, 0.2), NumericIs.AlmostEqualTo(0.032092377333650790123), "(1/2,0.2)"); } [Test] @@ -443,101 +443,101 @@ public void TestSpecialFunctions_Digamma() Assert.That(Fn.Digamma(-20.0000000001), Is.Not.NaN, "A4b"); // Compare Gamma with Maple: "evalf(Psi(x),20);" - NumericAssert.AreAlmostEqual(-1000.5755719318103005, Fn.Digamma(0.001), "B1"); - NumericAssert.AreAlmostEqual(-100.56088545786867450, Fn.Digamma(0.01), "B2"); - NumericAssert.AreAlmostEqual(-10.423754940411076795, Fn.Digamma(0.1), "B3"); - NumericAssert.AreAlmostEqual(-5.2890398965921882955, Fn.Digamma(0.2), "B4"); - NumericAssert.AreAlmostEqual(-2.5613845445851161457, Fn.Digamma(0.4), "B5"); - NumericAssert.AreAlmostEqual(-1.5406192138931904148, Fn.Digamma(0.6), "B6"); - NumericAssert.AreAlmostEqual(-.75492694994705139189, Fn.Digamma(0.9), "B7"); - NumericAssert.AreAlmostEqual(-.57886180210864542646, Fn.Digamma(0.999), "B8"); - NumericAssert.AreAlmostEqual(-.57721566490153286061, Fn.Digamma(1.0), "B9"); - NumericAssert.AreAlmostEqual(-.57557193181030047147, Fn.Digamma(1.001), 1e-14, "B10"); - NumericAssert.AreAlmostEqual(.36489973978576520559e-1, Fn.Digamma(1.5), 1e-14, "B11"); - NumericAssert.AreAlmostEqual(.35618416116405971922, Fn.Digamma(1.9), "B12"); - NumericAssert.AreAlmostEqual(.42278433509846713939, Fn.Digamma(2.0), "B13"); - NumericAssert.AreAlmostEqual(2.2517525890667211076, Fn.Digamma(10.0), "B14"); - NumericAssert.AreAlmostEqual(2.3039997054324985520, Fn.Digamma(10.51), "B15"); - NumericAssert.AreAlmostEqual(4.6001618527380874002, Fn.Digamma(100), "B16"); - NumericAssert.AreAlmostEqual(99.406213695944404856, Fn.Digamma(-0.01), "B17"); - NumericAssert.AreAlmostEqual(9.2450730500529486081, Fn.Digamma(-0.1), "B18"); - NumericAssert.AreAlmostEqual(.36489973978576520559e-1, Fn.Digamma(-0.5), 1e-14, "B19"); - NumericAssert.AreAlmostEqual(4.8683247666271948739, Fn.Digamma(-1.2), "B20"); - NumericAssert.AreAlmostEqual(100.89382514365634023, Fn.Digamma(-2.01), 1e-13, "B21"); - NumericAssert.AreAlmostEqual(104.57736050326787844, Fn.Digamma(-100.01), 1e-12, "B22"); + Assert.That(Fn.Digamma(0.001), NumericIs.AlmostEqualTo(-1000.5755719318103005), "B1"); + Assert.That(Fn.Digamma(0.01), NumericIs.AlmostEqualTo(-100.56088545786867450), "B2"); + Assert.That(Fn.Digamma(0.1), NumericIs.AlmostEqualTo(-10.423754940411076795), "B3"); + Assert.That(Fn.Digamma(0.2), NumericIs.AlmostEqualTo(-5.2890398965921882955), "B4"); + Assert.That(Fn.Digamma(0.4), NumericIs.AlmostEqualTo(-2.5613845445851161457), "B5"); + Assert.That(Fn.Digamma(0.6), NumericIs.AlmostEqualTo(-1.5406192138931904148), "B6"); + Assert.That(Fn.Digamma(0.9), NumericIs.AlmostEqualTo(-.75492694994705139189), "B7"); + Assert.That(Fn.Digamma(0.999), NumericIs.AlmostEqualTo(-.57886180210864542646), "B8"); + Assert.That(Fn.Digamma(1.0), NumericIs.AlmostEqualTo(-.57721566490153286061), "B9"); + Assert.That(Fn.Digamma(1.001), NumericIs.AlmostEqualTo(-.57557193181030047147, 1e-14), "B10"); + Assert.That(Fn.Digamma(1.5), NumericIs.AlmostEqualTo(.36489973978576520559e-1, 1e-14), "B11"); + Assert.That(Fn.Digamma(1.9), NumericIs.AlmostEqualTo(.35618416116405971922), "B12"); + Assert.That(Fn.Digamma(2.0), NumericIs.AlmostEqualTo(.42278433509846713939), "B13"); + Assert.That(Fn.Digamma(10.0), NumericIs.AlmostEqualTo(2.2517525890667211076), "B14"); + Assert.That(Fn.Digamma(10.51), NumericIs.AlmostEqualTo(2.3039997054324985520), "B15"); + Assert.That(Fn.Digamma(100), NumericIs.AlmostEqualTo(4.6001618527380874002), "B16"); + Assert.That(Fn.Digamma(-0.01), NumericIs.AlmostEqualTo(99.406213695944404856), "B17"); + Assert.That(Fn.Digamma(-0.1), NumericIs.AlmostEqualTo(9.2450730500529486081), "B18"); + Assert.That(Fn.Digamma(-0.5), NumericIs.AlmostEqualTo(.36489973978576520559e-1, 1e-14), "B19"); + Assert.That(Fn.Digamma(-1.2), NumericIs.AlmostEqualTo(4.8683247666271948739), "B20"); + Assert.That(Fn.Digamma(-2.01), NumericIs.AlmostEqualTo(100.89382514365634023, 1e-13), "B21"); + Assert.That(Fn.Digamma(-100.01), NumericIs.AlmostEqualTo(104.57736050326787844, 1e-12), "B22"); } [Test] public void TestSpecialFunctions_Erf() { // Compare Erf with Maple: "evalf(erf(x),20);" - NumericAssert.AreAlmostEqual(.0, Fn.Erf(0.0), "A1"); - NumericAssert.AreAlmostEqual(.11246291601828489220, Fn.Erf(0.1), "A2"); - NumericAssert.AreAlmostEqual(.22270258921047845414, Fn.Erf(0.2), "A3"); - NumericAssert.AreAlmostEqual(.32862675945912742764, Fn.Erf(0.3), "A4"); - NumericAssert.AreAlmostEqual(.42839235504666845510, Fn.Erf(0.4), "A5"); - NumericAssert.AreAlmostEqual(.52049987781304653768, Fn.Erf(0.5), "A6"); - NumericAssert.AreAlmostEqual(.60385609084792592256, Fn.Erf(0.6), "A7"); - NumericAssert.AreAlmostEqual(.67780119383741847298, Fn.Erf(0.7), "A8"); - NumericAssert.AreAlmostEqual(.74210096470766048617, Fn.Erf(0.8), "A9"); - NumericAssert.AreAlmostEqual(.79690821242283212852, Fn.Erf(0.9), "A10"); - NumericAssert.AreAlmostEqual(.84270079294971486934, Fn.Erf(1.0), "A11"); - NumericAssert.AreAlmostEqual(.88020506957408169977, Fn.Erf(1.1), "A12"); - NumericAssert.AreAlmostEqual(.91031397822963538024, Fn.Erf(1.2), "A13"); - NumericAssert.AreAlmostEqual(.99997790950300141456, Fn.Erf(3.0), "A14"); - NumericAssert.AreAlmostEqual(1.0, Fn.Erf(9.0), "A15"); - NumericAssert.AreAlmostEqual(1.0, Fn.Erf(100), "A16"); - NumericAssert.AreAlmostEqual(-.32862675945912742764, Fn.Erf(-0.3), "A17"); - NumericAssert.AreAlmostEqual(-.74210096470766048617, Fn.Erf(-0.8), "A18"); + Assert.That(Fn.Erf(0.0), NumericIs.AlmostEqualTo(.0), "A1"); + Assert.That(Fn.Erf(0.1), NumericIs.AlmostEqualTo(.11246291601828489220), "A2"); + Assert.That(Fn.Erf(0.2), NumericIs.AlmostEqualTo(.22270258921047845414), "A3"); + Assert.That(Fn.Erf(0.3), NumericIs.AlmostEqualTo(.32862675945912742764), "A4"); + Assert.That(Fn.Erf(0.4), NumericIs.AlmostEqualTo(.42839235504666845510), "A5"); + Assert.That(Fn.Erf(0.5), NumericIs.AlmostEqualTo(.52049987781304653768), "A6"); + Assert.That(Fn.Erf(0.6), NumericIs.AlmostEqualTo(.60385609084792592256), "A7"); + Assert.That(Fn.Erf(0.7), NumericIs.AlmostEqualTo(.67780119383741847298), "A8"); + Assert.That(Fn.Erf(0.8), NumericIs.AlmostEqualTo(.74210096470766048617), "A9"); + Assert.That(Fn.Erf(0.9), NumericIs.AlmostEqualTo(.79690821242283212852), "A10"); + Assert.That(Fn.Erf(1.0), NumericIs.AlmostEqualTo(.84270079294971486934), "A11"); + Assert.That(Fn.Erf(1.1), NumericIs.AlmostEqualTo(.88020506957408169977), "A12"); + Assert.That(Fn.Erf(1.2), NumericIs.AlmostEqualTo(.91031397822963538024), "A13"); + Assert.That(Fn.Erf(3.0), NumericIs.AlmostEqualTo(.99997790950300141456), "A14"); + Assert.That(Fn.Erf(9.0), NumericIs.AlmostEqualTo(1.0), "A15"); + Assert.That(Fn.Erf(100), NumericIs.AlmostEqualTo(1.0), "A16"); + Assert.That(Fn.Erf(-0.3), NumericIs.AlmostEqualTo(-.32862675945912742764), "A17"); + Assert.That(Fn.Erf(-0.8), NumericIs.AlmostEqualTo(-.74210096470766048617), "A18"); // Compare ErvInverse with Maple: "erfinv := y -> RootOf(-erf(_Z)+y); evalf(erfinv(x),20);" - NumericAssert.AreAlmostEqual(.0, Fn.ErfInverse(0.0), "B1"); - NumericAssert.AreAlmostEqual(.88855990494257687016e-1, Fn.ErfInverse(0.1), 1e-9, "B2"); - NumericAssert.AreAlmostEqual(.17914345462129167649, Fn.ErfInverse(0.2), 1e-8, "B3"); - NumericAssert.AreAlmostEqual(.27246271472675435562, Fn.ErfInverse(0.3), 1e-9, "B4"); - NumericAssert.AreAlmostEqual(.37080715859355792906, Fn.ErfInverse(0.4), 1e-8, "B5"); - NumericAssert.AreAlmostEqual(.47693627620446987338, Fn.ErfInverse(0.5), 1e-9, "B6"); - NumericAssert.AreAlmostEqual(.59511608144999485002, Fn.ErfInverse(0.6), 1e-8, "B7"); - NumericAssert.AreAlmostEqual(.73286907795921685222, Fn.ErfInverse(0.7), 1e-8, "B8"); - NumericAssert.AreAlmostEqual(.90619380243682322007, Fn.ErfInverse(0.8), 1e-8, "B9"); - NumericAssert.AreAlmostEqual(1.1630871536766740867, Fn.ErfInverse(0.9), 1e-8, "B10"); - NumericAssert.AreAlmostEqual(2.7510639057120607961, Fn.ErfInverse(0.9999), 1e-8, "B11"); - NumericAssert.AreAlmostEqual(3.7665625815708380738, Fn.ErfInverse(0.9999999), 1e-8, "B12"); - NumericAssert.AreAlmostEqual(-.27246271472675435562, Fn.ErfInverse(-0.3), 1e-9, "B13"); - NumericAssert.AreAlmostEqual(-.90619380243682322007, Fn.ErfInverse(-0.8), 1e-8, "B14"); - NumericAssert.AreAlmostEqual(.88622715746655210457e-3, Fn.ErfInverse(0.001), 1e-8, "B15"); - NumericAssert.AreAlmostEqual(.44311636293707267099e-2, Fn.ErfInverse(0.005), 1e-8, "B16"); + Assert.That(Fn.ErfInverse(0.0), NumericIs.AlmostEqualTo(.0), "B1"); + Assert.That(Fn.ErfInverse(0.1), NumericIs.AlmostEqualTo(.88855990494257687016e-1, 1e-9), "B2"); + Assert.That(Fn.ErfInverse(0.2), NumericIs.AlmostEqualTo(.17914345462129167649, 1e-8), "B3"); + Assert.That(Fn.ErfInverse(0.3), NumericIs.AlmostEqualTo(.27246271472675435562, 1e-9), "B4"); + Assert.That(Fn.ErfInverse(0.4), NumericIs.AlmostEqualTo(.37080715859355792906, 1e-8), "B5"); + Assert.That(Fn.ErfInverse(0.5), NumericIs.AlmostEqualTo(.47693627620446987338, 1e-9), "B6"); + Assert.That(Fn.ErfInverse(0.6), NumericIs.AlmostEqualTo(.59511608144999485002, 1e-8), "B7"); + Assert.That(Fn.ErfInverse(0.7), NumericIs.AlmostEqualTo(.73286907795921685222, 1e-8), "B8"); + Assert.That(Fn.ErfInverse(0.8), NumericIs.AlmostEqualTo(.90619380243682322007, 1e-8), "B9"); + Assert.That(Fn.ErfInverse(0.9), NumericIs.AlmostEqualTo(1.1630871536766740867, 1e-8), "B10"); + Assert.That(Fn.ErfInverse(0.9999), NumericIs.AlmostEqualTo(2.7510639057120607961, 1e-8), "B11"); + Assert.That(Fn.ErfInverse(0.9999999), NumericIs.AlmostEqualTo(3.7665625815708380738, 1e-8), "B12"); + Assert.That(Fn.ErfInverse(-0.3), NumericIs.AlmostEqualTo(-.27246271472675435562, 1e-9), "B13"); + Assert.That(Fn.ErfInverse(-0.8), NumericIs.AlmostEqualTo(-.90619380243682322007, 1e-8), "B14"); + Assert.That(Fn.ErfInverse(0.001), NumericIs.AlmostEqualTo(.88622715746655210457e-3, 1e-8), "B15"); + Assert.That(Fn.ErfInverse(0.005), NumericIs.AlmostEqualTo(.44311636293707267099e-2, 1e-8), "B16"); } [Test] public void TestSpecialFunctions_Beta() { // Symmetry: - NumericAssert.AreAlmostEqual(Fn.Beta(1.0, 0.1), Fn.Beta(0.1, 1.0), "A1"); - NumericAssert.AreAlmostEqual(Fn.Beta(10.0, 0.1), Fn.Beta(0.1, 10.0), "A2"); - NumericAssert.AreAlmostEqual(Fn.Beta(1.0, 0.5), Fn.Beta(0.5, 1.0), "A3"); - NumericAssert.AreAlmostEqual(Fn.Beta(10.0, 0.5), Fn.Beta(0.5, 10.0), "A4"); - NumericAssert.AreAlmostEqual(Fn.Beta(100.0, 10.0), Fn.Beta(10.0, 100.0), "A1"); + Assert.That(Fn.Beta(0.1, 1.0), NumericIs.AlmostEqualTo(Fn.Beta(1.0, 0.1)), "A1"); + Assert.That(Fn.Beta(0.1, 10.0), NumericIs.AlmostEqualTo(Fn.Beta(10.0, 0.1)), "A2"); + Assert.That(Fn.Beta(0.5, 1.0), NumericIs.AlmostEqualTo(Fn.Beta(1.0, 0.5)), "A3"); + Assert.That(Fn.Beta(0.5, 10.0), NumericIs.AlmostEqualTo(Fn.Beta(10.0, 0.5)), "A4"); + Assert.That(Fn.Beta(10.0, 100.0), NumericIs.AlmostEqualTo(Fn.Beta(100.0, 10.0)), "A1"); // Compare with Maple: "evalf(Beta(0.1,x),20);", with relative accuracy - NumericAssert.AreAlmostEqual(19.714639489050161663, Fn.Beta(0.1, 0.1), "B1"); - NumericAssert.AreAlmostEqual(14.599371492764829943, Fn.Beta(0.1, 0.2), "B2"); - NumericAssert.AreAlmostEqual(12.830598536321300437, Fn.Beta(0.1, 0.3), "B3"); - NumericAssert.AreAlmostEqual(10.0, Fn.Beta(0.1, 1.0), "B4"); - NumericAssert.AreAlmostEqual(9.0909090909090909091, Fn.Beta(0.1, 2.0), "B5"); - NumericAssert.AreAlmostEqual(8.1743590791584497328, Fn.Beta(0.1, 5.0), "B6"); - NumericAssert.AreAlmostEqual(7.5913800009109903433, Fn.Beta(0.1, 10.0), "B7"); - NumericAssert.AreAlmostEqual(6.0053229390929389725, Fn.Beta(0.1, 100.0), 1e-12, "B8"); + Assert.That(Fn.Beta(0.1, 0.1), NumericIs.AlmostEqualTo(19.714639489050161663), "B1"); + Assert.That(Fn.Beta(0.1, 0.2), NumericIs.AlmostEqualTo(14.599371492764829943), "B2"); + Assert.That(Fn.Beta(0.1, 0.3), NumericIs.AlmostEqualTo(12.830598536321300437), "B3"); + Assert.That(Fn.Beta(0.1, 1.0), NumericIs.AlmostEqualTo(10.0), "B4"); + Assert.That(Fn.Beta(0.1, 2.0), NumericIs.AlmostEqualTo(9.0909090909090909091), "B5"); + Assert.That(Fn.Beta(0.1, 5.0), NumericIs.AlmostEqualTo(8.1743590791584497328), "B6"); + Assert.That(Fn.Beta(0.1, 10.0), NumericIs.AlmostEqualTo(7.5913800009109903433), "B7"); + Assert.That(Fn.Beta(0.1, 100.0), NumericIs.AlmostEqualTo(6.0053229390929389725, 1e-12), "B8"); // Compare with Maple: "evalf(Beta(25.0,x),20);", with relative accuracy - NumericAssert.AreAlmostEqual(6.9076854432998202098, Fn.Beta(25.0, 0.1), 1e-13, "C1"); - NumericAssert.AreAlmostEqual(2.4193558279880311532, Fn.Beta(25.0, 0.2), 1e-14, "C2"); - NumericAssert.AreAlmostEqual(1.1437887414566949564, Fn.Beta(25.0, 0.3), 1e-14, "C3"); - NumericAssert.AreAlmostEqual(.40000000000000000000e-1, Fn.Beta(25.0, 1.0), 1e-14, "C4"); - NumericAssert.AreAlmostEqual(.15384615384615384615e-2, Fn.Beta(25.0, 2.0), 1e-14, "C5"); - NumericAssert.AreAlmostEqual(.16841396151740979327e-5, Fn.Beta(25.0, 5.0), 1e-13, "C6"); - NumericAssert.AreAlmostEqual(.76261281522028757519e-9, Fn.Beta(25.0, 10.0), 1e-13, "C7"); - NumericAssert.AreAlmostEqual(.38445319996184968535e-27, Fn.Beta(25.0, 100.0), 1e-13, "C8"); + Assert.That(Fn.Beta(25.0, 0.1), NumericIs.AlmostEqualTo(6.9076854432998202098, 1e-13), "C1"); + Assert.That(Fn.Beta(25.0, 0.2), NumericIs.AlmostEqualTo(2.4193558279880311532, 1e-14), "C2"); + Assert.That(Fn.Beta(25.0, 0.3), NumericIs.AlmostEqualTo(1.1437887414566949564, 1e-14), "C3"); + Assert.That(Fn.Beta(25.0, 1.0), NumericIs.AlmostEqualTo(.40000000000000000000e-1, 1e-14), "C4"); + Assert.That(Fn.Beta(25.0, 2.0), NumericIs.AlmostEqualTo(.15384615384615384615e-2, 1e-14), "C5"); + Assert.That(Fn.Beta(25.0, 5.0), NumericIs.AlmostEqualTo(.16841396151740979327e-5, 1e-13), "C6"); + Assert.That(Fn.Beta(25.0, 10.0), NumericIs.AlmostEqualTo(.76261281522028757519e-9, 1e-13), "C7"); + Assert.That(Fn.Beta(25.0, 100.0), NumericIs.AlmostEqualTo(.38445319996184968535e-27, 1e-13), "C8"); } [Test] @@ -546,28 +546,28 @@ public void TestSpecialFunctions_BetaRegularized() // Maple: Ix := (x,a,b) -> int(t^(a-1)*(1-t)^(b-1),t=0..x)/Beta(a,b); // Compare with Maple: "evalf(Ix(x,0.2,0.2),20);", with relative accuracy - NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(0.2, 0.2, 0.0), "A1"); - NumericAssert.AreAlmostEqual(.39272216435257082965, Fn.BetaRegularized(0.2, 0.2, 0.2), "A2"); - NumericAssert.AreAlmostEqual(.50000000000000000000, Fn.BetaRegularized(0.2, 0.2, 0.5), "A3"); - NumericAssert.AreAlmostEqual(.60727783564742917036, Fn.BetaRegularized(0.2, 0.2, 0.8), "A4"); - NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(0.2, 0.2, 1.0), "A5"); + Assert.That(Fn.BetaRegularized(0.2, 0.2, 0.0), NumericIs.AlmostEqualTo(0.0), "A1"); + Assert.That(Fn.BetaRegularized(0.2, 0.2, 0.2), NumericIs.AlmostEqualTo(.39272216435257082965), "A2"); + Assert.That(Fn.BetaRegularized(0.2, 0.2, 0.5), NumericIs.AlmostEqualTo(.50000000000000000000), "A3"); + Assert.That(Fn.BetaRegularized(0.2, 0.2, 0.8), NumericIs.AlmostEqualTo(.60727783564742917036), "A4"); + Assert.That(Fn.BetaRegularized(0.2, 0.2, 1.0), NumericIs.AlmostEqualTo(1.0000000000000000000), "A5"); // Compare with Maple: "evalf(Ix(x,0.6,1.2),20);", with relative accuracy - NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(0.6, 1.2, 0.0), "B1"); - NumericAssert.AreAlmostEqual(.42540331997033591754, Fn.BetaRegularized(0.6, 1.2, 0.2), "B2"); - NumericAssert.AreAlmostEqual(.71641011564425207256, Fn.BetaRegularized(0.6, 1.2, 0.5), "B3"); - NumericAssert.AreAlmostEqual(.91373194998181983314, Fn.BetaRegularized(0.6, 1.2, 0.8), "B4"); - NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(0.6, 1.2, 1.0), "B5"); + Assert.That(Fn.BetaRegularized(0.6, 1.2, 0.0), NumericIs.AlmostEqualTo(0.0), "B1"); + Assert.That(Fn.BetaRegularized(0.6, 1.2, 0.2), NumericIs.AlmostEqualTo(.42540331997033591754), "B2"); + Assert.That(Fn.BetaRegularized(0.6, 1.2, 0.5), NumericIs.AlmostEqualTo(.71641011564425207256), "B3"); + Assert.That(Fn.BetaRegularized(0.6, 1.2, 0.8), NumericIs.AlmostEqualTo(.91373194998181983314), "B4"); + Assert.That(Fn.BetaRegularized(0.6, 1.2, 1.0), NumericIs.AlmostEqualTo(1.0000000000000000000), "B5"); // Compare with Maple: "evalf(Ix(x,7.0,1.2),20);", with relative accuracy - NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(7.0, 1.2, 0.0), "C1"); - NumericAssert.AreAlmostEqual(.20126888449347947608e-4, Fn.BetaRegularized(7.0, 1.2, 0.2), "C2"); - NumericAssert.AreAlmostEqual(.11371092280417448678e-1, Fn.BetaRegularized(7.0, 1.2, 0.5), "C3"); - NumericAssert.AreAlmostEqual(.11102090346884848038, Fn.BetaRegularized(7.0, 1.2, 0.7), 1e-14, "C4"); - NumericAssert.AreAlmostEqual(.26774648551269072265, Fn.BetaRegularized(7.0, 1.2, 0.8), 1e-14, "C5"); - NumericAssert.AreAlmostEqual(.56477467605979107895, Fn.BetaRegularized(7.0, 1.2, 0.9), "C6"); - NumericAssert.AreAlmostEqual(.77753405618146275868, Fn.BetaRegularized(7.0, 1.2, 0.95), "C7"); - NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(7.0, 1.2, 1.0), "C8"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.0), NumericIs.AlmostEqualTo(0.0), "C1"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.2), NumericIs.AlmostEqualTo(.20126888449347947608e-4), "C2"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.5), NumericIs.AlmostEqualTo(.11371092280417448678e-1), "C3"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.7), NumericIs.AlmostEqualTo(.11102090346884848038, 1e-14), "C4"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.8), NumericIs.AlmostEqualTo(.26774648551269072265, 1e-14), "C5"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.9), NumericIs.AlmostEqualTo(.56477467605979107895), "C6"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 0.95), NumericIs.AlmostEqualTo(.77753405618146275868), "C7"); + Assert.That(Fn.BetaRegularized(7.0, 1.2, 1.0), NumericIs.AlmostEqualTo(1.0000000000000000000), "C8"); } [Test] @@ -576,7 +576,7 @@ public void TestSpecialFunctions_Sinc() // Test at integers: for(int i = -10; i < 10; i++) { - NumericAssert.AreAlmostEqual((i == 0) ? 1.0 : 0.0, Fn.Sinc(i), "sinc(" + i.ToString() + ")"); + Assert.That(Fn.Sinc(i), NumericIs.AlmostEqualTo((i == 0) ? 1.0 : 0.0), "sinc(" + i.ToString() + ")"); } } @@ -588,14 +588,14 @@ public void TestSpecialFunctions_Factorial() for(int i = 1; i < 32; i++) { factorial *= i; - NumericAssert.AreAlmostEqual(factorial, Fn.Factorial(i), "Factorial: " + i.ToString()); + Assert.That(Fn.Factorial(i), NumericIs.AlmostEqualTo(factorial), "Factorial: " + i.ToString()); } // approximation for(int i = 32; i < 90; i++) { factorial *= i; - NumericAssert.AreAlmostEqual(factorial, Fn.Factorial(i), 1e-10, "Factorial: " + i.ToString()); + Assert.That(Fn.Factorial(i), NumericIs.AlmostEqualTo(factorial, 1e-10), "Factorial: " + i.ToString()); } } @@ -607,19 +607,19 @@ public void TestSpecialFunctions_HarmonicNumber() for(int i = 1; i < 32; i++) { sum += 1.0 / i; - NumericAssert.AreAlmostEqual(sum, Fn.HarmonicNumber(i), "H" + i.ToString()); + Assert.That(Fn.HarmonicNumber(i), NumericIs.AlmostEqualTo(sum), "H" + i.ToString()); } // approximation for(int i = 32; i < 90; i++) { sum += 1.0 / i; - NumericAssert.AreAlmostEqual(sum, Fn.HarmonicNumber(i), 1e-10, "H" + i.ToString()); + Assert.That(Fn.HarmonicNumber(i), NumericIs.AlmostEqualTo(sum, 1e-10), "H" + i.ToString()); } // Compare with Maple: "evalf(sum(1/k,k=1..x),20)" - NumericAssert.AreAlmostEqual(12.090146129863427948, Fn.HarmonicNumber(100000), 1e-10, "H100000"); - NumericAssert.AreAlmostEqual(18.997896413853898325, Fn.HarmonicNumber(100000000), 1e-10, "H100000000"); + Assert.That(Fn.HarmonicNumber(100000), NumericIs.AlmostEqualTo(12.090146129863427948, 1e-10), "H100000"); + Assert.That(Fn.HarmonicNumber(100000000), NumericIs.AlmostEqualTo(18.997896413853898325, 1e-10), "H100000000"); } } } diff --git a/src/test/MathNet.Iridium.Test/StatisticsTests/StatisticsTest.cs b/src/test/MathNet.Iridium.Test/StatisticsTests/StatisticsTest.cs index af649d0..0ce262b 100644 --- a/src/test/MathNet.Iridium.Test/StatisticsTests/StatisticsTest.cs +++ b/src/test/MathNet.Iridium.Test/StatisticsTests/StatisticsTest.cs @@ -57,8 +57,8 @@ public void TestAccumulatorNumericStability() accumulator.Add(gaussian.NextDouble()); } - NumericAssert.AreAlmostEqual(0, accumulator.Mean, 0.2, "Mean of (0,1)"); - NumericAssert.AreAlmostEqual(1, accumulator.Variance, 0.5, "Variance of (0,1)"); + Assert.That(accumulator.Mean, NumericIs.AlmostEqualTo((double) 0, 0.2), "Mean of (0,1)"); + Assert.That(accumulator.Variance, NumericIs.AlmostEqualTo((double) 1, 0.5), "Variance of (0,1)"); // Test around 10^9, potential stability issues accumulator.Clear(); @@ -68,8 +68,8 @@ public void TestAccumulatorNumericStability() accumulator.Add(gaussian.NextDouble()); } - NumericAssert.AreAlmostEqual(1e+9, accumulator.Mean, 0.2, "Mean of (1e+9,1)"); - NumericAssert.AreAlmostEqual(1, accumulator.Variance, 0.5, "Variance of (1e+9,1)"); + Assert.That(accumulator.Mean, NumericIs.AlmostEqualTo(1e+9, 0.2), "Mean of (1e+9,1)"); + Assert.That(accumulator.Variance, NumericIs.AlmostEqualTo((double) 1, 0.5), "Variance of (1e+9,1)"); } [Test] @@ -82,23 +82,23 @@ public void TestAccumulatorAddRemove() accumulator.Add(i); } - NumericAssert.AreAlmostEqual(5, accumulator.Mean, "A Mean"); - NumericAssert.AreAlmostEqual(11, accumulator.Variance, "A Variance"); - NumericAssert.AreAlmostEqual(55, accumulator.Sum, "A Sum"); + Assert.That(accumulator.Mean, NumericIs.AlmostEqualTo((double) 5), "A Mean"); + Assert.That(accumulator.Variance, NumericIs.AlmostEqualTo((double) 11), "A Variance"); + Assert.That(accumulator.Sum, NumericIs.AlmostEqualTo((double) 55), "A Sum"); accumulator.Remove(9); accumulator.Remove(4); - NumericAssert.AreAlmostEqual(14d / 3, accumulator.Mean, "B Mean"); - NumericAssert.AreAlmostEqual(23d / 2, accumulator.Variance, "B Variance"); - NumericAssert.AreAlmostEqual(42, accumulator.Sum, "B Sum"); + Assert.That(accumulator.Mean, NumericIs.AlmostEqualTo(14d / 3), "B Mean"); + Assert.That(accumulator.Variance, NumericIs.AlmostEqualTo(23d / 2), "B Variance"); + Assert.That(accumulator.Sum, NumericIs.AlmostEqualTo((double) 42), "B Sum"); accumulator.Add(9); accumulator.Add(4); - NumericAssert.AreAlmostEqual(5, accumulator.Mean, "C Mean"); - NumericAssert.AreAlmostEqual(11, accumulator.Variance, "C Variance"); - NumericAssert.AreAlmostEqual(55, accumulator.Sum, "C Sum"); + Assert.That(accumulator.Mean, NumericIs.AlmostEqualTo((double) 5), "C Mean"); + Assert.That(accumulator.Variance, NumericIs.AlmostEqualTo((double) 11), "C Variance"); + Assert.That(accumulator.Sum, NumericIs.AlmostEqualTo((double) 55), "C Sum"); } [Test] @@ -115,9 +115,9 @@ public void TestDescriptiveStatisticsMeanVariance() // Test around 10^9, potential stability issues NormalDistribution gaussian = new NormalDistribution(1e+9, 2); - NumericAssert.AreAlmostEqual(1e+9, DescriptiveStatistics.Mean(gaussian.EnumerateDoubles(10000)), 0.2, "Mean of (1e+9,2)"); - NumericAssert.AreAlmostEqual(4, DescriptiveStatistics.Variance(gaussian.EnumerateDoubles(10000)), 0.5, "Variance of (1e+9,2)"); - NumericAssert.AreAlmostEqual(2, DescriptiveStatistics.StandardDeviation(gaussian.EnumerateDoubles(10000)), 0.5, "StdDev of (1e+9,2)"); + Assert.That(DescriptiveStatistics.Mean(gaussian.EnumerateDoubles(10000)), NumericIs.AlmostEqualTo(1e+9, 0.2), "Mean of (1e+9,2)"); + Assert.That(DescriptiveStatistics.Variance(gaussian.EnumerateDoubles(10000)), NumericIs.AlmostEqualTo((double) 4, 0.5), "Variance of (1e+9,2)"); + Assert.That(DescriptiveStatistics.StandardDeviation(gaussian.EnumerateDoubles(10000)), NumericIs.AlmostEqualTo((double) 2, 0.5), "StdDev of (1e+9,2)"); } [Test] diff --git a/src/test/MathNet.Iridium.Test/TransformationsTests/FftTest.cs b/src/test/MathNet.Iridium.Test/TransformationsTests/FftTest.cs index a171a02..22f08b0 100644 --- a/src/test/MathNet.Iridium.Test/TransformationsTests/FftTest.cs +++ b/src/test/MathNet.Iridium.Test/TransformationsTests/FftTest.cs @@ -50,7 +50,7 @@ public static void RealTestTimeEven(double[] samples) int len = samples.Length; for(int i = 1; i < samples.Length; i++) { - NumericAssert.AreAlmostEqual(samples[i], samples[len - i], "Real Even in Time Space"); + Assert.That(samples[len - i], NumericIs.AlmostEqualTo(samples[i]), "Real Even in Time Space"); } } @@ -59,10 +59,10 @@ public static void RealTestTimeOdd(double[] samples) int len = samples.Length; for(int i = 1; i < samples.Length; i++) { - NumericAssert.AreAlmostEqual(samples[i], -samples[len - i], "Real Odd in Time Space"); + Assert.That(-samples[len - i], NumericIs.AlmostEqualTo(samples[i]), "Real Odd in Time Space"); } - NumericAssert.AreAlmostEqual(0.0, samples[0], "Real Odd in Time Space: Periodic Continuation"); + Assert.That(samples[0], NumericIs.AlmostEqualTo(0.0), "Real Odd in Time Space: Periodic Continuation"); } public static void ComplexTestTimeEven(double[] samples) @@ -70,8 +70,8 @@ public static void ComplexTestTimeEven(double[] samples) int len = samples.Length; for(int i = 2; i < samples.Length / 2; i += 2) { - NumericAssert.AreAlmostEqual(samples[i], samples[len - i], "Complex Even in Time Space: Real Part"); - NumericAssert.AreAlmostEqual(samples[i + 1], samples[len + 1 - i], "Complex Even in Time Space: Imaginary Part"); + Assert.That(samples[len - i], NumericIs.AlmostEqualTo(samples[i]), "Complex Even in Time Space: Real Part"); + Assert.That(samples[len + 1 - i], NumericIs.AlmostEqualTo(samples[i + 1]), "Complex Even in Time Space: Imaginary Part"); } } @@ -80,12 +80,12 @@ public static void ComplexTestTimeOdd(double[] samples) int len = samples.Length; for(int i = 2; i < samples.Length / 2; i += 2) { - NumericAssert.AreAlmostEqual(samples[i], -samples[len - i], "Complex Odd in Time Space: Real Part"); - NumericAssert.AreAlmostEqual(samples[i + 1], -samples[len + 1 - i], "Complex Odd in Time Space: Imaginary Part"); + Assert.That(-samples[len - i], NumericIs.AlmostEqualTo(samples[i]), "Complex Odd in Time Space: Real Part"); + Assert.That(-samples[len + 1 - i], NumericIs.AlmostEqualTo(samples[i + 1]), "Complex Odd in Time Space: Imaginary Part"); } - NumericAssert.AreAlmostEqual(0.0, samples[0], "Complex Odd in Time Space: Real Part: Periodic Continuation"); - NumericAssert.AreAlmostEqual(0.0, samples[1], "Complex Odd in Time Space: Imaginary Part: Periodic Continuation"); + Assert.That(samples[0], NumericIs.AlmostEqualTo(0.0), "Complex Odd in Time Space: Real Part: Periodic Continuation"); + Assert.That(samples[1], NumericIs.AlmostEqualTo(0.0), "Complex Odd in Time Space: Imaginary Part: Periodic Continuation"); } public static void ComplexTestFreqEven(double[] samples) @@ -107,15 +107,15 @@ public static void ComplexTestFreqOdd(double[] samples) Assert.That(-samples[len - 1 - i], Is.EqualTo(samples[i + 3]).Within(0.00000001), "Complex Odd in Frequency Space: Imaginary Part"); } - NumericAssert.AreAlmostEqual(0.0, samples[0], "Complex Odd in Frequency Space: Real Part: Periodic Continuation (No DC)"); - NumericAssert.AreAlmostEqual(0.0, samples[1], "Complex Odd in Frequency Space: Imaginary Part: Periodic Continuation (No DC)"); + Assert.That(samples[0], NumericIs.AlmostEqualTo(0.0), "Complex Odd in Frequency Space: Real Part: Periodic Continuation (No DC)"); + Assert.That(samples[1], NumericIs.AlmostEqualTo(0.0), "Complex Odd in Frequency Space: Imaginary Part: Periodic Continuation (No DC)"); } public static void ComplexTestRealZero(double[] samples) { for(int i = 0; i < samples.Length; i += 2) { - NumericAssert.AreAlmostEqual(0, samples[i], "Complex: Zero Real Part"); + Assert.That(samples[i], NumericIs.AlmostEqualTo((double) 0), "Complex: Zero Real Part"); } } @@ -123,7 +123,7 @@ public static void ComplexTestImagZero(double[] samples) { for(int i = 1; i < samples.Length; i += 2) { - NumericAssert.AreAlmostEqual(0, samples[i], "Complex: Zero Imaginary Part"); + Assert.That(samples[i], NumericIs.AlmostEqualTo((double) 0), "Complex: Zero Imaginary Part"); } } #endregion @@ -166,17 +166,17 @@ public void Complex_Symmetry_RealEven_RealEven() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, data[0 * 2], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(-3.623, data[1 * 2], 0.001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(-0.31055, data[2 * 2], 0.0001, "MATLAB 3"); + Assert.That(data[0 * 2], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1"); + Assert.That(data[1 * 2], NumericIs.AlmostEqualTo(-3.623, 0.001), "MATLAB 2"); + Assert.That(data[2 * 2], NumericIs.AlmostEqualTo(-0.31055, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(-0.050611, data[6 * 2], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(-0.03882, data[7 * 2], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(-0.031248, data[8 * 2], 0.00001, "MATLAB 9"); + Assert.That(data[6 * 2], NumericIs.AlmostEqualTo(-0.050611, 0.00001), "MATLAB 7"); + Assert.That(data[7 * 2], NumericIs.AlmostEqualTo(-0.03882, 0.00001), "MATLAB 8"); + Assert.That(data[8 * 2], NumericIs.AlmostEqualTo(-0.031248, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(-0.017063, data[13 * 2], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(-0.016243, data[14 * 2], 0.00001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(-0.015777, data[15 * 2], 0.0001, "MATLAB 16"); + Assert.That(data[13 * 2], NumericIs.AlmostEqualTo(-0.017063, 0.0001), "MATLAB 14"); + Assert.That(data[14 * 2], NumericIs.AlmostEqualTo(-0.016243, 0.00001), "MATLAB 15"); + Assert.That(data[15 * 2], NumericIs.AlmostEqualTo(-0.015777, 0.0001), "MATLAB 16"); } [Test] @@ -209,17 +209,17 @@ public void Complex_Symmetry_ImaginaryEven_ImaginaryEven() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, data[(0 * 2) + 1], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(-3.623, data[(1 * 2) + 1], 0.001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(-0.31055, data[(2 * 2) + 1], 0.0001, "MATLAB 3"); + Assert.That(data[(0 * 2) + 1], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1"); + Assert.That(data[(1 * 2) + 1], NumericIs.AlmostEqualTo(-3.623, 0.001), "MATLAB 2"); + Assert.That(data[(2 * 2) + 1], NumericIs.AlmostEqualTo(-0.31055, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(-0.050611, data[(6 * 2) + 1], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(-0.03882, data[(7 * 2) + 1], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(-0.031248, data[(8 * 2) + 1], 0.00001, "MATLAB 9"); + Assert.That(data[(6 * 2) + 1], NumericIs.AlmostEqualTo(-0.050611, 0.00001), "MATLAB 7"); + Assert.That(data[(7 * 2) + 1], NumericIs.AlmostEqualTo(-0.03882, 0.00001), "MATLAB 8"); + Assert.That(data[(8 * 2) + 1], NumericIs.AlmostEqualTo(-0.031248, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(-0.017063, data[(13 * 2) + 1], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(-0.016243, data[(14 * 2) + 1], 0.00001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(-0.015777, data[(15 * 2) + 1], 0.0001, "MATLAB 16"); + Assert.That(data[(13 * 2) + 1], NumericIs.AlmostEqualTo(-0.017063, 0.0001), "MATLAB 14"); + Assert.That(data[(14 * 2) + 1], NumericIs.AlmostEqualTo(-0.016243, 0.00001), "MATLAB 15"); + Assert.That(data[(15 * 2) + 1], NumericIs.AlmostEqualTo(-0.015777, 0.0001), "MATLAB 16"); } [Test] @@ -255,17 +255,17 @@ public void Complex_Symmetry_RealOdd_ImaginaryEven() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(0, data[(0 * 2) + 1], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(7.4953, data[(1 * 2) + 1], 0.0001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(2.4733, data[(2 * 2) + 1], 0.0001, "MATLAB 3"); + Assert.That(data[(0 * 2) + 1], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 1"); + Assert.That(data[(1 * 2) + 1], NumericIs.AlmostEqualTo(7.4953, 0.0001), "MATLAB 2"); + Assert.That(data[(2 * 2) + 1], NumericIs.AlmostEqualTo(2.4733, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(0.75063, data[(6 * 2) + 1], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(0.61071, data[(7 * 2) + 1], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(0.50097, data[(8 * 2) + 1], 0.00001, "MATLAB 9"); + Assert.That(data[(6 * 2) + 1], NumericIs.AlmostEqualTo(0.75063, 0.00001), "MATLAB 7"); + Assert.That(data[(7 * 2) + 1], NumericIs.AlmostEqualTo(0.61071, 0.00001), "MATLAB 8"); + Assert.That(data[(8 * 2) + 1], NumericIs.AlmostEqualTo(0.50097, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(0.15183, data[(13 * 2) + 1], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(0.099557, data[(14 * 2) + 1], 0.00001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(0.049294, data[(15 * 2) + 1], 0.00001, "MATLAB 16"); + Assert.That(data[(13 * 2) + 1], NumericIs.AlmostEqualTo(0.15183, 0.0001), "MATLAB 14"); + Assert.That(data[(14 * 2) + 1], NumericIs.AlmostEqualTo(0.099557, 0.00001), "MATLAB 15"); + Assert.That(data[(15 * 2) + 1], NumericIs.AlmostEqualTo(0.049294, 0.00001), "MATLAB 16"); } [Test] @@ -301,17 +301,17 @@ public void Complex_Symmetry_ImaginaryOdd_RealEven() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(0, data[0 * 2], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(-7.4953, data[1 * 2], 0.0001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(-2.4733, data[2 * 2], 0.0001, "MATLAB 3"); + Assert.That(data[0 * 2], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 1"); + Assert.That(data[1 * 2], NumericIs.AlmostEqualTo(-7.4953, 0.0001), "MATLAB 2"); + Assert.That(data[2 * 2], NumericIs.AlmostEqualTo(-2.4733, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(-0.75063, data[6 * 2], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(-0.61071, data[7 * 2], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(-0.50097, data[8 * 2], 0.00001, "MATLAB 9"); + Assert.That(data[6 * 2], NumericIs.AlmostEqualTo(-0.75063, 0.00001), "MATLAB 7"); + Assert.That(data[7 * 2], NumericIs.AlmostEqualTo(-0.61071, 0.00001), "MATLAB 8"); + Assert.That(data[8 * 2], NumericIs.AlmostEqualTo(-0.50097, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(-0.15183, data[13 * 2], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(-0.099557, data[14 * 2], 0.00001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(-0.049294, data[15 * 2], 0.00001, "MATLAB 16"); + Assert.That(data[13 * 2], NumericIs.AlmostEqualTo(-0.15183, 0.0001), "MATLAB 14"); + Assert.That(data[14 * 2], NumericIs.AlmostEqualTo(-0.099557, 0.00001), "MATLAB 15"); + Assert.That(data[15 * 2], NumericIs.AlmostEqualTo(-0.049294, 0.00001), "MATLAB 16"); } [Test] @@ -343,25 +343,25 @@ public void Complex_Inverse_Mix() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, data[0 * 2], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(-11.118, data[1 * 2], 0.001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(-2.7838, data[2 * 2], 0.0001, "MATLAB 3"); + Assert.That(data[0 * 2], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1"); + Assert.That(data[1 * 2], NumericIs.AlmostEqualTo(-11.118, 0.001), "MATLAB 2"); + Assert.That(data[2 * 2], NumericIs.AlmostEqualTo(-2.7838, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(-0.80124, data[6 * 2], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(-0.64953, data[7 * 2], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(-0.53221, data[8 * 2], 0.00001, "MATLAB 9"); + Assert.That(data[6 * 2], NumericIs.AlmostEqualTo(-0.80124, 0.00001), "MATLAB 7"); + Assert.That(data[7 * 2], NumericIs.AlmostEqualTo(-0.64953, 0.00001), "MATLAB 8"); + Assert.That(data[8 * 2], NumericIs.AlmostEqualTo(-0.53221, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(-0.1689, data[13 * 2], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(-0.1158, data[14 * 2], 0.0001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(-0.065071, data[15 * 2], 0.00001, "MATLAB 16"); + Assert.That(data[13 * 2], NumericIs.AlmostEqualTo(-0.1689, 0.0001), "MATLAB 14"); + Assert.That(data[14 * 2], NumericIs.AlmostEqualTo(-0.1158, 0.0001), "MATLAB 15"); + Assert.That(data[15 * 2], NumericIs.AlmostEqualTo(-0.065071, 0.00001), "MATLAB 16"); - NumericAssert.AreAlmostEqual(0.18904, data[20 * 2], 0.0001, "MATLAB 21"); - NumericAssert.AreAlmostEqual(0.2475, data[21 * 2], 0.0001, "MATLAB 22"); - NumericAssert.AreAlmostEqual(0.31196, data[22 * 2], 0.00001, "MATLAB 23"); + Assert.That(data[20 * 2], NumericIs.AlmostEqualTo(0.18904, 0.0001), "MATLAB 21"); + Assert.That(data[21 * 2], NumericIs.AlmostEqualTo(0.2475, 0.0001), "MATLAB 22"); + Assert.That(data[22 * 2], NumericIs.AlmostEqualTo(0.31196, 0.00001), "MATLAB 23"); - NumericAssert.AreAlmostEqual(1.4812, data[29 * 2], 0.0001, "MATLAB 30"); - NumericAssert.AreAlmostEqual(2.1627, data[30 * 2], 0.0001, "MATLAB 31"); - NumericAssert.AreAlmostEqual(3.8723, data[31 * 2], 0.0001, "MATLAB 32"); + Assert.That(data[29 * 2], NumericIs.AlmostEqualTo(1.4812, 0.0001), "MATLAB 30"); + Assert.That(data[30 * 2], NumericIs.AlmostEqualTo(2.1627, 0.0001), "MATLAB 31"); + Assert.That(data[31 * 2], NumericIs.AlmostEqualTo(3.8723, 0.0001), "MATLAB 32"); cft.TransformBackward(data); @@ -369,8 +369,8 @@ public void Complex_Inverse_Mix() for(int i = 0; i < length; i += 2) { double z = (double)(i - numSamples) / numSamples; - NumericAssert.AreAlmostEqual(1.0 / ((z * z) + 1.0), data[i], 0.00001, "Inv: Real: " + i.ToString()); - NumericAssert.AreAlmostEqual(i == 0 ? 0.0 : z / ((z * z) + 1.0), data[i + 1], 0.00001, "Inv: Imag: " + i.ToString()); + Assert.That(data[i], NumericIs.AlmostEqualTo(1.0 / ((z * z) + 1.0), 0.00001), "Inv: Real: " + i.ToString()); + Assert.That(data[i + 1], NumericIs.AlmostEqualTo(i == 0 ? 0.0 : z / ((z * z) + 1.0), 0.00001), "Inv: Imag: " + i.ToString()); } } #endregion @@ -407,21 +407,21 @@ public void Real_TwoReal_EvenOdd() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, evenReal[0], 0.001, "MATLAB 1 (even)"); - NumericAssert.AreAlmostEqual(-3.623, evenReal[1], 0.001, "MATLAB 2 (even)"); - NumericAssert.AreAlmostEqual(-0.31055, evenReal[2], 0.0001, "MATLAB 3 (even)"); + Assert.That(evenReal[0], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1 (even)"); + Assert.That(evenReal[1], NumericIs.AlmostEqualTo(-3.623, 0.001), "MATLAB 2 (even)"); + Assert.That(evenReal[2], NumericIs.AlmostEqualTo(-0.31055, 0.0001), "MATLAB 3 (even)"); - NumericAssert.AreAlmostEqual(-0.050611, evenReal[6], 0.00001, "MATLAB 7 (even)"); - NumericAssert.AreAlmostEqual(-0.03882, evenReal[7], 0.00001, "MATLAB 8 (even)"); - NumericAssert.AreAlmostEqual(-0.031248, evenReal[8], 0.00001, "MATLAB 9 (even)"); + Assert.That(evenReal[6], NumericIs.AlmostEqualTo(-0.050611, 0.00001), "MATLAB 7 (even)"); + Assert.That(evenReal[7], NumericIs.AlmostEqualTo(-0.03882, 0.00001), "MATLAB 8 (even)"); + Assert.That(evenReal[8], NumericIs.AlmostEqualTo(-0.031248, 0.00001), "MATLAB 9 (even)"); - NumericAssert.AreAlmostEqual(-0.017063, evenReal[13], 0.0001, "MATLAB 14 (even)"); - NumericAssert.AreAlmostEqual(-0.016243, evenReal[14], 0.00001, "MATLAB 15 (even)"); - NumericAssert.AreAlmostEqual(-0.015777, evenReal[15], 0.0001, "MATLAB 16 (even)"); + Assert.That(evenReal[13], NumericIs.AlmostEqualTo(-0.017063, 0.0001), "MATLAB 14 (even)"); + Assert.That(evenReal[14], NumericIs.AlmostEqualTo(-0.016243, 0.00001), "MATLAB 15 (even)"); + Assert.That(evenReal[15], NumericIs.AlmostEqualTo(-0.015777, 0.0001), "MATLAB 16 (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[1], 0.001, "MATLAB 2i (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[7], 0.001, "MATLAB 8i (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[14], 0.001, "MATLAB 15i (even)"); + Assert.That(evenImag[1], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 2i (even)"); + Assert.That(evenImag[7], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 8i (even)"); + Assert.That(evenImag[14], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 15i (even)"); /* Compare ODD With MATLAB: samples_t = ([-16:1:15] ./ 16) ./ (([-16:1:15] ./ 16) .^ 2 + 1.0) @@ -429,21 +429,21 @@ public void Real_TwoReal_EvenOdd() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(0, oddImag[0], 0.001, "MATLAB 1 (odd)"); - NumericAssert.AreAlmostEqual(7.4953, oddImag[1], 0.0001, "MATLAB 2 (odd)"); - NumericAssert.AreAlmostEqual(2.4733, oddImag[2], 0.0001, "MATLAB 3 (odd)"); + Assert.That(oddImag[0], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 1 (odd)"); + Assert.That(oddImag[1], NumericIs.AlmostEqualTo(7.4953, 0.0001), "MATLAB 2 (odd)"); + Assert.That(oddImag[2], NumericIs.AlmostEqualTo(2.4733, 0.0001), "MATLAB 3 (odd)"); - NumericAssert.AreAlmostEqual(0.75063, oddImag[6], 0.00001, "MATLAB 7 (odd)"); - NumericAssert.AreAlmostEqual(0.61071, oddImag[7], 0.00001, "MATLAB 8 (odd)"); - NumericAssert.AreAlmostEqual(0.50097, oddImag[8], 0.00001, "MATLAB 9 (odd)"); + Assert.That(oddImag[6], NumericIs.AlmostEqualTo(0.75063, 0.00001), "MATLAB 7 (odd)"); + Assert.That(oddImag[7], NumericIs.AlmostEqualTo(0.61071, 0.00001), "MATLAB 8 (odd)"); + Assert.That(oddImag[8], NumericIs.AlmostEqualTo(0.50097, 0.00001), "MATLAB 9 (odd)"); - NumericAssert.AreAlmostEqual(0.15183, oddImag[13], 0.0001, "MATLAB 14 (odd)"); - NumericAssert.AreAlmostEqual(0.099557, oddImag[14], 0.00001, "MATLAB 15 (odd)"); - NumericAssert.AreAlmostEqual(0.049294, oddImag[15], 0.00001, "MATLAB 16 (odd)"); + Assert.That(oddImag[13], NumericIs.AlmostEqualTo(0.15183, 0.0001), "MATLAB 14 (odd)"); + Assert.That(oddImag[14], NumericIs.AlmostEqualTo(0.099557, 0.00001), "MATLAB 15 (odd)"); + Assert.That(oddImag[15], NumericIs.AlmostEqualTo(0.049294, 0.00001), "MATLAB 16 (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[1], 0.001, "MATLAB 2r (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[7], 0.001, "MATLAB 8r (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[14], 0.001, "MATLAB 15r (odd)"); + Assert.That(oddReal[1], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 2r (odd)"); + Assert.That(oddReal[7], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 8r (odd)"); + Assert.That(oddReal[14], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 15r (odd)"); } [Test] @@ -517,21 +517,21 @@ public void Real_SingleReal_EvenOdd() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, evenReal[0], 0.001, "MATLAB 1 (even)"); - NumericAssert.AreAlmostEqual(-3.623, evenReal[1], 0.001, "MATLAB 2 (even)"); - NumericAssert.AreAlmostEqual(-0.31055, evenReal[2], 0.0001, "MATLAB 3 (even)"); + Assert.That(evenReal[0], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1 (even)"); + Assert.That(evenReal[1], NumericIs.AlmostEqualTo(-3.623, 0.001), "MATLAB 2 (even)"); + Assert.That(evenReal[2], NumericIs.AlmostEqualTo(-0.31055, 0.0001), "MATLAB 3 (even)"); - NumericAssert.AreAlmostEqual(-0.050611, evenReal[6], 0.00001, "MATLAB 7 (even)"); - NumericAssert.AreAlmostEqual(-0.03882, evenReal[7], 0.00001, "MATLAB 8 (even)"); - NumericAssert.AreAlmostEqual(-0.031248, evenReal[8], 0.00001, "MATLAB 9 (even)"); + Assert.That(evenReal[6], NumericIs.AlmostEqualTo(-0.050611, 0.00001), "MATLAB 7 (even)"); + Assert.That(evenReal[7], NumericIs.AlmostEqualTo(-0.03882, 0.00001), "MATLAB 8 (even)"); + Assert.That(evenReal[8], NumericIs.AlmostEqualTo(-0.031248, 0.00001), "MATLAB 9 (even)"); - NumericAssert.AreAlmostEqual(-0.017063, evenReal[13], 0.0001, "MATLAB 14 (even)"); - NumericAssert.AreAlmostEqual(-0.016243, evenReal[14], 0.00001, "MATLAB 15 (even)"); - NumericAssert.AreAlmostEqual(-0.015777, evenReal[15], 0.0001, "MATLAB 16 (even)"); + Assert.That(evenReal[13], NumericIs.AlmostEqualTo(-0.017063, 0.0001), "MATLAB 14 (even)"); + Assert.That(evenReal[14], NumericIs.AlmostEqualTo(-0.016243, 0.00001), "MATLAB 15 (even)"); + Assert.That(evenReal[15], NumericIs.AlmostEqualTo(-0.015777, 0.0001), "MATLAB 16 (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[1], 0.001, "MATLAB 2i (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[7], 0.001, "MATLAB 8i (even)"); - NumericAssert.AreAlmostEqual(0, evenImag[14], 0.001, "MATLAB 15i (even)"); + Assert.That(evenImag[1], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 2i (even)"); + Assert.That(evenImag[7], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 8i (even)"); + Assert.That(evenImag[14], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 15i (even)"); /* Compare ODD With MATLAB: samples_t = ([-16:1:15] ./ 16) ./ (([-16:1:15] ./ 16) .^ 2 + 1.0) @@ -539,21 +539,21 @@ public void Real_SingleReal_EvenOdd() samples_f = fft(samples_t) */ - NumericAssert.AreAlmostEqual(0, oddImag[0], 0.001, "MATLAB 1 (odd)"); - NumericAssert.AreAlmostEqual(7.4953, oddImag[1], 0.0001, "MATLAB 2 (odd)"); - NumericAssert.AreAlmostEqual(2.4733, oddImag[2], 0.0001, "MATLAB 3 (odd)"); + Assert.That(oddImag[0], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 1 (odd)"); + Assert.That(oddImag[1], NumericIs.AlmostEqualTo(7.4953, 0.0001), "MATLAB 2 (odd)"); + Assert.That(oddImag[2], NumericIs.AlmostEqualTo(2.4733, 0.0001), "MATLAB 3 (odd)"); - NumericAssert.AreAlmostEqual(0.75063, oddImag[6], 0.00001, "MATLAB 7 (odd)"); - NumericAssert.AreAlmostEqual(0.61071, oddImag[7], 0.00001, "MATLAB 8 (odd)"); - NumericAssert.AreAlmostEqual(0.50097, oddImag[8], 0.00001, "MATLAB 9 (odd)"); + Assert.That(oddImag[6], NumericIs.AlmostEqualTo(0.75063, 0.00001), "MATLAB 7 (odd)"); + Assert.That(oddImag[7], NumericIs.AlmostEqualTo(0.61071, 0.00001), "MATLAB 8 (odd)"); + Assert.That(oddImag[8], NumericIs.AlmostEqualTo(0.50097, 0.00001), "MATLAB 9 (odd)"); - NumericAssert.AreAlmostEqual(0.15183, oddImag[13], 0.0001, "MATLAB 14 (odd)"); - NumericAssert.AreAlmostEqual(0.099557, oddImag[14], 0.00001, "MATLAB 15 (odd)"); - NumericAssert.AreAlmostEqual(0.049294, oddImag[15], 0.00001, "MATLAB 16 (odd)"); + Assert.That(oddImag[13], NumericIs.AlmostEqualTo(0.15183, 0.0001), "MATLAB 14 (odd)"); + Assert.That(oddImag[14], NumericIs.AlmostEqualTo(0.099557, 0.00001), "MATLAB 15 (odd)"); + Assert.That(oddImag[15], NumericIs.AlmostEqualTo(0.049294, 0.00001), "MATLAB 16 (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[1], 0.001, "MATLAB 2r (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[7], 0.001, "MATLAB 8r (odd)"); - NumericAssert.AreAlmostEqual(0, oddReal[14], 0.001, "MATLAB 15r (odd)"); + Assert.That(oddReal[1], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 2r (odd)"); + Assert.That(oddReal[7], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 8r (odd)"); + Assert.That(oddReal[14], NumericIs.AlmostEqualTo((double) 0, 0.001), "MATLAB 15r (odd)"); } [Test] @@ -636,25 +636,25 @@ public void Complex_MultiDim_1D_Inverse_Mix() samples_f = fftn(samples_t) */ - NumericAssert.AreAlmostEqual(25.128, data[0 * 2], 0.001, "MATLAB 1"); - NumericAssert.AreAlmostEqual(-11.118, data[1 * 2], 0.001, "MATLAB 2"); - NumericAssert.AreAlmostEqual(-2.7838, data[2 * 2], 0.0001, "MATLAB 3"); + Assert.That(data[0 * 2], NumericIs.AlmostEqualTo(25.128, 0.001), "MATLAB 1"); + Assert.That(data[1 * 2], NumericIs.AlmostEqualTo(-11.118, 0.001), "MATLAB 2"); + Assert.That(data[2 * 2], NumericIs.AlmostEqualTo(-2.7838, 0.0001), "MATLAB 3"); - NumericAssert.AreAlmostEqual(-0.80124, data[6 * 2], 0.00001, "MATLAB 7"); - NumericAssert.AreAlmostEqual(-0.64953, data[7 * 2], 0.00001, "MATLAB 8"); - NumericAssert.AreAlmostEqual(-0.53221, data[8 * 2], 0.00001, "MATLAB 9"); + Assert.That(data[6 * 2], NumericIs.AlmostEqualTo(-0.80124, 0.00001), "MATLAB 7"); + Assert.That(data[7 * 2], NumericIs.AlmostEqualTo(-0.64953, 0.00001), "MATLAB 8"); + Assert.That(data[8 * 2], NumericIs.AlmostEqualTo(-0.53221, 0.00001), "MATLAB 9"); - NumericAssert.AreAlmostEqual(-0.1689, data[13 * 2], 0.0001, "MATLAB 14"); - NumericAssert.AreAlmostEqual(-0.1158, data[14 * 2], 0.0001, "MATLAB 15"); - NumericAssert.AreAlmostEqual(-0.065071, data[15 * 2], 0.00001, "MATLAB 16"); + Assert.That(data[13 * 2], NumericIs.AlmostEqualTo(-0.1689, 0.0001), "MATLAB 14"); + Assert.That(data[14 * 2], NumericIs.AlmostEqualTo(-0.1158, 0.0001), "MATLAB 15"); + Assert.That(data[15 * 2], NumericIs.AlmostEqualTo(-0.065071, 0.00001), "MATLAB 16"); - NumericAssert.AreAlmostEqual(0.18904, data[20 * 2], 0.0001, "MATLAB 21"); - NumericAssert.AreAlmostEqual(0.2475, data[21 * 2], 0.0001, "MATLAB 22"); - NumericAssert.AreAlmostEqual(0.31196, data[22 * 2], 0.00001, "MATLAB 23"); + Assert.That(data[20 * 2], NumericIs.AlmostEqualTo(0.18904, 0.0001), "MATLAB 21"); + Assert.That(data[21 * 2], NumericIs.AlmostEqualTo(0.2475, 0.0001), "MATLAB 22"); + Assert.That(data[22 * 2], NumericIs.AlmostEqualTo(0.31196, 0.00001), "MATLAB 23"); - NumericAssert.AreAlmostEqual(1.4812, data[29 * 2], 0.0001, "MATLAB 30"); - NumericAssert.AreAlmostEqual(2.1627, data[30 * 2], 0.0001, "MATLAB 31"); - NumericAssert.AreAlmostEqual(3.8723, data[31 * 2], 0.0001, "MATLAB 32"); + Assert.That(data[29 * 2], NumericIs.AlmostEqualTo(1.4812, 0.0001), "MATLAB 30"); + Assert.That(data[30 * 2], NumericIs.AlmostEqualTo(2.1627, 0.0001), "MATLAB 31"); + Assert.That(data[31 * 2], NumericIs.AlmostEqualTo(3.8723, 0.0001), "MATLAB 32"); cft.TransformBackward(data, dims); @@ -745,50 +745,50 @@ public void Complex_MultiDim_3D_Inverse_Mix() H2 = reshape(H(2,:,:),[4,8]) */ - NumericAssert.AreAlmostEqual(4032, data[0 * 2], "MATLAB 1"); - NumericAssert.AreAlmostEqual(0, data[(0 * 2) + 1], "MATLAB 1b"); + Assert.That(data[0 * 2], NumericIs.AlmostEqualTo((double) 4032), "MATLAB 1"); + Assert.That(data[(0 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 1b"); - NumericAssert.AreAlmostEqual(-64, data[1 * 2], "MATLAB 2"); - NumericAssert.AreAlmostEqual(154.51, data[(1 * 2) + 1], 1e-5, "MATLAB 2b"); - NumericAssert.AreAlmostEqual(-64, data[2 * 2], "MATLAB 3"); - NumericAssert.AreAlmostEqual(64, data[(2 * 2) + 1], "MATLAB 3b"); - NumericAssert.AreAlmostEqual(-64, data[6 * 2], "MATLAB 7"); - NumericAssert.AreAlmostEqual(-64, data[(6 * 2) + 1], "MATLAB 7b"); - NumericAssert.AreAlmostEqual(-64, data[7 * 2], "MATLAB 8"); - NumericAssert.AreAlmostEqual(-154.51, data[(7 * 2) + 1], 1e-5, "MATLAB 8b"); + Assert.That(data[1 * 2], NumericIs.AlmostEqualTo((double) (-64)), "MATLAB 2"); + Assert.That(data[(1 * 2) + 1], NumericIs.AlmostEqualTo(154.51, 1e-5), "MATLAB 2b"); + Assert.That(data[2 * 2], NumericIs.AlmostEqualTo((double) (-64)), "MATLAB 3"); + Assert.That(data[(2 * 2) + 1], NumericIs.AlmostEqualTo((double) 64), "MATLAB 3b"); + Assert.That(data[6 * 2], NumericIs.AlmostEqualTo((double) (-64)), "MATLAB 7"); + Assert.That(data[(6 * 2) + 1], NumericIs.AlmostEqualTo((double) (-64)), "MATLAB 7b"); + Assert.That(data[7 * 2], NumericIs.AlmostEqualTo((double) (-64)), "MATLAB 8"); + Assert.That(data[(7 * 2) + 1], NumericIs.AlmostEqualTo(-154.51, 1e-5), "MATLAB 8b"); - NumericAssert.AreAlmostEqual(-512, data[8 * 2], "MATLAB 9"); - NumericAssert.AreAlmostEqual(512, data[(8 * 2) + 1], "MATLAB 9b"); + Assert.That(data[8 * 2], NumericIs.AlmostEqualTo((double) (-512)), "MATLAB 9"); + Assert.That(data[(8 * 2) + 1], NumericIs.AlmostEqualTo((double) 512), "MATLAB 9b"); - NumericAssert.AreAlmostEqual(0, data[9 * 2], "MATLAB 10"); - NumericAssert.AreAlmostEqual(0, data[(9 * 2) + 1], "MATLAB 10b"); - NumericAssert.AreAlmostEqual(0, data[15 * 2], "MATLAB 16"); - NumericAssert.AreAlmostEqual(0, data[(15 * 2) + 1], "MATLAB 16b"); + Assert.That(data[9 * 2], NumericIs.AlmostEqualTo((double) 0), "MATLAB 10"); + Assert.That(data[(9 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 10b"); + Assert.That(data[15 * 2], NumericIs.AlmostEqualTo((double) 0), "MATLAB 16"); + Assert.That(data[(15 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 16b"); - NumericAssert.AreAlmostEqual(-512, data[16 * 2], "MATLAB 17"); - NumericAssert.AreAlmostEqual(0, data[(16 * 2) + 1], "MATLAB 17b"); + Assert.That(data[16 * 2], NumericIs.AlmostEqualTo((double) (-512)), "MATLAB 17"); + Assert.That(data[(16 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 17b"); - NumericAssert.AreAlmostEqual(-512, data[24 * 2], "MATLAB 25"); - NumericAssert.AreAlmostEqual(-512, data[(24 * 2) + 1], "MATLAB 25b"); + Assert.That(data[24 * 2], NumericIs.AlmostEqualTo((double) (-512)), "MATLAB 25"); + Assert.That(data[(24 * 2) + 1], NumericIs.AlmostEqualTo((double) (-512)), "MATLAB 25b"); - NumericAssert.AreAlmostEqual(-2048, data[32 * 2], "MATLAB 33"); - NumericAssert.AreAlmostEqual(0, data[(32 * 2) + 1], "MATLAB 33b"); + Assert.That(data[32 * 2], NumericIs.AlmostEqualTo((double) (-2048)), "MATLAB 33"); + Assert.That(data[(32 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 33b"); - NumericAssert.AreAlmostEqual(0, data[33 * 2], "MATLAB 34"); - NumericAssert.AreAlmostEqual(0, data[(33 * 2) + 1], "MATLAB 34b"); - NumericAssert.AreAlmostEqual(0, data[39 * 2], "MATLAB 40"); - NumericAssert.AreAlmostEqual(0, data[(39 * 2) + 1], "MATLAB 40b"); + Assert.That(data[33 * 2], NumericIs.AlmostEqualTo((double) 0), "MATLAB 34"); + Assert.That(data[(33 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 34b"); + Assert.That(data[39 * 2], NumericIs.AlmostEqualTo((double) 0), "MATLAB 40"); + Assert.That(data[(39 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 40b"); - NumericAssert.AreAlmostEqual(0, data[56 * 2], "MATLAB 57"); - NumericAssert.AreAlmostEqual(0, data[(56 * 2) + 1], "MATLAB 57b"); + Assert.That(data[56 * 2], NumericIs.AlmostEqualTo((double) 0), "MATLAB 57"); + Assert.That(data[(56 * 2) + 1], NumericIs.AlmostEqualTo((double) 0), "MATLAB 57b"); cft.TransformBackward(data, dims); // Compare with original samples for(int i = 0; i < len; i += 2) { - NumericAssert.AreAlmostEqual((double)i, data[i], "Inv: Real: " + i.ToString()); - NumericAssert.AreAlmostEqual(0d, data[i + 1], "Inv: Imag: " + i.ToString()); + Assert.That(data[i], NumericIs.AlmostEqualTo((double)i), "Inv: Real: " + i.ToString()); + Assert.That(data[i + 1], NumericIs.AlmostEqualTo(0d), "Inv: Imag: " + i.ToString()); } } #endregion @@ -827,7 +827,7 @@ public void Stress_SingleReal_1024() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -865,7 +865,7 @@ public void Stress_SingleReal_4096() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -903,7 +903,7 @@ public void Stress_SingleReal_8192() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -941,7 +941,7 @@ public void Stress_SingleReal_16384() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -979,7 +979,7 @@ public void Stress_SingleReal_65536() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -1017,7 +1017,7 @@ public void Stress_SingleReal_262144() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } } @@ -1055,7 +1055,7 @@ public void Stress_SingleReal_1048576() // Compare with original samples for(int i = 0; i < numSamples; i += 2) { - NumericAssert.AreAlmostEqual(dataEven[i], dataEven2[i], 0.00001, "Inv: " + i.ToString()); + Assert.That(dataEven2[i], NumericIs.AlmostEqualTo(dataEven[i], 0.00001), "Inv: " + i.ToString()); } }