Categories
GraviPet.Categories.Category
— Method(cat::Category)(x)::eltype(codomain(cat))
Evaluate the function cat
at point x
. This is written as a function call cat(x)
. See also evaluate
.
GraviPet.Categories.evaluate
— Methodevaluate(cat::Category, x)::eltype(codomain(cat))
Evaluate the function cat
at point x
. This can also be written as a function call cat(x)
.
GraviPet.Categories.integrate
— Methodintegrate(cat::Category)::eltype(codomain(cat))
Integrate the function cat
over its domain.
GraviPet.Categories.project
— Methodproject(dst::T, src::Category)::T where {T<:Category}
Project the function src
onto the representation given by dst
. This can be used e.g. to sample Julia functions on a given grid, or to resample functiont on a different grid. dst
can be a skeleton representation.
Julia Functions
GraviPet.JuliaFunctions.JuliaFunction
— MethodJuliaFunction{DS,S,DT,T}(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T})
JuliaFunction(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T})
Create a zero-valued Julia function, i.e. a Julia function that is zero everywhere. The codomain
can be a zero-valued domain created via Box{DT,T}()
.
1D Grid Functions
GraviPet.GridFunctions1D.GridFunction1D
— MethodGridFunction1D{S,T}(name::AbstractString, domain::Interval{S}, codomain::Interval{T}, npoints::Int)
GridFunction1D(name::AbstractString, domain::Interval{S}, codomain::Interval{T}, npoints::Int)
Create a zero-valued grid function, i.e. a grid function that is zero everywhere. The codomain
can be a zero-valued domain created via Interval{T}()
.
npoints
specifies the resolution of the grid function. This makes it convenient to use zero-valued grid functions as "templates" or "skeletons" when creating other grid functions.
This zero-valued grid function is represented efficiently and does not store one element per grid point.
Multi-dimensional Grid Functions
GraviPet.GridFunctions.GridFunction
— MethodGridFunction{DS,S,DT,T}(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T}, grid_size::SVector{DS,Int})
GridFunction(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T}, grid_size::SVector{DS,Int})
Create a zero-valued grid function, i.e. a grid function that is zero everywhere. The codomain
can be a zero-valued domain created via Box{DT,T}()
.
grid_size
specifies the resolution of the grid function. This makes it convenient to use zero-valued grid functions as "templates" or "skeletons" when creating other grid functions.
This zero-valued grid function is represented efficiently and does not store one element per grid point.
Blocked Functions (Domain Decomposition)
Threaded Functions
Distributed Functions
Kernel Functions
GraviPet.KernelFunctions.KernelFunction
— MethodKernelFunction{DS,S,DT,T}(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T}, grid_size::SVector{DS,Int})
KernelFunction(name::AbstractString, domain::Box{DS,S}, codomain::Box{DT,T}, grid_size::SVector{DS,Int})
Create a zero-valued Kernel function, i.e. a Kernel function that is zero everywhere. The codomain
can be a zero-valued domain created via Box{DT,T}()
.
grid_size
specifies the resolution of the Kernel function. This makes it convenient to use zero-valued Kernel functions as "templates" or "skeletons" when creating other Kernel functions.
Miscellaneous
Base.:==
— Method==(dom1::Domain, dom2::Domain)::Bool
Equality for domains. Domains are equal if the have the same number of dimensions (see ndims
), and the same lower and upper bounds (see first
and last
). The element types might be different if they can be compared for equality, e.g. Float64
and BigFloat
.
Incompatible domains (living in different number of dimensions) are treated as unequal.
Base.last
— Methodlast(dom::Domain{T})::T
Return the upper bound of the domain. (At the moment domains are assumed to be cuboid, i.e. to form a box or hyper-rectangle.) Domain bounds can be infinity.
See also first
.
Base.isdisjoint
— Methodisdisjoint(dom1::Domain, dom2::Domain)::Bool
Test whether dom1
is disjoint from dom2
. Only compatible domains (which live in the same number of dimensions) can be compared.
Base.eltype
— Methodeltype(dom::Domain)::Type
Return the element type of a Domain
.
Base.ndims
— Methodndims(dom::Domain)::Int
Return the number of dimensions of a Domain
. Scalar domains are one-dimensional. Zero-dimensional domains consist of a single point only.
Base.issubset
— Methodissubset(dom1::Domain, dom2::Domain)::Bool
Test whether dom1
is a subset of dom2
. Only compatible domains (which live in the same number of dimensions) can be compared.
Base.in
— Methodin(elem, dom::Domain)::Bool
Test whether elem
is inside domain dom
.
Base.first
— Methodfirst(dom::Domain{T})::T
Return the lower bound of the domain. (At the moment domains are assumed to be cuboid, i.e. to form a box or hyper-rectangle.) Domain bounds can be infinity.
See also last
.