tensor

Jul 12, 2026

Changes in this version

+ type LazyBackend interface — js/wasm

+ DeferReleaseGPUBuffer func(bufferPtr unsafe.Pointer)

+ ReadGPUBuffer func(bufferPtr unsafe.Pointer, size uint64) ([]byte, error)

+ RegisterLiveGPU func(l *LazyGPUData)

+ ReleaseGPUBuffer func(bufferPtr unsafe.Pointer)

+ UnregisterLiveGPU func(l *LazyGPUData)

+ type LazyGPUData struct — js/wasm

+ func NewLazyGPUData(_ unsafe.Pointer, _ any, _ uint64, _ LazyBackend) *LazyGPUData

+ func (l *LazyGPUData) AddRef()

+ func (l *LazyGPUData) BufferPtr() unsafe.Pointer

+ func (l *LazyGPUData) IsPersistent() bool

+ func (l *LazyGPUData) IsRealized() bool

+ func (l *LazyGPUData) MarkRealized()

+ func (l *LazyGPUData) Realize() ([]byte, error)

+ func (l *LazyGPUData) RefCount() int32

+ func (l *LazyGPUData) Release()

+ func (l *LazyGPUData) ScheduleRelease()

+ func (l *LazyGPUData) SetPersistent(persistent bool)

+ func (l *LazyGPUData) Size() uint64

type RawTensor — js/wasm

+ func Cast(x *RawTensor, dtype DataType) (*RawTensor, error)

+ func Clip(x *RawTensor, minVal, maxVal float32) (*RawTensor, error)

+ func Concat(tensors []*RawTensor, axis int) (*RawTensor, error)

+ func Expand(x *RawTensor, targetShape Shape) (*RawTensor, error)

+ func Flatten(x *RawTensor, axis int) (*RawTensor, error)

+ func FullRaw(shape Shape, value float32, dtype DataType, device Device) (*RawTensor, error)

+ func GELU(x *RawTensor) (*RawTensor, error)

+ func Gather(x, indices *RawTensor, axis int) (*RawTensor, error)

+ func LeakyReLU(x *RawTensor, alpha float32) (*RawTensor, error)

+ func LogSoftmax(x *RawTensor, axis int) (*RawTensor, error)

+ func NewLazyRaw(shape Shape, dtype DataType, device Device, _ *LazyGPUData) (*RawTensor, error)

+ func PReLU(x, slope *RawTensor) (*RawTensor, error)

+ func ReLU(x *RawTensor) (*RawTensor, error)

+ func Reshape(x *RawTensor, newShape Shape) (*RawTensor, error)

+ func SiLU(x *RawTensor) (*RawTensor, error)

+ func Sigmoid(x *RawTensor) (*RawTensor, error)

+ func Slice(x *RawTensor, starts, ends, axes, steps []int64) (*RawTensor, error)

+ func Softmax(x *RawTensor, axis int) (*RawTensor, error)

+ func Split(x *RawTensor, axis int, splitSizes []int) ([]*RawTensor, error)

+ func Squeeze(x *RawTensor, axes ...int) (*RawTensor, error)

+ func Tanh(x *RawTensor) (*RawTensor, error)

+ func TransposeAxes(x *RawTensor, axes ...int) (*RawTensor, error)

+ func Unsqueeze(x *RawTensor, axes ...int) (*RawTensor, error)

+ func WhereRaw(condition, x, y *RawTensor) (*RawTensor, error)

May 27, 2026

Changes in this version

type Backend

+ ReLU func(x *RawTensor) *RawTensor

+ SiLU func(x *RawTensor) *RawTensor

+ Sigmoid func(x *RawTensor) *RawTensor

+ Tanh func(x *RawTensor) *RawTensor

type LazyBackend — darwin/amd64, linux/amd64, windows/amd64

+ DeferReleaseGPUBuffer func(bufferPtr unsafe.Pointer)

+ RegisterLiveGPU func(l *LazyGPUData)

+ UnregisterLiveGPU func(l *LazyGPUData)

type LazyGPUData — darwin/amd64, linux/amd64, windows/amd64

+ func (l *LazyGPUData) AddRef()

