Slight refactor of monomial basis

.github/workflows/CI.yml

@@ -18,7 +18,6 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.6'
           - '1.7'
           - '1.8'
           - '1.9'
@@ -28,7 +27,6 @@ jobs:
           - ubuntu-latest
         arch:
           - x64
-          - x86
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1

Project.toml

@@ -1,7 +1,7 @@
 name = "RadialBasisFunctions"
 uuid = "79ee0514-adf7-4479-8807-6f72ea8967e8"
 authors = ["Kyle Beggs"]
-version = "0.2.2"
+version = "0.2.3"
 
 [deps]
 ChunkSplitters = "ae650224-84b6-46f8-82ea-d812ca08434e"
@@ -22,7 +22,7 @@ NearestNeighbors = "0.4"
 PrecompileTools = "1"
 StaticArraysCore = "1.4"
 SymRCM = "0.2"
-julia = "1.6"
+julia = "1.7"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

src/RadialBasisFunctions.jl

@@ -20,7 +20,7 @@ export MonomialBasis
 include("utils.jl")
 export find_neighbors, reorder_points!
 
-include("linalg/stencil.jl")
+include("solve.jl")
 
 include("operators/operators.jl")
 export RadialBasisOperator, update_weights!
@@ -40,7 +40,7 @@ export Directional, directional
 include("operators/virtual.jl")
 export ∂virtual
 
-include("operators/monomial.jl")
+include("operators/monomial/monomial.jl")
 
 include("operators/operator_combinations.jl")
 
