דף זה תורגם על ידי Cloud Translation API.

DifferentiableView

@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

התצוגה של מערך כסעפת המוצר הניתנת להבדלה של Element מוכפלת עם עצמו פעמים count .

זמין כאשר 'אלמנט': 'ניתן להבדיל'

בָּסִיס
המערך הנצפה.
הַצהָרָה
public var base: [Element] { get set }
init(_:)
יוצר תצוגה ניתנת להבדלה של המערך הנתון.
הַצהָרָה
public init(_ base: [Element])
init(_:)
הַצהָרָה
@derivative init(_: <<error type>>)

TangentVector

הַצהָרָה

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

לנוע (יחד:)

הַצהָרָה

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInitializer
סגירה שמייצרת TangentVector של אפסים עם count זהה self .
הַצהָרָה
public var zeroTangentVectorInitializer: () -> TangentVector { get }

זמין כאשר 'אלמנט': 'EuclideanDifferentiable'

differentiableVectorView

הַצהָרָה

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

זמין כאשר 'Element': 'Differentiable' & 'Equatable'

==(_:_:)

הַצהָרָה

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

זמין כאשר 'אלמנט': 'ניתן להבדיל'

init(arrayLiteral:)

הַצהָרָה

public init(arrayLiteral elements: Element...)

תֵאוּר
הַצהָרָה
public var description: String { get }

זמין כאשר 'אלמנט': 'AdditiveArithmetic' ו'Differentiable'

אֶפֶס

הַצהָרָה

public static var zero: Array.DifferentiableView { get }

+(_:_:)

הַצהָרָה

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

-(_:_:)

הַצהָרָה

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

מנוי (_:)

הַצהָרָה

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

זמין כאשר 'אלמנט': 'ניתן להבדיל'

AllKeyPaths

הַצהָרָה

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

allKeyPaths

הַצהָרָה

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

זמין כאשר 'Element': 'Differentiable' & 'ElementaryFunctions'

sqrt(_:)
השורש הריבועי של x .
עבור טיפוסים אמיתיים, אם x הוא שלילי התוצאה היא .nan . עבור טיפוסים מורכבים יש חתך ענף על הציר האמיתי השלילי.
הַצהָרָה
public static func sqrt(_ x: `Self`) -> Array<Element>.DifferentiableView
חַסַת עָלִים(_:)
הקוסינוס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func cos(_ x: `Self`) -> Array<Element>.DifferentiableView
חֵטְא(_:)
הסינוס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func sin(_ x: `Self`) -> Array<Element>.DifferentiableView
לְהִשְׁתַזֵף(_:)
הטנגנס של x , מתפרש כזווית ברדיאנים.
הַצהָרָה
public static func tan(_ x: `Self`) -> Array<Element>.DifferentiableView

acos(_:)

הקוסינוס ההפוך של x ברדיאנים.

הַצהָרָה

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

asin(_:)

הסינוס ההפוך של x ברדיאנים.

הַצהָרָה

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

atan(_:)

הטנגנס ההפוך של x ברדיאנים.

הַצהָרָה

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

cosh(_:)

הקוסינוס ההיפרבולי של x .

הַצהָרָה

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

sinh(_:)

הסינוס ההיפרבולי של x .

הַצהָרָה

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

טאן(_:)

הטנגנס ההיפרבולי של x .

הַצהָרָה

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

acosh(_:)

הקוסינוס ההיפרבולי ההפוך של x .

הַצהָרָה

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

asinh(_:)

הסינוס ההיפרבולי ההפוך של x .

הַצהָרָה

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

atanh(_:)

הטנגנס ההיפרבולי ההפוך של x .

הַצהָרָה

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

exp(_:)
הפונקציה המעריכית שהוחלה על x , או e**x .
הַצהָרָה
public static func exp(_ x: `Self`) -> Array<Element>.DifferentiableView

exp2(_:)

שניים מועלים לעוצמה x .

הַצהָרָה

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

exp10(_:)

עשר מורם לעוצמה x .

הַצהָרָה

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

expm1(_:)
exp(x) - 1 מוערך כדי לשמור על דיוק קרוב לאפס.
הַצהָרָה
public static func expm1(_ x: `Self`) -> Array<Element>.DifferentiableView

עֵץ(_:)

הלוגריתם הטבעי של x .

הַצהָרָה

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

log2(_:)

הלוגריתם בסיס שניים של x .

הַצהָרָה

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

log10(_:)

הלוגריתם של בסיס עשר של x .

הַצהָרָה

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

log1p(_:)
log(1 + x) מוערך כדי לשמור על דיוק קרוב לאפס.
הַצהָרָה
public static func log1p(_ x: `Self`) -> Array<Element>.DifferentiableView
פאו(_:_:)
exp(y log(x)) מחושב ללא אובדן דיוק ביניים.
עבור טיפוסים אמיתיים, אם x הוא שלילי התוצאה היא NaN, גם אם y יש ערך אינטגרלי. עבור טיפוסים מורכבים, יש חתך ענף על הציר האמיתי השלילי.
הַצהָרָה
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>.DifferentiableView
פאו(_:_:)
x מועלה בחזקת ה- n .
המכפלה של n עותקים של x .
הַצהָרָה
public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView
שׁוֹרֶשׁ(_:_:)
השורש ה- n של x .
עבור טיפוסים אמיתיים, אם x הוא שלילי ו- n זוגי, התוצאה היא NaN. עבור טיפוסים מורכבים, יש ענף חתוך לאורך הציר האמיתי השלילי.
הַצהָרָה
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

זמין כאשר 'אלמנט': 'ניתן להבדיל'

אֵלֵמֶנט

הַצהָרָה

public typealias Element = Array<Element>.Element

מַדָד

הַצהָרָה

public typealias Index = Array<Element>.Index

מדדים

הַצהָרָה

public typealias Indices = Array<Element>.Indices

רצף משנה

הַצהָרָה

public typealias SubSequence = Array<Element>.SubSequence

מנוי (_:)

הַצהָרָה

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

startIndex
הַצהָרָה
public var startIndex: Index { get }
EndIndex
הַצהָרָה
public var endIndex: Index { get }
init()
הַצהָרָה
public init()

זמין כאשר 'Element': 'Differentiable' & 'VectorProtocol'

VectorSpaceScalar

הַצהָרָה

public typealias VectorSpaceScalar = Element.VectorSpaceScalar

מוֹסִיף(_:)

הַצהָרָה

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

לְהוֹסִיף(_:)

הַצהָרָה

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

מְחַסֵר(_:)

הַצהָרָה

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

לְחַסֵר(_:)

הַצהָרָה

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

קנה מידה (לפי:)

הַצהָרָה

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

קנה מידה (לפי:)

הַצהָרָה

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

זמין כאשר `Element`: `Differentiable` & `PointwiseMultiplitive`

אֶחָד
הַצהָרָה
public static var one: `Self` { get }
הֲדָדִי
הַצהָרָה
public var reciprocal: `Self` { get }

.*(_:_:)

הַצהָרָה

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

.*=(_:_:)

הַצהָרָה

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