এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

ডিফারেনশিয়াবল ভিউ

@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 সাথে গুণিত হয়।

উপলব্ধ যেখানে `Element`: `Differentiable`

ভিত্তি
দেখা অ্যারে।
ঘোষণা
public var base: [Element] { get set }
init(_:)
প্রদত্ত অ্যারের একটি ভিন্ন দৃশ্য তৈরি করে।
ঘোষণা
public init(_ base: [Element])
init(_:)
ঘোষণা
@derivative init(_: <<error type>>)

স্পর্শক ভেক্টর

ঘোষণা

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

সরানো (সাথে :)

ঘোষণা

public mutating mutating func move(along direction: TangentVector)

zeroTangentVectorInitializer
একটি বন্ধ যা self হিসাবে একই count সহ শূন্যের একটি TangentVector উৎপন্ন করে।
ঘোষণা
public var zeroTangentVectorInitializer: () -> TangentVector { get }

উপলব্ধ যেখানে `Element`: `EuclideanDifferentiable`

পার্থক্যযোগ্য ভেক্টরভিউ

ঘোষণা

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

উপলব্ধ যেখানে `উপাদান`: `পার্থক্যযোগ্য` এবং `সমান্য`

==(_:_:)

ঘোষণা

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

উপলব্ধ যেখানে `Element`: `Differentiable`

init(অ্যারেলিটারাল:)
ঘোষণা
public init(arrayLiteral elements: Element...)
বর্ণনা
ঘোষণা
public var description: String { get }

উপলব্ধ যেখানে `উপাদান`: `সংযোজন পাটিগণিত` এবং `পার্থক্য`

শূন্য

ঘোষণা

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 }

উপলব্ধ যেখানে `Element`: `Differentiable`

AllKeyPaths

ঘোষণা

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

allKeyPaths

ঘোষণা

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

উপলব্ধ যেখানে `Element`: `differentiable` & `Elimentary functions`

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
অসিন(_:)
রেডিয়ানে x এর বিপরীত সাইন।
ঘোষণা
public static func asin(_ x: `Self`) -> Array<Element>.DifferentiableView
আতান(_:)
রেডিয়ানে x এর বিপরীত স্পর্শক।
ঘোষণা
public static func atan(_ x: `Self`) -> Array<Element>.DifferentiableView
cosh(_:)
x এর হাইপারবোলিক কোসাইন।
ঘোষণা
public static func cosh(_ x: `Self`) -> Array<Element>.DifferentiableView
সিনহ(_:)
x এর হাইপারবোলিক সাইন।
ঘোষণা
public static func sinh(_ x: `Self`) -> Array<Element>.DifferentiableView
তানহ(_:)
x এর অধিবৃত্তীয় স্পর্শক।
ঘোষণা
public static func tanh(_ x: `Self`) -> Array<Element>.DifferentiableView
অ্যাকোশ(_:)
x এর বিপরীত হাইপারবোলিক কোসাইন।
ঘোষণা
public static func acosh(_ x: `Self`) -> Array<Element>.DifferentiableView
অসিং(_:)
x এর বিপরীত হাইপারবোলিক সাইন।
ঘোষণা
public static func asinh(_ x: `Self`) -> Array<Element>.DifferentiableView
atanh(_:)
x এর বিপরীত হাইপারবোলিক ট্যানজেন্ট।
ঘোষণা
public static func atanh(_ x: `Self`) -> Array<Element>.DifferentiableView
মেয়াদ(_:)
সূচকীয় ফাংশন 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

লগ2(_:)

x এর বেস-টু লগারিদম।

ঘোষণা

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

লগ10(_:)

x এর বেস-টেন লগারিদম।

ঘোষণা

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

log1p(_:)
log(1 + x) মূল্যায়ন করা হয়েছে যাতে শূন্যের কাছাকাছি নির্ভুলতা রক্ষা করা যায়।
ঘোষণা
public static func log1p(_ x: `Self`) -> Array<Element>.DifferentiableView
pow(_:_:)
exp(y log(x)) মধ্যবর্তী নির্ভুলতা না হারিয়ে গণনা করা হয়েছে।
বাস্তব প্রকারের জন্য, x ঋণাত্মক হলে ফলাফল হবে NaN, এমনকি y একটি অবিচ্ছেদ্য মান থাকলেও। জটিল ধরনের জন্য, ঋণাত্মক বাস্তব অক্ষের উপর একটি শাখা কাটা আছে।
ঘোষণা
public static func pow(_ x: `Self`, _ y: `Self`) -> Array<Element>.DifferentiableView
pow(_:_:)
x n ম শক্তিতে উত্থিত।
x এর n কপির গুণফল।
ঘোষণা
public static func pow(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView
মূল(_:_:)
x এর n ম মূল।
বাস্তব প্রকারের জন্য, যদি x ঋণাত্মক হয় এবং n জোড় হয়, ফলাফল হবে NaN। জটিল ধরনের জন্য, ঋণাত্মক বাস্তব অক্ষ বরাবর একটি শাখা কাটা আছে।
ঘোষণা
public static func root(_ x: `Self`, _ n: Int) -> Array<Element>.DifferentiableView

উপলব্ধ যেখানে `Element`: `Differentiable`

উপাদান

ঘোষণা

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`

ভেক্টরস্পেস স্কেলার
ঘোষণা
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)

উপলব্ধ যেখানে `উপাদান`: `পার্থক্যযোগ্য` এবং `বিন্দু অনুসারে বহুমুখী`

এক
ঘোষণা
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`)