A Julia package for working with spherical harmonic expansions

License: MIT License

Julia 100.00%

harmonicorthogonalpolynomials.jl's Introduction

HarmonicOrthogonalPolynomials.jl

A Julia package for working with spherical harmonic expansions and harmonic polynomials in balls.

A harmonic polynomial is a multivariate polynomial that solves Laplace's equation. Spherical harmonics are restrictions of harmonic polynomials to the sphere. Importantly they are orthogonal. This package is primarily an implementation of spherical harmonics (in 2D and 3D) but exploiting their polynomial features.

Currently this package focusses on support for 3D spherical harmonics. We use the convention of FastTransforms for real spherical harmonics:

julia> θ,φ = 0.1,0.2 # θ is polar, φ is azimuthal (physics convention)

julia> sphericalharmonicy(ℓ, m, θ, φ)
0.07521112971423363 + 0.015246050775019674im

But we also allow function approximation, building on top of ContinuumArrays.jl and ClassicalOrthogonalPolynomials.jl:

julia> S = SphericalHarmonic() # A quasi-matrix representation of spherical harmonics
SphericalHarmonic{Complex{Float64}}

julia> S[SphericalCoordinate(θ,φ),Block(ℓ+1)] # evaluate all spherical harmonics with specified ℓ
5-element Array{Complex{Float64},1}:
 0.003545977402630546 - 0.0014992151996309556im
  0.07521112971423363 - 0.015246050775019674im
    0.621352880681805 + 0.0im
  0.07521112971423363 + 0.015246050775019674im
 0.003545977402630546 + 0.0014992151996309556im

julia> 𝐱 = axes(S,1) # represent the unit sphere as a quasi-vector
Inclusion(the 3-dimensional unit sphere)

julia> f = 𝐱 -> ((x,y,z) = 𝐱; exp(x)*cos(y*sin(z))); # function to be approximation

julia> S \ f.(𝐱) # expansion coefficients, adaptively computed
∞-blocked ∞-element BlockedArray{Complex{Float64},1,LazyArrays.CachedArray{Complex{Float64},1,Array{Complex{Float64},1},Zeros{Complex{Float64},1,Tuple{InfiniteArrays.OneToInf{Int64}}}},Tuple{BlockedOneTo{Int,ArrayLayouts.RangeCumsum{Int64,InfiniteArrays.InfStepRange{Int64,Int64}}}}}:
        4.05681442931116 + 0.0im                   
 ──────────────────────────────────────────────────
      1.5777291816142751 + 3.19754060061646e-16im  
  -8.006900295635809e-17 + 0.0im                   
      1.5777291816142751 - 3.539535261006306e-16im 
 ──────────────────────────────────────────────────
      0.3881560551355611 + 5.196884701505137e-17im 
  -7.035627371746071e-17 + 2.5784941810054987e-18im
    -0.30926350498081934 + 0.0im                   
   -6.82462130695514e-17 - 3.515332651034677e-18im 
      0.3881560551355611 - 6.271963079558218e-17im 
 ──────────────────────────────────────────────────
     0.06830566496722756 - 8.852861226980248e-17im 
 -2.3672451919730833e-17 + 2.642173739237023e-18im 
     -0.0514592471634392 - 1.5572791163000952e-17im
  1.1972144648274198e-16 + 0.0im                   
    -0.05145924716343915 + 1.5264133695821818e-17im
                         ⋮

julia> f̃ = S * (S \ f.(𝐱)); # expansion of f in spherical harmonics

julia> f̃[SphericalCoordinate(θ,φ)] # approximates f
1.1026374731849062 + 4.004893695029451e-16im

harmonicorthogonalpolynomials.jl's People

Contributors

Stargazers

Watchers

Forkers

asclepiusinformatica tangwang-ustc

harmonicorthogonalpolynomials.jl's Issues

Some duplicate code SphericalHarmonics.jl

I assume bc my PR #10 was originally based on the dl/transform branch the merge order of the PRs somehow duplicated some of your complex spherical transforms code in SphericalHarmonics.jl. See e.g. repeat definition of struct SphereTrav which could lead to issues:
Here:

HarmonicOrthogonalPolynomials.jl/src/SphericalHarmonics.jl

