Documentation

Overview

    Package testlapack implements a set of testing routines for Lapack functions.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func DbdsqrTest

    func DbdsqrTest(t *testing.T, impl Dbdsqrer)

    func DcombssqTest

    func DcombssqTest(t *testing.T, impl Dcombssqer)

    func DgebakTest

    func DgebakTest(t *testing.T, impl Dgebaker)

    func DgebalTest

    func DgebalTest(t *testing.T, impl Dgebaler)

    func Dgebd2Test

    func Dgebd2Test(t *testing.T, impl Dgebd2er)

    func DgebrdTest

    func DgebrdTest(t *testing.T, impl Dgebrder)

    func DgeconTest

    func DgeconTest(t *testing.T, impl Dgeconer)

    func DgeevBenchmark

    func DgeevBenchmark(b *testing.B, impl Dgeever)

    func DgeevTest

    func DgeevTest(t *testing.T, impl Dgeever)

    func Dgehd2Test

    func Dgehd2Test(t *testing.T, impl Dgehd2er)

    func DgehrdTest

    func DgehrdTest(t *testing.T, impl Dgehrder)

    func Dgelq2Test

    func Dgelq2Test(t *testing.T, impl Dgelq2er)

    func DgelqfTest

    func DgelqfTest(t *testing.T, impl Dgelqfer)

    func DgelsTest

    func DgelsTest(t *testing.T, impl Dgelser)

    func Dgeql2Test

    func Dgeql2Test(t *testing.T, impl Dgeql2er)

    func Dgeqp3Test

    func Dgeqp3Test(t *testing.T, impl Dgeqp3er)

    func Dgeqr2Test

    func Dgeqr2Test(t *testing.T, impl Dgeqr2er)

    func DgeqrfTest

    func DgeqrfTest(t *testing.T, impl Dgeqrfer)

    func Dgerq2Test

    func Dgerq2Test(t *testing.T, impl Dgerq2er)

    func DgerqfTest

    func DgerqfTest(t *testing.T, impl Dgerqfer)

    func DgesvdTest

    func DgesvdTest(t *testing.T, impl Dgesvder, tol float64)

    func Dgetf2Test

    func Dgetf2Test(t *testing.T, impl Dgetf2er)

    func DgetrfTest

    func DgetrfTest(t *testing.T, impl Dgetrfer)

    func DgetriTest

    func DgetriTest(t *testing.T, impl Dgetrier)

    func DgetrsTest

    func DgetrsTest(t *testing.T, impl Dgetrser)

    func Dggsvd3Test

    func Dggsvd3Test(t *testing.T, impl Dggsvd3er)

    func Dggsvp3Test

    func Dggsvp3Test(t *testing.T, impl Dggsvp3er)

    func DgtsvTest

    func DgtsvTest(t *testing.T, impl Dgtsver)

    func DhseqrTest

    func DhseqrTest(t *testing.T, impl Dhseqrer)

    func DlabrdTest

    func DlabrdTest(t *testing.T, impl Dlabrder)

    func Dlacn2Test

    func Dlacn2Test(t *testing.T, impl Dlacn2er)

    func DlacpyTest

    func DlacpyTest(t *testing.T, impl Dlacpyer)

    func Dlae2Test

    func Dlae2Test(t *testing.T, impl Dlae2er)

    func Dlaev2Test

    func Dlaev2Test(t *testing.T, impl Dlaev2er)

    func DlaexcTest

    func DlaexcTest(t *testing.T, impl Dlaexcer)

    func Dlagge

    func Dlagge(m, n, kl, ku int, d []float64, a []float64, lda int, rnd *rand.Rand, work []float64)

      Dlagge generates a real general m×n matrix A, by pre- and post-multiplying a real diagonal matrix D with random orthogonal matrices:

      A = U*D*V.
      

      d must have length min(m,n), and work must have length m+n, otherwise Dlagge will panic.

      The parameters ku and kl are unused but they must satisfy

      0 <= kl <= m-1,
      0 <= ku <= n-1.
      

      func Dlags2Test

      func Dlags2Test(t *testing.T, impl Dlags2er)

      func Dlagsy

      func Dlagsy(n, k int, d []float64, a []float64, lda int, rnd *rand.Rand, work []float64)

        Dlagsy generates an n×n symmetric matrix A, by pre- and post- multiplying a real diagonal matrix D with a random orthogonal matrix:

        A = U * D * Uᵀ.
        

        work must have length at least 2*n, otherwise Dlagsy will panic.

        The parameter k is unused but it must satisfy

        0 <= k <= n-1.
        

        func DlagtmTest

        func DlagtmTest(t *testing.T, impl Dlagtmer)

        func DlahqrTest

        func DlahqrTest(t *testing.T, impl Dlahqrer)

        func Dlahr2Test

        func Dlahr2Test(t *testing.T, impl Dlahr2er)

        func Dlaln2Test

        func Dlaln2Test(t *testing.T, impl Dlaln2er)

        func DlangeTest

        func DlangeTest(t *testing.T, impl Dlanger)

        func DlangtTest

        func DlangtTest(t *testing.T, impl Dlangter)

        func DlansbTest

        func DlansbTest(t *testing.T, impl Dlansber)

        func DlanstTest

        func DlanstTest(t *testing.T, impl Dlanster)

        func DlansyTest

        func DlansyTest(t *testing.T, impl Dlansyer)

        func DlantbBenchmark

        func DlantbBenchmark(b *testing.B, impl Dlantber)

        func DlantbTest

        func DlantbTest(t *testing.T, impl Dlantber)

        func DlantrTest

        func DlantrTest(t *testing.T, impl Dlantrer)

        func Dlanv2Test

        func Dlanv2Test(t *testing.T, impl Dlanv2er)

        func DlapllTest

        func DlapllTest(t *testing.T, impl Dlapller)

        func DlapmtTest

        func DlapmtTest(t *testing.T, impl Dlapmter)

        func Dlapy2Test

        func Dlapy2Test(t *testing.T, impl Dlapy2er)

        func Dlaqp2Test

        func Dlaqp2Test(t *testing.T, impl Dlaqp2er)

        func DlaqpsTest

        func DlaqpsTest(t *testing.T, impl Dlaqpser)

        func Dlaqr04Test

        func Dlaqr04Test(t *testing.T, impl Dlaqr04er)

        func Dlaqr1Test

        func Dlaqr1Test(t *testing.T, impl Dlaqr1er)

        func Dlaqr23Test

        func Dlaqr23Test(t *testing.T, impl Dlaqr23er)

        func Dlaqr5Test

        func Dlaqr5Test(t *testing.T, impl Dlaqr5er)

        func DlarfTest

        func DlarfTest(t *testing.T, impl Dlarfer)

        func DlarfbTest

        func DlarfbTest(t *testing.T, impl Dlarfber)

        func DlarfgTest

        func DlarfgTest(t *testing.T, impl Dlarfger)

        func DlarftTest

        func DlarftTest(t *testing.T, impl Dlarfter)

        func DlarfxTest

        func DlarfxTest(t *testing.T, impl Dlarfxer)

        func DlartgTest

        func DlartgTest(t *testing.T, impl Dlartger)

        func Dlas2Test

        func Dlas2Test(t *testing.T, impl Dlas2er)

        func DlasclTest

        func DlasclTest(t *testing.T, impl Dlascler)

        func DlasetTest

        func DlasetTest(t *testing.T, impl Dlaseter)

        func Dlasq1Test

        func Dlasq1Test(t *testing.T, impl Dlasq1er)

        func Dlasq2Test

        func Dlasq2Test(t *testing.T, impl Dlasq2er)

        func DlasrTest

        func DlasrTest(t *testing.T, impl Dlasrer)

        func DlasrtTest

        func DlasrtTest(t *testing.T, impl Dlasrter)

        func DlassqTest

        func DlassqTest(t *testing.T, impl Dlassqer)

        func Dlasv2Test

        func Dlasv2Test(t *testing.T, impl Dlasv2er)

        func DlaswpTest

        func DlaswpTest(t *testing.T, impl Dlaswper)

        func Dlasy2Test

        func Dlasy2Test(t *testing.T, impl Dlasy2er)

        func DlatbsTest

        func DlatbsTest(t *testing.T, impl Dlatbser)

          DlatbsTest tests Dlatbs by generating a random triangular band system and checking that a residual for the computed solution is small.

          func Dlatm1

          func Dlatm1(dst []float64, mode int, cond float64, rsign bool, dist int, rnd *rand.Rand)

            Dlatm1 computes the entries of dst as specified by mode, cond and rsign.

            mode describes how dst will be computed:

            |mode| == 1: dst[0] = 1 and dst[1:n] = 1/cond
            |mode| == 2: dst[:n-1] = 1/cond and dst[n-1] = 1
            |mode| == 3: dst[i] = cond^{-i/(n-1)}, i=0,...,n-1
            |mode| == 4: dst[i] = 1 - i*(1-1/cond)/(n-1)
            |mode| == 5: dst[i] = random number in the range (1/cond, 1) such that
                              their logarithms are uniformly distributed
            |mode| == 6: dst[i] = random number from the distribution given by dist
            

            If mode is negative, the order of the elements of dst will be reversed. For other values of mode Dlatm1 will panic.

            If rsign is true and mode is not ±6, each entry of dst will be multiplied by 1 or -1 with probability 0.5

            dist specifies the type of distribution to be used when mode == ±6:

            dist == 1: Uniform[0,1)
            dist == 2: Uniform[-1,1)
            dist == 3: Normal(0,1)
            

            For other values of dist Dlatm1 will panic.

            rnd is used as a source of random numbers.

            func DlatrdTest

            func DlatrdTest(t *testing.T, impl Dlatrder)

            func DlatrsTest

            func DlatrsTest(t *testing.T, impl Dlatrser)

            func Dlauu2Test

            func Dlauu2Test(t *testing.T, impl Dlauu2er)

            func DlauumTest

            func DlauumTest(t *testing.T, impl Dlauumer)

            func Dorg2lTest

            func Dorg2lTest(t *testing.T, impl Dorg2ler)

            func Dorg2rTest

            func Dorg2rTest(t *testing.T, impl Dorg2rer)

            func DorgbrTest

            func DorgbrTest(t *testing.T, impl Dorgbrer)

            func DorghrTest

            func DorghrTest(t *testing.T, impl Dorghrer)

            func Dorgl2Test

            func Dorgl2Test(t *testing.T, impl Dorgl2er)

            func DorglqTest

            func DorglqTest(t *testing.T, impl Dorglqer)

            func DorgqlTest

            func DorgqlTest(t *testing.T, impl Dorgqler)

            func DorgqrTest

            func DorgqrTest(t *testing.T, impl Dorgqrer)

            func DorgtrTest

            func DorgtrTest(t *testing.T, impl Dorgtrer)

            func Dorm2rTest

            func Dorm2rTest(t *testing.T, impl Dorm2rer)

            func DormbrTest

            func DormbrTest(t *testing.T, impl Dormbrer)

            func DormhrTest

            func DormhrTest(t *testing.T, impl Dormhrer)

            func Dorml2Test

            func Dorml2Test(t *testing.T, impl Dorml2er)

            func DormlqTest

            func DormlqTest(t *testing.T, impl Dormlqer)

            func DormqrTest

            func DormqrTest(t *testing.T, impl Dormqrer)

            func Dormr2Test

            func Dormr2Test(t *testing.T, impl Dormr2er)

            func DpbconTest

            func DpbconTest(t *testing.T, impl Dpbconer)

              DpbconTest tests Dpbcon by generating a random symmetric band matrix A and checking that the estimated condition number is not too different from the condition number computed via the explicit inverse of A.

              func Dpbtf2Test

              func Dpbtf2Test(t *testing.T, impl Dpbtf2er)

                Dpbtf2Test tests Dpbtf2 on random symmetric positive definite band matrices by checking that the Cholesky factors multiply back to the original matrix.

                func DpbtrfTest

                func DpbtrfTest(t *testing.T, impl Dpbtrfer)

                  DpbtrfTest tests a band Cholesky factorization on random symmetric positive definite band matrices by checking that the Cholesky factors multiply back to the original matrix.

                  func DpbtrsTest

                  func DpbtrsTest(t *testing.T, impl Dpbtrser)

                    DpbtrsTest tests Dpbtrs by comparing the computed and known, generated solutions of a linear system with a random symmetric positive definite band matrix.

                    func DpoconTest

                    func DpoconTest(t *testing.T, impl Dpoconer)

                    func Dpotf2Test

                    func Dpotf2Test(t *testing.T, impl Dpotf2er)

                    func DpotrfTest

                    func DpotrfTest(t *testing.T, impl Dpotrfer)

                    func DpotriTest

                    func DpotriTest(t *testing.T, impl Dpotrier)

                    func DpotrsTest

                    func DpotrsTest(t *testing.T, impl Dpotrser)

                    func DrsclTest

                    func DrsclTest(t *testing.T, impl Drscler)

                    func DsteqrTest

                    func DsteqrTest(t *testing.T, impl Dsteqrer)

                    func DsterfTest

                    func DsterfTest(t *testing.T, impl Dsterfer)

                    func DsyevTest

                    func DsyevTest(t *testing.T, impl Dsyever)

                    func Dsytd2Test

                    func Dsytd2Test(t *testing.T, impl Dsytd2er)

                    func DsytrdTest

                    func DsytrdTest(t *testing.T, impl Dsytrder)

                    func DtbtrsTest

                    func DtbtrsTest(t *testing.T, impl Dtbtrser)

                    func DtgsjaTest

                    func DtgsjaTest(t *testing.T, impl Dtgsjaer)

                    func DtrconTest

                    func DtrconTest(t *testing.T, impl Dtrconer)

                    func Dtrevc3Test

                    func Dtrevc3Test(t *testing.T, impl Dtrevc3er)

                    func DtrexcTest

                    func DtrexcTest(t *testing.T, impl Dtrexcer)

                    func Dtrti2Test

                    func Dtrti2Test(t *testing.T, impl Dtrti2er)

                    func DtrtriTest

                    func DtrtriTest(t *testing.T, impl Dtrtrier)

                    func DtrtrsTest

                    func DtrtrsTest(t *testing.T, impl Dtrtrser)

                    func IladlcTest

                    func IladlcTest(t *testing.T, impl Iladlcer)

                    func IladlrTest

                    func IladlrTest(t *testing.T, impl Iladlrer)

                    Types

                    type A123

                    type A123 struct{}

                      A123 is the non-symmetric singular matrix

                          [ 1 2 3 ]
                      A = [ 4 5 6 ]
                          [ 7 8 9 ]
                      

                      It has three distinct real eigenvalues.

                      func (A123) Eigenvalues

                      func (A123) Eigenvalues() []complex128

                      func (A123) LeftEV

                      func (A123) LeftEV() blas64.General

                      func (A123) Matrix

                      func (A123) Matrix() blas64.General

                      func (A123) RightEV

                      func (A123) RightEV() blas64.General

                      type AntisymRandom

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

                        AntisymRandom is a anti-symmetric random matrix. All its eigenvalues are imaginary with one zero if the order is odd.

                        func NewAntisymRandom

                        func NewAntisymRandom(n int, rnd *rand.Rand) AntisymRandom

                        func (AntisymRandom) Eigenvalues

                        func (AntisymRandom) Eigenvalues() []complex128

                        func (AntisymRandom) Matrix

                        func (a AntisymRandom) Matrix() blas64.General

                        type Circulant

                        type Circulant int

                          Circulant is a generally non-symmetric matrix given by

                          A[i,j] = 1 + (j-i+n)%n.
                          

                          For example, for n=5,

                              [ 1 2 3 4 5 ]
                              [ 5 1 2 3 4 ]
                          A = [ 4 5 1 2 3 ]
                              [ 3 4 5 1 2 ]
                              [ 2 3 4 5 1 ]
                          

                          It has real and complex eigenvalues, some possibly repeated.

                          func (Circulant) Eigenvalues

                          func (c Circulant) Eigenvalues() []complex128

                          func (Circulant) Matrix

                          func (c Circulant) Matrix() blas64.General

                          type Clement

                          type Clement int

                            Clement is a generally non-symmetric matrix given by

                            A[i,j] = i+1  if j == i+1,
                                   = n-i  if j == i-1,
                                   = 0    otherwise.
                            

                            For example, for n=5,

                                [ . 1 . . . ]
                                [ 4 . 2 . . ]
                            A = [ . 3 . 3 . ]
                                [ . . 2 . 4 ]
                                [ . . . 1 . ]
                            

                            It has n distinct real eigenvalues.

                            func (Clement) Eigenvalues

                            func (c Clement) Eigenvalues() []complex128

                            func (Clement) Matrix

                            func (c Clement) Matrix() blas64.General

                            type Creation

                            type Creation int

                              Creation is a singular non-symmetric matrix given by

                              A[i,j] = i  if j == i-1,
                                     = 0  otherwise.
                              

                              For example, for n=5,

                                  [ . . . . . ]
                                  [ 1 . . . . ]
                              A = [ . 2 . . . ]
                                  [ . . 3 . . ]
                                  [ . . . 4 . ]
                              

                              Zero is its only eigenvalue.

                              func (Creation) Eigenvalues

                              func (c Creation) Eigenvalues() []complex128

                              func (Creation) Matrix

                              func (c Creation) Matrix() blas64.General

                              type Dbdsqrer

                              type Dbdsqrer interface {
                              	Dbdsqr(uplo blas.Uplo, n, ncvt, nru, ncc int, d, e, vt []float64, ldvt int, u []float64, ldu int, c []float64, ldc int, work []float64) (ok bool)
                              }

                              type Dcombssqer

                              type Dcombssqer interface {
                              	Dcombssq(scale1, ssq1, scale2, ssq2 float64) (scale, ssq float64)
                              }

                              type Dgebaker

                              type Dgebaker interface {
                              	Dgebak(job lapack.BalanceJob, side lapack.EVSide, n, ilo, ihi int, scale []float64, m int, v []float64, ldv int)
                              }

                              type Dgebaler

                              type Dgebaler interface {
                              	Dgebal(job lapack.BalanceJob, n int, a []float64, lda int, scale []float64) (int, int)
                              }

                              type Dgebd2er

                              type Dgebd2er interface {
                              	Dgebd2(m, n int, a []float64, lda int, d, e, tauq, taup, work []float64)
                              }

                              type Dgebrder

                              type Dgebrder interface {
                              	Dgebrd(m, n int, a []float64, lda int, d, e, tauQ, tauP, work []float64, lwork int)
                              	Dgebd2er
                              }

                              type Dgeconer

                              type Dgeconer interface {
                              	Dgecon(norm lapack.MatrixNorm, n int, a []float64, lda int, anorm float64, work []float64, iwork []int) float64
                              
                              	Dgetrier
                              	Dlanger
                              }

                              type Dgeever

                              type Dgeever interface {
                              	Dgeev(jobvl lapack.LeftEVJob, jobvr lapack.RightEVJob, n int, a []float64, lda int,
                              		wr, wi []float64, vl []float64, ldvl int, vr []float64, ldvr int, work []float64, lwork int) int
                              }

                              type Dgehd2er

                              type Dgehd2er interface {
                              	Dgehd2(n, ilo, ihi int, a []float64, lda int, tau, work []float64)
                              }

                              type Dgehrder

                              type Dgehrder interface {
                              	Dgehrd(n, ilo, ihi int, a []float64, lda int, tau, work []float64, lwork int)
                              
                              	Dorgqr(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                              }

                              type Dgelq2er

                              type Dgelq2er interface {
                              	Dgelq2(m, n int, a []float64, lda int, tau, work []float64)
                              }

                              type Dgelqfer

                              type Dgelqfer interface {
                              	Dgelq2er
                              	Dgelqf(m, n int, a []float64, lda int, tau, work []float64, lwork int)
                              }

                              type Dgelser

                              type Dgelser interface {
                              	Dgels(trans blas.Transpose, m, n, nrhs int, a []float64, lda int, b []float64, ldb int, work []float64, lwork int) bool
                              }

                              type Dgeql2er

                              type Dgeql2er interface {
                              	Dgeql2(m, n int, a []float64, lda int, tau, work []float64)
                              }

                              type Dgeqp3er

                              type Dgeqp3er interface {
                              	Dlapmter
                              	Dgeqp3(m, n int, a []float64, lda int, jpvt []int, tau, work []float64, lwork int)
                              }

                              type Dgeqr2er

                              type Dgeqr2er interface {
                              	Dgeqr2(m, n int, a []float64, lda int, tau []float64, work []float64)
                              }

                              type Dgeqrfer

                              type Dgeqrfer interface {
                              	Dgeqr2er
                              	Dgeqrf(m, n int, a []float64, lda int, tau, work []float64, lwork int)
                              }

                              type Dgerq2er

                              type Dgerq2er interface {
                              	Dgerq2(m, n int, a []float64, lda int, tau []float64, work []float64)
                              }

                              type Dgerqfer

                              type Dgerqfer interface {
                              	Dgerqf(m, n int, a []float64, lda int, tau, work []float64, lwork int)
                              }

                              type Dgesvder

                              type Dgesvder interface {
                              	Dgesvd(jobU, jobVT lapack.SVDJob, m, n int, a []float64, lda int, s, u []float64, ldu int, vt []float64, ldvt int, work []float64, lwork int) (ok bool)
                              }

                              type Dgetf2er

                              type Dgetf2er interface {
                              	Dgetf2(m, n int, a []float64, lda int, ipiv []int) bool
                              }

                              type Dgetrfer

                              type Dgetrfer interface {
                              	Dgetrf(m, n int, a []float64, lda int, ipiv []int) bool
                              }

                              type Dgetrier

                              type Dgetrier interface {
                              	Dgetrfer
                              	Dgetri(n int, a []float64, lda int, ipiv []int, work []float64, lwork int) bool
                              }

                              type Dgetrser

                              type Dgetrser interface {
                              	Dgetrfer
                              	Dgetrs(trans blas.Transpose, n, nrhs int, a []float64, lda int, ipiv []int, b []float64, ldb int)
                              }

                              type Dggsvd3er

                              type Dggsvd3er interface {
                              	Dggsvd3(jobU, jobV, jobQ lapack.GSVDJob, m, n, p int, a []float64, lda int, b []float64, ldb int, alpha, beta, u []float64, ldu int, v []float64, ldv int, q []float64, ldq int, work []float64, lwork int, iwork []int) (k, l int, ok bool)
                              }

                              type Dggsvp3er

                              type Dggsvp3er interface {
                              	Dlanger
                              	Dggsvp3(jobU, jobV, jobQ lapack.GSVDJob, m, p, n int, a []float64, lda int, b []float64, ldb int, tola, tolb float64, u []float64, ldu int, v []float64, ldv int, q []float64, ldq int, iwork []int, tau, work []float64, lwork int) (k, l int)
                              }

                              type Dgtsver

                              type Dgtsver interface {
                              	Dgtsv(n, nrhs int, dl, d, du []float64, b []float64, ldb int) (ok bool)
                              }

                              type Dhseqrer

                              type Dhseqrer interface {
                              	Dhseqr(job lapack.SchurJob, compz lapack.SchurComp, n, ilo, ihi int, h []float64, ldh int, wr, wi []float64,
                              		z []float64, ldz int, work []float64, lwork int) int
                              }

                              type Diagonal

                              type Diagonal int

                                Diagonal is a diagonal matrix given by

                                A[i,j] = i+1  if i == j,
                                       = 0    otherwise.
                                

                                For example, for n=5,

                                    [ 1 . . . . ]
                                    [ . 2 . . . ]
                                A = [ . . 3 . . ]
                                    [ . . . 4 . ]
                                    [ . . . . 5 ]
                                

                                It has n real eigenvalues {1,...,n}.

                                func (Diagonal) Eigenvalues

                                func (d Diagonal) Eigenvalues() []complex128

                                func (Diagonal) Matrix

                                func (d Diagonal) Matrix() blas64.General

                                type Dlabrder

                                type Dlabrder interface {
                                	Dlabrd(m, n, nb int, a []float64, lda int, d, e, tauq, taup, x []float64, ldx int, y []float64, ldy int)
                                }

                                type Dlacn2er

                                type Dlacn2er interface {
                                	Dlacn2(n int, v, x []float64, isgn []int, est float64, kase int, isave *[3]int) (float64, int)
                                }

                                type Dlacpyer

                                type Dlacpyer interface {
                                	Dlacpy(uplo blas.Uplo, m, n int, a []float64, lda int, b []float64, ldb int)
                                }

                                type Dlae2er

                                type Dlae2er interface {
                                	Dlae2(a, b, c float64) (rt1, rt2 float64)
                                }

                                type Dlaev2er

                                type Dlaev2er interface {
                                	Dlaev2(a, b, c float64) (rt1, rt2, cs1, sn1 float64)
                                }

                                type Dlaexcer

                                type Dlaexcer interface {
                                	Dlaexc(wantq bool, n int, t []float64, ldt int, q []float64, ldq int, j1, n1, n2 int, work []float64) bool
                                }

                                type Dlags2er

                                type Dlags2er interface {
                                	Dlags2(upper bool, a1, a2, a3, b1, b2, b3 float64) (csu, snu, csv, snv, csq, snq float64)
                                }

                                type Dlagtmer

                                type Dlagtmer interface {
                                	Dlagtm(trans blas.Transpose, m, n int, alpha float64, dl, d, du []float64, b []float64, ldb int, beta float64, c []float64, ldc int)
                                }

                                type Dlahqrer

                                type Dlahqrer interface {
                                	Dlahqr(wantt, wantz bool, n, ilo, ihi int, h []float64, ldh int, wr, wi []float64, iloz, ihiz int, z []float64, ldz int) int
                                }

                                type Dlahr2er

                                type Dlahr2er interface {
                                	Dlahr2(n, k, nb int, a []float64, lda int, tau, t []float64, ldt int, y []float64, ldy int)
                                }

                                type Dlaln2er

                                type Dlaln2er interface {
                                	Dlaln2(trans bool, na, nw int, smin, ca float64, a []float64, lda int, d1, d2 float64, b []float64, ldb int, wr, wi float64, x []float64, ldx int) (scale, xnorm float64, ok bool)
                                }

                                type Dlanger

                                type Dlanger interface {
                                	Dlange(norm lapack.MatrixNorm, m, n int, a []float64, lda int, work []float64) float64
                                }

                                type Dlangter

                                type Dlangter interface {
                                	Dlangt(norm lapack.MatrixNorm, n int, dl, d, du []float64) float64
                                }

                                type Dlansber

                                type Dlansber interface {
                                	Dlansb(norm lapack.MatrixNorm, uplo blas.Uplo, n, kd int, ab []float64, ldab int, work []float64) float64
                                }

                                type Dlanster

                                type Dlanster interface {
                                	Dlanst(norm lapack.MatrixNorm, n int, d, e []float64) float64
                                	Dlanger
                                }

                                type Dlansyer

                                type Dlansyer interface {
                                	Dlanger
                                	Dlansy(norm lapack.MatrixNorm, uplo blas.Uplo, n int, a []float64, lda int, work []float64) float64
                                }

                                type Dlantber

                                type Dlantber interface {
                                	Dlantb(norm lapack.MatrixNorm, uplo blas.Uplo, diag blas.Diag, n, k int, a []float64, lda int, work []float64) float64
                                }

                                type Dlantrer

                                type Dlantrer interface {
                                	Dlanger
                                	Dlantr(norm lapack.MatrixNorm, uplo blas.Uplo, diag blas.Diag, m, n int, a []float64, lda int, work []float64) float64
                                }

                                type Dlanv2er

                                type Dlanv2er interface {
                                	Dlanv2(a, b, c, d float64) (aa, bb, cc, dd float64, rt1r, rt1i, rt2r, rt2i float64, cs, sn float64)
                                }

                                type Dlapller

                                type Dlapller interface {
                                	Dgesvder
                                	Dlapll(n int, x []float64, incX int, y []float64, incY int) float64
                                }

                                type Dlapmter

                                type Dlapmter interface {
                                	Dlapmt(forward bool, m, n int, x []float64, ldx int, k []int)
                                }

                                type Dlapy2er

                                type Dlapy2er interface {
                                	Dlapy2(float64, float64) float64
                                }

                                type Dlaqp2er

                                type Dlaqp2er interface {
                                	Dlapmter
                                	Dlaqp2(m, n, offset int, a []float64, lda int, jpvt []int, tau, vn1, vn2, work []float64)
                                }

                                type Dlaqpser

                                type Dlaqpser interface {
                                	Dlapmter
                                	Dlaqps(m, n, offset, nb int, a []float64, lda int, jpvt []int, tau, vn1, vn2, auxv, f []float64, ldf int) (kb int)
                                }

                                type Dlaqr04er

                                type Dlaqr04er interface {
                                	Dlaqr04(wantt, wantz bool, n, ilo, ihi int, h []float64, ldh int, wr, wi []float64, iloz, ihiz int, z []float64, ldz int, work []float64, lwork int, recur int) int
                                
                                	Dlahqrer
                                }

                                type Dlaqr1er

                                type Dlaqr1er interface {
                                	Dlaqr1(n int, h []float64, ldh int, sr1, si1, sr2, si2 float64, v []float64)
                                }

                                type Dlaqr23er

                                type Dlaqr23er interface {
                                	Dlaqr23(wantt, wantz bool, n, ktop, kbot, nw int, h []float64, ldh int, iloz, ihiz int, z []float64, ldz int, sr, si []float64, v []float64, ldv int, nh int, t []float64, ldt int, nv int, wv []float64, ldwv int, work []float64, lwork int, recur int) (ns, nd int)
                                }

                                type Dlaqr5er

                                type Dlaqr5er interface {
                                	Dlaqr5(wantt, wantz bool, kacc22 int, n, ktop, kbot, nshfts int, sr, si []float64, h []float64, ldh int, iloz, ihiz int, z []float64, ldz int, v []float64, ldv int, u []float64, ldu int, nh int, wh []float64, ldwh int, nv int, wv []float64, ldwv int)
                                }

                                type Dlarfber

                                type Dlarfber interface {
                                	Dlarfter
                                	Dlarfb(side blas.Side, trans blas.Transpose, direct lapack.Direct,
                                		store lapack.StoreV, m, n, k int, v []float64, ldv int, t []float64, ldt int,
                                		c []float64, ldc int, work []float64, ldwork int)
                                }

                                type Dlarfer

                                type Dlarfer interface {
                                	Dlarf(side blas.Side, m, n int, v []float64, incv int, tau float64, c []float64, ldc int, work []float64)
                                }

                                type Dlarfger

                                type Dlarfger interface {
                                	Dlarfg(n int, alpha float64, x []float64, incX int) (beta, tau float64)
                                }

                                type Dlarfter

                                type Dlarfter interface {
                                	Dgeqr2er
                                	Dlarft(direct lapack.Direct, store lapack.StoreV, n, k int, v []float64, ldv int, tau []float64, t []float64, ldt int)
                                }

                                type Dlarfxer

                                type Dlarfxer interface {
                                	Dlarfx(side blas.Side, m, n int, v []float64, tau float64, c []float64, ldc int, work []float64)
                                }

                                type Dlartger

                                type Dlartger interface {
                                	Dlartg(f, g float64) (cs, sn, r float64)
                                }

                                type Dlas2er

                                type Dlas2er interface {
                                	Dlas2(f, g, h float64) (min, max float64)
                                }

                                type Dlascler

                                type Dlascler interface {
                                	Dlascl(kind lapack.MatrixType, kl, ku int, cfrom, cto float64, m, n int, a []float64, lda int)
                                }

                                type Dlaseter

                                type Dlaseter interface {
                                	Dlaset(uplo blas.Uplo, m, n int, alpha, beta float64, a []float64, lda int)
                                }

                                type Dlasq1er

                                type Dlasq1er interface {
                                	Dlasq1(n int, d, e, work []float64) int
                                
                                	Dgebrd(m, n int, a []float64, lda int, d, e, tauQ, tauP, work []float64, lwork int)
                                }

                                type Dlasq2er

                                type Dlasq2er interface {
                                	Dlasq2(n int, z []float64) (info int)
                                
                                	Dsyev(jobz lapack.EVJob, uplo blas.Uplo, n int, a []float64, lda int, w, work []float64, lwork int) (ok bool)
                                }

                                type Dlasrer

                                type Dlasrer interface {
                                	Dlasr(side blas.Side, pivot lapack.Pivot, direct lapack.Direct, m, n int, c, s, a []float64, lda int)
                                }

                                type Dlasrter

                                type Dlasrter interface {
                                	Dlasrt(s lapack.Sort, n int, d []float64)
                                }

                                type Dlassqer

                                type Dlassqer interface {
                                	Dlassq(n int, x []float64, incx int, scale, ssq float64) (float64, float64)
                                }

                                type Dlasv2er

                                type Dlasv2er interface {
                                	Dlasv2(f, g, h float64) (ssmin, ssmax, snr, csr, snl, csl float64)
                                }

                                type Dlaswper

                                type Dlaswper interface {
                                	Dlaswp(n int, a []float64, lda, k1, k2 int, ipiv []int, incX int)
                                }

                                type Dlasy2er

                                type Dlasy2er interface {
                                	Dlasy2(tranl, tranr bool, isgn, n1, n2 int, tl []float64, ldtl int, tr []float64, ldtr int, b []float64, ldb int, x []float64, ldx int) (scale, xnorm float64, ok bool)
                                }

                                type Dlatbser

                                type Dlatbser interface {
                                	Dlatbs(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, normin bool, n, kd int, ab []float64, ldab int, x []float64, cnorm []float64) float64
                                }

                                type Dlatrder

                                type Dlatrder interface {
                                	Dlatrd(uplo blas.Uplo, n, nb int, a []float64, lda int, e, tau, w []float64, ldw int)
                                }

                                type Dlatrser

                                type Dlatrser interface {
                                	Dlatrs(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, normin bool, n int, a []float64, lda int, x []float64, cnorm []float64) (scale float64)
                                }

                                type Dlauu2er

                                type Dlauu2er interface {
                                	Dlauu2(uplo blas.Uplo, n int, a []float64, lda int)
                                }

                                type Dlauumer

                                type Dlauumer interface {
                                	Dlauum(uplo blas.Uplo, n int, a []float64, lda int)
                                }

                                type Dorg2ler

                                type Dorg2ler interface {
                                	Dorg2l(m, n, k int, a []float64, lda int, tau, work []float64)
                                	Dgeql2er
                                }

                                type Dorg2rer

                                type Dorg2rer interface {
                                	Dgeqrfer
                                	Dorg2r(m, n, k int, a []float64, lda int, tau []float64, work []float64)
                                }

                                type Dorgbrer

                                type Dorgbrer interface {
                                	Dorgbr(vect lapack.GenOrtho, m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                	Dgebrder
                                }

                                type Dorghrer

                                type Dorghrer interface {
                                	Dorghr(n, ilo, ihi int, a []float64, lda int, tau, work []float64, lwork int)
                                
                                	Dgehrder
                                }

                                type Dorgl2er

                                type Dorgl2er interface {
                                	Dgelqfer
                                	Dorgl2(m, n, k int, a []float64, lda int, tau []float64, work []float64)
                                }

                                type Dorglqer

                                type Dorglqer interface {
                                	Dorgl2er
                                	Dorglq(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                }

                                type Dorgqler

                                type Dorgqler interface {
                                	Dorgql(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                
                                	Dlarfger
                                }

                                type Dorgqrer

                                type Dorgqrer interface {
                                	Dorg2rer
                                	Dorgqr(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                }

                                type Dorgtrer

                                type Dorgtrer interface {
                                	Dorgtr(uplo blas.Uplo, n int, a []float64, lda int, tau, work []float64, lwork int)
                                	Dsytrder
                                }

                                type Dorm2rer

                                type Dorm2rer interface {
                                	Dgeqrfer
                                	Dorm2r(side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64)
                                }

                                type Dormbrer

                                type Dormbrer interface {
                                	Dormbr(vect lapack.ApplyOrtho, side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64, lwork int)
                                	Dgebrder
                                }

                                type Dormhrer

                                type Dormhrer interface {
                                	Dormhr(side blas.Side, trans blas.Transpose, m, n, ilo, ihi int, a []float64, lda int, tau, c []float64, ldc int, work []float64, lwork int)
                                
                                	Dgehrder
                                }

                                type Dorml2er

                                type Dorml2er interface {
                                	Dgelqfer
                                	Dorml2(side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64)
                                }

                                type Dormlqer

                                type Dormlqer interface {
                                	Dorml2er
                                	Dormlq(side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64, lwork int)
                                }

                                type Dormqrer

                                type Dormqrer interface {
                                	Dorm2rer
                                	Dormqr(side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64, lwork int)
                                }

                                type Dormr2er

                                type Dormr2er interface {
                                	Dgerqf(m, n int, a []float64, lda int, tau, work []float64, lwork int)
                                	Dormr2(side blas.Side, trans blas.Transpose, m, n, k int, a []float64, lda int, tau, c []float64, ldc int, work []float64)
                                }

                                type Downshift

                                type Downshift int

                                  Downshift is a non-singular upper Hessenberg matrix given by

                                  A[i,j] = 1  if (i-j+n)%n == 1,
                                         = 0  otherwise.
                                  

                                  For example, for n=5,

                                      [ . . . . 1 ]
                                      [ 1 . . . . ]
                                  A = [ . 1 . . . ]
                                      [ . . 1 . . ]
                                      [ . . . 1 . ]
                                  

                                  Its eigenvalues are the complex roots of unity.

                                  func (Downshift) Eigenvalues

                                  func (d Downshift) Eigenvalues() []complex128

                                  func (Downshift) Matrix

                                  func (d Downshift) Matrix() blas64.General

                                  type Dpbconer

                                  type Dpbconer interface {
                                  	Dpbcon(uplo blas.Uplo, n, kd int, ab []float64, ldab int, anorm float64, work []float64, iwork []int) float64
                                  
                                  	Dpbtrser
                                  }

                                  type Dpbtf2er

                                  type Dpbtf2er interface {
                                  	Dpbtf2(uplo blas.Uplo, n, kd int, ab []float64, ldab int) (ok bool)
                                  }

                                  type Dpbtrfer

                                  type Dpbtrfer interface {
                                  	Dpbtrf(uplo blas.Uplo, n, kd int, ab []float64, ldab int) (ok bool)
                                  }

                                  type Dpbtrser

                                  type Dpbtrser interface {
                                  	Dpbtrs(uplo blas.Uplo, n, kd, nrhs int, ab []float64, ldab int, b []float64, ldb int)
                                  
                                  	Dpbtrfer
                                  }

                                  type Dpoconer

                                  type Dpoconer interface {
                                  	Dpotrfer
                                  	Dgeconer
                                  	Dlansy(norm lapack.MatrixNorm, uplo blas.Uplo, n int, a []float64, lda int, work []float64) float64
                                  	Dpocon(uplo blas.Uplo, n int, a []float64, lda int, anorm float64, work []float64, iwork []int) float64
                                  }

                                  type Dpotf2er

                                  type Dpotf2er interface {
                                  	Dpotf2(ul blas.Uplo, n int, a []float64, lda int) (ok bool)
                                  }

                                  type Dpotrfer

                                  type Dpotrfer interface {
                                  	Dpotrf(ul blas.Uplo, n int, a []float64, lda int) (ok bool)
                                  }

                                  type Dpotrier

                                  type Dpotrier interface {
                                  	Dpotri(uplo blas.Uplo, n int, a []float64, lda int) bool
                                  
                                  	Dpotrf(uplo blas.Uplo, n int, a []float64, lda int) bool
                                  }

                                  type Dpotrser

                                  type Dpotrser interface {
                                  	Dpotrs(uplo blas.Uplo, n, nrhs int, a []float64, lda int, b []float64, ldb int)
                                  
                                  	Dpotrf(uplo blas.Uplo, n int, a []float64, lda int) bool
                                  }

                                  type Drscler

                                  type Drscler interface {
                                  	Drscl(n int, a float64, x []float64, incX int)
                                  }

                                  type Dsteqrer

                                  type Dsteqrer interface {
                                  	Dsteqr(compz lapack.EVComp, n int, d, e, z []float64, ldz int, work []float64) (ok bool)
                                  	Dorgtrer
                                  }

                                  type Dsterfer

                                  type Dsterfer interface {
                                  	Dsteqrer
                                  	Dlansyer
                                  	Dsterf(n int, d, e []float64) (ok bool)
                                  }

                                  type Dsyever

                                  type Dsyever interface {
                                  	Dsyev(jobz lapack.EVJob, uplo blas.Uplo, n int, a []float64, lda int, w, work []float64, lwork int) (ok bool)
                                  }

                                  type Dsytd2er

                                  type Dsytd2er interface {
                                  	Dsytd2(uplo blas.Uplo, n int, a []float64, lda int, d, e, tau []float64)
                                  }

                                  type Dsytrder

                                  type Dsytrder interface {
                                  	Dsytrd(uplo blas.Uplo, n int, a []float64, lda int, d, e, tau, work []float64, lwork int)
                                  
                                  	Dorgqr(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                  	Dorgql(m, n, k int, a []float64, lda int, tau, work []float64, lwork int)
                                  }

                                  type Dtbtrser

                                  type Dtbtrser interface {
                                  	Dtbtrs(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n, kd, nrhs int, a []float64, lda int, b []float64, ldb int) bool
                                  }

                                  type Dtgsjaer

                                  type Dtgsjaer interface {
                                  	Dlanger
                                  	Dtgsja(jobU, jobV, jobQ lapack.GSVDJob, m, p, n, k, l int, a []float64, lda int, b []float64, ldb int, tola, tolb float64, alpha, beta, u []float64, ldu int, v []float64, ldv int, q []float64, ldq int, work []float64) (cycles int, ok bool)
                                  }

                                  type Dtrconer

                                  type Dtrconer interface {
                                  	Dtrcon(norm lapack.MatrixNorm, uplo blas.Uplo, diag blas.Diag, n int, a []float64, lda int, work []float64, iwork []int) float64
                                  
                                  	Dtrtri(uplo blas.Uplo, diag blas.Diag, n int, a []float64, lda int) bool
                                  	Dlantr(norm lapack.MatrixNorm, uplo blas.Uplo, diag blas.Diag, m, n int, a []float64, lda int, work []float64) float64
                                  }

                                  type Dtrevc3er

                                  type Dtrevc3er interface {
                                  	Dtrevc3(side lapack.EVSide, howmny lapack.EVHowMany, selected []bool, n int, t []float64, ldt int, vl []float64, ldvl int, vr []float64, ldvr int, mm int, work []float64, lwork int) int
                                  }

                                  type Dtrexcer

                                  type Dtrexcer interface {
                                  	Dtrexc(compq lapack.UpdateSchurComp, n int, t []float64, ldt int, q []float64, ldq int, ifst, ilst int, work []float64) (ifstOut, ilstOut int, ok bool)
                                  }

                                  type Dtrti2er

                                  type Dtrti2er interface {
                                  	Dtrti2(uplo blas.Uplo, diag blas.Diag, n int, a []float64, lda int)
                                  }

                                  type Dtrtrier

                                  type Dtrtrier interface {
                                  	Dtrtri(uplo blas.Uplo, diag blas.Diag, n int, a []float64, lda int) bool
                                  }

                                  type Dtrtrser

                                  type Dtrtrser interface {
                                  	Dtrtrs(uplo blas.Uplo, trans blas.Transpose, diag blas.Diag, n, nrhs int, a []float64, lda int, b []float64, ldb int) bool
                                  }

                                  type Fibonacci

                                  type Fibonacci int

                                    Fibonacci is an upper Hessenberg matrix with 3 distinct real eigenvalues. For example, for n=5,

                                        [ . 1 . . . ]
                                        [ 1 1 . . . ]
                                    A = [ . 1 1 . . ]
                                        [ . . 1 1 . ]
                                        [ . . . 1 1 ]
                                    

                                    func (Fibonacci) Eigenvalues

                                    func (f Fibonacci) Eigenvalues() []complex128

                                    func (Fibonacci) Matrix

                                    func (f Fibonacci) Matrix() blas64.General

                                    type Gear

                                    type Gear int

                                      Gear is a singular non-symmetric matrix with real eigenvalues. For example, for n=5,

                                          [ . 1 . . 1 ]
                                          [ 1 . 1 . . ]
                                      A = [ . 1 . 1 . ]
                                          [ . . 1 . 1 ]
                                          [-1 . . 1 . ]
                                      

                                      func (Gear) Eigenvalues

                                      func (g Gear) Eigenvalues() []complex128

                                      func (Gear) Matrix

                                      func (g Gear) Matrix() blas64.General

                                      type Grcar

                                      type Grcar struct {
                                      	N int
                                      	K int
                                      }

                                        Grcar is an upper Hessenberg matrix given by

                                        A[i,j] = -1  if i == j+1,
                                               = 1   if i <= j and j <= i+k,
                                               = 0   otherwise.
                                        

                                        For example, for n=5 and k=2,

                                            [  1  1  1  .  . ]
                                            [ -1  1  1  1  . ]
                                        A = [  . -1  1  1  1 ]
                                            [  .  . -1  1  1 ]
                                            [  .  .  . -1  1 ]
                                        

                                        The matrix has sensitive eigenvalues but they are not given explicitly.

                                        func (Grcar) Eigenvalues

                                        func (Grcar) Eigenvalues() []complex128

                                        func (Grcar) Matrix

                                        func (g Grcar) Matrix() blas64.General

                                        type Hanowa

                                        type Hanowa struct {
                                        	N     int // Order of the matrix, must be even.
                                        	Alpha float64
                                        }

                                          Hanowa is a non-symmetric non-singular matrix of even order given by

                                          A[i,j] = alpha    if i == j,
                                                 = -i-1     if i < n/2 and j == i + n/2,
                                                 = i+1-n/2  if i >= n/2 and j == i - n/2,
                                                 = 0        otherwise.
                                          

                                          The matrix has complex eigenvalues.

                                          func (Hanowa) Eigenvalues

                                          func (h Hanowa) Eigenvalues() []complex128

                                          func (Hanowa) Matrix

                                          func (h Hanowa) Matrix() blas64.General

                                          type Iladlcer

                                          type Iladlcer interface {
                                          	Iladlc(m, n int, a []float64, lda int) int
                                          }

                                          type Iladlrer

                                          type Iladlrer interface {
                                          	Iladlr(m, n int, a []float64, lda int) int
                                          }

                                          type Lesp

                                          type Lesp int

                                            Lesp is a tridiagonal, generally non-symmetric matrix given by

                                            A[i,j] = -2*i-5   if i == j,
                                                   = 1/(i+1)  if i == j-1,
                                                   = j+1      if i == j+1.
                                            

                                            For example, for n=5,

                                                [  -5    2    .    .    . ]
                                                [ 1/2   -7    3    .    . ]
                                            A = [   .  1/3   -9    4    . ]
                                                [   .    .  1/4  -11    5 ]
                                                [   .    .    .  1/5  -13 ].
                                            

                                            The matrix has sensitive eigenvalues but they are not given explicitly.

                                            func (Lesp) Eigenvalues

                                            func (Lesp) Eigenvalues() []complex128

                                            func (Lesp) Matrix

                                            func (l Lesp) Matrix() blas64.General

                                            type Rutis

                                            type Rutis struct{}

                                              Rutis is the 4×4 non-symmetric matrix

                                                  [ 4 -5  0  3 ]
                                              A = [ 0  4 -3 -5 ]
                                                  [ 5 -3  4  0 ]
                                                  [ 3  0  5  4 ]
                                              

                                              It has two distinct real eigenvalues and a pair of complex eigenvalues.

                                              func (Rutis) Eigenvalues

                                              func (Rutis) Eigenvalues() []complex128

                                              func (Rutis) Matrix

                                              func (Rutis) Matrix() blas64.General

                                              type Tris

                                              type Tris struct {
                                              	N       int
                                              	X, Y, Z float64
                                              }

                                                Tris is a tridiagonal matrix given by

                                                A[i,j] = x  if i == j-1,
                                                       = y  if i == j,
                                                       = z  if i == j+1.
                                                

                                                If x*z is negative, the matrix has complex eigenvalues.

                                                func (Tris) Eigenvalues

                                                func (t Tris) Eigenvalues() []complex128

                                                func (Tris) Matrix

                                                func (t Tris) Matrix() blas64.General

                                                type Wilk12

                                                type Wilk12 struct{}

                                                  Wilk12 is a 12×12 lower Hessenberg matrix with 12 distinct real eigenvalues.

                                                  func (Wilk12) Eigenvalues

                                                  func (Wilk12) Eigenvalues() []complex128

                                                  func (Wilk12) Matrix

                                                  func (Wilk12) Matrix() blas64.General

                                                  type Wilk20

                                                  type Wilk20 float64

                                                    Wilk20 is a 20×20 lower Hessenberg matrix. If the parameter is 0, the matrix has 20 distinct real eigenvalues. If the parameter is 1e-10, the matrix has 6 real eigenvalues and 7 pairs of complex eigenvalues.

                                                    func (Wilk20) Eigenvalues

                                                    func (w Wilk20) Eigenvalues() []complex128

                                                    func (Wilk20) Matrix

                                                    func (w Wilk20) Matrix() blas64.General

                                                    type Wilk4

                                                    type Wilk4 struct{}

                                                      Wilk4 is a 4×4 lower triangular matrix with 4 distinct real eigenvalues.

                                                      func (Wilk4) Eigenvalues

                                                      func (Wilk4) Eigenvalues() []complex128

                                                      func (Wilk4) Matrix

                                                      func (Wilk4) Matrix() blas64.General

                                                      type Zero

                                                      type Zero int

                                                        Zero is a matrix with all elements equal to zero.

                                                        func (Zero) Eigenvalues

                                                        func (z Zero) Eigenvalues() []complex128

                                                        func (Zero) Matrix

                                                        func (z Zero) Matrix() blas64.General