Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

tensor

package module

Go to main page

Versions in this module

v0

v0.9.24

Jul 14, 2022

Changes in this version

+ const AllAxes

+ const DEBUG

+ const PoolSize

+ var Bool = Dtype

+ var Byte = Uint8

+ var Complex128 = Dtype

+ var Complex64 = Dtype

+ var Float32 = Dtype

+ var Float64 = Dtype

+ var Int = Dtype

+ var Int16 = Dtype

+ var Int32 = Dtype

+ var Int64 = Dtype

+ var Int8 = Dtype

+ var String = Dtype

+ var TABCOUNT uint32 = 0

+ var Uint = Dtype

+ var Uint16 = Dtype

+ var Uint32 = Dtype

+ var Uint64 = Dtype

+ var Uint8 = Dtype

+ var Uintptr = Dtype

+ var UnsafePointer = Dtype

+ func BorrowBools(size int) []bool

+ func BorrowInts(size int) []int

+ func BroadcastStrides(destShape, srcShape Shape, destStrides, srcStrides []int) (retVal []int, err error)

+ func CheckSlice(s Slice, size int) error

+ func Copy(dst, src Tensor) error

+ func DontUsePool()

+ func Inner(a, b Tensor) (retVal interface{}, err error)

+ func IsMonotonicInts(a []int) (monotonic bool, incr1 bool)

+ func Itol(i int, shape Shape, strides []int) (coords []int, err error)

+ func Ltoi(shape Shape, strides []int, coords ...int) (at int, err error)

+ func MaskedReduce(t *Dense, retType Dtype, fn maskedReduceFn, axis ...int) interface

+ func MaxInt(a, b int) int

+ func MaxInts(is ...int) (retVal int)

+ func MinInt(a, b int) int

+ func ProdInts(a []int) (retVal int)

+ func Random(dt Dtype, size int) interface

+ func Range(dt Dtype, start, end int) interface

+ func Register(a Dtype)

+ func RegisterEq(a Dtype)

+ func RegisterFloat(a Dtype)

+ func RegisterNumber(a Dtype)

+ func RegisterOrd(a Dtype)

+ func ReturnBools(is []bool)

+ func ReturnInts(is []int)

+ func ReturnTensor(t Tensor)

+ func SampleIndex(in interface{}) int

+ func SliceDetails(s Slice, size int) (start, end, step int, err error)

+ func SortIndex(in interface{}) (out []int)

+ func SumInts(a []int) (retVal int)

+ func ToMat64(t *Dense, opts ...FuncOpt) (retVal *mat.Dense, err error)

+ func TransposeIndex(i int, oldShape, pattern, oldStrides, newStrides []int) int

+ func UnsafePermute(pattern []int, xs ...[]int) (err error)

+ func UntransposeIndex(i int, oldShape, pattern, oldStrides, newStrides []int) int

+ func Use(b BLAS)

+ func UsePool()

+ type AP struct

+ Δ Triangle

+ func MakeAP(shape Shape, strides []int, o DataOrder, Δ Triangle) AP

+ func (ap *AP) C() bool

+ func (ap *AP) Clone() (retVal AP)

+ func (ap *AP) CloneTo(dest *AP)

+ func (ap *AP) DataOrder() DataOrder

+ func (ap *AP) Dims() int

+ func (ap *AP) F() bool

+ func (ap *AP) Format(state fmt.State, c rune)

+ func (ap *AP) Init(shape Shape, strides []int)

+ func (ap *AP) IsColVec() bool

+ func (ap *AP) IsMatrix() bool

+ func (ap *AP) IsRowVec() bool

+ func (ap *AP) IsScalar() bool

+ func (ap *AP) IsScalarEquiv() bool

+ func (ap *AP) IsVector() bool

+ func (ap *AP) IsVectorLike() bool

+ func (ap *AP) IsZero() bool

+ func (ap *AP) S(size int, slices ...Slice) (newAP AP, ndStart, ndEnd int, err error)

+ func (ap *AP) SetShape(s ...int)

+ func (ap *AP) Shape() Shape

+ func (ap *AP) Size() int

+ func (ap *AP) Strides() []int

+ func (ap *AP) String() string

+ func (ap *AP) T(axes ...int) (retVal AP, a []int, err error)

+ type Abser interface

+ Abs func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Adder interface

+ Add func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ AddScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Argmaxer interface

+ Argmax func(t Tensor, axis int) (Tensor, error)

+ type Argminer interface

+ Argmin func(t Tensor, axis int) (Tensor, error)

+ type BLAS interface

+ func WhichBLAS() BLAS

+ type BitMap struct

+ func NewBitMap(size int) *BitMap

+ func (bm *BitMap) Clear(i int)

