Work in progress towards "Mathsable"

Fundamental decision to be made; should implementation hooks present like `Float.exp(_ x: Float) -> Float` or like `Float.Maths.exp(_ x: Float) -> Float`? Having the intermediate namespace to group them as in the second is definitely nicer, but it requires a little bit of extra machinery, and much more importantly, there doesn't seem to be any way to make access to the static `Maths` associatedtype transparent.

Author: stephentyrone

stdlib/public/CMakeLists.txt

@@ -61,6 +61,8 @@ if(SWIFT_BUILD_STDLIB)
   add_subdirectory(stubs)
   add_subdirectory(core)
   add_subdirectory(SwiftOnoneSupport)
+
+  add_subdirectory(Maths)
 endif()
 
 if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_REMOTE_MIRROR)

stdlib/public/Maths/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_swift_target_library(swiftMaths ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY
+    Maths.swift.gyb
+
+    SWIFT_COMPILE_FLAGS "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
+    SWIFT_COMPILE_FLAGS
+    LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
+)
+

stdlib/public/Maths/Maths.swift.gyb

@@ -0,0 +1,64 @@
+//===--- Maths.swift ------------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// MARK: - Free functions defined on FloatingPoint
+@_transparent
+public func ceil<T>(_ x: T) -> T where T: FloatingPoint {
+  return x.rounded(.up)
+}
+
+@_transparent
+public func floor<T>(_ x: T) -> T where T: FloatingPoint {
+  return x.rounded(.down)
+}
+
+@_transparent
+public func round<T: FloatingPoint>(_ x: T) -> T {
+  return x.rounded()
+}
+
+@_transparent
+public func trunc<T>(_ x: T) -> T where T: FloatingPoint {
+  return x.rounded(.towardZero)
+}
+
+@_transparent
+public func sqrt<T>(_ x: T) -> T where T: FloatingPoint {
+  return x.squareRoot()
+}
+
+@_transparent
+public func fma<T>(_ x: T, _ y: T, _ z: T) -> T where T: FloatingPoint {
+  return z.addingProduct(x, y)
+}
+
+@_transparent
+public func remainder<T>(_ x: T, _ y: T) -> T where T: FloatingPoint {
+  return x.remainder(dividingBy: y)
+}
+
+@_transparent
+public func fmod<T>(_ x: T, _ y: T) -> T where T: FloatingPoint {
+  return x.truncatingRemainder(dividingBy: y)
+}
+
+// MARK: - Free functions defined on Mathsable
+
+%from SwiftMathsFunctions import *
+%for func in MathFunctions:
+
+@_transparent
+public func ${func.free_decl()} {
+//  return T.Maths.${func.name}(${func.params()})
+  return T.${func.name}(${func.params()})
+}
+%end

stdlib/public/Platform/tgmath.swift.gyb

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftShims
+@_exported import Maths
 
 // Generic functions implementable directly on FloatingPoint.
 @_transparent
@@ -163,9 +164,6 @@ UnaryFunctions = [
 # We call this intrinsic via the Builtin method so keep this list in
 # sync with core/BuiltinMath.swift.gyb
 UnaryIntrinsicFunctions = [
-    'cos', 'sin',
-    'exp', 'exp2',
-    'log', 'log10', 'log2',
     'nearbyint', 'rint',
 ]
 

stdlib/public/core/CMakeLists.txt

@@ -87,6 +87,7 @@ set(SWIFTLIB_ESSENTIAL
   LifetimeManager.swift
   ManagedBuffer.swift
   Map.swift
+  Mathsable.swift.gyb
   MemoryLayout.swift
   UnicodeScalar.swift # ORDER DEPENDENCY: Must precede Mirrors.swift
   Misc.swift

stdlib/public/core/GroupInfo.json

@@ -167,7 +167,8 @@
     "Floating": [
       "FloatingPoint.swift",
       "FloatingPointParsing.swift",
-      "FloatingPointTypes.swift"],
+      "FloatingPointTypes.swift",
+      "Mathsable.swift"],
     "Vector": [
       "SIMDVector.swift",
       "SIMDVectorTypes.swift"]}

stdlib/public/core/Mathsable.swift.gyb

