package/gonum
1
0
Fork 0
mirror of https://github.com/gonum/gonum.git synced 2025-10-28 17:31:56 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Make order constant

Browse Source 
This is a start to removing column major handling of matrices.
This commit is contained in:
kortschak
2013-11-15 10:50:23 +10:30
parent dd2cd47b0c
commit 26b1734f85
3 changed files with 74 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
mat64/dense.go
View File

@@ -13,15 +13,7 @@ var blasEngine blas.Float64
func Register(b blas.Float64) { blasEngine = b } func Register(b blas.Float64) { blasEngine = b }
var blasOrder = blas.RowMajor const BlasOrder = blas.RowMajor
func Order(o blas.Order) blas.Order {
if o == blas.RowMajor || o == blas.ColMajor {
o, blasOrder = blasOrder, o
return o
}
return blasOrder
}
var ( var (
matrix *Dense matrix *Dense
@@ -73,7 +65,7 @@ func NewDense(r, c int, mat []float64) (*Dense, error) {
return nil, ErrShape return nil, ErrShape
} }
var stride int var stride int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
stride = c stride = c
case blas.ColMajor: case blas.ColMajor:
@@ -82,7 +74,7 @@ func NewDense(r, c int, mat []float64) (*Dense, error) {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
return &Dense{BlasMatrix{ return &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: r, Rows: r,
Cols: c, Cols: c,
Stride: stride, Stride: stride,
@@ -241,7 +233,7 @@ func (m *Dense) Submatrix(a Matrix, i, j, r, c int) {
func (m *Dense) Clone(a Matrix) { func (m *Dense) Clone(a Matrix) {
r, c := a.Dims() r, c := a.Dims()
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: r, Rows: r,
Cols: c, Cols: c,
} }
@@ -249,7 +241,7 @@ func (m *Dense) Clone(a Matrix) {
switch a := a.(type) { switch a := a.(type) {
case Blasser: case Blasser:
amat := a.BlasMatrix() amat := a.BlasMatrix()
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 0; i < r; i++ { for i := 0; i < r; i++ {
copy(data[i*c:(i+1)*c], amat.Data[i*amat.Stride:i*amat.Stride+c]) copy(data[i*c:(i+1)*c], amat.Data[i*amat.Stride:i*amat.Stride+c])
@@ -265,7 +257,7 @@ func (m *Dense) Clone(a Matrix) {
} }
m.mat.Data = data m.mat.Data = data
case Vectorer: case Vectorer:
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 0; i < r; i++ { for i := 0; i < r; i++ {
a.Row(data[i*c:(i+1)*c], i) a.Row(data[i*c:(i+1)*c], i)
@@ -298,7 +290,7 @@ func (m *Dense) Copy(a Matrix) (r, c int) {
switch a := a.(type) { switch a := a.(type) {
case Blasser: case Blasser:
amat := a.BlasMatrix() amat := a.BlasMatrix()
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 0; i < r; i++ { for i := 0; i < r; i++ {
copy(m.mat.Data[i*m.mat.Stride:i*m.mat.Stride+c], amat.Data[i*amat.Stride:i*amat.Stride+c]) copy(m.mat.Data[i*m.mat.Stride:i*m.mat.Stride+c], amat.Data[i*amat.Stride:i*amat.Stride+c])
@@ -311,7 +303,7 @@ func (m *Dense) Copy(a Matrix) (r, c int) {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
case Vectorer: case Vectorer:
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 0; i < r; i++ { for i := 0; i < r; i++ {
a.Row(m.mat.Data[i*m.mat.Stride:i*m.mat.Stride+c], i) a.Row(m.mat.Data[i*m.mat.Stride:i*m.mat.Stride+c], i)
@@ -428,7 +420,7 @@ func (m *Dense) Norm(ord float64) float64 {
} }
case ord == 0: case ord == 0:
var l int var l int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
l = m.mat.Cols l = m.mat.Cols
case blas.ColMajor: case blas.ColMajor:
@@ -462,12 +454,12 @@ func (m *Dense) Add(a, b Matrix) {
var k, l int var k, l int
if m.isZero() { if m.isZero() {
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -478,7 +470,7 @@ func (m *Dense) Add(a, b Matrix) {
} else if ar != m.mat.Rows || ac != m.mat.Cols { } else if ar != m.mat.Rows || ac != m.mat.Cols {
panic(ErrShape) panic(ErrShape)
} else { } else {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -491,7 +483,7 @@ func (m *Dense) Add(a, b Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
amat, bmat := a.BlasMatrix(), b.BlasMatrix() amat, bmat := a.BlasMatrix(), b.BlasMatrix()
if amat.Order != blasOrder || bmat.Order != blasOrder { if amat.Order != BlasOrder || bmat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride { for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride {
@@ -505,7 +497,7 @@ func (m *Dense) Add(a, b Matrix) {
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
rowa := make([]float64, ac) rowa := make([]float64, ac)
rowb := make([]float64, bc) rowb := make([]float64, bc)
@@ -551,12 +543,12 @@ func (m *Dense) Sub(a, b Matrix) {
var k, l int var k, l int
if m.isZero() { if m.isZero() {
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -567,7 +559,7 @@ func (m *Dense) Sub(a, b Matrix) {
} else if ar != m.mat.Rows || ac != m.mat.Cols { } else if ar != m.mat.Rows || ac != m.mat.Cols {
panic(ErrShape) panic(ErrShape)
} else { } else {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -580,7 +572,7 @@ func (m *Dense) Sub(a, b Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
amat, bmat := a.BlasMatrix(), b.BlasMatrix() amat, bmat := a.BlasMatrix(), b.BlasMatrix()
if amat.Order != blasOrder || bmat.Order != blasOrder { if amat.Order != BlasOrder || bmat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride { for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride {
@@ -594,7 +586,7 @@ func (m *Dense) Sub(a, b Matrix) {
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
rowa := make([]float64, ac) rowa := make([]float64, ac)
rowb := make([]float64, bc) rowb := make([]float64, bc)
@@ -640,12 +632,12 @@ func (m *Dense) MulElem(a, b Matrix) {
var k, l int var k, l int
if m.isZero() { if m.isZero() {
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -656,7 +648,7 @@ func (m *Dense) MulElem(a, b Matrix) {
} else if ar != m.mat.Rows || ac != m.mat.Cols { } else if ar != m.mat.Rows || ac != m.mat.Cols {
panic(ErrShape) panic(ErrShape)
} else { } else {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -669,7 +661,7 @@ func (m *Dense) MulElem(a, b Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
amat, bmat := a.BlasMatrix(), b.BlasMatrix() amat, bmat := a.BlasMatrix(), b.BlasMatrix()
if amat.Order != blasOrder || bmat.Order != blasOrder { if amat.Order != BlasOrder || bmat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride { for ja, jb, jm := 0, 0, 0; ja < k*amat.Stride; ja, jb, jm = ja+amat.Stride, jb+bmat.Stride, jm+m.mat.Stride {
@@ -683,7 +675,7 @@ func (m *Dense) MulElem(a, b Matrix) {
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
rowa := make([]float64, ac) rowa := make([]float64, ac)
rowb := make([]float64, bc) rowb := make([]float64, bc)
@@ -727,7 +719,7 @@ func (m *Dense) Dot(b Matrix) float64 {
} }
var k, l int var k, l int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = mr, mc k, l = mr, mc
case blas.ColMajor: case blas.ColMajor:
@@ -740,7 +732,7 @@ func (m *Dense) Dot(b Matrix) float64 {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
bmat := b.BlasMatrix() bmat := b.BlasMatrix()
if m.mat.Order != blasOrder || bmat.Order != blasOrder { if m.mat.Order != BlasOrder || bmat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
for jm, jb := 0, 0; jm < k*m.mat.Stride; jm, jb = jm+m.mat.Stride, jb+bmat.Stride { for jm, jb := 0, 0; jm < k*m.mat.Stride; jm, jb = jm+m.mat.Stride, jb+bmat.Stride {
@@ -752,7 +744,7 @@ func (m *Dense) Dot(b Matrix) float64 {
} }
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
row := make([]float64, bc) row := make([]float64, bc)
for r := 0; r < br; r++ { for r := 0; r < br; r++ {
@@ -795,12 +787,12 @@ func (m *Dense) Mul(a, b Matrix) {
} }
if w.isZero() { if w.isZero() {
w.mat = BlasMatrix{ w.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: bc, Cols: bc,
Data: realloc(w.mat.Data, ar*bc), Data: realloc(w.mat.Data, ar*bc),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
w.mat.Stride = bc w.mat.Stride = bc
case blas.ColMajor: case blas.ColMajor:
@@ -815,14 +807,14 @@ func (m *Dense) Mul(a, b Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
amat, bmat := a.BlasMatrix(), b.BlasMatrix() amat, bmat := a.BlasMatrix(), b.BlasMatrix()
if amat.Order != blasOrder || bmat.Order != blasOrder { if amat.Order != BlasOrder || bmat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
if blasEngine == nil { if blasEngine == nil {
panic(ErrNoEngine) panic(ErrNoEngine)
} }
blasEngine.Dgemm( blasEngine.Dgemm(
blasOrder, BlasOrder,
blas.NoTrans, blas.NoTrans, blas.NoTrans, blas.NoTrans,
ar, bc, ac, ar, bc, ac,
1., 1.,
@@ -844,7 +836,7 @@ func (m *Dense) Mul(a, b Matrix) {
if blasEngine == nil { if blasEngine == nil {
panic(ErrNoEngine) panic(ErrNoEngine)
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
w.mat.Data[r*w.mat.Stride+w.mat.Cols] = blasEngine.Ddot(ac, a.Row(row, r), 1, b.Col(col, c), 1) w.mat.Data[r*w.mat.Stride+w.mat.Cols] = blasEngine.Ddot(ac, a.Row(row, r), 1, b.Col(col, c), 1)
case blas.ColMajor: case blas.ColMajor:
@@ -869,7 +861,7 @@ func (m *Dense) Mul(a, b Matrix) {
for i, e := range row { for i, e := range row {
v += e * b.At(i, c) v += e * b.At(i, c)
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
w.mat.Data[r*w.mat.Stride+w.mat.Cols] = v w.mat.Data[r*w.mat.Stride+w.mat.Cols] = v
case blas.ColMajor: case blas.ColMajor:
@@ -888,12 +880,12 @@ func (m *Dense) Scale(f float64, a Matrix) {
var k, l int var k, l int
if m.isZero() { if m.isZero() {
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -904,7 +896,7 @@ func (m *Dense) Scale(f float64, a Matrix) {
} else if ar != m.mat.Rows || ac != m.mat.Cols { } else if ar != m.mat.Rows || ac != m.mat.Cols {
panic(ErrShape) panic(ErrShape)
} else { } else {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -916,7 +908,7 @@ func (m *Dense) Scale(f float64, a Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
amat := a.BlasMatrix() amat := a.BlasMatrix()
if amat.Order != blasOrder { if amat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
for ja, jm := 0, 0; ja < k*amat.Stride; ja, jm = ja+amat.Stride, jm+m.mat.Stride { for ja, jm := 0, 0; ja < k*amat.Stride; ja, jm = ja+amat.Stride, jm+m.mat.Stride {
@@ -928,7 +920,7 @@ func (m *Dense) Scale(f float64, a Matrix) {
} }
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
row := make([]float64, ac) row := make([]float64, ac)
for r := 0; r < ar; r++ { for r := 0; r < ar; r++ {
@@ -964,12 +956,12 @@ func (m *Dense) Apply(f ApplyFunc, a Matrix) {
var k, l int var k, l int
if m.isZero() { if m.isZero() {
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -980,7 +972,7 @@ func (m *Dense) Apply(f ApplyFunc, a Matrix) {
} else if ar != m.mat.Rows || ac != m.mat.Cols { } else if ar != m.mat.Rows || ac != m.mat.Cols {
panic(ErrShape) panic(ErrShape)
} else { } else {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -992,13 +984,13 @@ func (m *Dense) Apply(f ApplyFunc, a Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
amat := a.BlasMatrix() amat := a.BlasMatrix()
if amat.Order != blasOrder { if amat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
var r, c int var r, c int
for j, ja, jm := 0, 0, 0; ja < k*amat.Stride; j, ja, jm = j+1, ja+amat.Stride, jm+m.mat.Stride { for j, ja, jm := 0, 0, 0; ja < k*amat.Stride; j, ja, jm = j+1, ja+amat.Stride, jm+m.mat.Stride {
for i, v := range amat.Data[ja : ja+l] { for i, v := range amat.Data[ja : ja+l] {
if blasOrder == blas.RowMajor { if BlasOrder == blas.RowMajor {
r, c = j, i r, c = j, i
} else { } else {
r, c = i, j r, c = i, j
@@ -1010,7 +1002,7 @@ func (m *Dense) Apply(f ApplyFunc, a Matrix) {
} }
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
row := make([]float64, ac) row := make([]float64, ac)
for r := 0; r < ar; r++ { for r := 0; r < ar; r++ {
@@ -1060,12 +1052,12 @@ func (m *Dense) U(a Matrix) {
return return
case m.isZero(): case m.isZero():
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -1076,7 +1068,7 @@ func (m *Dense) U(a Matrix) {
case ar != m.mat.Rows || ac != m.mat.Cols: case ar != m.mat.Rows || ac != m.mat.Cols:
panic(ErrShape) panic(ErrShape)
default: default:
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ar, ac k, l = ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -1088,7 +1080,7 @@ func (m *Dense) U(a Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
amat := a.BlasMatrix() amat := a.BlasMatrix()
if amat.Order != blasOrder { if amat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
copy(m.mat.Data[:l], amat.Data[:l]) copy(m.mat.Data[:l], amat.Data[:l])
@@ -1100,7 +1092,7 @@ func (m *Dense) U(a Matrix) {
} }
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
row := make([]float64, ac) row := make([]float64, ac)
copy(m.mat.Data[:m.mat.Cols], a.Row(row, 0)) copy(m.mat.Data[:m.mat.Cols], a.Row(row, 0))
@@ -1129,7 +1121,7 @@ func (m *Dense) U(a Matrix) {
} }
func (m *Dense) zeroLower() { func (m *Dense) zeroLower() {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 1; i < m.mat.Rows; i++ { for i := 1; i < m.mat.Rows; i++ {
zero(m.mat.Data[i*m.mat.Stride : i*m.mat.Stride+i]) zero(m.mat.Data[i*m.mat.Stride : i*m.mat.Stride+i])
@@ -1156,12 +1148,12 @@ func (m *Dense) L(a Matrix) {
return return
case m.isZero(): case m.isZero():
m.mat = BlasMatrix{ m.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ar, Rows: ar,
Cols: ac, Cols: ac,
Data: realloc(m.mat.Data, ar*ac), Data: realloc(m.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
m.mat.Stride, k, l = ac, ar, ac m.mat.Stride, k, l = ac, ar, ac
case blas.ColMajor: case blas.ColMajor:
@@ -1172,7 +1164,7 @@ func (m *Dense) L(a Matrix) {
case ar != m.mat.Rows || ac != m.mat.Cols: case ar != m.mat.Rows || ac != m.mat.Cols:
panic(ErrShape) panic(ErrShape)
default: default:
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = ac, ar k, l = ac, ar
case blas.ColMajor: case blas.ColMajor:
@@ -1184,7 +1176,7 @@ func (m *Dense) L(a Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
amat := a.BlasMatrix() amat := a.BlasMatrix()
if amat.Order != blasOrder { if amat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
copy(m.mat.Data[:l], amat.Data[:l]) copy(m.mat.Data[:l], amat.Data[:l])
@@ -1196,7 +1188,7 @@ func (m *Dense) L(a Matrix) {
} }
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
row := make([]float64, ac) row := make([]float64, ac)
for r := 0; r < ar; r++ { for r := 0; r < ar; r++ {
@@ -1225,7 +1217,7 @@ func (m *Dense) L(a Matrix) {
} }
func (m *Dense) zeroUpper() { func (m *Dense) zeroUpper() {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
for i := 0; i < m.mat.Rows-1; i++ { for i := 0; i < m.mat.Rows-1; i++ {
zero(m.mat.Data[i*m.mat.Stride+i+1 : (i+1)*m.mat.Stride]) zero(m.mat.Data[i*m.mat.Stride+i+1 : (i+1)*m.mat.Stride])
@@ -1248,12 +1240,12 @@ func (m *Dense) TCopy(a Matrix) {
} }
if w.isZero() { if w.isZero() {
w.mat = BlasMatrix{ w.mat = BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: ac, Rows: ac,
Cols: ar, Cols: ar,
Data: realloc(w.mat.Data, ar*ac), Data: realloc(w.mat.Data, ar*ac),
} }
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
w.mat.Stride = ar w.mat.Stride = ar
case blas.ColMajor: case blas.ColMajor:
@@ -1263,7 +1255,7 @@ func (m *Dense) TCopy(a Matrix) {
} }
} else if ar != m.mat.Cols || ac != m.mat.Rows { } else if ar != m.mat.Cols || ac != m.mat.Rows {
panic(ErrShape) panic(ErrShape)
} else if blasOrder != blas.RowMajor && blasOrder != blas.ColMajor { } else if BlasOrder != blas.RowMajor && BlasOrder != blas.ColMajor {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
switch a := a.(type) { switch a := a.(type) {
@@ -1285,7 +1277,7 @@ func (m *Dense) TCopy(a Matrix) {
func (m *Dense) Sum() float64 { func (m *Dense) Sum() float64 {
var l int var l int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
l = m.mat.Cols l = m.mat.Cols
case blas.ColMajor: case blas.ColMajor:
@@ -1310,7 +1302,7 @@ func (m *Dense) Equals(b Matrix) bool {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
var k, l int var k, l int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = br, bc k, l = br, bc
case blas.ColMajor: case blas.ColMajor:
@@ -1330,7 +1322,7 @@ func (m *Dense) Equals(b Matrix) bool {
} }
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
rowb := make([]float64, bc) rowb := make([]float64, bc)
for r := 0; r < br; r++ { for r := 0; r < br; r++ {
@@ -1375,7 +1367,7 @@ func (m *Dense) EqualsApprox(b Matrix, epsilon float64) bool {
if b, ok := b.(Blasser); ok { if b, ok := b.(Blasser); ok {
var k, l int var k, l int
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
k, l = br, bc k, l = br, bc
case blas.ColMajor: case blas.ColMajor:
@@ -1395,7 +1387,7 @@ func (m *Dense) EqualsApprox(b Matrix, epsilon float64) bool {
} }
if b, ok := b.(Vectorer); ok { if b, ok := b.(Vectorer); ok {
switch blasOrder { switch BlasOrder {
case blas.RowMajor: case blas.RowMajor:
rowb := make([]float64, bc) rowb := make([]float64, bc)
for r := 0; r < br; r++ { for r := 0; r < br; r++ {

14
mat64/matrix_test.go
View File

@@ -86,7 +86,7 @@ func (s *S) TestNewDense(c *check.C) {
0, 0, 0, 0,
0, 0,
&Dense{BlasMatrix{ &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: 3, Cols: 3, Rows: 3, Cols: 3,
Stride: 3, Stride: 3,
Data: []float64{0, 0, 0, 0, 0, 0, 0, 0, 0}, Data: []float64{0, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -102,7 +102,7 @@ func (s *S) TestNewDense(c *check.C) {
1, 1, 1, 1,
3, 3,
&Dense{BlasMatrix{ &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: 3, Cols: 3, Rows: 3, Cols: 3,
Stride: 3, Stride: 3,
Data: []float64{1, 1, 1, 1, 1, 1, 1, 1, 1}, Data: []float64{1, 1, 1, 1, 1, 1, 1, 1, 1},
@@ -118,7 +118,7 @@ func (s *S) TestNewDense(c *check.C) {
0, 1, 0, 1,
1.7320508075688772, 1.7320508075688772,
&Dense{BlasMatrix{ &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: 3, Cols: 3, Rows: 3, Cols: 3,
Stride: 3, Stride: 3,
Data: []float64{1, 0, 0, 0, 1, 0, 0, 0, 1}, Data: []float64{1, 0, 0, 0, 1, 0, 0, 0, 1},
@@ -133,7 +133,7 @@ func (s *S) TestNewDense(c *check.C) {
3, 3, 3, 3,
-1, 0, -1, 0,
1.7320508075688772, 1.7320508075688772,
&Dense{BlasMatrix{Order: blasOrder, &Dense{BlasMatrix{Order: BlasOrder,
Rows: 3, Cols: 3, Rows: 3, Cols: 3,
Stride: 3, Stride: 3,
Data: []float64{-1, 0, 0, 0, -1, 0, 0, 0, -1}, Data: []float64{-1, 0, 0, 0, -1, 0, 0, 0, -1},
@@ -147,7 +147,7 @@ func (s *S) TestNewDense(c *check.C) {
2, 3, 2, 3,
1, 6, 1, 6,
9.539392014169456, 9.539392014169456,
&Dense{BlasMatrix{Order: blasOrder, &Dense{BlasMatrix{Order: BlasOrder,
Rows: 2, Cols: 3, Rows: 2, Cols: 3,
Stride: 3, Stride: 3,
Data: []float64{1, 2, 3, 4, 5, 6}, Data: []float64{1, 2, 3, 4, 5, 6},
@@ -163,7 +163,7 @@ func (s *S) TestNewDense(c *check.C) {
1, 6, 1, 6,
9.539392014169456, 9.539392014169456,
&Dense{BlasMatrix{ &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: 3, Cols: 2, Rows: 3, Cols: 2,
Stride: 2, Stride: 2,
Data: []float64{1, 2, 3, 4, 5, 6}, Data: []float64{1, 2, 3, 4, 5, 6},
@@ -470,7 +470,7 @@ func randDense(size int, rho float64, rnd func() float64) (*Dense, error) {
return nil, ErrZeroLength return nil, ErrZeroLength
} }
d := &Dense{BlasMatrix{ d := &Dense{BlasMatrix{
Order: blasOrder, Order: BlasOrder,
Rows: size, Cols: size, Stride: size, Rows: size, Cols: size, Stride: size,
Data: make([]float64, size*size), Data: make([]float64, size*size),
}} }}

6
mat64/vec.go
View File

@@ -80,10 +80,10 @@ func (m *Vec) Mul(a, b Matrix) {
if a, ok := a.(Blasser); ok { if a, ok := a.(Blasser); ok {
amat := a.BlasMatrix() amat := a.BlasMatrix()
if amat.Order != blasOrder { if amat.Order != BlasOrder {
panic(ErrIllegalOrder) panic(ErrIllegalOrder)
} }
blasEngine.Dgemv(blasOrder, blasEngine.Dgemv(BlasOrder,
blas.NoTrans, blas.NoTrans,
ar, ac, ar, ac,
1., 1.,
@@ -98,7 +98,7 @@ func (m *Vec) Mul(a, b Matrix) {
if a, ok := a.(Vectorer); ok { if a, ok := a.(Vectorer); ok {
row := make([]float64, ac) row := make([]float64, ac)
for r := 0; r < ar; r++ { for r := 0; r < ar; r++ {
switch blasOrder { switch BlasOrder {
case blas.RowMajor, blas.ColMajor: case blas.RowMajor, blas.ColMajor:
w[r] = blasEngine.Ddot(ac, a.Row(row, r), 1, bv, 1) w[r] = blasEngine.Ddot(ac, a.Row(row, r), 1, bv, 1)
default: default: