testlapack

package
v0.8.14 Latest Latest
Warning

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

 Go to latest Published: Dec 2, 2023 License: BSD-3-Clause Imports: 15 Imported by: 0

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

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