+ func (l *LazyGPUData) IsPersistent() bool

+ func (l *LazyGPUData) RefCount() int32

+ func (l *LazyGPUData) ScheduleRelease()

+ func (l *LazyGPUData) SetPersistent(persistent bool)

+ type MemoryReclaimer interface

+ ReclaimMemory func()

type MockBackend

+ func (m *MockBackend) ReLU(x *RawTensor) *RawTensor

+ func (m *MockBackend) SiLU(x *RawTensor) *RawTensor

+ func (m *MockBackend) Sigmoid(x *RawTensor) *RawTensor

+ func (m *MockBackend) Tanh(x *RawTensor) *RawTensor

type RawTensor

+ func (r *RawTensor) ReleaseGPU()

+ func (r *RawTensor) SetGPUPersistent(persistent bool)

type Tensor

+ func (t *Tensor[T, B]) Persist() *Tensor[T, B]

+ func (t *Tensor[T, B]) Unpersist() *Tensor[T, B]

May 16, 2026

Changes in this version

type Backend

+ ScatterAdd func(dest *RawTensor, dim int, indices *RawTensor, src *RawTensor) *RawTensor

+ SelectAdd func(dest *RawTensor, dim int, indices *RawTensor, src *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) ScatterAdd(dest *RawTensor, dim int, indices, src *RawTensor) *RawTensor

+ func (m *MockBackend) SelectAdd(dest *RawTensor, dim int, indices, src *RawTensor) *RawTensor

May 15, 2026

Changes in this version

+ func CheckScalarDType[T DType](val any) T

+ func RandFloat64() float64

+ func ResetSeed()

+ func SetSeed(seed int64)

type Backend

+ Clamp func(x *RawTensor, minBound, maxBound any) *RawTensor

type MockBackend

+ func (m *MockBackend) Clamp(x *RawTensor, minBound, maxBound any) *RawTensor

Apr 26, 2026

Changes in this version

type Backend

+ Abs func(x *RawTensor) *RawTensor

+ Sign func(x *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) Abs(x *RawTensor) *RawTensor

+ func (m *MockBackend) Sign(x *RawTensor) *RawTensor

type Tensor

+ func (t *Tensor[T, B]) Abs() *Tensor[T, B]

+ func (t *Tensor[T, B]) Sign() *Tensor[T, B]

Apr 10, 2026

Changes in this version

+ type ConvDims struct

+ CIn int

+ COut int

+ H int

+ HOut int

+ KH int

+ KW int

+ N int

+ Padding int

+ Stride int

+ W int

+ WOut int

+ type PoolDims struct

+ C int

+ H int

+ HOut int

+ KH int

+ KW int

+ N int

+ Padding int

+ Stride int

+ W int

+ WOut int

type Shape

+ func BroadcastShapesMatMul(a, b Shape) (Shape, bool, error)

Apr 7, 2026

Changes in this version

type Backend

+ Erf func(x *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) Erf(x *RawTensor) *RawTensor

type Tensor

+ func (t *Tensor[T, B]) Erf() *Tensor[T, B]

Dec 16, 2025

Changes in this version

type Backend

+ Conv2DInputBackward func(input, kernel, grad *RawTensor, stride, padding int) *RawTensor

+ Conv2DKernelBackward func(input, kernel, grad *RawTensor, stride, padding int) *RawTensor

+ MaxPool2DBackward func(input, grad *RawTensor, maxIndices []int, kernelSize, stride int) *RawTensor

type MockBackend

+ func (m *MockBackend) Conv2DInputBackward(_, _, _ *RawTensor, _, _ int) *RawTensor

+ func (m *MockBackend) Conv2DKernelBackward(_, _, _ *RawTensor, _, _ int) *RawTensor

+ func (m *MockBackend) MaxPool2DBackward(_, _ *RawTensor, _ []int, _, _ int) *RawTensor

Dec 3, 2025

Changes in this version

+ type LazyBackend interface — darwin/amd64, linux/amd64, windows/amd64

+ ReadGPUBuffer func(bufferPtr unsafe.Pointer, size uint64) ([]byte, error)