+ func (bm *BitMap) IsSet(i int) bool

+ func (bm *BitMap) Set(i int)

+ type Boolable interface

+ type ByIndiceser interface

+ SelectByIndices func(a, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ SelectByIndicesB func(input, outGrad, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ type CS struct

+ func CSCFromCoord(shape Shape, xs, ys []int, data interface{}) *CS

+ func CSRFromCoord(shape Shape, xs, ys []int, data interface{}) *CS

+ func NewCSC(indices, indptr []int, data interface{}, opts ...ConsOpt) *CS

+ func NewCSR(indices, indptr []int, data interface{}, opts ...ConsOpt) *CS

+ func (a *CS) Cap() int

+ func (a *CS) Get(i int) interface{}

+ func (a *CS) Len() int

+ func (a *CS) Memset(x interface{}) error

+ func (a *CS) Set(i int, x interface{})

+ func (a CS) Data() interface{}

+ func (a CS) Zero()

+ func (t *CS) Apply(fn interface{}, opts ...FuncOpt) (Tensor, error)

+ func (t *CS) AsCSC()

+ func (t *CS) AsCSR()

+ func (t *CS) At(coord ...int) (interface{}, error)

+ func (t *CS) Clone() interface{}

+ func (t *CS) DataOrder() DataOrder

+ func (t *CS) DataSize() int

+ func (t *CS) Dense() *Dense

+ func (t *CS) Dims() int

+ func (t *CS) Dtype() Dtype

+ func (t *CS) Engine() Engine

+ func (t *CS) Eq(other interface{}) bool

+ func (t *CS) Format(s fmt.State, c rune)

+ func (t *CS) GobDecode(p []byte) (err error)

+ func (t *CS) GobEncode() (p []byte, err error)

+ func (t *CS) Indices() []int

+ func (t *CS) Indptr() []int

+ func (t *CS) IsManuallyManaged() bool

+ func (t *CS) IsNativelyAccessible() bool

+ func (t *CS) IsScalar() bool

+ func (t *CS) Iterator() Iterator

+ func (t *CS) MemSize() uintptr

+ func (t *CS) NonZeroes() int

+ func (t *CS) ReadNpy(r io.Reader) error

+ func (t *CS) RequiresIterator() bool

+ func (t *CS) Reshape(...int) error

+ func (t *CS) ScalarValue() interface{}

+ func (t *CS) SetAt(v interface{}, coord ...int) error

+ func (t *CS) Shape() Shape

+ func (t *CS) Size() int

+ func (t *CS) Slice(...Slice) (View, error)

+ func (t *CS) Strides() []int

+ func (t *CS) String() string

+ func (t *CS) T(axes ...int) error

+ func (t *CS) Transpose() error

+ func (t *CS) UT()

+ func (t *CS) Uintptr() uintptr

+ func (t *CS) WriteNpy(w io.Writer) error

+ type Cbrter interface

+ Cbrt func(a Tensor, opt ...FuncOpt) (Tensor, error)

+ type Clamper interface

+ Clamp func(a Tensor, min, max interface{}, opts ...FuncOpt) (Tensor, error)

+ type Cloner interface

+ Clone func() interface{}

+ type Concater interface

+ Concat func(t Tensor, axis int, others ...Tensor) (Tensor, error)

+ type ConsOpt func(Tensor)

+ func AsDenseDiag(backing interface{}) ConsOpt

+ func AsFortran(backing interface{}, argMask ...[]bool) ConsOpt

+ func FromMemory(ptr uintptr, memsize uintptr) ConsOpt

+ func FromScalar(x interface{}, argMask ...[]bool) ConsOpt

+ func Of(a Dtype) ConsOpt

+ func WithBacking(x interface{}, argMask ...[]bool) ConsOpt

+ func WithEngine(e Engine) ConsOpt

+ func WithMask(x interface{}) ConsOpt

+ func WithShape(dims ...int) ConsOpt

+ type Cuber interface

+ Cube func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type DataOrder byte

+ const ColMajor

+ const NonContiguous

+ const Transposed

+ func MakeDataOrder(fs ...DataOrder) (retVal DataOrder)

+ func (f DataOrder) HasSameOrder(other DataOrder) bool

+ func (f DataOrder) IsColMajor() bool

+ func (f DataOrder) IsContiguous() bool

+ func (f DataOrder) IsNotContiguous() bool

+ func (f DataOrder) IsRowMajor() bool

+ func (f DataOrder) IsTransposed() bool

+ func (f DataOrder) String() string

+ type Dataer interface

+ Data func() interface{}

+ type Dense struct

+ func FromArrowArray(a arrowArray.Interface) *Dense

+ func FromArrowTensor(a arrowTensor.Interface) *Dense

+ func FromMat64(m *mat.Dense, opts ...FuncOpt) *Dense

+ func I(dt Dtype, r, c, k int) *Dense

+ func New(opts ...ConsOpt) *Dense

+ func NewDense(dt Dtype, shape Shape, opts ...ConsOpt) *Dense

+ func Ones(dt Dtype, shape ...int) *Dense

+ func (a *Dense) Cap() int

+ func (a *Dense) Get(i int) interface{}

+ func (a *Dense) Len() int

+ func (a *Dense) MemSize() uintptr

+ func (a *Dense) Set(i int, x interface{})

+ func (a *Dense) Uintptr() uintptr

+ func (t *Dense) Add(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) AddScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Apply(fn interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func (t *Dense) Argmax(axis int) (retVal *Dense, err error)

+ func (t *Dense) Argmin(axis int) (retVal *Dense, err error)

+ func (t *Dense) At(coords ...int) (interface{}, error)

+ func (t *Dense) Clone() interface{}

+ func (t *Dense) ClumpMasked() []Slice

+ func (t *Dense) ClumpUnmasked() []Slice

+ func (t *Dense) Concat(axis int, Ts ...*Dense) (retVal *Dense, err error)

+ func (t *Dense) CopyTo(other *Dense) error

+ func (t *Dense) Data() interface{}

+ func (t *Dense) DataSize() int

+ func (t *Dense) Div(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) DivScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Dtype() Dtype

+ func (t *Dense) ElEq(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) ElEqScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) ElNe(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) ElNeScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Engine() Engine

+ func (t *Dense) Eq(other interface{}) bool

+ func (t *Dense) FBDecode(buf []byte) error

+ func (t *Dense) FBEncode() ([]byte, error)

+ func (t *Dense) FillValue() interface{}

+ func (t *Dense) Filled(val ...interface{}) (interface{}, error)

+ func (t *Dense) FilledInplace(val ...interface{}) (interface{}, error)

+ func (t *Dense) FlatMaskedContiguous() []Slice

+ func (t *Dense) FlatMaskedEdges() (int, int)

+ func (t *Dense) FlatNotMaskedContiguous() []Slice

+ func (t *Dense) FlatNotMaskedEdges() (int, int)

+ func (t *Dense) Format(s fmt.State, c rune)

+ func (t *Dense) GobDecode(p []byte) (err error)

+ func (t *Dense) GobEncode() (p []byte, err error)

+ func (t *Dense) Gt(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) GtScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Gte(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) GteScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) HardenMask() bool

+ func (t *Dense) Hstack(others ...*Dense) (*Dense, error)

+ func (t *Dense) Info() *AP

+ func (t *Dense) Inner(other Tensor) (retVal interface{}, err error)

+ func (t *Dense) IsManuallyManaged() bool

+ func (t *Dense) IsMasked() bool

+ func (t *Dense) IsMaterializable() bool

+ func (t *Dense) IsNativelyAccessible() bool

+ func (t *Dense) IsView() bool

+ func (t *Dense) Iterator() Iterator

+ func (t *Dense) Lt(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) LtScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Lte(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) LteScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Mask() []bool

+ func (t *Dense) MaskAt(coords ...int) (bool, error)

+ func (t *Dense) MaskFromDense(tts ...*Dense)

+ func (t *Dense) MaskFromSlice(x interface{})

+ func (t *Dense) MaskedAll(axis ...int) interface{}

+ func (t *Dense) MaskedAny(axis ...int) interface{}

+ func (t *Dense) MaskedCount(axis ...int) interface{}

+ func (t *Dense) MaskedEqual(val1 interface{}) (err error)

+ func (t *Dense) MaskedGreater(val1 interface{}) (err error)

+ func (t *Dense) MaskedGreaterEqual(val1 interface{}) (err error)

+ func (t *Dense) MaskedInside(val1 interface{}, val2 interface{}) (err error)

+ func (t *Dense) MaskedLess(val1 interface{}) (err error)

+ func (t *Dense) MaskedLessEqual(val1 interface{}) (err error)

+ func (t *Dense) MaskedNotEqual(val1 interface{}) (err error)

+ func (t *Dense) MaskedOutside(val1 interface{}, val2 interface{}) (err error)

+ func (t *Dense) MaskedValues(val1 interface{}, val2 interface{}, val3 ...interface{}) (err error)

+ func (t *Dense) MatMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) MatVecMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Materialize() Tensor

