eschnett/SHTOOLS.jl - Change 7VIMUPV7XRRR3NTHQBBAFKUGI3Y23PSCOEY4CXQ3DVFKC2ACHN5AC

Add mutating variants of Legendre functions

Created by Erik Schnetter on February 17, 2021

7VIMUPV7XRRR3NTHQBBAFKUGI3Y23PSCOEY4CXQ3DVFKC2ACHN5AC

Dependencies

In channels

main

Change contents

Insertion in README.md at line 13 [4.3301]
[3.35]
[3.35]
```
Legendre Functions
```

Replacement in src/SHTOOLS.jl at line 6 [4.421]

B:BD[4.491] → [4.491:680]

cmaybe(::Type{T}, x::Maybe) where {T} = x === nothing ? Ptr{T}() : Ref{T}(x)
function cmayberef(::Type{T}, x::Maybe{Ref{T}}) where {T}
    return x === nothing ? Ptr{T}() : (x::Ref{T})
end

[4.491]

[4.680]

# For optional arguments
cmaybe(::Type{T}, x::Maybe{T}) where {T} = x === nothing ? Ptr{T}() : Ref{T}(x)

Insertion in src/SHTOOLS.jl at line 12 [4.421]
[4.817]
[4.817]
```
    op! = Symbol(op, "!")
```
Insertion in src/SHTOOLS.jl at line 14 [4.421]
[4.847]
[4.847]
```
    op_d1! = Symbol(op, "_d1!")
```

Replacement in src/SHTOOLS.jl at line 17 [4.421]

B:BD[4.873] → [4.873:1170]

        export $op
        function $op(lmax::Union{Cint,Int}, z::Union{Cdouble,Float64,Int};
                     csphase::Maybe{Int}=nothing, cnorm::Maybe{Int}=nothing,
                     exitstatus::Maybe{Ref{Int}}=nothing)
            p = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)

[4.873]

[4.1170]

        export $op!
        function $op!(p::AbstractVector{Cdouble}, lmax::Integer,
                      z::Union{AbstractFloat,Integer};
                      csphase::Maybe{Integer}=nothing,
                      cnorm::Maybe{Integer}=nothing,
                      exitstatus::Maybe{Ref{<:Integer}}=nothing)
            @assert length(p) ≥ (lmax + 1) * (lmax + 2) ÷ 2
            exitstatus′ = 0

Replacement in src/SHTOOLS.jl at line 28 [4.421]

B:BD[4.1363] → [4.1363:1431]

                  cmaybe(Cint, cnorm), cmayberef(Cint, exitstatus))

[4.1363]

[4.1431]

                  cmaybe(Cint, cnorm), exitstatus′)
            if exitstatus === nothing
                exitstatus′ ≠ 0 && error("$($op!): Error code $exitstatus′")
            else
                exitstatus[] = exitstatus′
            end

Replacement in src/SHTOOLS.jl at line 37 [4.421]

B:BD[4.1474] → [4.1474:1715]

        export $op_d1
        function $op_d1(lmax::Union{Cint,Int}, z::Union{Cdouble,Float64,Int};
                        csphase::Maybe{Int}=nothing, cnorm::Maybe{Int}=nothing,
                        exitstatus::Maybe{Ref{Int}}=nothing)

[4.1474]

[4.1715]

        export $op
        function $op(lmax::Integer, z::Union{AbstractFloat,Integer};
                     csphase::Maybe{Integer}=nothing,
                     cnorm::Maybe{Integer}=nothing,
                     exitstatus::Maybe{Ref{<:Integer}}=nothing)

Replacement in src/SHTOOLS.jl at line 43 [4.421]

B:BD[4.1783] → [4.1783:1852]

            dp = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)

[4.1783]

[4.1852]

            $op!(p, lmax, z; csphase=csphase, cnorm=cnorm,
                 exitstatus=exitstatus)
            return p
        end
        #
        export $op_d1!
        function $op_d1!(p::AbstractVector{Cdouble},
                         dp::AbstractVector{Cdouble}, lmax::Integer,
                         z::Union{AbstractVector,Integer};
                         csphase::Maybe{Integer}=nothing,
                         cnorm::Maybe{Integer}=nothing,
                         exitstatus::Maybe{Ref{<:Integer}}=nothing)
            @assert length(p) ≥ lmax + 1
            @assert length(dp) ≥ lmax + 1
            exitstatus′ = 0

Replacement in src/SHTOOLS.jl at line 61 [4.421]