@@ -63,7 +63,7 @@ using PrecompileTools
         basis_funcs = [
             IMQ(1),
             Gaussian(1),
-            PHS(1; poly_deg=-1),
+            PHS(1; poly_deg=0),
             PHS(3; poly_deg=0),
             PHS(5; poly_deg=1),
             PHS(7; poly_deg=2),

src/basis/basis.jl

@@ -1,29 +1,39 @@
 """
-    abstract type AbstractRadialBasis end
+    abstract type AbstractBasis end
 """
-abstract type AbstractRadialBasis end
+abstract type AbstractBasis end
+
+"""
+    abstract type AbstractRadialBasis <: AbstractBasis end
+"""
+abstract type AbstractRadialBasis <: AbstractBasis end
 
 struct ℒRadialBasisFunction{F<:Function}
     f::F
 end
 (ℒrbf::ℒRadialBasisFunction)(x, xᵢ) = ℒrbf.f(x, xᵢ)
 
-struct ℒMonomial{F<:Function}
+struct ℒMonomialBasis{Dim,Deg,F<:Function}
     f::F
+    function ℒMonomialBasis(dim::T, deg::T, f) where {T<:Int}
+        if deg < 0
+            throw(ArgumentError("Monomial basis must have non-negative degree"))
+        end
+        return new{dim,deg,typeof(f)}(f)
+    end
 end
-(ℒmon::ℒMonomial)(m, x) = ℒmon.f(m, x)
+function (ℒmon::ℒMonomialBasis{Dim,Deg})(x) where {Dim,Deg}
+    b = ones(_get_underlying_type(x), binomial(Dim + Deg, Dim))
+    ℒmon(b, x)
+    return b
+end
+(m::ℒMonomialBasis)(b, x) = m.f(b, x)
 
 include("polyharmonic_spline.jl")
 include("inverse_multiquadric.jl")
 include("gaussian.jl")
 include("monomial.jl")
 
-function ∂(basis::B, order::T, dim::T) where {T<:Int,B<:AbstractRadialBasis}
-    return ∂(basis, Val(order), dim)
-end
-∂(basis::B, dim::T) where {T<:Int,B} = ∂(basis, Val(1), dim)
-∂²(basis::B, dim::T) where {T<:Int,B} = ∂(basis, Val(2), dim)
-
 # pretty printing
 unicode_order(::Val{1}) = ""
 unicode_order(::Val{2}) = "²"

src/basis/gaussian.jl

@@ -18,7 +18,7 @@ end
 
 (rbf::Gaussian)(x, xᵢ) = exp(-(rbf.ε * euclidean(x, xᵢ))^2)
 
-function ∂(rbf::Gaussian, ::Val{1}, dim::Int)
+function ∂(rbf::Gaussian, dim::Int)
     function ∂ℒ(x, xᵢ)
         return -2 * rbf.ε^2 * (x[dim] - xᵢ[dim]) * exp(-rbf.ε^2 * sqeuclidean(x, xᵢ))
     end
@@ -30,7 +30,7 @@ function ∇(rbf::Gaussian)
     end
 end
 
-function ∂(rbf::Gaussian, ::Val{2}, dim::Int)
+function ∂²(rbf::Gaussian, dim::Int)
     function ∂²ℒ(x, xᵢ)
         ε2 = rbf.ε^2
         return (4 * ε2^2 * (x[dim] - xᵢ[dim])^2 - 2 * ε2) * exp(-ε2 * sqeuclidean(x, xᵢ))

src/basis/inverse_multiquadric.jl

@@ -15,7 +15,7 @@ end
 
 (rbf::IMQ)(x, xᵢ) = 1 / sqrt((euclidean(x, xᵢ) * rbf.ε)^2 + 1)
 
-function ∂(rbf::IMQ, ::Val{1}, dim::Int=1)
+function ∂(rbf::IMQ, dim::Int=1)
     function ∂ℒ(x, xᵢ)
         ε2 = rbf.ε .^ 2
         return (xᵢ[dim] - x[dim]) .* (ε2 / sqrt((ε2 * sqeuclidean(x, xᵢ) + 1)^3))
@@ -29,7 +29,7 @@ function ∇(rbf::IMQ)
     end
 end
 
-function ∂(rbf::IMQ, ::Val{2}, dim::Int=1)
+function ∂²(rbf::IMQ, dim::Int=1)
     function ∂²ℒ(x, xᵢ)
         ε2 = rbf.ε .^ 2
         ε4 = ε2^2

src/basis/monomial.jl

@@ -1,39 +1,100 @@
 """
-    struct MonomialBasis{T<:Int,B<:Function}
+    struct MonomialBasis{Dim,Deg} <: AbstractBasis
 
-Multivariate Monomial basis.
-n ∈ N: length of array, i.e., x ∈ Rⁿ
-deg ∈ N: degree
+`Dim` dimensional monomial basis of order `Deg`.
 """
-struct MonomialBasis{T<:Int,B}
-    n::T
-    deg::T
-    basis!::B
-    function MonomialBasis(n::T, deg::T) where {T<:Int}
+struct MonomialBasis{Dim,Deg,F<:Function} <: AbstractBasis
+    f::F
+    function MonomialBasis(dim::T, deg::T) where {T<:Int}
         if deg < 0
-            basis! = nothing
-        else
-            basis! = build_monomial_basis(n, deg)
+            throw(ArgumentError("Monomial basis must have non-negative degree"))
         end
-        return new{T,typeof(basis!)}(n, deg, basis!)
+        f = _get_monomial_basis(Val(dim), Val(deg))
+        return new{dim,deg,typeof(f)}(f)
     end
 end
 
-function (m::MonomialBasis)(x::AbstractVector{T}) where {T}
-    b = ones(T, binomial(m.n + m.deg, m.n))
-    m.basis!(b, x)
+function (m::MonomialBasis{Dim,Deg})(x) where {Dim,Deg}
+    b = ones(_get_underlying_type(x), binomial(Dim + Deg, Dim))
+    m.f(b, x)
     return b
 end
-(m::MonomialBasis)(b, x) = m.basis!(b, x)
+(m::MonomialBasis)(b, x) = m.f(b, x)
 
-function build_monomial_basis(n::T, deg::T) where {T<:Int}
-    if deg == 0
-        basis! = (b, x) -> b .= one(eltype(x))
-        return basis!
+for Dim in (:1, :2, :3)
+    @eval begin
+        function _get_monomial_basis(::Val{$Dim}, ::Val{0})
+            return function basis!(b, x)
+                b[1] = one(_get_underlying_type(x))
+                return nothing
+            end
+        end
+    end
+end
+
+function _get_monomial_basis(::Val{1}, ::Val{N}) where {N}
+    return function basis!(b, x)
+        b[1] = one(_get_underlying_type(x))
+        if N > 0
+            for n in 1:N
+                b[n + 1] = only(x)^n
+            end
+        end
+        return nothing
+    end
+end
+
+function _get_monomial_basis(::Val{2}, ::Val{1})
+    return function basis!(b, x)
+        b[1] = one(eltype(x))
+        b[2] = x[1]
+        b[3] = x[2]
+        return nothing
+    end
+end
+
+function _get_monomial_basis(::Val{2}, ::Val{2})
+    return function basis!(b, x)
+        b[1] = one(eltype(x))
+        b[2] = x[1]
+        b[3] = x[2]
+        b[4] = x[1] * x[2]
+        b[5] = x[1] * x[1]
+        b[6] = x[2] * x[2]
+        return nothing
+    end
+end
+
+function _get_monomial_basis(::Val{3}, ::Val{1})
+    return function basis!(b, x)
+        b[1] = one(eltype(x))
+        b[2] = x[1]
+        b[3] = x[2]
+        b[4] = x[3]
+        return nothing
     end
-    e = multiexponents(n + 1, deg)
-    e = map(i -> getindex.(e, i), 1:n)
-    ids = map(j -> map(i -> findall(x -> x >= i, e[j]), 1:deg), 1:n)
+end
+
+function _get_monomial_basis(::Val{3}, ::Val{2})
+    return function basis!(b, x)
+        b[1] = one(eltype(x))
+        b[2] = x[1]
+        b[3] = x[2]
+        b[4] = x[3]
+        b[5] = x[1] * x[2]
+        b[6] = x[1] * x[3]
+        b[7] = x[2] * x[3]
+        b[8] = x[1] * x[1]
+        b[9] = x[2] * x[2]
+        b[10] = x[3] * x[3]
+        return nothing
+    end
+end
+
+function _get_monomial_basis(::Val{Dim}, ::Val{Deg}) where {Dim,Deg}
+    e = multiexponents(Dim + 1, Deg)
+    e = map(i -> getindex.(e, i), 1:Dim)
+    ids = map(j -> map(i -> findall(x -> x >= i, e[j]), 1:Deg), 1:Dim)
     return build_monomial_basis(ids)
 end
 
@@ -49,7 +110,6 @@ function build_monomial_basis(ids::Vector{Vector{Vector{T}}}) where {T<:Int}
     return basis!
 end
 
-# pretty printing
-function Base.show(io::IO, pb::MonomialBasis)
-    return print(io, "MonomialBasis, deg=$(pb.deg) in $(pb.n) dimensions")
+function Base.show(io::IO, ::MonomialBasis{Dim,Deg}) where {Dim,Deg}
+    return print(io, "MonomialBasis of degree $(Deg) in $(Dim) dimensions")
 end

src/basis/polyharmonic_spline.jl

@@ -38,15 +38,15 @@ struct PHS1{T<:Int} <: AbstractPHS
 end
 
 (phs::PHS1)(x, xᵢ) = euclidean(x, xᵢ)
-function ∂(::PHS1, ::Val{1}, dim::Int)
+function ∂(::PHS1, dim::Int)
     ∂ℒ(x, xᵢ) = (x[dim] - xᵢ[dim]) / (euclidean(x, xᵢ) + DIV0_OFFSET)
     return ℒRadialBasisFunction(∂ℒ)
 end
 function ∇(::PHS1)
     ∇ℒ(x, xᵢ) = (x .- xᵢ) / euclidean(x, xᵢ)
     return ℒRadialBasisFunction(∇ℒ)
 end
-function ∂(::PHS1, ::Val{2}, dim::Int)
+function ∂²(::PHS1, dim::Int)
     function ∂²ℒ(x, xᵢ)
         return (-(x[dim] - xᵢ[dim])^2 + sqeuclidean(x, xᵢ)) /
                (euclidean(x, xᵢ)^3 + DIV0_OFFSET)
@@ -76,15 +76,15 @@ struct PHS3{T<:Int} <: AbstractPHS
 end
 
 (phs::PHS3)(x, xᵢ) = euclidean(x, xᵢ)^3
-function ∂(::PHS3, ::Val{1}, dim::Int)
+function ∂(::PHS3, dim::Int)
     ∂ℒ(x, xᵢ) = 3 * (x[dim] - xᵢ[dim]) * euclidean(x, xᵢ)
     return ℒRadialBasisFunction(∂ℒ)
 end
 function ∇(::PHS3)
     ∇ℒ(x, xᵢ) = 3 * (x .- xᵢ) * euclidean(x, xᵢ)
     return ℒRadialBasisFunction(∇ℒ)
 end
-function ∂(::PHS3, ::Val{2}, dim::Int)
+function ∂²(::PHS3, dim::Int)
     function ∂²ℒ(x, xᵢ)
         return 3 * (sqeuclidean(x, xᵢ) + (x[dim] - xᵢ[dim])^2) /
                (euclidean(x, xᵢ) + DIV0_OFFSET)
@@ -114,15 +114,15 @@ struct PHS5{T<:Int} <: AbstractPHS
 end
 
 (phs::PHS5)(x, xᵢ) = euclidean(x, xᵢ)^5
-function ∂(::PHS5, ::Val{1}, dim::Int)
+function ∂(::PHS5, dim::Int)
     ∂ℒ(x, xᵢ) = 5 * (x[dim] - xᵢ[dim]) * euclidean(x, xᵢ)^3
     return ℒRadialBasisFunction(∂ℒ)
 end
 function ∇(::PHS5)
     ∇ℒ(x, xᵢ) = 5 * (x .- xᵢ) * euclidean(x, xᵢ)^3
     return ℒRadialBasisFunction(∇ℒ)
 end
-function ∂(::PHS5, ::Val{2}, dim::Int)
+function ∂²(::PHS5, dim::Int)
     return function ∂²ℒ(x, xᵢ)
         return 5 * euclidean(x, xᵢ) * (3 * (x[dim] - xᵢ[dim])^2 + sqeuclidean(x, xᵢ))
     end
@@ -149,15 +149,15 @@ struct PHS7{T<:Int} <: AbstractPHS
 end
 
 (phs::PHS7)(x, xᵢ) = euclidean(x, xᵢ)^7
-function ∂(::PHS7, ::Val{1}, dim::Int)
+function ∂(::PHS7, dim::Int)
     ∂ℒ(x, xᵢ) = 7 * (x[dim] - xᵢ[dim]) * euclidean(x, xᵢ)^5
     return ℒRadialBasisFunction(∂ℒ)
 end
 function ∇(::PHS7)
     ∇ℒ(x, xᵢ) = 7 * (x .- xᵢ) * euclidean(x, xᵢ)^5
     return ℒRadialBasisFunction(∇ℒ)
 end
-function ∂(::PHS7, ::Val{2}, dim::Int)
+function ∂²(::PHS7, dim::Int)
     function ∂²ℒ(x, xᵢ)
         return 7 * euclidean(x, xᵢ)^3 * (5 * (x[dim] - xᵢ[dim])^2 + sqeuclidean(x, xᵢ))
     end

src/interpolation.jl

@@ -40,8 +40,8 @@ function (rbfi::Interpolator)(x::T) where {T}
     poly = zero(eltype(T))
     if !isempty(rbfi.monomial_weights)
         val_poly = rbfi.monomial_basis(x)
-        for i in eachindex(rbfi.monomial_weights)
-            poly += rbfi.monomial_weights[i] * val_poly[i]
+        for (i, val) in enumerate(val_poly)
+            poly += rbfi.monomial_weights[i] * val
         end
     end
     return rbf + poly
@@ -59,6 +59,7 @@ function Base.show(io::IO, op::Interpolator)
         io,
         "└─Basis: ",
         print_basis(op.rbf_basis),
-        " with degree $(op.monomial_basis.deg) Monomial",
+        " with degree $(_get_deg(op.monomial_basis)) Monomial",
     )
 end