Line 31 in c9afdb3

struct SphereTrav{T, AA<:AbstractMatrix{T}} <: AbstractBlockVector{T}

and here:

HarmonicOrthogonalPolynomials.jl/src/SphericalHarmonics.jl

Line 106 in c9afdb3

struct SphereTrav{T, AA<:AbstractMatrix{T}} <: AbstractBlockVector{T}

Do you want me to go through and clean this up?

Normalization?

@jagot suggested Condon–Shortley:

If you choose Condon–Shortley (which is commonly used by physicists), you could employ https://github.com/Jutho/WignerSymbols.jl for exact angular integrals. This is what I use in https://juliaatoms.github.io/AngularMomentumAlgebra.jl/dev/.

@MikaelSlevinsky Any preference?

Tag v0.0.1

I think we should try to tag ASAP so other packages can start depending on this. What we need to do first:

Tag ClassicalOrthogonalPolynomials.jl
Add README
Add Laplacian

@TSGut How do you feel about trying to tackle the Laplacian part? Following https://github.com/JuliaApproximation/MultivariateOrthogonalPolynomials.jl/blob/dd5c05b799014deb9d82286ac264524c7e33c22d/src/Triangle/Triangle.jl#L90
we probably want to do something like this:

@simplify function *(Dx::Laplacian, P::SphericalHarmonic)
    ℓ = mortar(Fill.(Base.OneTo(∞), 1:2:∞))
    m = mortar((:).(0:-1:(-∞), 0:∞))
    P * Diagonal(func_of_m_and_ℓ.(m, ℓ))
end

so in theory just add the formula to func_of_m_and_ℓ. Though I'm sure there will be bugs that I'll have to have a crack at... but a good task if you feel like getting some understanding on how the Infinite block array stuff actually works.

Fast evaluation via recurrence relations

Would this package be the right place for fast evaluation of a range of spherical harmonics using recurrence relations? In one algorithm, I need to repeatedly evaluate spherical harmonics at varying angles but for a predetermined range of ells and ms, and I will implement the following "diagonal" and "vertical" recurrence relations:

http://dx.doi.org/10.1088/0953-4075/49/24/245001

Would this be a good fit for SphericalHarmonics.jl?

How to represent tangent bundle?

When we do vector-spherical harmonics we'll want

V = VectorSphericalHarmonics()
eltype(V)

to be a type representing the tangent bundle.

Data structure

I'm hoping there will be two equivalent forms of a function on the sphere expanded in spherical harmonics: store the coefficients as a Vector or a Matrix. They are related through a type of data transposition. One form is more convenient than the other for certain operations, but they should both be supported. @dlfivefifty

In ApproxFun, this would be like supporting Fun{SphericalHarmonics{Float64}, Matrix{Float64}} and Fun{SphericalHarmonics{Float64}, Vector{Float64}} and conversion routines. I don't know what the data type will be called in quasi-land...

Laplacian eltype should be scalar

Cannot square an infinite Diagonal?

julia> using HarmonicOrthogonalPolynomials

julia> S = SphericalHarmonic()
SphericalHarmonic{ComplexF64}

julia> ∂θ = AngularMomentum(axes(S, 1))
AngularMomentum{Float64, QuasiArrays.Inclusion{SphericalCoordinate{Float64}, DomainSets.FixedUnitSphere{StaticArrays.SVector{3, Float64}}}}

julia> A = S \ (∂θ * S)
ℵ₀×ℵ₀ LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}} with indices OneToInf()×OneToInf():
 0.0+0.0im      ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅      …  
     ⋅      0.0+0.0im       ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅      -0.0-1.0im      ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅      0.0+1.0im      ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅      0.0+0.0im       ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅      -0.0-1.0im      ⋅           ⋅          ⋅          ⋅      …  
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅      0.0+1.0im       ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅      -0.0-2.0im      ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅      0.0+2.0im      ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅      0.0+0.0im     
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅      …  
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅      …  
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅      …  
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
     ⋅          ⋅           ⋅          ⋅          ⋅           ⋅          ⋅           ⋅          ⋅          ⋅         
    ⋮                                                        ⋮                                                    ⋱  

