ShapedArraySlice

@frozen
public struct ShapedArraySlice<Scalar> : _ShapedArrayProtocol

extension ShapedArraySlice: RandomAccessCollection, MutableCollection

extension ShapedArraySlice: CustomStringConvertible

extension ShapedArraySlice: CustomPlaygroundDisplayConvertible

extension ShapedArraySlice: CustomReflectable

extension ShapedArraySlice: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar

extension ShapedArraySlice: Equatable where Scalar: Equatable

extension ShapedArraySlice: Hashable where Scalar: Hashable

extension ShapedArraySlice: Codable where Scalar: Codable

Uma fatia contígua de uma instância ShapedArray ou ShapedArraySlice .

ShapedArraySlice permite operações rápidas e eficientes em fatias contíguas de instâncias ShapedArray . As instâncias ShapedArraySlice não possuem armazenamento próprio. Em vez disso, eles fornecem uma visão do armazenamento de seu ShapedArray base. ShapedArraySlice pode representar dois tipos diferentes de fatias: matrizes de elementos e submatrizes.

Matrizes de elementos são elementos subdimensionais de um ShapedArray : sua classificação é um a menos que sua base. As fatias da matriz de elementos são obtidas indexando uma instância ShapedArray com um índice Int32 singular.

Por exemplo:

    var matrix = ShapedArray(shape: [2, 2], scalars: [0, 1, 2, 3])
    // `matrix` represents [[0, 1], [2, 3]].

    let element = matrix[0]
    // `element` is a `ShapedArraySlice` with shape [2]. It is an element
    // array, specifically the first element in `matrix`: [0, 1].

    matrix[1] = ShapedArraySlice(shape: [2], scalars: [4, 8])
    // The second element in `matrix` has been mutated.
    // `matrix` now represents [[0, 1, 4, 8]].

Subarrays são um intervalo contíguo de elementos em um ShapedArray . A classificação de um subarray é igual à de sua base, mas sua dimensão principal é a contagem do intervalo de fatias. As fatias de subarray são obtidas indexando um ShapedArray com um Range<Int32> que representa um intervalo de elementos (na dimensão principal). Métodos como prefix(:) e suffix(:) que indexam internamente com um intervalo também produzem subarray.

Por exemplo:

    let zeros = ShapedArray(repeating: 0, shape: [3, 2])
    var matrix = ShapedArray(shape: [3, 2], scalars: Array(0..<6))
    // `zeros` represents [[0, 0], [0, 0], [0, 0]].
    // `matrix` represents [[0, 1], [2, 3], [4, 5]].

    let subarray = matrix.prefix(2)
    // `subarray` is a `ShapedArraySlice` with shape [2, 2]. It is a slice
    // of the first 2 elements in `matrix` and represents [[0, 1], [2, 3]].

    matrix[0..<2] = zeros.prefix(2)
    // The first 2 elements in `matrix` have been mutated.
    // `matrix` now represents [[0, 0], [0, 0], [4, 5]].

• classificação
  O número de dimensões da matriz.

  Declaração

  public var rank: Int { get }

• forma
  A forma da matriz.

  Declaração

  public var shape: [Int] { get }

• contagem escalar
  O número total de escalares na matriz.

  Declaração

  public var scalarCount: Int { get }

• init(forma:escalares:)
  Cria um ShapedArraySlice com a forma especificada e escalares contíguos na ordem principal da linha.

  Condição prévia

  O número de escalares deve ser igual ao produto das dimensões da forma.

  Declaração

  public init(shape: [Int], scalars: [Scalar])

• init(forma:escalares:)
  Cria um ShapedArraySlice com a forma especificada e a sequência de escalares na ordem principal da linha.

  Condição prévia

  O número de escalares deve ser igual ao produto das dimensões da forma.

  Declaração

  public init<S>(shape: [Int], scalars: S) where Scalar == S.Element, S : Sequence

• iniciar(_:)
  Cria um ShapedArraySlice a partir de um valor escalar.

  Declaração

  public init(_ scalar: Scalar)