@@ -0,0 +1,117 @@
+//===--- Mathsable.swift --------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+//  We are omitting the following for now, which could also be defined on
+//  FloatingPoint, as it's not obvious that we want free function
+//  implementations:
+//
+//    fabs - use Swift.abs instead.
+//
+//    scalbn, frexp, ldexp, ilogb - we should provide a better technique
+//    for safely rescaling floating-point computations instead of these
+//    poorly named and easy to misuse functions.
+
+%{
+from SwiftMathsFunctions import *
+}%
+
+/* NAMESPACED
+public protocol Mathsable {
+  associatedtype Maths: MathsImplementations where Maths.Value == Self
+}
+
+public protocol MathsImplementations {
+  associatedtype Value
+%for func in MathFunctions:
+  static func ${func.decl("Value")}
+%end
+}
+
+%for type in all_floating_point_types():
+extension ${type.stdlib_name}: Mathsable {
+  public enum Maths: MathsImplementations {
+    public typealias Value = ${type.stdlib_name}
+% for func in MathFunctions:
+
+    @_transparent
+    public static func ${func.decl("Value")} {
+      return ${func.impl(type)}
+    }
+%end
+  }
+}
+
+%end
+
+public struct _SIMDMaths<V>: MathsImplementations
+where V: SIMD, V.Scalar: Mathsable {
+  
+  public typealias Value = V
+%for func in MathFunctions:
+
+  @_transparent
+  public static func ${func.decl("V")} {
+    var r = V()
+    for i in x.indices {
+      r[i] = V.Scalar.Maths.${func.name}(${func.params("", "[i]")})
+    }
+    return r
+  }
+%end
+}
+
+extension SIMD where Scalar: Mathsable {
+  public typealias Maths = _SIMDMaths<Self>
+}
+
+%for n in [2,3,4,8,16,32,64]:
+extension SIMD${n}: Mathsable where Scalar: Mathsable { }
+%end
+*/
+
+/* NO NAMESPACE */
+public protocol Mathsable {
+%for func in MathFunctions:
+  static func ${func.decl("Self")}
+%end
+}
+
+%for type in all_floating_point_types():
+extension ${type.stdlib_name}: Mathsable {
+% for func in MathFunctions:
+
+  @_transparent
+  public static func ${func.decl(type.stdlib_name)} {
+    return ${func.impl(type)}
+  }
+%end
+}
+
+%end
+
+extension SIMD where Scalar: Mathsable {
+%for func in MathFunctions:
+
+  @_transparent
+  public static func ${func.decl("Self")} {
+    var r = Self()
+    for i in x.indices {
+      r[i] = Scalar.${func.name}(${func.params("", "[i]")})
+    }
+    return r
+  }
+%end
+}
+
+%for n in [2,3,4,8,16,32,64]:
+extension SIMD${n}: Mathsable where Scalar: Mathsable { }
+%end

utils/SwiftMathsFunctions.py

@@ -0,0 +1,37 @@
+from SwiftFloatingPointTypes import all_floating_point_types
+
+class SwiftMathsFunction(object):
+  def __init__(self, name, cName=None, intrinsic=False, args="x"):
+    self.name = name
+    self.cName = cName if cName is not None else name
+    self.intrinsic = intrinsic
+    self.args = args
+
+  def params(self, prefix="", suffix=""):
+    return ", ".join(
+      map(lambda a: prefix + a + suffix, self.args)
+    )
+  
+  def decl(self, type):
+    return self.name + "(" + self.params("_ ", ": " + type) + ") -> " + type
+  
+  def free_decl(self):
+    return self.name + "<T>(" + self.params("_ ", ": T") + ") -> T where T: Mathsable"
+  
+  def impl(self, type):
+    if self.intrinsic:
+      builtin = "Builtin.int_" + self.name + "_FPIEEE" + str(type.bits)
+      return type.stdlib_name + "(" + builtin + "(" + self.params("","._value") + "))"
+    return self.cName + type.cFuncSuffix + "(" + self.params() + ")"
+
+MathFunctions = [
+  SwiftMathsFunction(name="cos", intrinsic=True),
+  SwiftMathsFunction(name="sin", intrinsic=True),
+  SwiftMathsFunction(name="exp", intrinsic=True),
+  SwiftMathsFunction(name="exp2", intrinsic=True),
+  SwiftMathsFunction(name="log", intrinsic=True),
+  SwiftMathsFunction(name="log10", intrinsic=True),
+  SwiftMathsFunction(name="log2", intrinsic=True),
+]
+
+