func Gemm(tA, tB blas.Transpose, alpha complex64, a, b General, beta complex64, 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
	}
	cblas64.Cgemm(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 or conjugated.
package cblas64
import (
	"gonum.org/v1/gonum/blas"
	"gonum.org/v1/gonum/blas/gonum"
)
var cblas64 blas.Complex64 = gonum.Implementation{}
func Use(b blas.Complex64) {
	cblas64 = b
}
func Implementation() blas.Complex64 {
	return cblas64
}
type Vector struct {
	Inc  int
	Data []complex64
}
type General struct {
	Rows, Cols int
	Stride     int
	Data       []complex64
}
type Band struct {
	Rows, Cols int
	KL, KU     int
	Stride     int
	Data       []complex64
}
type Triangular struct {
	N      int
	Stride int
	Data   []complex64
	Uplo   blas.Uplo
	Diag   blas.Diag
}
type TriangularBand struct {
	N, K   int
	Stride int
	Data   []complex64
	Uplo   blas.Uplo
	Diag   blas.Diag
}
type TriangularPacked struct {
	N    int
	Data []complex64
	Uplo blas.Uplo
	Diag blas.Diag
}
type Symmetric struct {
	N      int
	Stride int
	Data   []complex64
	Uplo   blas.Uplo
}
type SymmetricBand struct {
	N, K   int
	Stride int
	Data   []complex64
	Uplo   blas.Uplo
}
type SymmetricPacked struct {
	N    int
	Data []complex64
	Uplo blas.Uplo
}
type Hermitian Symmetric
type HermitianBand SymmetricBand
type HermitianPacked SymmetricPacked
const negInc = "cblas64: negative vector increment"
func Dotu(n int, x, y Vector) complex64 {
	return cblas64.Cdotu(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Dotc(n int, x, y Vector) complex64 {
	return cblas64.Cdotc(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Nrm2(n int, x Vector) float32 {
	if x.Inc < 0 {
		panic(negInc)
	}
	return cblas64.Scnrm2(n, x.Data, x.Inc)
}
func Asum(n int, x Vector) float32 {
	if x.Inc < 0 {
		panic(negInc)
	}
	return cblas64.Scasum(n, x.Data, x.Inc)
}
func Iamax(n int, x Vector) int {
	if x.Inc < 0 {
		panic(negInc)
	}
	return cblas64.Icamax(n, x.Data, x.Inc)
}
func Swap(n int, x, y Vector) {
	cblas64.Cswap(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Copy(n int, x, y Vector) {
	cblas64.Ccopy(n, x.Data, x.Inc, y.Data, y.Inc)
}
func Axpy(n int, alpha complex64, x, y Vector) {
	cblas64.Caxpy(n, alpha, x.Data, x.Inc, y.Data, y.Inc)
}
func Scal(n int, alpha complex64, x Vector) {
	if x.Inc < 0 {
		panic(negInc)
	}
	cblas64.Cscal(n, alpha, x.Data, x.Inc)
}
func Dscal(n int, alpha float32, x Vector) {
	if x.Inc < 0 {
		panic(negInc)
	}
	cblas64.Csscal(n, alpha, x.Data, x.Inc)
}
func Gemv(t blas.Transpose, alpha complex64, a General, x Vector, beta complex64, y Vector) {
	cblas64.Cgemv(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 complex64, a Band, x Vector, beta complex64, y Vector) {
	cblas64.Cgbmv(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) {
	cblas64.Ctrmv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
}
func Tbmv(t blas.Transpose, a TriangularBand, x Vector) {
	cblas64.Ctbmv(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) {
	cblas64.Ctpmv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
}
func Trsv(t blas.Transpose, a Triangular, x Vector) {
	cblas64.Ctrsv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
}
func Tbsv(t blas.Transpose, a TriangularBand, x Vector) {
	cblas64.Ctbsv(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) {
	cblas64.Ctpsv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
}
func Hemv(alpha complex64, a Hermitian, x Vector, beta complex64, y Vector) {
	cblas64.Chemv(a.Uplo, a.N, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Hbmv(alpha complex64, a HermitianBand, x Vector, beta complex64, y Vector) {
	cblas64.Chbmv(a.Uplo, a.N, a.K, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Hpmv(alpha complex64, a HermitianPacked, x Vector, beta complex64, y Vector) {
	cblas64.Chpmv(a.Uplo, a.N, alpha, a.Data, x.Data, x.Inc, beta, y.Data, y.Inc)
}
func Geru(alpha complex64, x, y Vector, a General) {
	cblas64.Cgeru(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
}
func Gerc(alpha complex64, x, y Vector, a General) {
	cblas64.Cgerc(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
}
func Her(alpha float32, x Vector, a Hermitian) {
	cblas64.Cher(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data, a.Stride)
}
func Hpr(alpha float32, x Vector, a HermitianPacked) {
	cblas64.Chpr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data)
}
func Her2(alpha complex64, x, y Vector, a Hermitian) {
	cblas64.Cher2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
}
func Hpr2(alpha complex64, x, y Vector, a HermitianPacked) {
	cblas64.Chpr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data)
}