gonum: gonum.org/v1/gonum/lapack/testlapack Index | Files

package testlapack

import "gonum.org/v1/gonum/lapack/testlapack"

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

Index

Package Files

dbdsqr.go dgebak.go dgebal.go dgebd2.go dgebrd.go dgecon.go dgeev.go dgeev_bench.go dgehd2.go dgehrd.go dgelq2.go dgelqf.go dgels.go dgeql2.go dgeqp3.go dgeqr2.go dgeqrf.go dgerq2.go dgerqf.go dgesvd.go dgetf2.go dgetrf.go dgetri.go dgetrs.go dggsvd3.go dggsvp3.go dhseqr.go dlabrd.go dlacn2.go dlacpy.go dlae2.go dlaev2.go dlaexc.go dlags2.go dlahqr.go dlahr2.go dlaln2.go dlange.go dlanst.go dlansy.go dlantr.go dlanv2.go dlapll.go dlapmt.go dlapy2.go dlaqp2.go dlaqps.go dlaqr04.go dlaqr1.go dlaqr23.go dlaqr5.go dlarf.go dlarfb.go dlarfg.go dlarft.go dlarfx.go dlartg.go dlas2.go dlascl.go dlaset.go dlasq1.go dlasq2.go dlasq3.go dlasq4.go dlasq5.go dlasr.go dlasrt.go dlasv2.go dlaswp.go dlasy2.go dlatrd.go dlatrs.go dlauu2.go dlauum.go doc.go dorg2l.go dorg2r.go dorgbr.go dorghr.go dorgl2.go dorglq.go dorgql.go dorgqr.go dorgtr.go dorm2r.go dormbr.go dormhr.go dorml2.go dormlq.go dormqr.go dormr2.go dpbtf2.go dpocon.go dpotf2.go dpotrf.go dpotri.go dpotrs.go drscl.go dsteqr.go dsterf.go dsyev.go dsytd2.go dsytrd.go dtgsja.go dtrcon.go dtrevc3.go dtrexc.go dtrti2.go dtrtri.go fortran.go general.go iladlc.go iladlr.go matgen.go test_matrices.go

func DbdsqrTest Uses

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

func DgebakTest Uses

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

func DgebalTest Uses

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

func Dgebd2Test Uses

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

func DgebrdTest Uses

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

func DgeconTest Uses

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

func DgeevBenchmark Uses

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

func DgeevTest Uses

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

func Dgehd2Test Uses

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

func DgehrdTest Uses

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

func Dgelq2Test Uses

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

func DgelqfTest Uses

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

func DgelsTest Uses

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

func Dgeql2Test Uses

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

func Dgeqp3Test Uses

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

func Dgeqr2Test Uses

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

func DgeqrfTest Uses

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

func Dgerq2Test Uses

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

func DgerqfTest Uses

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

func DgesvdTest Uses

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

func Dgetf2Test Uses

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

func DgetrfTest Uses

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

func DgetriTest Uses

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

func DgetrsTest Uses

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

func Dggsvd3Test Uses

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

func Dggsvp3Test Uses

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

func DhseqrTest Uses

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

func DlabrdTest Uses

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

func Dlacn2Test Uses

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

func DlacpyTest Uses

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

func Dlae2Test Uses

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

func Dlaev2Test Uses

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

func DlaexcTest Uses

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

func Dlagge Uses

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 Uses

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

func Dlagsy Uses

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^T.

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 DlahqrTest Uses

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

func Dlahr2Test Uses

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

func Dlaln2Test Uses

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

func DlangeTest Uses

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

func DlanstTest Uses

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

func DlansyTest Uses

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

func DlantrTest Uses

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

func Dlanv2Test Uses

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

func DlapllTest Uses

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

func DlapmtTest Uses

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

func Dlapy2Test Uses

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

func Dlaqp2Test Uses

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

func DlaqpsTest Uses

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

func Dlaqr04Test Uses

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

func Dlaqr1Test Uses

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

func Dlaqr23Test Uses

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

func Dlaqr5Test Uses

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

func DlarfTest Uses

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

func DlarfbTest Uses

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

func DlarfgTest Uses

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

func DlarftTest Uses

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

func DlarfxTest Uses

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

func DlartgTest Uses

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

func Dlas2Test Uses

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

func DlasclTest Uses

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

func DlasetTest Uses

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

func Dlasq1Test Uses

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

func Dlasq2Test Uses

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

func Dlasq3Test Uses

func Dlasq3Test(t *testing.T, impl Dlasq3er)

func Dlasq4Test Uses

func Dlasq4Test(t *testing.T, impl Dlasq4er)

func Dlasq5Test Uses

func Dlasq5Test(t *testing.T, impl Dlasq5er)

func DlasrTest Uses

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

func DlasrtTest Uses

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

func Dlasv2Test Uses

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

func DlaswpTest Uses

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

func Dlasy2Test Uses

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

func Dlatm1 Uses

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 Uses

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

