1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
package tensor
import (
"reflect"
"gorgonia.org/tensor/internal/storage"
)
// Dtyper is any type that has a Dtype
type Dtyper interface {
Dtype() Dtype
}
// Eq is any type where you can perform an equality test
type Eq interface {
Eq(interface{}) bool
}
// Cloner is any type that can clone itself
type Cloner interface {
Clone() interface{}
}
// Dataer is any type that returns the data in its original form (typically a Go slice of something)
type Dataer interface {
Data() interface{}
}
// Boolable is any type has a zero and one value, and is able to set itself to either
type Boolable interface {
Zeroer
Oner
}
// A Zeroer is any type that can set itself to the zeroth value. It's used to implement the arrays
type Zeroer interface {
Zero()
}
// A Oner is any type that can set itself to the equivalent of one. It's used to implement the arrays
type Oner interface {
One()
}
// A MemSetter is any type that can set itself to a value.
type MemSetter interface {
Memset(interface{}) error
}
// A Densor is any type that can return a *Dense
type Densor interface {
Dense() *Dense
}
// ScalarRep is any Tensor that can represent a scalar
type ScalarRep interface {
IsScalar() bool
ScalarValue() interface{}
}
// View is any Tensor that can provide a view on memory
type View interface {
Tensor
IsView() bool
IsMaterializable() bool
Materialize() Tensor
}
// Slicer is any tensor that can slice
type Slicer interface {
Slice(...Slice) (View, error)
}
// DenseTensor is the interface for any Dense tensor.
type DenseTensor interface {
Tensor
Info() *AP
IsMatrix() bool
IsVector() bool
IsRowVec() bool
IsColVec() bool
// headerer
// arrayer
unsafeMem
setAP(*AP)
rtype() reflect.Type
reshape(dims ...int) error
setDataOrder(o DataOrder)
isTransposed() bool
ostrides() []int
oshape() Shape
transposeAxes() []int
transposeIndex(i int, transposePat, strides []int) int
oldAP() *AP
setOldAP(ap *AP)
parentTensor() *Dense
setParentTensor(*Dense)
len() int
cap() int
// operations
Inner(other Tensor) (retVal interface{}, err error)
MatMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)
MatVecMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)
TensorMul(other Tensor, axesA, axesB []int) (retVal *Dense, err error)
stackDense(axis int, others ...DenseTensor) (DenseTensor, error)
}
type SparseTensor interface {
Sparse
AsCSC()
AsCSR()
Indices() []int
Indptr() []int
// headerer
}
type MaskedTensor interface {
DenseTensor
IsMasked() bool
SetMask([]bool)
Mask() []bool
}
// Kinder. Bueno.
type Kinder interface {
Kind() reflect.Kind
}
type headerer interface {
hdr() *storage.Header
}
type arrayer interface {
arr() array
arrPtr() *array
}
type unsafeMem interface {
Set(i int, x interface{})
GetF64(i int) float64
GetF32(i int) float32
Ints() []int
Float64s() []float64
Float32s() []float32
Complex64s() []complex64
Complex128s() []complex128
}
|
