forked from tsai/mathnet-numerics
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1284 lines
59 KiB
1284 lines
59 KiB
// <copyright file="PrecisionTest.cs" company="Math.NET">
|
|
// Math.NET Numerics, part of the Math.NET Project
|
|
// http://numerics.mathdotnet.com
|
|
// http://github.com/mathnet/mathnet-numerics
|
|
//
|
|
// Copyright (c) 2009-2016 Math.NET
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person
|
|
// obtaining a copy of this software and associated documentation
|
|
// files (the "Software"), to deal in the Software without
|
|
// restriction, including without limitation the rights to use,
|
|
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following
|
|
// conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
// OTHER DEALINGS IN THE SOFTWARE.
|
|
// </copyright>
|
|
|
|
using System;
|
|
using System.Numerics;
|
|
using NUnit.Framework;
|
|
|
|
namespace MathNet.Numerics.UnitTests
|
|
{
|
|
/// <summary>
|
|
/// Precision tests.
|
|
/// </summary>
|
|
[TestFixture]
|
|
public sealed class PrecisionTest
|
|
{
|
|
/// <summary>
|
|
/// Double precision.
|
|
/// </summary>
|
|
private readonly double _doublePrecision = Math.Pow(2, -53);
|
|
|
|
/// <summary>
|
|
/// Magnitude tests.
|
|
/// </summary>
|
|
[Test]
|
|
public void Magnitude()
|
|
{
|
|
Assert.AreEqual(0, Precision.Magnitude(0));
|
|
|
|
Assert.AreEqual(0, Precision.Magnitude(1));
|
|
Assert.AreEqual(1, Precision.Magnitude(10));
|
|
Assert.AreEqual(2, Precision.Magnitude(100));
|
|
Assert.AreEqual(3, Precision.Magnitude(1000));
|
|
Assert.AreEqual(4, Precision.Magnitude(10000));
|
|
Assert.AreEqual(5, Precision.Magnitude(100000));
|
|
Assert.AreEqual(6, Precision.Magnitude(1000000));
|
|
|
|
Assert.AreEqual(7, 1e7.Magnitude());
|
|
Assert.AreEqual(8, 1e8.Magnitude());
|
|
Assert.AreEqual(9, 1e9.Magnitude());
|
|
Assert.AreEqual(10, 1e10.Magnitude());
|
|
Assert.AreEqual(11, 1e11.Magnitude());
|
|
Assert.AreEqual(12, 1e12.Magnitude());
|
|
|
|
Assert.AreEqual(-7, 1e-7.Magnitude());
|
|
Assert.AreEqual(-8, 1e-8.Magnitude());
|
|
Assert.AreEqual(-9, 1e-9.Magnitude());
|
|
Assert.AreEqual(-10, 1e-10.Magnitude());
|
|
Assert.AreEqual(-11, 1e-11.Magnitude());
|
|
Assert.AreEqual(-12, 1e-12.Magnitude());
|
|
|
|
Assert.AreEqual(5, 1.1e5.Magnitude());
|
|
Assert.AreEqual(-5, 2.2e-5.Magnitude());
|
|
Assert.AreEqual(9, 3.3e9.Magnitude());
|
|
Assert.AreEqual(-11, 4.4e-11.Magnitude());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Magnitude with negative values.
|
|
/// </summary>
|
|
[Test]
|
|
public void MagnitudeWithNegativeValues()
|
|
{
|
|
Assert.AreEqual(0, Precision.Magnitude(-1));
|
|
Assert.AreEqual(1, Precision.Magnitude(-10));
|
|
Assert.AreEqual(2, Precision.Magnitude(-100));
|
|
Assert.AreEqual(3, Precision.Magnitude(-1000));
|
|
Assert.AreEqual(4, Precision.Magnitude(-10000));
|
|
Assert.AreEqual(5, Precision.Magnitude(-100000));
|
|
Assert.AreEqual(6, Precision.Magnitude(-1000000));
|
|
|
|
Assert.AreEqual(7, (-1e7).Magnitude());
|
|
Assert.AreEqual(8, (-1e8).Magnitude());
|
|
Assert.AreEqual(9, (-1e9).Magnitude());
|
|
Assert.AreEqual(10, (-1e10).Magnitude());
|
|
Assert.AreEqual(11, (-1e11).Magnitude());
|
|
Assert.AreEqual(12, (-1e12).Magnitude());
|
|
|
|
Assert.AreEqual(-7, (-1e-7).Magnitude());
|
|
Assert.AreEqual(-8, (-1e-8).Magnitude());
|
|
Assert.AreEqual(-9, (-1e-9).Magnitude());
|
|
Assert.AreEqual(-10, (-1e-10).Magnitude());
|
|
Assert.AreEqual(-11, (-1e-11).Magnitude());
|
|
Assert.AreEqual(-12, (-1e-12).Magnitude());
|
|
|
|
Assert.AreEqual(5, (-1.1e5).Magnitude());
|
|
Assert.AreEqual(-5, (-2.2e-5).Magnitude());
|
|
Assert.AreEqual(9, (-3.3e9).Magnitude());
|
|
Assert.AreEqual(-11, (-4.4e-11).Magnitude());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get magnitude scaled value.
|
|
/// </summary>
|
|
[Test]
|
|
public void ScaleUnitMagnitude()
|
|
{
|
|
Assert.AreEqual(0, Precision.ScaleUnitMagnitude(0), 1e-12);
|
|
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(10), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(100), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1000), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(10000), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(100000), 1e-12);
|
|
Assert.AreEqual(1, Precision.ScaleUnitMagnitude(1000000), 1e-12);
|
|
|
|
Assert.AreEqual(1.1, 1.1e5.ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(2.2, 2.2e-5.ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(3.3, 3.3e9.ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(4.4, 4.4e-11.ScaleUnitMagnitude(), 1e-12);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Can get magnitude scaled value with a negative values.
|
|
/// </summary>
|
|
[Test]
|
|
public void ScaleUnitMagnitudeWithNegativeValues()
|
|
{
|
|
Assert.AreEqual(0, Precision.ScaleUnitMagnitude(0), 1e-12);
|
|
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-10), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-100), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1000), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-10000), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-100000), 1e-12);
|
|
Assert.AreEqual(-1, Precision.ScaleUnitMagnitude(-1000000), 1e-12);
|
|
|
|
Assert.AreEqual(-1.1, (-1.1e5).ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(-2.2, (-2.2e-5).ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(-3.3, (-3.3e9).ScaleUnitMagnitude(), 1e-12);
|
|
Assert.AreEqual(-4.4, (-4.4e-11).ScaleUnitMagnitude(), 1e-12);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Increment at zero.
|
|
/// </summary>
|
|
[Test]
|
|
public void IncrementAtZero()
|
|
{
|
|
var x = -2 * double.Epsilon;
|
|
Assert.AreEqual(-2 * double.Epsilon, x);
|
|
x = x.Increment();
|
|
x = x.Increment();
|
|
Assert.AreEqual(0.0, x);
|
|
x = x.Increment();
|
|
x = x.Increment();
|
|
Assert.AreEqual(2 * double.Epsilon, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrement at zero.
|
|
/// </summary>
|
|
[Test]
|
|
public void DecrementAtZero()
|
|
{
|
|
var x = 2 * double.Epsilon;
|
|
Assert.AreEqual(2 * double.Epsilon, x);
|
|
x = x.Decrement();
|
|
x = x.Decrement();
|
|
Assert.AreEqual(0.0, x);
|
|
x = x.Decrement();
|
|
x = x.Decrement();
|
|
Assert.AreEqual(-2 * double.Epsilon, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Increment at min/max.
|
|
/// </summary>
|
|
[Test]
|
|
public void IncrementAtMinMax()
|
|
{
|
|
var x = double.MaxValue;
|
|
x = x.Increment();
|
|
Assert.AreEqual(double.PositiveInfinity, x);
|
|
|
|
x = double.MinValue;
|
|
Assert.AreEqual(double.MinValue, x);
|
|
x = x.Increment();
|
|
Assert.Greater(x, double.MinValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrement at min/max.
|
|
/// </summary>
|
|
[Test]
|
|
public void DecrementAtMinMax()
|
|
{
|
|
var x = double.MaxValue;
|
|
Assert.AreEqual(double.MaxValue, x);
|
|
x = x.Decrement();
|
|
Assert.Greater(double.MaxValue, x);
|
|
|
|
x = double.MinValue;
|
|
Assert.AreEqual(double.MinValue, x);
|
|
x = x.Decrement();
|
|
Assert.AreEqual(double.NegativeInfinity, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coerce zero.
|
|
/// </summary>
|
|
[Test]
|
|
public void CoerceZero()
|
|
{
|
|
Assert.AreEqual(0.0, 0d.CoerceZero());
|
|
Assert.AreEqual(0.0, 0.0.Increment().CoerceZero());
|
|
Assert.AreEqual(0.0, 0.0.Decrement().CoerceZero());
|
|
|
|
Assert.AreEqual(1.0, 1d.CoerceZero());
|
|
Assert.AreEqual(-1.0, (-1d).CoerceZero());
|
|
Assert.AreEqual(0.5, 0.5d.CoerceZero());
|
|
Assert.AreEqual(-0.5, (-0.5d).CoerceZero());
|
|
|
|
Assert.AreEqual(double.PositiveInfinity, double.PositiveInfinity.CoerceZero());
|
|
Assert.AreEqual(double.NegativeInfinity, double.NegativeInfinity.CoerceZero());
|
|
Assert.AreEqual(double.MaxValue, double.MaxValue.CoerceZero());
|
|
Assert.AreEqual(double.MinValue, double.MinValue.CoerceZero());
|
|
Assert.AreEqual(double.NaN, double.NaN.CoerceZero());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coerce zero based on max numbers between.
|
|
/// </summary>
|
|
[Test]
|
|
public void CoerceZeroNumbersBetween()
|
|
{
|
|
Assert.AreEqual(0.0, (5 * double.Epsilon).CoerceZero(5));
|
|
Assert.AreEqual(0.0, (-5 * double.Epsilon).CoerceZero(5));
|
|
|
|
Assert.AreNotEqual(0.0, (5 * double.Epsilon).CoerceZero(4));
|
|
Assert.AreNotEqual(0.0, (-5 * double.Epsilon).CoerceZero(4));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coerce zero based on relative tolerance.
|
|
/// </summary>
|
|
[Test]
|
|
public void CoerceZeroRelativeTolerance()
|
|
{
|
|
Assert.AreEqual(0.0, 1e-6.CoerceZero(1e-5));
|
|
Assert.AreEqual(0.0, (-1e-6).CoerceZero(1e-5));
|
|
Assert.AreEqual(0.0, 1e+4.CoerceZero(1e+5));
|
|
Assert.AreEqual(0.0, (-1e+4).CoerceZero(1e+5));
|
|
|
|
Assert.AreNotEqual(0.0, 1e-4.CoerceZero(1e-5));
|
|
Assert.AreNotEqual(0.0, 1e-5.CoerceZero(1e-5));
|
|
Assert.AreNotEqual(0.0, (-1e-4).CoerceZero(1e-5));
|
|
Assert.AreNotEqual(0.0, (-1e-5).CoerceZero(1e-5));
|
|
Assert.AreNotEqual(0.0, 1e+6.CoerceZero(1e+5));
|
|
Assert.AreNotEqual(0.0, 1e+5.CoerceZero(1e+5));
|
|
Assert.AreNotEqual(0.0, (-1e+6).CoerceZero(1e+5));
|
|
Assert.AreNotEqual(0.0, (-1e+5).CoerceZero(1e+5));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching floating point numbers with negative Ulps.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingFloatingPointNumbersWithNegativeUlps()
|
|
{
|
|
Assert.That(() => Precision.RangeOfMatchingFloatingPointNumbers(10, -1), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching floating point numbers with value at infinity.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingFloatingPointNumbersWithValueAtInfinity()
|
|
{
|
|
var minmax = double.PositiveInfinity.RangeOfMatchingFloatingPointNumbers(1);
|
|
Assert.AreEqual(double.PositiveInfinity, minmax.Item1);
|
|
Assert.AreEqual(double.PositiveInfinity, minmax.Item2);
|
|
|
|
minmax = double.NegativeInfinity.RangeOfMatchingFloatingPointNumbers(1);
|
|
Assert.AreEqual(double.NegativeInfinity, minmax.Item1);
|
|
Assert.AreEqual(double.NegativeInfinity, minmax.Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching floating point numbers with value at NaN.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingFloatingPointNumbersWithValueAtNaN()
|
|
{
|
|
var minmax = double.NaN.RangeOfMatchingFloatingPointNumbers(1);
|
|
Assert.IsTrue(double.IsNaN(minmax.Item1));
|
|
Assert.IsTrue(double.IsNaN(minmax.Item2));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching floating point numbers with positive value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
/// <remarks>Numbers are calculated with the UlpsCalculator program which can be found in UlpsCalculator.cs</remarks>
|
|
[TestCase(0, -10 * double.Epsilon, 10 * double.Epsilon)]
|
|
[TestCase(1.0, 0.99999999999999889, 1.0000000000000022)]
|
|
[TestCase(2.0, 1.9999999999999978, 2.0000000000000044)]
|
|
[TestCase(3.0, 2.9999999999999956, 3.0000000000000044)]
|
|
[TestCase(4.0, 3.9999999999999956, 4.0000000000000089)]
|
|
[TestCase(5.0, 4.9999999999999911, 5.0000000000000089)]
|
|
[TestCase(6.0, 5.9999999999999911, 6.0000000000000089)]
|
|
[TestCase(7.0, 6.9999999999999911, 7.0000000000000089)]
|
|
[TestCase(8.0, 7.9999999999999911, 8.0000000000000178)]
|
|
public void RangeOfMatchingFloatingPointNumbersWithPositiveValue(double input, double expectedMin, double expectedMax)
|
|
{
|
|
var minmax = input.RangeOfMatchingFloatingPointNumbers(10);
|
|
Assert.AreEqual(expectedMin, minmax.Item1);
|
|
Assert.AreEqual(expectedMax, minmax.Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching floating point numbers with negative value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
/// <remarks>Numbers are calculated with the UlpsCalculator program which can be found in UlpsCalculator.cs</remarks>
|
|
[TestCase(0, -10 * double.Epsilon, 10 * double.Epsilon)]
|
|
[TestCase(-1.0, -1.0000000000000022, -0.99999999999999889)]
|
|
[TestCase(-2.0, -2.0000000000000044, -1.9999999999999978)]
|
|
[TestCase(-3.0, -3.0000000000000044, -2.9999999999999956)]
|
|
[TestCase(-4.0, -4.0000000000000089, -3.9999999999999956)]
|
|
[TestCase(-5.0, -5.0000000000000089, -4.9999999999999911)]
|
|
[TestCase(-6.0, -6.0000000000000089, -5.9999999999999911)]
|
|
[TestCase(-7.0, -7.0000000000000089, -6.9999999999999911)]
|
|
[TestCase(-8.0, -8.0000000000000178, -7.9999999999999911)]
|
|
public void RangeOfMatchingFloatingPointNumbersWithNegativeValue(double input, double expectedMin, double expectedMax)
|
|
{
|
|
var minmax = input.RangeOfMatchingFloatingPointNumbers(10);
|
|
Assert.AreEqual(expectedMin, minmax.Item1);
|
|
Assert.AreEqual(expectedMax, minmax.Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum matching floating point number with positive value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
[TestCase(0, 10 * double.Epsilon)]
|
|
[TestCase(1.0, 1.0000000000000022)]
|
|
[TestCase(2.0, 2.0000000000000044)]
|
|
[TestCase(3.0, 3.0000000000000044)]
|
|
[TestCase(4.0, 4.0000000000000089)]
|
|
[TestCase(5.0, 5.0000000000000089)]
|
|
[TestCase(6.0, 6.0000000000000089)]
|
|
[TestCase(7.0, 7.0000000000000089)]
|
|
[TestCase(8.0, 8.0000000000000178)]
|
|
public void MaximumMatchingFloatingPointNumberWithPositiveValue(double input, double expectedMax)
|
|
{
|
|
var max = input.MaximumMatchingFloatingPointNumber(10);
|
|
Assert.AreEqual(expectedMax, max);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum matching floating point number with negative value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
[TestCase(0, 10 * double.Epsilon)]
|
|
[TestCase(-1.0, -0.99999999999999889)]
|
|
[TestCase(-2.0, -1.9999999999999978)]
|
|
[TestCase(-3.0, -2.9999999999999956)]
|
|
[TestCase(-4.0, -3.9999999999999956)]
|
|
[TestCase(-5.0, -4.9999999999999911)]
|
|
[TestCase(-6.0, -5.9999999999999911)]
|
|
[TestCase(-7.0, -6.9999999999999911)]
|
|
[TestCase(-8.0, -7.9999999999999911)]
|
|
public void MaximumMatchingFloatingPointNumberWithNegativeValue(double input, double expectedMax)
|
|
{
|
|
var max = input.MaximumMatchingFloatingPointNumber(10);
|
|
Assert.AreEqual(expectedMax, max);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Minimum matching floating point number with positive value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
[TestCase(0, -10 * double.Epsilon)]
|
|
[TestCase(1.0, 0.99999999999999889)]
|
|
[TestCase(2.0, 1.9999999999999978)]
|
|
[TestCase(3.0, 2.9999999999999956)]
|
|
[TestCase(4.0, 3.9999999999999956)]
|
|
[TestCase(5.0, 4.9999999999999911)]
|
|
[TestCase(6.0, 5.9999999999999911)]
|
|
[TestCase(7.0, 6.9999999999999911)]
|
|
[TestCase(8.0, 7.9999999999999911)]
|
|
public void MinimumMatchingFloatingPointNumberWithPositiveValue(double input, double expectedMin)
|
|
{
|
|
var min = input.MinimumMatchingFloatingPointNumber(10);
|
|
Assert.AreEqual(expectedMin, min);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Minimum matching floating point number with negative value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
[TestCase(0, -10 * double.Epsilon)]
|
|
[TestCase(-1.0, -1.0000000000000022)]
|
|
[TestCase(-2.0, -2.0000000000000044)]
|
|
[TestCase(-3.0, -3.0000000000000044)]
|
|
[TestCase(-4.0, -4.0000000000000089)]
|
|
[TestCase(-5.0, -5.0000000000000089)]
|
|
[TestCase(-6.0, -6.0000000000000089)]
|
|
[TestCase(-7.0, -7.0000000000000089)]
|
|
[TestCase(-8.0, -8.0000000000000178)]
|
|
public void MinimumMatchingFloatingPointNumberWithNegativeValue(double input, double expectedMin)
|
|
{
|
|
var min = input.MinimumMatchingFloatingPointNumber(10);
|
|
Assert.AreEqual(expectedMin, min);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching Ulps with negative relative difference throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingUlpsWithNegativeRelativeDifferenceThrows()
|
|
{
|
|
Assert.That(() => 1d.RangeOfMatchingNumbers(-1d), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching Ulps with value at infinity throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingUlpsWithValueAtInfinityThrows()
|
|
{
|
|
Assert.That(() => double.PositiveInfinity.RangeOfMatchingNumbers(-1d), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching Ulps with value at Nan throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void RangeOfMatchingUlpsWithValueAtNaNThrows()
|
|
{
|
|
Assert.That(() => double.NaN.RangeOfMatchingNumbers(-1d), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching Ulps with positive value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="relativeDifference">Relative difference value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
[TestCase(0, 10 * double.Epsilon, 10, 10)]
|
|
[TestCase(1.0, (1.0000000000000022 - 1.0) / 1.0, 20, 10)]
|
|
[TestCase(2.0, (2.0000000000000044 - 2.0) / 2.0, 20, 10)]
|
|
[TestCase(3.0, (3.0000000000000044 - 3.0) / 3.0, 10, 10)]
|
|
[TestCase(4.0, (4.0000000000000089 - 4.0) / 4.0, 20, 10)]
|
|
[TestCase(5.0, (5.0000000000000089 - 5.0) / 5.0, 10, 10)]
|
|
[TestCase(6.0, (6.0000000000000089 - 6.0) / 6.0, 10, 10)]
|
|
[TestCase(7.0, (7.0000000000000089 - 7.0) / 7.0, 10, 10)]
|
|
[TestCase(8.0, (8.0000000000000178 - 8.0) / 8.0, 20, 10)]
|
|
public void RangeOfMatchingUlpsWithPositiveValue(double input, double relativeDifference, long expectedMin, long expectedMax)
|
|
{
|
|
var minmax = input.RangeOfMatchingNumbers(relativeDifference);
|
|
Assert.AreEqual(expectedMin, minmax.Item1);
|
|
Assert.AreEqual(expectedMax, minmax.Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Range of matching Ulps with negative value.
|
|
/// </summary>
|
|
/// <param name="input">Input value.</param>
|
|
/// <param name="relativeDifference">Relative difference value.</param>
|
|
/// <param name="expectedMin">Expected minimum.</param>
|
|
/// <param name="expectedMax">Expected maximum.</param>
|
|
[TestCase(0, 10 * double.Epsilon, 10, 10)]
|
|
[TestCase(-1.0, (1.0000000000000022 - 1.0) / 1.0, 10, 20)]
|
|
[TestCase(-2.0, (2.0000000000000044 - 2.0) / 2.0, 10, 20)]
|
|
[TestCase(-3.0, (3.0000000000000044 - 3.0) / 3.0, 10, 10)]
|
|
[TestCase(-4.0, (4.0000000000000089 - 4.0) / 4.0, 10, 20)]
|
|
[TestCase(-5.0, (5.0000000000000089 - 5.0) / 5.0, 10, 10)]
|
|
[TestCase(-6.0, (6.0000000000000089 - 6.0) / 6.0, 10, 10)]
|
|
[TestCase(-7.0, (7.0000000000000089 - 7.0) / 7.0, 10, 10)]
|
|
[TestCase(-8.0, (8.0000000000000178 - 8.0) / 8.0, 10, 20)]
|
|
public void RangeOfMatchingUlpsWithNegativeValue(double input, double relativeDifference, long expectedMin, long expectedMax)
|
|
{
|
|
var minmax = input.RangeOfMatchingNumbers(relativeDifference);
|
|
Assert.AreEqual(expectedMin, minmax.Item1);
|
|
Assert.AreEqual(expectedMax, minmax.Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test numbers between.
|
|
/// </summary>
|
|
[Test]
|
|
public void NumbersBetween()
|
|
{
|
|
Assert.AreEqual(0, 1.0.NumbersBetween(1.0));
|
|
Assert.AreEqual(0, Precision.NumbersBetween(0, 0));
|
|
Assert.AreEqual(0, (-1.0).NumbersBetween(-1.0));
|
|
|
|
Assert.AreEqual(1, Precision.NumbersBetween(0, double.Epsilon));
|
|
Assert.AreEqual(1, Precision.NumbersBetween(0, -double.Epsilon));
|
|
Assert.AreEqual(1, double.Epsilon.NumbersBetween(0));
|
|
Assert.AreEqual(1, (-double.Epsilon).NumbersBetween(0));
|
|
|
|
Assert.AreEqual(2, Precision.NumbersBetween(0, 2 * double.Epsilon));
|
|
Assert.AreEqual(2, Precision.NumbersBetween(0, -2 * double.Epsilon));
|
|
|
|
Assert.AreEqual(3, (-double.Epsilon).NumbersBetween(2 * double.Epsilon));
|
|
Assert.AreEqual(3, double.Epsilon.NumbersBetween(-2 * double.Epsilon));
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>AlmostEqual</c> with max numbers between with less than one number throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void AlmostEqualWithMaxNumbersBetweenWithLessThanOneNumberThrows()
|
|
{
|
|
Assert.That(() => Precision.AlmostEqualNumbersBetween(1, 2, 0), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
[Test]
|
|
public void AlmostEqual()
|
|
{
|
|
Assert.That(1.0.AlmostEqual(1.0), "1.0 equals 1.0.");
|
|
Assert.That(1.0.AlmostEqual(1.0 + _doublePrecision), "1.0 equals 1.0 + 2^(-53).");
|
|
Assert.That(1.0.AlmostEqual(1.0 + (_doublePrecision * 5)), "1.0 equals 1.0 + 5*2^(-53).");
|
|
Assert.That(!1.0.AlmostEqual(1.0 + (_doublePrecision * 100)), "1.0 does not equal 1.0 + 2^(-51).");
|
|
Assert.That(!1.0.AlmostEqual(2.0), "1.0 does not equal 2.0");
|
|
}
|
|
|
|
[Test]
|
|
public void AlmostEqualRelative()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.IsTrue(0.0.AlmostEqualRelative(-0.0, 1e-5));
|
|
Assert.IsTrue(0.0.AlmostEqualRelative(-0.0, 1e-15));
|
|
|
|
// compare two nearby numbers
|
|
Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + (3 * _doublePrecision), 1e-15));
|
|
Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + _doublePrecision, 1e-15));
|
|
Assert.IsTrue(1.0.AlmostEqualRelative(1.0 + 1e-16, 1e-15));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(1.0 + 1e-15, 1e-15));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(1.0 + 1e-14, 1e-15));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.IsTrue((1.0 + (3 * _doublePrecision)).AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsTrue((1.0 + _doublePrecision).AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsTrue((1.0 + 1e-16).AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsFalse((1.0 + 1e-15).AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsFalse((1.0 + 1e-14).AlmostEqualRelative(1.0, 1e-15));
|
|
|
|
// compare different numbers
|
|
Assert.IsFalse(2.0.AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(2.0, 1e-15));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.IsFalse(2.0.AlmostEqualRelative(1.0, 1e-5));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(2.0, 1e-5));
|
|
Assert.IsTrue(2.0.AlmostEqualRelative(1.0, 1e+1));
|
|
Assert.IsTrue(1.0.AlmostEqualRelative(2.0, 1e+1));
|
|
|
|
// compare inf & inf
|
|
Assert.IsTrue(double.PositiveInfinity.AlmostEqualRelative(double.PositiveInfinity, 1e-15));
|
|
Assert.IsTrue(double.NegativeInfinity.AlmostEqualRelative(double.NegativeInfinity, 1e-15));
|
|
|
|
// compare -inf and inf
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(double.NegativeInfinity, 1e-15));
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(double.PositiveInfinity, 1e-15));
|
|
|
|
// compare inf and non-inf
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(double.PositiveInfinity, 1e-15));
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(1.0, 1e-15));
|
|
Assert.IsFalse(1.0.AlmostEqualRelative(double.NegativeInfinity, 1e-15));
|
|
|
|
// compare tiny numbers with opposite signs
|
|
Assert.IsFalse(1e-12.AlmostEqualRelative(-1e-12, 1e-14));
|
|
Assert.IsFalse((-1e-12).AlmostEqualRelative(1e-12, 1e-14));
|
|
|
|
Assert.IsFalse((-2.0).AlmostEqualRelative(2.0, 1e-14));
|
|
Assert.IsFalse(2.0.AlmostEqualRelative(-2.0, 1e-14));
|
|
}
|
|
|
|
[Test]
|
|
public void AlmostEqualNumbersBetween()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.IsTrue(Precision.AlmostEqualNumbersBetween(0, -0, 1));
|
|
|
|
// compare two nearby numbers
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (3 * _doublePrecision), 1));
|
|
Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 + _doublePrecision, 1));
|
|
Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - _doublePrecision, 1));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (3 * _doublePrecision), 1));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.IsFalse((1.0 + (3 * _doublePrecision)).AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsTrue((1.0 + _doublePrecision).AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsTrue((1.0 - _doublePrecision).AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 - (3 * _doublePrecision)).AlmostEqualNumbersBetween(1.0, 1));
|
|
|
|
// compare two slightly more different numbers
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (10 * _doublePrecision), 1));
|
|
Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 + (10 * _doublePrecision), 10));
|
|
Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - (10 * _doublePrecision), 10));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (10 * _doublePrecision), 1));
|
|
|
|
// compare different numbers
|
|
Assert.IsFalse(2.0.AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(2.0, 1));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 + (1e5 * _doublePrecision), 1));
|
|
Assert.IsTrue(1.0.AlmostEqualNumbersBetween(1.0 - (1e5 * _doublePrecision), 200000));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(1.0 - (1e5 * _doublePrecision), 1));
|
|
|
|
// compare inf & inf
|
|
Assert.IsTrue(double.PositiveInfinity.AlmostEqualNumbersBetween(double.PositiveInfinity, 1));
|
|
Assert.IsTrue(double.NegativeInfinity.AlmostEqualNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare -inf and inf
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualNumbersBetween(double.NegativeInfinity, 1));
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
// compare inf and non-inf
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.AlmostEqualNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare tiny numbers with opposite signs
|
|
Assert.IsFalse(double.Epsilon.AlmostEqualNumbersBetween(-double.Epsilon, 1));
|
|
Assert.IsFalse((-double.Epsilon).AlmostEqualNumbersBetween(double.Epsilon, 1));
|
|
|
|
Assert.IsFalse((-2.0).AlmostEqualNumbersBetween(2.0, 1));
|
|
Assert.IsFalse(2.0.AlmostEqualNumbersBetween(-2.0, 1));
|
|
}
|
|
|
|
[Test]
|
|
public void AlmostEqualDecimalPlaces()
|
|
{
|
|
Assert.IsFalse(1d.AlmostEqual(double.NaN, 2));
|
|
Assert.IsFalse(double.NaN.AlmostEqual(2d, 2));
|
|
Assert.IsFalse(double.NaN.AlmostEqual(double.NaN, 2));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqual(2, 2));
|
|
Assert.IsFalse(1d.AlmostEqual(double.NegativeInfinity, 2));
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqual(2, 2));
|
|
Assert.IsFalse(1d.AlmostEqual(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqual(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqual(double.NegativeInfinity, 2));
|
|
Assert.IsTrue(double.PositiveInfinity.AlmostEqual(double.PositiveInfinity, 2));
|
|
Assert.IsTrue(double.NegativeInfinity.AlmostEqual(double.NegativeInfinity, 2));
|
|
|
|
// 1 -> +/- 0.05 (0.5e-1)
|
|
Assert.IsFalse(1d.AlmostEqual(1.06, 1));
|
|
Assert.IsTrue(1d.AlmostEqual(1.04, 1));
|
|
Assert.IsTrue(1d.AlmostEqual(1.00, 1));
|
|
Assert.IsTrue(1d.AlmostEqual(0.96, 1));
|
|
Assert.IsFalse(1d.AlmostEqual(0.94, 1));
|
|
Assert.IsFalse(1d.AlmostEqual(0.0, 1));
|
|
|
|
// -1 -> +/- 5 (0.5e+1)
|
|
Assert.IsFalse(100d.AlmostEqual(106.0, -1));
|
|
Assert.IsTrue(100d.AlmostEqual(104.0, -1));
|
|
Assert.IsTrue(100d.AlmostEqual(100.0, -1));
|
|
Assert.IsTrue(100d.AlmostEqual(96.0, -1));
|
|
Assert.IsFalse(100d.AlmostEqual(94.0, -1));
|
|
Assert.IsFalse(100d.AlmostEqual(0.0, -1));
|
|
|
|
// 3 -> +/- 0.0005 (0.5e-3)
|
|
Assert.IsFalse(0.01.AlmostEqual(0.0106, 3));
|
|
Assert.IsTrue(0.01.AlmostEqual(0.0104, 3));
|
|
Assert.IsTrue(0.01.AlmostEqual(0.0100, 3));
|
|
Assert.IsTrue(0.01.AlmostEqual(0.0096, 3));
|
|
Assert.IsFalse(0.01.AlmostEqual(0.0094, 3));
|
|
Assert.IsFalse(0.01.AlmostEqual(0.0, 3));
|
|
|
|
// 12 -> +/- 0.5e-12
|
|
Assert.IsTrue(0d.AlmostEqual(4 * _doublePrecision, 12));
|
|
Assert.IsTrue(0d.AlmostEqual(-4 * _doublePrecision, 12));
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>AlmostEqual</c> within relative decimal places.
|
|
/// </summary>
|
|
[Test]
|
|
public void AlmostEqualRelativeDecimalPlaces()
|
|
{
|
|
Assert.IsFalse(1d.AlmostEqualRelative(double.NaN, 2));
|
|
Assert.IsFalse(double.NaN.AlmostEqualRelative(2d, 2));
|
|
Assert.IsFalse(double.NaN.AlmostEqualRelative(double.NaN, 2));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(2, 2));
|
|
Assert.IsFalse(1d.AlmostEqualRelative(double.NegativeInfinity, 2));
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(2, 2));
|
|
Assert.IsFalse(1d.AlmostEqualRelative(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.NegativeInfinity.AlmostEqualRelative(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.PositiveInfinity.AlmostEqualRelative(double.NegativeInfinity, 2));
|
|
Assert.IsTrue(double.PositiveInfinity.AlmostEqualRelative(double.PositiveInfinity, 2));
|
|
Assert.IsTrue(double.NegativeInfinity.AlmostEqualRelative(double.NegativeInfinity, 2));
|
|
|
|
// 1 -> +/- max * 0.05 (0.5e-1)
|
|
Assert.IsTrue(1d.AlmostEqualRelative(1.04, 1));
|
|
Assert.IsFalse(1d.AlmostEqualRelative(1.06, 1));
|
|
Assert.IsTrue(1d.AlmostEqualRelative(0.96, 1));
|
|
Assert.IsFalse(1d.AlmostEqualRelative(0.94, 1));
|
|
|
|
// 1 -> +/- max * 0.05 (0.5e-1)
|
|
Assert.IsTrue(100d.AlmostEqualRelative(104.00, 1));
|
|
Assert.IsFalse(100d.AlmostEqualRelative(106.00, 1));
|
|
Assert.IsTrue(100d.AlmostEqualRelative(96.000, 1));
|
|
Assert.IsFalse(100d.AlmostEqualRelative(94.000, 1));
|
|
|
|
// 0 -> +/- max * 0.5 (0.5e-0)
|
|
Assert.IsTrue(0.01.AlmostEqualRelative(0.014, 0));
|
|
Assert.IsFalse(0.01.AlmostEqualRelative(0.016, 0));
|
|
Assert.IsTrue(0.01.AlmostEqualRelative(0.006, 0));
|
|
Assert.IsFalse(0.01.AlmostEqualRelative(0.004, 0));
|
|
|
|
Assert.IsTrue(0d.AlmostEqualRelative(4 * _doublePrecision, 12));
|
|
Assert.IsTrue(0d.AlmostEqualRelative(-4 * _doublePrecision, 12));
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>AlmostEqual</c> within decimal places with negative decimal places throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void AlmostEqualRelativeDecimalPlacesWithNegativeDecimalPlacesThrows()
|
|
{
|
|
Assert.That(() => Precision.AlmostEqualRelative(1, 2, -1), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
Assert.DoesNotThrow(() => Precision.AlmostEqual(1, 2, -1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>AlmostEqual</c> with small numbers and small number of decimal places.
|
|
/// </summary>
|
|
[Test]
|
|
public void AlmostEqualWithSmallNumbersAndSmallNumberOfDecimalPlaces()
|
|
{
|
|
Assert.IsTrue(0.0.AlmostEqualRelative(1e-12, 1));
|
|
Assert.IsTrue(0.0.AlmostEqualRelative(-1e-12, 1));
|
|
|
|
Assert.IsFalse(0.0.AlmostEqualRelative(1e-12, 13));
|
|
Assert.IsFalse(0.0.AlmostEqualRelative(-1e-12, 13));
|
|
|
|
Assert.IsFalse(0.0.AlmostEqualRelative(1, 1));
|
|
Assert.IsFalse(0.0.AlmostEqualRelative(-1, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>AlmostEqual</c> with decimal places with sign revert.
|
|
/// </summary>
|
|
[Test]
|
|
public void AlmostEqualWithDecimalPlacesWithSignRevert()
|
|
{
|
|
Assert.IsFalse(0.5.AlmostEqualRelative(0.3, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is larger with max numbers between.
|
|
/// </summary>
|
|
[Test]
|
|
public void IsLargerWithMaxNumbersBetween()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.IsFalse(Precision.IsLargerNumbersBetween(0, -0, 1));
|
|
|
|
// compare two nearby numbers
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 + (3 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 + _doublePrecision, 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 - _doublePrecision, 1));
|
|
Assert.IsTrue(1.0.IsLargerNumbersBetween(1.0 - (3 * _doublePrecision), 1));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.IsTrue((1.0 + (3 * _doublePrecision)).IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 + _doublePrecision).IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 - _doublePrecision).IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 - (3 * _doublePrecision)).IsLargerNumbersBetween(1.0, 1));
|
|
|
|
// compare two slightly more different numbers
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 + (10 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 + (10 * _doublePrecision), 10));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 - (10 * _doublePrecision), 10));
|
|
Assert.IsTrue(1.0.IsLargerNumbersBetween(1.0 - (10 * _doublePrecision), 1));
|
|
|
|
// compare different numbers
|
|
Assert.IsTrue(2.0.IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(2.0, 1));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 + (1e5 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(1.0 - (1e5 * _doublePrecision), 200000));
|
|
Assert.IsTrue(1.0.IsLargerNumbersBetween(1.0 - (1e5 * _doublePrecision), 1));
|
|
|
|
// compare inf & inf
|
|
Assert.IsFalse(double.PositiveInfinity.IsLargerNumbersBetween(double.PositiveInfinity, 1));
|
|
Assert.IsFalse(double.NegativeInfinity.IsLargerNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare -inf and inf
|
|
Assert.IsTrue(double.PositiveInfinity.IsLargerNumbersBetween(double.NegativeInfinity, 1));
|
|
Assert.IsFalse(double.NegativeInfinity.IsLargerNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
// compare inf and non-inf
|
|
Assert.IsTrue(double.PositiveInfinity.IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.IsLargerNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.IsLargerNumbersBetween(1.0, 1));
|
|
Assert.IsTrue(1.0.IsLargerNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare tiny numbers with opposite signs
|
|
Assert.IsTrue(double.Epsilon.IsLargerNumbersBetween(-double.Epsilon, 1));
|
|
Assert.IsFalse((-double.Epsilon).IsLargerNumbersBetween(double.Epsilon, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is larger with decimal places.
|
|
/// </summary>
|
|
[Test]
|
|
public void IsLargerWithDecimalPlaces()
|
|
{
|
|
Assert.IsFalse(Precision.IsLarger(1, double.NaN, 2));
|
|
Assert.IsFalse(double.NaN.IsLarger(2, 2));
|
|
Assert.IsFalse(double.NaN.IsLarger(double.NaN, 2));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.IsLarger(2, 2));
|
|
Assert.IsTrue(Precision.IsLarger(1, double.NegativeInfinity, 2));
|
|
|
|
Assert.IsTrue(double.PositiveInfinity.IsLarger(2, 2));
|
|
Assert.IsFalse(Precision.IsLarger(1, double.PositiveInfinity, 2));
|
|
|
|
Assert.IsFalse(double.NegativeInfinity.IsLarger(double.PositiveInfinity, 2));
|
|
Assert.IsTrue(double.PositiveInfinity.IsLarger(double.NegativeInfinity, 2));
|
|
|
|
Assert.IsFalse(double.PositiveInfinity.IsLarger(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.NegativeInfinity.IsLarger(double.NegativeInfinity, 2));
|
|
|
|
Assert.IsFalse(1.0.IsLarger(1.006, 2));
|
|
Assert.IsFalse(1.0.IsLarger(1.004, 2));
|
|
Assert.IsFalse(1.0.IsLarger(0.996, 2));
|
|
Assert.IsTrue(1.0.IsLarger(0.994, 2));
|
|
|
|
Assert.IsFalse(1.0.IsLargerRelative(1.006, 2));
|
|
Assert.IsFalse(1.0.IsLargerRelative(1.004, 2));
|
|
Assert.IsFalse(1.0.IsLargerRelative(0.996, 2));
|
|
Assert.IsTrue(1.0.IsLargerRelative(0.994, 2));
|
|
|
|
Assert.IsFalse(100.0.IsLargerRelative(100.6, 2));
|
|
Assert.IsFalse(100.0.IsLargerRelative(100.4, 2));
|
|
Assert.IsFalse(100.0.IsLargerRelative(99.6, 2));
|
|
Assert.IsTrue(100.0.IsLargerRelative(99.4, 2));
|
|
|
|
var max = 0.4 * Math.Pow(10, _doublePrecision.Magnitude());
|
|
Assert.IsFalse(0.0.IsLarger(max, -_doublePrecision.Magnitude()));
|
|
Assert.IsFalse(0.0.IsLarger(-max, -_doublePrecision.Magnitude()));
|
|
|
|
max = 0.6 * Math.Pow(10, _doublePrecision.Magnitude());
|
|
Assert.IsFalse(0.0.IsLarger(max, -_doublePrecision.Magnitude()));
|
|
Assert.IsTrue(0.0.IsLarger(-max, -_doublePrecision.Magnitude()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is smaller with max numbers between.
|
|
/// </summary>
|
|
[Test]
|
|
public void IsSmallerWithMaxNumbersBetween()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.IsFalse(Precision.IsSmallerNumbersBetween(0, -0, 1));
|
|
|
|
// compare two nearby numbers
|
|
Assert.IsTrue(1.0.IsSmallerNumbersBetween(1.0 + (3 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 + _doublePrecision, 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - _doublePrecision, 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - (3 * _doublePrecision), 1));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.IsFalse((1.0 + (3 * _doublePrecision)).IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 + _doublePrecision).IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse((1.0 - _doublePrecision).IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsTrue((1.0 - (3 * _doublePrecision)).IsSmallerNumbersBetween(1.0, 1));
|
|
|
|
// compare two slightly more different numbers
|
|
Assert.IsTrue(1.0.IsSmallerNumbersBetween(1.0 + (10 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 + (10 * _doublePrecision), 10));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - (10 * _doublePrecision), 10));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - (10 * _doublePrecision), 1));
|
|
|
|
// compare different numbers
|
|
Assert.IsFalse(2.0.IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsTrue(1.0.IsSmallerNumbersBetween(2.0, 1));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.IsTrue(1.0.IsSmallerNumbersBetween(1.0 + (1e5 * _doublePrecision), 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - (1e5 * _doublePrecision), 200000));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(1.0 - (1e5 * _doublePrecision), 1));
|
|
|
|
// compare inf & inf
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmallerNumbersBetween(double.PositiveInfinity, 1));
|
|
Assert.IsFalse(double.NegativeInfinity.IsSmallerNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare -inf and inf
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmallerNumbersBetween(double.NegativeInfinity, 1));
|
|
Assert.IsTrue(double.NegativeInfinity.IsSmallerNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
// compare inf and non-inf
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsTrue(1.0.IsSmallerNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
Assert.IsTrue(double.NegativeInfinity.IsSmallerNumbersBetween(1.0, 1));
|
|
Assert.IsFalse(1.0.IsSmallerNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare tiny numbers with opposite signs
|
|
Assert.IsFalse(double.Epsilon.IsSmallerNumbersBetween(-double.Epsilon, 1));
|
|
Assert.IsTrue((-double.Epsilon).IsSmallerNumbersBetween(double.Epsilon, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is smaller with decimal places.
|
|
/// </summary>
|
|
[Test]
|
|
public void IsSmallerWithDecimalPlaces()
|
|
{
|
|
Assert.IsFalse(Precision.IsSmaller(1, double.NaN, 2));
|
|
Assert.IsFalse(double.NaN.IsSmaller(2, 2));
|
|
Assert.IsFalse(double.NaN.IsSmaller(double.NaN, 2));
|
|
|
|
Assert.IsTrue(double.NegativeInfinity.IsSmaller(2, 2));
|
|
Assert.IsFalse(Precision.IsSmaller(1, double.NegativeInfinity, 2));
|
|
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmaller(2, 2));
|
|
Assert.IsTrue(Precision.IsSmaller(1, double.PositiveInfinity, 2));
|
|
|
|
Assert.IsTrue(double.NegativeInfinity.IsSmaller(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmaller(double.NegativeInfinity, 2));
|
|
|
|
Assert.IsFalse(double.PositiveInfinity.IsSmaller(double.PositiveInfinity, 2));
|
|
Assert.IsFalse(double.NegativeInfinity.IsSmaller(double.NegativeInfinity, 2));
|
|
|
|
Assert.IsTrue(1.0.IsSmaller(1.006, 2));
|
|
Assert.IsFalse(1.0.IsSmaller(1.004, 2));
|
|
Assert.IsFalse(1.0.IsSmaller(0.996, 2));
|
|
Assert.IsFalse(1.0.IsSmaller(0.994, 2));
|
|
|
|
Assert.IsTrue(1.0.IsSmallerRelative(1.006, 2));
|
|
Assert.IsFalse(1.0.IsSmallerRelative(1.004, 2));
|
|
Assert.IsFalse(1.0.IsSmallerRelative(0.996, 2));
|
|
Assert.IsFalse(1.0.IsSmallerRelative(0.994, 2));
|
|
|
|
Assert.IsTrue(100.0.IsSmallerRelative(100.6, 2));
|
|
Assert.IsFalse(100.0.IsSmallerRelative(100.4, 2));
|
|
Assert.IsFalse(100.0.IsSmallerRelative(99.6, 2));
|
|
Assert.IsFalse(100.0.IsSmallerRelative(99.4, 2));
|
|
|
|
var max = 0.4 * Math.Pow(10, _doublePrecision.Magnitude());
|
|
Assert.IsFalse(0.0.IsSmaller(max, -_doublePrecision.Magnitude()));
|
|
Assert.IsFalse(0.0.IsSmaller(-max, -_doublePrecision.Magnitude()));
|
|
|
|
max = 0.6 * Math.Pow(10, _doublePrecision.Magnitude());
|
|
Assert.IsTrue(0.0.IsSmaller(max, -_doublePrecision.Magnitude()));
|
|
Assert.IsFalse(0.0.IsSmaller(-max, -_doublePrecision.Magnitude()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between with negative number throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetweenWithNegativeNumberThrows()
|
|
{
|
|
const double Value = 10.0;
|
|
Assert.That(() => Value.CompareToNumbersBetween(Value, -1), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between with zero number throws <c>ArgumentOutOfRangeException</c>.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetweenWithZeroNumberThrows()
|
|
{
|
|
const double Value = 10.0;
|
|
Assert.That(() => Value.CompareToNumbersBetween(Value, 0), Throws.TypeOf<ArgumentOutOfRangeException>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between with infinity number.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetweenWithInfinityValue()
|
|
{
|
|
Assert.AreEqual(0, double.PositiveInfinity.CompareToNumbersBetween(double.PositiveInfinity, 1));
|
|
Assert.AreEqual(0, double.NegativeInfinity.CompareToNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareToNumbersBetween(double.NegativeInfinity, 1));
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareToNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
Assert.AreEqual(-1, Precision.CompareToNumbersBetween(1, double.PositiveInfinity, 1));
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareToNumbersBetween(1, 1));
|
|
|
|
Assert.AreEqual(1, Precision.CompareToNumbersBetween(1, double.NegativeInfinity, 1));
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareToNumbersBetween(1, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between with NaN value.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetweenWithNaNValue()
|
|
{
|
|
// compare nan & not-nan
|
|
Assert.AreEqual(1, Precision.CompareToNumbersBetween(1, double.NaN, 1));
|
|
Assert.AreEqual(0, double.NaN.CompareToNumbersBetween(double.NaN, 1));
|
|
Assert.AreEqual(-1, double.NaN.CompareToNumbersBetween(1, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between for values overflow a long.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetweenForValuesThatOverFlowALong()
|
|
{
|
|
Assert.AreEqual(1, 2.0.CompareToNumbersBetween(-2.0, 1));
|
|
Assert.AreEqual(-1, (-2.0).CompareToNumbersBetween(2.0, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with max numbers between.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithMaxNumbersBetween()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.AreEqual(0, Precision.CompareToNumbersBetween(0, -0, 1));
|
|
|
|
// compare two nearby numbers
|
|
Assert.AreEqual(-1, 1.0.CompareToNumbersBetween(1.0 + (3 * _doublePrecision), 1));
|
|
Assert.AreEqual(0, 1.0.CompareToNumbersBetween(1.0 + _doublePrecision, 1));
|
|
Assert.AreEqual(0, 1.0.CompareToNumbersBetween(1.0 - _doublePrecision, 1));
|
|
Assert.AreEqual(1, 1.0.CompareToNumbersBetween(1.0 - (3 * _doublePrecision), 1));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.AreEqual(1, (1.0 + (3 * _doublePrecision)).CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(0, (1.0 + _doublePrecision).CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(0, (1.0 - _doublePrecision).CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(-1, (1.0 - (3 * _doublePrecision)).CompareToNumbersBetween(1.0, 1));
|
|
|
|
// compare two slightly more different numbers
|
|
Assert.AreEqual(-1, 1.0.CompareToNumbersBetween(1.0 + (10 * _doublePrecision), 1));
|
|
Assert.AreEqual(0, 1.0.CompareToNumbersBetween(1.0 + (10 * _doublePrecision), 10));
|
|
Assert.AreEqual(0, 1.0.CompareToNumbersBetween(1.0 - (10 * _doublePrecision), 10));
|
|
Assert.AreEqual(1, 1.0.CompareToNumbersBetween(1.0 - (10 * _doublePrecision), 1));
|
|
|
|
// compare different numbers
|
|
Assert.AreEqual(1, 2.0.CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(-1, 1.0.CompareToNumbersBetween(2.0, 1));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.AreEqual(-1, 1.0.CompareToNumbersBetween(1.0 + (1e5 * _doublePrecision), 1));
|
|
Assert.AreEqual(0, 1.0.CompareToNumbersBetween(1.0 - (1e5 * _doublePrecision), 200000));
|
|
Assert.AreEqual(1, 1.0.CompareToNumbersBetween(1.0 - (1e5 * _doublePrecision), 1));
|
|
|
|
// compare inf & inf
|
|
Assert.AreEqual(0, double.PositiveInfinity.CompareToNumbersBetween(double.PositiveInfinity, 1));
|
|
Assert.AreEqual(0, double.NegativeInfinity.CompareToNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare -inf and inf
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareToNumbersBetween(double.NegativeInfinity, 1));
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareToNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
// compare inf and non-inf
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(-1, 1.0.CompareToNumbersBetween(double.PositiveInfinity, 1));
|
|
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareToNumbersBetween(1.0, 1));
|
|
Assert.AreEqual(1, 1.0.CompareToNumbersBetween(double.NegativeInfinity, 1));
|
|
|
|
// compare tiny numbers with opposite signs
|
|
Assert.AreEqual(1, double.Epsilon.CompareToNumbersBetween(-double.Epsilon, 1));
|
|
Assert.AreEqual(-1, (-double.Epsilon).CompareToNumbersBetween(double.Epsilon, 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare to with decimal places.
|
|
/// </summary>
|
|
[Test]
|
|
public void CompareToWithDecimalPlaces()
|
|
{
|
|
// compare zero and negative zero
|
|
Assert.AreEqual(0, Precision.CompareTo(0, -0, 1));
|
|
Assert.AreEqual(0, Precision.CompareTo(0, -0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, Precision.CompareTo(0, -0, Precision.SingleDecimalPlaces));
|
|
|
|
// compare two nearby numbers
|
|
Assert.AreEqual(-1, 1.0.CompareTo(1.0 + 10*_doublePrecision, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, 1.0.CompareTo(1.0 + _doublePrecision, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, 1.0.CompareTo(1.0 - _doublePrecision, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(1, 1.0.CompareTo(1.0 - 10*_doublePrecision, Precision.DoubleDecimalPlaces));
|
|
|
|
// compare with the two numbers reversed in compare order
|
|
Assert.AreEqual(1, (1.0 + 10*_doublePrecision).CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, (1.0 + _doublePrecision).CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, (1.0 - _doublePrecision).CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(-1, (1.0 - 10*_doublePrecision).CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
|
|
// compare two slightly more different numbers
|
|
Assert.AreEqual(-1, 1.0.CompareTo(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, 1.0.CompareTo(1.0 + (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2));
|
|
Assert.AreEqual(0, 1.0.CompareTo(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces - 2));
|
|
Assert.AreEqual(1, 1.0.CompareTo(1.0 - (50*_doublePrecision), Precision.DoubleDecimalPlaces));
|
|
|
|
// compare different numbers
|
|
Assert.AreEqual(1, 2.0.CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(-1, 1.0.CompareTo(2.0, Precision.DoubleDecimalPlaces));
|
|
|
|
// compare different numbers with large tolerance
|
|
Assert.AreEqual(-1, 1.0.CompareTo(1.0 + (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, 1.0.CompareTo(1.0 - (1e5 * _doublePrecision), 10));
|
|
Assert.AreEqual(1, 1.0.CompareTo(1.0 - (1e5 * _doublePrecision), Precision.DoubleDecimalPlaces));
|
|
|
|
// compare inf & inf
|
|
Assert.AreEqual(0, double.PositiveInfinity.CompareTo(double.PositiveInfinity, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(0, double.NegativeInfinity.CompareTo(double.NegativeInfinity, Precision.DoubleDecimalPlaces));
|
|
|
|
// compare -inf and inf
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareTo(double.NegativeInfinity, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareTo(double.PositiveInfinity, Precision.DoubleDecimalPlaces));
|
|
|
|
// compare inf and non-inf
|
|
Assert.AreEqual(1, double.PositiveInfinity.CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(-1, 1.0.CompareTo(double.PositiveInfinity, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(-1, double.NegativeInfinity.CompareTo(1.0, Precision.DoubleDecimalPlaces));
|
|
Assert.AreEqual(1, 1.0.CompareTo(double.NegativeInfinity, Precision.DoubleDecimalPlaces));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(100.3123, -3, 0)]
|
|
[TestCase(1100.6123, -3, 1000)]
|
|
[TestCase(1500.8123, -3, 2000)]
|
|
[TestCase(110003245.3123, -3, 110003000)]
|
|
[TestCase(110003245.3123, -1, 110003250)]
|
|
[TestCase(110003245.3123, 2, 110003245.31)]
|
|
[TestCase(110003245.3123, 0, 110003245)]
|
|
public void RoundDecimal(decimal number, int digit, decimal expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult, number.Round(digit));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(100.3123d, -3, 0d)]
|
|
[TestCase(1100.6123d, -3, 1000d)]
|
|
[TestCase(1500.8123d, -3, 2000d)]
|
|
[TestCase(110003245.3123d, -3, 110003000d)]
|
|
[TestCase(110003245.3123d, -1, 110003250d)]
|
|
[TestCase(110003245.3123d, 2, 110003245.31d)]
|
|
[TestCase(110003245.3123d, 0, 110003245d)]
|
|
public void RoundDouble(double number, int digit, double expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult,number.Round(digit));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(100.3123f, -3, 0f)]
|
|
[TestCase(1100.6123f, -3, 1000f)]
|
|
[TestCase(1500.8123f, -3, 2000f)]
|
|
[TestCase(11245.3123f, -3, 11000f)]
|
|
[TestCase(13245.3123f, -1, 13250f)]
|
|
[TestCase(13245.3123f, 2, 13245.31f)]
|
|
[TestCase(13245.3123f, 0, 13245f)]
|
|
public void RoundSingle(float number, int digit, float expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult,number.Round(digit));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(100, -3, 0)]
|
|
[TestCase(1100, -3, 1000)]
|
|
[TestCase(1500, -3, 2000)]
|
|
[TestCase(110003245, -3, 110003000)]
|
|
[TestCase(110003245, -1, 110003250)]
|
|
[TestCase(110003245, 2, 110003245)]
|
|
public void RoundInt32(int number, int digit, int expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult,number.Round(digit));
|
|
}
|
|
|
|
[Test]
|
|
public void RoundUint32()
|
|
{
|
|
Assert.AreEqual(110003250U,110003245U.Round(-1));
|
|
}
|
|
|
|
[Test]
|
|
public void RoundUInt64()
|
|
{
|
|
Assert.AreEqual(3250UL, 3245UL.Round(-1));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(110003245L, -1, 110003250L)]
|
|
public void RoundInt64(long number, int digit, long expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult, number.Round(digit));
|
|
}
|
|
|
|
[Test]
|
|
public void RoundInt16()
|
|
{
|
|
Assert.AreEqual(3250, ((short)3245).Round(-1));
|
|
}
|
|
|
|
[Test]
|
|
public void RoundUInt16()
|
|
{
|
|
Assert.AreEqual(3250,((ushort)3245).Round(-1));
|
|
}
|
|
|
|
[Test]
|
|
public void RoundBigInteger()
|
|
{
|
|
Assert.AreEqual(BigInteger.Zero,new BigInteger(100).Round(-3));
|
|
Assert.AreEqual(new BigInteger(1000),new BigInteger(1100).Round(-3));
|
|
Assert.AreEqual(new BigInteger(2000),new BigInteger(1500).Round(-3));
|
|
Assert.AreEqual(new BigInteger(110003000), new BigInteger(110003245).Round(-3));
|
|
Assert.AreEqual(new BigInteger(110003250), new BigInteger(110003245).Round(-1));
|
|
Assert.AreEqual(new BigInteger(110003245), new BigInteger(110003245).Round(2));
|
|
Assert.AreEqual(new BigInteger(110003245), new BigInteger(110003245).Round(0));
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(0.0, 2.0, 0.0)]
|
|
[TestCase(0.1, 2.0, 0.125)]
|
|
[TestCase(0.7, 2.0, 0.5)]
|
|
[TestCase(0.8, 2.0, 1.0)]
|
|
[TestCase(1.1, 2.0, 1.0)]
|
|
[TestCase(1.6, 2.0, 2.0)]
|
|
[TestCase(3.2, 2.0, 4.0)]
|
|
[TestCase(14.0, 2.0, 16.0)]
|
|
[TestCase(-14.0, 2.0, -16.0)]
|
|
public void RoundToPowerDouble(double number, double basis, double expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult, number.RoundToPower(basis), 0.0);
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(0.0, 0.3, 0.0)]
|
|
[TestCase(0.1, 0.3, 0.0)]
|
|
[TestCase(0.2, 0.3, 0.3)]
|
|
[TestCase(0.8, 0.3, 0.9)]
|
|
[TestCase(1.1, 0.3, 1.2)]
|
|
[TestCase(1.6, 0.3, 1.5)]
|
|
[TestCase(3.2, 0.3, 3.3)]
|
|
[TestCase(-3.2, 0.3, -3.3)]
|
|
public void RoundToMultipleDouble(double number, double basis, double expectedResult)
|
|
{
|
|
Assert.AreEqual(expectedResult, number.RoundToMultiple(basis), Precision.DoublePrecision);
|
|
}
|
|
}
|
|
}
|
|
|