testblas

package
v0.8.1-0...-a25970e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 17, 2021 License: BSD-3-Clause Imports: 8 Imported by: 0

Documentation

Overview

Package testblas provides tests for blas implementations.

Index

Constants

View Source 
const (
	SmallMat  = 10
	MediumMat = 100
	LargeMat  = 1000
	HugeMat   = 10000
)

Variables

View Source 
var DgemmCases = []DgemmCase{

	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
}
View Source 
var DgemvCases = []DgemvCase{
	{
		Name: "M_gt_N_Inc1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_gt_N_Inc1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_eq_N_Inc1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_eq_N_Inc1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_lt_N_Inc1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1, 10, 7},
			{9.6, 3.5, 9.1, -2, 9},
			{10, 7, 3, 1, -5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},

			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_lt_N_Inc1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1, 10, 7},
			{9.6, 3.5, 9.1, -2, 9},
			{10, 7, 3, 1, -5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_gt_N_Part1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_gt_N_Part1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_gt_N_IncNot1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_gt_N_IncNot1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
			{1, 1, 2},
			{9, 2, 5},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_eq_N_IncNot1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_eq_N_IncNot1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1},
			{9.6, 3.5, 9.1},
			{10, 7, 3},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_lt_N_IncNot1_NoTrans",

		A: [][]float64{
			{4.1, 6.2, 8.1, 10, 11},
			{9.6, 3.5, 9.1, -3, -2},
			{10, 7, 3, -7, -4},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_lt_N_IncNot1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1, 10, 11},
			{9.6, 3.5, 9.1, -3, -2},
			{10, 7, 3, -7, -4},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
	{
		Name: "M_eq_N_Lg_IncNot1_Trans",

		A: [][]float64{
			{4.1, 6.2, 8.1, 2.5, 3.3, 7.4, 9.3},
			{9.6, 3.5, 9.1, 1.2, 5.4, 4.8, 8.7},
			{10, 7, 3, 2, 4, 1, 12},
			{9.6, 3.5, 9.1, 1.2, 5.4, 4.8, 8.7},
			{4.1, 6.2, 8.1, 2.5, 3.3, 7.4, 9.3},
			{10, 7, 3, 2, 4, 1, 12},
			{9.6, 3.5, 9.1, 1.2, 5.4, 4.8, 8.7},
		},

		Subcases: []DgemvSubcase{
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
			{
				// contains filtered or unexported fields
			},
		},
		// contains filtered or unexported fields
	},
}
View Source 
var DoubleOneVectorCases = []DoubleOneVectorCase{
	{
		Name:   "AllPositive",
		X:      []float64{6, 5, 4, 2, 6},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  23,
		Dnrm2:  10.81665382639196787935766380241148783875388972153573863813135,
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: 0,
				Ans:   []float64{0, 0, 0, 0, 0},
			},
			{
				Alpha: 1,
				Ans:   []float64{6, 5, 4, 2, 6},
			},
			{
				Alpha: -2,
				Ans:   []float64{-12, -10, -8, -4, -12},
			},
		},
	},
	{
		Name:   "LeadingZero",
		X:      []float64{0, 1},
		Incx:   1,
		N:      2,
		Panic:  false,
		Dasum:  1,
		Dnrm2:  1,
		Idamax: 1,
		DscalCases: []DScalCase{
			{
				Alpha: 0,
				Ans:   []float64{0, 0},
			},
			{
				Alpha: 1,
				Ans:   []float64{0, 1},
			},
			{
				Alpha: -2,
				Ans:   []float64{0, -2},
			},
		},
	},
	{
		Name:   "MaxInMiddle",
		X:      []float64{6, 5, 9, 0, 6},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  26,
		Dnrm2:  13.34166406412633371248943627250846646911846482744007727141318,
		Idamax: 2,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-12, -10, -18, 0, -12},
			},
		},
	},
	{
		Name:   "MaxAtEnd",
		X:      []float64{6, 5, -9, 0, 10},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  30,
		Dnrm2:  15.55634918610404553681857596630667886426639062914642880494347,
		Idamax: 4,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-12, -10, 18, 0, -20},
			},
		},
	},
	{
		Name:   "AllNegative",
		X:      []float64{-6, -5, -4, -2, -6},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  23,
		Dnrm2:  10.81665382639196787935766380241148783875388972153573863813135,
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, 10, 8, 4, 12},
			},
		},
	},
	{
		Name:   "AllMixed",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  23,
		Dnrm2:  10.81665382639196787935766380241148783875388972153573863813135,
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, -10, -8, 4, 12},
			},
		},
	},
	{
		Name:   "ZeroN",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   1,
		N:      0,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "OneN",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   1,
		N:      1,
		Panic:  false,
		Dasum:  6,
		Dnrm2:  6,
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "PositiveExactInc",
		X:      []float64{-6, 5, 10, -2, -5},
		Incx:   2,
		N:      3,
		Panic:  false,
		Dasum:  21,
		Dnrm2:  12.68857754044952038019377274608948979173952662752515253090272,
		Idamax: 1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, 5, -20, -2, 10},
			},
		},
	},
	{
		Name:   "PositiveOffInc",
		X:      []float64{-6, 5, 4, -2, -6, 8, 10, 11},
		Incx:   3,
		N:      3,
		Panic:  false,
		Dasum:  18,
		Dnrm2:  11.83215956619923208513465658312323409683100246158868064575943,
		Idamax: 2,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, 5, 4, 4, -6, 8, -20, 11},
			},
		},
	},
	{
		Name:   "PositiveShortInc",
		X:      []float64{-6, 5, 4, -2, -6, 8, 10, 11},
		Incx:   3,
		N:      2,
		Panic:  false,
		Dasum:  8,
		Dnrm2:  6.324555320336758663997787088865437067439110278650433653715009,
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{12, 5, 4, 4, -6, 8, 10, 11},
			},
		},
	},
	{
		Name:   "NegativeInc",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   -1,
		N:      5,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "NegativeExactInc",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   -2,
		N:      3,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "NegativeOffInc",
		X:      []float64{-6, 5, 4, -2, -6, 8, 10, 11},
		Incx:   -3,
		N:      2,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6, 8, 10, 11},
			},
		},
	},
	{
		Name:   "NegativeShortInc",
		X:      []float64{-6, 5, 4, -2, -6, 8, 10, 11},
		Incx:   -3,
		N:      2,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6, 8, 10, 11},
			},
		},
	},
	{
		Name:  "NegativeN",
		X:     []float64{-6, 5, 4, -2, -6},
		Incx:  2,
		N:     -5,
		Panic: true,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:  "ZeroInc",
		X:     []float64{-6, 5, 4, -2, -6},
		Incx:  0,
		N:     5,
		Panic: true,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:  "OutOfBounds",
		X:     []float64{-6, 5, 4, -2, -6},
		Incx:  2,
		N:     6,
		Panic: true,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "NegativeOutOfBounds",
		X:      []float64{-6, 5, 4, -2, -6},
		Incx:   -2,
		N:      6,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-6, 5, 4, -2, -6},
			},
		},
	},
	{
		Name:   "NaN",
		X:      []float64{math.NaN(), 2.0},
		Incx:   1,
		N:      2,
		Panic:  false,
		Dasum:  math.NaN(),
		Dnrm2:  math.NaN(),
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{math.NaN(), -4.0},
			},
			{
				Alpha: 0,
				Ans:   []float64{0, 0},
			},
		},
	},
	{
		Name:   "NaNInc",
		X:      []float64{math.NaN(), math.NaN(), 2.0},
		Incx:   2,
		N:      2,
		Panic:  false,
		Dasum:  math.NaN(),
		Dnrm2:  math.NaN(),
		Idamax: 0,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{math.NaN(), math.NaN(), -4.0},
			},
			{
				Alpha: 0,
				Ans:   []float64{0, math.NaN(), 0},
			},
		},
	},
	{
		Name:   "Empty",
		X:      []float64{},
		Incx:   1,
		N:      0,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{},
			},
			{
				Alpha: 0,
				Ans:   []float64{},
			},
		},
	},
	{
		Name:   "EmptyZeroInc",
		X:      []float64{},
		Incx:   0,
		N:      0,
		Panic:  true,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{},
			},
			{
				Alpha: 0,
				Ans:   []float64{},
			},
		},
	},
	{
		Name:   "EmptyReverse",
		X:      []float64{},
		Incx:   -1,
		N:      0,
		Panic:  false,
		Dasum:  0,
		Dnrm2:  0,
		Idamax: -1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{},
			},
			{
				Alpha: 0,
				Ans:   []float64{},
			},
		},
	},
	{
		Name:   "MultiInf",
		X:      []float64{5, math.Inf(1), math.Inf(-1), 8, 9},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  math.Inf(1),
		Dnrm2:  math.Inf(1),
		Idamax: 1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-10, math.Inf(-1), math.Inf(1), -16, -18},
			},
			{
				Alpha: 0,
				Ans:   []float64{0, 0, 0, 0, 0},
			},
		},
	},
	{
		Name:   "NaNInf",
		X:      []float64{5, math.NaN(), math.Inf(-1), 8, 9},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  math.NaN(),
		Dnrm2:  math.NaN(),
		Idamax: 2,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-10, math.NaN(), math.Inf(1), -16, -18},
			},
			{
				Alpha: 0,
				Ans:   []float64{0, 0, 0, 0, 0},
			},
		},
	},
	{
		Name:   "InfNaN",
		X:      []float64{5, math.Inf(1), math.NaN(), 8, 9},
		Incx:   1,
		N:      5,
		Panic:  false,
		Dasum:  math.NaN(),
		Dnrm2:  math.NaN(),
		Idamax: 1,
		DscalCases: []DScalCase{
			{
				Alpha: -2,
				Ans:   []float64{-10, math.Inf(-1), math.NaN(), -16, -18},
			},
			{
				Alpha: 0,
				Ans:   []float64{0, 0, 0, 0, 0},
			},
		},
	},
}
View Source 
var DoubleTwoVectorCases = []DoubleTwoVectorCase{
	{
		Name:  "UnitaryInc",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0},
		Incx:  1,
		Incy:  1,
		N:     6,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 1,
				Ans:   []float64{18, 13, -2, 10, 20, 4},
			},
			{
				Alpha: 2,
				Ans:   []float64{28, 28, -8, 13, 34, 11},
			},
			{
				Alpha: -3,
				Ans:   []float64{-22, -47, 22, -2, -36, -24},
			},
			{
				Alpha: 0,
				Ans:   []float64{8, -2, 4, 7, 6, -3},
			},
		},
		DdotAns: 110,
		DswapAns: DTwoVecAnswer{
			X: []float64{8, -2, 4, 7, 6, -3},
			Y: []float64{10, 15, -6, 3, 14, 7},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{10, 15, -6, 3, 14, 7},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(0),
				S:    math.Sin(0),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3},
			},
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{12.444023964292095, 12.749380282068351, -3.7473736752571014, 5.677251193294846, 15.224018588957296, 5.076299724034451},
				YAns: []float64{3.024279678886205, -8.151889500183792, 6.160940718590796, 5.076299724034451, -0.4788089421498931, -5.677251193294846},
			},
			{
				C:    math.Cos(0.5 * math.Pi),
				S:    math.Sin(0.5 * math.Pi),
				XAns: []float64{8, -2, 4, 7, 6, -3},
				YAns: []float64{-10, -15, 6, -3, -14, -7},
			},
			{
				C:    math.Cos(math.Pi),
				S:    math.Sin(math.Pi),
				XAns: []float64{-10, -15, 6, -3, -14, -7},
				YAns: []float64{-8, 2, -4, -7, -6, 3},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Identity,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3},
				Name: "Neg2Flag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
				Name: "Neg1Flag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{9.2, 15.2, -6.4, 2.3, 13.4, 7.3},
				YAns: []float64{9, -0.5, 3.4, 7.3, 7.4, -2.3},
				Name: "ZeroFlag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{13, 5.5, 1, 8.5, 13, 0.5},
				YAns: []float64{-4.4, -16.4, 8.8, 1.9, -9.8, -9.1},
				Name: "OneFlag",
			},
		},
	},
	{
		Name:  "UnitaryIncLong",
		X:     []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
		Y:     []float64{8, -2, 4, 7, 6, -3, 7, -6},
		XTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  1,
		Incy:  1,
		N:     6,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 1,
				Ans:   []float64{18, 13, -2, 10, 20, 4, 7, -6},
			},
			{
				Alpha: 2,
				Ans:   []float64{28, 28, -8, 13, 34, 11, 7, -6},
			},
			{
				Alpha: -3,
				Ans:   []float64{-22, -47, 22, -2, -36, -24, 7, -6},
			},
			{
				Alpha: 0,
				Ans:   []float64{8, -2, 4, 7, 6, -3, 7, -6},
			},
		},
		DdotAns: 110,
		DswapAns: DTwoVecAnswer{
			X: []float64{8, -2, 4, 7, 6, -3, 8, -9, 10},
			Y: []float64{10, 15, -6, 3, 14, 7, 7, -6},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
			Y: []float64{10, 15, -6, 3, 14, 7, 7, -6},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(0),
				S:    math.Sin(0),
				XAns: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
				YAns: []float64{8, -2, 4, 7, 6, -3, 7, -6},
			},
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{12.444023964292095, 12.749380282068351, -3.7473736752571014, 5.677251193294846, 15.224018588957296, 5.076299724034451, 8, -9, 10},
				YAns: []float64{3.024279678886205, -8.151889500183792, 6.160940718590796, 5.076299724034451, -0.4788089421498931, -5.677251193294846, 7, -6},
			},
			{
				C:    math.Cos(0.5 * math.Pi),
				S:    math.Sin(0.5 * math.Pi),
				XAns: []float64{8, -2, 4, 7, 6, -3, 8, -9, 10},
				YAns: []float64{-10, -15, 6, -3, -14, -7, 7, -6},
			},
			{
				C:    math.Cos(math.Pi),
				S:    math.Sin(math.Pi),
				XAns: []float64{-10, -15, 6, -3, -14, -7, 8, -9, 10},
				YAns: []float64{-8, 2, -4, -7, -6, 3, 7, -6},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Identity,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
				YAns: []float64{8, -2, 4, 7, 6, -3, 7, -6},
				Name: "Neg2Flag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6, 8, -9, 10},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8, 7, -6},
				Name: "Neg1Flag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{9.2, 15.2, -6.4, 2.3, 13.4, 7.3, 8, -9, 10},
				YAns: []float64{9, -0.5, 3.4, 7.3, 7.4, -2.3, 7, -6},
				Name: "ZeroFlag",
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{13, 5.5, 1, 8.5, 13, 0.5, 8, -9, 10},
				YAns: []float64{-4.4, -16.4, 8.8, 1.9, -9.8, -9.1, 7, -6},
				Name: "OneFlag",
			},
		},
	},
	{
		Name:  "PositiveInc",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  2,
		Incy:  3,
		N:     3,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{28, -2, 4, -5, 6, -3, 24, 10},
			},
		},
		DdotAns: -18,
		DswapAns: DTwoVecAnswer{
			X: []float64{8, 15, 7, 3, -4, 7},
			Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{12.444023964292095, 15, -2.479518890035003, 3, 10.997835971550302, 7},
				YAns: []float64{3.024279678886205, -2, 4, 8.879864079700745, 6, -3, -9.541886812516392, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 15, -6.1, 3, 13, 7},
				YAns: []float64{5, -2, 4, 2.9, 6, -3, -0.6, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{9.2, 15, -6.7, 3, 14.4, 7},
				YAns: []float64{9, -2, 4, 6.4, 6, -3, -2.6, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{13, 15, 4, 3, 3, 7},
				YAns: []float64{-4.4, -2, 4, 10.9, 6, -3, -16.8, 10},
			},
		},
	},
	{
		Name:  "NegativeInc",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  -2,
		Incy:  -3,
		N:     3,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{28, -2, 4, -5, 6, -3, 24, 10},
			},
		},
		DdotAns: -18,
		DswapAns: DTwoVecAnswer{
			X: []float64{8, 15, 7, 3, -4, 7},
			Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{12.444023964292095, 15, -2.479518890035003, 3, 10.997835971550302, 7},
				YAns: []float64{3.024279678886205, -2, 4, 8.879864079700745, 6, -3, -9.541886812516392, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 15, -6.1, 3, 13, 7},
				YAns: []float64{5, -2, 4, 2.9, 6, -3, -0.6, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{9.2, 15, -6.7, 3, 14.4, 7},
				YAns: []float64{9, -2, 4, 6.4, 6, -3, -2.6, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{13, 15, 4, 3, 3, 7},
				YAns: []float64{-4.4, -2, 4, 10.9, 6, -3, -16.8, 10},
			},
		},
	},
	{
		Name:  "MixedInc1",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  2,
		Incy:  -3,
		N:     3,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DdotAns: 30,
		DswapAns: DTwoVecAnswer{
			X: []float64{-4, 15, 7, 3, 8, 7},
			Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{7.372604823403701, 15, -2.479518890035003, 3, 16.069255112438693, 7},
				YAns: []float64{1.333806631923407, -2, 4, 8.879864079700745, 6, -3, -7.851413765553595, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{9.4, 15, -6.1, 3, 11.8, 7},
				YAns: []float64{5.4, -2, 4, 2.9, 6, -3, -1, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{10.4, 15, -6.7, 3, 13.2, 7},
				YAns: []float64{9.4, -2, 4, 6.4, 6, -3, -3, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{1, 15, 4, 3, 15, 7},
				YAns: []float64{-8.4, -2, 4, 10.9, 6, -3, -12.8, 10},
			},
		},
	},
	{
		Name:  "MixedInc2",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  -2,
		Incy:  3,
		N:     3,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DdotAns: 30,
		DswapAns: DTwoVecAnswer{
			X: []float64{-4, 15, 7, 3, 8, 7},
			Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{7.372604823403701, 15, -2.479518890035003, 3, 16.069255112438693, 7},
				YAns: []float64{1.333806631923407, -2, 4, 8.879864079700745, 6, -3, -7.851413765553595, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{9.4, 15, -6.1, 3, 11.8, 7},
				YAns: []float64{5.4, -2, 4, 2.9, 6, -3, -1, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.OffDiagonal,
					H:    [4]float64{1, 0.1, -0.1, 1},
				},
				XAns: []float64{10.4, 15, -6.7, 3, 13.2, 7},
				YAns: []float64{9.4, -2, 4, 6.4, 6, -3, -3, 10},
			},
			{
				P: blas.DrotmParams{
					Flag: blas.Diagonal,
					H:    [4]float64{0.5, -1, 1, 0.7},
				},
				XAns: []float64{1, 15, 4, 3, 15, 7},
				YAns: []float64{-8.4, -2, 4, 10.9, 6, -3, -12.8, 10},
			},
		},
	},
	{
		Name:  "ZeroN",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  -2,
		Incy:  3,
		N:     0,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DswapAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
		},
		DcopyAns: DTwoVecAnswer{
			X: []float64{10, 15, -6, 3, 14, 7},
			Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
	},
	{
		Name:  "NegativeN",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  -2,
		Incy:  3,
		N:     -3,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
			},
		},
	},
	{
		Name:  "ZeroIncX",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  0,
		Incy:  3,
		N:     2,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
			},
		},
	},
	{
		Name:  "ZeroIncY",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  1,
		Incy:  0,
		N:     2,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
			},
		},
	},
	{
		Name:  "OutOfBoundsX",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  8,
		Incy:  2,
		N:     2,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
				YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
			},
		},
	},
	{
		Name:  "OutOfBoundsY",
		X:     []float64{10, 15, -6, 3, 14, 7},
		Y:     []float64{8, -2, 4, 7, 6, -3, -4, 10},
		XTmp:  []float64{0, 0, 0, 0, 0, 0},
		YTmp:  []float64{0, 0, 0, 0, 0, 0, 0, 0},
		Incx:  2,
		Incy:  8,
		N:     2,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{36, -2, 4, -5, 6, -3, 16, 10},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{10, 15, -6, 3, 14, 7},
				YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
			},
		},
	},
	{
		Name:  "Empty",
		X:     []float64{},
		Y:     []float64{},
		Incx:  1,
		Incy:  1,
		N:     0,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{},
				YAns: []float64{},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{},
				YAns: []float64{},
			},
		},
	},
	{
		Name:  "EmptyZeroIncX",
		X:     []float64{},
		Y:     []float64{},
		Incx:  0,
		Incy:  1,
		N:     0,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{},
				YAns: []float64{},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{},
				YAns: []float64{},
			},
		},
	},
	{
		Name:  "EmptyZeroIncY",
		X:     []float64{},
		Y:     []float64{},
		Incx:  1,
		Incy:  0,
		N:     0,
		Panic: true,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{},
				YAns: []float64{},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{},
				YAns: []float64{},
			},
		},
	},
	{
		Name:  "EmptyReverse",
		X:     []float64{},
		Y:     []float64{},
		Incx:  -1,
		Incy:  -1,
		N:     0,
		Panic: false,
		DaxpyCases: []DaxpyCase{
			{
				Alpha: 2,
				Ans:   []float64{},
			},
		},
		DrotCases: []DrotCase{
			{
				C:    math.Cos(25 * math.Pi / 180),
				S:    math.Sin(25 * math.Pi / 180),
				XAns: []float64{},
				YAns: []float64{},
			},
		},
		DrotmCases: []DrotmCase{
			{
				P: blas.DrotmParams{
					Flag: blas.Rescaling,
					H:    [4]float64{0.9, 0.1, -0.1, 0.5},
				},
				XAns: []float64{},
				YAns: []float64{},
			},
		},
	},
}
View Source 
var DrotgTests = []DrotgTestStruct{
	{
		Name: "ZeroAB",
		C:    1,
	},
	{
		Name: "PosA_ZeroB",
		A:    0.5,
		C:    1,
		R:    0.5,
	},
	{
		Name: "NegA_ZeroB",
		A:    -4.6,
		C:    1,
		R:    -4.6,
	},
	{
		Name: "ZeroA_PosB",
		B:    3,
		S:    1,
		R:    3,
		Z:    1,
	},
	{
		Name: "ZeroA_NegB",
		B:    -0.3,
		S:    1,
		R:    -0.3,
		Z:    1,
	},
	{
		Name: "PosA_PosB_AGTB",
		A:    5,
		B:    0.3,
		C:    0.99820484546577868593549038000,
		S:    0.05989229072794672115612942280,
		R:    5.00899191454727744602429072688,
		Z:    0.05989229072794672115612942280,
	},
	{
		Name: "PosA_PosB_ALTB",
		A:    3,
		B:    4,
		C:    3.0 / 5,
		S:    4.0 / 5,
		R:    5,
		Z:    5.0 / 3.0,
	},

	{
		Name: "PosA_NegB_AGTB",
		A:    2.6,
		B:    -0.9,
		C:    0.94498607344025815971847507095,
		S:    -0.32711056388316628605639521686,
		R:    2.751363298439520872718790879655,
		Z:    -0.3271105638831662860563952168,
	},
	{
		Name: "PosA_NegB_ALTB",
		A:    2.6,
		B:    -2.9,
		C:    -0.6675450157520258540548049558,
		S:    0.7445694406464903756765132200,
		R:    -3.8948684188300893100043812234,
		Z:    1 / -0.6675450157520258540548049558,
	},
	{
		Name: "NegA_PosB_AGTB",
		A:    -11.4,
		B:    10.3,
		C:    0.7419981952497362418487847947,
		S:    -0.6704018781642353764072353847,
		R:    -15.363918770938617534070671122,
		Z:    -0.6704018781642353764072353847,
	},
	{
		Name: "NegA_PosB_ALTB",
		A:    -1.4,
		B:    10.3,
		C:    -0.1346838895922121112404717523,
		S:    0.9908886162855605326977564640,
		R:    10.394710193170370442523552032,
		Z:    1 / -0.1346838895922121112404717523,
	},
	{
		Name: "NegA_NegB_AGTB",
		A:    -11.4,
		B:    10.3,
		C:    0.7419981952497362418487847947,
		S:    -0.6704018781642353764072353847,
		R:    -15.363918770938617534070671122,
		Z:    -0.6704018781642353764072353847,
	},
	{
		Name: "NegA_NegB_ALTB",
		A:    -1.4,
		B:    -10.3,
		C:    0.1346838895922121112404717523,
		S:    0.9908886162855605326977564640,
		R:    -10.394710193170370442523552032,
		Z:    1 / 0.1346838895922121112404717523,
	},
}
View Source 
var DrotmgTests = []DrotmgTestStruct{
	{
		Name: "NegD1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
		},
		D1: -4,
		D2: 6,
		X1: 8,
		Y1: -4,
	},
	{
		Name: "ZeroD2",
		P: &blas.DrotmParams{
			Flag: blas.Identity,
		},
		D1:  4,
		X1:  8,
		Y1:  -5,
		Rd1: 4,
		Rx1: 8,
	},
	{
		Name: "ZeroY1",
		P: &blas.DrotmParams{
			Flag: blas.Identity,
		},
		D1:  4,
		D2:  -6,
		X1:  8,
		Rd1: 4,
		Rd2: -6,
		Rx1: 8,
	},
	{
		Name: "NegQ2_and_AQ1_LT_AQ2",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
		},
		D1:  8,
		D2:  -6,
		X1:  4,
		Y1:  8,
		Rd1: 0,
		Rd2: 0,
		Rx1: 0,
	},
	{
		Name: "ZeroD1",
		P: &blas.DrotmParams{
			Flag: blas.Diagonal,
			H:    [4]float64{0, 0, 0, 0},
		},
		D1:  0,
		D2:  2,
		X1:  8,
		Y1:  4,
		Rd1: 2,
		Rd2: 0,
		Rx1: 4,
	},
	{
		Name: "AbsQ1_GT_AbsQU__D2_Pos",
		P: &blas.DrotmParams{
			Flag: blas.OffDiagonal,
			H:    [4]float64{0, -0.625, 0.9375, 0},
		},
		D1:  2,
		D2:  3,
		X1:  8,
		Y1:  5,
		Rd1: 1.2610837438423645,
		Rd2: 1.8916256157635467,
		Rx1: 12.6875,
	},
	{
		Name: "AbsQ1_GT_AbsQU__D2_Neg",
		P: &blas.DrotmParams{
			Flag: blas.OffDiagonal,
			H:    [4]float64{0, -0.625, -0.9375, 0},
		},
		D1:  2,
		D2:  -3,
		X1:  8,
		Y1:  5,
		Rd1: 4.830188679245283,
		Rd2: -7.245283018867925,
		Rx1: 3.3125,
	},
	{
		Name: "AbsQ1_LT_AbsQU__D2_Pos",
		P: &blas.DrotmParams{
			Flag: blas.Diagonal,
			H:    [4]float64{5.0 / 12, 0, 0, 0.625},
		},
		D1:  2,
		D2:  3,
		X1:  5,
		Y1:  8,
		Rd1: 2.3801652892561984,
		Rd2: 1.586776859504132,
		Rx1: 121.0 / 12,
	},
	{
		Name: "D1=D2_X1=X2",
		P: &blas.DrotmParams{
			Flag: blas.Diagonal,
			H:    [4]float64{1, 0, 0, 1},
		},
		D1:  2,
		D2:  2,
		X1:  8,
		Y1:  8,
		Rd1: 1,
		Rd2: 1,
		Rx1: 16,
	},
	{
		Name: "RD1_Big_RD2_Big_Flag_0",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{4096, -3584, 1792, 4096},
		},
		D1:  1600000000,
		D2:  800000000,
		X1:  8,
		Y1:  7,
		Rd1: 68.96627824858757,
		Rd2: 34.483139124293785,
		Rx1: 45312,
	},
	{
		Name: "RD1_Big_RD2_Big_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{2340.5714285714284, -4096, 4096, 4681.142857142857},
		},
		D1:  800000000,
		D2:  1600000000,
		X1:  8,
		Y1:  7,
		Rd1: 57.6914092640818,
		Rd2: 28.8457046320409,
		Rx1: 47396.57142857142,
	},
	{
		Name: "RD1_Big_RD2_Med_Flag_0",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{4096, -1, 0.0004096, 1},
		},
		D1:  20000000,
		D2:  2,
		X1:  8,
		Y1:  8,
		Rd1: 1.1920927762985347,
		Rd2: 1.9999998000000199,
		Rx1: 32768.0032768,
	},
	{
		Name: "RD1_Big_RD2_Med_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{4.096e-17, -1, 4096, 1e-10},
		},
		D1:  2,
		D2:  20000000000,
		X1:  8,
		Y1:  80000000000,
		Rd1: 1192.0928955078125,
		Rd2: 2,
		Rx1: 3.2768e+14,
	},

	{
		Name: "D1_Big_D2_Small_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{2.8671999999999997e-26, -0.000244140625, 4096, 2.44140625e-16},
		},
		D1:  0.000000014,
		D2:  2000000000,
		X1:  0.000008,
		Y1:  8000000,
		Rd1: 119.20928955078125,
		Rd2: 0.234881024,
		Rx1: 3.2768e+10,
	},

	{
		Name: "RD1_Med_RD2_Big_Flag_0",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{1, -0.0004096, 1000, 4096},
		},
		D1:  2,
		D2:  20000000000,
		X1:  80000000,
		Y1:  8,
		Rd1: 1.9998000199980002,
		Rd2: 1191.9736981379988,
		Rx1: 8.0008e+07,
	},
	{
		Name: "D1_Med_D2_Big_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{50, -4096, 1, 4.096e-06},
		},
		D1:  20000000000,
		D2:  0.4,
		X1:  80000000,
		Y1:  80000000000000000,
		Rd1: 0.39999998000000103,
		Rd2: 1192.092835903171,
		Rx1: 8.0000004e+16,
	},
	{
		Name: "RD1_Med_RD2_Small_Flag_0",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{1, -0.0007233796296296296, 1.1111111111111111e-10, 0.000244140625},
		},
		D1:  1.2,
		D2:  0.000000000045,
		X1:  2.7,
		Y1:  8,
		Rd1: 1.1999999996049382,
		Rd2: 0.0007549747197514486,
		Rx1: 2.700000000888889,
	},
	{
		Name: "RD1_Med_RD2_Small_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0.0002197265625, -1, 0.000244140625, 3.375e-11},
		},
		D1:  1.2,
		D2:  0.000000000045,
		X1:  2.7,
		Y1:  80000000000,
		Rd1: 0.0007549747199770676,
		Rd2: 1.19999999996355,
		Rx1: 1.9531250000593264e+07,
	},

	{
		Name: "D1_Small_D2_Big_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{2.3731773997569866e+10, -1.6777216e+07, 0.000244140625, 1.6777216e-07},
		},
		D1:  120000000000000000,
		D2:  0.000000000012345,
		X1:  0.08,
		Y1:  8000000000000,
		Rd1: 0.00010502490698765249,
		Rd2: 216.1836123957717,
		Rx1: 3.8516669198055897e+09,
	},
	{
		Name: "RD1_Small_RD2_Med_Flag_0",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0.000244140625, -1e-08, 0.24414062499999997, 1},
		},
		D1:  0.0000000002,
		D2:  20,
		X1:  0.8,
		Y1:  0.000000008,
		Rd1: 0.003355409645903541,
		Rd2: 19.99980000199998,
		Rx1: 0.000195314453125,
	},
	{
		Name: "RD1_Small_RD2_Med_Flag_1",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0.0012207031250000002, -1, 0.000244140625, 1e-09},
		},
		D1:  0.02,
		D2:  0.000000000004,
		X1:  0.008,
		Y1:  8000000,
		Rd1: 6.710886366445568e-05,
		Rd2: 0.019999999900000003,
		Rx1: 1953.125009765625,
	},
	{

		Name: "OpenBLAS#1452",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{1.6110934624105326e-06, -0.000244140625, 0.000244140625, 1.6276041666666668e-06},
		},
		D1:  5.9e-8,
		D2:  5.960464e-8,
		X1:  1,
		Y1:  150,
		Rd1: 0.9999559282289687,
		Rd2: 0.9898121986058326,
		Rx1: 0.03662270484346241,
	},
	{
		Name: "netlib/BLAS/TESTING#1",
		P: &blas.DrotmParams{
			Flag: blas.OffDiagonal,
			H:    [4]float64{0, -0.16666666666666669, 0.5, 0},
		},
		D1:  0.10000000000000001,
		D2:  0.29999999999999999,
		X1:  1.2000000000000000,
		Y1:  0.20000000000000001,
		Rd1: 9.2307692307692313e-2,
		Rd2: 0.27692307692307694,
		Rx1: 1.2999999999999998,
	},
	{
		Name: "netlib/BLAS/TESTING#2",
		P: &blas.DrotmParams{
			Flag: blas.Diagonal,
			H:    [4]float64{0.5, 0, 0, 0.14285714285714285},
		},
		D1:  0.69999999999999996,
		D2:  0.20000000000000001,
		X1:  0.59999999999999998,
		Y1:  4.2000000000000002,
		Rd1: 0.18666666666666668,
		Rd2: 0.65333333333333332,
		Rx1: 4.5000000000000000,
	},
	{
		Name: "netlib/BLAS/TESTING#3",
		P: &blas.DrotmParams{
			Flag: blas.Identity,
			H:    [4]float64{0, 0, 0, 0},
		},
		D1:  0,
		D2:  0,
		X1:  0,
		Y1:  0,
		Rd1: 0,
		Rd2: 0,
		Rx1: 0,
	},
	{
		Name: "netlib/BLAS/TESTING#4",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0, 0, 0, 0},
		},
		D1:  4,
		D2:  -1,
		X1:  2,
		Y1:  4,
		Rd1: 0,
		Rd2: 0,
		Rx1: 0,
	},
	{
		Name: "netlib/BLAS/TESTING#5",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0.244140625e-03, -0.1e-3, 0.8138020833333334, 1},
		},
		D1:  6e-10,
		D2:  2e-2,
		X1:  100000,
		Y1:  10,
		Rd1: 7.5497471999999991e-3,
		Rd2: 1.4999999999999999e-2,
		Rx1: 32.552083333333336,
	},
	{
		Name: "netlib/BLAS/TESTING#6",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{4096, -999999.99999999988, 2.0479999999999999e-3, 1},
		},
		D1:  40000000000,
		D2:  2e-2,
		X1:  1.0000000000000001e-5,
		Y1:  10,
		Rd1: 1589.4571940104167,
		Rd2: 1.3333333333333334e-2,
		Rx1: 6.1440000000000008e-2,
	},
	{
		Name: "netlib/BLAS/TESTING#7",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{0.5e-4, -0.2441406250e-3, 1, 2.441406250},
		},
		D1:  2.0000000000000001e-10,
		D2:  4.0000000000000001e-2,
		X1:  100000,
		Y1:  10,
		Rd1: 2.6666666666666668e-2,
		Rd2: 2.2369621333333334e-3,
		Rx1: 15,
	},
	{
		Name: "netlib/BLAS/TESTING#8",
		P: &blas.DrotmParams{
			Flag: blas.Rescaling,
			H:    [4]float64{500000, -4096, 1, 4.096e-3},
		},
		D1:  20000000000,
		D2:  4.0000000000000001e-2,
		X1:  1.0000000000000001e-5,
		Y1:  10,
		Rd1: 2.6666666666666668e-2,
		Rd2: 794.72859700520837,
		Rx1: 15,
	},
}

