tensor

package module

Go to main page

Versions in this module

v0

v0.10.0-working

Jan 18, 2021

v0.9.24

Jul 18, 2022

v0.9.23

Apr 4, 2022

v0.9.22

Mar 28, 2022

Changes in this version

type Dense

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

type Slice

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

+ 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 StdEng

+ 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) 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)

type Tensor

+ 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 SoftMax(x Tensor, axis int, opts ...FuncOpt) (retVal Tensor, err error)

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

type View

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

v0.9.21

Sep 16, 2021

Changes in this version

+ 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 MinBetweener interface

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

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

type StdEng

+ 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) 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)

type Tensor

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

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

v0.9.20

Mar 28, 2021

v0.9.19

Jan 14, 2021

v0.9.18

Jan 14, 2021

v0.9.17

Dec 30, 2020

v0.9.16

Dec 30, 2020

v0.9.15

Dec 11, 2020

Changes in this version

type AP

+ func (ap *AP) IsScalarEquiv() bool

+ type ByIndiceser interface

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

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

type CS

+ func (a *CS) Cap() int

+ func (a *CS) Len() int

type Dense

+ func (a *Dense) Cap() int

+ func (a *Dense) Len() int

type FlatSparseIterator

+ func (a FlatSparseIterator) Cap() int

+ func (a FlatSparseIterator) Len() int

type StdEng

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

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

type Tensor

+ 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)

v0.9.14

Oct 26, 2020

Changes in this version

type MemoryFlag

+ const IsOverallocated

v0.9.13

Oct 20, 2020

v0.9.12

Oct 20, 2020

Changes in this version

type AP

+ func (ap *AP) IsVectorLike() bool

type Shape

+ func (s Shape) IsVectorLike() bool

v0.9.11

Sep 9, 2020

Changes in this version

type Dense

+ func FromArrowArray(a arrowArray.Interface) *Dense

+ func FromArrowTensor(a arrowTensor.Interface) *Dense

v0.9.9

Jul 8, 2020

v0.9.8

Jun 30, 2020

v0.9.7

Jun 1, 2020

v0.9.6

Apr 10, 2020

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) IsVector() 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 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) Get(i int) interface{}

+ 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) Pointer() unsafe.Pointer

+ 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{}) 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 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) Get(i int) interface{}

+ func (a *Dense) MemSize() uintptr

+ func (a *Dense) Pointer() unsafe.Pointer

+ 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) 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) Data() interface{}

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

+ 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 Maxer interface

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

+ type MemSetter interface

+ Memset func(interface{}) error

+ type Memory interface

+ MemSize func() uintptr

+ Pointer func() unsafe.Pointer

+ Uintptr func() uintptr

+ type MemoryFlag byte

+ const ManuallyManaged

+ const NativelyInaccessible

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

+ 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) 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

+ type Slicer interface

+ Slice func(...Slice) (View, 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) 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) 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) 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) Sign(a Tensor, 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

+ MemSize func() uintptr

+ Pointer func() unsafe.Pointer

+ 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()

+ Uintptr func() uintptr

+ 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 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 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 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 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

+ type Zeroer interface

+ Zero func()

v0.9.6-performance

Jun 1, 2020

v0.9.4

Jan 4, 2020

v0.9.3

Dec 8, 2019

v0.9.2

Oct 14, 2019

v0.9.1

Sep 5, 2019

v0.9.0-working

Aug 18, 2018

v0.9.0-beta

Aug 19, 2018

v0.8.0-working

Dec 17, 2017

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL