correct whitespace in Epochs implementation (#916)

While trying to enable `swift-format` based linting, these files were
noted to have whitespace errors.  Correct the errors to allow enabling
the linter.

Author: compnerd

Sources/TensorFlow/Epochs/Algorithms.swift

@@ -292,21 +292,21 @@ public struct Concatenation<Base1: Sequence, Base2: Sequence>: Sequence
     self._base1 = _base1
     self._base2 = base2
   }
-  
+
   public struct Iterator: IteratorProtocol {
     var _iterator1: Base1.Iterator
     var _iterator2: Base2.Iterator
-    
+
     init(_ concatenation: Concatenation) {
       _iterator1 = concatenation._base1.makeIterator()
       _iterator2 = concatenation._base2.makeIterator()
     }
-    
+
     public mutating func next() -> Base1.Element? {
       return _iterator1.next() ?? _iterator2.next()
     }
   }
-  
+
   public func makeIterator() -> Iterator {
     Iterator(self)
   }
@@ -614,7 +614,7 @@ extension Collection {
   /// predicate, as if `self.partition(by: predicate)` had already
   /// been called.
   ///
-  /// - Efficiency: At most log(N) invocations of `predicate`, where 
+  /// - Efficiency: At most log(N) invocations of `predicate`, where
   ///   N is the length of `self`.  At most log(N) index offsetting
   ///   operations if `self` conforms to `RandomAccessCollection`;
   ///   at most N such operations otherwise.
@@ -636,4 +636,4 @@ extension Collection {
     }
     return l
   }
-}
+}

Sources/TensorFlow/Epochs/NonuniformTrainingEpochs.swift

