Fix format in repo

src/common.jl

@@ -45,4 +45,4 @@ function binomial_prod(n, p, x)
     end
 end
 
-mvdigamma(η,p) = sum( digamma(η + (one(d) - d)/2) for d=1:p)
+mvdigamma(η, p) = sum(digamma(η + (one(d) - d) / 2) for d in 1:p)

src/distributions/beta.jl

@@ -69,7 +69,7 @@ getgradlogpartition(::NaturalParametersSpace, ::Type{Beta}) = (η) -> begin
     ηsum = η₁p + η₂p
     dig = digamma(ηsum)
 
-    return SA[digamma(η₁p) - dig, digamma(η₂p) - dig]
+    return SA[digamma(η₁p)-dig, digamma(η₂p)-dig]
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{Beta}) = (η) -> begin

src/distributions/binomial.jl

@@ -95,7 +95,7 @@ end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{Binomial}, ntrials) = (η) -> begin
     (η₁,) = unpack_parameters(Binomial, η)
-    return SA[ntrials*exp(η₁) / (one(η₁) + exp(η₁))]
+    return SA[ntrials*exp(η₁)/(one(η₁)+exp(η₁))]
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{Binomial}, ntrials) = (η) -> begin

src/distributions/categorical.jl

@@ -28,7 +28,8 @@ end
 # The default implementation via `@generated` function fails to infer this
 exponential_family_typetag(::Categorical) = Categorical
 
-isproper(::NaturalParametersSpace, ::Type{Categorical}, η, conditioner) = isinteger(conditioner) && (conditioner === length(η)) && (length(η) >= 2) && (η[end] ≈ 0)
+isproper(::NaturalParametersSpace, ::Type{Categorical}, η, conditioner) =
+    isinteger(conditioner) && (conditioner === length(η)) && (length(η) >= 2) && (η[end] ≈ 0)
 isproper(::MeanParametersSpace, ::Type{Categorical}, θ, conditioner) =
     isinteger(conditioner) && (conditioner === length(θ)) && (length(θ) >= 2) && all(>(0), θ) && isapprox(sum(θ), 1)
 
@@ -51,14 +52,14 @@ function (::MeanToNatural{Categorical})(tuple_of_θ::Tuple{Any}, _)
     return (LoopVectorization.vmap(pᵢ -> log(pᵢ / pₖ), p),)
 end
 
-function (::NaturalToMean{Categorical})(tuple_of_η::Tuple{V}, _) where { V <: Vector }
+function (::NaturalToMean{Categorical})(tuple_of_η::Tuple{V}, _) where {V <: Vector}
     (η,) = tuple_of_η
     return (softmax(η),)
 end
 
 # We use `Categorical` from `Distributions.jl` for the `MeanParametersSpace` 
 # and their implementation supports only `Vector`s
-function (::NaturalToMean{Categorical})(tuple_of_η::Tuple{V}, _) where { V <: AbstractVector }
+function (::NaturalToMean{Categorical})(tuple_of_η::Tuple{V}, _) where {V <: AbstractVector}
     (η,) = tuple_of_η
     return (softmax(convert(Vector, η)),)
 end
@@ -87,7 +88,7 @@ getlogpartition(::NaturalParametersSpace, ::Type{Categorical}, conditioner) =
         return logsumexp(η)
     end
 
-getgradlogpartition(::NaturalParametersSpace, ::Type{Categorical}, conditioner) = 
+getgradlogpartition(::NaturalParametersSpace, ::Type{Categorical}, conditioner) =
     (η) -> begin
         if (conditioner !== length(η))
             throw(
@@ -97,7 +98,7 @@ getgradlogpartition(::NaturalParametersSpace, ::Type{Categorical}, conditioner)
             )
         end
         sumη = vmapreduce(exp, +, η)
-        return vmap(d->exp(d)/sumη ,η)
+        return vmap(d -> exp(d) / sumη, η)
     end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{Categorical}, conditioner) =

src/distributions/chi_squared.jl

@@ -56,7 +56,7 @@ unpack_parameters(::Type{Chisq}, packed) = (first(packed),)
 isbasemeasureconstant(::Type{Chisq}) = NonConstantBaseMeasure()
 
 getbasemeasure(::Type{Chisq}) = (x) -> exp(-x / 2)
