blas: add hermitian conversions

blas/blas32/conv.go

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

blas/blas32/conv_symmetric.go

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

blas/blas32/conv_symmetric_test.go

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

blas/blas32/conv_test.go

@@ -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,

blas/blas64/conv.go

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

blas/blas64/conv_symmetric.go

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

blas/blas64/conv_symmetric_test.go

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

blas/blas64/conv_test.go

@@ -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,

blas/cblas128/conv.go

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

blas/cblas128/conv_hermitian.go

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

blas/cblas128/conv_hermitian_test.go

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

blas/cblas128/conv_symmetric.go

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

blas/cblas128/conv_symmetric_test.go

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

blas/cblas128/conv_test.go

@@ -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,

blas/cblas64/conv.go

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

blas/cblas64/conv_hermitian.go

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

blas/cblas64/conv_hermitian_test.go

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

blas/cblas64/conv_test.go

@@ -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,

blas/conversions.bash

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