Mathematics

AbstractMapping{DT,CT,D}

Abstract type for mappings from a domain type DT to a codomain type CT. The third parameter D is a set of DTs and specifies the actual domain, use Any if all elements of DT are in the domain. TODO: Use DomainSets.Full

AffineMapping(A, b)

Creates the affine map A*x + b.

Constant mapping.

DerivativeAtLF(x)

The linear form $b$ with $b(f) = f'(x)$ for a specified position $x$.

FiniteElement(K, P, N)

Construct a finite element $(K, \mathcal{P}, \mathcal{N})$ according to Ciarlet's definition. Parameters are

• the domain K,

• the space P of functions defined on K,

• a vector of linear forms N,

• a cache holding computed objects such as a nodal basis.

Function $R \to R$.

Function $R^n \to R$ of several real variables.

FunctionSpace

General concept of a space containing functions which map domain type DT to codomain type CT.

Function to $R$.

Identity function.

Element of the real numbers

Element of the set of pairs of real numbers

Element of the set of triples of real numbers

Element of the set of $n \times m$-matrices of real numbers

Element of the set of pairs of real numbers

Element of the set of triples of real numbers

Element of the set of $n \times m$-matrices of real numbers

Element of the set of $n$-tuples of real numbers

Interpolation(h::MappingToRn, C)

The interpolating mapping $m: R^n \to Y$

$m(x) = \sum_{i=1}^m h_i(x) C_i$

with interpolation functions $h_i : R^n \to R$ and coefficients $C_i \in Y$ where $Y$ can be numbers or vectors.

MappingFromComponents(c1, c2, ..., cn)

Construct a mapping $X \to Z$ from Mappings $c_k: X \to Y, k = 1, \dots, n$ such that $Z = Y^n$.

Mappings from the real numbers.

Mappings from $R^n$.

Vector valued mapping ''R^n \to R^m'' with $n,m > 1$ of several real variables.

Neutral element w.r.t. multiplication.

P{N,K}

FunctionSpace of N-variate polynomials where the largest sum of exponents is not larger than K.

PDerivativeAtLF(x, n)

Evaluates the partial derivative at x in directions n of a function $f : \mathbb{R}^n \to \mathbb{R}$. The i-th entry of n specifies the order of the partial derivative in direction i. For instance, [1, 2] refers to the partial derivative $f_{xyy}(\mathbf{x})$.

Parametric curve$R \to R^n$.

PiecewiseFunction(breakpoints, functions)

Constructs a piecewise function.

Polynomial([a0, a1, a2, ...], d=R)

Construct polynomial a0 + a1 x + a2 x^2 + ... defined on domain d.

PolynomialSpace{N,K}

FunctionSpace of possibly multivarite polynomials of N variables and maximum exponent K.

Q{N,K}

FunctionSpace of N-variate polynomials where the largest exponent is smaller equal K.

Q23R{K}

Reduced polynomial space Q{2,3,K} for nonconforming Kirchhoff rectangle.

S{N, K}

FunctionSpace of serendipity polynomials. Only defined for n=2 and k=2,3.

ValueAtLF(x)

The linear form $b$ with $b(f) = f(x)$ for a specified position $x$.

Vector field ''R^n \to R^n'' with `n >1`.

Neutral element w.r.t. addition.

div(v)

Shorthand notation for divergence(v)

Base.intersect(s, x)
Base.intersect(x, s)
s ∩ x
x ∩ s

Select all values from the vector x which are in the interval s.

H(f) returns the Hessian of function f

_antiderivative(::FunctionRToR) -> FunctionRToR

Fallback for function types which do not provide higher order antiderivatives.

_combineforms(points, genforms)

Helper function to construct linear forms.

_derivative(f::FunctionRnToR{N}, n::Integer)

Default implementation of n-th order derivative of multivariate function f. Currently implemented for

• n = 1: Returns the gradient function

• n = 2: Returns the Hessian function

_derivativeat(f::FunctionRnToR{N,D}, x::InRⁿ{N}, ns::AbstractArray{<:Integer})

Default implementation for the evaluation of the ns partial derivative of f at x. Note that this is an inefficient implementation which computes the derivative function first.

_derivativeat(f::FunctionRnToR{N}, x::InRⁿ{N}, n::Integer)

Default implementation for the evaluation n-th order derivative of multivariate function f at position x. Currently implemented for

• n = 1: Returns the gradient of f at x

• n = 2: Returns the Hessian of f at x

_dimension(s::Type{<:PolynomialSpace})

Fallback implemenentation to determine the dimension of space s. Useful for testing.

_factorialpower(m, n)

Return the product ``m (m - 1) ... (m - n)

_makebreakpoints(pts, I)

Make breakpoints from Interval I and all points from pts which are in I.

_nn(n, indices...)

Converts sequence of variable indices to vector of length n indicating orders of partial derivatives. For instance, calling _nn(2, 1, 2, 1, 1) representing $w_{xyxx}$ returns [3, 1] which corresponds to $w_{xxxy}$.

affinefunction(I₁::Interval, I₂::Interval)

