src/Numerics/Complex32.cs src/UnitTests/ComplexTests/Complex32Test.TextHandling.cs src/UnitTests/ComplexTests/Complex32Test.cs @@ -1279,7 +1279,17 @@ namespace MathNet.Numerics #region Conversion /// <summary> - /// Explicit conversion of a real decimal to a real <c>Complex</c>. + /// Explicit conversion of a <c>Complex32</c> to a <c>Complex</c>. + /// </summary> + /// <param name="value">The decimal value to convert.</param> + /// <returns>The result of the conversion.</returns> + public static implicit operator Complex(Complex32 value) + { + return new Complex(value.Real, value.Imaginary); + } + + /// <summary> + /// Explicit conversion of a real decimal to a <c>Complex</c>. /// </summary> /// <param name="value">The decimal value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1289,7 +1299,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real byte to a real <c>Complex</c>. + /// Implicit conversion of a real byte to a <c>Complex</c>. /// </summary> /// <param name="value">The byte value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1299,7 +1309,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real short to a real <c>Complex</c>. + /// Implicit conversion of a real short to a <c>Complex</c>. /// </summary> /// <param name="value">The short value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1309,7 +1319,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real int to a real <c>Complex</c>. + /// Implicit conversion of a real int to a <c>Complex</c>. /// </summary> /// <param name="value">The int value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1319,7 +1329,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real long to a real <c>Complex</c>. + /// Implicit conversion of a real long to a <c>Complex</c>. /// </summary> /// <param name="value">The long value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1329,7 +1339,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real uint to a real <c>Complex</c>. + /// Implicit conversion of a real uint to a <c>Complex</c>. /// </summary> /// <param name="value">The uint value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1339,7 +1349,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real ulong to a real <c>Complex</c>. + /// Implicit conversion of a real ulong to a <c>Complex</c>. /// </summary> /// <param name="value">The ulong value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1349,7 +1359,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real float to a real <c>Complex</c>. + /// Implicit conversion of a real float to a <c>Complex</c>. /// </summary> /// <param name="value">The float value to convert.</param> /// <returns>The result of the conversion.</returns> @@ -1359,7 +1369,7 @@ namespace MathNet.Numerics } /// <summary> - /// Implicit conversion of a real double to a real <c>Complex</c>. + /// Implicit conversion of a real double to a <c>Complex</c>. /// </summary> /// <param name="value">The double value to convert.</param> /// <returns>The result of the conversion.</returns> src/Numerics/Complex.cs @@ -158,5 +158,39 @@ namespace MathNet.Numerics token = token.Next; return value; } + + /// <summary> + /// Globalized Parsing: Parse a float number + /// </summary> + /// <param name="token">First token of the number.</param> + /// <param name="culture">Culture Info.</param> + /// <returns>The parsed float number using the given culture information.</returns> + /// <exception cref="FormatException" /> + internal static float ParseSingle(ref LinkedListNode<string> token, CultureInfo culture) + { + // in case the + and - in scientific notation are separated, join them back together. + if (token.Value.EndsWith("e", true, culture)) + { + if (token.Next == null || token.Next.Next == null) + { + throw new FormatException(); + } + + token.Value = token.Value + token.Next.Value + token.Next.Next.Value; + + var list = token.List; + list.Remove(token.Next.Next); + list.Remove(token.Next); + } + + float value; + if (!Single.TryParse(token.Value, NumberStyles.Any, culture, out value)) + { + throw new FormatException(); + } + + token = token.Next; + return value; + } } } \ No newline at end of file src/Numerics/GlobalizationHelper.cs @@ -72,6 +72,7 @@ <Compile Include="Complex.cs" /> <Compile Include="Constants.cs" /> <Compile Include="Control.cs" /> + <Compile Include="Complex32.cs" /> <Compile Include="Distributions\Continuous\Beta.cs" /> <Compile Include="Distributions\Continuous\ContinuousUniform.cs" /> <Compile Include="Distributions\Continuous\LogNormal.cs" /> src/Numerics/Numerics.csproj @@ -95,7 +95,10 @@ namespace MathNet.Numerics private static readonly int _numberOfDecimalPlacesForFloats; /// <summary>Value representing 10 * 2^(-52)</summary> - private static readonly double _defaultRelativeAccuracy = _doubleMachinePrecision * 10; + private static readonly double _defaultDoubleRelativeAccuracy = _doubleMachinePrecision * 10; + + /// <summary>Value representing 10 * 2^(-52)</summary> + private static readonly float _defaultSingleRelativeAccuracy = (float)(_singleMachinePrecision * 10); #endregion @@ -691,7 +694,19 @@ namespace MathNet.Numerics public static bool AlmostEqual(this double a, double b) { double diff = a - b; - return AlmostEqualWithError(a, b, diff, _defaultRelativeAccuracy); + return AlmostEqualWithError(a, b, diff, _defaultDoubleRelativeAccuracy); + } + + /// <summary> + /// Checks whether two real numbers are almost equal. + /// </summary> + /// <param name="a">The first number</param> + /// <param name="b">The second number</param> + /// <returns>true if the two values differ by no more than 10 * 2^(-52); false otherwise.</returns> + public static bool AlmostEqual(this float a, float b) + { + double diff = a - b; + return AlmostEqualWithError(a, b, diff, _defaultSingleRelativeAccuracy); } /// <summary> @@ -705,7 +720,7 @@ namespace MathNet.Numerics where T : IPrecisionSupport<T> { double diff = a.NormOfDifference(b); - return AlmostEqualWithError(a.Norm(), b.Norm(), diff, _defaultRelativeAccuracy); + return AlmostEqualWithError(a.Norm(), b.Norm(), diff, _defaultDoubleRelativeAccuracy); } /// <summary> @@ -996,6 +1011,62 @@ namespace MathNet.Numerics } /// <summary> + /// Compares two floats and determines if they are equal to within the specified number of decimal places or not. If the numbers + /// are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + /// </summary> + /// <remarks> + /// <para> + /// The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + /// two so that we have half the range on each side of the numbers, e.g. if <paramref name="decimalPlaces"/> == 2, then 0.01 will equal between + /// 0.005 and 0.015, but not 0.02 and not 0.00 + /// </para> + /// </remarks> + /// <param name="a">The first value.</param> + /// <param name="b">The second value.</param> + /// <param name="decimalPlaces">The number of decimal places.</param> + /// <returns><see langword="true" /> if both doubles are equal to each other within the specified number of decimal places; otherwise <see langword="false" />.</returns> + /// <exception cref="ArgumentOutOfRangeException"> + /// Thrown if <paramref name="decimalPlaces"/> is smaller than zero. + /// </exception> + public static bool AlmostEqualInDecimalPlaces(this float a, float b, int decimalPlaces) + { + if (decimalPlaces <= 0) + { + // Can't have a negative number of decimal places + throw new ArgumentOutOfRangeException("decimalPlaces"); + } + + // If A or B are a NAN, return false. NANs are equal to nothing, + // not even themselves. + if (double.IsNaN(a) || double.IsNaN(b)) + { + return false; + } + + // If A or B are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + if (double.IsInfinity(a) || double.IsInfinity(b)) + { + return a == b; + } + + if (Math.Abs(a) < _doubleMachinePrecision || Math.Abs(b) < _doubleMachinePrecision) + { + return AlmostEqualWithAbsoluteDecimalPlaces(a, b, decimalPlaces); + } + + // If both numbers are equal, get out now. This should remove the possibility of both numbers being zero + // and any problems associated with that. + if (a.Equals(b)) + { + return true; + } + + return AlmostEqualWithRelativeDecimalPlaces(a, b, decimalPlaces); + } + + /// <summary> /// Compares two doubles and determines if they are equal to within the specified number of decimal places or not. /// </summary> /// <remarks> src/Numerics/Precision.cs @@ -80,6 +80,28 @@ namespace MathNet.Numerics.UnitTests } } + + /// <summary> + /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. + /// </summary> + /// <param name="expected">The expected value.</param> + /// <param name="actual">The actual value.</param> + /// <param name="decimalPlaces">The number of decimal places to agree on.</param> + public static void AlmostEqual(Complex32 expected, Complex32 actual, int decimalPlaces) + { + bool pass = expected.Real.AlmostEqualInDecimalPlaces(actual.Real, decimalPlaces); + if (!pass) + { + Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); + } + + pass = expected.Imaginary.AlmostEqualInDecimalPlaces(actual.Imaginary, decimalPlaces); + if (!pass) + { + Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); + } + } + /// <summary> /// Asserts that the expected value and the actual value are equal up to a certain /// maximum error. src/UnitTests/AssertHelpers.cs @@ -794,12 +794,12 @@ namespace MathNet.Numerics.UnitTests.ComplexTests } [Test] - public void CanConvertDoulbeComplex() + public void CanConvertComplex32ToComplex() { - const double orginal = 123.456789; - var complex = (Complex)orginal; - Assert.AreEqual(123.456789, complex.Real); - Assert.AreEqual(0.0, complex.Imaginary); + var complex32 = new Complex32(123.456f, -78.9f); + var complex = (Complex)complex32; + Assert.AreEqual(123.456f, (float)complex.Real); + Assert.AreEqual(-78.9f, (float)complex.Imaginary); } } } \ No newline at end of file src/UnitTests/ComplexTests/ComplexTest.cs @@ -35,7 +35,7 @@ namespace MathNet.Numerics.UnitTests public sealed class PrecisionTest { private const double _acceptableError = 1e-12; - private readonly double _doublePrecision = System.Math.Pow(2, -53); + private readonly double _doublePrecision = Math.Pow(2, -53); [Test] public void Magnitude() src/UnitTests/PrecisionTest.cs @@ -64,6 +64,8 @@ <Compile Include="CombinatoricsTests\CombinatoricsCountingTest.cs" /> <Compile Include="ComplexTests\ComplexTest.TextHandling.cs" /> <Compile Include="ComplexTests\ComplexTest.cs" /> + <Compile Include="ComplexTests\Complex32Test.TextHandling.cs" /> + <Compile Include="ComplexTests\Complex32Test.cs" /> <Compile Include="DistributionTests\CommonDistributionTests.cs" /> <Compile Include="DistributionTests\Continuous\BetaTests.cs" /> <Compile Include="DistributionTests\Continuous\ContinuousUniformTests.cs" /> src/UnitTests/UnitTests.csproj 49d8b712e9fc2f4666bfd08b1f8df5caca81aa49 Marcus Cuda marcus@cuda.net http://github.com/cuda/mathnet-numerics/commit/8f2ee01da2157d9caddc8e565746e85cfee6ff8f 8f2ee01da2157d9caddc8e565746e85cfee6ff8f 2009-11-04T04:25:02-08:00 2009-11-04T04:17:31-08:00 added complex32 type 887f26ac641311d4069db4053c830496b379b5ce Marcus Cuda marcus@cuda.net