B:BD[4.2066] → [4.2066:2134]

                  cmaybe(Cint, cnorm), cmayberef(Cint, exitstatus))

[4.2066]

[4.2134]

                  cmaybe(Cint, cnorm), exitstatus′)
            if exitstatus === nothing
                exitstatus′ ≠ 0 && error("$($op_d1!): Error code $exitstatus′")
            else
                exitstatus[] = exitstatus′
            end
            return p, dp
        end
        #
        export $op_d1
        function $op_d1(lmax::Integer, z::Union{AbstractFloat,Integer};
                        csphase::Maybe{Integer}=nothing,
                        cnorm::Maybe{Integer}=nothing,
                        exitstatus::Maybe{Ref{<:Integer}}=nothing)
            p = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)
            dp = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)
            $op_d1!(p, dp, lmax, z; csphase=csphase, cnorm=cnorm,
                    exitstatus=exitstatus)

Insertion in src/SHTOOLS.jl at line 86 [4.421]
[4.2244]
[4.2244]
```
    op! = Symbol(op, "!")
```
Insertion in src/SHTOOLS.jl at line 88 [4.421]
[4.2274]
[4.2274]
```
    op_d1! = Symbol(op, "_d1!")
```

Replacement in src/SHTOOLS.jl at line 91 [4.421]

B:BD[4.2300] → [4.2300:2319]

B:BD[4.2319] → [2.0:75]

∅:D[2.75] → [4.2393:2451]

B:BD[4.2393] → [4.2393:2451]

B:BD[4.2451] → [2.76:144]

        export $op
        function $op(lmax::Union{Cint,Int}, z::Union{Cdouble,Float64,Int};
                     exitstatus::Maybe{Ref{Int}}=nothing)
            p = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)

[4.2300]

[4.2517]

        export $op!
        function $op!(p::AbstractVector{Cdouble}, lmax::Integer,
                      z::Union{AbstractFloat,Integer};
                      exitstatus::Maybe{Ref{<:Integer}}=nothing)
            @assert length(p) ≥ lmax + 1
            exitstatus′ = 0

Replacement in src/SHTOOLS.jl at line 99 [4.421]

∅:D[2.217] → [4.2645:2692]

B:BD[4.2645] → [4.2645:2692]

                  cmayberef(Cint, exitstatus))

[2.217]

[4.2692]

                  exitstatus′)
            if exitstatus === nothing
                exitstatus′ ≠ 0 && error("$($op!): Error code $exitstatus′")
            else
                exitstatus[] = exitstatus′
            end

Replacement in src/SHTOOLS.jl at line 108 [4.421]

B:BD[4.2735] → [4.2735:2757]

B:BD[4.2757] → [2.218:296]

∅:D[2.296] → [4.2834:2895]

B:BD[4.2834] → [4.2834:2895]

B:BD[4.2895] → [2.297:434]

        export $op_d1
        function $op_d1(lmax::Union{Cint,Int}, z::Union{Cdouble,Float64,Int};
                        exitstatus::Maybe{Ref{Int}}=nothing)
            p = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)
            dp = Array{Cdouble}(undef, (lmax + 1) * (lmax + 2) ÷ 2)

[4.2735]

[4.3028]

        export $op
        function $op(lmax::Integer, z::Union{AbstractFloat,Integer};
                     exitstatus::Maybe{Ref{<:Integer}}=nothing)
            p = Array{Cdouble}(undef, lmax + 1)
            $op!(p, lmax, z; exitstatus=exitstatus)
            return p
        end
        #
        export $op_d1!
        function $op_d1!(p::AbstractVector{Cdouble},
                         dp::AbstractVector{Cdouble}, lmax::Integer,
                         z::Union{AbstractFloat,Integer};
                         exitstatus::Maybe{Ref{<:Integer}}=nothing)
            @assert length(p) ≥ lmax + 1
            @assert length(dp) ≥ lmax + 1
            exitstatus′ = 0

Replacement in src/SHTOOLS.jl at line 126 [4.421]

B:BD[4.3169] → [2.435:491]

                  lmax, z, cmayberef(Cint, exitstatus))

[4.3169]

[4.3224]

                  lmax, z, exitstatus′)
            if exitstatus === nothing
                exitstatus′ ≠ 0 && error("$($op_d1!): Error code $exitstatus′")
            else
                exitstatus[] = exitstatus′
            end
            return p, dp
        end
        #
        export $op_d1
        function $op_d1(lmax::Integer, z::Union{AbstractFloat,Integer};
                        exitstatus::Maybe{Ref{<:Integer}}=nothing)
            p = Array{Cdouble}(undef, lmax + 1)
            dp = Array{Cdouble}(undef, lmax + 1)
            $op_d1!(p, dp, lmax, z; exitstatus=exitstatus)

