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
    }

    Directories

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