Permalink
Fetching contributors…
Cannot retrieve contributors at this time
864 lines (777 sloc) 29.5 KB
//
// Rational.swift
// NumericAnnex
//
// Created by Xiaodi Wu on 4/15/17.
//
/// A type to represent a rational value.
///
/// - Note: `Ratio` is a type alias for `Rational<Int>`.
///
/// Create new instances of `Rational<T>` by using integer literals and the
/// division (`/`) operator. For example:
///
/// ```swift
/// let x = 1 / 3 as Ratio // `x` is of type `Rational<Int>`
/// let y = 2 as Ratio // `y` is of type `Rational<Int>`
/// let z: Ratio = 2 / 3 // `z` is also of type `Rational<Int>`
///
/// print(x + y + z) // Prints "3"
/// ```
///
/// You can create an unreduced fraction by using the initializer
/// `Rational<T>.init(numerator:denominator:)`. For example:
///
/// ```swift
/// let a = Ratio(numerator: 3, denominator: 3)
/// print(a) // Prints "3/3"
/// ```
///
/// All arithmetic operations on values in canonical form (i.e. reduced to
/// lowest terms) return results in canonical form. However, operations on
/// values not in canonical form may or may not return results that are
/// themselves in canonical form. The property `canonicalized` is the canonical
/// form of any value.
///
/// Additional Considerations
/// -------------------------
///
/// ### Special Values
///
/// `Rational<T>` does not prohibit zero as a denominator. Any instance with a
/// positive numerator and zero denominator represents (positive) infinity; any
/// instance with a negative numerator and zero denominator represents negative
/// infinity; and any instance with zero numerator and zero denominator
/// represents NaN ("not a number").
///
/// As with floating-point types, `Rational<T>.infinity` compares greater than
/// every finite value and negative infinity, and `-Rational<T>.infinity`
/// compares less than every finite value and positive infinity. Infinite values
/// of the same sign compare equal to each other.
///
/// As with floating-point types, `Rational<T>.nan` does not compare equal to
/// any other value, including another NaN. Use the property `isNaN` to test if
/// a value is NaN. `Rational<T>` arithmetic operations are intended to
/// propagate NaN in the same manner as analogous floating-point operations.
///
/// ### Numerical Limits
///
/// When a value of type `Rational<T>` is in canonical form, the sign of the
/// numerator is the sign of the value; that is, in canonical form, the sign of
/// the denominator is always positive. Therefore, `-1 / T.min` cannot be
/// represented as a value of type `Rational<T>` because `abs(T.min)` cannot be
/// represented as a value of type `T`.
///
/// To ensure that every representable value of type `Rational<T>` has a
/// representable magnitude and reciprocal of the same type, an overflow trap
/// occurs when the division (`/`) operator is used to create a value of type
/// `Rational<T>` with numerator `T.min`.
@_fixed_layout
public struct Rational<T : SignedInteger> : Codable
where T : Codable & _ExpressibleByBuiltinIntegerLiteral,
T.Magnitude : UnsignedInteger {
// ---------------------------------------------------------------------------
// MARK: Stored Properties
// ---------------------------------------------------------------------------
/// The numerator of the rational value.
public var numerator: T
/// The denominator of the rational value.
public var denominator: T
// ---------------------------------------------------------------------------
// MARK: Initializers
// ---------------------------------------------------------------------------
/// Creates a new value from the given numerator and denominator without
/// computing its canonical form (i.e., without reducing to lowest terms).
///
/// To create a value reduced to lowest terms, use the division (`/`)
/// operator. For example:
///
/// ```swift
/// let x = 3 / 3 as Rational<Int>
/// print(x) // Prints "1"
/// ```
///
/// - Parameters:
/// - numerator: The new value's numerator.
/// - denominator: The new value's denominator.
@_transparent // @_inlineable
public init(numerator: T, denominator: T) {
self.numerator = numerator
self.denominator = denominator
}
/// Creates a new rational value from the given binary integer.
///
/// If `source` or its magnitude is not representable as a numerator of type
/// `T`, a runtime error may occur.
///
/// - Parameters:
/// - source: A binary integer to convert to a rational value.
@_transparent // @_inlineable
public init<Source : BinaryInteger>(_ source: Source) {
let t = T(source)
// Ensure that `t.magnitude` is representable as a `T`.
_ = T(t.magnitude)
self.numerator = t
self.denominator = 1
}
/// Creates a new rational value from the given binary floating-point value.
///
/// If `source` or its magnitude is not representable exactly as a ratio of
/// two signed integers of type `T`, a runtime error may occur.
///
/// - Parameters:
/// - source: A binary floating-point value to convert to a rational value.
@_transparent // @_inlineable
public init<Source : BinaryFloatingPoint>(_ source: Source) {
if source.isNaN { self = .nan; return }
if source == .infinity { self = .infinity; return }
if source == -.infinity { self = -.infinity; return }
if source.isZero { self = 0; return }
let exponent = source.exponent
let significandWidth = source.significandWidth
let shift = Source.Exponent(significandWidth) - exponent
if shift <= 0 {
self.numerator = T(source)
self.denominator = 1
return
}
let numerator = T(
Source(
sign: source.sign,
exponent: exponent + shift,
significand: source.significand
)
)
let denominator = T(Source(sign: .plus, exponent: shift, significand: 1))
// Ensure that `numerator.magnitude` and `denominator.magnitude` are each
// representable as a `T`.
_ = T(numerator.magnitude)
_ = T(denominator.magnitude)
self.numerator = numerator
self.denominator = denominator
}
}
extension Rational where T : FixedWidthInteger {
// ---------------------------------------------------------------------------
// MARK: Initializers (Constrained)
// ---------------------------------------------------------------------------
/// Creates a new rational value from the given binary floating-point value,
/// if it can be represented exactly.
///
/// If `source` or its magnitude is not representable exactly as a ratio of
/// two signed integers of type `T`, the result is `nil`.
///
/// - Note: This initializer creates only instances of
/// `Rational<T> where T : FixedWidthInteger`.
///
/// - Parameters:
/// - source: A floating-point value to convert to a rational value.
@_transparent // @_inlineable
public init?<Source : BinaryFloatingPoint>(exactly source: Source) {
// TODO: Document this initializer.
if source.isNaN { self = .nan; return }
if source == .infinity { self = .infinity; return }
if source == -.infinity { self = -.infinity; return }
if source.isZero { self = 0; return } // Consider -0.0 to be exactly 0.
let exponent = source.exponent
let significandWidth = source.significandWidth
let shift = Source.Exponent(significandWidth) - exponent
let bitWidth = T.bitWidth
if shift <= 0 {
guard exponent + 1 < bitWidth else { return nil }
self.numerator = T(source)
self.denominator = 1
return
}
guard significandWidth + 1 < bitWidth && shift + 1 < bitWidth else {
return nil
}
self.numerator = T(
Source(
sign: source.sign,
exponent: exponent + shift,
significand: source.significand
)
)
self.denominator = T(Source(sign: .plus, exponent: shift, significand: 1))
}
}
extension Rational {
// ---------------------------------------------------------------------------
// MARK: Static Properties
// ---------------------------------------------------------------------------
/// Positive infinity.
///
/// Infinity compares greater than all finite numbers and equal to other
/// (positive) infinite values.
@_transparent // @_inlineable
public static var infinity: Rational {
return Rational(numerator: 1, denominator: 0)
}
/// A quiet NaN ("not a number").
///
/// A NaN compares not equal, not greater than, and not less than every value,
/// including itself. Passing a NaN to an operation generally results in NaN.
@_transparent // @_inlineable
public static var nan: Rational {
return Rational(numerator: 0, denominator: 0)
}
// ---------------------------------------------------------------------------
// MARK: Static Methods
// ---------------------------------------------------------------------------
/// Compares the (finite) magnitude of two finite values, returning -1 if
/// `lhs.magnitude` is less than `rhs.magnitude`, 0 if `lhs.magnitude` is
/// equal to `rhs.magnitude`, or 1 if `lhs.magnitude` is greater than
/// `rhs.magnitude`.
@_versioned
internal static func _compareFiniteMagnitude(
_ lhs: Rational, _ rhs: Rational
) -> Int {
let ldm = lhs.denominator.magnitude
let rdm = rhs.denominator.magnitude
let gcd = T.Magnitude.gcd(ldm, rdm)
let a = rdm / gcd * lhs.numerator.magnitude
let b = ldm / gcd * rhs.numerator.magnitude
return a == b ? 0 : (a < b ? -1 : 1)
// FIXME: Use full-width multiplication to avoid trapping on overflow
// where `T : FixedWidthInteger, T.Magnitude : FixedWidthInteger`.
/*
let a = (rdm / gcd).multipliedFullWidth(by: lhs.numerator.magnitude)
let b = (ldm / gcd).multipliedFullWidth(by: rhs.numerator.magnitude)
return a.high == b.high
? (a.low == b.low ? 0 : (a.low < b.low ? -1 : 1))
: (a.high < b.high ? -1 : 1)
*/
}
/// Returns the quotient obtained by dividing the first value by the second,
/// trapping in case of arithmetic overflow.
///
/// - Parameters:
/// - lhs: The value to divide.
/// - rhs: The value by which to divide `lhs`.
@_transparent // @_inlineable
public static func / (lhs: Rational, rhs: Rational) -> Rational {
return lhs * rhs.reciprocal()
}
/// Divides the left-hand side by the right-hand side and stores the quotient
/// in the left-hand side, trapping in case of arithmetic overflow.
///
/// - Parameters:
/// - lhs: The value to divide.
/// - rhs: The value by which to divide `lhs`.
@_transparent // @_inlineable
public static func /= (lhs: inout Rational, rhs: Rational) {
lhs = lhs * rhs.reciprocal()
}
// ---------------------------------------------------------------------------
// MARK: Computed Properties
// ---------------------------------------------------------------------------
/// The canonical representation of this value.
@_transparent // @_inlineable
public var canonical: Rational {
let nm = numerator.magnitude, dm = denominator.magnitude
// Note that if `T` is a signed fixed-width integer type, `gcd(nm, dm)`
// could be equal to `-T.min`, which is not representable as a `T`. This is
// why the following arithmetic is performed with values of type
// `T.Magnitude`.
let gcd = T.Magnitude.gcd(nm, dm)
guard gcd != 0 else { return self }
let n = sign == .plus ? T(nm / gcd) : -T(nm / gcd)
let d = T(dm / gcd)
return Rational(numerator: n, denominator: d)
}
/// A Boolean value indicating whether the instance's representation is in
/// canonical form.
@_transparent // @_inlineable
public var isCanonical: Bool {
if denominator > 0 {
return T.Magnitude.gcd(numerator.magnitude, denominator.magnitude) == 1
}
return denominator == 0 && numerator.magnitude <= 1
}
/// A Boolean value indicating whether the instance is finite.
///
/// All values other than NaN and infinity are considered finite.
@_transparent // @_inlineable
public var isFinite: Bool {
return denominator != 0
}
/// A Boolean value indicating whether the instance is infinite.
///
/// Note that `isFinite` and `isInfinite` do not form a dichotomy because NaN
/// is neither finite nor infinite.
@_transparent // @_inlineable
public var isInfinite: Bool {
return denominator == 0 && numerator != 0
}
/// A Boolean value indicating whether the instance is NaN ("not a number").
///
/// Because NaN is not equal to any value, including NaN, use this property
/// instead of the equal-to operator (`==`) or not-equal-to operator (`!=`) to
/// test whether a value is or is not NaN.
@_transparent // @_inlineable
public var isNaN: Bool {
return denominator == 0 && numerator == 0
}
/// A Boolean value indicating whether the instance is a proper fraction.
///
/// A fraction is proper if and only if the absolute value of the fraction is
/// less than 1.
@_transparent // @_inlineable
public var isProper: Bool {
return denominator != 0 && numerator / denominator == 0
}
/// A Boolean value indicating whether the instance is equal to zero.
@_transparent // @_inlineable
public var isZero: Bool {
return denominator != 0 && numerator == 0
}
/// The magnitude (absolute value) of this value.
@_transparent // @_inlineable
public var magnitude: Rational {
return sign == .minus ? -self : self
}
/// The mixed form representing this value.
///
/// If the value is not finite, the mixed form has zero as its whole part and
/// the value as its fractional part.
@_transparent // @_inlineable
public var mixed: (whole: T, fractional: Rational) {
if denominator == 0 { return (whole: 0, fractional: self) }
let t = numerator.quotientAndRemainder(dividingBy: denominator)
return (
whole: t.quotient,
fractional: Rational(numerator: t.remainder, denominator: denominator)
)
}
/// The sign of this value.
@_transparent // @_inlineable
public var sign: Sign {
return numerator == 0 || (denominator < 0) == (numerator < 0)
? .plus
: .minus
}
// ---------------------------------------------------------------------------
// MARK: Methods
// ---------------------------------------------------------------------------
/// Returns the reciprocal (multiplicative inverse) of this value.
@_transparent // @_inlineable
public func reciprocal() -> Rational {
return numerator < 0
? Rational(numerator: -denominator, denominator: -numerator)
: Rational(numerator: denominator, denominator: numerator)
}
/// Returns this value rounded to an integral value using the specified
/// rounding rule.
///
/// ```swift
/// let x = 7 / 2 as Rational<Int>
/// print(x.rounded()) // Prints "4"
/// print(x.rounded(.towardZero)) // Prints "3"
/// print(x.rounded(.up)) // Prints "4"
/// print(x.rounded(.down)) // Prints "3"
/// ```
///
/// See the `FloatingPointRoundingRule` enumeration for more information about
/// the available rounding rules.
///
/// - Parameters:
/// - rule: The rounding rule to use.
///
/// - SeeAlso: `round(_:)`, `RoundingRule`
@_transparent // @_inlineable
public func rounded(
_ rule: RoundingRule = .toNearestOrAwayFromZero
) -> Rational {
var t = self
t.round(rule)
return t
}
/// Rounds the value to an integral value using the specified rounding rule.
///
/// ```swift
/// var x = 7 / 2 as Rational<Int>
/// x.round() // x == 4
///
/// var x = 7 / 2 as Rational<Int>
/// x.round(.towardZero) // x == 3
///
/// var x = 7 / 2 as Rational<Int>
/// x.round(.up) // x == 4
///
/// var x = 7 / 2 as Rational<Int>
/// x.round(.down) // x == 3
/// ```
///
/// See the `FloatingPointRoundingRule` enumeration for more information about
/// the available rounding rules.
///
/// - Parameters:
/// - rule: The rounding rule to use.
///
/// - SeeAlso: `round(_:)`, `RoundingRule`
@_transparent // @_inlineable
public mutating func round(_ rule: RoundingRule = .toNearestOrAwayFromZero) {
if denominator == 0 { return }
let f: T
(numerator, f) = numerator.quotientAndRemainder(dividingBy: denominator)
// Rounding rules only come into play if the fractional part is non-zero.
if f != 0 {
switch rule {
case .toNearestOrAwayFromZero:
fallthrough
case .toNearestOrEven:
switch denominator.magnitude.quotientAndRemainder(
dividingBy: f.magnitude
) {
case (2, 0): // Tie.
if rule == .toNearestOrEven && numerator % 2 == 0 { break }
fallthrough
case (1, _): // Nearest is away from zero.
if f > 0 { numerator += 1 } else { numerator -= 1 }
default: // Nearest is toward zero.
break
}
case .up:
if f > 0 { numerator += 1 }
case .down:
if f < 0 { numerator -= 1 }
case .towardZero:
break
case .awayFromZero:
if f > 0 { numerator += 1 } else { numerator -= 1 }
}
}
denominator = 1
}
}
extension Rational : ExpressibleByIntegerLiteral {
// ---------------------------------------------------------------------------
// MARK: ExpressibleByIntegerLiteral
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public init(integerLiteral value: T) {
self.numerator = value
self.denominator = 1
}
}
extension Rational : CustomStringConvertible {
// ---------------------------------------------------------------------------
// MARK: CustomStringConvertible
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public var description: String {
if numerator == 0 { return denominator == 0 ? "nan" : "0" }
if denominator == 0 { return numerator < 0 ? "-inf" : "inf" }
return denominator == 1 ? "\(numerator)" : "\(numerator)/\(denominator)"
}
}
extension Rational : Equatable {
// ---------------------------------------------------------------------------
// MARK: Equatable
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public static func == (lhs: Rational, rhs: Rational) -> Bool {
if lhs.denominator == 0 {
if lhs.numerator == 0 { return false }
if lhs.numerator > 0 { return rhs.denominator == 0 && rhs.numerator > 0 }
return rhs.denominator == 0 && rhs.numerator < 0
}
if rhs.denominator == 0 { return false }
return lhs.sign == rhs.sign && _compareFiniteMagnitude(lhs, rhs) == 0
}
}
extension Rational : Hashable {
// ---------------------------------------------------------------------------
// MARK: Hashable
// ---------------------------------------------------------------------------
// @_transparent // @_inlineable
public var hashValue: Int {
let t = canonical
return _Hash._combine(t.numerator, t.denominator)
}
}
extension Rational : Comparable {
// ---------------------------------------------------------------------------
// MARK: Comparable
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public static func < (lhs: Rational, rhs: Rational) -> Bool {
if lhs.denominator == 0 {
if lhs.numerator >= 0 { return false }
return rhs.denominator != 0 || rhs.numerator > 0
}
if rhs.denominator == 0 { return rhs.numerator > 0 }
switch (lhs.sign, rhs.sign) {
case (.plus, .minus):
return false
case (.minus, .plus):
return true
case (.plus, .plus):
return _compareFiniteMagnitude(lhs, rhs) < 0
case (.minus, .minus):
return _compareFiniteMagnitude(lhs, rhs) > 0
}
}
@_transparent // @_inlineable
public static func > (lhs: Rational, rhs: Rational) -> Bool {
return rhs < lhs
}
@_transparent // @_inlineable
public static func <= (lhs: Rational, rhs: Rational) -> Bool {
if lhs.denominator == 0 {
if lhs.numerator == 0 { return false }
if lhs.numerator > 0 { return rhs.denominator == 0 && rhs.numerator > 0 }
return rhs.denominator != 0 || rhs.numerator != 0
}
if rhs.denominator == 0 { return rhs.numerator > 0 }
switch (lhs.sign, rhs.sign) {
case (.plus, .minus):
return false
case (.minus, .plus):
return true
case (.plus, .plus):
return _compareFiniteMagnitude(lhs, rhs) <= 0
case (.minus, .minus):
return _compareFiniteMagnitude(lhs, rhs) >= 0
}
}
@_transparent // @_inlineable
public static func >= (lhs: Rational, rhs: Rational) -> Bool {
return rhs <= lhs
}
}
extension Rational : Strideable {
// ---------------------------------------------------------------------------
// MARK: Strideable
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public func distance(to other: Rational) -> Rational {
return other - self
}
@_transparent // @_inlineable
public func advanced(by amount: Rational) -> Rational {
return self + amount
}
}
extension Rational : Numeric {
// ---------------------------------------------------------------------------
// MARK: Numeric
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public init?<U>(exactly source: U) where U : BinaryInteger {
guard let t = T(exactly: source) else { return nil }
// Ensure that `t.magnitude` is representable as a `T`.
guard let _ = T(exactly: t.magnitude) else { return nil }
self.numerator = t
self.denominator = 1
}
@_transparent // @_inlineable
public static func + (lhs: Rational, rhs: Rational) -> Rational {
if lhs.denominator == 0 {
if rhs.denominator != 0 || lhs.numerator == 0 { return lhs }
if lhs.numerator > 0 { return rhs.numerator < 0 ? .nan : rhs }
return rhs.numerator > 0 ? .nan : rhs
}
if rhs.denominator == 0 { return rhs }
let ldm = lhs.denominator.magnitude
let rdm = rhs.denominator.magnitude
let gcd = T.Magnitude.gcd(ldm, rdm)
let a = T(rdm / gcd * lhs.numerator.magnitude)
let b = T(ldm / gcd * rhs.numerator.magnitude)
let n = lhs.sign == .plus
? (rhs.sign == .plus ? a + b : a - b)
: (rhs.sign == .plus ? b - a : -a - b)
let d = T(ldm / gcd * rdm)
return Rational(numerator: n, denominator: d).canonical
}
@_transparent // @_inlineable
public static func += (lhs: inout Rational, rhs: Rational) {
lhs = lhs + rhs
}
@_transparent // @_inlineable
public static func - (lhs: Rational, rhs: Rational) -> Rational {
return lhs + (-rhs)
}
@_transparent // @_inlineable
public static func -= (lhs: inout Rational, rhs: Rational) {
lhs = lhs + (-rhs)
}
@_transparent // @_inlineable
public static func * (lhs: Rational, rhs: Rational) -> Rational {
if lhs.denominator == 0 {
if rhs.numerator == 0 { return .nan }
return rhs.sign == .plus ? lhs : -lhs
}
if rhs.denominator == 0 {
if lhs.numerator == 0 { return .nan }
return lhs.sign == .plus ? rhs : -rhs
}
let lnm = lhs.numerator.magnitude, ldm = lhs.denominator.magnitude
let rnm = rhs.numerator.magnitude, rdm = rhs.denominator.magnitude
// Note that if `T` is a signed fixed-width integer type, `gcd(lnm, rdm)` or
// `gcd(rnm, ldm)` could be equal to `-T.min`, which is not representable as
// a `T`. This is why the following arithmetic is performed with values of
// type `T.Magnitude`.
let a = T.Magnitude.gcd(lnm, rdm)
let b = T.Magnitude.gcd(rnm, ldm)
let n = lhs.sign == rhs.sign
? T(lnm / a * (rnm / b))
: -T(lnm / a * (rnm / b))
let d = T(ldm / b * (rdm / a))
return Rational(numerator: n, denominator: d)
}
@_transparent // @_inlineable
public static func *= (lhs: inout Rational, rhs: Rational) {
lhs = lhs * rhs
}
}
extension Rational : SignedNumeric {
// ---------------------------------------------------------------------------
// MARK: SignedNumeric
// ---------------------------------------------------------------------------
@_transparent // @_inlineable
public static prefix func - (operand: Rational) -> Rational {
return Rational(
numerator: -operand.numerator, denominator: operand.denominator
)
}
@_transparent // @_inlineable
public mutating func negate() {
numerator.negate()
}
}
/// Returns the absolute value (magnitude) of `x`.
@_transparent
public func abs<T>(_ x: Rational<T>) -> Rational<T> {
return x.magnitude
}
/// Returns the closest integral value greater than or equal to `x`.
@_transparent
public func ceil<T>(_ x: Rational<T>) -> Rational<T> {
return x.rounded(.up)
}
/// Returns the closest integral value less than or equal to `x`.
@_transparent
public func floor<T>(_ x: Rational<T>) -> Rational<T> {
return x.rounded(.down)
}
/// Returns the closest integral value; if two values are equally close, returns
/// the one with greater magnitude.
@_transparent
public func round<T>(_ x: Rational<T>) -> Rational<T> {
return x.rounded()
}
/// Returns the closest integral value with magnitude less than or equal to that
/// of `x`.
@_transparent
public func trunc<T>(_ x: Rational<T>) -> Rational<T> {
return x.rounded(.towardZero)
}
public typealias Ratio = Rational<Int>
// MARK: -
extension BinaryInteger {
// ---------------------------------------------------------------------------
// MARK: Initializers
// ---------------------------------------------------------------------------
/// Creates a new binary integer from the given rational value, if it can be
/// represented exactly.
///
/// If `source` is not representable exactly, the result is `nil`.
///
/// - Parameters:
/// - source: A rational value to convert to a binary integer.
@_transparent // @_inlineable
public init?<U>(exactly source: Rational<U>) {
let (whole, fraction) = source.mixed
guard fraction.isZero, let exact = Self(exactly: whole) else { return nil }
self = exact
}
/// Creates a new binary integer from the given rational value, rounding
/// toward zero.
///
/// If `source` is outside the bounds of this type after rounding toward zero,
/// a runtime error may occur.
///
/// - Parameters:
/// - source: A rational value to convert to a binary integer.
@_transparent // @_inlineable
public init<U>(_ source: Rational<U>) {
self = Self(source.mixed.whole)
}
}
extension FloatingPoint {
// ---------------------------------------------------------------------------
// MARK: Initializers
// ---------------------------------------------------------------------------
/// Creates a new floating-point value from the given rational value, after
/// rounding the whole part, the numerator of the fractional part, and the
/// denominator of the fractional part each to the closest possible
/// representation.
///
/// If two representable values are equally close, the result of rounding is
/// the value with more trailing zeros in its significand bit pattern.
///
/// - Parameters:
/// - source: The rational value to convert to a floating-point value.
public init(_ source: Rational<Int>) {
let (whole, fraction) = source.mixed
self = Self(whole) + Self(fraction.numerator) / Self(fraction.denominator)
}
/// Creates a new floating-point value from the given rational value, after
/// rounding the whole part, the numerator of the fractional part, and the
/// denominator of the fractional part each to the closest possible
/// representation.
///
/// If two representable values are equally close, the result of rounding is
/// the value with more trailing zeros in its significand bit pattern.
///
/// - Parameters:
/// - source: The rational value to convert to a floating-point value.
public init(_ source: Rational<Int8>) {
let (whole, fraction) = source.mixed
self = Self(whole) + Self(fraction.numerator) / Self(fraction.denominator)
}
/// Creates a new floating-point value from the given rational value, after
/// rounding the whole part, the numerator of the fractional part, and the
/// denominator of the fractional part each to the closest possible
/// representation.
///
/// If two representable values are equally close, the result of rounding is
/// the value with more trailing zeros in its significand bit pattern.
///
/// - Parameters:
/// - source: The rational value to convert to a floating-point value.
public init(_ source: Rational<Int16>) {
let (whole, fraction) = source.mixed
self = Self(whole) + Self(fraction.numerator) / Self(fraction.denominator)
}
/// Creates a new floating-point value from the given rational value, after
/// rounding the whole part, the numerator of the fractional part, and the
/// denominator of the fractional part each to the closest possible
/// representation.
///
/// If two representable values are equally close, the result of rounding is
/// the value with more trailing zeros in its significand bit pattern.
///
/// - Parameters:
/// - source: The rational value to convert to a floating-point value.
public init(_ source: Rational<Int32>) {
let (whole, fraction) = source.mixed
self = Self(whole) + Self(fraction.numerator) / Self(fraction.denominator)
}
/// Creates a new floating-point value from the given rational value, after
/// rounding the whole part, the numerator of the fractional part, and the
/// denominator of the fractional part each to the closest possible
/// representation.
///
/// If two representable values are equally close, the result of rounding is
/// the value with more trailing zeros in its significand bit pattern.
///
/// - Parameters:
/// - source: The rational value to convert to a floating-point value.
public init(_ source: Rational<Int64>) {
let (whole, fraction) = source.mixed
self = Self(whole) + Self(fraction.numerator) / Self(fraction.denominator)
}
}