Esta página foi traduzida pela API Cloud Translation.

Visualização Diferenciável

@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

A visão de uma matriz como a variedade de produto diferenciável do Element multiplicado por ele mesmo pelos tempos count .

Disponível onde `Element`: `Differentiable`

base
A matriz visualizada.
Declaração
public var base: [Element] { get set }
iniciar(_:)
Cria uma visão diferenciável do array fornecido.
Declaração
public init(_ base: [Element])
iniciar(_:)
Declaração
@derivative init(_: <<error type>>)

TangenteVetor

Declaração

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

mover (junto:)

Declaração

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInicializador
Um fechamento que produz um TangentVector de zeros com a mesma count que self .
Declaração
public var zeroTangentVectorInitializer: () -> TangentVector { get }

Disponível onde `Element`: `EuclideanDifferentiable`

VectorView diferenciável

Declaração

public var differentiableVectorView: Array.DifferentiableView.TangentVector { get }

Disponível onde `Element`: `Differentiable` e `Equatable`

==(_:_:)

Declaração

public static func == (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Bool

Disponível onde `Element`: `Differentiable`

iniciar(arrayLiteral:)

Declaração

public init(arrayLiteral elements: Element...)

descrição
Declaração
public var description: String { get }

Disponível onde `Element`: `AdditiveArithmetic` e `Differentiable`

zero

Declaração

public static var zero: Array.DifferentiableView { get }

+(_:_:)

Declaração

public static func + (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Array.DifferentiableView

-(_:_:)

Declaração

public static func - (
  lhs: Array.DifferentiableView,
  rhs: Array.DifferentiableView
) -> Array.DifferentiableView

subscrito(_:)

Declaração

public subscript(index: Int) -> Element { get }

Disponível onde `Element`: `Differentiable`

Todos os caminhos-chave

Declaração

public typealias AllKeyPaths = [PartialKeyPath<Array.DifferentiableView>]

todosKeyPaths

Declaração

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

Disponível onde `Element`: `Differentiable` e `ElementaryFunctions`

quadrado(_:)
A raiz quadrada de x .
Para tipos reais, se x for negativo o resultado será .nan . Para tipos complexos existe um corte de ramo no eixo real negativo.
Declaração
public static func sqrt(_ x: `Self`) -> Array<Element>.DifferentiableView

porque(_:)

O cosseno de x , interpretado como um ângulo em radianos.

Declaração

public static func cos(_ x: `Self`) -> Array<Element>.DifferentiableView

pecado(_:)

O seno de x , interpretado como um ângulo em radianos.

Declaração

public static func sin(_ x: `Self`) -> Array<Element>.DifferentiableView

bronzeado(_:)
A tangente de x , interpretada como um ângulo em radianos.
Declaração
public static func tan(_ x: `Self`) -> Array<Element>.DifferentiableView

acos(_:)

O cosseno inverso de x em radianos.

Declaração

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

asin(_:)

O seno inverso de x em radianos.

Declaração

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

atan(_:)

A tangente inversa de x em radianos.

Declaração

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

cosh(_:)

O cosseno hiperbólico de x .

Declaração

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

sinh(_:)

O seno hiperbólico de x .

Declaração

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

tan(_:)

A tangente hiperbólica de x .

Declaração

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

acosh(_:)

O cosseno hiperbólico inverso de x .

Declaração

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

asinh(_:)

O seno hiperbólico inverso de x .

Declaração

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

atanh(_:)

A tangente hiperbólica inversa de x .

Declaração

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

exp(_:)

A função exponencial aplicada a x ou e**x .

Declaração

public static func exp(_ x: `Self`) -> Array<Element>.DifferentiableView

exp2(_:)

Dois elevados à potência x .

Declaração

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

exp10(_:)

Dez elevado à potência x .

Declaração

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

expm1(_:)
exp(x) - 1 avaliado de forma a preservar a precisão próxima de zero.
Declaração
public static func expm1(_ x: `Self`) -> Array<Element>.DifferentiableView

registro(_:)

O logaritmo natural de x .

Declaração

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

registro2(_:)

O logaritmo de base dois de x .

Declaração

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

registro10(_:)

O logaritmo de base dez de x .

Declaração

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

log1p(_:)
log(1 + x) avaliado de forma a preservar a precisão próxima de zero.
Declaração
public static func log1p(_ x: `Self`) -> Array<Element>.DifferentiableView
prisioneiro de guerra(_:_:)
exp(y log(x)) calculado sem perda de precisão intermediária.
Para tipos reais, se x for negativo o resultado será NaN, mesmo que y tenha um valor integral. Para tipos complexos, há um corte de ramo no eixo real negativo.
Declaração
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>.DifferentiableView
prisioneiro de guerra(_:_:)
x elevado à n ésima potência.
O produto de n cópias de x .
Declaração
public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView
raiz(_:_:)
A n raiz de x .
Para tipos reais, se x for negativo en n par, o resultado será NaN. Para tipos complexos, há um corte de ramo ao longo do eixo real negativo.
Declaração
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

Disponível onde `Element`: `Differentiable`

Elemento

Declaração

public typealias Element = Array<Element>.Element

Índice

Declaração

public typealias Index = Array<Element>.Index

Índices

Declaração

public typealias Indices = Array<Element>.Indices

Subsequência

Declaração

public typealias SubSequence = Array<Element>.SubSequence

subscrito(_:)

Declaração

public subscript(position: Array<Element>.Index) -> Element { get set }

startIndex
Declaração
public var startIndex: Index { get }
endIndex
Declaração
public var endIndex: Index { get }
inicialização()
Declaração
public init()

Disponível onde `Element`: `Differentiable` e `VectorProtocol`

VectorSpaceScalar

Declaração

public typealias VectorSpaceScalar = Element.VectorSpaceScalar

adicionando(_:)

Declaração

public func adding(_ x: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

adicionar(_:)

Declaração

public mutating mutating func add(_ x: Element.VectorSpaceScalar)

subtraindo(_:)

Declaração

public func subtracting(_ x: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

subtrair(_:)

Declaração

public mutating mutating func subtract(_ x: Element.VectorSpaceScalar)

dimensionado (por:)

Declaração

public func scaled(by scale: Element.VectorSpaceScalar) -> Array<Element>.DifferentiableView

escala (por:)

Declaração

public mutating mutating func scale(by scale: Element.VectorSpaceScalar)

Disponível onde `Element`: `Differentiable` e `PointwiseMultiplicative`

um
Declaração
public static var one: `Self` { get }
recíproca
Declaração
public var reciprocal: `Self` { get }

.*(_:_:)

Declaração

public static func .* (lhs: `Self`, rhs: `Self`) -> Array<Element>.DifferentiableView

.*=(_:_:)

Declaração

public static func .*= (lhs: inout `Self`, rhs: `Self`)