Arbitrary Precision Rationals

A rational number is a number that can be expressed as a ratio of two integers. The same rational number can be represented in many different ways. For example, 1/2 = 3/6 = -5/-10, and so on. A unique representation can be defined by requiring that the numerator and the denominator do not have any common divisors, and requiring that the denominator is always positive.

Numerics.NET provides the BigRational class, which can represent rational numbers where the numerator and the denominator are arbitrary size integers. The internal representation of rational numbers is always normalized. Furthermore, the number 0 is represented as 0/1.

The BigRational class has three constructors. The first constructor takes two arguments: two BigInteger values that represent the numerator and the denominator. The second constructor takes two 32 bit integer arguments that once again represent the numerator and the denominator. The third constructor takes one BigInteger argument. It constructs the BigRational representation of the integer. The denominator is set equal to one.

BigInteger n = BigInteger.Pow(2, 111);
BigInteger d = BigInteger.Pow(3, 111);
BigRational a = new BigRational(n, d);
BigRational b = new BigRational(1, 5);
BigRational c = new BigRational(n);

Dim n As BigInteger = BigInteger.Pow(2, 111)
Dim d As BigInteger = BigInteger.Pow(3, 111)
Dim a As BigRational = New BigRational(n, d)
Dim b As BigRational = New BigRational(1, 5)
Dim c As BigRational = New BigRational(n)

No code example is currently available or this language may not be supported.

let n = BigInteger.Pow(2, 111)
let d = BigInteger.Pow(3, 111)
let a = new BigRational(n, d)
let b = new BigRational(1, 5)
let c = new BigRational(n)
//

The BigRational class provides several constants for commonly used and special rational numbers. These are listed in the following table:

Working with rational numbers is easy. The Numerator property gets the numerator of the rational number, while Denominator gets the denominator. The numerator and the denominator never have common divisors and the denominator is always positive. The Sign property returns the sign of the rational number.

Details of rational arithmetic

When performing binary operations, if one of the operands is a BigRational, and the other operand is an integer of any size (including BigInteger), then the integer operand is converted to BigRational, and, if the operation produces a numerical result, the type of the result is BigRational.

Operations with non-integer types, including, Decimal, are not supported.

Arithmetic operations

Numerics.NET provides methods for all basic arithmetic operators on rational numbers. Most contain special versions for cases where one of the operands is real. Overloaded versions of the arithmetic operators are provided for languages that support them. For languages that don't support operator overloading, equivalent static (Shared in Visual Basic) methods are supplied. For example:

BigRational e = new BigRational(2, 7);
BigRational f = new BigRational(3, 5);
BigRational g = 2 - 3 * (e + f);

Dim e As BigRational = New BigRational(2, 7)
Dim f As BigRational = New BigRational(3, 5)
Dim g As BigRational = 2 - 3 * (e + f)

No code example is currently available or this language may not be supported.

let e = new BigRational(2, 7)
let f = new BigRational(3, 5)
let g = 2 - 3 * (e + f)
//

In addition, the relational operators are also available. In a language that does not support custom operators, the Equals or CompareTo method can be used.

Functions of rational numbers

The Abs method returns the absolute value of a rational number. The Max and Min methods return the larger and smaller of two rational numbers, respectively. The Floor method returns the largest integer less than or equal to a rational number. The Ceiling method returns the smallest integer greater than or equal to a number. The Round method rounds a rational number to the specified number of decimal digits.

Casts and conversions

Converting to big integers

The BigRational type supports implicit conversions from all numerical including BigInteger.

For the built-in floating-point types, Single and Double, and Decimal, the result is the exact representation as a rational number where the denominator is a power of 2 or 10.

Converting from rational numbers

There are no implicit conversions from BigRational to any of the built-in numerical types. For integral types, the explicit conversions first round the number towards zero and return the least significant bits of the rounded value that fit in the type. For example, the conversion to a 32 bit unsigned integer contains the 32 least significant bits of the rounded value.

For the built-in floating-point types, Single and Double, the converted value is accurate to the first 24 or 53 bits, respectively. If the number is too large to be represented in the floating-point type, then either positive or negative infinity is returned.

The BigRational type also implements the IConvertible interface. The implementation is explicit. In order to call any of the conversion functions, you first need to cast the original to the IConvertible interface type.

Unlike type casts, calls to these conversion types do throw an OverflowException when the value is too large to fit in an integral type or Decimal.