`Batched.BatchedArray`

— Type`BatchedArray{T, NI, N, AT} <: AbstractBatchedArray{T, NI, N}`

A concrete type for batched arrays. `T`

is the element type, `NI`

is the inner sample's dimension, `N`

is the total dimension and `AT`

is the array type that actually holds the value.

`Batched.BatchedUniformScaling`

— Type`BatchedUniformScaling{T, N, ST <: AbstractArray{T, N}} <: AbstractBatchedArray{T, 0, N}`

Scale a batch of arrays with a batch of scalars.

`BatchedUniformScaling(scalars)`

The shape of batch can be multidimentional, which means member `BatchedScale.scalars`

can be a matrix or high dimentional array, the shape of this member is the shape of batch. `dims`

defines the dimmension of each sample in the batch. It can be multidimentional as well.

`Batched.batch_size`

— Function`batch_size(batched_array) -> Tuple`

Returns a tuple of size of each batch dimension of the batched array.

`Batched.inner_size`

— Function`inner_size(batched_array) -> Tuple`

Returns a tuple of size of each inner dimension of the batched array.

`Batched.merged_size`

— Function`merged_size(batched_array) -> Tuple`

Returns the size of this batched array after merging all its batched dimension together.

`Batched.AbstractBatchedArray`

— Type`AbstractBatchedArray{T, NI, N}`

Abstract type batched array. A batched array use its last `N - NI`

dimension as batch dimension, it is a batch of array with dimension `NI`

.

`Batched.AbstractBatchedMatrix`

— Type`AbstractBatchedMatrix{T, N}`

Batched matrix.

`Batched.AbstractBatchedScalar`

— Type`AbstractBatchedScalar{T, N}`

Batched scalars.

`Batched.AbstractBatchedVector`

— Type`AbstractBatchedVector{T, N}`

Batched vector.

`Batched.BatchedAdjoint`

— Type`BatchedAdjoint{T, N, S <: AbstractBatchedMatrix} <: AbstractBatchedMatrix{T, N}`

Batched ajoint. Transpose a batch of matrix.

`Batched.BatchedTranspose`

— Type`BatchedTranspose{T, N, S} <: AbstractBatchedMatrix{T, N}`

Batched transpose. Transpose a batch of matrix.

`Batched.batched_gemm`

— Function```
batched_gemm(A, B)
batched_gemm(tA, tB, A, B)
batched_gemm(tA, tB, alpha, A, B)
```

Batched version of `BLAS.gemm`

.

`Batched.batched_gemm!`

— Function`batched_gemm!(transA, transB, alpha, A, B, beta, C)`

Batched version of `BLAS.gemm!`

.

`Batched.batched_tr!`

— Method`batched_tr!(B::AbstractVector{T}, A::AbstractArray{T, 3})`

Perform batched matrix trace.