Gridap.Algebra

The exported names are

• AffineOperator
• BackslashSolver
• BlockArrayCOO
• LUSolver
• LinearSolver
• NLSolver
• NewtonRaphsonSolver
• NonLinearOperator
• NonLinearSolver
• NumericalSetup
• SparseMatrixCSR
• SymSparseMatrixCSR
• SymbolicSetup
• add_entry!
• allocate_coo_vectors
• allocate_jacobian
• allocate_residual
• allocate_residual_and_jacobian
• colvals
• copy_entries!
• create_coo_vectors
• fill_entries!
• finalize_coo!
• get_matrix
• get_vector
• getindices
• getptr
• hascolmajororder
• hasrowmajororder
• is_entry_stored
• jacobian
• jacobian!
• numerical_setup
• numerical_setup!
• push_coo!
• residual
• residual!
• residual_and_jacobian
• residual_and_jacobian!
• solve
• solve!
• sparse_from_coo
• sparsecsr
• symbolic_setup
• symsparsecsr
• test_linear_solver
• test_non_linear_operator
• test_non_linear_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(::Type{T},op::NonLinearOperator) where T
• 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)

struct SparseMatrixCSR{Bi,Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}

Matrix type for storing Bi-based sparse matrices in the Compressed Sparse Row format. The standard way of constructing SparseMatrixCSR is through the sparsecsr function.

struct SymSparseMatrixCSR{T,Ti<:Integer} <: AbstractSparseMatrix{T,Ti}

Matrix type for storing symmetric sparse matrices in the Compressed Sparse Row format. The standard way of constructing SparseMatrixCSR is through the symsparsecsr function.

abstract type SymbolicSetup <: GridapType end

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

add_entry!(A,v::Number,i::Integer,j::Integer,combine::Function=+)

Add an entry given its position and the operation to perform.

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

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

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

colvals(S::AbstractSparseMatrix)

Return columns indices or raises an error (Depending on the SparseMatrix type)

fill_entry!(A,v::Number)

Fills an existing sparse matrix A with a given value v.

finalize_coo!(::Type{T} where T,I,J,V,m,n)

Check and insert diagonal entries in COO vectors if needed.

getindices(S::AbstractSparseMatrix)

Return row indices.

getptr(S::AbstractSparseMatrix)

Return columns pointer.

hascolmajororder(::Type{AbstractSparseMatrix})

Check if values are stored in col-major order. Return true.

hasrowmajororder(::Type{AbstractSparseMatrix})

Check if values are stored in row-major order. Return false.

is_entry_stored(::Type{T} where T,i::Integer,j::Integer) -> Bool

Tells if the entry with coordinates [i,j] will be stored when calling function push_coo!

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

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

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

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

push_coo!(::Type{T} where T, I,J,V,ik,jk,vk)

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)

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:

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{T} where T,args...)

args... are the same as for function sparse

sparsecsr(args...)

Same args than sparse.

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

symsparsecsr(args...)

Same args than sparse.

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

test_non_linear_operator(
  op::NonLinearOperator,
  x::AbstractVector,
  b::AbstractVector,
  pred=isapprox;
  jac=nothing)

test_non_linear_solver(
  nls::NonLinearSolver,
  op::NonLinearOperator,
  x0::AbstractVector,
  x::AbstractVector,
  pred::Function=isapprox)

zero_initial_guess(op::NonLinearOperator)

zero_initial_guess(::Type{T},op::NonLinearOperator) where T

convert(::Type{AbstractSparseMatrix}, x::AbstractSparseMatrix)

Convert x to a value of the first type given.

count(pred, S::AbstractSparseMatrix) -> Integer

Count the number of elements in nonzeros(S) for which predicate pred returns true.

findnz(S::AbstractSparseMatrix)

Return a tuple (I, J, V) where I and J are the row and column indices of the stored ("structurally non-zero") values in sparse matrix A, and V is a vector of the values.

nnz(S::AbstractSparseMatrix)

Returns the number of stored (filled) elements in a sparse array.

nonzeros(S::AbstractSparseMatrix)

Return a vector of the structural nonzero values in sparse array S. This includes zeros that are explicitly stored in the sparse array. The returned vector points directly to the internal nonzero storage of S, and any modifications to the returned vector will mutate S as well.

nzrange(S::AbstractSparseMatrix, index::Integer) where {Bi}

Return the range of indices to the structural nonzero values of a sparse matrix index (Row or column depending on the compression type).

rowvals(S::AbstractSparseMatrix)

Return row indices or raises an error (Depending on the SparseMatrix type)