-getlogbasemeasure(::Type{Chisq}) = (x) -> -x/2
+getlogbasemeasure(::Type{Chisq}) = (x) -> -x / 2
 getsufficientstatistics(::Type{Chisq}) = (log,)
 
 getlogpartition(::NaturalParametersSpace, ::Type{Chisq}) = (η) -> begin
@@ -67,7 +67,7 @@ end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{Chisq}) = (η) -> begin
     (η1,) = unpack_parameters(Chisq, η)
-    return SA[digamma(η1 + one(η1)) + logtwo]
+    return SA[digamma(η1 + one(η1))+logtwo]
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{Chisq}) = (η) -> begin

src/distributions/dirichlet.jl

@@ -92,4 +92,4 @@ end
 getgradlogpartition(::MeanParametersSpace, ::Type{Dirichlet}) = (θ) -> begin
     (α,) = unpack_parameters(Dirichlet, θ)
     return digamma.(α) .- digamma(sum(α))
-end
+end

src/distributions/erlang.jl

@@ -60,7 +60,7 @@ end
 getgradlogpartition(::NaturalParametersSpace, ::Type{Erlang}) = (η) -> begin
     (η1, η2) = unpack_parameters(Erlang, η)
     dη1 = digamma(η1 + 1) - log(-η2)
-    dη2 = - (η1 + one(η1))*inv(η2)
+    dη2 = -(η1 + one(η1)) * inv(η2)
     return SA[dη1, dη2]
 end
 

src/distributions/gamma_family/gamma_family.jl

@@ -102,7 +102,7 @@ end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{Gamma}) = (η) -> begin
     (η₁, η₂) = unpack_parameters(Gamma, η)
-    return SA[digamma(η₁ + one(η₁)) - log(-η₂), - (η₁ + one(η₁)) / η₂]
+    return SA[digamma(η₁ + one(η₁))-log(-η₂), -(η₁ + one(η₁))/η₂]
 end
 
 # Mean parametrization
@@ -122,5 +122,5 @@ end
 
 getgradlogpartition(::MeanParametersSpace, ::Type{Gamma}) = (θ) -> begin
     (shape, scale) = unpack_parameters(Gamma, θ)
-    return SA[digamma(shape) - log(scale), - shape / scale]
-end
+    return SA[digamma(shape)-log(scale), -shape/scale]
+end

src/distributions/gamma_inverse.jl

@@ -66,7 +66,7 @@ end
 getgradlogpartition(::NaturalParametersSpace, ::Type{GammaInverse}) = (η) -> begin
     (η₁, η₂) = unpack_parameters(GammaInverse, η)
     dη1 = -digamma(-η₁ - one(η₁)) + log(-η₂)
-    dη2 = - (-η₁ - one(η₁))/η₂
+    dη2 = -(-η₁ - one(η₁)) / η₂
     return SA[dη1, dη2]
 end
 

src/distributions/geometric.jl

@@ -69,4 +69,4 @@ end
 getgradlogpartition(::MeanParametersSpace, ::Type{Geometric}) = (θ) -> begin
     (p,) = unpack_parameters(Geometric, θ)
     return SA[one(p) / (p^2 - p);]
-end
+end

src/distributions/lognormal.jl

@@ -54,9 +54,9 @@ getlogpartition(::NaturalParametersSpace, ::Type{LogNormal}) = (η) -> begin
 end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{LogNormal}) = (η) -> begin
-    (η₁, η₂) = unpack_parameters(LogNormal, η) 
-    dη1 =  -(η₁ + 1)/(2η₂)
-    dη2 = (η₁ + 1)^2/(4η₂^2) - inv(η₂)/2
+    (η₁, η₂) = unpack_parameters(LogNormal, η)
+    dη1 = -(η₁ + 1) / (2η₂)
+    dη2 = (η₁ + 1)^2 / (4η₂^2) - inv(η₂) / 2
     return SA[dη1, dη2]
 end
 
@@ -73,10 +73,10 @@ getlogpartition(::MeanParametersSpace, ::Type{LogNormal}) = (θ) -> begin
     return abs2(μ) / (2abs2(σ)) + log(σ)
 end
 
-getgradlogpartition(::MeanParametersSpace, ::Type{LogNormal}) = (θ) -> begin    
+getgradlogpartition(::MeanParametersSpace, ::Type{LogNormal}) = (θ) -> begin
     (μ, σ) = unpack_parameters(LogNormal, θ)
     dμ = abs(μ) / (abs2(σ))