Replacement in src/SHTOOLS.jl at line 148 [4.421]

B:BD[2.508] → [2.508:571]

function PlmIndex(l::Union{Cint,Int}, m::Union{Cint,Int})::Int

[2.508]

[2.571]

function PlmIndex(l::Integer, m::Integer)

Replacement in src/SHTOOLS.jl at line 152 [4.421]
B:BD[2.758] → [2.758:775]
```
    return index
```
[2.758]
[4.3284]
```
    return Int(index)
```

Insertion in test/runtests.jl at line 3 [4.22]

[4.48]


@testset "PlmBar" begin
    p = PlmBar(4, 0)
    p′ = zeros(15)
    PlmBar!(p′, 4, 0)
    @test p′ == p

Replacement in test/runtests.jl at line 10 [4.22]

B:BD[4.49] → [4.49:129]

p = PlmBar(4, 0)
p, dp = PlmBar_d1(4, 0)
p = PlBar(4, 0)
p, dp = PlBar_d1(4, 0)

[4.49]

[4.129]

    p, dp = PlmBar_d1(4, 0)
    dp′ = zeros(15)
    PlmBar_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
    p = PlBar(4, 0)
    p′ = zeros(5)
    PlBar!(p′, 4, 0)
    @test p′ == p
    p, dp = PlBar_d1(4, 0)
    dp′ = zeros(5)
    PlBar_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
end

Replacement in test/runtests.jl at line 28 [4.22]

B:BD[4.130] → [4.130:206]

p = PlmON(4, 0)
p, dp = PlmON_d1(4, 0)
p = PlON(4, 0)
p, dp = PlON_d1(4, 0)

[4.130]

[4.206]

@testset "PlmON" begin
    p = PlmON(4, 0)
    p′ = zeros(15)
    PlmON!(p′, 4, 0)
    @test p′ == p

Replacement in test/runtests.jl at line 34 [4.22]

B:BD[4.207] → [4.207:303]

p = PlmSchmidt(4, 0)
p, dp = PlmSchmidt_d1(4, 0)
p = PlSchmidt(4, 0)
p, dp = PlSchmidt_d1(4, 0)

[4.207]

[4.303]

    p, dp = PlmON_d1(4, 0)
    dp′ = zeros(15)
    PlmON_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp

Replacement in test/runtests.jl at line 40 [4.22]

B:BD[4.304] → [4.304:400]

p = PLegendreA(4, 0)
p, dp = PLegendreA_d1(4, 0)
p = PLegendre(4, 0)
p, dp = PLegendre_d1(4, 0)

[4.304]

[2.782]

    p = PlON(4, 0)
    p′ = zeros(5)
    PlON!(p′, 4, 0)
    @test p′ == p

Replacement in test/runtests.jl at line 45 [4.22]

B:BD[2.783] → [2.783:824]

index = PlmIndex(4, 3)
@test index == 14

[2.783]

    p, dp = PlON_d1(4, 0)
    dp′ = zeros(5)
    PlON_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
end
@testset "PlmSchmidt" begin
    p = PlmSchmidt(4, 0)
    p′ = zeros(15)
    PlmSchmidt!(p′, 4, 0)
    @test p′ == p
    p, dp = PlmSchmidt_d1(4, 0)
    dp′ = zeros(15)
    PlmSchmidt_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
    p = PlSchmidt(4, 0)
    p′ = zeros(5)
    PlSchmidt!(p′, 4, 0)
    @test p′ == p
    p, dp = PlSchmidt_d1(4, 0)
    dp′ = zeros(5)
    PlSchmidt_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
end
@testset "PLegendreA" begin
    p = PLegendreA(4, 0)
    p′ = zeros(15)
    PLegendreA!(p′, 4, 0)
    @test p′ == p
    p, dp = PLegendreA_d1(4, 0)
    dp′ = zeros(15)
    PLegendreA_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
    p = PLegendre(4, 0)
    p′ = zeros(5)
    PLegendre!(p′, 4, 0)
    @test p′ == p
    p, dp = PLegendre_d1(4, 0)
    dp′ = zeros(5)
    PLegendre_d1!(p′, dp′, 4, 0)
    @test p′ == p
    @test dp′ == dp
end
@testset "PlmIndex" begin
    index = PlmIndex(4, 3)
    @test index == 14
end