func Gemm(tA, tB blas.Transpose, alpha float64, a, b General, beta float64, c General) {
	var m, n, k int
	if tA == blas.NoTrans {
		m, k = a.Rows, a.Cols
	} else {
		m, k = a.Cols, a.Rows
	}
	if tB == blas.NoTrans {
		n = b.Cols
	} else {
		n = b.Rows
	}
	blas64.Dgemm(tA, tB, m, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
}
Level 3
Gemm computes
C = alpha * A * B + beta * C,
where A, B, and C are dense matrices, and alpha and beta are scalars.
tA and tB specify whether A or B are transposed.
package blas64
import (
	"gonum.org/v1/gonum/blas"
	"gonum.org/v1/gonum/blas/gonum"
)
var blas64 blas.Float64 = gonum.Implementation{}
func Use(b blas.Float64) {
	blas64 = b
}
func Implementation() blas.Float64 {
	return blas64
}
type Vector struct {
	Inc  int
	Data []float64
}
type General struct {
	Rows, Cols int
	Stride     int
	Data       []float64
}
type Band struct {
	Rows, Cols int
	KL, KU     int
	Stride     int
	Data       []float64
}
type Triangular struct {
	N      int
	Stride int
	Data   []float64
	Uplo   blas.Uplo
	Diag   blas.Diag
}
type TriangularBand struct {
	N, K   int
	Stride int
	Data   []float64
	Uplo   blas.Uplo
	Diag   blas.Diag
}
type TriangularPacked struct {
	N    int
	Data []float64
	Uplo blas.Uplo
	Diag blas.Diag
}
type Symmetric struct {
	N      int
	Stride int
	Data   []float64
	Uplo   blas.Uplo
}
type SymmetricBand struct {
	N, K   int
	Stride int
	Data   []float64
	Uplo   blas.Uplo
}
type SymmetricPacked struct {
	N    int
	Data []float64
	Uplo blas.Uplo
}
const negInc = "blas64: negative vector increment"
func Dot(n int, x, y Vector) float64 {
	return blas64.Ddot(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Nrm2(n int, x Vector) float64 {
	if x.Inc < 0 {
		panic(negInc)
	}
	return blas64.Dnrm2(n, x.Data, x.Inc)
}
func Asum(n int, x Vector) float64 {
	if x.Inc < 0 {
		panic(negInc)
	}
	return blas64.Dasum(n, x.Data, x.Inc)
}
func Iamax(n int, x Vector) int {
	if x.Inc < 0 {
		panic(negInc)
	}
	return blas64.Idamax(n, x.Data, x.Inc)
}
func Swap(n int, x, y Vector) {
	blas64.Dswap(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Copy(n int, x, y Vector) {
	blas64.Dcopy(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Axpy(n int, alpha float64, x, y Vector) {
	blas64.Daxpy(n, alpha, x.Data, x.Inc, y.Data, y.Inc)
}
func Rotg(a, b float64) (c, s, r, z float64) {
	return blas64.Drotg(a, b)
}
func Rotmg(d1, d2, b1, b2 float64) (p blas.DrotmParams, rd1, rd2, rb1 float64) {
	return blas64.Drotmg(d1, d2, b1, b2)
}
func Rot(n int, x, y Vector, c, s float64) {
	blas64.Drot(n, x.Data, x.Inc, y.Data, y.Inc, c, s)
}
func Rotm(n int, x, y Vector, p blas.DrotmParams) {
	blas64.Drotm(n, x.Data, x.Inc, y.Data, y.Inc, p)
}
func Scal(n int, alpha float64, x Vector) {
	if x.Inc < 0 {
		panic(negInc)
	}
	blas64.Dscal(n, alpha, x.Data, x.Inc)
}
func Gemv(t blas.Transpose, alpha float64, a General, x Vector, beta float64, y Vector) {
	blas64.Dgemv(t, a.Rows, a.Cols, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Gbmv(t blas.Transpose, alpha float64, a Band, x Vector, beta float64, y Vector) {
	blas64.Dgbmv(t, a.Rows, a.Cols, a.KL, a.KU, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Trmv(t blas.Transpose, a Triangular, x Vector) {
	blas64.Dtrmv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
}
func Tbmv(t blas.Transpose, a TriangularBand, x Vector) {
	blas64.Dtbmv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
}
func Tpmv(t blas.Transpose, a TriangularPacked, x Vector) {
	blas64.Dtpmv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
}
func Trsv(t blas.Transpose, a Triangular, x Vector) {
	blas64.Dtrsv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
}
func Tbsv(t blas.Transpose, a TriangularBand, x Vector) {
	blas64.Dtbsv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
}
func Tpsv(t blas.Transpose, a TriangularPacked, x Vector) {
	blas64.Dtpsv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
}
func Symv(alpha float64, a Symmetric, x Vector, beta float64, y Vector) {
	blas64.Dsymv(a.Uplo, a.N, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Sbmv(alpha float64, a SymmetricBand, x Vector, beta float64, y Vector) {
	blas64.Dsbmv(a.Uplo, a.N, a.K, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Spmv(alpha float64, a SymmetricPacked, x Vector, beta float64, y Vector) {
	blas64.Dspmv(a.Uplo, a.N, alpha, a.Data, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Ger(alpha float64, x, y Vector, a General) {
	blas64.Dger(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
}
func Syr(alpha float64, x Vector, a Symmetric) {
	blas64.Dsyr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data, a.Stride)
}
func Spr(alpha float64, x Vector, a SymmetricPacked) {
	blas64.Dspr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data)
}
func Syr2(alpha float64, x, y Vector, a Symmetric) {
	blas64.Dsyr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
}
func Spr2(alpha float64, x, y Vector, a SymmetricPacked) {
	blas64.Dspr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data)
}