func DlatrsTest Uses

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

func Dlauu2Test Uses

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

func DlauumTest Uses

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

func Dorg2lTest Uses

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

func Dorg2rTest Uses

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

func DorgbrTest Uses

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

func DorghrTest Uses

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

func Dorgl2Test Uses

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

func DorglqTest Uses

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

func DorgqlTest Uses

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

func DorgqrTest Uses

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

func DorgtrTest Uses

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

func Dorm2rTest Uses

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

func DormbrTest Uses

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

func DormhrTest Uses

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

func Dorml2Test Uses

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

func DormlqTest Uses

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

func DormqrTest Uses

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

func Dormr2Test Uses

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

func Dpbtf2Test Uses

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

func DpoconTest Uses

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

func Dpotf2Test Uses

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

func DpotrfTest Uses

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

func DpotriTest Uses

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

func DpotrsTest Uses

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

func DrsclTest Uses

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

func DsteqrTest Uses

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

func DsterfTest Uses

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

func DsyevTest Uses

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

func Dsytd2Test Uses

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

func DsytrdTest Uses

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

func DtgsjaTest Uses

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

func DtrconTest Uses

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

func Dtrevc3Test Uses

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

func DtrexcTest Uses

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

func Dtrti2Test Uses

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

func DtrtriTest Uses

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

func IladlcTest Uses

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

func IladlrTest Uses

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

type A123 Uses

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 Uses

func (A123) Eigenvalues() []complex128

func (A123) LeftEV Uses

func (A123) LeftEV() blas64.General

func (A123) Matrix Uses

func (A123) Matrix() blas64.General

func (A123) RightEV Uses

func (A123) RightEV() blas64.General

type AntisymRandom Uses

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 Uses

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

func (AntisymRandom) Eigenvalues Uses

func (AntisymRandom) Eigenvalues() []complex128

func (AntisymRandom) Matrix Uses

func (a AntisymRandom) Matrix() blas64.General

type Circulant Uses

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 Uses

func (c Circulant) Eigenvalues() []complex128

func (Circulant) Matrix Uses

func (c Circulant) Matrix() blas64.General

type Clement Uses

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 Uses

func (c Clement) Eigenvalues() []complex128

func (Clement) Matrix Uses

func (c Clement) Matrix() blas64.General

type Creation Uses

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 Uses

func (c Creation) Eigenvalues() []complex128

func (Creation) Matrix Uses

func (c Creation) Matrix() blas64.General

type Dbdsqrer Uses

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 Dgebaker Uses

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

type Dgebaler Uses

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

type Dgebd2er Uses

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

type Dgebrder Uses

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

type Dgeconer Uses

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

type Dgeever Uses

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 Uses

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

type Dgehrder Uses

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 Uses

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

type Dgelqfer Uses

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

type Dgelser Uses

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 Uses

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

type Dgeqp3er Uses

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

type Dgeqr2er Uses

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

type Dgeqrfer Uses

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

type Dgerq2er Uses

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

type Dgerqfer Uses

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

type Dgesvder Uses

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 Uses

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

type Dgetrfer Uses

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

type Dgetrier Uses

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

type Dgetrser Uses

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

type Dggsvd3er Uses

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 Uses

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 Dhseqrer Uses

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 Uses

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 Uses

func (d Diagonal) Eigenvalues() []complex128

func (Diagonal) Matrix Uses

func (d Diagonal) Matrix() blas64.General

type Dlabrder Uses

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 Uses

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

type Dlacpyer Uses

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

type Dlae2er Uses

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

type Dlaev2er Uses

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

type Dlaexcer Uses

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 Uses

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

type Dlahqrer Uses

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 Uses

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

type Dlahr2test Uses

type Dlahr2test struct {
    N, K, NB int
    A        []float64

    AWant   []float64
    TWant   []float64
    YWant   []float64
    TauWant []float64
}

type Dlaln2er Uses

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 Uses

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

type Dlanster Uses

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

type Dlansyer Uses

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

type Dlantrer Uses

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 Uses

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

type Dlapller Uses

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

type Dlapmter Uses

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

type Dlapy2er Uses

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

type Dlaqp2er Uses

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

type Dlaqpser Uses

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 Uses

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 Uses

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

type Dlaqr23er Uses

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 Uses

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 Dlaqr5test Uses

type Dlaqr5test struct {
    WantT          bool
    N              int
    NShifts        int
    KTop, KBot     int
    ShiftR, ShiftI []float64
    H              []float64

    HWant []float64
    ZWant []float64
}

type Dlarfber Uses

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 Uses

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

type Dlarfger Uses

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

type Dlarfter Uses

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 Uses

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

type Dlartger Uses

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

type Dlas2er Uses

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

type Dlascler Uses

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

type Dlaseter Uses

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

type Dlasq1er Uses

type Dlasq1er interface {
    Dlasq1(n int, d, e, work []float64) int
    Dgetrfer
}

