func NewBandDense(r, c, kl, ku int, data []float64) *BandDense {
	if r < 0 || c < 0 || kl < 0 || ku < 0 {
		panic("mat: negative dimension")
	}
	if kl+1 > r || ku+1 > c {
		panic("mat: band out of range")
	}
	bc := kl + ku + 1
	if data != nil && len(data) != min(r, c+kl)*bc {
		panic(ErrShape)
	}
	if data == nil {
		data = make([]float64, min(r, c+kl)*bc)
	}
	return &BandDense{
		mat: blas64.Band{
			Rows:   r,
			Cols:   c,
			KL:     kl,
			KU:     ku,
			Stride: bc,
			Data:   data,
		},
	}
}
NewBandDense creates a new Band matrix with r rows and c columns. If data == nil,
a new slice is allocated for the backing slice. If len(data) == min(r, c+kl)*(kl+ku+1),
data is used as the backing slice, and changes to the elements of the returned
BandDense will be reflected in data. If neither of these is true, NewBandDense
will panic. kl must be at least zero and less r, and ku must be at least zero and
less than c, otherwise NewBandDense 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. For example, the matrix
1  2  3  0  0  0
4  5  6  7  0  0
0  8  9 10 11  0
0  0 12 13 14 15
0  0  0 16 17 18
0  0  0  0 19 20
becomes (* entries are never accessed)
*  1  2  3
4  5  6  7
8  9 10 11
12 13 14 15
16 17 18  *
19 20  *  *
which is passed to NewBandDense as []float64{*, 1, 2, 3, 4, ...} with kl=1 and ku=2.
Only the values in the band portion of the matrix are used.
package mat
import (
	"gonum.org/v1/gonum/blas/blas64"
)
var (
	bandDense *BandDense
	_         Matrix    = bandDense
	_         Banded    = bandDense
	_         RawBander = bandDense
	_ NonZeroDoer    = bandDense
	_ RowNonZeroDoer = bandDense
	_ ColNonZeroDoer = bandDense
)
type BandDense struct {
	mat blas64.Band
}
type Banded interface {
	Matrix
	Bandwidth() (kl, ku int)
	TBand() Banded
}
type RawBander interface {
	RawBand() blas64.Band
}
type MutableBanded interface {
	Banded
	SetBand(i, j int, v float64)
}
var (
	_ Matrix            = TransposeBand{}
	_ Banded            = TransposeBand{}
	_ UntransposeBander = TransposeBand{}
)
type TransposeBand struct {
	Banded Banded
}
func (t TransposeBand) At(i, j int) float64 {
	return t.Banded.At(j, i)
}
func (t TransposeBand) Dims() (r, c int) {
	c, r = t.Banded.Dims()
	return r, c
}
func (t TransposeBand) T() Matrix {
	return t.Banded
}
func (t TransposeBand) Bandwidth() (kl, ku int) {
	kl, ku = t.Banded.Bandwidth()
	return ku, kl
}
func (t TransposeBand) TBand() Banded {
	return t.Banded
}
func (t TransposeBand) Untranspose() Matrix {
	return t.Banded
}
func (t TransposeBand) UntransposeBand() Banded {
	return t.Banded
}