julia> A2 = S \ (∂θ^2 * S)
ℵ₀×ℵ₀ LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}}} with indices OneToInf()×OneToInf():
 0.0+0.0im      ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅      0.0+0.0im       ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅      -1.0+0.0im       ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅      -1.0+0.0im      ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅      0.0+0.0im       ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅      -1.0+0.0im       ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅      -1.0+0.0im       ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅      -4.0+0.0im       ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅      -4.0+0.0im      ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅      0.0+0.0im     
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
    ⋮                                                         ⋮                                                      ⋱  

julia> A*A
ℵ₀×ℵ₀ LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}}} with indices OneToInf()×OneToInf():
 0.0+0.0im      ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅      0.0+0.0im       ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅      -1.0+0.0im       ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅      -1.0+0.0im      ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅      0.0+0.0im       ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅      -1.0+0.0im       ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅      -1.0+0.0im       ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅      -4.0+0.0im       ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅      -4.0+0.0im      ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅      0.0+0.0im     
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅      …  
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
     ⋅          ⋅           ⋅           ⋅          ⋅           ⋅           ⋅           ⋅           ⋅          ⋅         
    ⋮                                                         ⋮                                                      ⋱  

julia> A^2
ERROR: MethodError: Cannot `convert` an object of type LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}} to an object of type LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}}
Closest candidates are:
  convert(::Type{T}, ::Intervals.AnchoredInterval{P, T, L, R} where {L<:Intervals.Bounded, R<:Intervals.Bounded}) where {P, T} at /Users/mikael/.julia/packages/Intervals/ua9cq/src/anchoredinterval.jl:181
  convert(::Type{T}, ::Intervals.Interval{T, L, R} where {L<:Intervals.Bound, R<:Intervals.Bound}) where T at /Users/mikael/.julia/packages/Intervals/ua9cq/src/interval.jl:253
  convert(::Type{T}, ::QuasiArrays.QuasiIteratorsMD.QuasiCartesianIndex{1, II} where II<:Tuple) where T at /Users/mikael/.julia/packages/QuasiArrays/bxqu9/src/multidimensional.jl:131
  ...
