         return scale - (mantissa.bitWidth-1)
     }
     public var significand:BigFloat {
+        // print("\(#line)", self)
+        if self.isNaN || self.isSignalingNaN || self.isZero || self.isInfinite { return self }
         return BigFloat(scale: self.scale - (mantissa.bitWidth + 2), mantissa:self.mantissa)
     }
     public var decomposed:(sign:FloatingPointSign, exponent:Exponent, significand:BigFloat) {

            :    scale  < 0 ? .minus : .plus    // ±0 and inifinity
    }
    public mutating func negate() {
        if Swift.abs(scale) == Int.max {
            scale.negate()
        }
        else if mantissa == 0 {

/// 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
            }
        }
    }
}