Functions

func DasumTest 

func DasumTest(t *testing.T, blasser Dasumer)

func DaxpyTest 

func DaxpyTest(t *testing.T, d Daxpyer)

func DcopyTest 

func DcopyTest(t *testing.T, d Dcopier)

func DdotTest 

func DdotTest(t *testing.T, d Ddotter)

func DgbmvTest 

func DgbmvTest(t *testing.T, blasser Dgbmver)

func DgemmBenchmark 

func DgemmBenchmark(b *testing.B, dgemm Dgemmer, m, n, k int, tA, tB blas.Transpose)

func DgemvBenchmark 

func DgemvBenchmark(b *testing.B, impl Dgemver, tA blas.Transpose, m, n, incX, incY int)

func DgemvTest 

func DgemvTest(t *testing.T, blasser Dgemver)

func DgerBenchmark 

func DgerBenchmark(b *testing.B, impl Dgerer, m, n, incX, incY int)

func DgerTest 

func DgerTest(t *testing.T, blasser Dgerer)

func Dnrm2Test 

func Dnrm2Test(t *testing.T, blasser Dnrm2er)

func DrotTest 

func DrotTest(t *testing.T, d Droter)

func DrotgTest 

func DrotgTest(t *testing.T, d Drotger)

func DrotmTest 