Stacktrace:
 [1] LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}}}(diag::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}})
   @ LinearAlgebra /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/LinearAlgebra/src/diagonal.jl:10
 [2] convert(T::Type{LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}}}}, m::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}})
   @ LinearAlgebra /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/LinearAlgebra/src/special.jl:53
 [3] to_power_type(x::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}})
   @ Base ./intfuncs.jl:240
 [4] power_by_squaring(x_::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}, p::Int64)
   @ Base ./intfuncs.jl:255
 [5] ^(A::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}, p::Int64)
   @ LinearAlgebra /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/LinearAlgebra/src/dense.jl:442
 [6] macro expansion
   @ ./none:0 [inlined]
 [7] literal_pow(f::typeof(^), x::LinearAlgebra.Diagonal{ComplexF64, LazyArrays.BroadcastVector{ComplexF64, typeof(*), Tuple{Complex{Bool}, LazyArrays.BroadcastVector{Float64, Type{Float64}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(div), Tuple{LazyArrays.BroadcastVector{Int64, typeof(*), Tuple{LazyArrays.BroadcastVector{Int64, typeof(^), Tuple{Int64, LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Int64}}}}, BlockArrays.BlockVector{Int64, LazyArrays.BroadcastVector{Base.OneTo{Int64}, Type{Base.OneTo}, Tuple{InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, Int64}}}}}}}, #unused#::Val{2})
   @ Base ./none:0
 [8] top-level scope
   @ REPL[12]:1

julia>

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Let `sphericalharmonicy` call `FastTransforms.sphevaluatepi`?

I wonder how accurate and efficient the normalization is

HarmonicOrthogonalPolynomials.jl/src/HarmonicOrthogonalPolynomials.jl

Lines 175 to 178 in 4049e8f

 function sphericalharmonicy(ℓ, m, θ, φ) 

 m̃ = abs(m) 

 exp((lgamma(ℓ+m̃+1)+lgamma(ℓ-m̃+1)-2lgamma(ℓ+1))/2)*sqrt((2ℓ+1)/(4π)) * exp(im*m*φ) * sin(θ/2)^m̃ * cos(θ/2)^m̃ * jacobip(ℓ-m̃,m̃,m̃,cos(θ)) 

 end

compared to recurrence relations with normalization built-in

julia> θ, φ, ℓ, m = 0.1, 0.2, 2, 1
(0.1, 0.2, 2, 1)

julia> @time FastTransforms.sphevaluatepi(θ/π, ℓ, m)*exp(im*m*φ)/sqrt(2π)
  0.000011 seconds (7 allocations: 176 bytes)
0.07521112971423365 + 0.015246050775019672im

julia> θ, φ, ℓ, m = π/2, 0.2, 10_000, 5000
(1.5707963267948966, 0.2, 10000, 5000)

julia> @time FastTransforms.sphevaluatepi(θ/π, ℓ, m)*exp(im*m*φ)/sqrt(2π)
  0.000060 seconds (7 allocations: 176 bytes)
0.19235804128133974 + 0.2828286746396144im

Spherical coordinates

I would hope that we choose theta to be co-latitude (z = cos(theta)) and varphi to be longitude. Seems there is a different choice here?

https://github.com/JuliaApproximation/SphericalHarmonics.jl/blob/7028d27ba92bb289a7d8bd4f241ed4314eb8f2e9/src/SphericalHarmonics.jl#L30-L37

Controlling tolerance during function approximation

It will be nice to have a means to control the tolerance during function approximation. In other words, using the example code in README, I would like to have something like

julia> S = SphericalHarmonic();

julia> 𝐱 = axes(S,1);

julia> f = 𝐱 -> ((x,y,z) = 𝐱; exp(x)*cos(y*sin(z)));

julia> f̃ = S * ( \(S, f.(𝐱); tolerance=1e-6) ); # expansion of f in spherical harmonics with tolerance

where the last line specifies the tolerance during \, which is motivated by this section of the ApproxFun.jl documentation; see the last line of the section.

Not sure in which package this feature needs to be implemented: this package, ContinuumArrays.jl, or ClassicalOrthogonalPolynomials.jl? If basic directions are provided, I don't mind generating a PR myself, so please advise.

Rename package

Someone has already registered

https://github.com/jishnub/SphericalHarmonics.jl

Options:

SphericalHarmonicsQuasi.jl: though if we rename OrthogonalPolnomialsQuasi.jl to ClassicalOrthogonalPolynomials.jl this is not a good name.
HarmonicOrthogonalPolynomials.jl: would match ClassicalOrthogonalPolynomials.jl, etc. and emphasise that we are thinking of them as polynomials in cartesian coordinates
HarmonicPolynomials.jl: less verbose version of above though may make it sound algebraic
SphericalHarmonicExpansions.jl
Something else

Please vote if you care.

Cannot create the Laplacian like this

I assume I'm doing something wrong:

julia> S = SphericalHarmonic()
SphericalHarmonic{ComplexF64}

julia> Δ = Laplacian(axes(S, 1))
Laplacian{SphericalCoordinate{Float64}, DomainSets.FixedUnitSphere{SVector{3, Float64}}}

julia> L = S \ (Δ * S)
ERROR: ArgumentError: Cannot create infinite Array
Stacktrace:
  [1] Vector{Vector{ComplexF64}}(#unused#::UndefInitializer, #unused#::Tuple{Infinities.InfiniteCardinal{0}})
    @ InfiniteArrays ~/.julia/packages/InfiniteArrays/h9Ynf/src/infarrays.jl:19
  [2] _BlockArray(#unused#::Type{Vector{Vector{ComplexF64}}}, baxes::Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}})
    @ BlockArrays ~/.julia/packages/BlockArrays/qaMjJ/src/blockarray.jl:92
  [3] macro expansion
    @ ~/.julia/packages/BlockArrays/qaMjJ/src/blockarray.jl:126 [inlined]
  [4] initialized_blocks_BlockArray(#unused#::Type{Vector{Vector{ComplexF64}}}, baxes::Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}})
    @ BlockArrays ~/.julia/packages/BlockArrays/qaMjJ/src/blockarray.jl:124
  [5] BlockArray
    @ ~/.julia/packages/BlockArrays/qaMjJ/src/blockarray.jl:140 [inlined]
  [6] similar
    @ ~/.julia/packages/BlockArrays/qaMjJ/src/blockarray.jl:354 [inlined]
  [7] similar(a::BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, #unused#::Type{ComplexF64})
    @ BlockArrays ~/.julia/packages/BlockArrays/qaMjJ/src/abstractblockarray.jl:37
  [8] AbstractVector{ComplexF64}(A::BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}})
    @ Base ./array.jl:541
  [9] convert(#unused#::Type{AbstractVector{ComplexF64}}, a::BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}})
    @ Base ./abstractarray.jl:16
 [10] copy_oftype(A::BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, #unused#::Type{ComplexF64})
    @ LinearAlgebra /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/LinearAlgebra/src/LinearAlgebra.jl:350
 [11] copy(M::ArrayLayouts.Lmul{ArrayLayouts.DiagonalLayout{ArrayLayouts.OnesLayout}, ArrayLayouts.DiagonalLayout{BlockArrays.BlockLayout{LazyArrays.BroadcastLayout{Type{Fill}}, ArrayLayouts.FillLayout}}, Diagonal{ComplexF64, Ones{ComplexF64, 1, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/mTQvg/src/diagonal.jl:60
 [12] copy(M::ArrayLayouts.Mul{ArrayLayouts.DiagonalLayout{ArrayLayouts.OnesLayout}, ArrayLayouts.DiagonalLayout{BlockArrays.BlockLayout{LazyArrays.BroadcastLayout{Type{Fill}}, ArrayLayouts.FillLayout}}, Diagonal{ComplexF64, Ones{ComplexF64, 1, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/mTQvg/src/mul.jl:108
 [13] materialize(M::ArrayLayouts.Mul{ArrayLayouts.DiagonalLayout{ArrayLayouts.OnesLayout}, ArrayLayouts.DiagonalLayout{BlockArrays.BlockLayout{LazyArrays.BroadcastLayout{Type{Fill}}, ArrayLayouts.FillLayout}}, Diagonal{ComplexF64, Ones{ComplexF64, 1, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/mTQvg/src/mul.jl:105
 [14] mul
    @ ~/.julia/packages/ArrayLayouts/mTQvg/src/mul.jl:106 [inlined]
 [15] copy(M::LazyArrays.Applied{LazyArrays.MulStyle, typeof(*), Tuple{Diagonal{ComplexF64, Ones{ComplexF64, 1, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}})
    @ LazyArrays ~/.julia/packages/LazyArrays/MMaBf/src/linalg/mul.jl:13
 [16] materialize
    @ ~/.julia/packages/LazyArrays/MMaBf/src/lazyapplying.jl:81 [inlined]
 [17] apply
    @ ~/.julia/packages/LazyArrays/MMaBf/src/lazyapplying.jl:78 [inlined]
 [18] _copy_ldiv_mul
    @ ~/.julia/packages/LazyArrays/MMaBf/src/linalg/inv.jl:98 [inlined]
 [19] copy
    @ ~/.julia/packages/LazyArrays/MMaBf/src/linalg/inv.jl:100 [inlined]
 [20] copy(L::ArrayLayouts.Ldiv{ContinuumArrays.BasisLayout, LazyArrays.ApplyLayout{typeof(*)}, SphericalHarmonic{ComplexF64}, ApplyQuasiMatrix{ComplexF64, typeof(*), Tuple{SphericalHarmonic{ComplexF64}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}}})
    @ ContinuumArrays ~/.julia/packages/ContinuumArrays/tg4mj/src/bases/bases.jl:201
 [21] materialize
    @ ~/.julia/packages/ArrayLayouts/mTQvg/src/ldiv.jl:22 [inlined]
 [22] ldiv
    @ ~/.julia/packages/ArrayLayouts/mTQvg/src/ldiv.jl:86 [inlined]
 [23] \(A::SphericalHarmonic{ComplexF64}, B::ApplyQuasiMatrix{ComplexF64, typeof(*), Tuple{SphericalHarmonic{ComplexF64}, Diagonal{Int64, BlockVector{Int64, LazyArrays.BroadcastVector{Fill{Int64, 1, Tuple{Base.OneTo{Int64}}}, Type{Fill}, Tuple{LazyArrays.BroadcastVector{Int64, typeof(-), Tuple{InfiniteArrays.InfStepRange{Int64, Int64}, LazyArrays.BroadcastVector{Int64, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, InfiniteArrays.InfUnitRange{Int64}, Base.RefValue{Val{2}}}}}}, InfiniteArrays.InfStepRange{Int64, Int64}}}, Tuple{BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}})
    @ QuasiArrays ~/.julia/packages/QuasiArrays/bxqu9/src/matmul.jl:34
 [24] top-level scope
    @ REPL[45]:1

julia>

Finish RealSphericalHarmonic

@TSGut this would be a good issue to get the hang of things. #6 is a good starting point

Are SphericalHarmonic() expansions broken?

E.g. for the example in the README I'm getting

julia> S = SphericalHarmonic()
SphericalHarmonic{ComplexF64}

julia> 𝐱 = axes(S,1)
Inclusion(the 3-dimensional unit sphere)

julia> f = 𝐱 -> ((x,y,z) = 𝐱; exp(x)*cos(y*sin(z)))
#7 (generic function with 1 method)

julia> S \ f.(𝐱)
ERROR: LoadError: MethodError: no method matching InfiniteArrays.Infinity(::Int64)
Closest candidates are:
  (::Type{T})(::T) where T<:Number at boot.jl:760
  InfiniteArrays.Infinity() at /home/timon/.julia/packages/InfiniteArrays/ptnOj/src/Infinity.jl:15
  (::Type{T})(::AbstractChar) where T<:Union{AbstractChar, Number} at char.jl:50
  ...
Stacktrace:
  [1] convert(#unused#::Type{InfiniteArrays.Infinity}, x::Int64)
    @ Base ./number.jl:7
  [2] zero(#unused#::Type{InfiniteArrays.Infinity})
    @ Base ./number.jl:261
  [3] Base.OneTo{InfiniteArrays.Infinity}(stop::InfiniteArrays.Infinity)
    @ Base ./range.jl:326
  [4] Base.OneTo(stop::InfiniteArrays.Infinity)
    @ Base ./range.jl:335
  [5] axes(#unused#::ClassicalOrthogonalPolynomials.Jacobi{Float64})
    @ ClassicalOrthogonalPolynomials ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/jacobi.jl:144
  [6] indextype(A::ClassicalOrthogonalPolynomials.Jacobi{Float64})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/mul.jl:64
  [7] unsafe_view(::ClassicalOrthogonalPolynomials.Jacobi{Float64}, ::Float64, ::Base.OneTo{Int64})
    @ QuasiArrays ~/.julia/packages/QuasiArrays/vCP8C/src/subquasiarray.jl:115
  [8] unsafe_getindex
    @ ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/clenshaw.jl:26 [inlined]
  [9] unsafe_getindex(P::ClassicalOrthogonalPolynomials.Jacobi{Float64}, x::Float64, n::Int64)
    @ ClassicalOrthogonalPolynomials ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/clenshaw.jl:80
 [10] jacobip(n::Int64, a::Int64, b::Int64, z::Float64)
    @ ClassicalOrthogonalPolynomials ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/jacobi.jl:133
 [11] sphericalharmonicy(ℓ::Int64, m::Int64, θ::Float64, φ::Float64)
    @ HarmonicOrthogonalPolynomials ~/.julia/packages/HarmonicOrthogonalPolynomials/2vPE2/src/HarmonicOrthogonalPolynomials.jl:177
 [12] getindex(S::SphericalHarmonic{ComplexF64}, x::SphericalCoordinate{Float64}, K::BlockArrays.BlockIndex{1})
    @ HarmonicOrthogonalPolynomials ~/.julia/packages/HarmonicOrthogonalPolynomials/2vPE2/src/HarmonicOrthogonalPolynomials.jl:184
 [13] getindex(S::SphericalHarmonic{ComplexF64}, x::SphericalCoordinate{Float64}, k::Int64)
    @ HarmonicOrthogonalPolynomials ~/.julia/packages/HarmonicOrthogonalPolynomials/2vPE2/src/HarmonicOrthogonalPolynomials.jl:216
 [14] getindex
    @ ~/.julia/packages/QuasiArrays/vCP8C/src/subquasiarray.jl:219 [inlined]
 [15] _default_blasmul!(#unused#::IndexCartesian, α::ComplexF64, A::SubArray{ComplexF64, 2, SphericalHarmonic{ComplexF64}, Tuple{Vector{SphericalCoordinate{Float64}}, UnitRange{Int64}}, false}, B::SubArray{ComplexF64, 1, BlockArrays.PseudoBlockVector{ComplexF64, LazyArrays.ApplyArray{ComplexF64, 1, typeof(vcat), Tuple{Vector{ComplexF64}, FillArrays.Zeros{ComplexF64, 1, Tuple{InfiniteArrays.OneToInf{Int64}}}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Tuple{UnitRange{Int64}}, false}, β::Bool, C::Vector{ComplexF64})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:210
 [16] default_blasmul!
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:222 [inlined]
 [17] materialize!(M::ArrayLayouts.MulAdd{ArrayLayouts.UnknownLayout, LazyArrays.PaddedLayout{ArrayLayouts.DenseColumnMajor}, ArrayLayouts.DenseColumnMajor, ComplexF64, SubArray{ComplexF64, 2, SphericalHarmonic{ComplexF64}, Tuple{Vector{SphericalCoordinate{Float64}}, UnitRange{Int64}}, false}, SubArray{ComplexF64, 1, BlockArrays.PseudoBlockVector{ComplexF64, LazyArrays.ApplyArray{ComplexF64, 1, typeof(vcat), Tuple{Vector{ComplexF64}, FillArrays.Zeros{ComplexF64, 1, Tuple{InfiniteArrays.OneToInf{Int64}}}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Tuple{UnitRange{Int64}}, false}, Vector{ComplexF64}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:252
 [18] muladd!
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:68 [inlined]
 [19] copyto!
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:75 [inlined]
 [20] copy(M::ArrayLayouts.MulAdd{ArrayLayouts.UnknownLayout, LazyArrays.PaddedLayout{ArrayLayouts.DenseColumnMajor}, ArrayLayouts.ZerosLayout, ComplexF64, SubArray{ComplexF64, 2, SphericalHarmonic{ComplexF64}, Tuple{Vector{SphericalCoordinate{Float64}}, UnitRange{Int64}}, false}, SubArray{ComplexF64, 1, BlockArrays.PseudoBlockVector{ComplexF64, LazyArrays.ApplyArray{ComplexF64, 1, typeof(vcat), Tuple{Vector{ComplexF64}, FillArrays.Zeros{ComplexF64, 1, Tuple{InfiniteArrays.OneToInf{Int64}}}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Tuple{UnitRange{Int64}}, false}, FillArrays.Zeros{ComplexF64, 1, Tuple{Base.OneTo{Int64}}}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/muladd.jl:70
 [21] copy
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/mul.jl:108 [inlined]
 [22] materialize(M::ArrayLayouts.Mul{ArrayLayouts.UnknownLayout, LazyArrays.PaddedLayout{ArrayLayouts.DenseColumnMajor}, SubArray{ComplexF64, 2, SphericalHarmonic{ComplexF64}, Tuple{Vector{SphericalCoordinate{Float64}}, UnitRange{Int64}}, false}, SubArray{ComplexF64, 1, BlockArrays.PseudoBlockVector{ComplexF64, LazyArrays.ApplyArray{ComplexF64, 1, typeof(vcat), Tuple{Vector{ComplexF64}, FillArrays.Zeros{ComplexF64, 1, Tuple{InfiniteArrays.OneToInf{Int64}}}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}, Tuple{UnitRange{Int64}}, false}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/mul.jl:105
 [23] mul
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/mul.jl:106 [inlined]
 [24] copy
    @ ~/.julia/packages/LazyArrays/6zNYO/src/linalg/mul.jl:13 [inlined]
 [25] materialize
    @ ~/.julia/packages/LazyArrays/6zNYO/src/lazyapplying.jl:81 [inlined]
 [26] apply
    @ ~/.julia/packages/LazyArrays/6zNYO/src/lazyapplying.jl:78 [inlined]
 [27] sub_materialize
    @ ~/.julia/packages/LazyArrays/6zNYO/src/linalg/mul.jl:204 [inlined]
 [28] sub_materialize
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/ArrayLayouts.jl:107 [inlined]
 [29] layout_getindex
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/ArrayLayouts.jl:110 [inlined]
 [30] _getindex(#unused#::Type, #unused#::IndexCartesian, A::QuasiArrays.ApplyQuasiVector{ComplexF64, typeof(*), Tuple{SphericalHarmonic{ComplexF64}, BlockArrays.PseudoBlockVector{ComplexF64, LazyArrays.ApplyArray{ComplexF64, 1, typeof(vcat), Tuple{Vector{ComplexF64}, FillArrays.Zeros{ComplexF64, 1, Tuple{InfiniteArrays.OneToInf{Int64}}}}}, Tuple{BlockArrays.BlockedUnitRange{ArrayLayouts.RangeCumsum{Int64, InfiniteArrays.InfStepRange{Int64, Int64}}}}}}}, I::Tuple{Vector{SphericalCoordinate{Float64}}})
    @ QuasiArrays ~/.julia/packages/QuasiArrays/vCP8C/src/abstractquasiarray.jl:386
 [31] _getindex
    @ ~/.julia/packages/QuasiArrays/vCP8C/src/abstractquasiarray.jl:377 [inlined]
 [32] getindex
    @ ~/.julia/packages/QuasiArrays/vCP8C/src/abstractquasiarray.jl:372 [inlined]
 [33] adaptivetransform_ldiv(A::SphericalHarmonic{ComplexF64}, f::QuasiArrays.BroadcastQuasiVector{Float64, var"#7#8", Tuple{QuasiArrays.Inclusion{SphericalCoordinate{Float64}, DomainSets.FixedUnitSphere{StaticArrays.SVector{3, Float64}}}}})
    @ ClassicalOrthogonalPolynomials ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/ClassicalOrthogonalPolynomials.jl:88
 [34] transform_ldiv
    @ ~/.julia/packages/ClassicalOrthogonalPolynomials/rHxj7/src/ClassicalOrthogonalPolynomials.jl:50 [inlined]
 [35] transform_ldiv
    @ ~/.julia/packages/ContinuumArrays/OKuUi/src/bases/bases.jl:176 [inlined]
 [36] copy
    @ ~/.julia/packages/ContinuumArrays/OKuUi/src/bases/bases.jl:178 [inlined]
 [37] materialize(M::ArrayLayouts.Ldiv{ContinuumArrays.BasisLayout, LazyArrays.BroadcastLayout{var"#7#8"}, SphericalHarmonic{ComplexF64}, QuasiArrays.BroadcastQuasiVector{Float64, var"#7#8", Tuple{QuasiArrays.Inclusion{SphericalCoordinate{Float64}, DomainSets.FixedUnitSphere{StaticArrays.SVector{3, Float64}}}}}})
    @ ArrayLayouts ~/.julia/packages/ArrayLayouts/ATRic/src/ldiv.jl:22
 [38] ldiv
    @ ~/.julia/packages/ArrayLayouts/ATRic/src/ldiv.jl:86 [inlined]
 [39] \(A::SphericalHarmonic{ComplexF64}, B::QuasiArrays.BroadcastQuasiVector{Float64, var"#7#8", Tuple{QuasiArrays.Inclusion{SphericalCoordinate{Float64}, DomainSets.FixedUnitSphere{StaticArrays.SVector{3, Float64}}}}})
    @ QuasiArrays ~/.julia/packages/QuasiArrays/vCP8C/src/matmul.jl:34
 [40] top-level scope

	function sphericalharmonicy(ℓ, m, θ, φ)
	m̃ = abs(m)
	exp((lgamma(ℓ+m̃+1)+lgamma(ℓ-m̃+1)-2lgamma(ℓ+1))/2)sqrt((2ℓ+1)/(4π)) exp(immφ) * sin(θ/2)^m̃ * cos(θ/2)^m̃ * jacobip(ℓ-m̃,m̃,m̃,cos(θ))
	end

juliaapproximation / harmonicorthogonalpolynomials.jl Goto Github PK