+ func (t *Dense) Max(along ...int) (retVal *Dense, err error)

+ func (t *Dense) Memset(x interface{}) error

+ func (t *Dense) Min(along ...int) (retVal *Dense, err error)

+ func (t *Dense) Mod(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) ModScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Mul(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) MulScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Narrow(dim, start, length int) (View, error)

+ func (t *Dense) NonMaskedCount(axis ...int) interface{}

+ func (t *Dense) Norm(ord NormOrder, axes ...int) (retVal *Dense, err error)

+ func (t *Dense) Outer(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) PBDecode(buf []byte) error

+ func (t *Dense) PBEncode() ([]byte, error)

+ func (t *Dense) Pow(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) PowScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) ReadCSV(r io.Reader, opts ...FuncOpt) (err error)

+ func (t *Dense) ReadNpy(r io.Reader) (err error)

+ func (t *Dense) Reduce(fn interface{}, axis int, defaultValue interface{}) (retVal *Dense, err error)

+ func (t *Dense) Repeat(axis int, repeats ...int) (retVal Tensor, err error)

+ func (t *Dense) RequiresIterator() bool

+ func (t *Dense) ResetMask(val ...bool) error

+ func (t *Dense) Reshape(dims ...int) error

+ func (t *Dense) RollAxis(axis, start int, safe bool) (retVal *Dense, err error)

