Warning: This project is deprecated. Swift for TensorFlow was an experiment in the next-generation platform for machine learning, incorporating the latest research across machine learning, compilers, differentiable programming, systems design, and beyond. It was archived in February 2021.

Array

extension Array: MutableCollectionAlgorithms

extension Array: KeyPathIterable

extension Array: Differentiable where Element: Differentiable

extension Array: EuclideanDifferentiable
where Element: EuclideanDifferentiable

extension Array where Element: Differentiable

extension Array : ConvertibleFromNumpyArray
where Element : NumpyScalarCompatible

public extension Array where Element : NumpyScalarCompatible

extension Array : PythonConvertible where Element : PythonConvertible

extension Array : ConvertibleFromPython where Element : ConvertibleFromPython

extension Array: ElementaryFunctions where Element: ElementaryFunctions

extension Array: TensorArrayProtocol where Element: TensorGroup

extension Array where Element == UInt8

extension Array where Element == Bool

extension Array where Element == Int64

extension Array where Element == XLATensor

extension Array where Element: AnyTensor

extension Array where Element == PaddingConfigDimension


                    
                    
                    DifferentiableView

The view of an array as the differentiable product manifold of Element multiplied with itself count times.

Declaration

@frozen
public struct DifferentiableView

extension Array.DifferentiableView: Differentiable
where Element: Differentiable

extension Array.DifferentiableView: EuclideanDifferentiable
where Element: EuclideanDifferentiable

extension Array.DifferentiableView: Equatable
where Element: Differentiable & Equatable

extension Array.DifferentiableView: ExpressibleByArrayLiteral
where Element: Differentiable

extension Array.DifferentiableView: CustomStringConvertible
where Element: Differentiable

extension Array.DifferentiableView: AdditiveArithmetic
where Element: AdditiveArithmetic & Differentiable

extension Array.DifferentiableView: _KeyPathIterableBase
where Element: Differentiable

extension Array.DifferentiableView: KeyPathIterable
where Element: Differentiable

extension Array.DifferentiableView: ElementaryFunctions
where Element: Differentiable & ElementaryFunctions

extension Array.DifferentiableView:
  BidirectionalCollection,
  Collection,
  MutableCollection,
  RandomAccessCollection,
  RangeReplaceableCollection,
  Sequence
where Element: Differentiable

extension Array.DifferentiableView: VectorProtocol
where Element: Differentiable & VectorProtocol

extension Array.DifferentiableView: PointwiseMultiplicative
where Element: Differentiable & PointwiseMultiplicative


                    
                    
                    AllKeyPaths

Declaration

public typealias AllKeyPaths = [PartialKeyPath<Array>]


                    
                    
                    allKeyPaths

Declaration

public var allKeyPaths: [PartialKeyPath<Array>] { get }

Available where `Element`: `Differentiable`


                    
                    
                    TangentVector

Declaration

public typealias TangentVector =
  Array<Element.TangentVector>.DifferentiableView


                    
                    
                    move(along:)

Declaration

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInitializer
A closure that produces a TangentVector of zeros with the same count as self.
Declaration
public var zeroTangentVectorInitializer: () -> TangentVector { get }

Available where `Element`: `EuclideanDifferentiable`


                    
                    
                    differentiableVectorView

Declaration

public var differentiableVectorView: TangentVector { get }

Available where `Element`: `Differentiable`

init(repeating:)
Declaration
@derivative init(repeating: count)


                    
                    
                    differentiableMap(_:)

Declaration

@differentiable(wrt: self)
public func differentiableMap<Result: Differentiable>(
  _ body: @differentiable (Element) -> Result
) -> [Result]


                    
                    
                    differentiableReduce(_:_:)

Declaration

