Type conversions to integers or decimal types without support for _NaN_ or _Infinity_ now throw an OverflowException instead of a DivideByZeroException.

Author: danm-de

BreakingChanges.md

@@ -9,6 +9,7 @@ This file contains a summary of the most important breaking changes, sorted by v
 ### 9.0.0
 
 - When using the .NET8 assembly, the data type implements the two interfaces `INumber<Fraction>` and `ISignedNumber<Fraction>` with the corresponding support but also possible side effects when using the generic [math functions](https://learn.microsoft.com/en-us/dotnet/standard/generics/math). For more information, see this [Microsoft blog article](https://devblogs.microsoft.com/dotnet/dotnet-7-generic-math/).
+- Type conversions to integers or decimal types without support for _NaN_ or _Infinity_ now throw an `OverflowException` instead of a `DivideByZeroException`.
 
 ### 8.0.0
 

Changelog.md

@@ -5,10 +5,12 @@
 - PR [Implemented the INumber<Fraction> interface](https://github.com/Fractions-DotNet/Fractions/pull/96) by [lipchev](https://github.com/lipchev)
 - PR [More DecimalQuantityFormatter performance optimizations](https://github.com/Fractions-DotNet/Fractions/pull/115) by [lipchev](https://github.com/lipchev)
 - Replaced [FluentAssertions](https://xceed.com/products/unit-testing/fluent-assertions/) with [AwesomeAssertions](https://awesomeassertions.org/)
+- Type conversions to integers or decimal types without support for _NaN_ or _Infinity_ now throw an `OverflowException` instead of a `DivideByZeroException`.
 
 ### Breaking changes
 
 - When using the .NET8 assembly, the data type implements the two interfaces `INumber<Fraction>` and `ISignedNumber<Fraction>` with the corresponding support but also possible side effects when using the generic [math functions](https://learn.microsoft.com/en-us/dotnet/standard/generics/math). For more information, see this [Microsoft blog article](https://devblogs.microsoft.com/dotnet/dotnet-7-generic-math/).
+- Type conversions to integers or decimal types without support for _NaN_ or _Infinity_ now throw an `OverflowException` instead of a `DivideByZeroException`. 
 
 ## 8.3.2
 - PR [Optimizing the PowerOfTen function for exponents in the range 18-54](https://github.com/danm-de/Fractions/pull/110) by [lipchev](https://github.com/lipchev)

src/Fractions/Fraction.ConvertTo.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Numerics;
+using Fractions.Properties;
 
 namespace Fractions;
 
@@ -13,9 +14,8 @@ public readonly partial struct Fraction {
     ///     Converts the fraction to a 32-bit signed integer.
     /// </summary>
     /// <returns>The result of the integer division of the numerator by the denominator.</returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     /// <exception cref="OverflowException">
-    ///     Thrown when the result of the division is outside the range of a 32-bit signed integer.
+    ///     Thrown when the result of the division is outside the range of a 32-bit signed integer or when the denominator is zero, meaning the value is NaN or infinity.
     /// </exception>
     public int ToInt32() {
         return (int)ToBigInteger();
@@ -25,9 +25,8 @@ public int ToInt32() {
     ///     Converts the fraction to a 64-bit signed integer.
     /// </summary>
     /// <returns>The result of the integer division of the numerator by the denominator.</returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     /// <exception cref="OverflowException">
-    ///     Thrown when the result of the division is outside the range of a 64-bit signed integer.
+    ///     Thrown when the result of the division is outside the range of a 64-bit signed integer or when the denominator is zero, meaning the value is NaN or infinity.
     /// </exception>
     public long ToInt64() {
         return (long)ToBigInteger();
@@ -37,9 +36,8 @@ public long ToInt64() {
     ///     Converts the fraction to a 32-bit unsigned integer.
     /// </summary>
     /// <returns>The result of the integer division of the numerator by the denominator.</returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     /// <exception cref="OverflowException">
-    ///     Thrown when the result of the division is outside the range of a 32-bit unsigned integer.
+    ///     Thrown when the result of the division is outside the range of a 32-bit unsigned integer or when the denominator is zero, meaning the value is NaN or infinity.
     /// </exception>
     [CLSCompliant(false)]
     public uint ToUInt32() {
@@ -50,9 +48,8 @@ public uint ToUInt32() {
     ///     Converts the fraction to a 64-bit unsigned integer.
     /// </summary>
     /// <returns>The result of the integer division of the numerator by the denominator.</returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     /// <exception cref="OverflowException">
-    ///     Thrown when the result of the division is outside the range of a 64-bit unsigned integer.
+    ///     Thrown when the result of the division is outside the range of a 64-bit unsigned integer or when the denominator is zero, meaning the value is NaN or infinity.
     /// </exception>
     [CLSCompliant(false)]
     public ulong ToUInt64() {
@@ -63,9 +60,14 @@ public ulong ToUInt64() {
     ///     Converts the fraction to a BigInteger.
     /// </summary>
     /// <returns>The result of the integer division of the numerator by the denominator.</returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
+    /// <exception cref="OverflowException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     public BigInteger ToBigInteger() {
         var denominator = Denominator;
+
+        if (denominator.IsZero) {
+            throw new OverflowException(Resources.ValueMustNotNanOrInfinity);
+        }
+
         return denominator.IsOne ? Numerator : Numerator / denominator;
     }
 
@@ -76,17 +78,16 @@ public BigInteger ToBigInteger() {
     ///     The fraction represented as a decimal. If the number exceeds decimal precision, the extra decimals are lost
     ///     due to rounding.
     /// </returns>
-    /// <exception cref="DivideByZeroException">Thrown when the denominator is zero - i.e. the value is NaN or Infinity.</exception>
     /// <exception cref="OverflowException">
-    ///     Thrown when the number represented by this fraction is outside the decimal range.
+    ///     Thrown when the number represented by this fraction is outside the decimal range or when the denominator is zero, meaning the value is NaN or infinity.
     /// </exception>
     public decimal ToDecimal() {
         var numerator = Numerator;
         var denominator = Denominator;
         switch (denominator.Sign) {
             case 0: {
-                throw new DivideByZeroException();
-            }
+                throw new OverflowException(Resources.ValueMustNotNanOrInfinity);
+                }
             case -1: {
                 numerator = -numerator;
                 denominator = -denominator;

src/Fractions/Fraction.Round.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Numerics;
+using Fractions.Properties;
 
 namespace Fractions;
 
@@ -99,9 +100,12 @@ public static BigInteger RoundToBigInteger(Fraction fraction, MidpointRounding m
     /// <param name="denominator">The denominator of the fraction to be rounded.</param>
     /// <param name="mode">Specifies the strategy that mathematical rounding methods should use to round a number.</param>
     /// <returns>The number rounded to using the <paramref name="mode" /> rounding strategy.</returns>
+    /// <exception cref="OverflowException">
+    ///     Thrown when the denominator is zero, meaning the value is NaN or infinity.
+    /// </exception>
     private static BigInteger RoundToBigInteger(BigInteger numerator, BigInteger denominator, MidpointRounding mode) {
         if (denominator.IsZero) {
-            throw new DivideByZeroException();
+            throw new OverflowException(Resources.ValueMustNotNanOrInfinity);
         }
 
         if (numerator.IsZero || denominator.IsOne) {

src/Fractions/Properties/Resources.Designer.cs

@@ -141,4 +141,7 @@
   <data name="InvalidTokenType" xml:space="preserve">
     <value>Invalid token type {0} (expected {1}).</value>
   </data>
+  <data name="ValueMustNotNanOrInfinity" xml:space="preserve">
+    <value>The value must not be NaN or +/-infinity.</value>
+  </data>
 </root>

src/Fractions/Properties/Resources.resx

@@ -222,9 +222,9 @@ from midpointRounding in RoundingModes
 
     [Test]
     [TestCaseSource(nameof(RoundNaNToBigIntegerTestCases))]
-    public void The_result_of_rounding_NaN_to_BigInteger_should_be_a_DivideByZeroException(Fraction fraction,
+    public void The_result_of_rounding_NaN_to_BigInteger_should_be_a_OverflowException(Fraction fraction,
         MidpointRounding roundingMode) {
-        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<DivideByZeroException>();
+        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<OverflowException>();
     }
 
     private static IEnumerable RoundPositiveInfinityToBigIntegerTestCases =>
@@ -233,9 +233,9 @@ from midpointRounding in RoundingModes
 
     [Test]
     [TestCaseSource(nameof(RoundPositiveInfinityToBigIntegerTestCases))]
-    public void The_result_of_rounding_PositiveInfinity_to_BigInteger_should_throw_a_DivideByZeroException(
+    public void The_result_of_rounding_PositiveInfinity_to_BigInteger_should_throw_a_OverflowException(
         Fraction fraction, MidpointRounding roundingMode) {
-        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<DivideByZeroException>();
+        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<OverflowException>();
     }
 
     private static IEnumerable RoundNegativeInfinityToBigIntegerTestCases =>
@@ -244,9 +244,9 @@ from midpointRounding in RoundingModes
 
     [Test]
     [TestCaseSource(nameof(RoundNegativeInfinityToBigIntegerTestCases))]
-    public void The_result_of_rounding_NegativeInfinity_to_BigInteger_should_throw_a_DivideByZeroException(
+    public void The_result_of_rounding_NegativeInfinity_to_BigInteger_should_throw_a_OverflowException(
         Fraction fraction, MidpointRounding roundingMode) {
-        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<DivideByZeroException>();
+        Invoking(() => Fraction.RoundToBigInteger(fraction, roundingMode)).Should().Throw<OverflowException>();
     }
 
     [Test]