+ ReleaseGPUBuffer func(bufferPtr unsafe.Pointer)

+ type LazyGPUData struct — darwin/amd64, linux/amd64, windows/amd64

+ func NewLazyGPUData(bufferPtr unsafe.Pointer, size uint64, backend LazyBackend) *LazyGPUData

+ func (l *LazyGPUData) BufferPtr() unsafe.Pointer

+ func (l *LazyGPUData) IsRealized() bool

+ func (l *LazyGPUData) MarkRealized()

+ func (l *LazyGPUData) Realize() ([]byte, error)

+ func (l *LazyGPUData) Release()

+ func (l *LazyGPUData) Size() uint64

type RawTensor — darwin/amd64, linux/amd64, windows/amd64

+ func Cast(x *RawTensor, dtype DataType) (*RawTensor, error)

+ func Clip(x *RawTensor, minVal, maxVal float32) (*RawTensor, error)

+ func Concat(tensors []*RawTensor, axis int) (*RawTensor, error)

+ func Expand(x *RawTensor, targetShape Shape) (*RawTensor, error)

+ func Flatten(x *RawTensor, axis int) (*RawTensor, error)

+ func FullRaw(shape Shape, value float32, dtype DataType, device Device) (*RawTensor, error)

+ func GELU(x *RawTensor) (*RawTensor, error)

+ func Gather(x, indices *RawTensor, axis int) (*RawTensor, error)

+ func LeakyReLU(x *RawTensor, alpha float32) (*RawTensor, error)

+ func LogSoftmax(x *RawTensor, axis int) (*RawTensor, error)

+ func NewLazyRaw(shape Shape, dtype DataType, device Device, gpuData *LazyGPUData) (*RawTensor, error)

+ func PReLU(x, slope *RawTensor) (*RawTensor, error)

+ func ReLU(x *RawTensor) (*RawTensor, error)

+ func Reshape(x *RawTensor, newShape Shape) (*RawTensor, error)

+ func SiLU(x *RawTensor) (*RawTensor, error)

+ func Sigmoid(x *RawTensor) (*RawTensor, error)

+ func Slice(x *RawTensor, starts, ends, axes, steps []int64) (*RawTensor, error)

+ func Softmax(x *RawTensor, axis int) (*RawTensor, error)

+ func Split(x *RawTensor, axis int, splitSizes []int) ([]*RawTensor, error)

+ func Squeeze(x *RawTensor, axes ...int) (*RawTensor, error)

+ func Tanh(x *RawTensor) (*RawTensor, error)

+ func TransposeAxes(x *RawTensor, axes ...int) (*RawTensor, error)

+ func Unsqueeze(x *RawTensor, axes ...int) (*RawTensor, error)

+ func WhereRaw(condition, x, y *RawTensor) (*RawTensor, error)

+ func (r *RawTensor) GPUData() *LazyGPUData

+ func (r *RawTensor) IsLazy() bool

+ func (r *RawTensor) SetGPUData(gpuData *LazyGPUData)

Dec 1, 2025

Changes in this version

type Backend

+ Embedding func(weight, indices *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) Embedding(weight, indices *RawTensor) *RawTensor

type Tensor

+ func (t *Tensor[T, B]) Embedding(indices *Tensor[int32, B]) *Tensor[T, B]

Dec 1, 2025

Changes in this version

type Backend

+ BatchMatMul func(a, b *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) BatchMatMul(a, b *RawTensor) *RawTensor

type Tensor

+ func (t *Tensor[T, B]) BatchMatMul(other *Tensor[T, B]) *Tensor[T, B]

Nov 30, 2025

Changes in this version

type Backend

+ AddScalar func(x *RawTensor, scalar any) *RawTensor

+ And func(a, b *RawTensor) *RawTensor

+ Argmax func(x *RawTensor, dim int) *RawTensor

+ Cast func(x *RawTensor, dtype DataType) *RawTensor

+ Cat func(tensors []*RawTensor, dim int) *RawTensor

+ Chunk func(x *RawTensor, n, dim int) []*RawTensor

+ Cos func(x *RawTensor) *RawTensor

+ DivScalar func(x *RawTensor, scalar any) *RawTensor

