         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

    public static func +(_ lhs:BigFloat, _ rhs:BigFloat)->BigFloat {
        return nan
    }
    
    public func isLess(than other:BigFloat)->Bool {
        if self.isNaN  { return false }
        if other.isNaN { return false }
        if self.isInfinite { }
        fatalError()
    }
    public static func <(_ lhs:BigFloat, _ rhs:BigFloat)->Bool {
        return lhs.isLess(than:rhs)

extension BigFloat : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral {
    public init?<T:BinaryInteger>(exactly bi:T) {
        mantissa = Significand(bi)
        scale = 0
    }
    /// BinaryInteger -> BigFloat
    public init<T:BinaryInteger>(_ bi:T) { self.init(exactly:bi)! }
    public init(integerLiteral value: Int) { self.init(value) }
    /// BinaryFloatingPoint -> BigFloat
    public init?<T:BinaryFloatingPoint>(exactly bf:T) {
        if bf.isNaN                 { self = .nan }
        else if bf.isSignalingNaN   { self = .signalingNaN }
        else if bf.isInfinite       { self = bf.sign == .minus ? -.infinity : +.infinity }
        else if bf.isZero           { self = bf.sign == .minus ? .negativeZero : .zero }
        else {
            mantissa = Significand(bf.significandBitPattern | 1 << T.significandBitCount)
            mantissa >>= mantissa.trailingZeroBitCount
            if bf < 0 { mantissa.negate() }
            scale = Exponent(bf.exponent) - (mantissa.bitWidth-1 - 1)
        }
    }
    public init<T:BinaryFloatingPoint>(_ bf:T) { self.init(exactly:bf)! }
    public var asDouble:Double { return Double(self) }