-    dσ = -abs2(μ) / (σ^3) + 1/σ
+    dσ = -abs2(μ) / (σ^3) + 1 / σ
     return SA[dμ, dσ]
 end
 

src/distributions/matrix_dirichlet.jl

@@ -153,11 +153,11 @@ getlogpartition(::NaturalParametersSpace, ::Type{MatrixDirichlet}) =
         )
     end
 
-getgradlogpartition(::NaturalParametersSpace, ::Type{MatrixDirichlet}) = 
+getgradlogpartition(::NaturalParametersSpace, ::Type{MatrixDirichlet}) =
     (η) -> begin
         (η1,) = unpack_parameters(MatrixDirichlet, η)
         return vmapreduce(
-            d -> getgradlogpartition(NaturalParametersSpace(), Dirichlet)(convert(Vector, d)),vcat,
+            d -> getgradlogpartition(NaturalParametersSpace(), Dirichlet)(convert(Vector, d)), vcat,
             eachcol(η1))
     end
 
@@ -185,11 +185,11 @@ getlogpartition(::MeanParametersSpace, ::Type{MatrixDirichlet}) =
         )
     end
 
-getgradlogpartition(::MeanParametersSpace, ::Type{MatrixDirichlet}) = 
+getgradlogpartition(::MeanParametersSpace, ::Type{MatrixDirichlet}) =
     (θ) -> begin
         (α,) = unpack_parameters(MatrixDirichlet, θ)
         return vmapreduce(
-            d -> getgradlogpartition(NaturalParametersSpace(), Dirichlet)(convert(Vector, d)),vcat,
+            d -> getgradlogpartition(NaturalParametersSpace(), Dirichlet)(convert(Vector, d)), vcat,
             eachcol(α))
     end
 

src/distributions/negative_binomial.jl

@@ -100,7 +100,7 @@ isbasemeasureconstant(::Type{NegativeBinomial}) = NonConstantBaseMeasure()
 
 getbasemeasure(::Type{NegativeBinomial}, conditioner) = (x) -> binomial(Int(x + conditioner - 1), x)
 
-lchoose(a,b) = loggamma(a+1) - loggamma(b+1) - loggamma(a-b+1)
+lchoose(a, b) = loggamma(a + 1) - loggamma(b + 1) - loggamma(a - b + 1)
 
 getlogbasemeasure(::Type{NegativeBinomial}, conditioner) = (x) -> lchoose(Int(x + conditioner - 1), x)
 getsufficientstatistics(::Type{NegativeBinomial}, conditioner) = (identity,)
@@ -110,9 +110,9 @@ getlogpartition(::NaturalParametersSpace, ::Type{NegativeBinomial}, conditioner)
     return -conditioner * log(one(η1) - exp(η1))
 end
 
-getgradlogpartition(::NaturalParametersSpace,::Type{NegativeBinomial}, conditioner) = (η) -> begin
+getgradlogpartition(::NaturalParametersSpace, ::Type{NegativeBinomial}, conditioner) = (η) -> begin
     (η1,) = unpack_parameters(NegativeBinomial, η)
-    return SA[-conditioner*(-exp(η1)/(one(η1)-exp(η1)));]
+    return SA[-conditioner * (-exp(η1) / (one(η1) - exp(η1)));]
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{NegativeBinomial}, r) = (η) -> begin
@@ -127,9 +127,9 @@ getlogpartition(::MeanParametersSpace, ::Type{NegativeBinomial}, conditioner) =
     return -conditioner * log(one(p) - p)
 end
 
-getgradlogpartition(::MeanParametersSpace,::Type{NegativeBinomial}, conditioner) = (θ) -> begin
+getgradlogpartition(::MeanParametersSpace, ::Type{NegativeBinomial}, conditioner) = (θ) -> begin
     (p,) = unpack_parameters(NegativeBinomial, η)
-    return SA[conditioner*inv(one(p) - p);]
+    return SA[conditioner * inv(one(p) - p);]
 end
 
 getfisherinformation(::MeanParametersSpace, ::Type{NegativeBinomial}, r) = (θ) -> begin

src/distributions/normal_family/normal_family.jl

