Remove trailing whitespace, add comment to make init differentiable.

Author: bartchr808

Sources/TensorFlow/Core/Complex.swift

@@ -2,7 +2,6 @@ public struct Complex<T : FloatingPoint> {
   public var real: T
   public var imaginary: T
 
-  @differentiable(where T : Differentiable)
   public init(real: T = 0, imaginary: T = 0) {
     self.real = real
     self.imaginary = imaginary
@@ -15,43 +14,43 @@ extension Complex : Differentiable where T : Differentiable {
 }
 
 extension Complex {
-   
+
   public static var i: Complex {
     return Complex(real: 0, imaginary: 1)
   }
 
-   
+
   public var isFinite: Bool {
     return real.isFinite && imaginary.isFinite
   }
 
-   
+
   public var isInfinite: Bool {
     return real.isInfinite || imaginary.isInfinite
   }
 
-   
+
   public var isNaN: Bool {
     return (real.isNaN && !imaginary.isInfinite) ||
       (imaginary.isNaN && !real.isInfinite)
   }
 
-   
+
   public var isZero: Bool {
     return real.isZero && imaginary.isZero
   }
 }
 
 extension Complex : ExpressibleByIntegerLiteral {
-   
+
   public init(integerLiteral value: Int) {
     self.real = T(value)
     self.imaginary = 0
   }
 }
 
 extension Complex : CustomStringConvertible {
-   
+
   public var description: String {
     return real.isNaN && real.sign == .minus
       ? imaginary.sign == .minus
@@ -64,36 +63,36 @@ extension Complex : CustomStringConvertible {
 }
 
 extension Complex : Equatable {
-   
+
   public static func == (lhs: Complex, rhs: Complex) -> Bool {
     return lhs.real == rhs.real && lhs.imaginary == rhs.imaginary
   }
 }
 
 extension Complex : AdditiveArithmetic {
-   
+
   @differentiable(vjp: _vjpAdd(lhs:rhs:) where T : Differentiable)
   public static func + (lhs: Complex, rhs: Complex) -> Complex {
-    var lhs = lhs
-    lhs += rhs
-    return lhs
+    var temp = lhs
+    temp += rhs
+    return temp
   }
 
-   
+
   public static func += (lhs: inout Complex, rhs: Complex) {
     lhs.real += rhs.real
     lhs.imaginary += rhs.imaginary
   }
 
-   
+
   @differentiable(vjp: _vjpSubtract(lhs:rhs:) where T : Differentiable)
   public static func - (lhs: Complex, rhs: Complex) -> Complex {
-    var lhs = lhs
-    lhs -= rhs
-    return lhs
+    var temp = lhs
+    temp -= rhs
+    return temp
   }
 
-   
+
   public static func -= (lhs: inout Complex, rhs: Complex) {
     lhs.real -= rhs.real
     lhs.imaginary -= rhs.imaginary
@@ -107,7 +106,7 @@ extension Complex : Numeric {
     self.imaginary = 0
   }
 
-   
+
   @differentiable(vjp: _vjpMultiply(lhs:rhs:) where T : Differentiable)
   public static func * (lhs: Complex, rhs: Complex) -> Complex {
     var a = lhs.real, b = lhs.imaginary, c = rhs.real, d = rhs.imaginary
@@ -149,12 +148,12 @@ extension Complex : Numeric {
     return Complex(real: x, imaginary: y)
   }
 
-   
+
   public static func *= (lhs: inout Complex, rhs: Complex) {
     lhs = lhs * rhs
   }
 
-   
+
   public var magnitude: T {
     var x = abs(real)
     var y = abs(imaginary)
@@ -168,21 +167,21 @@ extension Complex : Numeric {
 }
 
 extension Complex : SignedNumeric {
-   
+
   @differentiable(vjp: _vjpNegate where T : Differentiable)
   public static prefix func - (operand: Complex) -> Complex {
     return Complex(real: -operand.real, imaginary: -operand.imaginary)
   }
 
-   
+
   public mutating func negate() {
     real.negate()
     imaginary.negate()
   }
 }
 
 extension Complex {
-   
+
   @differentiable(vjp: _vjpDivide(lhs:rhs:) where T : Differentiable)
   public static func / (lhs: Complex, rhs: Complex) -> Complex {
     var a = lhs.real, b = lhs.imaginary, c = rhs.real, d = rhs.imaginary
@@ -218,51 +217,51 @@ extension Complex {
     return Complex(real: x, imaginary: y)
   }
 
-   
+
   public static func /= (lhs: inout Complex, rhs: Complex) {
     lhs = lhs / rhs
   }
 }
 
 extension Complex {
-   
+
   @differentiable(vjp: _vjpComplexConjugate where T : Differentiable)
   public func complexConjugate() -> Complex {
     return Complex(real: real, imaginary: -imaginary)
   }
 }
 
- 
+
 public func abs<T>(_ z: Complex<T>) -> Complex<T> {
   return Complex(real: z.magnitude)
 }
 
 extension Complex {
-   
+
   @differentiable(vjp: _vjpAdding(real:) where T : Differentiable, T.TangentVector == T)
   public func adding(real: T) -> Complex {
     var c = self
     c.real += real
     return c
   }
 
-   
+
   @differentiable(vjp: _vjpSubtracting(real:) where T : Differentiable, T.TangentVector == T)
   public func subtracting(real: T) -> Complex {
     var c = self
     c.real -= real
     return c
   }
 
-   
+
   @differentiable(vjp: _vjpAdding(imaginary:) where T : Differentiable, T.TangentVector == T)
   public func adding(imaginary: T) -> Complex {
     var c = self
     c.imaginary += imaginary
     return c
   }
-  
-   
+
+
   @differentiable(vjp: _vjpSubtracting(imaginary:) where T : Differentiable, T.TangentVector == T)
   public func subtracting(imaginary: T) -> Complex {
     var c = self
@@ -273,25 +272,25 @@ extension Complex {
 
 extension Complex where T : Differentiable {
   @usableFromInline
-  static func _vjpAdd(lhs: Complex, rhs: Complex) 
+  static func _vjpAdd(lhs: Complex, rhs: Complex)
   -> (Complex, (Complex) -> (Complex, Complex)) {
     return (lhs + rhs, { v in (v, v) })
   }
 
   @usableFromInline
-  static func _vjpSubtract(lhs: Complex, rhs: Complex) 
+  static func _vjpSubtract(lhs: Complex, rhs: Complex)
   -> (Complex, (Complex) -> (Complex, Complex)) {
     return (lhs - rhs, { v in (v, -v) })
   }
 
   @usableFromInline
-  static func _vjpMultiply(lhs: Complex, rhs: Complex) 
+  static func _vjpMultiply(lhs: Complex, rhs: Complex)
   -> (Complex, (Complex) -> (Complex, Complex)) {
     return (lhs * rhs, { v in (rhs * v, lhs * v) })
   }
 
   @usableFromInline
-  static func _vjpDivide(lhs: Complex, rhs: Complex) 
+  static func _vjpDivide(lhs: Complex, rhs: Complex)
   -> (Complex, (Complex) -> (Complex, Complex)) {
     return (lhs / rhs, { v in (v / rhs, -lhs / (rhs * rhs) * v) })
   }