• init(forma:repetindo:)
  Cria um ShapedArraySlice com a forma especificada e um valor escalar único e repetido.

  Declaração

  @available(*, deprecated, renamed: "init(repeating:shape:﹚")
  public init(shape: [Int], repeating repeatedValue: Scalar)

  Parâmetros

  repeatedValue	O valor escalar a ser repetido.
  shape	A forma do ShapedArraySlice .

• init(repetindo:forma:)
  Cria um ShapedArraySlice com a forma especificada e um valor escalar único e repetido.

  Declaração

  public init(repeating repeatedValue: Scalar, shape: [Int])

  Parâmetros

  repeatedValue	O valor escalar a ser repetido.
  shape	A forma do ShapedArraySlice .

• escalarRange
  O intervalo de escalares do ShapedArray base representado por um ShapedArraySlice .

  Declaração

  var scalarRange: Range<Int> { get }

• comUnsafeBufferPointer(_:)
  Chama um fechamento com um ponteiro para o armazenamento contíguo do ShapedArraySlice .

  Declaração

  public func withUnsafeBufferPointer<Result>(
    _ body: (UnsafeBufferPointer<Scalar>) throws -> Result
  ) rethrows -> Result

  Parâmetros

  body

  Um encerramento com um parâmetro UnsafeBufferPointer que aponta para o armazenamento contíguo do ShapedArraySlice . Se não existir tal armazenamento, ele será criado. Se body tiver um valor de retorno, esse valor também será usado como valor de retorno para o método withUnsafeBufferPointer(_:) . O argumento do ponteiro é válido apenas durante a execução do método.

• comUnsafeMutableBufferPointer(_:)
  Chama o fechamento fornecido com um ponteiro para o armazenamento contíguo mutável do ShapedArraySlice .

  Declaração

  public mutating func withUnsafeMutableBufferPointer<Result>(
    _ body: (inout UnsafeMutableBufferPointer<Scalar>) throws -> Result
  ) rethrows -> Result

  Parâmetros

  body

  Um fechamento com um parâmetro UnsafeMutableBufferPointer que aponta para o armazenamento contíguo do ShapedArraySlice . Se não existir tal armazenamento, ele será criado. Se body tiver um valor de retorno, esse valor também será usado como valor de retorno para o método withUnsafeMutableBufferPointer(_:) . O argumento do ponteiro é válido apenas durante a execução do método.

• Índice
  Declaração

  public typealias Index = Int

• Elemento
  Declaração

  public typealias Element = ShapedArraySlice

• Subsequência
  Declaração

  public typealias SubSequence = ShapedArraySlice

• índices
  Declaração

  public var indices: Range<Int> { get }

• startIndex
  Declaração

  public var startIndex: Int { get }

• endIndex
  Declaração

  public var endIndex: Int { get }

• subscrito(_:)
  Acesse a matriz de elementos especificada por um índice na dimensão inicial.

  Declaração

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

  Parâmetros

  index

  Índice da matriz de elementos.

• subscrito(_:)
  Acesse o subarray especificado por um intervalo contíguo de índices.

  Declaração

  public subscript(bounds: Range<Int>) -> SubSequence { get set }

  Parâmetros

  bounds

  Gama contígua de índices.

• descrição
  Uma representação textual deste ShapedArraySlice .

  Observação

  use fullDescription para uma representação não impressa mostrando todos os escalares.

  Declaração

  public var description: String { get }

• playgroundDescrição
  Declaração

  public var playgroundDescription: Any { get }

• espelho personalizado
  Declaração

  public var customMirror: Mirror { get }

Disponível onde `Scalar`: `TensorFlowScalar`

• iniciar(_:)
  Declaração

  public init(_ tensor: Tensor<Scalar>)

• ArrayLiteralElement
  Declaração

  public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

• iniciar(arrayLiteral:)
  Declaração

  public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)

Disponível onde `Scalar`: `Equatable`

• ==(_:_:)
  Declaração

  public static func == (lhs: ShapedArraySlice, rhs: ShapedArraySlice) -> Bool

Disponível onde `Scalar`: `Hashable`

• hash(em:)
  Declaração

  public func hash(into hasher: inout Hasher)

Disponível onde `Scalar`: `Codable`

• codificar (para:)
  Declaração

  public func encode(to encoder: Encoder) throws

• iniciar(de:)
  Declaração

  public init(from decoder: Decoder) throws