func NewSymBandDense(n, k int, data []float64) *SymBandDense {
	if n <= 0 || k < 0 {
		if n == 0 {
			panic(ErrZeroLength)
		}
		panic("mat: negative dimension")
	}
	if k+1 > n {
		panic("mat: band out of range")
	}
	bc := k + 1
	if data != nil && len(data) != n*bc {
		panic(ErrShape)
	}
	if data == nil {
		data = make([]float64, n*bc)
	}
	return &SymBandDense{
		mat: blas64.SymmetricBand{
			N:      n,
			K:      k,
			Stride: bc,
			Uplo:   blas.Upper,
			Data:   data,
		},
	}
}
NewSymBandDense creates a new SymBand matrix with n rows and columns. If data == nil,
a new slice is allocated for the backing slice. If len(data) == n*(k+1),
data is used as the backing slice, and changes to the elements of the returned
SymBandDense will be reflected in data. If neither of these is true, NewSymBandDense
will panic. k must be at least zero and less than n, otherwise NewSymBandDense will panic.

The data must be arranged in row-major order constructed by removing the zeros
from the rows outside the band and aligning the diagonals. SymBandDense matrices
are stored in the upper triangle. For example, the matrix
1  2  3  0  0  0
2  4  5  6  0  0
3  5  7  8  9  0
0  6  8 10 11 12
0  0  9 11 13 14
0  0  0 12 14 15
becomes (* entries are never accessed)
1  2  3
4  5  6
7  8  9
10 11 12
13 14  *
15  *  *
which is passed to NewSymBandDense as []float64{1, 2, ..., 15, *, *, *} with k=2.
Only the values in the band portion of the matrix are used.
package mat
import (
	"gonum.org/v1/gonum/blas"
	"gonum.org/v1/gonum/blas/blas64"
)
var (
	symBandDense *SymBandDense
	_            Matrix           = symBandDense
	_            Symmetric        = symBandDense
	_            Banded           = symBandDense
	_            SymBanded        = symBandDense
	_            RawSymBander     = symBandDense
	_            MutableSymBanded = symBandDense
	_ NonZeroDoer    = symBandDense
	_ RowNonZeroDoer = symBandDense
	_ ColNonZeroDoer = symBandDense
)
type SymBandDense struct {
	mat blas64.SymmetricBand
}
type SymBanded interface {
	Banded
	Symmetric() int
	SymBand() (n, k int)
}
type MutableSymBanded interface {
	SymBanded
	SetSymBand(i, j int, v float64)
}
type RawSymBander interface {
	RawSymBand() blas64.SymmetricBand
}