---

yaml
---
r: 262110
b: refs/heads/tensorflow
c: 4d4f4b2
h: refs/heads/master

Author: dan-zheng

[refs]

@@ -818,7 +818,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 714f8d6dc4f20647679259a11a99bea287b0c975
+refs/heads/tensorflow: 4d4f4b253ca9deb4fd12428b110c244e17d18164
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/stdlib/public/core/AutoDiff.swift

@@ -63,24 +63,26 @@ public protocol ShapedVectorNumeric : VectorNumeric {
 /// elements are of `Tangent` type.
 public protocol Differentiable {
   /// The tangent vector space of this differentiable manifold.
-  associatedtype TangentVector : Differentiable
-    where TangentVector.TangentVector == TangentVector
+  associatedtype TangentVector : Differentiable, VectorNumeric
+    where TangentVector.TangentVector == TangentVector,
+          TangentVector.Scalar : FloatingPoint
   /// The cotangent space of this differentiable manifold.
-  associatedtype CotangentVector : Differentiable
-    where CotangentVector.CotangentVector == CotangentVector
+  associatedtype CotangentVector : Differentiable, VectorNumeric
+    where CotangentVector.CotangentVector == CotangentVector,
+          CotangentVector.Scalar : FloatingPoint
 
   /// Returns `self` moved along the value space towards the given tangent
   /// vector. In Riemannian geometry (mathematics), this represents an
   /// exponential map.
-  func moved(toward direction: TangentVector) -> Self
+  func moved(along direction: TangentVector) -> Self
 
   /// Convert a cotangent vector to its corresponding tangent vector.
   func tangentVector(from cotangent: CotangentVector) -> TangentVector
 }
 
 public extension Differentiable
   where Self : VectorNumeric, TangentVector == Self {
-  func moved(toward direction: TangentVector) -> Self {
+  func moved(along direction: TangentVector) -> Self {
     return self + direction
   }
 }

branches/tensorflow/stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -1832,12 +1832,7 @@ extension ${Self} : Strideable {
 //===----------------------------------------------------------------------===//
 
 extension ${Self} : VectorNumeric {
-  public typealias Shape = ()
   public typealias Scalar = ${Self}
-
-  public init(repeating repeatedValue: ${Self}, shape: ()) {
-    self = repeatedValue
-  }
 }
 
 extension ${Self} : Differentiable {

branches/tensorflow/test/AutoDiff/differentiable_attr_type_checking.swift

@@ -540,15 +540,23 @@ struct JVPStruct {
   let p: Float
 }
 
+extension JVPStruct : VectorNumeric {
+  static var zero: JVPStruct { return JVPStruct(p: 0) }
+  static func + (lhs: JVPStruct, rhs: JVPStruct) -> JVPStruct {
+    return JVPStruct(p: lhs.p + rhs.p)
+  }
+  static func - (lhs: JVPStruct, rhs: JVPStruct) -> JVPStruct {
+    return JVPStruct(p: lhs.p - rhs.p)
+  }
+  typealias Scalar = Float
+  static func * (lhs: Float, rhs: JVPStruct) -> JVPStruct {
+    return JVPStruct(p: lhs * rhs.p)
+  }
+}
+
 extension JVPStruct : Differentiable {
   typealias TangentVector = JVPStruct
   typealias CotangentVector = JVPStruct
-  func moved(toward direction: JVPStruct) -> JVPStruct {
-    return JVPStruct(p: p + direction.p)
-  }
-  func tangentVector(from cotangent: JVPStruct) -> JVPStruct {
-    return cotangent
-  }
 }
 
 extension JVPStruct {
@@ -634,15 +642,23 @@ struct VJPStruct {
   let p: Float
 }
 
+extension VJPStruct : VectorNumeric {
+  static var zero: VJPStruct { return VJPStruct(p: 0) }
+  static func + (lhs: VJPStruct, rhs: VJPStruct) -> VJPStruct {
+    return VJPStruct(p: lhs.p + rhs.p)
+  }
+  static func - (lhs: VJPStruct, rhs: VJPStruct) -> VJPStruct {
+    return VJPStruct(p: lhs.p - rhs.p)
+  }
+  typealias Scalar = Float
+  static func * (lhs: Float, rhs: VJPStruct) -> VJPStruct {
+    return VJPStruct(p: lhs * rhs.p)
+  }
+}
+
 extension VJPStruct : Differentiable {
   typealias TangentVector = VJPStruct
   typealias CotangentVector = VJPStruct
-  func moved(toward direction: VJPStruct) -> VJPStruct {
-    return VJPStruct(p: p + direction.p)
-  }
-  func tangentVector(from cotangent: VJPStruct) -> VJPStruct {
-    return cotangent
-  }
 }
 
 extension VJPStruct {

branches/tensorflow/test/AutoDiff/protocol_requirement_autodiff.swift

@@ -25,10 +25,7 @@ extension DiffReq {
 
 struct Quadratic : DiffReq, Equatable {
   typealias TangentVector = Quadratic
-  typealias CoangentVector = Quadratic
-  func moved(toward q: Quadratic) -> Quadratic {
-    return Quadratic(a + q.a, b + q.b, c + q.c)
-  }
+  typealias CotangentVector = Quadratic
 
   let a, b, c: Float
   init(_ a: Float, _ b: Float, _ c: Float) {
@@ -42,13 +39,26 @@ struct Quadratic : DiffReq, Equatable {
   }
 }
 
+extension Quadratic : VectorNumeric {
+  static var zero: Quadratic { return Quadratic(0, 0, 0) }
+  static func + (lhs: Quadratic, rhs: Quadratic) -> Quadratic {
+    return Quadratic(lhs.a + rhs.a, lhs.b + rhs.b, lhs.c + rhs.c)
+  }
+  static func - (lhs: Quadratic, rhs: Quadratic) -> Quadratic {
+  return Quadratic(lhs.a + rhs.a, lhs.b + rhs.b, lhs.c + rhs.c)
+}
+  typealias Scalar = Float
+  static func * (lhs: Float, rhs: Quadratic) -> Quadratic {
+    return Quadratic(lhs * rhs.a, lhs * rhs.b, lhs * rhs.c)
+  }
+}
+
 ProtocolRequirementAutodiffTests.test("Trivial") {
   expectEqual((Quadratic(0, 0, 1), 12), Quadratic(11, 12, 13).gradF(at: 0))
   expectEqual((Quadratic(1, 1, 1), 2 * 11 + 12),
               Quadratic(11, 12, 13).gradF(at: 1))
   expectEqual((Quadratic(4, 2, 1), 2 * 11 * 2 + 12),
               Quadratic(11, 12, 13).gradF(at: 2))
-
 }
 
 runAllTests()

branches/tensorflow/test/AutoDiff/witness_table_silgen.swift

@@ -11,12 +11,15 @@ protocol Proto : Differentiable {
   func function3(_ x: Float, _ y: Float) -> Float
 }
 
-struct S : Proto {
+struct S : Proto, VectorNumeric {
+  static var zero: S { return S(p: 0) }
+  typealias Scalar = Float
+  static func + (lhs: S, rhs: S) -> S { return S(p: lhs.p + rhs.p) }
+  static func - (lhs: S, rhs: S) -> S { return S(p: lhs.p - rhs.p) }
+  static func * (lhs: Float, rhs: S) -> S { return S(p: lhs * rhs.p) }
+
   typealias TangentVector = S
   typealias CotangentVector = S
-  func moved(toward vector: TangentVector) -> S {
-    fatalError("unimplemented")
-  }
 
   let p: Float