Throw DivideByZeroException for zero to a negative power

PreciseNumber.Test/PreciseNumberExponentialTests.cs

@@ -223,6 +223,21 @@ public void TestPowRejectsAFractionalPowerOfANegativeValue()
 		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Parse("-2").Pow(Parse("0.5")));
 	}
 
+	[TestMethod]
+	public void TestPowOfZeroToANegativePowerThrowsLikeDivision()
+	{
+		// Zero to a negative power is one over zero, which One / Zero and RootN(0, -n) already reject.
+		Assert.ThrowsExactly<DivideByZeroException>(() => PreciseNumber.Zero.Pow(PreciseNumber.NegativeOne));
+		Assert.ThrowsExactly<DivideByZeroException>(() => PreciseNumber.Zero.Pow(Parse("-0.5")));
+		Assert.ThrowsExactly<DivideByZeroException>(() => PreciseNumber.Pow(PreciseNumber.Zero, Parse("-2")));
+		Assert.ThrowsExactly<DivideByZeroException>(() => PreciseNumber.Pow(PreciseNumber.Zero, Parse("-0.5")));
+
+		// A positive power of zero is still zero, and the zero power of anything is still one.
+		Assert.AreEqual(PreciseNumber.Zero, PreciseNumber.Pow(PreciseNumber.Zero, 2.ToPreciseNumber()));
+		Assert.AreEqual(PreciseNumber.Zero, PreciseNumber.Pow(PreciseNumber.Zero, Parse("0.5")));
+		Assert.AreEqual(PreciseNumber.One, PreciseNumber.Pow(PreciseNumber.Zero, PreciseNumber.Zero));
+	}
+
 	[TestMethod]
 	public void TestExpM1KeepsTheDigitsOfASmallArgument()
 	{

PreciseNumber/PreciseNumber.Exponentials.cs

@@ -647,6 +647,7 @@ public static PreciseNumber Exp10M1(PreciseNumber x, int significantDigits)
 	/// <param name="y">The exponent.</param>
 	/// <returns><c>x^y</c>.</returns>
 	/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="x"/> is negative and <paramref name="y"/> is not an integer.</exception>
+	/// <exception cref="DivideByZeroException">Thrown when <paramref name="x"/> is zero and <paramref name="y"/> is negative.</exception>
 	/// <exception cref="OverflowException">Thrown when the result needs an exponent outside the range of an <see cref="int"/>.</exception>
 	/// <remarks>
 	/// An integer exponent is exact, by repeated squaring. Anything else is

PreciseNumber/PreciseNumber.cs

@@ -697,7 +697,7 @@
 	/// A fixed precision such as <c>E15</c> rounds values that need 17 digits, which turns
 	/// <see cref="double.MaxValue"/> into a number that converts back to infinity.
 	/// </remarks>
 	internal static string GetStringFormatForFloatType<TFloat>()
 		where TFloat : INumber<TFloat>
 		=> "R";
 
@@ -1111,7 +1111,7 @@
 	public static PreciseNumber MinMagnitudeNumber(PreciseNumber x, PreciseNumber y) => MinMagnitude(x, y);
 
 	/// <inheritdoc/>
 	public static PreciseNumber Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
 	{
 		if (s.IsEmpty)
 		{
@@ -1740,6 +1740,7 @@
 	/// <param name="power">The power to raise the number to.</param>
 	/// <returns>A new instance of <see cref="PreciseNumber"/> that is the result of raising the current instance to the specified power.</returns>
 	/// <exception cref="ArgumentOutOfRangeException">Thrown when the current instance is negative and <paramref name="power"/> is not an integer.</exception>
+	/// <exception cref="DivideByZeroException">Thrown when the current instance is zero and <paramref name="power"/> is negative.</exception>
 	/// <exception cref="OverflowException">Thrown when the result needs an exponent outside the range of an <see cref="int"/>.</exception>
 	/// <remarks>
 	/// An integer power is exact, by repeated squaring. A fractional power is
@@ -1754,7 +1755,7 @@
 		}
 		else if (Significand.IsZero)
 		{
-			return Zero;
+			return PowOfZero(power);
 		}
 		else if (IsUnit)
 		{
@@ -1797,6 +1798,17 @@
 		return FractionalPow(this, power, significantDigits);
 	}
 
+	/// <summary>
+	/// Returns zero raised to a non-zero power.
+	/// </summary>
+	/// <param name="power">The non-zero power.</param>
+	/// <returns>Zero, for a positive <paramref name="power"/>.</returns>
+	/// <exception cref="DivideByZeroException">Thrown when <paramref name="power"/> is negative, since that is one over zero, as for <c>One / Zero</c>.</exception>
+	private static PreciseNumber PowOfZero(PreciseNumber power) =>
+		power.Significand.Sign < 0
+			? throw new DivideByZeroException()
+			: Zero;
+
 	/// <inheritdoc/>
 	public static PreciseNumber operator -(PreciseNumber value) =>
 		Negate(value);