gonum: gonum.org/v1/gonum/blas/testblas Index | Files | Directories

package testblas

import "gonum.org/v1/gonum/blas/testblas"

Package testblas provides tests for blas implementations.

Index

Package Files

benchsize.go common.go dgbmv.go dgemm.go dgemmbench.go dgemv.go dger.go doc.go dsbmv.go dspmv.go dspr.go dspr2.go dsymm.go dsymv.go dsyr.go dsyr2.go dsyr2k.go dsyrk.go dtbmv.go dtbsv.go dtpmv.go dtpsv.go dtrmm.go dtrmv.go dtrmvbench.go dtrsm.go dtrsv.go dtxmv.go dzasum.go dznrm2.go izamax.go level1double.go level2bench.go zaxpy.go zcopy.go zdotc.go zdotu.go zdscal.go zgbmv.go zgemm.go zgemv.go zgerc.go zgeru.go zhbmv.go zhemm.go zhemv.go zher.go zher2.go zher2k.go zherk.go zhpmv.go zhpr.go zhpr2.go zscal.go zswap.go zsymm.go zsyr2k.go zsyrk.go ztbmv.go ztbsv.go ztpmv.go ztpsv.go ztrmm.go ztrmv.go ztrsm.go ztrsv.go

Constants

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

Variables

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
    },
}
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
    },
}
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},
            },
        },
    },
}
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{},
            },
        },
    },
}
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,
    },
}
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,
    },
}

func DasumTest Uses

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

func DaxpyTest Uses

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

func DcopyTest Uses

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

func DdotTest Uses

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

func DgbmvTest Uses

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

func DgemmBenchmark Uses

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

func DgemvBenchmark Uses

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

func DgemvTest Uses

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

func DgerBenchmark Uses

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

func DgerTest Uses

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

func Dnrm2Test Uses

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

func DrotTest Uses

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

func DrotgTest Uses

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

func DrotmTest Uses

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

func DrotmgTest Uses

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

func DsbmvTest Uses

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

func DscalTest Uses

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

func DspmvTest Uses

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

func Dspr2Test Uses

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

func DsprTest Uses

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

func DswapTest Uses

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

func DsymmTest Uses

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

func DsymvTest Uses

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

func Dsyr2Test Uses

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

func Dsyr2kTest Uses

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

func DsyrTest Uses

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

func DsyrkTest Uses

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

func DtbmvTest Uses

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

func DtbsvTest Uses

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

func DtpmvTest Uses

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

func DtpsvTest Uses

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

func DtrmmTest Uses

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

func DtrmvBenchmark Uses

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

func DtrmvTest Uses

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

func DtrsmTest Uses

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

func DtrsvTest Uses

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

func DtxmvTest Uses

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

func DzasumTest Uses

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

func Dznrm2Test Uses

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

func IdamaxTest Uses

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

func IzamaxTest Uses

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

func SgerBenchmark Uses

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

func TestDgemm Uses

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

func ZaxpyTest Uses

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

func ZcopyTest Uses

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

func ZdotcTest Uses

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

func ZdotuTest Uses

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

func ZdscalTest Uses

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

func ZgbmvTest Uses

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

func ZgemmTest Uses

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

func ZgemvTest Uses

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

func ZgercTest Uses

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

func ZgeruTest Uses

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

func ZhbmvTest Uses

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

func ZhemmTest Uses

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

func ZhemvTest Uses

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

func Zher2Test Uses

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

func Zher2kTest Uses

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

func ZherTest Uses

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

func ZherkTest Uses

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

func ZhpmvTest Uses

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

func Zhpr2Test Uses

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

func ZhprTest Uses

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

func ZscalTest Uses

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

func ZswapTest Uses

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

func ZsymmTest Uses

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

func Zsyr2kTest Uses

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

func ZsyrkTest Uses

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

func ZtbmvTest Uses

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

func ZtbsvTest Uses

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

func ZtpmvTest Uses

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

func ZtpsvTest Uses

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

func ZtrmmTest Uses

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

func ZtrmvTest Uses

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

func ZtrsmTest Uses

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

func ZtrsvTest Uses

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

type DScalCase Uses

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

type DTwoVecAnswer Uses

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

type Dasumer Uses

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

type DaxpyCase Uses

type DaxpyCase struct {
    Alpha float64
    Ans   []float64
}

type Daxpyer Uses

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

type Dcopier Uses

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

type Ddotter Uses

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

type Dgbmver Uses

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 Uses

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

type Dgemmer Uses

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 Uses

type DgemvCase struct {
    Name string

    A   [][]float64

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

type DgemvSubcase Uses

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

type Dgemver Uses

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 Uses

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

type Dnrm2er Uses

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

type DoubleOneVectorCase Uses

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

type DoubleTwoVectorCase Uses

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 Uses

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

type Droter Uses

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

type DrotgTestStruct Uses

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

type Drotger Uses

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

type DrotmCase Uses

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

type Drotmer Uses

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

type DrotmgTestStruct Uses

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

type Drotmger Uses

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

type Dsbmver Uses

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 Uses

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

type Dspmver Uses

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 Uses

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

type Dsprer Uses

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

type Dswapper Uses

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

type Dsyker Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

type Dtbmver Uses

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 Uses

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 Uses

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

type Dtpsver Uses

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

type Dtrmmer Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

type Dznrm2er Uses

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

type Idamaxer Uses

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

type Izamaxer Uses

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

type Sgerer Uses

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

type Zaxpyer Uses

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

type Zcopyer Uses

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

type Zdotcer Uses

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

type Zdotuer Uses

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

type Zdscaler Uses

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

type Zgbmver Uses

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 Uses

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 Uses

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 Uses

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

type Zgeruer Uses

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

type Zhbmver Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

type Zherker Uses

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 Uses

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 Uses

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

type Zhprer Uses

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

type Zscaler Uses

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

type Zswaper Uses

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

type Zsymmer Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

type Ztpsver Uses

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

    Ztpmver
}

type Ztrmmer Uses

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 Uses

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 Uses

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 Uses

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

PathSynopsis
benchautogenScript for automatic code generation of the benchmark routines.

Package testblas imports 7 packages (graph). Updated 2019-04-16. Refresh now. Tools for package owners.