func DrotmTest(t *testing.T, d Drotmer)

func DrotmgTest 

func DrotmgTest(t *testing.T, d Drotmger)

func DsbmvTest 

func DsbmvTest(t *testing.T, blasser Dsbmver)

func DscalTest 

func DscalTest(t *testing.T, blasser Dscaler)

func DspmvTest 

func DspmvTest(t *testing.T, blasser Dspmver)

func Dspr2Test 

func Dspr2Test(t *testing.T, blasser Dspr2er)

func DsprTest 

func DsprTest(t *testing.T, blasser Dsprer)

func DswapTest 

func DswapTest(t *testing.T, d Dswapper)

func DsymmTest 

func DsymmTest(t *testing.T, blasser Dsymmer)

func DsymvTest 

func DsymvTest(t *testing.T, blasser Dsymver)

func Dsyr2Test 

func Dsyr2Test(t *testing.T, blasser Dsyr2er)

func Dsyr2kTest 

func Dsyr2kTest(t *testing.T, blasser Dsyr2ker)

func DsyrTest 

func DsyrTest(t *testing.T, blasser Dsyrer)

func DsyrkTest 

func DsyrkTest(t *testing.T, blasser Dsyker)

func DtbmvTest 

func DtbmvTest(t *testing.T, blasser Dtbmver)

