Skip to content

[AutoDiff] Declare differential-producing differential operators. #25697

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Jun 24, 2019
Merged

[AutoDiff] Declare differential-producing differential operators. #25697

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
8e581ed
[AutoDiff] Declare diffenrential-producing differential operators.
njjiang Jun 24, 2019
27f05a9
Update indentation to 2 spaces
njjiang Jun 24, 2019
7b7c056
Make functions public and add @available attribute
njjiang Jun 24, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
208 changes: 167 additions & 41 deletions stdlib/public/core/AutoDiff.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -336,6 +336,37 @@ public extension Differentiable {
// Free-function-style differential operators
//===----------------------------------------------------------------------===//

// Transpose

@available(*, unavailable)
@inlinable
public func transpose<T, R>(
of body: @escaping @differentiable/*(linear)*/ (T) -> R
) -> @differentiable/*(linear)*/ (R) -> T {
fatalError()
}

// Value with differential

@available(*, unavailable)
@inlinable
public func valueWithDifferential<T, R>(
at x: T, in body: @differentiable (T) -> R
) -> (value: R, differential: @differentiable/*(linear)*/
(T.TangentVector) -> R.TangentVector) {
fatalError()
}

@available(*, unavailable)
@inlinable
public func valueWithDifferential<T, U, R>(
at x: T, _ y: U, in body: @differentiable (T, U) -> R
) -> (value: R,
differential: @differentiable/*(linear)*/
(T.TangentVector, U.TangentVector) -> R.TangentVector) {
fatalError()
}

// Value with pullback

@inlinable
Expand All @@ -362,6 +393,25 @@ public func valueWithPullback<T, U, V, R>(
return Builtin.autodiffApply_vjp_arity3(f, x, y, z)
}

// Differential

@available(*, unavailable)
@inlinable
public func differential<T, R>(
at x: T, in body: @differentiable(T) -> R
) -> @differentiable/*(linear)*/ (T.TangentVector) -> R.TangentVector {
fatalError()
}

@available(*, unavailable)
@inlinable
public func differential<T, U, R>(
at x: T, _ y: U, in body: @differentiable(T, U) -> R
) -> @differentiable/*(linear)*/ (T.TangentVector, U.TangentVector)
-> R.TangentVector {
fatalError()
}

// Pullback

@inlinable
Expand All @@ -386,6 +436,70 @@ public func pullback<T, U, V, R>(
return Builtin.autodiffApply_vjp_arity3(f, x, y, z).1
}

// Derivative

@available(*, unavailable)
@inlinable
public func derivative<T: FloatingPoint, R>(
at x: T, in body: @escaping @differentiable (T) -> R
) -> R.TangentVector where T.TangentVector : FloatingPoint {
fatalError()
}

@available(*, unavailable)
@inlinable
public func derivative<T: FloatingPoint, U: FloatingPoint, R>(
at x: T, _ y: U, in body: @escaping @differentiable (T) -> R
) -> R.TangentVector where T.TangentVector : FloatingPoint {
fatalError()
}

// Gradient

@inlinable
public func gradient<T, R>(
at x: T, in f: @differentiable (T) -> R
) -> T.TangentVector
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, in: f)(R(1))
}

@inlinable
public func gradient<T, U, R>(
at x: T, _ y: U, in f: @differentiable (T, U) -> R
) -> (T.TangentVector, U.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, y, in: f)(R(1))
}

@inlinable
public func gradient<T, U, V, R>(
at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> R
) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, y, z, in: f)(R(1))
}

// Value with derivative

@available(*, unavailable)
@inlinable
public func valueWithDerivative<T: FloatingPoint, R>(
at x: T, in body: @escaping @differentiable (T) -> R
) -> (value: R, derivative: R.TangentVector)
where T.TangentVector : FloatingPoint {
fatalError()
}

@available(*, unavailable)
@inlinable
public func valueWithDerivative<T: FloatingPoint, U: FloatingPoint, R>(
at x: T, _ y: U, in body: @escaping @differentiable (T) -> R
) -> (value: R, derivative: R.TangentVector)
where T.TangentVector : FloatingPoint {
fatalError()
}

// Value with gradient

@inlinable
Expand Down Expand Up @@ -416,84 +530,96 @@ public func valueWithGradient<T, U, V, R>(
return (y, pullback(R(1)))
}