+ func (t *Dense) SVD(uv, full bool) (s, u, v *Dense, err error)

+ func (t *Dense) SafeT(axes ...int) (retVal *Dense, err error)

+ func (t *Dense) ScalarValue() interface{}

+ func (t *Dense) SetAt(v interface{}, coords ...int) error

+ func (t *Dense) SetMask(mask []bool)

+ func (t *Dense) SetMaskAt(v bool, coords ...int) error

+ func (t *Dense) SetMaskAtIndex(v bool, i int) error

+ func (t *Dense) ShallowClone() *Dense

+ func (t *Dense) Slice(slices ...Slice) (retVal View, err error)

+ func (t *Dense) SliceInto(view *Dense, slices ...Slice) (retVal View, err error)

+ func (t *Dense) SoftenMask() bool

+ func (t *Dense) Stack(axis int, others ...*Dense) (retVal *Dense, err error)

+ func (t *Dense) Sub(other *Dense, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) SubScalar(other interface{}, leftTensor bool, opts ...FuncOpt) (retVal *Dense, err error)

+ func (t *Dense) Sum(along ...int) (retVal *Dense, err error)

+ func (t *Dense) T(axes ...int) (err error)

+ func (t *Dense) TensorMul(other Tensor, axesA, axesB []int) (retVal *Dense, err error)

+ func (t *Dense) Trace() (retVal interface{}, err error)

+ func (t *Dense) Transpose() error

+ func (t *Dense) UT()

+ func (t *Dense) Vstack(others ...*Dense) (*Dense, error)

+ func (t *Dense) WriteCSV(w io.Writer, formats ...string) (err error)

+ func (t *Dense) WriteNpy(w io.Writer) (err error)

+ func (t *Dense) Zero()

+ type DenseStacker interface

+ StackDense func(t DenseTensor, axis int, others ...DenseTensor) (retVal DenseTensor, err error)

+ type DenseTensor interface

+ Info func() *AP

+ Inner func(other Tensor) (retVal interface{}, err error)

+ IsColVec func() bool

+ IsMatrix func() bool

+ IsRowVec func() bool

+ IsVector func() bool

+ MatMul func(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)

+ MatVecMul func(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)

+ TensorMul func(other Tensor, axesA, axesB []int) (retVal *Dense, err error)

+ type Densor interface

+ Dense func() *Dense

+ type Diager interface

+ Diag func(a Tensor) (Tensor, error)

+ type Diver interface

+ Div func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ DivScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Dotter interface

+ Dot func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ type Dtype struct

+ func (dt Dtype) Apply(hm.Subs) hm.Substitutable

+ func (dt Dtype) Eq(other hm.Type) bool

+ func (dt Dtype) Format(s fmt.State, c rune)

+ func (dt Dtype) FreeTypeVar() hm.TypeVarSet

+ func (dt Dtype) Normalize(k, v hm.TypeVarSet) (hm.Type, error)

+ func (dt Dtype) Types() hm.Types

+ type Dtyper interface

+ Dtype func() Dtype

+ type ElEqer interface

+ ElEq func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ ElNe func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ EqScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ NeScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Engine interface

+ Accessible func(mem Memory) (Memory, error)

+ Alloc func(size int64) (Memory, error)

+ AllocAccessible func() bool

+ Free func(mem Memory, size int64) error

+ Memclr func(mem Memory)

+ Memcpy func(dst, src Memory) error

+ Memset func(mem Memory, val interface{}) error

+ WorksWith func(order DataOrder) bool

+ type Eq interface

+ Eq func(interface{}) bool

+ type Exper interface