func DtbsvTest 

func DtbsvTest(t *testing.T, blasser Dtbsver)

func DtpmvTest 

func DtpmvTest(t *testing.T, blasser Dtpmver)

func DtpsvTest 

func DtpsvTest(t *testing.T, blasser Dtpsver)

func DtrmmTest 

func DtrmmTest(t *testing.T, blasser Dtrmmer)

func DtrmvBenchmark 

func DtrmvBenchmark(b *testing.B, dtrmv Dtrmver, n, lda, incX int, ul blas.Uplo, tA blas.Transpose, d blas.Diag)

func DtrmvTest 

func DtrmvTest(t *testing.T, blasser Dtrmver)

func DtrsmTest 

func DtrsmTest(t *testing.T, impl Dtrsmer)

func DtrsvTest 

func DtrsvTest(t *testing.T, blasser Dtrsver)

func DtxmvTest 

func DtxmvTest(t *testing.T, blasser Dtxmver)

func DzasumTest 

func DzasumTest(t *testing.T, impl Dzasumer)

func Dznrm2Test 

func Dznrm2Test(t *testing.T, impl Dznrm2er)

func IdamaxTest 

func IdamaxTest(t *testing.T, blasser Idamaxer)

func IzamaxTest 

func IzamaxTest(t *testing.T, impl Izamaxer)