@@ -399,15 +399,15 @@ function Base.isapprox(left::UnivariateNormalDistributionsFamily, right::Univari
     return all(p -> isapprox(p[1], p[2]; kwargs...), zip(mean_var(left), mean_var(right)))
 end
 
-function Base.isapprox(left::D, right::D; kwargs...) where { D <: UnivariateNormalDistributionsFamily }
+function Base.isapprox(left::D, right::D; kwargs...) where {D <: UnivariateNormalDistributionsFamily}
     return all(p -> isapprox(p[1], p[2]; kwargs...), zip(params(left), params(right)))
 end
 
 function Base.isapprox(left::MultivariateNormalDistributionsFamily, right::MultivariateNormalDistributionsFamily; kwargs...)
     return all(p -> isapprox(p[1], p[2]; kwargs...), zip(mean_cov(left), mean_cov(right)))
 end
 
-function Base.isapprox(left::D, right::D; kwargs...) where { D <: MultivariateNormalDistributionsFamily }
+function Base.isapprox(left::D, right::D; kwargs...) where {D <: MultivariateNormalDistributionsFamily}
     return all(p -> isapprox(p[1], p[2]; kwargs...), zip(params(left), params(right)))
 end
 
@@ -586,7 +586,7 @@ end
 getgradlogpartition(::NaturalParametersSpace, ::Type{NormalMeanVariance}) =
     (η) -> begin
         (η₁, η₂) = unpack_parameters(NormalMeanVariance, η)
-        return SA[-η₁ * inv(η₂*2), abs2(η₁) / ( 4 * abs2(η₂)) - 1 / (2 * η₂)]
+        return SA[-η₁*inv(η₂ * 2), abs2(η₁)/(4*abs2(η₂))-1/(2*η₂)]
     end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{NormalMeanVariance}) =
@@ -608,7 +608,7 @@ end
 getgradlogpartition(::MeanParametersSpace, ::Type{NormalMeanVariance}) =
     (θ) -> begin
         (μ, σ²) = unpack_parameters(NormalMeanVariance, θ)
-        return SA[μ / σ², - abs2(μ) / (2σ²^2) + 1 / σ²]
+        return SA[μ/σ², -abs2(μ)/(2σ²^2)+1/σ²]
     end
 
 getfisherinformation(::MeanParametersSpace, ::Type{NormalMeanVariance}) = (θ) -> begin

src/distributions/normal_gamma.jl

@@ -103,7 +103,8 @@ BayesBase.support(::Type{NormalGamma}) = NormalGammaDomain()
 
 # Natural parametrization
 isproper(::NaturalParametersSpace, ::Type{NormalGamma}, η, conditioner) =
-    isnothing(conditioner) && length(η) === 4 && getindex(η, 2) < 0 && getindex(η, 3) > -1 / 2 &&  getindex(η, 1)^2/(4*getindex(η,2))  - getindex(η, 4) > 0 && all(!isinf, η) && all(!isnan, η)
+    isnothing(conditioner) && length(η) === 4 && getindex(η, 2) < 0 && getindex(η, 3) > -1 / 2 &&
+    getindex(η, 1)^2 / (4 * getindex(η, 2)) - getindex(η, 4) > 0 && all(!isinf, η) && all(!isnan, η)
 isproper(::MeanParametersSpace, ::Type{NormalGamma}, θ, conditioner) =
     isnothing(conditioner) && length(θ) === 4 && all(>(0), getindex(θ, 2:4)) && all(!isinf, θ) && all(!isnan, θ)
 
@@ -143,15 +144,15 @@ getlogpartition(::NaturalParametersSpace, ::Type{NormalGamma}) = (η) -> begin
     return loggamma(η3half) - log(-2η2) * (1 / 2) - (η3half) * log(-η4 + η1^2 / (4η2))
 end
 
-getgradlogpartition(::NaturalParametersSpace,::Type{NormalGamma}) = (η) -> begin  
+getgradlogpartition(::NaturalParametersSpace, ::Type{NormalGamma}) = (η) -> begin
     (η1, η2, η3, η4) = unpack_parameters(NormalGamma, η)
     η3half = η3 + (1 / 2)
