iterative

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

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

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

type Context struct {
	// X is the current approximate solution.
	// On the first call to Method.Iterate, X
	// must contain the initial estimate.
	// Method must update X with the current
	// estimate when it commands
	// ComputeResidual and EndIteration.
	X []float64
	// Residual is the current residual b-A*x.
	// On the first call to Method.Iterate,
	// Residual must contain the initial
	// residual.
	// TODO(vladimir-ch): Consider whether the
	// behavior should also include: Method
	// must update Residual with the current
	// value of b-A*x when it commands
	// EndIteration.
	Residual []float64
	// ResidualNorm is (an estimate of) the
	// norm of the current residual. Method
	// must update it when it commands
	// CheckResidualNorm. It does not have to
	// be equal to the norm of Residual, some
	// methods (e.g., GMRES) can estimate the
	// residual norm without forming the
	// residual itself.
	// TODO(vladimir-ch): Actually this is
	// something that should be discussed.
	ResidualNorm float64
	// Converged indicates to Method that the
	// ResidualNorm satisfies the stopping
	// criterion as a result of
	// CheckResidualNorm operation. If a
	// Method commands EndIteration with
	// Converged true, the caller must not
	// call Method.Iterate again without
	// calling Method.Init first.
	Converged bool

	// Src and Dst are the source and
	// destination vectors for various
	// Operations.
	Src, Dst []float64
}

type GMRES struct {
	// Restart is the restart parameter.
	// It must be 0 <= Restart <= dim.
	// If it is 0, it will be set to dim.
	Restart int
	// contains filtered or unexported fields
}

type MatrixOps struct {
	// MatVec computes A*x and stores the
	// result into dst. It must be non-nil.
	MatVec func(dst, x []float64)

	// MatTransVec computes A^T*x and stores
	// the result into dst. If the Method does
	// not command MatTransVec, this can be
	// nil.
	MatTransVec func(dst, x []float64)
}

type Method interface {
	// Init initializes the method for solving
	// a dim×dim linear system.
	Init(dim int)

	// Iterate retrieves data from Context,
	// updates it, and returns the next
	// operation. The caller must perform the
	// Operation using data in Context, and
	// depending on the state call Iterate
	// again.
	Iterate(*Context) (Operation, error)
}

type Operation uint64

type Result struct {
	// X is the approximate solution.
	X []float64
	// Stats holds the statistics of the
	// solve.
	Stats Stats
}

type Settings struct {
	// X0 is an initial guess.
	// If it is nil, the zero vector will be
	// used.
	// If it is not nil, the length of X0 must
	// be equal to the dimension of the
	// system.
	X0 []float64

	// Tolerance specifies error tolerance for
	// the final approximate solution produced
	// by the iterative method. Tolerance must
	// be smaller than one and greater than
	// the machine epsilon.
	//
	// If NormA is not zero, the stopping
	// criterion used will be
	//  |r_i| < Tolerance * (|A|*|x_i| + |b|),
	// If NormA is zero (not available), the
	// stopping criterion will be
	//  |r_i| < Tolerance * |b|.
	Tolerance float64

	// NormA is an estimate of a norm |A| of
	// A, for example, an approximation of the
	// largest entry. Zero value means that
	// the norm is unknown, and it will not be
	// used in the stopping criterion.
	NormA float64

	// MaxIterations is the limit on the
	// number of iterations.
	// If it is zero, it will be set to twice
	// the dimension of the system.
	MaxIterations int

	// PSolve describes the preconditioner
	// solve that stores into dst the solution
	// of the system
	//  M z = rhs.
	// If it is nil, no preconditioning will
	// be used (M is the identitify).
	PSolve func(dst, rhs []float64) error

	// PSolveTrans describes the
	// preconditioner solve that stores into
	// dst the solution of the system
	//  M^T z = rhs.
	// If it is nil, no preconditioning will
	// be used (M is the identitify).
	PSolveTrans func(dst, rhs []float64) error
}

type Stats struct {
	// Iterations is the number of iteration
	// done by Method.
	Iterations int
	// MatVec is the number of MatVec and
	// MatTransVec operations commanded by
	// Method.
	MatVec int
	// PSolve is the number of PSolve and
	// PSolveTrans operations commanded by
	// Method.
	PSolve int
	// ResidualNorm is the final norm of the
	// residual.
	ResidualNorm float64
	// StartTime is an approximate time when
	// the solve was started.
	StartTime time.Time
	// Runtime is an approximate duration of
	// the solve.
	Runtime time.Duration
}