func SgerBenchmark 

func SgerBenchmark(b *testing.B, blasser Sgerer, m, n, incX, incY int)

func TestDgemm 

func TestDgemm(t *testing.T, blasser Dgemmer)

func ZaxpyTest 

func ZaxpyTest(t *testing.T, impl Zaxpyer)

func ZcopyTest 

func ZcopyTest(t *testing.T, impl Zcopyer)

func ZdotcTest 

func ZdotcTest(t *testing.T, impl Zdotcer)

func ZdotuTest 

func ZdotuTest(t *testing.T, impl Zdotuer)

func ZdscalTest 

func ZdscalTest(t *testing.T, impl Zdscaler)

func ZgbmvTest 

func ZgbmvTest(t *testing.T, impl Zgbmver)

func ZgemmTest 

func ZgemmTest(t *testing.T, impl Zgemmer)

func ZgemvTest 

func ZgemvTest(t *testing.T, impl Zgemver)

func ZgercTest 

func ZgercTest(t *testing.T, impl Zgercer)

func ZgeruTest 

func ZgeruTest(t *testing.T, impl Zgeruer)

func ZhbmvTest 

func ZhbmvTest(t *testing.T, impl Zhbmver)

func ZhemmTest 

func ZhemmTest(t *testing.T, impl Zhemmer)