+ Equal func(a, b *RawTensor) *RawTensor

+ Exp func(x *RawTensor) *RawTensor

+ Expand func(x *RawTensor, shape Shape) *RawTensor

+ Gather func(x *RawTensor, dim int, index *RawTensor) *RawTensor

+ Greater func(a, b *RawTensor) *RawTensor

+ GreaterEqual func(a, b *RawTensor) *RawTensor

+ Log func(x *RawTensor) *RawTensor

+ Lower func(a, b *RawTensor) *RawTensor

+ LowerEqual func(a, b *RawTensor) *RawTensor

+ MeanDim func(x *RawTensor, dim int, keepDim bool) *RawTensor

+ MulScalar func(x *RawTensor, scalar any) *RawTensor

+ Not func(x *RawTensor) *RawTensor

+ NotEqual func(a, b *RawTensor) *RawTensor

+ Or func(a, b *RawTensor) *RawTensor

+ Rsqrt func(x *RawTensor) *RawTensor

+ Sin func(x *RawTensor) *RawTensor

+ Softmax func(x *RawTensor, dim int) *RawTensor

+ Sqrt func(x *RawTensor) *RawTensor

+ Squeeze func(x *RawTensor, dim int) *RawTensor

+ SubScalar func(x *RawTensor, scalar any) *RawTensor

+ Sum func(x *RawTensor) *RawTensor

+ SumDim func(x *RawTensor, dim int, keepDim bool) *RawTensor

+ Unsqueeze func(x *RawTensor, dim int) *RawTensor

+ Where func(condition, x, y *RawTensor) *RawTensor

type MockBackend

+ func (m *MockBackend) AddScalar(x *RawTensor, scalar any) *RawTensor

