formatting (#196)

Author: cscherrer

docs/make.jl

@@ -1,8 +1,8 @@
 using Documenter
 using MeasureTheory
 
-DocMeta.setdocmeta!(MeasureBase, :DocTestSetup, :(using MeasureBase); recursive=true)
-DocMeta.setdocmeta!(MeasureTheory, :DocTestSetup, :(using MeasureTheory); recursive=true)
+DocMeta.setdocmeta!(MeasureBase, :DocTestSetup, :(using MeasureBase); recursive = true)
+DocMeta.setdocmeta!(MeasureTheory, :DocTestSetup, :(using MeasureTheory); recursive = true)
 
 pages = [
     "Home" => "index.md",
@@ -18,18 +18,16 @@ pages = [
 ]
 
 makedocs(;
-    modules=[MeasureBase, MeasureTheory],
-    authors="Chad Scherrer <[email protected]> and contributors",
-    repo="https://github.com/cscherrer/MeasureTheory.jl/blob/{commit}{path}#L{line}",
-    sitename="MeasureTheory.jl",
-    format=Documenter.HTML(;
-        prettyurls=get(ENV, "CI", "false") == "true",
-        canonical="https://cscherrer.github.io/MeasureTheory.jl",
-        assets=String[],
+    modules = [MeasureBase, MeasureTheory],
+    authors = "Chad Scherrer <[email protected]> and contributors",
+    repo = "https://github.com/cscherrer/MeasureTheory.jl/blob/{commit}{path}#L{line}",
+    sitename = "MeasureTheory.jl",
+    format = Documenter.HTML(;
+        prettyurls = get(ENV, "CI", "false") == "true",
+        canonical = "https://cscherrer.github.io/MeasureTheory.jl",
+        assets = String[],
     ),
-    pages=pages
+    pages = pages,
 )
 
-deploydocs(;
-    repo="github.com/cscherrer/MeasureTheory.jl",
-)
+deploydocs(; repo = "github.com/cscherrer/MeasureTheory.jl")

scratch/orderstats.jl

@@ -3,7 +3,7 @@ struct OrderStatistic{n,r,B} <: AbstractMeasure
 end
 
 @inline function basemeasure(d::OrderStatistic{n,r})
-    WeightedMeasure(logbeta(n+1, r+1), d.base)
+    WeightedMeasure(logbeta(n + 1, r + 1), d.base)
 end
 
 @inline function logdensity_def(d::OrderStatistic{n,r}, x)

src/MeasureTheory.jl

@@ -49,7 +49,16 @@ export ifelse
 
 import MeasureBase: insupport, instance, marginals
 import MeasureBase:
-    testvalue, logdensity_def, density_def, basemeasure, kleisli, params, paramnames, ∫, 𝒹, ∫exp
+    testvalue,
+    logdensity_def,
+    density_def,
+    basemeasure,
+    kleisli,
+    params,
+    paramnames,
+    ∫,
+    𝒹,
+    ∫exp
 import MeasureBase: ≪
 using MeasureBase: BoundedInts, BoundedReals, CountingMeasure, IntegerDomain, IntegerNumbers
 using MeasureBase: weightedmeasure, restrict

src/combinators/affine.jl

@@ -23,8 +23,7 @@ Base.propertynames(d::AffineTransform{N}) where {N} = N
 
 import InverseFunctions: inverse
 
-@inline inverse(f::AffineTransform{(:μ, :σ)}) =
-    AffineTransform((μ = -(f.σ \ f.μ), ω = f.σ))
+@inline inverse(f::AffineTransform{(:μ, :σ)}) = AffineTransform((μ = -(f.σ \ f.μ), ω = f.σ))
 @inline inverse(f::AffineTransform{(:μ, :ω)}) = AffineTransform((μ = -f.ω * f.μ, σ = f.ω))
 @inline inverse(f::AffineTransform{(:σ,)}) = AffineTransform((ω = f.σ,))
 @inline inverse(f::AffineTransform{(:ω,)}) = AffineTransform((σ = f.ω,))
@@ -121,14 +120,12 @@ logjac(f::AffineTransform{(:μ,)}) = 0.0
 
 ###############################################################################
 
-
 struct OrthoLebesgue{N,T} <: PrimitiveMeasure
     par::NamedTuple{N,T}
 
     OrthoLebesgue(nt::NamedTuple{N,T}) where {N,T} = new{N,T}(nt)
 end
 
-
 basemeasure(d::OrthoLebesgue) = d
 
 logdensity_def(::OrthoLebesgue, x) = static(0)
@@ -139,7 +136,7 @@ struct Affine{N,M,T} <: AbstractMeasure
 end
 
 function Pretty.tile(d::Affine)
-    Pretty.list_layout(Pretty.tile.([params(d.f), d.parent]); prefix=:Affine)
+    Pretty.list_layout(Pretty.tile.([params(d.f), d.parent]); prefix = :Affine)
 end
 
 function testvalue(d::Affine)
@@ -233,16 +230,20 @@ end
     weightedmeasure(-logjac(d), OrthoLebesgue(params(d)))
 end
 
-@inline function basemeasure(d::Affine{N,M,Tuple{A1,A2}}) where {N,M,A1<:AbstractArray, A2<:AbstractArray}
+@inline function basemeasure(
+    d::Affine{N,M,Tuple{A1,A2}},
+) where {N,M,A1<:AbstractArray,A2<:AbstractArray}
     weightedmeasure(-logjac(d), OrthoLebesgue(params(d)))
 end
 
 @inline basemeasure(d::Affine) = affine(getfield(d, :f), basemeasure(d.parent))
 
 # We can't do this until we know we're working with Lebesgue measure, since for
 # example it wouldn't make sense to apply a log-Jacobian to a point measure
-@inline basemeasure(d::Affine{N,L}) where {N,L<:Lebesgue} = weightedmeasure(-logjac(d), d.parent)
-@inline basemeasure(d::Affine{N,L}) where {N,L<:LebesgueMeasure} = weightedmeasure(-logjac(d), d.parent)
+@inline basemeasure(d::Affine{N,L}) where {N,L<:Lebesgue} =
+    weightedmeasure(-logjac(d), d.parent)
+@inline basemeasure(d::Affine{N,L}) where {N,L<:LebesgueMeasure} =
+    weightedmeasure(-logjac(d), d.parent)
 
 logjac(d::Affine) = logjac(getfield(d, :f))
 

src/combinators/chain.jl

@@ -2,7 +2,6 @@ using DynamicIterators
 import DynamicIterators: dub, dyniterate, evolve
 using Base.Iterators: SizeUnknown, IsInfinite
 
-
 export Chain
 
 struct Chain{K,M} <: AbstractMeasure

src/combinators/exponential-families.jl

@@ -5,7 +5,7 @@ export ExponentialFamily
     mdim
     pdim
     t
-    x    
+    x
     a
 end
 
@@ -17,7 +17,7 @@ function MeasureBase.powermeasure(fam::ExponentialFamily, dims::NTuple{N,I}) whe
     t = Tuple((y -> f.(y) for f in fam.t))
     a(η) = BroadcastArray(fam.a, η)
     p = prod(dims)
-    ExponentialFamily(fam.base ^ dims, fam.mdim * p, fam.pdim * p,  t, fam.x, a)
+    ExponentialFamily(fam.base^dims, fam.mdim * p, fam.pdim * p, t, fam.x, a)
 end
 
 @concrete terse struct ExpFamMeasure <: AbstractMeasure
@@ -26,24 +26,24 @@ end
     a # instantiated to a value
 end
 
-
 @inline function (fam::ExponentialFamily)(β)
-    η = fam.x * β 
+    η = fam.x * β
     a = fam.a(η)
     ExpFamMeasure(fam, η, a)
 end
 
 MeasureBase.basemeasure(d::ExpFamMeasure) = d.fam.base
 
-tracedot(a::AbstractVector,b::AbstractVector) = dot(a, b)
+tracedot(a::AbstractVector, b::AbstractVector) = dot(a, b)
 
-tracedot(a::AbstractVector,x,b::AbstractVector) = dot(a, x, b)
+tracedot(a::AbstractVector, x, b::AbstractVector) = dot(a, x, b)
 
-tracedot(a,b) = sum((dot(view(a,:,j), view(b,:,j)) for j in 1:size(a,2)))
+tracedot(a, b) = sum((dot(view(a, :, j), view(b, :, j)) for j in 1:size(a, 2)))
 
-tracedot(a,x,b) = sum(1:size(a,2)) do j
-    dot(view(a,:,j), x, view(b,:,j))
-end
+tracedot(a, x, b) =
+    sum(1:size(a, 2)) do j
+        dot(view(a, :, j), x, view(b, :, j))
+    end
 
 # @inline function tracedot(a::BlockDiag, b::BlockDiag)
 #     numblocks = length(a.blocks)
@@ -61,13 +61,12 @@ function logdensity_def(d::ExpFamMeasure, y)
     dot(t, η)
 end
 
-
 function withX(fam::ExponentialFamily, x)
     @inline t(y) = fam.t.(y)
     newx = ApplyArray(kron, x, fam.x)
     η(β) = fam.η.(β)
     a(β) = sum(fam.a, β)
-    ExponentialFamily(fam.base ^ size(x,1), t, x, η, a)
+    ExponentialFamily(fam.base^size(x, 1), t, x, η, a)
 end
 
 @concrete terse struct ExpFamLikelihood <: AbstractLikelihood
@@ -80,11 +79,10 @@ end
 export likelihood
 
 function regression(fam, uᵀ, vᵀ)
-
 end
 
 function likelihood(fam::ExponentialFamily, y)
-    c = logdensityof(fam.base, y) 
+    c = logdensityof(fam.base, y)
     t = ApplyArray(vcat, (f.(y) for f in fam.t)...)
     tᵀx = t' * fam.x
     ExpFamLikelihood(fam, y, tᵀx, c)