func ZhemvTest 

func ZhemvTest(t *testing.T, impl Zhemver)

func Zher2Test 

func Zher2Test(t *testing.T, impl Zher2er)

func Zher2kTest 

func Zher2kTest(t *testing.T, impl Zher2ker)

func ZherTest 

func ZherTest(t *testing.T, impl Zherer)

func ZherkTest 

func ZherkTest(t *testing.T, impl Zherker)

func ZhpmvTest 

func ZhpmvTest(t *testing.T, impl Zhpmver)

func Zhpr2Test 

func Zhpr2Test(t *testing.T, impl Zhpr2er)

func ZhprTest 

func ZhprTest(t *testing.T, impl Zhprer)

func ZscalTest 

func ZscalTest(t *testing.T, impl Zscaler)

func ZswapTest 

func ZswapTest(t *testing.T, impl Zswaper)

func ZsymmTest 

func ZsymmTest(t *testing.T, impl Zsymmer)

func Zsyr2kTest 

func Zsyr2kTest(t *testing.T, impl Zsyr2ker)

func ZsyrkTest 

func ZsyrkTest(t *testing.T, impl Zsyrker)

func ZtbmvTest 

func ZtbmvTest(t *testing.T, impl Ztbmver)

func ZtbsvTest 

func ZtbsvTest(t *testing.T, impl Ztbsver)

