Compare a SignificantNumber with a PreciseNumber through Equals [minor]

SignificantNumber.Test/SignificantNumberValueTypeTests.cs

@@ -295,4 +295,34 @@ public void CompareAtSignificance_ComparesAtTheLowerSignificantDigitCount(string
 	{
 		Assert.AreEqual(expected, int.Sign(SignificantNumber.CompareAtSignificance(Parse(left), Parse(right))));
 	}
+
+	[TestMethod]
+	[DataRow("1.5", "1.5", true)]
+	[DataRow("1.50", "1.5", true)]
+	[DataRow("0", "0", true)]
+	[DataRow("-2.25", "-2.25", true)]
+	[DataRow("1.5", "1.4", false)]
+	[DataRow("1.4", "1.5", false)]
+	public void EqualsPreciseNumber_AgreesInBothArgumentOrdersAndWithOperator(string significant, string precise, bool expected)
+	{
+		SignificantNumber s = Parse(significant);
+		PreciseNumber p = PreciseNumber.Parse(precise, CultureInfo.InvariantCulture);
+
+		Assert.AreEqual(expected, s == p, $"{s} == {p}");
+		Assert.AreEqual(expected, s.Equals(p), $"{s}.Equals({p})");
+		Assert.AreEqual(expected, p.Equals(s), $"{p}.Equals({s})");
+		Assert.AreEqual(expected, s.CompareTo((object)p) == 0, $"{s}.CompareTo((object){p}) == 0");
+	}
+
+	[TestMethod]
+	public void EqualsObject_BoxedPreciseNumber_IsFalseEvenWhenEqual()
+	{
+		SignificantNumber s = Parse("1.5");
+		object boxed = PreciseNumber.Parse("1.5", CultureInfo.InvariantCulture);
+
+		// The record struct's Equals(object) only accepts another SignificantNumber, so a boxed PreciseNumber is
+		// never equal to it, although CompareTo(object) treats the two as the same value.
+		Assert.IsFalse(s.Equals(boxed));
+		Assert.AreEqual(0, s.CompareTo(boxed));
+	}
 }

SignificantNumber/SignificantNumber.cs

@@ -589,7 +589,7 @@
 	/// <exception cref="DivideByZeroException">Thrown when the current number is zero and <paramref name="power"/> is negative.</exception>
 	/// <exception cref="ArgumentException">Thrown when the current number is negative and <paramref name="power"/> is not an integer, as the result is not a real number.</exception>
 	/// <exception cref="OverflowException">Thrown when the result's power of ten is too large or too small to represent.</exception>
 	public SignificantNumber Pow(PreciseNumber power)
 	{
 		if (Equal(power, Zero))
 		{
@@ -714,7 +714,7 @@
 		double magnitude = Math.Abs(exponent);
 		int lostDigits = !double.IsFinite(magnitude)
 			? DoubleSignificantDigits
 			: magnitude > 1 ? (int)Math.Ceiling(Math.Log10(magnitude)) : 0;
 
 		return int.Max(1, int.Min(significantDigits, DoubleSignificantDigits - lostDigits));
 	}
@@ -891,6 +891,21 @@
 			? Value.CompareTo(significantNumber.Value)
 			: Value.CompareTo(obj);
 
+	/// <summary>
+	/// Determines whether the current instance holds the same value as a <see cref="PreciseNumber"/>.
+	/// </summary>
+	/// <param name="other">The precise number to compare with the current instance.</param>
+	/// <returns><see langword="true"/> if the values are equal; otherwise, <see langword="false"/>.</returns>
+	/// <remarks>
+	/// The values are compared exactly, so the result agrees with <c>==</c> and with
+	/// <see cref="PreciseNumber.Equals(PreciseNumber)"/> called the other way round. A <see cref="PreciseNumber"/> boxed as
+	/// an <see cref="object"/> still goes to <see cref="Equals(SignificantNumber)"/> through the record's
+	/// <c>Equals(object)</c>, which returns <see langword="false"/> because the object is not a
+	/// <see cref="SignificantNumber"/>, even though <see cref="CompareTo(object)"/> returns zero for it.
+	/// </remarks>
+	public bool Equals(PreciseNumber other) =>
+		Value.Equals(other);
+
 	/// <summary>
 	/// Returns the absolute value of the specified <see cref="SignificantNumber"/>.
 	/// </summary>