-    c   = (-η4 + η1^2/(4η2))
-    dη1 = -η3half*((η1/(2η2)) / c) 
-    dη2 = -inv(η2)/2 - η3half*(-η1^2/(4η2^2) / c)
+    c = (-η4 + η1^2 / (4η2))
+    dη1 = -η3half * ((η1 / (2η2)) / c)
+    dη2 = -inv(η2) / 2 - η3half * (-η1^2 / (4η2^2) / c)
     dη3 = digamma(η3half) - log(c)
-    dη4 = η3half /c
-    
+    dη4 = η3half / c
+
     return SA[dη1, dη2, dη3, dη4]
 end
 

src/distributions/pareto.jl

@@ -151,7 +151,7 @@ end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{Pareto}, conditioner) = (η) -> begin
     (η1,) = unpack_parameters(Pareto, η)
-    return SA[log(conditioner) - one(η1)/(one(η1)+η1);]
+    return SA[log(conditioner) - one(η1) / (one(η1) + η1);]
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{Pareto}, _) = (η) -> begin

src/distributions/rayleigh.jl

@@ -57,7 +57,7 @@ getlogpartition(::NaturalParametersSpace, ::Type{Rayleigh}) = (η) -> begin
 end
 
 getgradlogpartition(::NaturalParametersSpace, ::Type{Rayleigh}) = (η) -> begin
-    (η1, ) = unpack_parameters(Rayleigh, η)
+    (η1,) = unpack_parameters(Rayleigh, η)
     return SA[-inv(η1);]
 end
 
@@ -75,7 +75,7 @@ end
 
 getgradlogpartition(::MeanParametersSpace, ::Type{Rayleigh}) = (θ) -> begin
     (σ,) = unpack_parameters(Rayleigh, θ)
-    return SA[2/σ;]
+    return SA[2 / σ;]
 end
 
 getfisherinformation(::MeanParametersSpace, ::Type{Rayleigh}) = (θ) -> begin

src/distributions/von_mises.jl

@@ -18,7 +18,7 @@ function BayesBase.prod(::PreserveTypeProd{Distribution}, left::VonMises, right:
 
     phase = ((μleft - asin(sin(μleft))) + (μright - asin(sin(μright)))) / pi
 
-    return VonMises(α+ π*phase, R)
+    return VonMises(α + π * phase, R)
 end
 
 function BayesBase.prod(
@@ -30,9 +30,8 @@ function BayesBase.prod(
     conditionerright = getconditioner(right)
     ηleft = getnaturalparameters(left)
     ηright = getnaturalparameters(right)
-
-    return ExponentialFamilyDistribution(VonMises,ηright + ηleft , conditionerleft + conditionerright, nothing)
-
+
+    return ExponentialFamilyDistribution(VonMises, ηright + ηleft, conditionerleft + conditionerright, nothing)
 end
 
 BayesBase.insupport(ef::ExponentialFamilyDistribution{T}, value) where {T <: VonMises} = insupport(convert(Distribution, ef), value)
@@ -77,7 +76,7 @@ getsufficientstatistics(::Type{VonMises}, _) = (cos, sin)
 getgradlogpartition(::NaturalParametersSpace, ::Type{VonMises}, _) = (η) -> begin
     u = sqrt(dot(η, η))
     same_part = besseli(1, u) / (u * besseli(0, u))
-    return SA[η[1] * same_part, η[2] * same_part]
+    return SA[η[1]*same_part, η[2]*same_part]
 end
 getlogpartition(::NaturalParametersSpace, ::Type{VonMises}, _) = (η) -> begin
     return log(besseli(0, sqrt(dot(η, η))))

src/distributions/von_mises_fisher.jl

@@ -83,10 +83,10 @@ end
 getgradlogpartition(::NaturalParametersSpace, ::Type{VonMisesFisher}) = (η) -> begin
     κ = sqrt(dot(η, η))
     p = length(η)
-    term1 = - ((p / 2) - 1) / κ
-    term2 = ((p / 2) - 1)/κ  +  besseli((p / 2), κ)/besseli((p / 2) - 1, κ)
-    term3 = (term1 + term2)/(κ)
-    return term3*η
+    term1 = -((p / 2) - 1) / κ
+    term2 = ((p / 2) - 1) / κ + besseli((p / 2), κ) / besseli((p / 2) - 1, κ)
+    term3 = (term1 + term2) / (κ)
+    return term3 * η
 end
 
 getfisherinformation(::NaturalParametersSpace, ::Type{VonMisesFisher}) = (η) -> begin