func ZtpmvTest 

func ZtpmvTest(t *testing.T, impl Ztpmver)

func ZtpsvTest 

func ZtpsvTest(t *testing.T, impl Ztpsver)

func ZtrmmTest 

func ZtrmmTest(t *testing.T, impl Ztrmmer)

func ZtrmvTest 

func ZtrmvTest(t *testing.T, impl Ztrmver)

func ZtrsmTest 

func ZtrsmTest(t *testing.T, impl Ztrsmer)

func ZtrsvTest 

func ZtrsvTest(t *testing.T, impl Ztrsver)

Types

type DScalCase 

type DScalCase struct {
	Alpha float64
	Ans   []float64
	Name  string
}

type DTwoVecAnswer 

type DTwoVecAnswer struct {
	X []float64
	Y []float64
}

type Dasumer 

type Dasumer interface {
	Dasum(n int, x []float64, incX int) float64
}

type DaxpyCase 

type DaxpyCase struct {
	Alpha float64
	Ans   []float64
}

type Daxpyer 

type Daxpyer interface {
	Daxpy(n int, alpha float64, x []float64, incX int, y []float64, incY int)
}

type Dcopier 

type Dcopier interface {
	Dcopy(n int, x []float64, incX int, y []float64, incY int)
}

type Ddotter 

type Ddotter interface {
	Ddot(n int, x []float64, incX int, y []float64, incY int) float64
}

type Dgbmver 

type Dgbmver interface {
	Dgbmv(tA blas.Transpose, m, n, kL, kU int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
}

type DgemmCase 

type DgemmCase struct {
	// contains filtered or unexported fields
}

type Dgemmer 

type Dgemmer interface {
	Dgemm(tA, tB blas.Transpose, m, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
}

type DgemvCase 

type DgemvCase struct {
	Name string

	A [][]float64

	Subcases []DgemvSubcase
	// contains filtered or unexported fields
}

type DgemvSubcase 

type DgemvSubcase struct {
	// contains filtered or unexported fields
}

type Dgemver 

type Dgemver interface {
	Dgemv(tA blas.Transpose, m, n int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
}

type Dgerer 

type Dgerer interface {
	Dger(m, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64, lda int)
}

type Dnrm2er 

type Dnrm2er interface {
	Dnrm2(n int, x []float64, incX int) float64
}

type DoubleOneVectorCase 

type DoubleOneVectorCase struct {
	Name       string
	X          []float64
	Incx       int
	N          int
	Panic      bool
	Dasum      float64
	Dnrm2      float64
	Idamax     int
	DscalCases []DScalCase
}

type DoubleTwoVectorCase 

type DoubleTwoVectorCase struct {
	Name  string
	X     []float64
	Y     []float64
	XTmp  []float64
	YTmp  []float64
	Incx  int
	Incy  int
	N     int
	Panic bool
	// For Daxpy
	DaxpyCases []DaxpyCase
	DdotAns    float64
	DswapAns   DTwoVecAnswer
	DcopyAns   DTwoVecAnswer
	DrotCases  []DrotCase
	DrotmCases []DrotmCase
}

type DrotCase 

type DrotCase struct {
	C    float64
	S    float64
	XAns []float64
	YAns []float64
}

type Droter 

type Droter interface {
	Drot(n int, x []float64, incX int, y []float64, incY int, c, s float64)
}

type DrotgTestStruct 

type DrotgTestStruct struct {
	Name       string
	A, B       float64
	C, S, R, Z float64
}

type Drotger 

type Drotger interface {
	Drotg(a, b float64) (c, s, r, z float64)
}

type DrotmCase 

type DrotmCase struct {
	P    blas.DrotmParams
	XAns []float64
	YAns []float64
	Name string
}

type Drotmer 

type Drotmer interface {
	Drotm(n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams)
}

type DrotmgTestStruct 

type DrotmgTestStruct struct {
	Name           string
	D1, D2, X1, Y1 float64
	P              *blas.DrotmParams
	Rd1, Rd2, Rx1  float64
}

type Drotmger 

type Drotmger interface {
	Drotmg(d1, d2, x1, y1 float64) (p blas.DrotmParams, rd1, rd2, rx1 float64)
	Drotmer
}

type Dsbmver 

type Dsbmver interface {
	Dsbmv(ul blas.Uplo, n, k int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
}

type Dscaler 

type Dscaler interface {
	Dscal(n int, alpha float64, x []float64, incX int)
}

type Dspmver 

type Dspmver interface {
	Dspmv(ul blas.Uplo, n int, alpha float64, ap []float64, x []float64, incX int, beta float64, y []float64, incY int)
}

type Dspr2er 

type Dspr2er interface {
	Dspr2(ul blas.Uplo, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64)
}

type Dsprer 

type Dsprer interface {
	Dspr(ul blas.Uplo, n int, alpha float64, x []float64, incX int, a []float64)
}

type Dswapper 

type Dswapper interface {
	Dswap(n int, x []float64, incX int, y []float64, incY int)
}

type Dsyker 

type Dsyker interface {
	Dsyrk(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float64, a []float64, lda int, beta float64, c []float64, ldc int)
}

type Dsymmer 

type Dsymmer interface {
	Dsymm(s blas.Side, ul blas.Uplo, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
}

type Dsymver 

type Dsymver interface {
	Dsymv(ul blas.Uplo, n int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
}

type Dsyr2er 

type Dsyr2er interface {
	Dsyr2(ul blas.Uplo, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64, lda int)
}

type Dsyr2ker 

type Dsyr2ker interface {
	Dsyr2k(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
}

type Dsyrer 

type Dsyrer interface {
	Dsyr(ul blas.Uplo, n int, alpha float64, x []float64, incX int, a []float64, lda int)
}

type Dtbmver 

type Dtbmver interface {
	Dtbmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n, k int, a []float64, lda int, x []float64, incX int)
}

type Dtbsver 

type Dtbsver interface {
	Dtbsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n, k int, a []float64, lda int, x []float64, incX int)
	Dtrsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
}

type Dtpmver 

type Dtpmver interface {
	Dtpmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, ap []float64, x []float64, incX int)
}

type Dtpsver 

type Dtpsver interface {
	Dtpsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, ap []float64, x []float64, incX int)
}

type Dtrmmer 

type Dtrmmer interface {
	Dtrmm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int)
}

type Dtrmver 

type Dtrmver interface {
	Dtrmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
}

type Dtrsmer 

type Dtrsmer interface {
	Dtrsm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int,
		alpha float64, a []float64, lda int, b []float64, ldb int)
}

type Dtrsver 

type Dtrsver interface {
	Dtrsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
}

type Dtxmver 

type Dtxmver interface {
	Dtrmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
	Dtbmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n, k int, a []float64, lda int, x []float64, incX int)
	Dtpmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, x []float64, incX int)
}