type Dlasq2er Uses

type Dlasq2er interface {
    Dgetrfer
    Dlasq2(n int, z []float64) (info int)
}

type Dlasq3er Uses

type Dlasq3er interface {
    Dlasq3(i0, n0 int, z []float64, pp int, dmin, sigma, desig, qmax float64, nFail, iter, nDiv int, ttype int, dmin1, dmin2, dn, dn1, dn2, g, tau float64) (
        i0Out, n0Out, ppOut int, dminOut, sigmaOut, desigOut, qmaxOut float64, nFailOut, iterOut, nDivOut, ttypeOut int, dmin1Out, dmin2Out, dnOut, dn1Out, dn2Out, gOut, tauOut float64)
}

type Dlasq4er Uses

type Dlasq4er interface {
    Dlasq4(i0, n0 int, z []float64, pp int, n0in int, dmin, dmin1, dmin2, dn, dn1, dn2, tau float64, ttype int, g float64) (tauOut float64, ttypeOut int, gOut float64)
}

type Dlasq5er Uses

type Dlasq5er interface {
    Dlasq5(i0, n0 int, z []float64, pp int, tau, sigma float64) (i0Out, n0Out, ppOut int, tauOut, sigmaOut, dmin, dmin1, dmin2, dn, dnm1, dnm2 float64)
}

type Dlasrer Uses

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

type Dlasrter Uses

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

type Dlasv2er Uses

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

type Dlaswper Uses

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

type Dlasy2er Uses

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 Dlatrder Uses

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

type Dlatrser Uses

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 Uses

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

type Dlauumer Uses

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

type Dorg2ler Uses

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

type Dorg2rer Uses

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

type Dorgbrer Uses

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

type Dorghrer Uses

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

    Dgehrder
}

type Dorgl2er Uses

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

type Dorglqer Uses

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

type Dorgqler Uses

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

    Dlarfger
}

type Dorgqrer Uses

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

type Dorgtrer Uses

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

type Dorm2rer Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (d Downshift) Eigenvalues() []complex128

func (Downshift) Matrix Uses

func (d Downshift) Matrix() blas64.General

type Dpbtf2er Uses

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

type Dpoconer Uses

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 Uses

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

type Dpotrfer Uses

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

type Dpotrier Uses

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 Uses

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 Uses

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

type Dsteqrer Uses

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

type Dsterfer Uses

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

type Dsyever Uses

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 Uses

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

type Dsytrder Uses

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 Dtgsjaer Uses

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 Uses

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

type Dtrevc3er Uses

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 Uses

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 Uses

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

type Dtrtrier Uses

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

type Fibonacci Uses

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 Uses

func (f Fibonacci) Eigenvalues() []complex128

func (Fibonacci) Matrix Uses

func (f Fibonacci) Matrix() blas64.General

type Gear Uses

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 Uses

func (g Gear) Eigenvalues() []complex128

func (Gear) Matrix Uses

func (g Gear) Matrix() blas64.General

type Grcar Uses

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 Uses

func (Grcar) Eigenvalues() []complex128

func (Grcar) Matrix Uses

func (g Grcar) Matrix() blas64.General

type Hanowa Uses

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 Uses

func (h Hanowa) Eigenvalues() []complex128

func (Hanowa) Matrix Uses

func (h Hanowa) Matrix() blas64.General

type Iladlcer Uses

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

type Iladlrer Uses

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

type Lesp Uses

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 Uses

func (Lesp) Eigenvalues() []complex128

func (Lesp) Matrix Uses

func (l Lesp) Matrix() blas64.General

type Rutis Uses

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 Uses

func (Rutis) Eigenvalues() []complex128

func (Rutis) Matrix Uses

func (Rutis) Matrix() blas64.General

type Tris Uses

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 Uses

func (t Tris) Eigenvalues() []complex128

func (Tris) Matrix Uses

func (t Tris) Matrix() blas64.General

type Wilk12 Uses

type Wilk12 struct{}

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

func (Wilk12) Eigenvalues Uses

func (Wilk12) Eigenvalues() []complex128

func (Wilk12) Matrix Uses

func (Wilk12) Matrix() blas64.General

type Wilk20 Uses

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 Uses

func (w Wilk20) Eigenvalues() []complex128

func (Wilk20) Matrix Uses

func (w Wilk20) Matrix() blas64.General

type Wilk4 Uses

type Wilk4 struct{}

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

func (Wilk4) Eigenvalues Uses

func (Wilk4) Eigenvalues() []complex128

func (Wilk4) Matrix Uses

func (Wilk4) Matrix() blas64.General

type Zero Uses

type Zero int

Zero is a matrix with all elements equal to zero.

func (Zero) Eigenvalues Uses

func (z Zero) Eigenvalues() []complex128

func (Zero) Matrix Uses

func (z Zero) Matrix() blas64.General

Package testlapack imports 17 packages (graph). Updated 2019-05-20. Refresh now. Tools for package owners.