Affine function $f: I_1 \to I_2$ with $f(I_1) = I_2$.

antiderivative(f::FunctionRToR, n=1) -> FunctionRToR

An n-th antiderivative of the function f.

basis(s::FunctionSpace{DT,CT}, d) -> Vector{<:AbstractMapping{DT,CT}}

Generate a basis for function space s defined on d.

Type of elements in the codomain of the mapping.

Type of elements in the codomain of the mapping.

degree(f)
degree(f, i)

Polynomial degree of f. Returns the

• number -1 if f` is the zero function

• largest exponent if f is a polynomial

• largest sum of exponents if f is a multivariate polynomial

• Inf in all other cases

For a multivariate mapping f, the invocation degree(f, i) returns the polynomial degree in the i-th parameter.

derivative(m::AbstractMapping{DT, CT}, n::Integer = 1) -> AbstractMapping{DT, dt(DT, CT, n)}
derivative(m::AbstractMapping{DT, CT}, ns::AbstractArray{Integer}) -> AbstractMapping{DT, CT}

• The (generalized) n-th derivative of m.

• The (generalized) ns-th partial derivative of m.

derivativeat(m::AbstractMapping{DT, CT}, x::DT, n::Integer = 1) -> dt(DT, CT, n)
derivativeat(m::AbstractMapping{DT, CT}, x::DT, ns::AbstractArray{Integer}) -> CT

• Evaluates the (generalized) n-th derivative at x where dt(DT, CT, n) is the derivative type.

• Evaluates the (generalized) ns-th partial derivative at x. For instance derivativeat(f, x, [2, 1]) computes $f_{xxy}(x, y)$.

derivativetype(m, n)
derivativetype(DT, CT, n)

Type of the n-th order derivative for the mapping m or domain type DT and codomain type CT. For instance, the second derivative of a function R2 to R is a 2x2 matrix.

divergence(v::VectorField)

Divergence of the vector field v.

divergenceat(v::VectorField, x::InRⁿ)

Evaluates the divergence of the vector field v at point x.

Domain of the mapping.

Type of elements in the domain of the mapping.

Type of elements in the domain of the mapping.

Gradient of function f

hatfunctions(x::AbstractVector{<:Real})

Given an ascending node vector $x_1, x_2, \dots, x_{N_N}$, returns the 1D piecewise affine finite element basis functions $\varphi_1, \dots, \varphi_{N_N}$ with $\varphi_i(x_j) = \delta_{ij}$ for $i,j = 1, \dots, N_N$.

hermiteelement(K; conforming=true)

Hermite type finite element. Generates the Bogner-Fox-Schmit element (Braess, p. 72) if K is a rectangle and conforming is true.

Hessian of function f

integrate(f::FunctionRToR, I::Interval) -> Float64

The integral of the function f over the interval I.

interpolate(x::AbstractVector{<:Real}, y::AbstractVector{<:Real}; order=1)

Construct a function which interpolates the points $(x_1, y_1), (x_2, y_2), \dots, (x_n, y_n)$. The entries in x have to be in ascending order and x and y need to have the same length.

jacobian(u::MappingRnToRm)

Jacobian of the mapping u.

jacobianat(u::MappingRnToRm, x::InRⁿ)

Evaluates the jacobian of the mapping u at point x.

lagrangeelement(K, k)

Lagrange type finite element.

lagrangepolynomials(x, D=R)

Lagrange polynomials for nodes $x_0, \dots, x_k$ defined on the domain D.

Laplacian of function f

linesegment(p1, p2)

Returns the line segment from p1 to p2 as parametric curve.

mmonomials(n::Integer, p::Integer, dom=R^n, predicate=(...) -> true; type=Float64)

Generate multivariate momonials of n components up to degree p. Optionally, a domain, a predicate and a coefficient type can be specified

monomials(p, D=R)

Monomials of degree $p_1, \dots, p_n$ defined on the domain D.

nodalbasis(e)
nodalbasis(t, d)

Generate a nodal basis for element e defined on d. This default implementation might be overridden by specific element types. Option to specify domain only useful for symbolic domains.

An independent variable of a function.

points(K, on, n=0)

Pick certain points from domain K at locations on which can take the following values

• :corners – Returns points on corners of the domain

• :sides – Gives n points equidistantly distributed on each side

• :interior – Generates n by n points in the interior

pois(m::MappingFromR) -> Float64[]

Return the points of interest of the mapping m.

polynomialinterpolation(points)
polynomialinterpolation(p1, p2, p3, ...)
polynomialinterpolation([p1, p2, p3, ...])

Constructs a polynomial parametric curve interpolating the specified points. The curve is defined on the unit interval [-1, 1].

roots(m::MappingFromR, I::Union{Nothing,Interval}=nothing) -> Float64[]

Return the roots of the mapping m either in I or the domain of m.

serendipityelement(K, k)

Serendipity element (currently only for rectangles and $k=1,2$).

valueat(m::AbstractMapping{DT, CT}, x::DT) -> CT

Evaluate the mapping m at x.

Δ(f) returns the Laplacian of function f

∇(f) returns the gradient of function f

dimension