Generic implementations of math functions implementable on FloatingPoint. (#3524)

Replace the non-generic tgmath functions with generic <T: FloatingPoint> implementations where possible, and move the global sqrt() operation into tgmath.

Author: stephentyrone

stdlib/public/Platform/tgmath.swift.gyb

@@ -10,6 +10,52 @@
 //
 //===----------------------------------------------------------------------===//
 
+// Generic functions implementable directly on FloatingPoint.
+@_transparent
+public func fabs<T: FloatingPoint>(_ x: T) -> T {
+  return abs(x)
+}
+
+@_transparent
+public func sqrt<T: FloatingPoint>(_ x: T) -> T {
+  return x.squareRoot()
+}
+
+@_transparent
+public func fma<T: FloatingPoint>(_ x: T, _ y: T, _ z: T) -> T {
+  return z.addingProduct(x,y)
+}
+
+@_transparent
+public func remainder<T: FloatingPoint>(_ x: T, _ y: T) -> T {
+  return x.remainder(dividingBy: y)
+}
+
+@_transparent
+public func fmod<T: FloatingPoint>(_ x: T, _ y: T) -> T {
+  return x.truncatingRemainder(dividingBy: y)
+}
+
+@_transparent
+public func ceil<T: FloatingPoint>(_ x: T) -> T {
+  return x.rounded(.up)
+}
+
+@_transparent
+public func floor<T: FloatingPoint>(_ x: T) -> T {
+  return x.rounded(.down)
+}
+
+@_transparent
+public func round<T: FloatingPoint>(_ x: T) -> T {
+  return x.rounded()
+}
+
+@_transparent
+public func trunc<T: FloatingPoint>(_ x: T) -> T {
+  return x.rounded(.towardZero)
+}
+
 %{
 
 # Don't need 64-bit (Double/CDouble) overlays. The ordinary C imports work fine.
@@ -50,7 +96,7 @@ UnaryFunctions = [
     'acosh', 'asinh', 'atanh', 'cosh', 'sinh', 'tanh',
     'expm1',
     'log1p', 'logb',
-    'cbrt', 'sqrt', 'erf', 'erfc', 'tgamma',
+    'cbrt', 'erf', 'erfc', 'tgamma',
 ]
 
 # These functions have a corresponding LLVM intrinsic
@@ -60,22 +106,21 @@ UnaryIntrinsicFunctions = [
     'cos', 'sin',
     'exp', 'exp2',
     'log', 'log10', 'log2',
-    'fabs',
-    'ceil', 'floor', 'nearbyint', 'rint', 'round', 'trunc',
+    'nearbyint', 'rint',
 ]
 
 # (T, T) -> T
 BinaryFunctions = [
-    'atan2', 'hypot', 'pow', 'fmod',
-    'remainder', 'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
+    'atan2', 'hypot', 'pow',
+    'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
 ]
 
 # These functions have special implementations.
 OtherFunctions = [
     'fpclassify',
     'isnormal', 'isfinite', 'isinf', 'isnan', 'signbit',
     'modf', 'ldexp', 'frexp', 'ilogb', 'scalbn', 'lgamma',
-    'remquo', 'nan', 'fma',
+    'remquo', 'nan',
     'jn', 'yn'
 ]
 
@@ -117,7 +162,6 @@ def TypedBinaryFunctions():
 
 }%
 
-
 // Unary functions
 // Note these do not have a corresponding LLVM intrinsic
 % for T, CT, f, ufunc in TypedUnaryFunctions():
@@ -319,14 +363,6 @@ public func nan(_ tag: String) -> ${T} {
 
 % end
 
-% for T, CT, f in OverlayFloatTypes():
-@_transparent
-public func fma(_ x: ${T}, _ y: ${T}, _ z: ${T}) -> ${T} {
-  return ${T}(fma${f}(${CT}(x), ${CT}(y), ${CT}(z)))
-}
-
-% end
-
 % # These C functions only support double. The overlay fixes the Int parameter.
 @_transparent
 public func jn(_ n: Int, _ x: Double) -> Double {

stdlib/public/SDK/CoreGraphics/CGFloat.swift.gyb

@@ -605,26 +605,6 @@ public func tgamma(_ x: CGFloat) -> CGFloat {
   return CGFloat(tgamma(x.native))
 }
 
-@_transparent
-public func fabs(_ x: CGFloat) -> CGFloat {
-  return CGFloat(fabs(x.native))
-}
-
-@_transparent
-public func sqrt(_ x: CGFloat) -> CGFloat {
-  return CGFloat(sqrt(x.native))
-}
-
-@_transparent
-public func ceil(_ x: CGFloat) -> CGFloat {
-  return CGFloat(ceil(x.native))
-}
-
-@_transparent
-public func floor(_ x: CGFloat) -> CGFloat {
-  return CGFloat(floor(x.native))
-}
-
 @_transparent
 public func nearbyint(_ x: CGFloat) -> CGFloat {
   return CGFloat(nearbyint(x.native))
@@ -635,16 +615,6 @@ public func rint(_ x: CGFloat) -> CGFloat {
   return CGFloat(rint(x.native))
 }
 
-@_transparent
-public func round(_ x: CGFloat) -> CGFloat {
-  return CGFloat(round(x.native))
-}
-
-@_transparent
-public func trunc(_ x: CGFloat) -> CGFloat {
-  return CGFloat(trunc(x.native))
-}
-
 @_transparent
 public func atan2(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
   return CGFloat(atan2(lhs.native, rhs.native))
@@ -660,16 +630,6 @@ public func pow(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
   return CGFloat(pow(lhs.native, rhs.native))
 }
 
-@_transparent
-public func fmod(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
-  return CGFloat(fmod(lhs.native, rhs.native))
-}
-
-@_transparent
-public func remainder(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
-  return CGFloat(remainder(lhs.native, rhs.native))
-}
-
 @_transparent
 public func copysign(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
   return CGFloat(copysign(lhs.native, rhs.native))
@@ -760,11 +720,6 @@ public func nan(_ tag: String) -> CGFloat {
   return CGFloat(nan(tag) as CGFloat.NativeType)
 }
 
-@_transparent
-public func fma(_ x: CGFloat, _ y: CGFloat, _ z: CGFloat) -> CGFloat {
-  return CGFloat(fma(x.native, y.native, z.native))
-}
-
 @_transparent
 public func j0(_ x: CGFloat) -> CGFloat {
   return CGFloat(j0(Double(x.native)))

stdlib/public/core/BuiltinMath.swift.gyb

@@ -49,8 +49,7 @@ UnaryIntrinsicFunctions = [
     'cos', 'sin',
     'exp', 'exp2',
     'log', 'log10', 'log2',
-    'fabs',
-    'ceil', 'floor', 'nearbyint', 'rint', 'round', 'trunc',
+    'nearbyint', 'rint',
 ]
 
 def TypedUnaryIntrinsicFunctions():

stdlib/public/core/FloatingPoint.swift.gyb

@@ -572,11 +572,6 @@ public func ${op[0]}=<T : FloatingPoint>(lhs: inout T, rhs: T) {
 
 %end
 
-@_transparent
-public func sqrt<T : FloatingPoint>(_ rhs: T) -> T {
-  return rhs.squareRoot()
-}
-
 @_transparent
 public func ==<T : FloatingPoint>(lhs: T, rhs: T) -> Bool {
   return lhs.isEqual(to: rhs)