formatting

Author: cscherrer

.JuliaFormatter.toml

@@ -6,7 +6,7 @@ whitespace_ops_in_indices = false
 remove_extra_newlines = true
 import_to_using = false
 pipe_to_function_call = false
-short_to_long_function_def = false
+short_to_long_function_def = true
 always_use_return = false
 whitespace_in_kwargs = true
 annotate_untyped_fields_with_any = false

src/MeasureBase.jl

@@ -131,4 +131,4 @@ include("interface.jl")
 
 using .Interface
 
-end # module MeasureBase
+end # module MeasureBase

src/combinators/bind.jl

@@ -33,4 +33,4 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::Bind) where {T}
     x = rand(rng, T, d.μ)
     y = rand(rng, T, d.k(x))
     return y
-end
+end

src/combinators/conditional.jl

@@ -1,5 +1,5 @@
 struct ConditionalMeasure{M,C} <: AbstractMeasure
-    parent::M 
+    parent::M
     constraint::C
 end
 
@@ -37,10 +37,13 @@ condition(μ, constraint) = ConditionalMeasure(μ, constraint)
 #     end
 # end
 
-function Base.:|(μ::ProductMeasure{NamedTuple{M,T}}, constraint::NamedTuple{N}) where {M,T,N}
-    productmeasure(merge(marginals(μ),rmap(Dirac, constraint)))
+function Base.:|(
+    μ::ProductMeasure{NamedTuple{M,T}},
+    constraint::NamedTuple{N},
+) where {M,T,N}
+    productmeasure(merge(marginals(μ), rmap(Dirac, constraint)))
 end
 
 function Pretty.tile(d::ConditionalMeasure)
-    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.constraint), sep=" | ")
-end
+    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.constraint), sep = " | ")
+end

src/combinators/for.jl

@@ -0,0 +1 @@
+

src/combinators/likelihood.jl

@@ -116,8 +116,8 @@ struct Likelihood{K,X} <: AbstractLikelihood
     k::K
     x::X
 
-    Likelihood(k::K, x::X) where {K<:AbstractTransitionKernel,X} = new{K,X}(k,x)
-    Likelihood(k::K, x::X) where {K<:Function,X} = new{K,X}(k,x)
+    Likelihood(k::K, x::X) where {K<:AbstractTransitionKernel,X} = new{K,X}(k, x)
+    Likelihood(k::K, x::X) where {K<:Function,X} = new{K,X}(k, x)
     Likelihood(μ, x) = Likelihood(kernel(μ), x)
 end
 

src/combinators/pointwise.jl

@@ -5,12 +5,10 @@ struct PointwiseProductMeasure{P,L} <: AbstractMeasure
     likelihood::L
 end
 
-
-
-iterate(p::PointwiseProductMeasure, i=1) = iterate((p.prior, p.likelihood), i)
+iterate(p::PointwiseProductMeasure, i = 1) = iterate((p.prior, p.likelihood), i)
 
 function Pretty.tile(d::PointwiseProductMeasure)
-    Pretty.pair_layout(Pretty.tile(d.prior), Pretty.tile(d.likelihood), sep=" ⊙ ")
+    Pretty.pair_layout(Pretty.tile(d.prior), Pretty.tile(d.likelihood), sep = " ⊙ ")
 end
 
 ⊙(μ, ℓ) = pointwiseproduct(μ, ℓ)
@@ -24,7 +22,7 @@ function gentype(d::PointwiseProductMeasure)
     gentype(d.prior)
 end
 
-@inbounds function insupport(d::PointwiseProductMeasure, p) 
+@inbounds function insupport(d::PointwiseProductMeasure, p)
     μ, ℓ = d
     insupport(μ, p) && insupport(ℓ.k(p), ℓ.x)
 end

src/combinators/power.jl

@@ -24,7 +24,11 @@ function Pretty.tile(μ::PowerMeasure)
     return Pretty.pair_layout(arg1, arg2; sep = " ^ ")
 end
 