// Value with gradient (curried)
// Derivative (curried)

@available(*, unavailable)
@inlinable
public func derivative<T: FloatingPoint, R>(
of body: @escaping @differentiable (T) -> R
) -> (T) -> R.TangentVector where T.TangentVector : FloatingPoint {
fatalError()
}

@available(*, unavailable)
@inlinable
public func derivative<T: FloatingPoint, U: FloatingPoint, R>(
of body: @escaping @differentiable (T, U) -> R
) -> (T, U) -> R.TangentVector where T.TangentVector : FloatingPoint {
fatalError()
}

// Gradient (curried)

@inlinable
public func valueWithGradient<T, R>(
public func gradient<T, R>(
of f: @escaping @differentiable (T) -> R
) -> (T) -> (value: R, gradient: T.TangentVector)
) -> (T) -> T.TangentVector
where R : FloatingPoint, R.TangentVector == R {
return { x in valueWithGradient(at: x, in: f) }
return { x in gradient(at: x, in: f) }
}

@inlinable
public func valueWithGradient<T, U, R>(
public func gradient<T, U, R>(
of f: @escaping @differentiable (T, U) -> R
) -> (T, U) -> (value: R, gradient: (T.TangentVector, U.TangentVector))
) -> (T, U) -> (T.TangentVector, U.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return { x, y in valueWithGradient(at: x, y, in: f) }
return { x, y in gradient(at: x, y, in: f) }
}

@inlinable
public func valueWithGradient<T, U, V, R>(
public func gradient<T, U, V, R>(
of f: @escaping @differentiable (T, U, V) -> R
) -> (T, U, V)
-> (value: R,
gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return { x, y, z in valueWithGradient(at: x, y, z, in: f) }
return { x, y, z in gradient(at: x, y, z, in: f) }
}

// Gradient

@inlinable
public func gradient<T, R>(
at x: T, in f: @differentiable (T) -> R
) -> T.TangentVector
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, in: f)(R(1))
}
// Value with derivative (curried)

@available(*, unavailable)
@inlinable
public func gradient<T, U, R>(
at x: T, _ y: U, in f: @differentiable (T, U) -> R
) -> (T.TangentVector, U.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, y, in: f)(R(1))
public func valueWithDerivative<T: FloatingPoint, R>(
of body: @escaping @differentiable (T) -> R
) -> (value: R, derivative: R.TangentVector)
where T.TangentVector: FloatingPoint {
fatalError()
}

@available(*, unavailable)
@inlinable
public func gradient<T, U, V, R>(
at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> R
) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return pullback(at: x, y, z, in: f)(R(1))
public func valueWithDerivative<T: FloatingPoint, U: FloatingPoint, R>(
of body: @escaping @differentiable (T, U) -> R
) -> (value: R, derivative: R.TangentVector)
where T.TangentVector: FloatingPoint, U.TangentVector: FloatingPoint {
fatalError()
}

// Gradient (curried)
// Value with gradient (curried)

@inlinable
public func gradient<T, R>(
public func valueWithGradient<T, R>(
of f: @escaping @differentiable (T) -> R
) -> (T) -> T.TangentVector
) -> (T) -> (value: R, gradient: T.TangentVector)
where R : FloatingPoint, R.TangentVector == R {
return { x in gradient(at: x, in: f) }
return { x in valueWithGradient(at: x, in: f) }
}

@inlinable
public func gradient<T, U, R>(
public func valueWithGradient<T, U, R>(
of f: @escaping @differentiable (T, U) -> R
) -> (T, U) -> (T.TangentVector, U.TangentVector)
) -> (T, U) -> (value: R, gradient: (T.TangentVector, U.TangentVector))
where R : FloatingPoint, R.TangentVector == R {
return { x, y in gradient(at: x, y, in: f) }
return { x, y in valueWithGradient(at: x, y, in: f) }
}

@inlinable
public func gradient<T, U, V, R>(
public func valueWithGradient<T, U, V, R>(
of f: @escaping @differentiable (T, U, V) -> R
) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
) -> (T, U, V)
-> (value: R,
gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
where R : FloatingPoint, R.TangentVector == R {
return { x, y, z in gradient(at: x, y, z, in: f) }
return { x, y, z in valueWithGradient(at: x, y, z, in: f) }
}

//===----------------------------------------------------------------------===//
Expand Down