Gridap.Algebra

The exported names are

• AffineOperator
• ArrayBuilder
• BackslashSolver
• DoNotLoop
• LUSolver
• LinearSolver
• Loop
• LoopStyle
• MinCPU
• MinMemory
• NLSolver
• NewtonRaphsonSolver
• NonlinearOperator
• NonlinearSolver
• NumericalSetup
• SparseMatrixBuilder
• SymbolicSetup
• add_entries!
• add_entry!
• allocate_coo_vectors
• allocate_in_domain
• allocate_in_range
• allocate_jacobian
• allocate_matrix
• allocate_matrix_and_vector
• allocate_residual
• allocate_residual_and_jacobian
• allocate_vector
• axpy_entries!
• copy_entries!
• create_from_nz
• finalize_coo!
• get_array_type
• get_matrix
• get_vector
• hessian
• hessian!
• is_entry_stored
• jacobian
• jacobian!
• length_to_ptrs!
• muladd!
• numerical_setup
• numerical_setup!
• nz_allocation
• nz_counter
• nz_index
• push_coo!
• residual
• residual!
• residual_and_jacobian
• residual_and_jacobian!
• rewind_ptrs!
• solve
• solve!
• sparse_from_coo
• symbolic_setup
• test_linear_solver
• test_nonlinear_operator
• test_nonlinear_solver
• zero_initial_guess

struct AffineOperator{A<:AbstractMatrix,B<:AbstractVector} <: NonlinearOperator
  matrix::A
  vector::B
end

struct BackslashSolver <: LinearSolver end

Wrapper of the backslash solver available in julia This is typically faster than LU for a single solve

struct LUSolver <: LinearSolver end

Wrapper of the LU solver available in julia

abstract type LinearSolver <: NonlinearSolver end

• symbolic_setup(::LinearSolver,mat::AbstractMatrix)
• test_linear_solver

struct NLSolver <: NonlinearSolver
  # private fields
end

The cache generated when using this solver has a field result that hosts the result object generated by the underlying nlsolve function. It corresponds to the most latest solve.

NLSolver(ls::LinearSolver;kwargs...)
NLSolver(;kwargs...)

Same kwargs as in nlsolve. If ls is provided, it is not possible to use the linsolve kw-argument.

struct NewtonRaphsonSolver <:NonlinearSolver
  # Private fields
end

Vanilla Newton-Raphson method

abstract type NonlinearOperator <: GridapType end

• residual!(b::AbstractVector,op::NonlinearOperator,x::AbstractVector)
• jacobian!(A::AbstractMatrix,op::NonlinearOperator,x::AbstractVector)
• zero_initial_guess(op::NonlinearOperator)
• allocate_residual(op::NonlinearOperator,x::AbstractVector)
• allocate_jacobian(op::NonlinearOperator,x::AbstractVector)

abstract type NonlinearSolver <: GridapType end

• solve!(x::AbstractVector,nls::NonlinearSolver,op::NonlinearOperator)
• solve!(x::AbstractVector,nls::NonlinearSolver,op::NonlinearOperator, cache)

abstract type NumericalSetup <: GridapType end

• numerical_setup!(::NumericalSetup,mat::AbstractMatrix)
• solve!(x::AbstractVector,::NumericalSetup,b::AbstractVector)

abstract type SymbolicSetup <: GridapType end

• numerical_setup(::SymbolicSetup,mat::AbstractMatrix)

add_entries!(combine::Function,A,vs,is,js)

Add several entries only for positive input indices. Returns A.

add_entry!(combine::Function,A,v,i...)
add_entry!(A,v,i...)

Add an entry. Returns A.

allocate_in_domain(matrix::AbstractMatrix{T}) where T

Allocate a vector in the domain of matrix matrix.

allocate_in_domain(::Type{V},matrix) where V

Allocate a vector of type V in the domain of matrix matrix.

allocate_in_range(matrix::AbstractMatrix{T}) where T