-function Base.rand(rng::AbstractRNG, ::Type{T}, d::PowerMeasure{M}) where {T, M<:AbstractMeasure}
+function Base.rand(
+    rng::AbstractRNG,
+    ::Type{T},
+    d::PowerMeasure{M},
+) where {T,M<:AbstractMeasure}
     map(CartesianIndices(d.axes)) do _
         rand(rng, T, d.parent)
     end
@@ -36,10 +40,10 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::PowerMeasure) where {T}
     end
 end
 
-@inline function powermeasure(x::T, sz::Tuple{Vararg{<:Any,N}}) where {T, N}
-    a = axes(Fill{T, N}(x, sz))
+@inline function powermeasure(x::T, sz::Tuple{Vararg{<:Any,N}}) where {T,N}
+    a = axes(Fill{T,N}(x, sz))
     A = typeof(a)
-    PowerMeasure{T,A}(x,a)
+    PowerMeasure{T,A}(x, a)
 end
 
 marginals(d::PowerMeasure) = Fill(d.parent, d.axes)
@@ -61,7 +65,7 @@ params(d::PowerMeasure) = params(first(marginals(d)))
 # basemeasure(μ::PowerMeasure) = @inbounds basemeasure(first(μ.data))^size(μ.data)
 
 @inline function basemeasure(d::PowerMeasure)
-    basemeasure(d.parent) ^ d.axes
+    basemeasure(d.parent)^d.axes
 end
 
 @inline function logdensity_def(d::PowerMeasure{M}, x) where {M}
@@ -71,7 +75,10 @@ end
     end
 end
 
-@inline function logdensity_def(d::PowerMeasure{M, Tuple{Base.OneTo{StaticInt{N}}}}, x) where {M,N}
+@inline function logdensity_def(
+    d::PowerMeasure{M,Tuple{Base.OneTo{StaticInt{N}}}},
+    x,
+) where {M,N}
     parent = d.parent
     sum(1:N) do j
         @inbounds logdensity_def(parent, x[j])
@@ -92,4 +99,4 @@ end
         # https://github.com/SciML/Static.jl/issues/36
         dynamic(insupport(p, xj))
     end
-end
+end

src/combinators/powerweighted.jl

@@ -7,16 +7,16 @@ end
 
 logdensity_def(d::PowerWeightedMeasure, x) = d.exponent * logdensity_def(d.parent, x)
 
-basemeasure(d::PowerWeightedMeasure, x) = basemeasure(d.parent, x) ↑ d.exponent
+basemeasure(d::PowerWeightedMeasure, x) = basemeasure(d.parent, x)↑d.exponent
 
-basemeasure(d::PowerWeightedMeasure) = basemeasure(d.parent) ↑ d.exponent
+basemeasure(d::PowerWeightedMeasure) = basemeasure(d.parent)↑d.exponent
 
 function powerweightedmeasure(d, α)
     isone(α) && return d
     PowerWeightedMeasure(d, α)
 end
 
-(d::AbstractMeasure) ↑ α = powerweightedmeasure(d, α)
+(d::AbstractMeasure)↑α = powerweightedmeasure(d, α)
 
 insupport(d::PowerWeightedMeasure, x) = insupport(d.parent, x)
 
@@ -29,9 +29,9 @@ function powerweightedmeasure(d::PowerWeightedMeasure, α)
 end
 
 function powerweightedmeasure(d::WeightedMeasure, α)
-    weightedmeasure(α*d.logweight, powerweightedmeasure(d.base, α))
+    weightedmeasure(α * d.logweight, powerweightedmeasure(d.base, α))
 end
 
 function Pretty.tile(d::PowerWeightedMeasure)
-    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.exponent), sep=" ↑ ")
-end
+    Pretty.pair_layout(Pretty.tile(d.parent), Pretty.tile(d.exponent), sep = " ↑ ")
+end

src/combinators/product.jl

@@ -31,13 +31,23 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::AbstractProductMeasure) where
     _rand_product(rng, T, mar, eltype(mar))
 end
 
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar, ::Type{M}) where {T,M<:AbstractMeasure}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar,
+    ::Type{M},
+) where {T,M<:AbstractMeasure}
     map(mar) do dⱼ
         rand(rng, T, dⱼ)
     end
 end
 
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar::ReadonlyMappedArray, ::Type{M}) where {T,M<:AbstractMeasure}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar::ReadonlyMappedArray,
+    ::Type{M},
+) where {T,M<:AbstractMeasure}
     mappedarray(mar.data) do dⱼ
         rand(rng, T, mar.f(dⱼ))
     end |> collect
