         return BigFloat(scale:Int.max, mantissa:+1)
     }
     public var isNaN:Bool {
-        return Swift.abs(scale) == Int.max && mantissa == +1
+        return scale != -Int.max-1 && Swift.abs(scale) == Int.max && mantissa == +1
     }
     public static var signalingNaN:BigFloat {
         return BigFloat(scale:Int.max, mantissa:-1)
     }
     public var isSignalingNaN:Bool {
-        return Swift.abs(scale) == Int.max && mantissa == -1
+        return scale != -Int.max-1 && Swift.abs(scale) == Int.max && mantissa == -1
     }
     public static var infinity:BigFloat {
         return BigFloat(scale:Int.max, mantissa:0)
     }
     public var isInfinite:Bool {
-        return Swift.abs(self.scale) == Int.max && mantissa == 0
+        return scale != -Int.max-1 && Swift.abs(self.scale) == Int.max && mantissa == 0
     }
     public static var zero:BigFloat         { return BigFloat(scale:0, mantissa:0) }
     public static var negativeZero:BigFloat { return BigFloat(scale:-Int.max-1, mantissa:0) }
     public var isZero:Bool {
-        return  mantissa == 0 && Swift.abs(scale) != Int.max
+        return  mantissa == 0 && scale == 0 || scale == -Int.max-1
     }
     public var sign: FloatingPointSign {
         return 0 < mantissa ? .plus

        return scale - (mantissa.bitWidth-1)
    }
    public var significand:BigFloat {
        return BigFloat(scale: self.scale - (mantissa.bitWidth + 2), mantissa:self.mantissa)
    }
    public var decomposed:(sign:FloatingPointSign, exponent:Exponent, significand:BigFloat) {

/// BigFloat -> Double
extension Double {
    public init(_ bf:BigFloat) { // tailored becaused it is the most frequently used
        if bf.mantissa.bitWidth-1 < 64 {
            self.init(sign:bf.sign, exponent:Exponent(bf.scale), significand:Double(bf.mantissa.magnitude))
        } else {
            let offset = bf.mantissa.bitWidth-1 - 64
            self.init(
                sign:bf.sign,
                exponent:Exponent(bf.scale + offset),
                significand:Double(bf.mantissa.magnitude >> offset)
            )
        }
    }
}
/// BigFloat -> BigRat
extension BigRat {
    public init(_ bf:BigFloat) {
        if bf.isNaN                 { self = BigRat.nan }
        else if bf.isSignalingNaN   { self = BigRat.signalingNaN }
        else if bf.isInfinite       { self = bf.sign == .minus ? -BigRat.infinity : +.infinity }
        else if bf.isZero           { self = bf.sign == .minus ? -BigRat.zero : +BigRat.zero }
        else {
            (num, den) = (bf.mantissa, 1)
            if bf.scale < 0 {
                den <<= -bf.scale
            } else {
                num <<= +bf.scale
            }
        }
    }
}
