Mercurial > repos > public > sbplib_julia

comparison src/SbpOperators/quadrature/diagonal_quadrature.jl @ 546:09ae5b519b4c feature/quadrature_as_outer_product

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update documentation
author Vidar Stiernström <vidar.stiernstrom@it.uu.se>
date Fri, 27 Nov 2020 12:33:10 +0100
parents 576c6d1acc28
children 3c18a15934a7
comparison
equal deleted inserted replaced
545:ff412b29db31 546:09ae5b519b4c
16 export diagonal_quadrature 16 export diagonal_quadrature
17 17
18 """ 18 """
19 DiagonalQuadrature{T,M} <: TensorMapping{T,1,1} 19 DiagonalQuadrature{T,M} <: TensorMapping{T,1,1}
20 20
21 Implements the one-dimensional diagonal quadrature operator as a `TensorMapping 21 Implements the one-dimensional diagonal quadrature operator as a `TensorMapping`
22 TODO: Elaborate on properties 22 The quadrature is defined by the quadrature interval length `h`, the quadrature
23 closure weights `closure` and the number of quadrature intervals `size`. The
24 interior stencil has the weight 1.
23 """ 25 """
24 struct DiagonalQuadrature{T,M} <: TensorMapping{T,1,1} 26 struct DiagonalQuadrature{T,M} <: TensorMapping{T,1,1}
25 h::T 27 h::T
26 closure::NTuple{M,T} 28 closure::NTuple{M,T}
27 size::Tuple{Int} 29 size::Tuple{Int}
29 export DiagonalQuadrature 31 export DiagonalQuadrature
30 32
31 """ 33 """
32 DiagonalQuadrature(g, quadrature_closure) 34 DiagonalQuadrature(g, quadrature_closure)
33 35
34 Constructs the `DiagonalQuadrature` defined by the `EquidistantGrid` `g` and 36 Constructs the `DiagonalQuadrature` `H` on the `EquidistantGrid` `g` with
35 closure stencil `quadrature_closure`. 37 `H.closure` specified by `quadrature_closure`.
36 """ 38 """
37 function DiagonalQuadrature(g::EquidistantGrid{1}, quadrature_closure) 39 function DiagonalQuadrature(g::EquidistantGrid{1}, quadrature_closure)
38 return DiagonalQuadrature(spacing(g)[1], quadrature_closure, size(g)) 40 return DiagonalQuadrature(spacing(g)[1], quadrature_closure, size(g))
39 end 41 end
40 42
41 LazyTensors.range_size(H::DiagonalQuadrature) = H.size 43 LazyTensors.range_size(H::DiagonalQuadrature) = H.size
42 LazyTensors.domain_size(H::DiagonalQuadrature) = H.size 44 LazyTensors.domain_size(H::DiagonalQuadrature) = H.size
43 45
44 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index) where T 46 """
45 return @inbounds apply(H, v, I) 47 apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index) where T
46 end 48 Implements the application `(H*v)[i]` an `Index{R}` where `R` is one of the regions
47 49 `Lower`,`Interior`,`Upper`,`Unknown`.
50 """
48 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index{Lower}) where T 51 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index{Lower}) where T
49 return @inbounds H.h*H.closure[Int(I)]*v[Int(I)] 52 return @inbounds H.h*H.closure[Int(I)]*v[Int(I)]
50 end 53 end
51 54
52 function LazyTensors.apply(H::DiagonalQuadrature{T},v::AbstractVector{T}, I::Index{Upper}) where T 55 function LazyTensors.apply(H::DiagonalQuadrature{T},v::AbstractVector{T}, I::Index{Upper}) where T
56 59
57 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index{Interior}) where T 60 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index{Interior}) where T
58 return @inbounds H.h*v[Int(I)] 61 return @inbounds H.h*v[Int(I)]
59 end 62 end
60 63
61 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, index::Index{Unknown}) where T 64 function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index{Unknown}) where T
62 N = length(v); 65 N = length(v);
63 r = getregion(Int(index), closure_size(H), N) 66 r = getregion(Int(I), closure_size(H), N)
64 i = Index(Int(index), r) 67 i = Index(Int(I), r)
65 return LazyTensors.apply(H, v, i) 68 return LazyTensors.apply(H, v, i)
66 end 69 end
67 70
68 LazyTensors.apply_transpose(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index) where T = LazyTensors.apply(H,v,I) 71 """
72 apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::Index) where T
73 Implements the application (H'*v)[I]. The operator is self-adjoint.
74 """
75 LazyTensors.apply_transpose(H::DiagonalQuadrature, v::AbstractVector, I) = LazyTensors.apply(H,v,I)
69 76
70 """ 77 """
71 closure_size(H) 78 closure_size(H)
72 Returns the size of the closure stencil of a DiagonalQuadrature `H`. 79 Returns the size of the closure stencil of a DiagonalQuadrature `H`.
73 """ 80 """