Merge pull request #120 from ktsu-dev/fix/exponent-overflow

Author: matt-edmondson

PreciseNumber.Test/PreciseNumberTests.cs

@@ -2545,6 +2545,47 @@ public void TestParseThenFormatAtExtremeExponentsRoundTrips()
 		Assert.ThrowsExactly<OverflowException>(() => huge.ToString(CultureInfo.InvariantCulture));
 	}
 
+	[TestMethod]
+	public void TestMultiplyThrowsOverflowWhenTheExponentLeavesTheIntRange()
+	{
+		PreciseNumber big = PreciseNumber.Parse("1e2000000000", NumberStyles.Float, CultureInfo.InvariantCulture);
+		PreciseNumber small = PreciseNumber.Parse("1e-2000000000", NumberStyles.Float, CultureInfo.InvariantCulture);
+
+		// Wrapping would give 1e-294967296 and 1e+294967296, off by billions of orders of magnitude.
+		Assert.ThrowsExactly<OverflowException>(() => big * big);
+		Assert.ThrowsExactly<OverflowException>(() => small * small);
+		Assert.ThrowsExactly<OverflowException>(() => PreciseNumber.Pow(big, 2.ToPreciseNumber()));
+
+		// Exponents that still fit are unaffected.
+		Assert.AreEqual(PreciseNumber.One, big * small);
+	}
+
+	[TestMethod]
+	public void TestDivideThrowsOverflowWhenTheExponentLeavesTheIntRange()
+	{
+		PreciseNumber big = PreciseNumber.Parse("1e2000000000", NumberStyles.Float, CultureInfo.InvariantCulture);
+		PreciseNumber small = PreciseNumber.Parse("1e-2000000000", NumberStyles.Float, CultureInfo.InvariantCulture);
+
+		Assert.ThrowsExactly<OverflowException>(() => big / small);
+		Assert.ThrowsExactly<OverflowException>(() => small / big);
+
+		// Exponents that still fit are unaffected.
+		Assert.AreEqual(PreciseNumber.One, big / big);
+	}
+
+	[TestMethod]
+	public void TestDivideThrowsOverflowWhenScalingTheQuotientLeavesTheIntRange()
+	{
+		PreciseNumber tiny = PreciseNumber.Parse("1E-2147483648", NumberStyles.Float, CultureInfo.InvariantCulture);
+
+		// An exact quotient: 1e-2147483648 / 2 is 5e-2147483649, one place past int.MinValue.
+		Assert.ThrowsExactly<OverflowException>(() => tiny / PreciseNumber.CreateFromComponents(0, 2));
+
+		// A rounded quotient: a third needs its digits below int.MinValue too.
+		Assert.ThrowsExactly<OverflowException>(() => tiny / PreciseNumber.CreateFromComponents(0, 3));
+		Assert.ThrowsExactly<OverflowException>(() => PreciseNumber.Divide(tiny, PreciseNumber.CreateFromComponents(0, 3), 5));
+	}
+
 	[TestMethod]
 	public void TestRoundAtExtremeNegativeExponentGivesZero()
 	{

PreciseNumber/PreciseNumber.cs

@@ -1452,6 +1452,7 @@ public static PreciseNumber Add(PreciseNumber left, PreciseNumber right)
 	/// <param name="left">The first number to multiply.</param>
 	/// <param name="right">The second number to multiply.</param>
 	/// <returns>The result of the multiplication.</returns>
+	/// <exception cref="OverflowException">Thrown when the product needs an exponent outside the range of an <see cref="int"/>.</exception>
 	public static PreciseNumber Multiply(PreciseNumber left, PreciseNumber right)
 	{
 		if (left.Significand.IsZero || right.Significand.IsZero)
@@ -1469,7 +1470,7 @@ public static PreciseNumber Multiply(PreciseNumber left, PreciseNumber right)
 
 		// (l * 10^el) * (r * 10^er) == (l * r) * 10^(el + er), so there is no need to scale the
 		// operands to a common exponent first; doing so only inflates both significands.
-		return new PreciseNumber(left.Exponent + right.Exponent, left.Significand * right.Significand);
+		return new PreciseNumber(checked(left.Exponent + right.Exponent), left.Significand * right.Significand);
 	}
 
 	/// <summary>
@@ -1479,6 +1480,7 @@ public static PreciseNumber Multiply(PreciseNumber left, PreciseNumber right)
 	/// <param name="right">The number to divide by.</param>
 	/// <returns>The result of the division.</returns>
 	/// <exception cref="DivideByZeroException">Thrown when <paramref name="right"/> is zero.</exception>
+	/// <exception cref="OverflowException">Thrown when the quotient needs an exponent outside the range of an <see cref="int"/>.</exception>
 	/// <remarks>
 	/// A quotient whose decimal expansion terminates is produced exactly, however many digits that
 	/// takes. One that repeats is produced to the precision of the wider operand, and never fewer
@@ -1508,6 +1510,7 @@ public static PreciseNumber Divide(PreciseNumber left, PreciseNumber right)
 	/// <returns>The result of the division.</returns>
 	/// <exception cref="DivideByZeroException">Thrown when <paramref name="right"/> is zero.</exception>
 	/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="significantDigits"/> is less than one.</exception>
+	/// <exception cref="OverflowException">Thrown when the quotient needs an exponent outside the range of an <see cref="int"/>.</exception>
 	public static PreciseNumber Divide(PreciseNumber left, PreciseNumber right, int significantDigits)
 	{
 		if (significantDigits < 1)
@@ -1527,7 +1530,7 @@ public static PreciseNumber Divide(PreciseNumber left, PreciseNumber right, int
 
 		BigInteger numerator = left.Significand;
 		BigInteger denominator = right.Significand;
-		int exponent = left.Exponent - right.Exponent;
+		int exponent = checked(left.Exponent - right.Exponent);
 
 		// Carry the sign on the numerator so the denominator can be factorized as a positive value.
 		if (denominator.Sign < 0)
@@ -1586,7 +1589,7 @@ private static bool TryDivideExactly(BigInteger numerator, BigInteger denominato
 		int scale = Math.Max(twos, fives);
 		BigInteger significand = numerator * BigInteger.Pow(2, scale - twos) * BigInteger.Pow(5, scale - fives);
 
-		result = new PreciseNumber(exponent - scale, significand);
+		result = new PreciseNumber(checked(exponent - scale), significand);
 		return true;
 	}
 
@@ -1605,7 +1608,7 @@ private static PreciseNumber DivideToPrecision(BigInteger numerator, BigInteger
 		// rounding decision is made on.
 		int scale = significantDigits + 1 - CountDigits(numerator) + CountDigits(denominator);
 		BigInteger scaled = scale > 0 ? numerator * Pow10(scale) : numerator;
-		int scaledExponent = exponent - Math.Max(scale, 0);
+		int scaledExponent = checked(exponent - Math.Max(scale, 0));
 
 		BigInteger quotient = scaled / denominator;
 		int excess = CountDigits(quotient) - significantDigits;
@@ -1626,7 +1629,7 @@ private static PreciseNumber DivideToPrecision(BigInteger numerator, BigInteger
 			kept += quotient.Sign;
 		}
 
-		return new PreciseNumber(scaledExponent + excess, kept);
+		return new PreciseNumber(checked(scaledExponent + excess), kept);
 	}
 
 	/// <summary>