+ Exp func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type FMAer interface

+ FMA func(a, x, y Tensor) (Tensor, error)

+ FMAScalar func(a Tensor, x interface{}, y Tensor) (Tensor, error)

+ type FlatIterator struct

+ func FlatIteratorFromDense(tt DenseTensor) *FlatIterator

+ func (it *FlatIterator) Chan() (retVal chan int)

+ func (it *FlatIterator) Coord() []int

+ func (it *FlatIterator) Done() bool

+ func (it *FlatIterator) Next() (int, error)

+ func (it *FlatIterator) NextInvalid() (int, int, error)

+ func (it *FlatIterator) NextValid() (int, int, error)

+ func (it *FlatIterator) NextValidity() (int, bool, error)

+ func (it *FlatIterator) Reset()

+ func (it *FlatIterator) SetForward()

+ func (it *FlatIterator) SetReverse()

+ func (it *FlatIterator) Slice(sli Slice) (retVal []int, err error)

+ func (it *FlatIterator) Start() (int, error)

+ type FlatMaskedIterator struct

+ func FlatMaskedIteratorFromDense(tt MaskedTensor) *FlatMaskedIterator

+ func (it *FlatMaskedIterator) NextInvalid() (int, int, error)

+ func (it *FlatMaskedIterator) NextValid() (int, int, error)

+ func (it *FlatMaskedIterator) NextValidity() (int, bool, error)

+ type FlatSparseIterator struct

+ func NewFlatSparseIterator(t *CS) *FlatSparseIterator

+ func (a FlatSparseIterator) Cap() int

+ func (a FlatSparseIterator) Data() interface{}

+ func (a FlatSparseIterator) Get(i int) interface{}

+ func (a FlatSparseIterator) Len() int

+ func (a FlatSparseIterator) Memset(x interface{}) error

+ func (a FlatSparseIterator) Set(i int, x interface{})

+ func (a FlatSparseIterator) Zero()

+ func (it *FlatSparseIterator) Coord() []int

+ func (it *FlatSparseIterator) Done() bool

+ func (it *FlatSparseIterator) Next() (int, error)

+ func (it *FlatSparseIterator) NextInvalid() (int, int, error)

+ func (it *FlatSparseIterator) NextValid() (int, int, error)

+ func (it *FlatSparseIterator) NextValidity() (int, bool, error)

+ func (it *FlatSparseIterator) Reset()

+ func (it *FlatSparseIterator) SetForward()

+ func (it *FlatSparseIterator) SetReverse()

+ func (it *FlatSparseIterator) Start() (int, error)

+ type Float32Engine struct

+ func (e Float32Engine) Add(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e Float32Engine) FMA(a, x, y Tensor) (retVal Tensor, err error)

+ func (e Float32Engine) FMAScalar(a Tensor, x interface{}, y Tensor) (retVal Tensor, err error)

+ func (e Float32Engine) Inner(a, b Tensor) (retVal float32, err error)

+ type Float64Engine struct

+ func (e Float64Engine) Add(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e Float64Engine) FMA(a, x, y Tensor) (retVal Tensor, err error)

+ func (e Float64Engine) FMAScalar(a Tensor, x interface{}, y Tensor) (retVal Tensor, err error)

+ func (e Float64Engine) Inner(a, b Tensor) (retVal float64, err error)

+ type FuncOpt func(*OpOpt)

+ func As(t Dtype) FuncOpt

+ func AsSameType() FuncOpt

+ func UseSafe() FuncOpt

+ func UseUnsafe() FuncOpt

+ func WithIncr(incr Tensor) FuncOpt

+ func WithReuse(reuse Tensor) FuncOpt

+ type Gteer interface

+ Gte func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ GteScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Gter interface

+ Gt func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ GtScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type InfChecker interface

+ HasInf func(t Tensor) (bool, error)

+ type InnerProder interface

+ Inner func(a, b Tensor) (interface{}, error)

+ type InnerProderF32 interface

+ Inner func(a, b Tensor) (float32, error)

+ type InnerProderF64 interface

+ Inner func(a, b Tensor) (float64, error)

+ type InvSqrter interface

+ InvSqrt func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Inver interface

+ Inv func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Iterator interface

+ Coord func() []int

+ Done func() bool

+ Next func() (int, error)

+ NextInvalid func() (int, int, error)

+ NextValid func() (int, int, error)

+ NextValidity func() (int, bool, error)

+ Reset func()

+ SetForward func()

+ SetReverse func()

+ Shape func() Shape

+ Start func() (int, error)

+ func IteratorFromDense(tts ...DenseTensor) Iterator

+ func NewIterator(aps ...*AP) Iterator

+ type Kinder interface

+ Kind func() reflect.Kind

