     var isInfinite: Bool { return false }
     var isNaN: Bool { return false }
     var isSignaling: Bool { return false }
+    var nextPowerOf2: Int {
+        let c = ceil(log2(Double(self)))
+        return Int(pow(2.0, c))
+    }
+    var faculty : UInt64 {
+        let one = UInt64(1)
+        if self <= Self(1) { return one }
+        let value = UInt64(self)
+        return value * (value - one).faculty
+    }
 }
 
 protocol EnhancedFloatingPointType : NumericType {}
-extension EnhancedFloatingPointType {}
-
+extension EnhancedFloatingPointType {
+    var inaccuracy : Self {
+        let this : Self = self
+        let succ : Self = self.successor()
+        print("\(this) -> \(succ)")
+        return succ - this
+    }
+}
 
 extension Int    : EnhancedIntegerType {}
 extension Int8   : EnhancedIntegerType {}



func max<T : NumericType>(numbers: T...) -> T {
    return numbers.max { $0 > $1 }
}

func min<T : NumericType>(numbers: T...) -> T {
    return numbers.max { $0 < $1 }
}


    static var max : Float { return FLT_MAX }
    static var min : Float { return FLT_MIN }
    public func successor() -> Float {
        return nextafterf(self, FLT_MAX)
    }
}