+ func (m *MockBackend) And(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Argmax(_ *RawTensor, _ int) *RawTensor

+ func (m *MockBackend) Cast(x *RawTensor, dtype DataType) *RawTensor

+ func (m *MockBackend) Cat(tensors []*RawTensor, dim int) *RawTensor

+ func (m *MockBackend) Chunk(x *RawTensor, n, dim int) []*RawTensor

+ func (m *MockBackend) Cos(x *RawTensor) *RawTensor

+ func (m *MockBackend) DivScalar(x *RawTensor, scalar any) *RawTensor

+ func (m *MockBackend) Equal(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Exp(x *RawTensor) *RawTensor

+ func (m *MockBackend) Expand(_ *RawTensor, _ Shape) *RawTensor

+ func (m *MockBackend) Gather(x *RawTensor, dim int, index *RawTensor) *RawTensor

+ func (m *MockBackend) Greater(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) GreaterEqual(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Log(x *RawTensor) *RawTensor

+ func (m *MockBackend) Lower(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) LowerEqual(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) MeanDim(x *RawTensor, dim int, keepDim bool) *RawTensor

+ func (m *MockBackend) MulScalar(x *RawTensor, scalar any) *RawTensor

+ func (m *MockBackend) Not(x *RawTensor) *RawTensor

+ func (m *MockBackend) NotEqual(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Or(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Rsqrt(x *RawTensor) *RawTensor

+ func (m *MockBackend) Sin(x *RawTensor) *RawTensor

+ func (m *MockBackend) Softmax(_ *RawTensor, _ int) *RawTensor

+ func (m *MockBackend) Sqrt(x *RawTensor) *RawTensor

+ func (m *MockBackend) Squeeze(x *RawTensor, dim int) *RawTensor

+ func (m *MockBackend) SubScalar(x *RawTensor, scalar any) *RawTensor

+ func (m *MockBackend) Sum(x *RawTensor) *RawTensor

+ func (m *MockBackend) SumDim(x *RawTensor, dim int, keepDim bool) *RawTensor

+ func (m *MockBackend) Unsqueeze(x *RawTensor, dim int) *RawTensor

+ func (m *MockBackend) Where(condition, x, y *RawTensor) *RawTensor

type Tensor

+ func Cat[T DType, B Backend](tensors []*Tensor[T, B], dim int) *Tensor[T, B]

+ func Where[T DType, B Backend](cond *Tensor[bool, B], x, y *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) AddScalar(scalar T) *Tensor[T, B]

+ func (t *Tensor[T, B]) Argmax(dim int) *Tensor[int32, B]

+ func (t *Tensor[T, B]) Chunk(n, dim int) []*Tensor[T, B]

+ func (t *Tensor[T, B]) Cos() *Tensor[T, B]

+ func (t *Tensor[T, B]) Detach() *Tensor[T, B]

+ func (t *Tensor[T, B]) DivScalar(scalar T) *Tensor[T, B]

+ func (t *Tensor[T, B]) Eq(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Equal(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Exp() *Tensor[T, B]

+ func (t *Tensor[T, B]) Expand(shape Shape) *Tensor[T, B]

+ func (t *Tensor[T, B]) Float32() *Tensor[float32, B]

+ func (t *Tensor[T, B]) Float64() *Tensor[float64, B]

+ func (t *Tensor[T, B]) Gather(dim int, index *Tensor[int32, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) Ge(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Greater(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) GreaterEqual(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Gt(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Int32() *Tensor[int32, B]

+ func (t *Tensor[T, B]) Int64() *Tensor[int64, B]

+ func (t *Tensor[T, B]) Le(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Log() *Tensor[T, B]

+ func (t *Tensor[T, B]) Lower(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) LowerEqual(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Lt(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) MeanDim(dim int, keepDim bool) *Tensor[T, B]

+ func (t *Tensor[T, B]) MulScalar(scalar T) *Tensor[T, B]

+ func (t *Tensor[T, B]) Ne(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) NotEqual(other *Tensor[T, B]) *Tensor[bool, B]

+ func (t *Tensor[T, B]) Rsqrt() *Tensor[T, B]

+ func (t *Tensor[T, B]) Sin() *Tensor[T, B]

+ func (t *Tensor[T, B]) Softmax(dim int) *Tensor[T, B]

+ func (t *Tensor[T, B]) Sqrt() *Tensor[T, B]

+ func (t *Tensor[T, B]) Squeeze(dim int) *Tensor[T, B]

+ func (t *Tensor[T, B]) SubScalar(scalar T) *Tensor[T, B]

+ func (t *Tensor[T, B]) Sum() *Tensor[T, B]

+ func (t *Tensor[T, B]) SumDim(dim int, keepDim bool) *Tensor[T, B]

+ func (t *Tensor[T, B]) Unsqueeze(dim int) *Tensor[T, B]

+ func (t *Tensor[bool, B]) And(other *Tensor[bool, B]) *Tensor[bool, B]

+ func (t *Tensor[bool, B]) Not() *Tensor[bool, B]

+ func (t *Tensor[bool, B]) Or(other *Tensor[bool, B]) *Tensor[bool, B]

Nov 17, 2025

Changes in this version

+ type Backend interface

+ Add func(a, b *RawTensor) *RawTensor

+ Conv2D func(input, kernel *RawTensor, stride, padding int) *RawTensor

+ Device func() Device

+ Div func(a, b *RawTensor) *RawTensor

+ MatMul func(a, b *RawTensor) *RawTensor

+ MaxPool2D func(input *RawTensor, kernelSize, stride int) *RawTensor

+ Mul func(a, b *RawTensor) *RawTensor

+ Name func() string

+ Reshape func(t *RawTensor, newShape Shape) *RawTensor

+ Sub func(a, b *RawTensor) *RawTensor

+ Transpose func(t *RawTensor, axes ...int) *RawTensor

+ type DType interface

+ type DataType int

+ const Bool

+ const Float32

+ const Float64

+ const Int32

+ const Int64

+ const Uint8

+ func (dt DataType) Size() int

+ func (dt DataType) String() string

+ type Device int

+ const CPU

+ const CUDA

+ const Metal

+ const Vulkan

+ const WebGPU

+ func (d Device) String() string

+ type MockBackend struct

+ func NewMockBackend() *MockBackend

+ func (m *MockBackend) Add(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Conv2D(input, kernel *RawTensor, stride, padding int) *RawTensor

+ func (m *MockBackend) Device() Device

+ func (m *MockBackend) Div(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) MatMul(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) MaxPool2D(input *RawTensor, kernelSize, stride int) *RawTensor

+ func (m *MockBackend) Mul(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Name() string

+ func (m *MockBackend) Reshape(t *RawTensor, newShape Shape) *RawTensor

+ func (m *MockBackend) Sub(a, b *RawTensor) *RawTensor

+ func (m *MockBackend) Transpose(t *RawTensor, axes ...int) *RawTensor

+ type RawTensor struct

+ func NewRaw(shape Shape, dtype DataType, device Device) (*RawTensor, error)

+ func (r *RawTensor) AsBool() []bool

+ func (r *RawTensor) AsFloat32() []float32

+ func (r *RawTensor) AsFloat64() []float64

+ func (r *RawTensor) AsInt32() []int32

+ func (r *RawTensor) AsInt64() []int64

+ func (r *RawTensor) AsUint8() []uint8

+ func (r *RawTensor) ByteSize() int

+ func (r *RawTensor) Clone() *RawTensor

+ func (r *RawTensor) DType() DataType

+ func (r *RawTensor) Data() []byte

+ func (r *RawTensor) Device() Device

+ func (r *RawTensor) ForceNonUnique() func()

+ func (r *RawTensor) IsUnique() bool

+ func (r *RawTensor) NumElements() int

+ func (r *RawTensor) Release()

+ func (r *RawTensor) Shape() Shape

+ func (r *RawTensor) Strides() []int

+ type Shape []int

+ func BroadcastShapes(a, b Shape) (Shape, bool, error)

+ func (s Shape) Clone() Shape

+ func (s Shape) ComputeStrides() []int

+ func (s Shape) Equal(other Shape) bool

+ func (s Shape) NumElements() int

+ func (s Shape) Validate() error

+ type Tensor struct

+ func Arange[T DType, B Backend](start, end T, b B) *Tensor[T, B]

+ func Eye[T DType, B Backend](n int, b B) *Tensor[T, B]

+ func FromSlice[T DType, B Backend](data []T, shape Shape, b B) (*Tensor[T, B], error)

+ func Full[T DType, B Backend](shape Shape, value T, b B) *Tensor[T, B]

+ func New[T DType, B Backend](raw *RawTensor, b B) *Tensor[T, B]

+ func Ones[T DType, B Backend](shape Shape, b B) *Tensor[T, B]

+ func Rand[T DType, B Backend](shape Shape, b B) *Tensor[T, B]

+ func Randn[T DType, B Backend](shape Shape, b B) *Tensor[T, B]

+ func Zeros[T DType, B Backend](shape Shape, b B) *Tensor[T, B]

+ func (t *Tensor[T, B]) Add(other *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) At(indices ...int) T

+ func (t *Tensor[T, B]) Backend() B

+ func (t *Tensor[T, B]) Clone() *Tensor[T, B]

+ func (t *Tensor[T, B]) DType() DataType

+ func (t *Tensor[T, B]) Data() []T

+ func (t *Tensor[T, B]) Device() Device

+ func (t *Tensor[T, B]) Div(other *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) Grad() *Tensor[T, B]

+ func (t *Tensor[T, B]) Item() T

+ func (t *Tensor[T, B]) MatMul(other *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) Mul(other *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) NumElements() int

+ func (t *Tensor[T, B]) Raw() *RawTensor

+ func (t *Tensor[T, B]) RequireGrad() *Tensor[T, B]

+ func (t *Tensor[T, B]) RequiresGrad() bool

+ func (t *Tensor[T, B]) Reshape(newShape ...int) *Tensor[T, B]

+ func (t *Tensor[T, B]) Set(value T, indices ...int)

+ func (t *Tensor[T, B]) SetGrad(grad *Tensor[T, B])

+ func (t *Tensor[T, B]) Shape() Shape

+ func (t *Tensor[T, B]) String() string

+ func (t *Tensor[T, B]) Sub(other *Tensor[T, B]) *Tensor[T, B]

+ func (t *Tensor[T, B]) T() *Tensor[T, B]

+ func (t *Tensor[T, B]) Transpose(axes ...int) *Tensor[T, B]