+ type Log10er interface

+ Log10 func(a Tensor, opt ...FuncOpt) (Tensor, error)

+ type Log2er interface

+ Log2 func(a Tensor, opt ...FuncOpt) (Tensor, error)

+ type Loger interface

+ Log func(a Tensor, opt ...FuncOpt) (Tensor, error)

+ type Lteer interface

+ Lte func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ LteScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Lter interface

+ Lt func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ LtScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Mapper interface

+ Map func(fn interface{}, a Tensor, opts ...FuncOpt) (Tensor, error)

+ type MaskedTensor interface

+ IsMasked func() bool

+ Mask func() []bool

+ SetMask func([]bool)

+ type MatMuler interface

+ MatMul func(a, b, preallocated Tensor) error

+ type MatVecMuler interface

+ MatVecMul func(a, b, preallocated Tensor) error

+ type MathError interface

+ Indices func() []int

+ type MaxBetweener interface

+ MaxBetween func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ MaxBetweenScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Maxer interface

+ Max func(a Tensor, along ...int) (Tensor, error)

+ type MemSetter interface

+ Memset func(interface{}) error

+ type Memory interface

+ MemSize func() uintptr

+ Uintptr func() uintptr

+ type MemoryFlag byte

+ const IsOverallocated

+ const ManuallyManaged

+ const NativelyInaccessible

+ func MakeMemoryFlag(fs ...MemoryFlag) (retVal MemoryFlag)

+ type MinBetweener interface

+ MinBetween func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ MinBetweenScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Miner interface

+ Min func(a Tensor, along ...int) (Tensor, error)

+ type Moder interface

+ Mod func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ ModScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Muler interface

+ Mul func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ MulScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type MultIterator struct

+ func MultIteratorFromDense(tts ...DenseTensor) *MultIterator

+ func NewMultIterator(aps ...*AP) *MultIterator

+ func (it *MultIterator) Coord() []int

+ func (it *MultIterator) Done() bool

+ func (it *MultIterator) LastIndex(j int) int

+ func (it *MultIterator) Next() (int, error)

+ func (it *MultIterator) NextInvalid() (int, int, error)

+ func (it *MultIterator) NextValid() (int, int, error)

+ func (it *MultIterator) NextValidity() (int, bool, error)

+ func (it *MultIterator) Reset()

+ func (it *MultIterator) SetForward()

+ func (it *MultIterator) SetReverse()

+ func (it *MultIterator) Start() (int, error)

+ type NaNChecker interface

+ HasNaN func(t Tensor) (bool, error)

+ type Neger interface

+ Neg func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type NoOpError interface

+ NoOp func() bool

+ type NonStdEngine interface

+ NonStdAlloc func()

+ type NormOrder float64

+ func FrobeniusNorm() NormOrder

+ func InfNorm() NormOrder

+ func NegInfNorm() NormOrder

+ func Norm(ord int) NormOrder

+ func NuclearNorm() NormOrder

+ func UnorderedNorm() NormOrder

+ func (n NormOrder) IsFrobenius() bool

+ func (n NormOrder) IsInf(sign int) bool

+ func (n NormOrder) IsNuclear() bool

+ func (n NormOrder) IsUnordered() bool

+ func (n NormOrder) String() string

+ func (n NormOrder) Valid() bool

+ type Oner interface

+ One func()

+ type OpOpt struct

+ func ParseFuncOpts(opts ...FuncOpt) *OpOpt

+ func (fo *OpOpt) As() Dtype

+ func (fo *OpOpt) Incr() Tensor

+ func (fo *OpOpt) IncrReuse() (Tensor, bool)

+ func (fo *OpOpt) Reuse() Tensor

+ func (fo *OpOpt) Safe() bool

+ func (fo *OpOpt) Same() bool

+ type OptimizedReducer interface

+ OptimizedReduce func(a Tensor, axis int, firstFn, lastFn, defaultFn, defaultValue interface{}, ...) (Tensor, error)

+ type OuterProder interface

+ Outer func(a, b, preallocated Tensor) error

+ type Power interface

+ Pow func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ PowScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Proder interface

+ Prod func(a Tensor, along ...int) (Tensor, error)

+ type Reducer interface

+ Reduce func(fn interface{}, a Tensor, axis int, defaultValue interface{}, opts ...FuncOpt) (Tensor, error)

+ type Repeater interface

+ Repeat func(t Tensor, axis int, repeats ...int) (Tensor, error)

+ RepeatReuse func(t Tensor, reuse Tensor, axis int, repeeats ...int) (Tensor, error)

+ type SVDer interface

+ SVD func(a Tensor, uv, full bool) (s, u, v Tensor, err error)

+ type ScalarRep interface

