[AutoDiff upstream] Gardening.

- Standardize filenames: `XXXDifferentiation.swift`.
  - Use Pascal or snake case consistently.
- Formatting changes.

Author: dan-zheng

stdlib/public/Differentiation/ArrayDifferentiation.swift

@@ -1,8 +1,8 @@
-//===--- ArrayDifferentiation.swift -------------------------*- swift -*-===//
+//===--- ArrayDifferentiation.swift ---------------------------*- swift -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Copyright (c) 2019 - 2020 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
@@ -12,7 +12,11 @@
 
 import Swift
 
-// TODO(TF-938): Add 'Element : Differentiable' constraint.
+//===----------------------------------------------------------------------===//
+// Protocol conformances
+//===----------------------------------------------------------------------===//
+
+// TODO(TF-938): Add `Element: Differentiable` requirement.
 extension Array {
   /// The view of an array as the differentiable product manifold of `Element`
   /// multiplied with itself `count` times.
@@ -22,7 +26,8 @@ extension Array {
   }
 }
 
-extension Array.DifferentiableView : Differentiable where Element : Differentiable {
+extension Array.DifferentiableView: Differentiable
+where Element: Differentiable {
   /// The viewed array.
   public var base: [Element] {
     get { return _base }
@@ -31,8 +36,9 @@ extension Array.DifferentiableView : Differentiable where Element : Differentiab
 
   @usableFromInline
   @derivative(of: base)
-  func _vjpBase() ->
-    (value: [Element], pullback: (Array<Element>.TangentVector) -> TangentVector) {
+  func _vjpBase() -> (
+    value: [Element], pullback: (Array<Element>.TangentVector) -> TangentVector
+  ) {
     return (base, { $0 })
   }
 
@@ -41,8 +47,9 @@ extension Array.DifferentiableView : Differentiable where Element : Differentiab
 
   @usableFromInline
   @derivative(of: init(_:))
-  static func _vjpInit(_ base: [Element]) ->
-    (value: Array.DifferentiableView, pullback: (TangentVector) -> TangentVector) {
+  static func _vjpInit(_ base: [Element]) -> (
+    value: Array.DifferentiableView, pullback: (TangentVector) -> TangentVector
+  ) {
     return (Array.DifferentiableView(base), { $0 })
   }
 
@@ -52,16 +59,16 @@ extension Array.DifferentiableView : Differentiable where Element : Differentiab
   public mutating func move(along direction: TangentVector) {
     precondition(
       base.count == direction.base.count,
-      "cannot move Array.DifferentiableView with count \(base.count) along " +
-        "direction with different count \(direction.base.count)")
+      "cannot move Array.DifferentiableView with count \(base.count) along "
+        + "direction with different count \(direction.base.count)")
     for i in base.indices {
       base[i].move(along: direction.base[i])
     }
   }
 }
 
-extension Array.DifferentiableView : Equatable
-  where Element : Differentiable & Equatable {
+extension Array.DifferentiableView: Equatable
+where Element: Differentiable & Equatable {
   public static func == (
     lhs: Array.DifferentiableView,
     rhs: Array.DifferentiableView
@@ -70,15 +77,15 @@ extension Array.DifferentiableView : Equatable
   }
 }
 
-extension Array.DifferentiableView : ExpressibleByArrayLiteral
-  where Element : Differentiable {
+extension Array.DifferentiableView: ExpressibleByArrayLiteral
+where Element: Differentiable {
   public init(arrayLiteral elements: Element...) {
     self.init(elements)
   }
 }
 
-extension Array.DifferentiableView : CustomStringConvertible
-  where Element : Differentiable {
+extension Array.DifferentiableView: CustomStringConvertible
+where Element: Differentiable {
   public var description: String {
     return base.description
   }
@@ -88,8 +95,8 @@ extension Array.DifferentiableView : CustomStringConvertible
 ///
 /// Note that `Array.DifferentiableView([])` is the zero in the product spaces
 /// of all counts.
-extension Array.DifferentiableView : AdditiveArithmetic
-  where Element : AdditiveArithmetic & Differentiable {
+extension Array.DifferentiableView: AdditiveArithmetic
+where Element: AdditiveArithmetic & Differentiable {
 
   public static var zero: Array.DifferentiableView {
     return Array.DifferentiableView([])
@@ -100,10 +107,10 @@ extension Array.DifferentiableView : AdditiveArithmetic
     rhs: Array.DifferentiableView
   ) -> Array.DifferentiableView {
     precondition(
-      lhs.base.count == 0 || rhs.base.count == 0 ||
-        lhs.base.count == rhs.base.count,
-      "cannot add Array.DifferentiableViews with different counts: " +
-        "\(lhs.base.count) and \(rhs.base.count)")
+      lhs.base.count == 0 || rhs.base.count == 0
+        || lhs.base.count == rhs.base.count,
+      "cannot add Array.DifferentiableViews with different counts: "
+        + "\(lhs.base.count) and \(rhs.base.count)")
     if lhs.base.count == 0 {
       return rhs
     }
@@ -118,10 +125,10 @@ extension Array.DifferentiableView : AdditiveArithmetic
     rhs: Array.DifferentiableView
   ) -> Array.DifferentiableView {
     precondition(
-      lhs.base.count == 0 || rhs.base.count == 0 ||
-        lhs.base.count == rhs.base.count,
-      "cannot subtract Array.DifferentiableViews with different counts: " +
-        "\(lhs.base.count) and \(rhs.base.count)")
+      lhs.base.count == 0 || rhs.base.count == 0
+        || lhs.base.count == rhs.base.count,
+      "cannot subtract Array.DifferentiableViews with different counts: "
+        + "\(lhs.base.count) and \(rhs.base.count)")
     if lhs.base.count == 0 {
       return rhs
     }
@@ -143,7 +150,7 @@ extension Array.DifferentiableView : AdditiveArithmetic
 
 /// Makes `Array` differentiable as the product manifold of `Element`
 /// multiplied with itself `count` times.
-extension Array : Differentiable where Element : Differentiable {
+extension Array: Differentiable where Element: Differentiable {
   // In an ideal world, `TangentVector` would be `[Element.TangentVector]`.
   // Unfortunately, we cannot conform `Array` to `AdditiveArithmetic` for
   // `TangentVector` because `Array` already has a static `+` method with
@@ -167,14 +174,18 @@ extension Array : Differentiable where Element : Differentiable {
   }
 }
 
-extension Array where Element : Differentiable {
+//===----------------------------------------------------------------------===//
+// Derivatives
+//===----------------------------------------------------------------------===//
+
+extension Array where Element: Differentiable {
   @usableFromInline
   @derivative(of: subscript)
-  func _vjpSubscript(index: Int) ->
-    (value: Element, pullback: (Element.TangentVector) -> TangentVector)
-  {
+  func _vjpSubscript(index: Int) -> (
+    value: Element, pullback: (Element.TangentVector) -> TangentVector
+  ) {
     func pullback(_ gradientIn: Element.TangentVector) -> TangentVector {
-      var gradientOut = Array<Element.TangentVector>(
+      var gradientOut = [Element.TangentVector](
         repeating: .zero,
         count: count)
       gradientOut[index] = gradientIn
@@ -185,22 +196,27 @@ extension Array where Element : Differentiable {
 
   @usableFromInline
   @derivative(of: +)
-  static func _vjpConcatenate(_ lhs: [Element], _ rhs: [Element]) ->
-    (value: [Element], pullback: (TangentVector) -> (TangentVector, TangentVector)) {
-      func pullback(_ gradientIn: TangentVector) ->
-        (TangentVector, TangentVector) {
-        precondition(
-          gradientIn.base.count == lhs.count + rhs.count,
-          "+ should receive gradient with count equal to sum of operand " +
-            "counts, but counts are: gradient \(gradientIn.base.count), " +
-            "lhs \(lhs.count), rhs \(rhs.count)")
-        return (
-          TangentVector(Array<Element.TangentVector>(
+  static func _vjpConcatenate(_ lhs: [Element], _ rhs: [Element]) -> (
+    value: [Element],
+    pullback: (TangentVector) -> (TangentVector, TangentVector)
+  ) {
+    func pullback(_ gradientIn: TangentVector) -> (TangentVector, TangentVector)
+    {
+      precondition(
+        gradientIn.base.count == lhs.count + rhs.count,
+        "+ should receive gradient with count equal to sum of operand "
+          + "counts, but counts are: gradient \(gradientIn.base.count), "
+          + "lhs \(lhs.count), rhs \(rhs.count)")
+      return (
+        TangentVector(
+          [Element.TangentVector](
             gradientIn.base[0..<lhs.count])),
-          TangentVector(Array<Element.TangentVector>(
-            gradientIn.base[lhs.count...])))
-      }
-      return (lhs + rhs, pullback)
+        TangentVector(
+          [Element.TangentVector](
+            gradientIn.base[lhs.count...]))
+      )
+    }
+    return (lhs + rhs, pullback)
   }
 }
 
@@ -218,7 +234,8 @@ extension Array where Element: Differentiable {
   @usableFromInline
   @derivative(of: append)
   mutating func _jvpAppend(_ element: Element) -> (
-    value: Void, differential: (inout TangentVector, Element.TangentVector) -> Void
+    value: Void,
+    differential: (inout TangentVector, Element.TangentVector) -> Void
   ) {
     append(element)
     return ((), { $0.base.append($1) })
@@ -231,19 +248,22 @@ extension Array where Element: Differentiable {
   static func _vjpInit(repeating repeatedValue: Element, count: Int) -> (
     value: Self, pullback: (TangentVector) -> Element.TangentVector
   ) {
-    (value: Self(repeating: repeatedValue, count: count), pullback: { v in
-      v.base.reduce(.zero, +)
-    })
+    (
+      value: Self(repeating: repeatedValue, count: count),
+      pullback: { v in
+        v.base.reduce(.zero, +)
+      }
+    )
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Differentiable higher order functions for collections
 //===----------------------------------------------------------------------===//
 
-public extension Array where Element: Differentiable {
+extension Array where Element: Differentiable {
   @differentiable(wrt: (self, initialResult))
-  func differentiableReduce<Result: Differentiable>(
+  public func differentiableReduce<Result: Differentiable>(
     _ initialResult: Result,
     _ nextPartialResult: @differentiable (Result, Element) -> Result
   ) -> Result {
@@ -255,12 +275,14 @@ public extension Array where Element: Differentiable {
   internal func _vjpDifferentiableReduce<Result: Differentiable>(
     _ initialResult: Result,
     _ nextPartialResult: @differentiable (Result, Element) -> Result
-  ) -> (value: Result,
-        pullback: (Result.TangentVector)
-          -> (Array.TangentVector, Result.TangentVector)) {
+  ) -> (
+    value: Result,
+    pullback: (Result.TangentVector)
+      -> (Array.TangentVector, Result.TangentVector)
+  ) {
     var pullbacks:
-      [(Result.TangentVector) -> (Result.TangentVector, Element.TangentVector)]
-        = []
+      [(Result.TangentVector) -> (Result.TangentVector, Element.TangentVector)] =
+        []
     let count = self.count
     pullbacks.reserveCapacity(count)
     var result = initialResult
@@ -270,23 +292,26 @@ public extension Array where Element: Differentiable {
       result = y
       pullbacks.append(pb)
     }
-    return (value: result, pullback: { tangent in
-      var resultTangent = tangent
-      var elementTangents = TangentVector([])
-      elementTangents.base.reserveCapacity(count)
-      for pullback in pullbacks.reversed() {
-        let (newResultTangent, elementTangent) = pullback(resultTangent)
-        resultTangent = newResultTangent
-        elementTangents.base.append(elementTangent)
+    return (
+      value: result,
+      pullback: { tangent in
+        var resultTangent = tangent
+        var elementTangents = TangentVector([])
+        elementTangents.base.reserveCapacity(count)
+        for pullback in pullbacks.reversed() {
+          let (newResultTangent, elementTangent) = pullback(resultTangent)
+          resultTangent = newResultTangent
+          elementTangents.base.append(elementTangent)
+        }
+        return (TangentVector(elementTangents.base.reversed()), resultTangent)
       }
-      return (TangentVector(elementTangents.base.reversed()), resultTangent)
-    })
+    )
   }
 }
 
-public extension Array where Element: Differentiable {
+extension Array where Element: Differentiable {
   @differentiable(wrt: self)
-  func differentiableMap<Result: Differentiable>(
+  public func differentiableMap<Result: Differentiable>(
     _ body: @differentiable (Element) -> Result
   ) -> [Result] {
     map(body)
@@ -296,8 +321,10 @@ public extension Array where Element: Differentiable {
   @derivative(of: differentiableMap)
   internal func _vjpDifferentiableMap<Result: Differentiable>(
     _ body: @differentiable (Element) -> Result
-  ) -> (value: [Result],
-        pullback: (Array<Result>.TangentVector) -> Array.TangentVector) {
+  ) -> (
+    value: [Result],
+    pullback: (Array<Result>.TangentVector) -> Array.TangentVector
+  ) {
     var values: [Result] = []
     var pullbacks: [(Result.TangentVector) -> Element.TangentVector] = []
     for x in self {
@@ -310,4 +337,4 @@ public extension Array where Element: Differentiable {
     }
     return (value: values, pullback: pullback)
   }
-}
+}

stdlib/public/Differentiation/CMakeLists.txt

@@ -2,7 +2,7 @@
 #
 # This source file is part of the Swift.org open source project
 #
-# Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+# Copyright (c) 2019 - 2020 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
@@ -17,10 +17,14 @@ add_swift_target_library(swift_Differentiation ${SWIFT_STDLIB_LIBRARY_BUILD_TYPE
   ArrayDifferentiation.swift
 
   GYB_SOURCES
-    tgmathDerivatives.swift.gyb
-    SIMDVectorTypesDerivatives.swift.gyb
-    FloatingPointTypesDerivatives.swift.gyb    
+    FloatingPointDifferentiation.swift.gyb
+    TgmathDerivatives.swift.gyb
+    SIMDDifferentiation.swift.gyb
 
+  SWIFT_MODULE_DEPENDS_OSX Darwin
+  SWIFT_MODULE_DEPENDS_IOS Darwin
+  SWIFT_MODULE_DEPENDS_TVOS Darwin
+  SWIFT_MODULE_DEPENDS_WATCHOS Darwin
   SWIFT_MODULE_DEPENDS_LINUX Glibc
   SWIFT_MODULE_DEPENDS_FREEBSD Glibc
   SWIFT_MODULE_DEPENDS_CYGWIN Glibc

stdlib/public/Differentiation/FloatingPointTypesDerivatives.swift.gyb renamed to stdlib/public/Differentiation/FloatingPointDifferentiation.swift.gyb

@@ -1,4 +1,4 @@
-//===--- FloatingPointTypesDerivatives.swift.gyb --------------*- swift -*-===//
+//===--- FloatingPointDifferentiation.swift.gyb ---------------*- swift -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -208,7 +208,6 @@ extension ${Self} {
 % end
 % end
 
-
 extension FloatingPoint where Self : Differentiable,
                               Self == Self.TangentVector {
   /// The vector-Jacobian product function of `addingProduct`. Returns the