@differentiable(wrt: (self, initialResult)
public func differentiableReduce<Result: Differentiable>(
  _ initialResult: Result,
  _ nextPartialResult: @differentiable (Result, Element) -> Result
) -> Result

Available where `Element` : `NumpyScalarCompatible`


                    
                    
                    init(numpy:)

Creates an Array with the same shape and scalars as the specified numpy.ndarray instance.

Precondition

The numpy Python package must be installed.

Declaration

public init?(numpy numpyArray: PythonObject)

Parameters


                                numpyArray

The numpy.ndarray instance to convert.

Return Value

numpyArray converted to an Array. Returns nil if numpyArray is not 1-D or does not have a compatible scalar dtype.

makeNumpyArray()
Creates a 1-D numpy.ndarray instance with the same scalars as this Array.

Precondition
The numpy Python package must be installed.
Declaration
func makeNumpyArray() -> PythonObject

Available where `Element` : `PythonConvertible`


                    
                    
                    pythonObject

Declaration

public var pythonObject: PythonObject { get }

Available where `Element` : `ConvertibleFromPython`


                    
                    
                    init(_:)

Declaration

public init?(_ pythonObject: PythonObject)

Available where `Element`: `ElementaryFunctions`

sqrt(_:)
The square root of x.

For real types, if x is negative the result is .nan. For complex types there is a branch cut on the negative real axis.
Declaration
public static func sqrt(_ x: `Self`) -> Array<Element>
cos(_:)
The cosine of x, interpreted as an angle in radians.
Declaration
public static func cos(_ x: `Self`) -> Array<Element>
sin(_:)
The sine of x, interpreted as an angle in radians.
Declaration
public static func sin(_ x: `Self`) -> Array<Element>
tan(_:)
The tangent of x, interpreted as an angle in radians.
Declaration
public static func tan(_ x: `Self`) -> Array<Element>


                    
                    
                    acos(_:)

The inverse cosine of x in radians.

Declaration

public static func acos(_ x: `Self`) -> Array<Element>


                    
                    
                    asin(_:)

The inverse sine of x in radians.

Declaration

public static func asin(_ x: `Self`) -> Array<Element>


                    
                    
                    atan(_:)

The inverse tangent of x in radians.

Declaration

public static func atan(_ x: `Self`) -> Array<Element>


                    
                    
                    cosh(_:)

The hyperbolic cosine of x.

Declaration

public static func cosh(_ x: `Self`) -> Array<Element>


                    
                    
                    sinh(_:)

The hyperbolic sine of x.

Declaration

public static func sinh(_ x: `Self`) -> Array<Element>


                    
                    
                    tanh(_:)

The hyperbolic tangent of x.

Declaration

public static func tanh(_ x: `Self`) -> Array<Element>


                    
                    
                    acosh(_:)

The inverse hyperbolic cosine of x.

Declaration

public static func acosh(_ x: `Self`) -> Array<Element>


                    
                    
                    asinh(_:)

The inverse hyperbolic sine of x.

Declaration

public static func asinh(_ x: `Self`) -> Array<Element>


                    
                    
                    atanh(_:)

The inverse hyperbolic tangent of x.

Declaration

public static func atanh(_ x: `Self`) -> Array<Element>

exp(_:)
The exponential function applied to x, or e**x.
Declaration
public static func exp(_ x: `Self`) -> Array<Element>


                    
                    
                    exp2(_:)

Two raised to to power x.

Declaration

public static func exp2(_ x: `Self`) -> Array<Element>


                    
                    
                    exp10(_:)

Ten raised to to power x.

Declaration

public static func exp10(_ x: `Self`) -> Array<Element>

expm1(_:)
exp(x) - 1 evaluated so as to preserve accuracy close to zero.
Declaration
public static func expm1(_ x: `Self`) -> Array<Element>


                    
                    
                    log(_:)

The natural logarithm of x.

Declaration

public static func log(_ x: `Self`) -> Array<Element>


                    
                    
                    log2(_:)

The base-two logarithm of x.

Declaration

public static func log2(_ x: `Self`) -> Array<Element>


                    
                    
                    log10(_:)

The base-ten logarithm of x.

Declaration

public static func log10(_ x: `Self`) -> Array<Element>

log1p(_:)
log(1 + x) evaluated so as to preserve accuracy close to zero.
Declaration
public static func log1p(_ x: `Self`) -> Array<Element>
pow(_:_:)
exp(y log(x)) computed without loss of intermediate precision.

For real types, if x is negative the result is NaN, even if y has an integral value. For complex types, there is a branch cut on the negative real axis.
Declaration
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>


                    
                    
                    pow(_:_:)

x raised to the nth power.

The product of n copies of x.

Declaration

public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>

root(_:_:)
The nth root of x.

For real types, if x is negative and n is even, the result is NaN. For complex types, there is a branch cut along the negative real axis.
Declaration
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>

Available where `Element`: `TensorGroup`


                    
                    
                    init(_owning:count:)

Declaration

public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int)


                    
                    
                    init(_handles:)

Declaration

public init<C: RandomAccessCollection>(
  _handles: C
) where C.Element: _AnyTensorHandle

Available where `Element` == `UInt8`

sha1()
Note
The SHA1 hash is only 20 bytes long and so only the first 20 bytes of the returned SIMD32<UInt8> are non-zero.
Declaration
func sha1() -> SIMD32<UInt8>
sha512()
Declaration
func sha512() -> SIMD64<UInt8>

Available where `Element` == `Bool`

mergingMask(with:)
Computes a || b elementwise as though we were or-ing together two masks.
Declaration
public func mergingMask(with other: [Bool]) -> [Bool]

Available where `Element` == `Int64`


                    
                    
                    withArrayRef(_:)

Declaration

func withArrayRef<Result>(_ body: (Int64ArrayRef) throws -> Result) rethrows -> Result

Available where `Element` == `XLATensor`


                    
                    
                    withArrayRef(_:)

Declaration

func withArrayRef<Result>(_ body: (OpaqueXLATensorArrayRef) throws -> Result) rethrows -> Result

Available where `Element`: `AnyTensor`


                    
                    
                    withArrayRef(_:)

Declaration

func withArrayRef<T, Result>(_ body: (OpaqueXLATensorArrayRef) throws -> Result) rethrows
  -> Result
where Element == Tensor<T>

Available where `Element` == `PaddingConfigDimension`


                    
                    
                    withArrayRef(_:)

Declaration

func withArrayRef<Result>(_ body: (inout PaddingConfig) -> Result) -> Result