+ IsScalar func() bool

+ ScalarValue func() interface{}

+ type Shape []int

+ func ScalarShape() Shape

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

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

+ func (s Shape) CalcStridesWithMask(mask []bool) []int

+ func (s Shape) Clone() Shape

+ func (s Shape) Concat(axis int, ss ...Shape) (newShape Shape, err error)

+ func (s Shape) DimSize(d int) (size int, err error)

+ func (s Shape) Dims() int

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

+ func (s Shape) Format(st fmt.State, r rune)

+ func (s Shape) IsColVec() bool

+ func (s Shape) IsMatrix() bool

+ func (s Shape) IsRowVec() bool

+ func (s Shape) IsScalar() bool

+ func (s Shape) IsScalarEquiv() bool

+ func (s Shape) IsVector() bool

+ func (s Shape) IsVectorLike() bool

+ func (s Shape) Repeat(axis int, repeats ...int) (newShape Shape, finalRepeats []int, size int, err error)

+ func (s Shape) S(slices ...Slice) (retVal Shape, err error)

+ func (s Shape) TotalSize() int

+ type Signer interface

+ Sign func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Slice interface

+ End func() int

+ Start func() int

+ Step func() int

+ func S(start int, opt ...int) Slice

+ type Slicer interface

+ Slice func(...Slice) (View, error)

+ type SoftMaxer interface