+_get_deg(::MonomialBasis{Dim,Deg}) where {Dim,Deg} = Deg

src/operators/directional.jl

@@ -20,11 +20,7 @@ function directional(
     k::T=autoselect_k(data, basis),
     adjl=find_neighbors(data, k),
 ) where {D<:AbstractArray,B<:AbstractRadialBasis,T<:Int}
-    f = ntuple(length(first(data))) do dim
-        return let dim = dim
-            x -> ∂(x, 1, dim)
-        end
-    end
+    f = ntuple(dim -> Base.Fix2(∂, dim), length(first(data)))
     ℒ = Directional(f, v)
     return RadialBasisOperator(ℒ, data, basis; k=k, adjl=adjl)
 end
@@ -42,11 +38,7 @@ function directional(
     k::T=autoselect_k(data, basis),
     adjl=find_neighbors(data, eval_points, k),
 ) where {B<:AbstractRadialBasis,T<:Int}
-    f = ntuple(length(first(data))) do dim
-        return let dim = dim
-            x -> ∂(x, 1, dim)
-        end
-    end
+    f = ntuple(dim -> Base.Fix2(∂, dim), length(first(data)))
     ℒ = Directional(f, v)
     return RadialBasisOperator(ℒ, data, eval_points, basis; k=k, adjl=adjl)
 end