mirror of
https://github.com/gonum/gonum.git
synced 2025-10-07 16:11:03 +08:00
blas: add hermitian conversions
This commit is contained in:
kortschak
@@ -45,65 +45,6 @@ func (t General) From(a GeneralCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
@@ -230,93 +171,6 @@ func (t Band) From(a BandCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas32: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas32: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas32: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas32: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas32: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas32: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
|
||||
155
blas/blas32/conv_symmetric.go
Normal file
155
blas/blas32/conv_symmetric.go
Normal file
@@ -0,0 +1,155 @@
|
||||
// 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 "gonum.org/v1/gonum/blas"
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas32: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas32: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas32: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas32: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas32: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas32: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas32: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas32: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas32: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
307
blas/blas32/conv_symmetric_test.go
Normal file
307
blas/blas32/conv_symmetric_test.go
Normal file
@@ -0,0 +1,307 @@
|
||||
// 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 newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float32, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) float32 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float32, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) float32 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) float32
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{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 TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float32, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) float32 {
|
||||
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:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float32, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) float32 {
|
||||
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:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) float32
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{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 TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -108,108 +108,6 @@ func TestConvertGeneral(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float32, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) float32 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float32, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) float32 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) float32
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{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 TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(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,
|
||||
@@ -515,198 +413,6 @@ func TestConvertBand(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float32, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) float32 {
|
||||
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:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float32, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) float32 {
|
||||
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:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) float32
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{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 TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(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,
|
||||
|
||||
@@ -43,65 +43,6 @@ func (t General) From(a GeneralCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
@@ -228,93 +169,6 @@ func (t Band) From(a BandCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
|
||||
153
blas/blas64/conv_symmetric.go
Normal file
153
blas/blas64/conv_symmetric.go
Normal file
@@ -0,0 +1,153 @@
|
||||
// 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 blas64
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
305
blas/blas64/conv_symmetric_test.go
Normal file
305
blas/blas64/conv_symmetric_test.go
Normal file
@@ -0,0 +1,305 @@
|
||||
// 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 blas64
|
||||
|
||||
import (
|
||||
"math"
|
||||
"testing"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
)
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) float64 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) float64 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) float64
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{N: 3, Stride: 3, Data: []float64{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []float64{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) float64 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) float64 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) float64
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []float64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []float64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []float64{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []float64{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []float64{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []float64{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []float64{
|
||||
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: []float64{
|
||||
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: []float64{
|
||||
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: []float64{
|
||||
-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: []float64{
|
||||
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: []float64{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -106,108 +106,6 @@ func TestConvertGeneral(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) float64 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]float64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) float64 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) float64
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{N: 3, Stride: 3, Data: []float64{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []float64{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(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,
|
||||
@@ -513,198 +411,6 @@ func TestConvertBand(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) float64 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]float64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) float64 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) float64
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []float64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []float64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []float64{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []float64{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []float64{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []float64{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []float64{
|
||||
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: []float64{
|
||||
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: []float64{
|
||||
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: []float64{
|
||||
-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: []float64{
|
||||
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: []float64{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(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,
|
||||
|
||||
@@ -45,65 +45,6 @@ func (t General) From(a GeneralCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
@@ -230,93 +171,6 @@ func (t Band) From(a BandCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
|
||||
155
blas/cblas128/conv_hermitian.go
Normal file
155
blas/cblas128/conv_hermitian.go
Normal file
@@ -0,0 +1,155 @@
|
||||
// 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 cblas128
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// HermitianCols represents a matrix using the conventional column-major storage scheme.
|
||||
type HermitianCols Hermitian
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t HermitianCols) From(a Hermitian) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Hermitian) From(a HermitianCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HermitianBandCols represents an Hermitian matrix using the band column-major storage scheme.
|
||||
type HermitianBandCols HermitianBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBandCols) From(a HermitianBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBand) From(a HermitianBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
307
blas/cblas128/conv_hermitian_test.go
Normal file
307
blas/cblas128/conv_hermitian_test.go
Normal file
@@ -0,0 +1,307 @@
|
||||
// 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 cblas128
|
||||
|
||||
import (
|
||||
math "math/cmplx"
|
||||
"testing"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
)
|
||||
|
||||
func newHermitianFrom(a HermitianCols) Hermitian {
|
||||
t := Hermitian{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Hermitian) n() int { return m.N }
|
||||
func (m Hermitian) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Hermitian) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newHermitianColsFrom(a Hermitian) HermitianCols {
|
||||
t := HermitianCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianCols) n() int { return m.N }
|
||||
func (m HermitianCols) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m HermitianCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type hermitian interface {
|
||||
n() int
|
||||
at(i, j int) complex128
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalHermitian(a, b hermitian) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 hermitianTests = []Hermitian{
|
||||
{N: 3, Stride: 3, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []complex128{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertHermitian(t *testing.T) {
|
||||
for _, test := range hermitianTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newHermitianColsFrom(test)
|
||||
if !equalHermitian(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newHermitianFrom(colmajor)
|
||||
if !equalHermitian(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func newHermitianBandFrom(a HermitianBandCols) HermitianBand {
|
||||
t := HermitianBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianBand) n() (n int) { return m.N }
|
||||
func (m HermitianBand) at(i, j int) complex128 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m HermitianBand) bandwidth() (k int) { return m.K }
|
||||
func (m HermitianBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newHermitianBandColsFrom(a HermitianBand) HermitianBandCols {
|
||||
t := HermitianBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianBandCols) n() (n int) { return m.N }
|
||||
func (m HermitianBandCols) at(i, j int) complex128 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m HermitianBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m HermitianBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type hermitianBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) complex128
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalHermitianBand(a, b hermitianBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 hermitianBandTests = []HermitianBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []complex128{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []complex128{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
-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: []complex128{
|
||||
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: []complex128{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertHermBand(t *testing.T) {
|
||||
for _, test := range hermitianBandTests {
|
||||
colmajor := newHermitianBandColsFrom(test)
|
||||
if !equalHermitianBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newHermitianBandFrom(colmajor)
|
||||
if !equalHermitianBand(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
155
blas/cblas128/conv_symmetric.go
Normal file
155
blas/cblas128/conv_symmetric.go
Normal file
@@ -0,0 +1,155 @@
|
||||
// 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 cblas128
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
307
blas/cblas128/conv_symmetric_test.go
Normal file
307
blas/cblas128/conv_symmetric_test.go
Normal file
@@ -0,0 +1,307 @@
|
||||
// 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 cblas128
|
||||
|
||||
import (
|
||||
math "math/cmplx"
|
||||
"testing"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
)
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) complex128
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{N: 3, Stride: 3, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []complex128{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) complex128 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) complex128 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) complex128
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []complex128{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []complex128{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
-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: []complex128{
|
||||
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: []complex128{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -108,108 +108,6 @@ func TestConvertGeneral(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex128, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) complex128 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) complex128
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{N: 3, Stride: 3, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []complex128{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(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,
|
||||
@@ -515,198 +413,6 @@ func TestConvertBand(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) complex128 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex128, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) complex128 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) complex128
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []complex128{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []complex128{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []complex128{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []complex128{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
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: []complex128{
|
||||
-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: []complex128{
|
||||
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: []complex128{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(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,
|
||||
|
||||
@@ -45,65 +45,6 @@ func (t General) From(a GeneralCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
@@ -230,93 +171,6 @@ func (t Band) From(a BandCols) {
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
|
||||
155
blas/cblas64/conv_hermitian.go
Normal file
155
blas/cblas64/conv_hermitian.go
Normal file
@@ -0,0 +1,155 @@
|
||||
// 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 cblas64
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// HermitianCols represents a matrix using the conventional column-major storage scheme.
|
||||
type HermitianCols Hermitian
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t HermitianCols) From(a Hermitian) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Hermitian) From(a HermitianCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HermitianBandCols represents an Hermitian matrix using the band column-major storage scheme.
|
||||
type HermitianBandCols HermitianBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBandCols) From(a HermitianBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBand) From(a HermitianBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
307
blas/cblas64/conv_hermitian_test.go
Normal file
307
blas/cblas64/conv_hermitian_test.go
Normal file
@@ -0,0 +1,307 @@
|
||||
// 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 cblas64
|
||||
|
||||
import (
|
||||
math "gonum.org/v1/gonum/internal/cmplx64"
|
||||
"testing"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
)
|
||||
|
||||
func newHermitianFrom(a HermitianCols) Hermitian {
|
||||
t := Hermitian{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Hermitian) n() int { return m.N }
|
||||
func (m Hermitian) at(i, j int) complex64 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Hermitian) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newHermitianColsFrom(a Hermitian) HermitianCols {
|
||||
t := HermitianCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianCols) n() int { return m.N }
|
||||
func (m HermitianCols) at(i, j int) complex64 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m HermitianCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type hermitian interface {
|
||||
n() int
|
||||
at(i, j int) complex64
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalHermitian(a, b hermitian) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 hermitianTests = []Hermitian{
|
||||
{N: 3, Stride: 3, Data: []complex64{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []complex64{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertHermitian(t *testing.T) {
|
||||
for _, test := range hermitianTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newHermitianColsFrom(test)
|
||||
if !equalHermitian(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newHermitianFrom(colmajor)
|
||||
if !equalHermitian(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func newHermitianBandFrom(a HermitianBandCols) HermitianBand {
|
||||
t := HermitianBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianBand) n() (n int) { return m.N }
|
||||
func (m HermitianBand) at(i, j int) complex64 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m HermitianBand) bandwidth() (k int) { return m.K }
|
||||
func (m HermitianBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newHermitianBandColsFrom(a HermitianBand) HermitianBandCols {
|
||||
t := HermitianBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m HermitianBandCols) n() (n int) { return m.N }
|
||||
func (m HermitianBandCols) at(i, j int) complex64 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m HermitianBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m HermitianBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type hermitianBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) complex64
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalHermitianBand(a, b hermitianBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 hermitianBandTests = []HermitianBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []complex64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []complex64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []complex64{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []complex64{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []complex64{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []complex64{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []complex64{
|
||||
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: []complex64{
|
||||
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: []complex64{
|
||||
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: []complex64{
|
||||
-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: []complex64{
|
||||
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: []complex64{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertHermBand(t *testing.T) {
|
||||
for _, test := range hermitianBandTests {
|
||||
colmajor := newHermitianBandColsFrom(test)
|
||||
if !equalHermitianBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newHermitianBandFrom(colmajor)
|
||||
if !equalHermitianBand(rowmajor, test) {
|
||||
t.Errorf("unexpected result for col major to row major conversion:\n\tgot: %#v\n\twant:%#v",
|
||||
rowmajor, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -108,108 +108,6 @@ func TestConvertGeneral(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricFrom(a SymmetricCols) Symmetric {
|
||||
t := Symmetric{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m Symmetric) n() int { return m.N }
|
||||
func (m Symmetric) at(i, j int) complex64 {
|
||||
if m.Uplo == blas.Lower && i < j && j < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i*m.Stride+j]
|
||||
}
|
||||
func (m Symmetric) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricColsFrom(a Symmetric) SymmetricCols {
|
||||
t := SymmetricCols{
|
||||
N: a.N,
|
||||
Stride: a.N,
|
||||
Data: make([]complex64, a.N*a.N),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricCols) n() int { return m.N }
|
||||
func (m SymmetricCols) at(i, j int) complex64 {
|
||||
if m.Uplo == blas.Lower && i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
if m.Uplo == blas.Upper && i > j && i < m.N {
|
||||
i, j = j, i
|
||||
}
|
||||
return m.Data[i+j*m.Stride]
|
||||
}
|
||||
func (m SymmetricCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetric interface {
|
||||
n() int
|
||||
at(i, j int) complex64
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetric(a, b symmetric) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricTests = []Symmetric{
|
||||
{N: 3, Stride: 3, Data: []complex64{
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
7, 8, 9,
|
||||
}},
|
||||
{N: 3, Stride: 5, Data: []complex64{
|
||||
1, 2, 3, 0, 0,
|
||||
4, 5, 6, 0, 0,
|
||||
7, 8, 9, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymmetric(t *testing.T) {
|
||||
for _, test := range symmetricTests {
|
||||
for _, uplo := range []blas.Uplo{blas.Upper, blas.Lower} {
|
||||
test.Uplo = uplo
|
||||
colmajor := newSymmetricColsFrom(test)
|
||||
if !equalSymmetric(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricFrom(colmajor)
|
||||
if !equalSymmetric(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,
|
||||
@@ -515,198 +413,6 @@ func TestConvertBand(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func newSymmetricBandFrom(a SymmetricBandCols) SymmetricBand {
|
||||
t := SymmetricBand{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBand) n() (n int) { return m.N }
|
||||
func (m SymmetricBand) at(i, j int) complex64 {
|
||||
b := Band{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBand) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBand) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
func newSymmetricBandColsFrom(a SymmetricBand) SymmetricBandCols {
|
||||
t := SymmetricBandCols{
|
||||
N: a.N,
|
||||
K: a.K,
|
||||
Stride: a.K + 1,
|
||||
Data: make([]complex64, a.N*(a.K+1)),
|
||||
Uplo: a.Uplo,
|
||||
}
|
||||
for i := range t.Data {
|
||||
t.Data[i] = math.NaN()
|
||||
}
|
||||
t.From(a)
|
||||
return t
|
||||
}
|
||||
|
||||
func (m SymmetricBandCols) n() (n int) { return m.N }
|
||||
func (m SymmetricBandCols) at(i, j int) complex64 {
|
||||
b := BandCols{
|
||||
Rows: m.N, Cols: m.N,
|
||||
Stride: m.Stride,
|
||||
Data: m.Data,
|
||||
}
|
||||
switch m.Uplo {
|
||||
default:
|
||||
panic("cblas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
b.KU = m.K
|
||||
if i > j {
|
||||
i, j = j, i
|
||||
}
|
||||
case blas.Lower:
|
||||
b.KL = m.K
|
||||
if i < j {
|
||||
i, j = j, i
|
||||
}
|
||||
}
|
||||
return b.at(i, j)
|
||||
}
|
||||
func (m SymmetricBandCols) bandwidth() (k int) { return m.K }
|
||||
func (m SymmetricBandCols) uplo() blas.Uplo { return m.Uplo }
|
||||
|
||||
type symmetricBand interface {
|
||||
n() (n int)
|
||||
at(i, j int) complex64
|
||||
bandwidth() (k int)
|
||||
uplo() blas.Uplo
|
||||
}
|
||||
|
||||
func equalSymmetricBand(a, b symmetricBand) bool {
|
||||
an := a.n()
|
||||
bn := b.n()
|
||||
if an != bn {
|
||||
return false
|
||||
}
|
||||
if a.uplo() != b.uplo() {
|
||||
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 symmetricBandTests = []SymmetricBand{
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Upper, Data: []complex64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 0, Stride: 1, Uplo: blas.Lower, Data: []complex64{
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Upper, Data: []complex64{
|
||||
1, 2,
|
||||
3, 4,
|
||||
5, -1,
|
||||
}},
|
||||
{N: 3, K: 1, Stride: 2, Uplo: blas.Lower, Data: []complex64{
|
||||
-1, 1,
|
||||
2, 3,
|
||||
4, 5,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Upper, Data: []complex64{
|
||||
1, 2, 3,
|
||||
4, 5, -1,
|
||||
6, -2, -3,
|
||||
}},
|
||||
{N: 3, K: 2, Stride: 3, Uplo: blas.Lower, Data: []complex64{
|
||||
-2, -1, 1,
|
||||
-3, 2, 4,
|
||||
3, 5, 6,
|
||||
}},
|
||||
|
||||
{N: 3, K: 0, Stride: 5, Uplo: blas.Upper, Data: []complex64{
|
||||
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: []complex64{
|
||||
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: []complex64{
|
||||
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: []complex64{
|
||||
-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: []complex64{
|
||||
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: []complex64{
|
||||
-2, -1, 1, 0, 0,
|
||||
-3, 2, 4, 0, 0,
|
||||
3, 5, 6, 0, 0,
|
||||
}},
|
||||
}
|
||||
|
||||
func TestConvertSymBand(t *testing.T) {
|
||||
for _, test := range symmetricBandTests {
|
||||
colmajor := newSymmetricBandColsFrom(test)
|
||||
if !equalSymmetricBand(colmajor, test) {
|
||||
t.Errorf("unexpected result for row major to col major conversion:\n\tgot: %#v\n\tfrom:%#v",
|
||||
colmajor, test)
|
||||
}
|
||||
rowmajor := newSymmetricBandFrom(colmajor)
|
||||
if !equalSymmetricBand(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,
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
# Use of this source code is governed by a BSD-style
|
||||
# license that can be found in the LICENSE file.
|
||||
|
||||
# Generate code for blas32.
|
||||
echo Generating blas32/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv.go
|
||||
cat blas64/conv.go \
|
||||
@@ -23,6 +24,27 @@ cat blas64/conv_test.go \
|
||||
\
|
||||
>> blas32/conv_test.go
|
||||
|
||||
echo Generating blas32/conv_symmetric.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv_symmetric.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
\
|
||||
>> blas32/conv_symmetric.go
|
||||
|
||||
echo Generating blas32/conv_symmetric_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv_symmetric_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/math32"_' \
|
||||
\
|
||||
>> blas32/conv_symmetric_test.go
|
||||
|
||||
|
||||
# Generate code for cblas128.
|
||||
echo Generating cblas128/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv.go
|
||||
cat blas64/conv.go \
|
||||
@@ -42,6 +64,54 @@ cat blas64/conv_test.go \
|
||||
\
|
||||
>> cblas128/conv_test.go
|
||||
|
||||
echo Generating cblas128/conv_symmetric.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_symmetric.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
\
|
||||
>> cblas128/conv_symmetric.go
|
||||
|
||||
echo Generating cblas128/conv_symmetric_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_symmetric_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's_"math"_math "math/cmplx"_' \
|
||||
\
|
||||
>> cblas128/conv_symmetric_test.go
|
||||
|
||||
echo Generating cblas128/conv_hermitian.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_hermitian.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
\
|
||||
>> cblas128/conv_hermitian.go
|
||||
|
||||
echo Generating cblas128/conv_hermitian_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_hermitian_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
-e 's_"math"_math "math/cmplx"_' \
|
||||
\
|
||||
>> cblas128/conv_hermitian_test.go
|
||||
|
||||
|
||||
# Generate code for cblas64.
|
||||
echo Generating cblas64/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv.go
|
||||
cat blas64/conv.go \
|
||||
@@ -60,3 +130,30 @@ cat blas64/conv_test.go \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
\
|
||||
>> cblas64/conv_test.go
|
||||
|
||||
echo Generating cblas64/conv_hermitian.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv_hermitian.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
\
|
||||
>> cblas64/conv_hermitian.go
|
||||
|
||||
echo Generating cblas64/conv_hermitian_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv_hermitian_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
\
|
||||
>> cblas64/conv_hermitian_test.go
|
||||
|
||||
Reference in New Issue
Block a user