mirror of
https://github.com/gonum/gonum.git
synced 2025-10-31 02:26:59 +08:00
621 lines
13 KiB
Go
621 lines
13 KiB
Go
// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.
|
|
|
|
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package blas32
|
|
|
|
import (
|
|
math "gonum.org/v1/gonum/internal/math32"
|
|
"testing"
|
|
|
|
"gonum.org/v1/gonum/blas"
|
|
)
|
|
|
|
func newGeneralFrom(a GeneralCols) General {
|
|
t := General{
|
|
Rows: a.Rows,
|
|
Cols: a.Cols,
|
|
Stride: a.Cols,
|
|
Data: make([]float32, a.Rows*a.Cols),
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m General) dims() (r, c int) { return m.Rows, m.Cols }
|
|
func (m General) at(i, j int) float32 { return m.Data[i*m.Stride+j] }
|
|
|
|
func newGeneralColsFrom(a General) GeneralCols {
|
|
t := GeneralCols{
|
|
Rows: a.Rows,
|
|
Cols: a.Cols,
|
|
Stride: a.Rows,
|
|
Data: make([]float32, a.Rows*a.Cols),
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m GeneralCols) dims() (r, c int) { return m.Rows, m.Cols }
|
|
func (m GeneralCols) at(i, j int) float32 { return m.Data[i+j*m.Stride] }
|
|
|
|
type general interface {
|
|
dims() (r, c int)
|
|
at(i, j int) float32
|
|
}
|
|
|
|
func sameGeneral(a, b general) bool {
|
|
ar, ac := a.dims()
|
|
br, bc := b.dims()
|
|
if ar != br || ac != bc {
|
|
return false
|
|
}
|
|
for i := 0; i < ar; i++ {
|
|
for j := 0; j < ac; j++ {
|
|
if a.at(i, j) != b.at(i, j) || math.IsNaN(a.at(i, j)) != math.IsNaN(b.at(i, j)) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var generalTests = []General{
|
|
{Rows: 2, Cols: 3, Stride: 3, Data: []float32{
|
|
1, 2, 3,
|
|
4, 5, 6,
|
|
}},
|
|
{Rows: 3, Cols: 2, Stride: 2, Data: []float32{
|
|
1, 2,
|
|
3, 4,
|
|
5, 6,
|
|
}},
|
|
{Rows: 3, Cols: 3, Stride: 3, Data: []float32{
|
|
1, 2, 3,
|
|
4, 5, 6,
|
|
7, 8, 9,
|
|
}},
|
|
{Rows: 2, Cols: 3, Stride: 5, Data: []float32{
|
|
1, 2, 3, 0, 0,
|
|
4, 5, 6, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 2, Stride: 5, Data: []float32{
|
|
1, 2, 0, 0, 0,
|
|
3, 4, 0, 0, 0,
|
|
5, 6, 0, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 3, Stride: 5, Data: []float32{
|
|
1, 2, 3, 0, 0,
|
|
4, 5, 6, 0, 0,
|
|
7, 8, 9, 0, 0,
|
|
}},
|
|
}
|
|
|
|
func TestConvertGeneral(t *testing.T) {
|
|
for _, test := range generalTests {
|
|
colmajor := newGeneralColsFrom(test)
|
|
if !sameGeneral(colmajor, test) {
|
|
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
|
colmajor, test)
|
|
}
|
|
rowmajor := newGeneralFrom(colmajor)
|
|
if !sameGeneral(rowmajor, test) {
|
|
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
|
rowmajor, test)
|
|
}
|
|
}
|
|
}
|
|
|
|
func newTriangularFrom(a TriangularCols) Triangular {
|
|
t := Triangular{
|
|
N: a.N,
|
|
Stride: a.N,
|
|
Data: make([]float32, a.N*a.N),
|
|
Diag: a.Diag,
|
|
Uplo: a.Uplo,
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m Triangular) n() int { return m.N }
|
|
func (m Triangular) at(i, j int) float32 {
|
|
if m.Diag == blas.Unit && i == j {
|
|
return 1
|
|
}
|
|
if m.Uplo == blas.Lower && i < j && j < m.N {
|
|
return 0
|
|
}
|
|
if m.Uplo == blas.Upper && i > j {
|
|
return 0
|
|
}
|
|
return m.Data[i*m.Stride+j]
|
|
}
|
|
func (m Triangular) uplo() blas.Uplo { return m.Uplo }
|
|
func (m Triangular) diag() blas.Diag { return m.Diag }
|
|
|
|
func newTriangularColsFrom(a Triangular) TriangularCols {
|
|
t := TriangularCols{
|
|
N: a.N,
|
|
Stride: a.N,
|
|
Data: make([]float32, a.N*a.N),
|
|
Diag: a.Diag,
|
|
Uplo: a.Uplo,
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m TriangularCols) n() int { return m.N }
|
|
func (m TriangularCols) at(i, j int) float32 {
|
|
if m.Diag == blas.Unit && i == j {
|
|
return 1
|
|
}
|
|
if m.Uplo == blas.Lower && i < j {
|
|
return 0
|
|
}
|
|
if m.Uplo == blas.Upper && i > j && i < m.N {
|
|
return 0
|
|
}
|
|
return m.Data[i+j*m.Stride]
|
|
}
|
|
func (m TriangularCols) uplo() blas.Uplo { return m.Uplo }
|
|
func (m TriangularCols) diag() blas.Diag { return m.Diag }
|
|
|
|
type triangular interface {
|
|
n() int
|
|
at(i, j int) float32
|
|
uplo() blas.Uplo
|
|
diag() blas.Diag
|
|
}
|
|
|
|
func sameTriangular(a, b triangular) bool {
|
|
an := a.n()
|
|
bn := b.n()
|
|
if an != bn {
|
|
return false
|
|
}
|
|
for i := 0; i < an; i++ {
|
|
for j := 0; j < an; j++ {
|
|
if a.at(i, j) != b.at(i, j) || math.IsNaN(a.at(i, j)) != math.IsNaN(b.at(i, j)) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var triangularTests = []Triangular{
|
|
{N: 3, Stride: 3, Data: []float32{
|
|
1, 2, 3,
|
|
4, 5, 6,
|
|
7, 8, 9,
|
|
}},
|
|
{N: 3, Stride: 5, Data: []float32{
|
|
1, 2, 3, 0, 0,
|
|
4, 5, 6, 0, 0,
|
|
7, 8, 9, 0, 0,
|
|
}},
|
|
}
|
|
|
|
func TestConvertTriangular(t *testing.T) {
|
|
for _, test := range triangularTests {
|
|
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower, blas.All} {
|
|
for _, diag := range []blas.Diag{blas.Unit, blas.NonUnit} {
|
|
test.Uplo = uplo
|
|
test.Diag = diag
|
|
colmajor := newTriangularColsFrom(test)
|
|
if !sameTriangular(colmajor, test) {
|
|
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
|
colmajor, test)
|
|
}
|
|
rowmajor := newTriangularFrom(colmajor)
|
|
if !sameTriangular(rowmajor, test) {
|
|
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
|
rowmajor, test)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func newBandFrom(a BandCols) Band {
|
|
t := Band{
|
|
Rows: a.Rows,
|
|
Cols: a.Cols,
|
|
KL: a.KL,
|
|
KU: a.KU,
|
|
Stride: a.KL + a.KU + 1,
|
|
Data: make([]float32, a.Rows*(a.KL+a.KU+1)),
|
|
}
|
|
for i := range t.Data {
|
|
t.Data[i] = math.NaN()
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m Band) dims() (r, c int) { return m.Rows, m.Cols }
|
|
func (m Band) at(i, j int) float32 {
|
|
pj := j + m.KL - i
|
|
if pj < 0 || m.KL+m.KU+1 <= pj {
|
|
return 0
|
|
}
|
|
return m.Data[i*m.Stride+pj]
|
|
}
|
|
func (m Band) bandwidth() (kl, ku int) { return m.KL, m.KU }
|
|
|
|
func newBandColsFrom(a Band) BandCols {
|
|
t := BandCols{
|
|
Rows: a.Rows,
|
|
Cols: a.Cols,
|
|
KL: a.KL,
|
|
KU: a.KU,
|
|
Stride: a.KL + a.KU + 1,
|
|
Data: make([]float32, a.Cols*(a.KL+a.KU+1)),
|
|
}
|
|
for i := range t.Data {
|
|
t.Data[i] = math.NaN()
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m BandCols) dims() (r, c int) { return m.Rows, m.Cols }
|
|
func (m BandCols) at(i, j int) float32 {
|
|
pj := i + m.KU - j
|
|
if pj < 0 || m.KL+m.KU+1 <= pj {
|
|
return 0
|
|
}
|
|
return m.Data[j*m.Stride+pj]
|
|
}
|
|
func (m BandCols) bandwidth() (kl, ku int) { return m.KL, m.KU }
|
|
|
|
type band interface {
|
|
dims() (r, c int)
|
|
at(i, j int) float32
|
|
bandwidth() (kl, ku int)
|
|
}
|
|
|
|
func sameBand(a, b band) bool {
|
|
ar, ac := a.dims()
|
|
br, bc := b.dims()
|
|
if ar != br || ac != bc {
|
|
return false
|
|
}
|
|
akl, aku := a.bandwidth()
|
|
bkl, bku := b.bandwidth()
|
|
if akl != bkl || aku != bku {
|
|
return false
|
|
}
|
|
for i := 0; i < ar; i++ {
|
|
for j := 0; j < ac; j++ {
|
|
if a.at(i, j) != b.at(i, j) || math.IsNaN(a.at(i, j)) != math.IsNaN(b.at(i, j)) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var bandTests = []Band{
|
|
{Rows: 3, Cols: 4, KL: 0, KU: 0, Stride: 1, Data: []float32{
|
|
1,
|
|
2,
|
|
3,
|
|
}},
|
|
{Rows: 3, Cols: 3, KL: 0, KU: 0, Stride: 1, Data: []float32{
|
|
1,
|
|
2,
|
|
3,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 0, KU: 0, Stride: 1, Data: []float32{
|
|
1,
|
|
2,
|
|
3,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 0, KU: 1, Stride: 2, Data: []float32{
|
|
1, 2,
|
|
3, 4,
|
|
5, 6,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 0, KU: 1, Stride: 2, Data: []float32{
|
|
1, 2,
|
|
3, 4,
|
|
5, 6,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 1, KU: 1, Stride: 3, Data: []float32{
|
|
-1, 2, 3,
|
|
4, 5, 6,
|
|
7, 8, 9,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 1, KU: 1, Stride: 3, Data: []float32{
|
|
-1, 2, 3,
|
|
4, 5, 6,
|
|
7, 8, -2,
|
|
9, -3, -4,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 2, KU: 1, Stride: 4, Data: []float32{
|
|
-2, -1, 3, 4,
|
|
-3, 5, 6, 7,
|
|
8, 9, 10, 11,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 2, KU: 1, Stride: 4, Data: []float32{
|
|
-2, -1, 2, 3,
|
|
-3, 4, 5, 6,
|
|
7, 8, 9, -4,
|
|
10, 11, -5, -6,
|
|
}},
|
|
|
|
{Rows: 3, Cols: 4, KL: 0, KU: 0, Stride: 5, Data: []float32{
|
|
1, 0, 0, 0, 0,
|
|
2, 0, 0, 0, 0,
|
|
3, 0, 0, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 3, KL: 0, KU: 0, Stride: 5, Data: []float32{
|
|
1, 0, 0, 0, 0,
|
|
2, 0, 0, 0, 0,
|
|
3, 0, 0, 0, 0,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 0, KU: 0, Stride: 5, Data: []float32{
|
|
1, 0, 0, 0, 0,
|
|
2, 0, 0, 0, 0,
|
|
3, 0, 0, 0, 0,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 0, KU: 1, Stride: 5, Data: []float32{
|
|
1, 2, 0, 0, 0,
|
|
3, 4, 0, 0, 0,
|
|
5, 6, 0, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 0, KU: 1, Stride: 5, Data: []float32{
|
|
1, 2, 0, 0, 0,
|
|
3, 4, 0, 0, 0,
|
|
5, 6, 0, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 1, KU: 1, Stride: 5, Data: []float32{
|
|
-1, 2, 3, 0, 0,
|
|
4, 5, 6, 0, 0,
|
|
7, 8, 9, 0, 0,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 1, KU: 1, Stride: 5, Data: []float32{
|
|
-1, 2, 3, 0, 0,
|
|
4, 5, 6, 0, 0,
|
|
7, 8, -2, 0, 0,
|
|
9, -3, -4, 0, 0,
|
|
}},
|
|
{Rows: 3, Cols: 4, KL: 2, KU: 1, Stride: 5, Data: []float32{
|
|
-2, -1, 3, 4, 0,
|
|
-3, 5, 6, 7, 0,
|
|
8, 9, 10, 11, 0,
|
|
}},
|
|
{Rows: 4, Cols: 3, KL: 2, KU: 1, Stride: 5, Data: []float32{
|
|
-2, -1, 2, 3, 0,
|
|
-3, 4, 5, 6, 0,
|
|
7, 8, 9, -4, 0,
|
|
10, 11, -5, -6, 0,
|
|
}},
|
|
}
|
|
|
|
func TestConvertBand(t *testing.T) {
|
|
for _, test := range bandTests {
|
|
colmajor := newBandColsFrom(test)
|
|
if !sameBand(colmajor, test) {
|
|
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
|
colmajor, test)
|
|
}
|
|
rowmajor := newBandFrom(colmajor)
|
|
if !sameBand(rowmajor, test) {
|
|
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
|
rowmajor, test)
|
|
}
|
|
}
|
|
}
|
|
|
|
func newTriangularBandFrom(a TriangularBandCols) TriangularBand {
|
|
t := TriangularBand{
|
|
N: a.N,
|
|
K: a.K,
|
|
Stride: a.K + 1,
|
|
Data: make([]float32, a.N*(a.K+1)),
|
|
Uplo: a.Uplo,
|
|
Diag: a.Diag,
|
|
}
|
|
for i := range t.Data {
|
|
t.Data[i] = math.NaN()
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m TriangularBand) n() (n int) { return m.N }
|
|
func (m TriangularBand) at(i, j int) float32 {
|
|
if m.Diag == blas.Unit && i == j {
|
|
return 1
|
|
}
|
|
b := Band{
|
|
Rows: m.N, Cols: m.N,
|
|
Stride: m.Stride,
|
|
Data: m.Data,
|
|
}
|
|
switch m.Uplo {
|
|
default:
|
|
panic("blas32: bad BLAS uplo")
|
|
case blas.Upper:
|
|
if i > j {
|
|
return 0
|
|
}
|
|
b.KU = m.K
|
|
case blas.Lower:
|
|
if i < j {
|
|
return 0
|
|
}
|
|
b.KL = m.K
|
|
}
|
|
return b.at(i, j)
|
|
}
|
|
func (m TriangularBand) bandwidth() (k int) { return m.K }
|
|
func (m TriangularBand) uplo() blas.Uplo { return m.Uplo }
|
|
func (m TriangularBand) diag() blas.Diag { return m.Diag }
|
|
|
|
func newTriangularBandColsFrom(a TriangularBand) TriangularBandCols {
|
|
t := TriangularBandCols{
|
|
N: a.N,
|
|
K: a.K,
|
|
Stride: a.K + 1,
|
|
Data: make([]float32, a.N*(a.K+1)),
|
|
Uplo: a.Uplo,
|
|
Diag: a.Diag,
|
|
}
|
|
for i := range t.Data {
|
|
t.Data[i] = math.NaN()
|
|
}
|
|
t.From(a)
|
|
return t
|
|
}
|
|
|
|
func (m TriangularBandCols) n() (n int) { return m.N }
|
|
func (m TriangularBandCols) at(i, j int) float32 {
|
|
if m.Diag == blas.Unit && i == j {
|
|
return 1
|
|
}
|
|
b := BandCols{
|
|
Rows: m.N, Cols: m.N,
|
|
Stride: m.Stride,
|
|
Data: m.Data,
|
|
}
|
|
switch m.Uplo {
|
|
default:
|
|
panic("blas32: bad BLAS uplo")
|
|
case blas.Upper:
|
|
if i > j {
|
|
return 0
|
|
}
|
|
b.KU = m.K
|
|
case blas.Lower:
|
|
if i < j {
|
|
return 0
|
|
}
|
|
b.KL = m.K
|
|
}
|
|
return b.at(i, j)
|
|
}
|
|
func (m TriangularBandCols) bandwidth() (k int) { return m.K }
|
|
func (m TriangularBandCols) uplo() blas.Uplo { return m.Uplo }
|
|
func (m TriangularBandCols) diag() blas.Diag { return m.Diag }
|
|
|
|
type triangularBand interface {
|
|
n() (n int)
|
|
at(i, j int) float32
|
|
bandwidth() (k int)
|
|
uplo() blas.Uplo
|
|
diag() blas.Diag
|
|
}
|
|
|
|
func sameTriangularBand(a, b triangularBand) bool {
|
|
an := a.n()
|
|
bn := b.n()
|
|
if an != bn {
|
|
return false
|
|
}
|
|
if a.uplo() != b.uplo() {
|
|
return false
|
|
}
|
|
if a.diag() != b.diag() {
|
|
return false
|
|
}
|
|
ak := a.bandwidth()
|
|
bk := b.bandwidth()
|
|
if ak != bk {
|
|
return false
|
|
}
|
|
for i := 0; i < an; i++ {
|
|
for j := 0; j < an; j++ {
|
|
if a.at(i, j) != b.at(i, j) || math.IsNaN(a.at(i, j)) != math.IsNaN(b.at(i, j)) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var triangularBandTests = []TriangularBand{
|
|
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []float32{
|
|
1,
|
|
2,
|
|
3,
|
|
}},
|
|
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []float32{
|
|
1,
|
|
2,
|
|
3,
|
|
}},
|
|
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []float32{
|
|
1, 2,
|
|
3, 4,
|
|
5, -1,
|
|
}},
|
|
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []float32{
|
|
-1, 1,
|
|
2, 3,
|
|
4, 5,
|
|
}},
|
|
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []float32{
|
|
1, 2, 3,
|
|
4, 5, -1,
|
|
6, -2, -3,
|
|
}},
|
|
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []float32{
|
|
-2, -1, 1,
|
|
-3, 2, 4,
|
|
3, 5, 6,
|
|
}},
|
|
|
|
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []float32{
|
|
1, 0, 0, 0, 0,
|
|
2, 0, 0, 0, 0,
|
|
3, 0, 0, 0, 0,
|
|
}},
|
|
{N: 3, K: 0, Stride: 5, Uplo: blas.Lower, Data: []float32{
|
|
1, 0, 0, 0, 0,
|
|
2, 0, 0, 0, 0,
|
|
3, 0, 0, 0, 0,
|
|
}},
|
|
{N: 3, K: 1, Stride: 5, Uplo: blas.Upper, Data: []float32{
|
|
1, 2, 0, 0, 0,
|
|
3, 4, 0, 0, 0,
|
|
5, -1, 0, 0, 0,
|
|
}},
|
|
{N: 3, K: 1, Stride: 5, Uplo: blas.Lower, Data: []float32{
|
|
-1, 1, 0, 0, 0,
|
|
2, 3, 0, 0, 0,
|
|
4, 5, 0, 0, 0,
|
|
}},
|
|
{N: 3, K: 2, Stride: 5, Uplo: blas.Upper, Data: []float32{
|
|
1, 2, 3, 0, 0,
|
|
4, 5, -1, 0, 0,
|
|
6, -2, -3, 0, 0,
|
|
}},
|
|
{N: 3, K: 2, Stride: 5, Uplo: blas.Lower, Data: []float32{
|
|
-2, -1, 1, 0, 0,
|
|
-3, 2, 4, 0, 0,
|
|
3, 5, 6, 0, 0,
|
|
}},
|
|
}
|
|
|
|
func TestConvertTriBand(t *testing.T) {
|
|
for _, test := range triangularBandTests {
|
|
colmajor := newTriangularBandColsFrom(test)
|
|
if !sameTriangularBand(colmajor, test) {
|
|
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
|
colmajor, test)
|
|
}
|
|
rowmajor := newTriangularBandFrom(colmajor)
|
|
if !sameTriangularBand(rowmajor, test) {
|
|
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
|
rowmajor, test)
|
|
}
|
|
}
|
|
}
|