update doscstrings to v1.6 format (#8)

* update doscstrings to v1.6 format

* update Documenter to v0.27

Author: jishnub

.github/workflows/ci.yml

@@ -59,7 +59,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1
         with:
-          version: '1'
+          version: '1.6'
       - run: |
           julia --project=docs -e '
             using Pkg

docs/Project.toml

@@ -4,5 +4,5 @@ HyperDualNumbers = "50ceba7f-c3ee-5a84-a6e8-3ad40456ec97"
 LegendrePolynomials = "3db4a2ba-fc88-11e8-3e01-49c72059a882"
 
 [compat]
-Documenter = "0.26"
+Documenter = "0.27"
 HyperDualNumbers = "4"

docs/src/derivatives.md

@@ -2,24 +2,24 @@
 
 ## Analytical recursive approach
 
-The Bonnet's recursion formula 
+The Bonnet's recursion formula
 
 ```math
 P_\ell(x) = \left((2\ell-1) x P_{\ell-1}(x) - (\ell-1)P_{\ell - 2}(x)\right)/\ell
 ```
 
-may be differentiated an arbitrary number of times analytically to obtain recursion relations for higher derivatives: 
+may be differentiated an arbitrary number of times analytically to obtain recursion relations for higher derivatives:
 
 ```math
-\frac{d^n P_\ell(x)}{dx^n} = \frac{(2\ell-1)}{\ell} \left(x \frac{d^n P_{\ell-1}(x)}{dx^n} + 
+\frac{d^n P_\ell(x)}{dx^n} = \frac{(2\ell-1)}{\ell} \left(x \frac{d^n P_{\ell-1}(x)}{dx^n} +
 n \frac{d^{(n-1)} P_{\ell-1}(x)}{dx^{(n-1)}} \right) - \frac{(\ell-1)}{\ell} \frac{d^n P_{\ell-2}(x)}{dx^n}
 ```
 
 This provides a simultaneous recursion relation in ``\ell`` as well as ``n``, solving which we may obtain derivatives up to any order. This is the approach used in this package to compute the derivatives of Legendre polynomials.
 
 ## Automatic diferentiation
 
-The Julia automatic differentiation framework may be used to compute the derivatives of Legendre polynomials alongside their values. Since the defintions of the polynomials are completely general, they may be called with dual or hyperdual numbers as arguments to evaluate derivarives in one go. 
+The Julia automatic differentiation framework may be used to compute the derivatives of Legendre polynomials alongside their values. Since the defintions of the polynomials are completely general, they may be called with dual or hyperdual numbers as arguments to evaluate derivarives in one go.
 We demonstrate one example of this using the package [`HyperDualNumbers.jl`](https://github.com/JuliaDiff/HyperDualNumbers.jl) v4:
 
 ```@meta
@@ -43,21 +43,21 @@ julia> p = Pl(xh, 3)
 -0.4375 + 0.375ε₁ + 0.375ε₂ + 7.5ε₁ε₂
 ```
 
-The Legendre polynomial ``P_\ell(x)`` may be obtained using 
+The Legendre polynomial ``P_\ell(x)`` may be obtained using
 
 ```jldoctest hyperdual
 julia> realpart(p)
 -0.4375
 ```
 
-The first derivative ``dP_\ell(x)/dx`` may be obtained as 
+The first derivative ``dP_\ell(x)/dx`` may be obtained as
 
 ```jldoctest hyperdual
 julia> ε₁part(p)
 0.375
 ```
 
-The second derivative ``d^2P_\ell(x)/dx^2`` may be obtained using 
+The second derivative ``d^2P_\ell(x)/dx^2`` may be obtained using
 
 ```jldoctest hyperdual
 julia> ε₁ε₂part(p)
@@ -68,7 +68,7 @@ Something similar may also be evaluated for all `l` iteratively. For example, th
 
 ```jldoctest hyperdual
 julia> collectPl(xh, lmax=4)
-5-element OffsetArray(::Array{Hyper{Float64},1}, 0:4) with eltype Hyper{Float64} with indices 0:4:
+5-element OffsetArray(::Vector{Hyper{Float64}}, 0:4) with eltype Hyper{Float64} with indices 0:4:
                 1.0 + 0.0ε₁ + 0.0ε₂ + 0.0ε₁ε₂
                 0.5 + 1.0ε₁ + 1.0ε₂ + 0.0ε₁ε₂
              -0.125 + 1.5ε₁ + 1.5ε₂ + 3.0ε₁ε₂
@@ -80,15 +80,15 @@ We may extract the first derivatives by broadcasting the function `ε₁part` on
 
 ```jldoctest hyperdual
 julia> ε₁part.(collectPl(xh, lmax=4))
-5-element OffsetArray(::Array{Float64,1}, 0:4) with eltype Float64 with indices 0:4:
+5-element OffsetArray(::Vector{Float64}, 0:4) with eltype Float64 with indices 0:4:
   0.0
   1.0
   1.5
   0.375
  -1.5625
 ```
 
-Similarly the function `ε₁ε₂part` may be used to obtain the second derivatives. 
+Similarly the function `ε₁ε₂part` may be used to obtain the second derivatives.
 
 Several convenience functions to compute the derivatives of Legendre polynomials were available in `LegendrePolynomials` v0.2, but have been removed in v0.3. The users are encouraged to implement convenience functions to extract the derivatives as necessary. As an exmaple, we may compute the polynomials and their first and second derivatives together as
 
@@ -104,4 +104,4 @@ Pl_dPl_d2Pl (generic function with 1 method)
 
 julia> Pl_dPl_d2Pl(0.5, lmax = 3)
 ([1.0, 0.5, -0.125, -0.4375], [0.0, 1.0, 1.5, 0.375], [0.0, 0.0, 3.0, 7.5])
-```
+```

docs/src/index.md

@@ -13,13 +13,13 @@ Compute [Legendre polynomials](https://en.wikipedia.org/wiki/Legendre_polynomial
 P_\ell(x) = \left((2\ell-1) x P_{\ell-1}(x) - (\ell-1)P_{\ell - 2}(x)\right)/\ell
 ```
 
-Currently this package evaluates the standard polynomials that satisfy ``P_\ell(1) = 1`` and ``P_0(x) = 1``. These are normalized as 
+Currently this package evaluates the standard polynomials that satisfy ``P_\ell(1) = 1`` and ``P_0(x) = 1``. These are normalized as
 
 ```math
 \int_{-1}^1 P_m(x) P_n(x) dx = \frac{2}{2n+1} \delta_{mn}.
 ```
 
-There are four main functions: 
+There are four main functions:
 
 * [`Pl(x,l)`](@ref Pl): this evaluates the Legendre polynomial for a given degree `l` at the argument `x`. The argument needs to satisfy `-1 <= x <= 1`.
 * [`collectPl(x; lmax)`](@ref collectPl): this evaluates all the polynomials for `l` lying in `0:lmax` at the argument `x`. As before the argument needs to lie in the domain of validity. Functionally this is equivalent to `Pl.(x, 0:lmax)`, except `collectPl` evaluates the result in one pass, and is therefore faster. There is also the in-place version [`collectPl!`](@ref) that uses a pre-allocated array.
@@ -46,7 +46,7 @@ Evaluate all the polynomials for `l` in `0:lmax` as `collectPl(x; lmax)`
 
 ```jldoctest
 julia> collectPl(0.5, lmax = 3)
-4-element OffsetArray(::Array{Float64,1}, 0:3) with eltype Float64 with indices 0:3:
+4-element OffsetArray(::Vector{Float64}, 0:3) with eltype Float64 with indices 0:3:
   1.0
   0.5
  -0.125
@@ -57,7 +57,7 @@ Evaluate all the `n`th derivatives as `collectdnPl(x; lmax, n)`:
 
 ```jldoctest
 julia> collectdnPl(0.5, lmax = 5, n = 3)
-6-element OffsetArray(::Array{Float64,1}, 0:5) with eltype Float64 with indices 0:5:
+6-element OffsetArray(::Vector{Float64}, 0:5) with eltype Float64 with indices 0:5:
   0.0
   0.0
   0.0
@@ -82,10 +82,10 @@ julia> Pl(big(1)/3, 5)
 0.3333333333333333333333333333333333333333333333333333333333333333333333333333305
 ```
 
-The precision of the latter may be altered using `setprecision`, as 
+The precision of the latter may be altered using `setprecision`, as
 
 ```jldoctest
-julia> setprecision(300) do 
+julia> setprecision(300) do
        Pl(big(1)/3, 5)
        end
 0.33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333317

src/LegendrePolynomials.jl

@@ -59,7 +59,7 @@ julia> import LegendrePolynomials: LegendrePolynomialIterator
 julia> iter = LegendrePolynomialIterator(0.5, 4);
 
 julia> collect(iter)
-5-element OffsetArray(::Array{Float64,1}, 0:4) with eltype Float64 with indices 0:4:
+5-element OffsetArray(::Vector{Float64}, 0:4) with eltype Float64 with indices 0:4:
   1.0
   0.5
  -0.125
@@ -69,15 +69,15 @@ julia> collect(iter)
 julia> iter = LegendrePolynomialIterator(0.5);
 
 julia> collect(Iterators.take(iter, 5)) # evaluete 5 elements (l = 0:4)
-5-element Array{Float64,1}:
+5-element Vector{Float64}:
   1.0
   0.5
  -0.125
  -0.4375
  -0.2890625
 
 julia> collect(Iterators.take(Iterators.drop(iter, 100), 5)) # evaluate Pl for l = 100:104
-5-element Array{Float64,1}:
+5-element Vector{Float64}:
  -0.0605180259618612
   0.02196749072249231
   0.08178451892628381
@@ -90,7 +90,7 @@ struct LegendrePolynomialIterator{T, L <: Union{Integer, Nothing}, V}
 	lmax :: L
 	function LegendrePolynomialIterator{T,L,V}(x::V, lmax::L) where {T, L <: Union{Integer, Nothing}, V}
 		checkdomain(x)
-		new{T,L,V}(x, lmax)		
+		new{T,L,V}(x, lmax)
 	end
 end
 LegendrePolynomialIterator(x) = LegendrePolynomialIterator{polytype(x), Nothing, typeof(x)}(x, nothing)
@@ -202,10 +202,10 @@ end
 	dnPl(x, l::Integer, n::Integer, [cache::AbstractVector])
 
 Compute the ``n``-th derivative ``d^n P_\\ell(x)/dx^n`` of the Legendre polynomial ``P_\\ell(x)``.
-Optionally a pre-allocated vector `cache` may be provided, which must have a minimum length of `l - n + 1` 
+Optionally a pre-allocated vector `cache` may be provided, which must have a minimum length of `l - n + 1`
 and may be overwritten during the computation.
 
-The order of the derivative `n` must be non-negative. For `n == 0` this function just returns 
+The order of the derivative `n` must be non-negative. For `n == 0` this function just returns
 Legendre polynomials.
 
 # Examples
@@ -218,7 +218,7 @@ julia> dnPl(0.5, 4, 0) == Pl(0.5, 4) # zero-th order derivative == Pl(x)
 true
 ```
 """
-Base.@propagate_inbounds function dnPl(x, l::Integer, n::Integer, 
+Base.@propagate_inbounds function dnPl(x, l::Integer, n::Integer,
 	A = begin
 		_checkvalues(x, l, n)
 		# do not allocate A if the value is trivially zero
@@ -245,7 +245,7 @@ end
 """
 	collectPl!(v::AbstractVector, x; [lmax::Integer = length(v) - 1])
 
-Compute the Legendre Polynomials ``P_\\ell(x)`` for the argument `x` and all degrees `l` in `0:lmax`, 
+Compute the Legendre Polynomials ``P_\\ell(x)`` for the argument `x` and all degrees `l` in `0:lmax`,
 and store them in `v`.
 
 At output `v[firstindex(v) + l] == Pl(x,l)`.
@@ -255,7 +255,7 @@ At output `v[firstindex(v) + l] == Pl(x,l)`.
 julia> v = zeros(4);
 
 julia> collectPl!(v, 0.5)
-4-element Array{Float64,1}:
+4-element Vector{Float64}:
   1.0
   0.5
  -0.125
@@ -264,7 +264,7 @@ julia> collectPl!(v, 0.5)
 julia> v = zeros(0:4);
 
 julia> collectPl!(v, 0.5, lmax = 3) # only l from 0 to 3 are populated
-5-element OffsetArray(::Array{Float64,1}, 0:4) with eltype Float64 with indices 0:4:
+5-element OffsetArray(::Vector{Float64}, 0:4) with eltype Float64 with indices 0:4:
   1.0
   0.5
  -0.125
@@ -276,7 +276,7 @@ function collectPl!(v::AbstractVector, x; lmax::Integer  = length(v) - 1)
 	checklength(v, lmax + 1)
 
 	iter = LegendrePolynomialIterator(x, lmax)
-	
+
 	for (l, Pl) in pairs(iter)
 		v[l + firstindex(v)] = Pl
 	end
@@ -293,7 +293,7 @@ Return `P` with indices `0:lmax`, where `P[l] == Pl(x,l)`
 # Examples
 ```jldoctest
 julia> collectPl(0.5, lmax = 4)
-5-element OffsetArray(::Array{Float64,1}, 0:4) with eltype Float64 with indices 0:4:
+5-element OffsetArray(::Vector{Float64}, 0:4) with eltype Float64 with indices 0:4:
   1.0
   0.5
  -0.125
@@ -306,7 +306,7 @@ collectPl(x; lmax::Integer) = collect(LegendrePolynomialIterator(x, lmax))
 """
 	collectdnPl(x; n::Integer, lmax::Integer)
 
-Compute the ``n``-th derivative of a Legendre Polynomial ``P_\\ell(x)`` for the argument `x` and all degrees `l = 0:lmax`. 
+Compute the ``n``-th derivative of a Legendre Polynomial ``P_\\ell(x)`` for the argument `x` and all degrees `l = 0:lmax`.
 
 The order of the derivative `n` must be greater than or equal to zero.
 
@@ -316,7 +316,7 @@ Returns `v` with indices `0:lmax`, where `v[l] == dnPl(x, l, n)`.
 
 ```jldoctest
 julia> collectdnPl(0.5, lmax = 3, n = 2)
-4-element OffsetArray(::Array{Float64,1}, 0:3) with eltype Float64 with indices 0:3:
+4-element OffsetArray(::Vector{Float64}, 0:3) with eltype Float64 with indices 0:3:
  0.0
  0.0
  3.0
@@ -336,8 +336,8 @@ end
 """
 	collectdnPl!(v::AbstractVector, x; lmax::Integer, n::Integer)
 
-Compute the ``n``-th derivative of a Legendre Polynomial ``P_\\ell(x)`` for the argument `x` and all degrees `l = 0:lmax`, 
-and store the result in `v`. 
+Compute the ``n``-th derivative of a Legendre Polynomial ``P_\\ell(x)`` for the argument `x` and all degrees `l = 0:lmax`,
+and store the result in `v`.
 
 The order of the derivative `n` must be greater than or equal to zero.
 
@@ -349,7 +349,7 @@ At output, `v[l + firstindex(v)] == dnPl(x, l, n)` for `l = 0:lmax`.
 julia> v = zeros(4);
 
 julia> collectdnPl!(v, 0.5, lmax = 3, n = 2)
-4-element Array{Float64,1}:
+4-element Vector{Float64}:
  0.0
  0.0
  3.0
@@ -360,13 +360,13 @@ function collectdnPl!(v, x; lmax::Integer, n::Integer)
 	assertnonnegative(lmax)
 	n >= 0 || throw(ArgumentError("order of derivative n must be >= 0"))
 	checklength(v, lmax + 1)
-	
+
 	# trivially zero for l < n
 	fill!((@view v[(0:n-1) .+ firstindex(v)]), zero(eltype(v)))
 	# populate the other elements
 	@inbounds dnPl(x, lmax, n, @view v[(n:lmax) .+ firstindex(v)])
-	
+
 	v
 end
 
-end
+end