Reject a precision below one in ReduceSignificance [patch]

ReduceSignificance did not validate its argument, so 5 reduced to zero
significant digits returned 10, and to minus one returned 0, with no
error. It now throws ArgumentOutOfRangeException below one, as Divide,
the roots, Sin and the constant accessors already do.

The exponent addition is now checked too, following the exponent-overflow
fix in #120, so a result beyond int's exponent range throws
OverflowException instead of wrapping.

Fixes #126

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LasidbyRZfyxgW8Z9wQu9M

Author: claude

PreciseNumber.Test/PreciseNumberTests.cs

@@ -1056,6 +1056,26 @@ public void TestReduceSignificance()
 		Assert.AreEqual(number, number.ReduceSignificance(5));
 	}
 
+	// A precision below one has no meaning, and used to return a wrong number rather than fail:
+	// 5 reduced to zero digits came back as 10, and to minus one digit as 0.
+
+	[TestMethod]
+	[DataRow(0)]
+	[DataRow(-1)]
+	[DataRow(int.MinValue)]
+	public void TestReduceSignificanceRejectsAPrecisionBelowOne(int significantDigits)
+	{
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => 5.ToPreciseNumber().ReduceSignificance(significantDigits));
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => PreciseNumber.Pi.ReduceSignificance(significantDigits));
+	}
+
+	[TestMethod]
+	public void TestReduceSignificanceThrowsWhenTheExponentLeavesTheIntRange()
+	{
+		PreciseNumber number = PreciseNumber.CreateFromComponents(int.MaxValue - 1, 12345);
+		Assert.ThrowsExactly<OverflowException>(() => number.ReduceSignificance(3));
+	}
+
 	[TestMethod]
 	public void TestReduceSignificanceRoundsHalfAwayFromZeroOnTheDroppedDigits()
 	{

PreciseNumber/PreciseNumber.cs

@@ -857,8 +857,15 @@ internal long CountDecimalDigits() =>
 	/// <param name="significantDigits">The number of significant digits to reduce to.</param>
 	/// <returns>A new instance of <see cref="PreciseNumber"/> reduced to the specified number of significant digits.</returns>
 	/// <remarks>Rounds half away from zero, so 123.5 becomes 124 and 123.456 becomes 123 at three digits.</remarks>
+	/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="significantDigits"/> is less than one.</exception>
+	/// <exception cref="OverflowException">Thrown when the result needs an exponent outside the range of an <see cref="int"/>.</exception>
 	public PreciseNumber ReduceSignificance(int significantDigits)
 	{
+		if (significantDigits < 1)
+		{
+			throw new ArgumentOutOfRangeException(nameof(significantDigits), significantDigits, "At least one significant digit is required.");
+		}
+
 		int significantDifference = significantDigits < SignificantDigits
 			? SignificantDigits - significantDigits
 			: 0;
@@ -868,9 +875,7 @@ public PreciseNumber ReduceSignificance(int significantDigits)
 			return this;
 		}
 
-		int newExponent = Exponent == 0
-			? significantDifference
-			: Exponent + significantDifference;
+		int newExponent = checked(Exponent + significantDifference);
 		BigInteger newSignificand = DropDigitsRoundingHalfAwayFromZero(Significand, significantDifference);
 		return new(newExponent, newSignificand);
 	}