formatting (#64)

* formatting

* bump version

Author: cscherrer

Project.toml

@@ -1,7 +1,7 @@
 name = "MeasureBase"
 uuid = "fa1605e6-acd5-459c-a1e6-7e635759db14"
 authors = ["Chad Scherrer <chad.scherrer@gmail.com> and contributors"]
-version = "0.12.0"
+version = "0.12.1"
 
 [deps]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"

src/combinators/power.jl

@@ -86,7 +86,7 @@ end
 end
 
 @inline function logdensity_def(
-    d::PowerMeasure{M,NTuple{N, Base.OneTo{StaticInt{0}}}},
+    d::PowerMeasure{M,NTuple{N,Base.OneTo{StaticInt{0}}}},
     x,
 ) where {M,N}
     static(0.0)
@@ -108,11 +108,11 @@ end
     end
 end
 
-
 @inline getdof(μ::PowerMeasure) = getdof(μ.parent) * prod(map(length, μ.axes))
 
-@inline getdof(::PowerMeasure{<:Any, NTuple{N,Base.OneTo{StaticInt{0}}}}) where N = static(0)
-
+@inline function getdof(::PowerMeasure{<:Any,NTuple{N,Base.OneTo{StaticInt{0}}}}) where {N}
+    static(0)
+end
 
 @propagate_inbounds function checked_arg(μ::PowerMeasure, x::AbstractArray{<:Any})
     @boundscheck begin

src/combinators/transformedmeasure.jl

@@ -14,7 +14,6 @@ function paramnames(::AbstractTransformedMeasure) end
 
 function parent(::AbstractTransformedMeasure) end
 
-
 export PushforwardMeasure
 
 """
@@ -35,13 +34,14 @@ end
 gettransform(ν::PushforwardMeasure) = ν.f
 parent(ν::PushforwardMeasure) = ν.origin
 
-
 function Pretty.tile(ν::PushforwardMeasure)
     Pretty.list_layout(Pretty.tile.([ν.f, ν.inv_f, ν.origin]); prefix = :PushforwardMeasure)
 end
 
-
-@inline function logdensity_def(ν::PushforwardMeasure{FF,IF,M,<:WithVolCorr}, y) where {FF,IF,M}
+@inline function logdensity_def(
+    ν::PushforwardMeasure{FF,IF,M,<:WithVolCorr},
+    y,
+) where {FF,IF,M}
     x_orig, inv_ladj = with_logabsdet_jacobian(ν.inv_f, y)
     logd_orig = logdensity_def(ν.origin, x_orig)
     logd = float(logd_orig + inv_ladj)
@@ -53,16 +53,18 @@ end
         # Return constant -Inf to prevent problems with ForwardDiff:
         (isfinite(logd_orig) && (inv_ladj == -Inf)),
         neginf,
-        logd
+        logd,
     )
 end
 
-@inline function logdensity_def(ν::PushforwardMeasure{FF,IF,M,<:NoVolCorr}, y) where {FF,IF,M}
+@inline function logdensity_def(
+    ν::PushforwardMeasure{FF,IF,M,<:NoVolCorr},
+    y,
+) where {FF,IF,M}
     x_orig = to_origin(ν, y)
     return logdensity_def(ν.origin, x_orig)
 end
 
-
 insupport(ν::PushforwardMeasure, y) = insupport(transport_origin(ν), to_origin(ν, y))
 
 testvalue(ν::PushforwardMeasure) = from_origin(ν, testvalue(transport_origin(ν)))
@@ -71,30 +73,27 @@ testvalue(ν::PushforwardMeasure) = from_origin(ν, testvalue(transport_origin(
     PushforwardMeasure(ν.f, ν.inv_f, basemeasure(transport_origin(ν)), NoVolCorr())
 end
 
-
-_pushfwd_dof(::Type{MU}, ::Type, dof) where MU = NoDOF{MU}()
-_pushfwd_dof(::Type{MU}, ::Type{<:Tuple{Any,Real}}, dof) where MU = dof
+_pushfwd_dof(::Type{MU}, ::Type, dof) where {MU} = NoDOF{MU}()
+_pushfwd_dof(::Type{MU}, ::Type{<:Tuple{Any,Real}}, dof) where {MU} = dof
 
 # Assume that DOF are preserved if with_logabsdet_jacobian is functional:
 @inline function getdof(ν::MU) where {MU<:PushforwardMeasure}
     T = Core.Compiler.return_type(testvalue, Tuple{typeof(ν.origin)})
-    R = Core.Compiler.return_type(with_logabsdet_jacobian, Tuple{typeof(ν.f), T})
+    R = Core.Compiler.return_type(with_logabsdet_jacobian, Tuple{typeof(ν.f),T})
     _pushfwd_dof(MU, R, getdof(ν.origin))
 end
 
 # Bypass `checked_arg`, would require potentially costly transformation:
 @inline checked_arg(::PushforwardMeasure, x) = x
 
-
 @inline transport_origin(ν::PushforwardMeasure) = ν.origin
 @inline from_origin(ν::PushforwardMeasure, x) = ν.f(x)
 @inline to_origin(ν::PushforwardMeasure, y) = ν.inv_f(y)
 
-function Base.rand(rng::AbstractRNG, ::Type{T}, ν::PushforwardMeasure) where T
+function Base.rand(rng::AbstractRNG, ::Type{T}, ν::PushforwardMeasure) where {T}
     return from_origin(ν, rand(rng, T, transport_origin(ν)))
 end
 
-
 export pushfwd
 
 """

src/getdof.jl

@@ -7,7 +7,6 @@ a global property of the measure.
 """
 struct NoDOF{MU} end
 
-
 """
     getdof(μ)
 
@@ -23,11 +22,10 @@ Also see [`check_dof`](@ref).
 function getdof end
 
 # Prevent infinite recursion:
-@inline _default_getdof(::Type{MU}, ::MU) where MU = NoDOF{MU}
-@inline _default_getdof(::Type{MU}, mu_base) where MU = getdof(mu_base)
-
-@inline getdof(μ::MU) where MU = _default_getdof(MU, basemeasure(μ))
+@inline _default_getdof(::Type{MU}, ::MU) where {MU} = NoDOF{MU}
+@inline _default_getdof(::Type{MU}, mu_base) where {MU} = getdof(mu_base)
 
+@inline getdof(μ::MU) where {MU} = _default_getdof(MU, basemeasure(μ))
 
 """
     MeasureBase.check_dof(ν, μ)::Nothing
@@ -41,15 +39,18 @@ function check_dof(ν, μ)
     n_ν = getdof(ν)
     n_μ = getdof(μ)
     if n_ν != n_μ
-        throw(ArgumentError("Measure ν of type $(nameof(typeof(ν))) has $(n_ν) DOF but μ of type $(nameof(typeof(μ))) has $(n_μ) DOF"))
+        throw(
+            ArgumentError(
+                "Measure ν of type $(nameof(typeof(ν))) has $(n_ν) DOF but μ of type $(nameof(typeof(μ))) has $(n_μ) DOF",
+            ),
+        )
     end
     return nothing
 end
 
 _check_dof_pullback(ΔΩ) = NoTangent(), NoTangent(), NoTangent()
 ChainRulesCore.rrule(::typeof(check_dof), ν, μ) = check_dof(ν, μ), _check_dof_pullback
 
-
 """
     MeasureBase.NoArgCheck{MU,T}
 
@@ -58,7 +59,6 @@ variate of measures of type `MU`.
 """
 struct NoArgCheck{MU,T} end
 
-
 """
     MeasureBase.checked_arg(μ::MU, x::T)::T
 
@@ -68,10 +68,16 @@ return `NoArgCheck{MU,T}()` if not check can be performed.
 function checked_arg end
 
 # Prevent infinite recursion:
-@propagate_inbounds _default_checked_arg(::Type{MU}, ::MU, ::T) where {MU,T} = NoArgCheck{MU,T}
-@propagate_inbounds _default_checked_arg(::Type{MU}, mu_base, x) where MU = checked_arg(mu_base, x)
+@propagate_inbounds function _default_checked_arg(::Type{MU}, ::MU, ::T) where {MU,T}
+    NoArgCheck{MU,T}
+end
+@propagate_inbounds function _default_checked_arg(::Type{MU}, mu_base, x) where {MU}
+    checked_arg(mu_base, x)
+end
 
-@propagate_inbounds checked_arg(mu::MU, x) where MU = _default_checked_arg(MU, basemeasure(mu), x)
+@propagate_inbounds function checked_arg(mu::MU, x) where {MU}
+    _default_checked_arg(MU, basemeasure(mu), x)
+end
 
 _checked_arg_pullback(ΔΩ) = NoTangent(), NoTangent(), ΔΩ
 ChainRulesCore.rrule(::typeof(checked_arg), ν, x) = checked_arg(ν, x), _checked_arg_pullback

src/insupport.jl

@@ -10,7 +10,6 @@ insupport(m)(x) == insupport(m, x)
 """
 function insupport end
 
-
 """
     MeasureBase.require_insupport(μ, x)::Nothing
 

src/interface.jl

@@ -65,10 +65,9 @@ function test_interface(μ::M) where {M}
     end
 end
 
-
 function test_transport(ν, μ)
     supertype(x::Real) = Real
-    supertype(x::AbstractArray{<:Real,N}) where N = AbstractArray{<:Real,N}
+    supertype(x::AbstractArray{<:Real,N}) where {N} = AbstractArray{<:Real,N}
 
     @testset "transport_to $μ to $ν" begin
         x = rand(μ)
@@ -82,7 +81,7 @@ function test_transport(ν, μ)
         x2, ladj_inv = with_logabsdet_jacobian(inverse(f), y)
         @test x ≈ x2
         @test y ≈ y2
-        @test ladj_fwd ≈ - ladj_inv
+        @test ladj_fwd ≈ -ladj_inv
         @test ladj_fwd ≈ logdensityof(μ, x) - logdensityof(ν, y)
     end
 end

src/standard/stdexponential.jl

@@ -7,8 +7,7 @@ insupport(d::StdExponential, x) = x ≥ zero(x)
 @inline logdensity_def(::StdExponential, x) = -x
 @inline basemeasure(::StdExponential) = Lebesgue()
 
-@inline transport_def(::StdUniform, μ::StdExponential, x) = - expm1(-x)
-@inline transport_def(::StdExponential, μ::StdUniform, x) = - log1p(-x)
+@inline transport_def(::StdUniform, μ::StdExponential, x) = -expm1(-x)
+@inline transport_def(::StdExponential, μ::StdUniform, x) = -log1p(-x)
 
 Base.rand(rng::Random.AbstractRNG, ::Type{T}, ::StdExponential) where {T} = randexp(rng, T)
-

src/standard/stdlogistic.jl

@@ -4,10 +4,12 @@ export StdLogistic
 
 @inline insupport(d::StdLogistic, x) = true
 
-@inline logdensity_def(::StdLogistic, x) = (u = -abs(x); u - 2*log1pexp(u))
+@inline logdensity_def(::StdLogistic, x) = (u = -abs(x); u - 2 * log1pexp(u))
 @inline basemeasure(::StdLogistic) = Lebesgue()
 
 @inline transport_def(::StdUniform, μ::StdLogistic, x) = logistic(x)
 @inline transport_def(::StdLogistic, μ::StdUniform, x) = logit(x)
 
-@inline Base.rand(rng::Random.AbstractRNG, ::Type{T}, ::StdLogistic) where {T} = logit(rand(rng, T))
+@inline function Base.rand(rng::Random.AbstractRNG, ::Type{T}, ::StdLogistic) where {T}
+    logit(rand(rng, T))
+end

src/standard/stdmeasure.jl

@@ -3,10 +3,8 @@ abstract type StdMeasure <: AbstractMeasure end
 StdMeasure(::typeof(rand)) = StdUniform()
 StdMeasure(::typeof(randexp)) = StdExponential()
 
-
 @inline check_dof(::StdMeasure, ::StdMeasure) = nothing
 
-
 @inline transport_def(::MU, μ::MU, x) where {MU<:StdMeasure} = x
 
 function transport_def(ν::StdMeasure, μ::PowerMeasure{<:StdMeasure}, x)
@@ -17,24 +15,34 @@ function transport_def(ν::PowerMeasure{<:StdMeasure}, μ::StdMeasure, x)
     return Fill(transport_def(ν.parent, μ, only(x)), map(length, ν.axes)...)
 end
 
-function transport_def(ν::PowerMeasure{<:StdMeasure,<:NTuple{1,Base.OneTo}}, μ::PowerMeasure{<:StdMeasure,<:NTuple{1,Base.OneTo}}, x)
+function transport_def(
+    ν::PowerMeasure{<:StdMeasure,<:NTuple{1,Base.OneTo}},
+    μ::PowerMeasure{<:StdMeasure,<:NTuple{1,Base.OneTo}},
+    x,
+)
     return transport_to(ν.parent, μ.parent).(x)
 end
 
-function transport_def(ν::PowerMeasure{<:StdMeasure,<:NTuple{N,Base.OneTo}}, μ::PowerMeasure{<:StdMeasure,<:NTuple{M,Base.OneTo}}, x) where {N,M}
+function transport_def(
+    ν::PowerMeasure{<:StdMeasure,<:NTuple{N,Base.OneTo}},
+    μ::PowerMeasure{<:StdMeasure,<:NTuple{M,Base.OneTo}},
+    x,
+) where {N,M}
     return reshape(transport_to(ν.parent, μ.parent).(x), map(length, ν.axes)...)
 end
 
-
 # Implement transport_to(NU::Type{<:StdMeasure}, μ) and transport_to(ν, MU::Type{<:StdMeasure}):
 
 _std_measure(::Type{M}, ::StaticInt{1}) where {M<:StdMeasure} = M()
 _std_measure(::Type{M}, dof::Integer) where {M<:StdMeasure} = M()^dof
 _std_measure_for(::Type{M}, μ::Any) where {M<:StdMeasure} = _std_measure(M, getdof(μ))
 
-MeasureBase.transport_to(::Type{NU}, μ) where {NU<:StdMeasure} = transport_to(_std_measure_for(NU, μ), μ)
-MeasureBase.transport_to(ν, ::Type{MU}) where {MU<:StdMeasure} = transport_to(ν, _std_measure_for(MU, ν))
-
+function MeasureBase.transport_to(::Type{NU}, μ) where {NU<:StdMeasure}
+    transport_to(_std_measure_for(NU, μ), μ)
+end
+function MeasureBase.transport_to(ν, ::Type{MU}) where {MU<:StdMeasure}
+    transport_to(ν, _std_measure_for(MU, ν))
+end
 
 # Transform between standard measures and Dirac: