Provides customization points for MutableCollection algorithms.

If incorporated into the standard library, these requirements would just be part of MutableCollection. In the meantime, you can declare conformance of a collection to MutableCollectionAlgorithms to get these customization points to be used from other algorithms defined on MutableCollectionAlgorithms.

Types whose elements can be collated in some higher-rank element of the same type (example: tensors, tuple of tensors)

A type whose nested properties and elements can be copied to a Device.

A type whose values provides custom key paths to properties or elements.

A scalar data type compatible with TensorFlow.

Types that conform to TensorFlowScalar can be used as the Scalar associated type of Tensor.

An integer data type that represents integer types which can be used as tensor indices in TensorFlow.

A floating-point data type that conforms to Differentiable and is compatible with TensorFlow.

A type that mathematically represents a differentiable manifold whose tangent spaces are finite-dimensional.

A type with values that support pointwise multiplication.

A type that represents an unranked vector space. Values of this type are elements in this vector space and have either no shape or a static shape.

A type that is differentiable in the Euclidean space. The type may represent a vector space, or consist of a vector space and some other non-differentiable component.

Mathematically, this represents a product manifold that consists of a differentiable vector space and some arbitrary manifold, where the tangent bundle of the entire product manifold is equal to the vector space component.

This abstraction is useful for representing common differentiable data structures that contain both differentiable vector properties and other stored properties that do not have a derivative, e.g.

struct Perceptron: @memberwise EuclideanDifferentiable {
    var weight: SIMD16<Float>
    var bias: Float
    @noDerivative var useBias: Bool
}

A neural network layer.

Types that conform to Layer represent functions that map inputs to outputs. They may have an internal state represented by parameters, such as weight tensors.

Layer instances define a differentiable callAsFunction(_:) method for mapping inputs to outputs.

A parameterless neural network layer.

The TangentVector of parameterless layers is always EmptyTangentVector.

A type that has elementary functions available.

An “elementary function” is a function built up from powers, roots, exponentials, logarithms, trigonometric functions (sin, cos, tan) and their inverses, and the hyperbolic functions (sinh, cosh, tanh) and their inverses.

Conformance to this protocol means that all of these building blocks are available as static functions on the type.

let x: Float = 1
let y = Float.sin(x) // 0.84147096

A type whose nested floating-point tensor properties and elements can be converted from full precision to reduced precision and vice versa.

An implementation detail used to work around the fact that Swift can’t express a generic constraint that some type must be an instance of Sampling.

A type that can be initialized from a numpy.ndarray instance represented as a PythonObject.

A type that is bitwise compatible with one or more NumPy scalar types.

A type whose values can be converted to a PythonObject.

A type that can be initialized from a PythonObject.

A type that provides seedable deterministic pseudo-random data.

A SeedableRandomNumberGenerator can be used anywhere where a RandomNumberGenerator would be used. It is useful when the pseudo-random data needs to be reproducible across runs.

Conforming to the SeedableRandomNumberGenerator Protocol

To make a custom type conform to the SeedableRandomNumberGenerator protocol, implement the init(seed: [UInt8]) initializer, as well as the requirements for RandomNumberGenerator. The values returned by next() must form a deterministic sequence that depends only on the seed provided upon initialization.

A recurrent layer cell.

A type with values that support differentiable binary operations.

Used by BidirectionalRecurrentLayer as a generic requirement for merge functions.

Special protocol for calling tensorflow operations that take heterogeneous arrays as input.

A protocol representing types that can be mapped to Array<CTensorHandle>.

This protocol is defined separately from TensorGroup in order for the number of tensors to be determined at runtime. For example, [Tensor<Float>] may have an unknown number of elements at compile time.

This protocol can be derived automatically for structs whose stored properties all conform to the TensorGroup protocol. It cannot be derived automatically for structs whose properties all conform to TensorArrayProtocol due to the constructor requirement (i.e., in such cases it would be impossible to know how to break down count among the stored properties).

A protocol representing types that can be mapped to and from Array<CTensorHandle>.

When a TensorGroup is used as an argument to a tensor operation, it is passed as an argument list whose elements are the tensor fields of the type.

When a TensorGroup is returned as a result of a tensor operation, it is initialized with its tensor fields set to the tensor operation’s tensor results.

A supported datatype in x10.