type Dzasumer 

type Dzasumer interface {
	Dzasum(n int, x []complex128, incX int) float64
}

type Dznrm2er 

type Dznrm2er interface {
	Dznrm2(n int, x []complex128, incX int) float64
	Dnrm2er
}

type Idamaxer 

type Idamaxer interface {
	Idamax(n int, x []float64, incX int) int
}

type Izamaxer 

type Izamaxer interface {
	Izamax(n int, x []complex128, incX int) int
}

type Sgerer 

type Sgerer interface {
	Sger(m, n int, alpha float32, x []float32, incX int, y []float32, incY int, a []float32, lda int)
}

type Zaxpyer 

type Zaxpyer interface {
	Zaxpy(n int, alpha complex128, x []complex128, incX int, y []complex128, incY int)
}

type Zcopyer 

type Zcopyer interface {
	Zcopy(n int, x []complex128, incX int, y []complex128, incY int)
}

type Zdotcer 

type Zdotcer interface {
	Zdotc(n int, x []complex128, incX int, y []complex128, incY int) complex128
}

type Zdotuer 

type Zdotuer interface {
	Zdotu(n int, x []complex128, incX int, y []complex128, incY int) complex128
}

type Zdscaler 

type Zdscaler interface {
	Zdscal(n int, alpha float64, x []complex128, incX int)
}

type Zgbmver 

type Zgbmver interface {
	Zgbmv(trans blas.Transpose, m, n, kL, kU int, alpha complex128, ab []complex128, ldab int, x []complex128, incX int, beta complex128, y []complex128, incY int)

	Zgemver
}

type Zgemmer 

type Zgemmer interface {
	Zgemm(tA, tB blas.Transpose, m, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
}

type Zgemver 

type Zgemver interface {
	Zgemv(trans blas.Transpose, m, n int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
}

type Zgercer 

type Zgercer interface {
	Zgerc(m, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
}

type Zgeruer 

type Zgeruer interface {
	Zgeru(m, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
}

type Zhbmver 

type Zhbmver interface {
	Zhbmv(uplo blas.Uplo, n, k int, alpha complex128, ab []complex128, ldab int, x []complex128, incX int, beta complex128, y []complex128, incY int)

	Zhemver
}

type Zhemmer 

type Zhemmer interface {
	Zhemm(side blas.Side, uplo blas.Uplo, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
}

type Zhemver 

type Zhemver interface {
	Zhemv(uplo blas.Uplo, n int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
}

type Zher2er 

type Zher2er interface {
	Zher2(uplo blas.Uplo, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
}

type Zher2ker 

type Zher2ker interface {
	Zher2k(uplo blas.Uplo, trans blas.Transpose, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta float64, c []complex128, ldc int)
}

type Zherer 

type Zherer interface {
	Zher(uplo blas.Uplo, n int, alpha float64, x []complex128, incX int, a []complex128, lda int)
}

type Zherker 

type Zherker interface {
	Zherk(uplo blas.Uplo, trans blas.Transpose, n, k int, alpha float64, a []complex128, lda int, beta float64, c []complex128, ldc int)
}

type Zhpmver 

type Zhpmver interface {
	Zhpmv(uplo blas.Uplo, n int, alpha complex128, ap []complex128, x []complex128, incX int, beta complex128, y []complex128, incY int)
}

type Zhpr2er 

type Zhpr2er interface {
	Zhpr2(uplo blas.Uplo, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, ap []complex128)
}

type Zhprer 

type Zhprer interface {
	Zhpr(uplo blas.Uplo, n int, alpha float64, x []complex128, incX int, ap []complex128)
}

type Zscaler 

type Zscaler interface {
	Zscal(n int, alpha complex128, x []complex128, incX int)
}

type Zswaper 

type Zswaper interface {
	Zswap(n int, x []complex128, incX int, y []complex128, incY int)
}

type Zsymmer 

type Zsymmer interface {
	Zsymm(side blas.Side, uplo blas.Uplo, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
}

type Zsyr2ker 

type Zsyr2ker interface {
	Zsyr2k(uplo blas.Uplo, trans blas.Transpose, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
}

type Zsyrker 

type Zsyrker interface {
	Zsyrk(uplo blas.Uplo, trans blas.Transpose, n, k int, alpha complex128, a []complex128, lda int, beta complex128, c []complex128, ldc int)
}

type Ztbmver 

type Ztbmver interface {
	Ztbmv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n, k int, ab []complex128, ldab int, x []complex128, incX int)

	Ztrmver
}

type Ztbsver 

type Ztbsver interface {
	Ztbsv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n, k int, ab []complex128, ldab int, x []complex128, incX int)

	Ztbmver
}

type Ztpmver 

type Ztpmver interface {
	Ztpmv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n int, ap []complex128, x []complex128, incX int)
}

type Ztpsver 

type Ztpsver interface {
	Ztpsv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n int, ap []complex128, x []complex128, incX int)

	Ztpmver
}

type Ztrmmer 

type Ztrmmer interface {
	Ztrmm(side blas.Side, uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int)
}

type Ztrmver 

type Ztrmver interface {
	Ztrmv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n int, a []complex128, lda int, x []complex128, incX int)
}

type Ztrsmer 

type Ztrsmer interface {
	Ztrsm(side blas.Side, uplo blas.Uplo, transA blas.Transpose, diag blas.Diag, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int)
}

type Ztrsver 

type Ztrsver interface {
	Ztrsv(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n int, a []complex128, lda int, x []complex128, incX int)

	Ztrmver
}

Source Files

View all Source files

Directories

Path Synopsis
Script for automatic code generation of the benchmark routines.
 Script for automatic code generation of the benchmark routines.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.