Gridap.Algebra

Exported names

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 ArrayBuilder{T}

T is the type of array to be built.

ArrayCounter{T}(axes::A)

where T is the target matrix/array type.

struct BackslashSolver <: LinearSolver end

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

struct DoNotLoop end

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

struct MinCPU end

Represent sparse matrix assembly strategy minimizing CPU cost.

struct MinMemory{T}

Represent sparse matrix assembly strategy minimizing memory cost.

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)

struct SparseMatrixBuilder{T,A}

SparseMatrixBuilder(::Type{T}[, ::S])

Create a builder for sparse matrix of type T, using assembly stategy S(), either MinCPU() or MinMemory(). The default is MinMemory().

abstract type SymbolicSetup <: GridapType end

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

LoopStyle(::Type)
LoopStyle(::T) where T = LoopStyle(T)

Trait to tell if looping on nonzeros entries is necessary to count the values with a counter (see nz_counter) of an array of type T.

Returns Loop() or DoNotLoop.

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_coo_vectors(::Type{<:AbstractSparseMatrix{Tv,Ti}}, n::Integer)

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 LinearAlgebra.axpy! for sparse matrices.

copy_entries!(a,b)

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

create_from_nz(nz_alloc::AbstractArray)

Creates a matrix from its nonzero values, allocated using nz_allocation and filled using add_entry! and/or add_entries!.

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

Check and insert diagonal entries in COO vectors if needed.

get_array_type(::ArrayBuilder{T}) = T

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.

function hessian end

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

nz_allocation(a::ArrayCounter{T})

Allocates a vector that will serve as structural nonzero values internal storage for a matrix holding the values counted in a. See also create_from_nz, SparseArrays.nonzeros.

nz_counter(::ArrayBuilder{T},axes)

Generate a counter (ArrayCounter) to count the nonzero values for an array type A.

nz_index(A::AbstractSparseMatrix,i,j)

Index of A[i,j] in the structural nonzero values internal storage of A. See also SparseArrays.nonzeros.

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)