Allocate a vector in the range of matrix matrix.

allocate_in_range(::Type{V},matrix) where V

Allocate a vector of type V in the range of matrix matrix.

allocate_jacobian(op::NonlinearOperator,x::AbstractVector)

allocate_residual(op::NonlinearOperator,x::AbstractVector)

allocate_residual_and_jacobian(op::NonlinearOperator,x::AbstractVector)

allocate_vector(::Type{V},indices) where V

Allocate a vector of type V indexable at the indices indices

axpy_entries!(α::Number, A::T, B::T) where {T<: AbstractMatrix} -> T

Efficient implementation of axpy! for sparse matrices.

copy_entries!(a,b)

Copy the entries of array b into array a. Returns a.

finalize_coo!(::Type,I,J,V,m,n)

Check and insert diagonal entries in COO vectors if needed.

get_matrix(operator)

Return the matrix corresponding to the assembled left hand side of the operator. This matrix incorporates all boundary conditions and constraints.

get_vector(operator)

Return the vector corresponding to the assembled right hand side of the operator. This vector includes all boundary conditions and constraints.

is_entry_stored(::Type,i,j) -> Bool

Tells if the entry with coordinates [i,j] will be stored in the coo vectors.

jacobian!(A::AbstractMatrix,op::NonlinearOperator,x::AbstractVector)

jacobian(op::NonlinearOperator,x::AbstractVector)

length_to_ptrs!(ptrs)

Given a vector of integers, mutate it from length state to pointer state.

muladd!(c,a,b)

Matrix multiply a*b and add to result to c. Returns c.

numerical_setup!(::NumericalSetup,mat::AbstractMatrix)

numerical_setup(::SymbolicSetup,mat::AbstractMatrix) -> NumericalSetup

push_coo!(::Type, I,J,V,i,j,v)

Inserts entries in COO vectors for further building a sparse matrix of type T.

residual!(b::AbstractVector,op::NonlinearOperator,x::AbstractVector)

residual(op::NonlinearOperator,x::AbstractVector)

residual_and_jacobian!(
  b::AbstractVector, A::AbstractMatrix,
  op::NonlinearOperator, x::AbstractVector)

residual_and_jacobian(op::NonlinearOperator,x::AbstractVector)

rewind_ptrs!(ptrs)

Rewind the given vector of pointers.

solve!(x::AbstractVector,ls::LinearSolver,A::AbstractMatrix,b::AbstractVector)

solve!(
  x::AbstractVector,
  ls::LinearSolver,
  op::AffineOperator,
  cache,
  newmatrix::Bool)

solve!(x::AbstractVector,nls::NonlinearSolver,op::NonlinearOperator,cache)

Solve using the cache object from a previous solve.

solve!(x::AbstractVector,nls::NonlinearSolver,op::NonlinearOperator)

Usage:

cache = solve!(x,nls,op)

The returned cache object can be used in subsequent solves:

cache = solve!(x,nls,op,cache)

solve!(x::AbstractVector,::NumericalSetup,b::AbstractVector)

solve(ls::LinearSolver,A::AbstractMatrix,b::AbstractVector)

solve(nls::NonlinearSolver,op::NonlinearOperator)

Creates and uses a zero initial guess.

sparse_from_coo(::Type,I,J,V,m,n)

symbolic_setup(::LinearSolver,mat::AbstractMatrix) -> SymbolicSetup

test_linear_solver(
  ls::LinearSolver,
  A::AbstractMatrix,
  b::AbstractVector,
  x::AbstractVector)

test_nonlinear_operator(
  op::NonlinearOperator,
  x::AbstractVector,
  b::AbstractVector,
  pred=isapprox;
  jac=nothing)

test_nonlinear_solver(
  nls::NonlinearSolver,
  op::NonlinearOperator,
  x0::AbstractVector,
  x::AbstractVector,
  pred::Function=isapprox)

zero_initial_guess(op::NonlinearOperator)