     }
     
     static func multiplyWithOverflow(_ lhs: Rational, _ rhs: Rational) -> (Rational, overflow: Bool) {
-        guard lhs.isFinite() && rhs.isFinite() else {
+        if lhs.isInfinite || rhs.isInfinite {
             return (Rational(lhs.numerator * rhs.numerator, 0), false);
         }
 

    /// Initialize a Double from a Rational
    /// - Note: If the deonominator is zero, the Double will be initialized to +/- infinity
    init(_ number: Rational) {
        if number.isFinite() {
            self = Double(number.numerator) / Double(number.denominator);
        } else if number.isInfinite() {
            self = number.numerator > 0 ? Double.infinity : -Double.infinity;
        } else {
            self = Double.nan;

    
    /// Is the Rational finite?
    /// Returns: False if the denominator is 0, True otherwise
    var isFinite : Bool {
        return denominator != 0;
    }
    
    /// Is the Rational infinite?
    /// Returns: True if the denominator is 0, False otherwise
    var isInfinite : Bool {
        return numerator != 0 && denominator == 0;
    }
    
    /// Is the Rational not a number?
    /// Returns: True if the numerator and denominator are 0, False otherwise
    var isNaN : Bool {
        return numerator == 0 && denominator == 0;
    }
}
