SE-0113 + residual SE-0067 work (#3443)

Implemented SE-0113 + residual SE-0067 operations.

- adds `rounded` and `round` to `FloatingPoint`, from SE-0113.
- adds `remainder`, `squareRoot`, and `addingProduct`, from SE-0067.
- adds basic test coverage for all of the above.
- provides a default implementation of `nextDown` on `FloatingPoint`.

Author: stephentyrone

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

@@ -166,12 +166,12 @@ public struct CGFloat {
       exponent: exponent, significand: significand.native)
   }
 
-  public var nextUp: CGFloat {
-    return CGFloat(native.nextUp)
+  public mutating func round(_ rule: FloatingPointRoundingRule) {
+    native.round(rule)
   }
 
-  public var nextDown: CGFloat {
-    return CGFloat(native.nextDown)
+  public var nextUp: CGFloat {
+    return CGFloat(native.nextUp)
   }
 
   public static func abs(_ x: CGFloat) -> CGFloat {
@@ -202,8 +202,6 @@ public struct CGFloat {
     native.formTruncatingRemainder(dividingBy: other.native)
   }
 
-  /*  TODO: Need to call C sqrt and fma or llvm sqrt and fma intrinsics
-   *  for these to be implemented on the underlying types.
   public mutating func formRemainder(dividingBy other: CGFloat) {
     native.formRemainder(dividingBy: other.native)
   }
@@ -215,7 +213,6 @@ public struct CGFloat {
   public mutating func addProduct(_ lhs: CGFloat, _ rhs: CGFloat) {
     native.addProduct(lhs.native, rhs.native)
   }
-  */
 
   public func isEqual(to other: CGFloat) -> Bool {
     return self.native.isEqual(to: other.native)

stdlib/public/SwiftShims/LibcShims.h

@@ -82,6 +82,45 @@ __swift_uint32_t _swift_stdlib_cxx11_mt19937(void);
 SWIFT_RUNTIME_STDLIB_INTERFACE
 __swift_uint32_t
 _swift_stdlib_cxx11_mt19937_uniform(__swift_uint32_t upper_bound);
+  
+// Math library functions
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_remainderf(float, float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_squareRootf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE
+float _swift_stdlib_addProductf(float, float, float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_roundf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_roundevenf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_truncf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_roundawayf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_ceilf(float);
+SWIFT_RUNTIME_STDLIB_INTERFACE float _swift_stdlib_floorf(float);
+  
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_remainder(double, double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_squareRoot(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE
+double _swift_stdlib_addProduct(double, double, double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_round(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_roundeven(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_trunc(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_roundaway(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_ceil(double);
+SWIFT_RUNTIME_STDLIB_INTERFACE double _swift_stdlib_floor(double);
+  
+// TODO: Remove horrible workaround when importer does Float80 <-> long double.
+#if (defined __i386__ || defined __x86_64__) && !defined _MSC_VER
+SWIFT_RUNTIME_STDLIB_INTERFACE
+void _swift_stdlib_remainderl(void *_self, const void *_other);
+SWIFT_RUNTIME_STDLIB_INTERFACE
+void _swift_stdlib_squareRootl(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE
+void _swift_stdlib_addProductl(void *_self, const void *_lhs, const void *_rhs);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_roundl(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_roundevenl(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_truncl(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_roundawayl(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_ceill(void *_self);
+SWIFT_RUNTIME_STDLIB_INTERFACE void _swift_stdlib_floorl(void *_self);
+#endif
 
 #ifdef __cplusplus
 }} // extern "C", namespace swift

stdlib/public/core/FloatingPoint.swift.gyb

@@ -279,7 +279,6 @@ public protocol FloatingPoint: Comparable, IntegerLiteralConvertible,
   /// representable value.
   mutating func divide(by other: Self)
 
-  /*  TODO: Need a remainder builtin or to call C remainder[fl] for these
   /// Remainder of `self` divided by `other`.  This is the IEEE 754 remainder
   /// operation.
   ///
@@ -298,7 +297,6 @@ public protocol FloatingPoint: Comparable, IntegerLiteralConvertible,
 
   /// Mutating form of `remainder`.
   mutating func formRemainder(dividingBy other: Self)
-  */
 
   /// Remainder of `self` divided by `other` using truncating division.
   /// Equivalent to the C standard library function `fmod`.
@@ -314,8 +312,6 @@ public protocol FloatingPoint: Comparable, IntegerLiteralConvertible,
   /// Mutating form of `truncatingRemainder`.
   mutating func formTruncatingRemainder(dividingBy other: Self)
 
-  /* TODO: Need to call C sqrt and fma or llvm sqrt and fma intrinsics
-   * for these.
   /// Square root of `self`.
   func squareRoot() -> Self
 
@@ -328,7 +324,6 @@ public protocol FloatingPoint: Comparable, IntegerLiteralConvertible,
 
   /// Fused multiply-add, accumulating the product of `lhs` and `rhs` to `self`.
   mutating func addProduct(_ lhs: Self, _ rhs: Self)
-  */
 
   /// The minimum of `x` and `y`.  Implements the IEEE 754 `minNum` operation.
   ///
@@ -364,6 +359,35 @@ public protocol FloatingPoint: Comparable, IntegerLiteralConvertible,
   /// `y` are quiet NaNs, a quiet NaN is returned.
   static func maximumMagnitude(_ x: Self, _ y: Self) -> Self
 
+  /// Returns the value of `self` rounded to an integral value using the
+  /// specified rounding rule.  If the rounding rule is omitted, it defaults
+  /// to `.toNearestOrAwayFromZero`, aka "schoolbook rounding".
+  ///
+  /// This implements the C library rounding functions and the IEEE 754
+  /// operations that they bind.
+  ///
+  /// - `round(x)` is `x.rounded()` (the default rounding rule is provided by
+  ///   an extension.  This implements the IEEE 754 `roundToIntegralTiesToAway`
+  ///   operation.
+  ///
+  /// - `roundeven(x)` is `x.rounded(.toNearestOrEven)`.  This implements
+  ///   the IEEE 754 `roundToIntegralTiesToEven` operation.
+  ///
+  /// - `trunc(x)` is `x.rounded(.towardZero)`.  This implements the IEEE 754
+  ///   `roundToIntegralTowardZero` operation.
+  ///
+  /// - `ceil(x)` is `x.rounded(.up)`.  This implements the IEEE 754
+  ///   `roundToIntegralTowardPositive` operation.
+  ///
+  /// - `floor(x)` is `x.rounded(.down)`.  This implements the IEEE 754
+  ///   `roundToIntegralTowardNegative` operation.
+  func rounded(_ rule: FloatingPointRoundingRule) -> Self
+
+  /// Rounds `self` to an integral value using the specified rounding rule.
+  /// If the rounding rule is omitted, it defaults to
+  /// `.toNearestOrAwayFromZero`, aka "schoolbook rounding".
+  mutating func round(_ rule: FloatingPointRoundingRule)
+
   /// The least representable value that compares greater than `self`.
   ///
   /// - If `x` is `-infinity`, then `x.nextUp` is `-greatestMagnitude`.
@@ -490,6 +514,35 @@ public enum FloatingPointClassification {
   case positiveInfinity
 }
 
+/// Describes a rule for rounding a floating-point number.
+public enum FloatingPointRoundingRule {
+
+  /// The result is the closest allowed value; if two values are equally close,
+  /// the one with greater magnitude is chosen.  Also known as "schoolbook
+  /// rounding".
+  case toNearestOrAwayFromZero
+
+  /// The result is the closest allowed value; if two values are equally close,
+  /// the even one is chosen.  Also known as "bankers rounding".
+  case toNearestOrEven
+
+  /// The result is the closest allowed value that is greater than or equal
+  /// to the source.
+  case up
+
+  /// The result is the closest allowed value that is less than or equal to
+  /// the source.
+  case down
+
+  /// The result is the closest allowed value whose magnitude is less than or
+  /// equal to that of the source.
+  case towardZero
+
+  /// The result is the closest allowed value whose magnitude is greater than
+  /// or equal to that of the source.
+  case awayFromZero
+}
+
 @_transparent
 public prefix func +<T : FloatingPoint>(x: T) -> T {
   return x
@@ -522,12 +575,10 @@ public func ${op[0]}=<T : FloatingPoint>(lhs: inout T, rhs: T) {
 
 %end
 
-/*  TODO: uncomment once implemented.
 @_transparent
 public func sqrt<T : FloatingPoint>(_ rhs: T) -> T {
   return rhs.squareRoot()
 }
-*/
 
 @_transparent
 public func ==<T : FloatingPoint>(lhs: T, rhs: T) -> Bool {
@@ -675,14 +726,47 @@ extension FloatingPoint {
     return Self(1).ulp
   }
 
+  @_transparent
+  public func rounded(_ rule: FloatingPointRoundingRule) -> Self {
+    var lhs = self
+    lhs.round(rule)
+    return lhs
+  }
+
+  /// Returns `self` rounded to the closest integral value.  If `self` is
+  /// exactly halfway between two integers (e.g. 1.5), the integral value
+  /// with greater magnitude (2.0 in this example) is returned.
+  ///
+  /// Other rounding modes can be explicitly specified with
+  /// `.rounded(_: FloatingPointRoundingRule)`.
+  @_transparent
+  public func rounded() -> Self {
+    return rounded(.toNearestOrAwayFromZero)
+  }
+
+  /// Rounds `self` to the closest integral value.  If `self` is exactly
+  /// halfway between two integers (e.g. 1.5), the integral value with
+  /// greater magnitude is selected.
+  ///
+  /// Other rounding modes can be explicitly specified with
+  /// `.round(_: FloatingPointRoundingRule)`.
+  @_transparent
+  public mutating func round() {
+    round(.toNearestOrAwayFromZero)
+  }
+
+  @_transparent
+  public var nextDown: Self {
+    return -(-self).nextUp
+  }
+
   @_transparent
   public func truncatingRemainder(dividingBy rhs: Self) -> Self {
     var lhs = self
     lhs.formTruncatingRemainder(dividingBy: rhs)
     return lhs
   }
 
-  /*  TODO: uncomment once implemented.
   @_transparent
   public func remainder(dividingBy rhs: Self) -> Self {
     var lhs = self
@@ -703,7 +787,6 @@ extension FloatingPoint {
     addend.addProduct(lhs, rhs)
     return addend
   }
-  */
 
   public static func minimum(_ left: Self, _ right: Self) -> Self {
     if left.isSignalingNaN || right.isSignalingNaN {

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -508,8 +508,39 @@ extension ${Self}: BinaryFloatingPoint {
       significandBitPattern: significandBitPattern + 1)
   }
 
-  public var nextDown: ${Self} {
-    return -(-self).nextUp
+  @_transparent
+  public mutating func round(_ rule: FloatingPointRoundingRule) {
+%if bits == 80:
+    switch rule {
+    case .toNearestOrAwayFromZero:
+      _swift_stdlib_roundl(&self)
+    case .toNearestOrEven:
+      _swift_stdlib_roundevenl(&self)
+    case .towardZero:
+      _swift_stdlib_truncl(&self)
+    case .awayFromZero:
+      _swift_stdlib_roundawayl(&self)
+    case .up:
+      _swift_stdlib_ceill(&self)
+    case .down:
+      _swift_stdlib_floorl(&self)
+    }
+%else:
+    switch rule {
+    case .toNearestOrAwayFromZero:
+      self = _swift_stdlib_round${cFuncSuffix(bits)}(self)
+    case .toNearestOrEven:
+      self = _swift_stdlib_roundeven${cFuncSuffix(bits)}(self)
+    case .towardZero:
+      self = _swift_stdlib_trunc${cFuncSuffix(bits)}(self)
+    case .awayFromZero:
+      self = _swift_stdlib_roundaway${cFuncSuffix(bits)}(self)
+    case .up:
+      self = _swift_stdlib_ceil${cFuncSuffix(bits)}(self)
+    case .down:
+      self = _swift_stdlib_floor${cFuncSuffix(bits)}(self)
+    }
+%end
   }
 
   @_transparent
@@ -537,30 +568,40 @@ extension ${Self}: BinaryFloatingPoint {
     _value = Builtin.fdiv_FPIEEE${bits}(self._value, other._value)
   }
 
-  /*  TODO: Need a remainder builtin or to call C remainder[fl] for this
   @_transparent
   public mutating func formRemainder(dividingBy other: ${Self}) {
-    fatalError("Unimplemented")
+%if bits == 80:
+    var other = other
+    _swift_stdlib_remainderl(&self, &other)
+%else:
+    self = _swift_stdlib_remainder${cFuncSuffix(bits)}(self, other)
+%end
   }
-  */
 
   @_transparent
   public mutating func formTruncatingRemainder(dividingBy other: ${Self}) {
     _value = Builtin.frem_FPIEEE${bits}(self._value, other._value)
   }
 
-  /*  TODO: Need to call C sqrt and fma or llvm sqrt and fma intrinsics
-   *  for these.
   @_transparent
   public mutating func formSquareRoot( ) {
-    fatalError("Unimplemented.")
+%if bits == 80:
+    _swift_stdlib_squareRootl(&self)
+%else:
+    self = _swift_stdlib_squareRoot${cFuncSuffix(bits)}(self)
+%end
   }
 
   @_transparent
   public mutating func addProduct(_ lhs: ${Self}, _ rhs: ${Self}) {
-    fatalError("Unimplemented.")
+%if bits == 80:
+    var lhs = lhs
+    var rhs = rhs
+    _swift_stdlib_addProductl(&self, &lhs, &rhs)
+%else:
+    self = _swift_stdlib_addProduct${cFuncSuffix(bits)}(self, lhs, rhs)
+%end
   }
-  */
 
   @_transparent
   public func isEqual(to other: ${Self}) -> Bool {