+ LogSoftMax func(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ LogSoftMaxB func(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ SoftMax func(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ SoftMaxB func(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ type Sparse interface

+ NonZeroes func() int

+ type SparseTensor interface

+ AsCSC func()

+ AsCSR func()

+ Indices func() []int

+ Indptr func() []int

+ type Sqrter interface

+ Sqrt func(a Tensor, opt ...FuncOpt) (Tensor, error)

+ type Squarer interface

+ Square func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Stacker interface

+ Stack func(t Tensor, axis int, others ...Tensor) (Tensor, error)

+ type StdEng struct

+ func (e StdEng) Abs(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Accessible(mem Memory) (Memory, error)

+ func (e StdEng) Add(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) AddScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Alloc(size int64) (Memory, error)

+ func (e StdEng) AllocAccessible() bool

+ func (e StdEng) Argmax(t Tensor, axis int) (retVal Tensor, err error)

+ func (e StdEng) Argmin(t Tensor, axis int) (retVal Tensor, err error)

+ func (e StdEng) Cbrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Clamp(a Tensor, min, max interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Concat(t Tensor, axis int, others ...Tensor) (retVal Tensor, err error)

+ func (e StdEng) Cube(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Diag(t Tensor) (retVal Tensor, err error)

+ func (e StdEng) Div(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) DivScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Dot(x, y Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) ElEq(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) ElNe(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) EqScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Exp(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) FMA(a, x, y Tensor) (Tensor, error)

+ func (e StdEng) FMAScalar(a Tensor, x interface{}, y Tensor) (Tensor, error)

+ func (e StdEng) Free(mem Memory, size int64) error

+ func (e StdEng) Gt(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) GtScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Gte(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) GteScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Inner(a, b Tensor) (retVal interface{}, err error)

+ func (e StdEng) Inv(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) InvSqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Log(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Log10(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Log2(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) LogSoftMax(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) LogSoftMaxB(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Lt(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) LtScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Lte(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) LteScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Map(fn interface{}, a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) MatMul(a, b, prealloc Tensor) (err error)

+ func (e StdEng) MatVecMul(a, b, prealloc Tensor) (err error)

+ func (e StdEng) Max(a Tensor, along ...int) (retVal Tensor, err error)

+ func (e StdEng) MaxBetween(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) MaxBetweenScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Memclr(mem Memory)

+ func (e StdEng) Memcpy(dst, src Memory) error

+ func (e StdEng) Memset(mem Memory, val interface{}) error

+ func (e StdEng) Min(a Tensor, along ...int) (retVal Tensor, err error)

+ func (e StdEng) MinBetween(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) MinBetweenScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Mod(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) ModScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Mul(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) MulScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) NeScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Neg(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) OptimizedReduce(a Tensor, axis int, firstFn, lastFn, defaultFn, defaultValue interface{}, ...) (retVal Tensor, err error)

+ func (e StdEng) Outer(a, b, prealloc Tensor) (err error)

+ func (e StdEng) Pow(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) PowScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Reduce(fn interface{}, a Tensor, axis int, defaultValue interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Repeat(t Tensor, axis int, repeats ...int) (Tensor, error)

+ func (e StdEng) RepeatReuse(t Tensor, reuse Tensor, axis int, repeats ...int) (Tensor, error)

+ func (e StdEng) SVD(a Tensor, uv, full bool) (s, u, v Tensor, err error)

+ func (e StdEng) SelectByIndices(a, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) SelectByIndicesB(input, outGrad, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Sign(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) SoftMax(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) SoftMaxB(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Sqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Square(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) StackDense(t DenseTensor, axis int, others ...DenseTensor) (retVal DenseTensor, err error)

+ func (e StdEng) Sub(a Tensor, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) SubScalar(t Tensor, s interface{}, leftTensor bool, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Sum(a Tensor, along ...int) (retVal Tensor, err error)

+ func (e StdEng) Tanh(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func (e StdEng) Trace(t Tensor) (retVal interface{}, err error)

+ func (e StdEng) Transpose(a Tensor, expStrides []int) error

+ func (e StdEng) WorksWith(order DataOrder) bool

+ type Suber interface

+ Sub func(a, b Tensor, opts ...FuncOpt) (Tensor, error)

+ SubScalar func(a Tensor, b interface{}, leftTensor bool, opts ...FuncOpt) (Tensor, error)

+ type Sumer interface

+ Sum func(a Tensor, along ...int) (Tensor, error)

+ type Tanher interface

+ Tanh func(a Tensor, opts ...FuncOpt) (Tensor, error)

+ type Tensor interface

+ Apply func(fn interface{}, opts ...FuncOpt) (Tensor, error)

+ At func(...int) (interface{}, error)

+ DataOrder func() DataOrder

+ DataSize func() int

+ Dims func() int

+ Dtype func() Dtype

+ Engine func() Engine

+ IsManuallyManaged func() bool

+ IsNativelyAccessible func() bool

+ IsScalar func() bool

+ Iterator func() Iterator

+ ReadNpy func(io.Reader) error

+ RequiresIterator func() bool

+ Reshape func(...int) error

+ ScalarValue func() interface{}

+ SetAt func(v interface{}, coord ...int) error

+ Shape func() Shape

+ Size func() int

+ Strides func() []int

+ T func(axes ...int) error

+ Transpose func() error

+ UT func()

+ WriteNpy func(io.Writer) error

+ func Abs(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Add(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Argmax(t Tensor, axis int) (retVal Tensor, err error)

+ func Argmin(t Tensor, axis int) (retVal Tensor, err error)

+ func ByIndices(a, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func ByIndicesB(a, b, indices Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func Cbrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Clamp(a Tensor, min interface{}, max interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Concat(axis int, t Tensor, others ...Tensor) (retVal Tensor, err error)

+ func Contract(a, b Tensor, aAxes, bAxes []int) (retVal Tensor, err error)

+ func Cube(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Diag(t Tensor) (retVal Tensor, err error)

+ func Div(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Dot(x, y Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func ElEq(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func ElNe(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Exp(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func FMA(a Tensor, x interface{}, y Tensor) (retVal Tensor, err error)

+ func Gt(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Gte(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Inv(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func InvSqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Log(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Log10(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Log2(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func LogSoftMax(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func LogSoftMaxB(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func Lt(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Lte(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func MatMul(a, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func MatVecMul(a, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Materialize(t Tensor) Tensor

+ func MaxBetween(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func MinBetween(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Mod(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Mul(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Neg(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Outer(a, b Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Pow(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Repeat(t Tensor, axis int, repeats ...int) (retVal Tensor, err error)

+ func RepeatReuse(t, reuse Tensor, axis int, repeats ...int) (retval Tensor, err error)

+ func Sign(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func SoftMax(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func SoftMaxB(output, grad Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

+ func Sqrt(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Square(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Stack(axis int, t Tensor, others ...Tensor) (retVal Tensor, err error)

+ func Sub(a, b interface{}, opts ...FuncOpt) (retVal Tensor, err error)

+ func Sum(t Tensor, along ...int) (retVal Tensor, err error)

+ func T(t Tensor, axes ...int) (retVal Tensor, err error)

+ func Tanh(a Tensor, opts ...FuncOpt) (retVal Tensor, err error)

+ func Transpose(t Tensor, axes ...int) (retVal Tensor, err error)

+ type Tracer interface

+ Trace func(a Tensor) (interface{}, error)

+ type Transposer interface

+ Transpose func(t Tensor, expStrides []int) error

+ type Triangle byte

+ const Lower

+ const NotTriangle

+ const Symmetric

+ const Upper

+ type View interface

+ IsMaterializable func() bool

+ IsView func() bool

+ Materialize func() Tensor

+ func Narrow(t Tensor, dim, start, length int) (View, error)

+ type Zeroer interface

+ Zero func()

v0.9.0-beta

Aug 19, 2018

v0.8.1

Jan 22, 2018

v0.8.0

Dec 17, 2017