@@ -49,14 +59,17 @@ function _rand_product(rng::AbstractRNG, ::Type{T}, mar, ::Type{M}) where {T,M}
     end
 end
 
-
-function _rand_product(rng::AbstractRNG, ::Type{T}, mar::ReadonlyMappedArray, ::Type{M}) where {T,M}
+function _rand_product(
+    rng::AbstractRNG,
+    ::Type{T},
+    mar::ReadonlyMappedArray,
+    ::Type{M},
+) where {T,M}
     mappedarray(mar.data) do dⱼ
         rand(rng, mar.f(dⱼ))
     end |> collect
 end
 
-
 @inline function logdensity_def(d::AbstractProductMeasure, x)
     mapreduce(logdensity_def, +, marginals(d), x)
 end
@@ -70,12 +83,12 @@ end
 end
 
 function Pretty.tile(d::ProductMeasure{T}) where {T<:Tuple}
-    Pretty.list_layout(Pretty.tile.([marginals(d)...]), sep=" ⊗ ")
+    Pretty.list_layout(Pretty.tile.([marginals(d)...]), sep = " ⊗ ")
 end
 
 # For tuples, `mapreduce` has trouble with type inference
 @inline function logdensity_def(d::ProductMeasure{T}, x) where {T<:Tuple}
-    ℓs = map(logdensity_def, marginals(d),x)
+    ℓs = map(logdensity_def, marginals(d), x)
     sum(ℓs)
 end
 
@@ -115,30 +128,35 @@ function basemeasure(μ::ProductMeasure{Base.Generator{I,F}}) where {I,F}
     _basemeasure(μ, B, static(Base.issingletontype(B)))
 end
 
-
-
 function basemeasure(μ::ProductMeasure{A}) where {T,A<:AbstractMappedArray{T}}
     B = Core.Compiler.return_type(basemeasure, Tuple{T})
     _basemeasure(μ, B, static(Base.issingletontype(B)))
 end
 
 function _basemeasure(μ::ProductMeasure, ::Type{B}, ::True) where {T,B}
-    return instance(B) ^ axes(marginals(μ))
+    return instance(B)^axes(marginals(μ))
 end
 
-function _basemeasure(μ::ProductMeasure{A}, ::Type{B}, ::False) where {T,A<:AbstractMappedArray{T},B}
+function _basemeasure(
+    μ::ProductMeasure{A},
+    ::Type{B},
+    ::False,
+) where {T,A<:AbstractMappedArray{T},B}
     mar = marginals(μ)
     productmeasure(mappedarray(basemeasure, mar))
 end
 
-function _basemeasure(μ::ProductMeasure{Base.Generator{I,F}}, ::Type{B}, ::False) where {I,F,B}
+function _basemeasure(
+    μ::ProductMeasure{Base.Generator{I,F}},
+    ::Type{B},
+    ::False,
+) where {I,F,B}
     mar = marginals(μ)
     productmeasure(Base.Generator(basekernel(mar.f), mar.iter))
 end
 
 marginals(μ::ProductMeasure) = μ.marginals
 
-
 testvalue(d::AbstractProductMeasure) = map(testvalue, marginals(d))
 
 export ⊗
@@ -184,18 +202,17 @@ function _rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure, mar::AbstractArra
     rand!(rng, d, x)
 end
 
-
 @inline function insupport(d::AbstractProductMeasure, x::AbstractArray)
     mar = marginals(d)
-    for (j,mj) in enumerate(mar)
+    for (j, mj) in enumerate(mar)
         dynamic(insupport(mj, x[j])) || return false
     end
     return true
 end
 
 @inline function insupport(d::AbstractProductMeasure, x)
-    for (mj,xj) in zip(marginals(d), x)
+    for (mj, xj) in zip(marginals(d), x)
         dynamic(insupport(mj, xj)) || return false
     end
     return true
-end
+end