Cette page a été traduite par l'API Cloud Translation.

Vue différenciable

@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

La vue d'un tableau en tant que variété de produits différentiables d' Element multipliée par elle-même count des fois.

Disponible où `Element` : `Differentiable`

base
Le tableau affiché.
Déclaration
public var base: [Element] { get set }
initialisation(_:)
Crée une vue différenciable du tableau donné.
Déclaration
public init(_ base: [Element])
initialisation(_:)
Déclaration
@derivative init(_: <<error type>>)

TangenteVecteur

Déclaration

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

bouger (le long :)

Déclaration

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInitializer
Une fermeture qui produit un TangentVector de zéros avec le même count que self .
Déclaration
public var zeroTangentVectorInitializer: () -> TangentVector { get }

Disponible où `Element` : `EuclideanDifferentiable`

différentiableVectorView

Déclaration

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

Disponible où `Element` : `Differentiable` & `Equatable`

==(_:_:)

Déclaration

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

Disponible où `Element` : `Differentiable`

init (arrayLiteral :)

Déclaration

public init(arrayLiteral elements: Element...)

description
Déclaration
public var description: String { get }

Disponible où `Element` : `AdditiveArithmetic` & `Differentiable`

zéro

Déclaration

public static var zero: Array.DifferentiableView { get }

+(_:_:)

Déclaration

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

-(_:_:)

Déclaration

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

indice(_:)

Déclaration

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

Disponible où `Element` : `Differentiable`

Tous les chemins clés

Déclaration

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

tous les chemins clés

Déclaration

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

Disponible où `Element` : `Differentiable` & `ElementaryFunctions`

carré(_:)
La racine carrée de x .
Pour les types réels, si x est négatif, le résultat est .nan . Pour les types complexes il y a une branche coupée sur l’axe réel négatif.
Déclaration
public static func sqrt(_ x: `Self`) -> Array<Element>.DifferentiableView

cos(_:)

Le cosinus de x , interprété comme un angle en radians.

Déclaration

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

péché(_:)

Le sinus de x , interprété comme un angle en radians.

Déclaration

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

tanné(_:)

La tangente de x , interprétée comme un angle en radians.

Déclaration

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

acos(_:)

Le cosinus inverse de x en radians.

Déclaration

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

asin(_:)

Le sinus inverse de x en radians.

Déclaration

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

atan(_:)

La tangente inverse de x en radians.

Déclaration

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

matraque(_:)

Le cosinus hyperbolique de x .

Déclaration

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

sinh(_:)

Le sinus hyperbolique de x .

Déclaration

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

tanh(_:)

La tangente hyperbolique de x .

Déclaration

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

acosh(_:)

Le cosinus hyperbolique inverse de x .

Déclaration

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

asinh(_:)

Le sinus hyperbolique inverse de x .

Déclaration

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

atanh(_:)

La tangente hyperbolique inverse de x .

Déclaration

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

exp(_:)

La fonction exponentielle appliquée à x , ou e**x .

Déclaration

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

exp2(_:)

Deux élevés au pouvoir x .

Déclaration

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

exp10(_:)

Dix élevés au pouvoir x .

Déclaration

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

expm1(_:)
exp(x) - 1 évalué de manière à conserver une précision proche de zéro.
Déclaration
public static func expm1(_ x: `Self`) -> Array<Element>.DifferentiableView

enregistrer(_:)

Le logarithme népérien de x .

Déclaration

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

log2(_:)

Le logarithme en base deux de x .

Déclaration

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

log10(_:)

Le logarithme en base dix de x .

Déclaration

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

log1p(_:)
log(1 + x) évalué de manière à conserver une précision proche de zéro.
Déclaration
public static func log1p(_ x: `Self`) -> Array<Element>.DifferentiableView
pow(_:_:)
exp(y log(x)) calculé sans perte de précision intermédiaire.
Pour les types réels, si x est négatif le résultat est NaN, même si y a une valeur entière. Pour les types complexes, il existe une branche coupée sur l’axe réel négatif.
Déclaration
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>.DifferentiableView

pow(_:_:)

x élevé à la n puissance.

Le produit de n copies de x .

Déclaration

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

racine(_:_:)
La n ème racine de x .
Pour les types réels, si x est négatif et n est pair, le résultat est NaN. Pour les types complexes, il existe une branche coupée le long de l’axe réel négatif.
Déclaration
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

Disponible où `Element` : `Differentiable`

Élément

Déclaration

public typealias Element = Array<Element>.Element

Indice

Déclaration

public typealias Index = Array<Element>.Index

Indices

Déclaration

public typealias Indices = Array<Element>.Indices

Sous-séquence

Déclaration

public typealias SubSequence = Array<Element>.SubSequence

indice(_:)

Déclaration

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

débutIndex
Déclaration
public var startIndex: Index { get }
finIndex
Déclaration
public var endIndex: Index { get }
initialisation()
Déclaration
public init()

Disponible où `Element` : `Differentiable` & `VectorProtocol`

VecteurEspaceScalaire

Déclaration

public typealias VectorSpaceScalar = Element.VectorSpaceScalar

ajout (_:)

Déclaration

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

ajouter(_:)

Déclaration

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

soustraire(_:)

Déclaration

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

soustraire(_:)

Déclaration

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

mis à l'échelle (par :)

Déclaration

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

échelle (par :)

Déclaration

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

Disponible où `Element` : `Differentiable` & `PointwiseMultiplicative`

un
Déclaration
public static var one: `Self` { get }
réciproque
Déclaration
public var reciprocal: `Self` { get }

.*(_:_:)

Déclaration

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

.*=(_:_:)

Déclaration

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