@@ -160,7 +160,7 @@ where Entropy == SystemRandomNumberGenerator {
 
 /// A collection of batches suitable for inference, drawing samples from
 /// `samples` into batches of `batchSize`.
-public typealias NonuniformInferenceBatches<Samples: Collection> 
+public typealias NonuniformInferenceBatches<Samples: Collection>
   = Slices<Sampling<Samples, [Samples.Index]>>
 
 /// An implementation detail used to work around the fact that Swift can't
@@ -174,9 +174,9 @@ public protocol SamplingProtocol : Collection {
 }
 extension Sampling : SamplingProtocol {}
 
-extension Slices 
+extension Slices
   // This constraint matches when Self == NonuniformInferenceBatches<T>.
-  where Base: SamplingProtocol, Base.Selection == [Base.Samples.Index] 
+  where Base: SamplingProtocol, Base.Selection == [Base.Samples.Index]
 {
   /// Creates an instance containing batches of `n` elements of `samples` where
   /// the size of the largest sample in successive batches is strictly
@@ -189,8 +189,8 @@ extension Slices
     areInAscendingSizeOrder:
       @escaping (Base.Samples.Element, Base.Samples.Element) -> Bool
   ) {
-    self.init(samples: samples, batchSize: n) { 
-      areInAscendingSizeOrder(samples[$0], samples[$1]) 
+    self.init(samples: samples, batchSize: n) {
+      areInAscendingSizeOrder(samples[$0], samples[$1])
     }
   }
 

Sources/TensorFlow/Epochs/Sampling.swift

@@ -58,9 +58,9 @@ where Selection: BidirectionalCollection {
   public func index(_ i: Index, offsetBy n: Int) -> Index {
     selection.index(before: i)
   }
-  
+
   // Needed because of https://bugs.swift.org/browse/SR-12692
-  /// Returns `i` offset by `distance` unless that requires passing `limit`, in 
+  /// Returns `i` offset by `distance` unless that requires passing `limit`, in
   /// which case `nil` is returned.
   @inlinable
   public func index(

Sources/TensorFlow/Epochs/Slices.swift

@@ -25,8 +25,8 @@ public struct Slices<Base: Collection> {
 
   /// The maximum length of the slices.
   private let batchSize: Int
-    
-  /// Creates an instance that divides `base` into batches 
+
+  /// Creates an instance that divides `base` into batches
   /// of size `n`.
   ///
   /// If `base.count % n != 0` the `count` of the last batch

Sources/TensorFlow/Operators/Math.swift

@@ -393,36 +393,36 @@ extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint {
 // Consider publicly exposing these operators when tensorflow/swift-apis is no
 // longer built as part of the Swift standard library,
 /*
-public extension VectorProtocol {	
-    static func + (lhs: VectorSpaceScalar, rhs: Self) -> Self {	
-        rhs.adding(lhs)	
-    }	
+public extension VectorProtocol {
+    static func + (lhs: VectorSpaceScalar, rhs: Self) -> Self {
+        rhs.adding(lhs)
+    }
 
-    static func + (lhs: Self, rhs: VectorSpaceScalar) -> Self {	
-        lhs.adding(rhs)	
-    }	
+    static func + (lhs: Self, rhs: VectorSpaceScalar) -> Self {
+        lhs.adding(rhs)
+    }
 
-    static func - (lhs: Self, rhs: VectorSpaceScalar) -> Self {	
-        lhs.subtracting(rhs)	
-    }	
+    static func - (lhs: Self, rhs: VectorSpaceScalar) -> Self {
+        lhs.subtracting(rhs)
+    }
 
-    static func * (lhs: VectorSpaceScalar, rhs: Self) -> Self {	
-        rhs.scaled(by: lhs)	
-    }	
+    static func * (lhs: VectorSpaceScalar, rhs: Self) -> Self {
+        rhs.scaled(by: lhs)
+    }
 
-    static func * (lhs: Self, rhs: VectorSpaceScalar) -> Self {	
-        lhs.scaled(by: rhs)	
-    }	
-}	
+    static func * (lhs: Self, rhs: VectorSpaceScalar) -> Self {
+        lhs.scaled(by: rhs)
+    }
+}
 
-public extension VectorProtocol where VectorSpaceScalar: SignedNumeric {	
-    static prefix func - (x: Self) -> Self {	
-        .zero - x	
-    }	
+public extension VectorProtocol where VectorSpaceScalar: SignedNumeric {
+    static prefix func - (x: Self) -> Self {
+        .zero - x
+    }
 
-    static func - (lhs: VectorSpaceScalar, rhs: Self) -> Self {	
-        (-rhs).adding(lhs)	
-    }	
+    static func - (lhs: VectorSpaceScalar, rhs: Self) -> Self {
+        (-rhs).adding(lhs)
+    }
 }
 */
 
@@ -1472,9 +1472,9 @@ public func swish<T: TensorFlowFloatingPoint>(_ x: Tensor<T>) -> Tensor<T> {
   x * sigmoid(x)
 }
 
-// Note: A custom vjp function for swish is required to avoid excessive 
-// tensor memory consumption due to storing both `x` and `sigmoid(x)` for 
-// backprop. This vjp recomputes `sigmoid(x)` during backprop, so that 
+// Note: A custom vjp function for swish is required to avoid excessive
+// tensor memory consumption due to storing both `x` and `sigmoid(x)` for
+// backprop. This vjp recomputes `sigmoid(x)` during backprop, so that
 // the `sigmoid(x)` expression can be freed during the forward pass.
 @inlinable
 @derivative(of: swish)

Sources/TensorFlow/StdlibExtensions.swift

@@ -281,4 +281,4 @@ where Element: Differentiable & PointwiseMultiplicative {
 extension Collection {
   /// Returns the `n`th position in `self`.
   func index(atOffset n: Int) -> Index { index(startIndex, offsetBy: n) }
-}
+}

Tests/TensorFlowTests/LayerTests.swift

@@ -1970,7 +1970,7 @@ final class LayerTests: XCTestCase {
     let transformerResult = transformerLayerNorm(transformerTensor)
     XCTAssertEqual(transformerTensor.shape, transformerResult.shape)
   }
-  
+
   func testGaussianNoise() {
     Context.local.learningPhase = .inference
     let gaussianNoise = GaussianNoise<Float>(standardDeviation: 1.0)