fix format

src/bayesian.jl

@@ -5,19 +5,32 @@ struct PolyaGammaSample
     PolyaGammaSample(i_idx, e_idx, val) = new(i_idx, e_idx, val)
 end
 
+"""
+    posterior(
+        item::AbstractItem,
+        examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
+        responses::Vector{<:AbstractResponse}, #only responses of item sorted by e.idx
+        W::Vector{PolyaGammaSample}, #sorted by e.idx
+    )
+
+"""
 function posterior(
     item::AbstractItem,
     examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
-    responses::Vector{ResponseBinary}, #only responses of item sorted by e.idx
+    responses::Vector{<:AbstractResponse}, #only responses of item sorted by e.idx
     W::Vector{PolyaGammaSample}, #sorted by e.idx
 )
-    return posterior(item.parameters,
-        map(e -> e.latent, examinees),
-        responses,
-        W,
-    )
+    return posterior(item.parameters, map(e -> e.latent, examinees), responses, W)
 end
 
+"""
+    update_posterior!(
+        item::AbstractItem,
+        examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
+        responses::Vector{<:AbstractResponse}, #only responses of item sorted by e.idx
+        W::Vector{PolyaGammaSample}, #sorted by e.idx
+    )
+"""
 function update_posterior!(
     item::AbstractItem,
     examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
@@ -27,17 +40,21 @@ function update_posterior!(
     item.parameters.posterior = posterior(item, examinees, responses, W)
 end
 
+"""
+    posterior(
+        examinee::AbstractExaminee,
+        items::Vector{<:AbstractItem}, #only items answered by examinee sorted by i.idx
+        responses::Vector{<:AbstractResponse}, #only responses of examinee sorted by i.idx
+        W::Vector{PolyaGammaSample},
+    )
+"""
 function posterior(
     examinee::AbstractExaminee,
     items::Vector{<:AbstractItem}, #only items answered by examinee sorted by i.idx
     responses::Vector{<:AbstractResponse}, #only responses of examinee sorted by i.idx
     W::Vector{PolyaGammaSample},
 )
-    return posterior(examinee.latent,
-        map(i -> i.parameters, items),
-        responses,
-        W,
-    )
+    return posterior(examinee.latent, map(i -> i.parameters, items), responses, W)
 end
 
 function posterior(
@@ -52,10 +69,9 @@ function posterior(
     mu =
         sigma2 * (
             mapreduce(
-                (i, w, r) ->
-                    i.a * (i.a * i.b * w.val +
-                     #(get_responses_by_item_id(i.id, responses_e)[1].val - 0.5)
-                     (r.val - 0.5)),
+                (i, w, r) -> i.a * (i.a * i.b * w.val +
+                                    #(get_responses_by_item_id(i.id, responses_e)[1].val - 0.5)
+                                    (r.val - 0.5)),
                 +,
                 parameters,
                 W,
@@ -65,6 +81,14 @@ function posterior(
     return Distributions.Normal(mu, sqrt(sigma2))::Distributions.ContinuousDistribution
 end
 
+"""
+    update_posterior!(
+        examinee::AbstractExaminee,
+        items::Vector{<:AbstractItem}, #only items answered by examinee sorted by i.idx
+        responses::Vector{<:AbstractResponse}, #only responses of examinee sorted by i.idx
+        W::Vector{PolyaGammaSample},
+    )
+"""
 function update_posterior!(
     examinee::AbstractExaminee,
     items::Vector{<:AbstractItem}, #only items answered by examinee sorted by i.idx
@@ -77,15 +101,14 @@ end
 function posterior(
     latent::Latent1D,
     parameters::Parameters2PL,
+    response::ResponseBinary,
     w::PolyaGammaSample,
-    r::ResponseBinary
-    )
+)
     sigma2 = (parameters.a^2) * w.val
     sigma2 = 1 / (sigma2 + (1 / Distributions.var(latent.prior)))
     mu =
         sigma2 * (
-            parameters.a *
-            (parameters.a * parameters.b * w.val + (r.val - 0.5)) +
+            parameters.a * (parameters.a * parameters.b * w.val + (response.val - 0.5)) +
             (latent.prior.μ / Distributions.var(latent.prior))
         )
     return Distributions.Normal(mu, sqrt(sigma2))
@@ -96,34 +119,29 @@ end
     posterior(
         examinee::AbstractExaminee,
         item::AbstractItem,
+        response::ResponseBinary,
         w::PolyaGammaSample,
-        r::ResponseBinary
         )
 """
 function posterior(
     examinee::AbstractExaminee,
     item::AbstractItem,
+    response::ResponseBinary,
     w::PolyaGammaSample,
-    r::ResponseBinary
-    )
-    return posterior(
-        examinee.latent,
-        item.parameters,
-        w,
-        r
-        )
+)
+    return posterior(examinee.latent, item.parameters, response, w)
 end
 
 function posterior(
-    parameters::Parameters2PL, 
-    latent::Latent1D, 
+    parameters::Parameters2PL,
+    latent::Latent1D,
+    response::ResponseBinary,
     w::PolyaGammaSample,
-    r::ResponseBinary
-    )
+)
     a = parameters.a
     b = parameters.b
     latent_val = latent.val
-    r_val = r.val
+    r_val = response.val
     w_val = w.val
 
     sigma2 = [(latent_val - b)^2 * w.val, a^2 * w_val]
@@ -143,16 +161,12 @@ function posterior(
 end
 
 function posterior(
-    item::AbstractItem, 
-    examinee::AbstractExaminee, 
+    item::AbstractItem,
+    examinee::AbstractExaminee,
+    response::AbstractResponse,
     w::PolyaGammaSample,
-    r::ResponseBinary
-    )
-    return posterior(item.parameters,
-    examinee.latent,
-    w,
-    r,
-    )
+)
+    return posterior(item.parameters, examinee.latent, response, w)
 end
 
 
@@ -169,13 +183,10 @@ function posterior(
     sigma2 = mapreduce((e, w) -> [(e.val - b)^2, a^2] .* w.val, +, latents, W)
     sigma2 = 1 ./ (sigma2 + (1 ./ Distributions.var.(prior)))
     mu = mapreduce(
-        (e, w, r) -> [
-            (e.val - b) * (r.val - 0.5),
-            -a * (
-                #(get_responses_by_examinee_id(e.id, responses)[1].val - 0.5) -
-                (r.val - 0.5) - (a * e.val * w.val)
-            ),
-        ],
+        (e, w, r) -> [(e.val - b) * (r.val - 0.5), -a * (
+            #(get_responses_by_examinee_id(e.id, responses)[1].val - 0.5) -
+            (r.val - 0.5) - (a * e.val * w.val)
+        )],
         +,
         latents,
         W,
@@ -189,29 +200,6 @@ function posterior(
 end
 
 
-"""
-    posterior(
-        item::AbstractItem,
-        examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
-        responses::Vector{ResponseBinary}, #only responses of item sorted by e.idx
-        W::Vector{PolyaGammaSample}, #sorted by e.idx
-    )
-
-"""
-function posterior(
-    item::AbstractItem,
-    examinees::Vector{<:AbstractExaminee}, #must be sorted by e.idx
-    responses::Vector{ResponseBinary}, #only responses of item sorted by e.idx
-    W::Vector{PolyaGammaSample}, #sorted by e.idx
-)
-    return posterior(item.parameters,
-        map(e -> e.latent, examinees),
-        responses,
-        W,
-    )
-end
-
-
 function generate_w(examinee::AbstractExaminee, items::Vector{<:AbstractItem})
     return map(
         i -> PolyaGammaSample(
@@ -227,31 +215,23 @@ function generate_w(examinee::AbstractExaminee, items::Vector{<:AbstractItem})
 end
 
 function generate_w(parameters::Parameters2PL, latent::Latent1D)
-    return Distributions.rand(PolyaGamma(
-                1,
-                parameters.a * (latent.val - parameters.b),
-            ))
+    return Distributions.rand(PolyaGamma(1, parameters.a * (latent.val - parameters.b)))
 end
 
 function generate_w(item::AbstractItem, examinees::Vector{<:AbstractExaminee})
     return map(
-        e -> PolyaGammaSample(
-            item.idx,
-            e.idx,
-            generate_w(item.parameters, e.latent)
-        ),
+        e -> PolyaGammaSample(item.idx, e.idx, generate_w(item.parameters, e.latent)),
         examinees,
     )
 end
 
-function generate_w(items::Vector{<:AbstractItem}, examinees_i::Vector{Vector{<:AbstractExaminee}})
+function generate_w(
+    items::Vector{<:AbstractItem},
+    examinees_i::Vector{Vector{<:AbstractExaminee}},
+)
     return mapreduce(
         i -> map(
-            e -> PolyaGammaSample(
-                i.idx,
-                e.idx,
-                generate_w(i.parameters, e.latent)
-            ),
+            e -> PolyaGammaSample(i.idx, e.idx, generate_w(i.parameters, e.latent)),
             examinees_i[i.idx],
         ),
         vcat,
@@ -316,7 +296,7 @@ function mcmc_iter!(
 end
 
 function mcmc_iter!(
-    examinee:: AbstractExaminee,
+    examinee::AbstractExaminee,
     items::Vector{<:AbstractItem},
     responses::Vector{<:AbstractResponse},
     W::Vector{PolyaGammaSample};

src/calibration/PolyaGamma_MCMC.jl

@@ -43,4 +43,4 @@ function estimate_ability!(
         mcmc_iter!(examinee, items, responses, W; sampling = sampling)
     end
     update_estimate!(examinee; sampling = sampling)
-end
+end

src/examinee/latent/1D.jl

@@ -82,8 +82,10 @@ end
 function update_estimate!(latent::Latent1D; sampling = true)
     chain_size = size(latent.chain, 1)
     if sampling
-        latent.val = sum(latent.chain[(chain_size - min(999, chain_size - 1)) : end]) / min(1000, chain_size)
+        latent.val =
+            sum(latent.chain[(chain_size-min(999, chain_size - 1)):end]) /
+            min(1000, chain_size)
     else
         latent.val = sum(latent.chain) / chain_size
     end
-end
+end

src/examinee/latent/ND.jl

@@ -27,13 +27,13 @@ LatentND(dist, bounds)
 Randomly generates a value for the N-dimensional latent variable and assigns a custom multivariate distribution to prior and posterior with specific bounds.
 """
 mutable struct LatentND <: AbstractLatent
-names::Vector{String}
-val::Vector{Float64}
-bounds::Vector{Vector{Float64}}
-prior::Distributions.MultivariateDistribution
-posterior::Distributions.MultivariateDistribution
-chain::Vector{Vector{Float64}}
-expected_information::Matrix{Float64}
+    names::Vector{String}
+    val::Vector{Float64}
+    bounds::Vector{Vector{Float64}}
+    prior::Distributions.MultivariateDistribution
+    posterior::Distributions.MultivariateDistribution
+    chain::Vector{Vector{Float64}}
+    expected_information::Matrix{Float64}
 
     function LatentND(names, val, bounds, prior, posterior, chain, expected_information)
         new(names, val, bounds, prior, posterior, chain, expected_information)
@@ -49,4 +49,4 @@ expected_information::Matrix{Float64}
         val = truncate_rand(dist, bounds)
         new(string.("L_", collect(1:N)), val, bounds, dist, dist, [val], LinearAlgebra.I(N))
     end
-end
+end

src/item/parameters/binary/1pl.jl

@@ -32,5 +32,5 @@ end
 
 """
 function empty_chain!(parameters::Parameters1PL)
-    parameters.chain = Vector{Float64}(undef,0)
-end
+    parameters.chain = Vector{Float64}(undef, 0)
+end

src/item/parameters/binary/2pl.jl

@@ -75,7 +75,7 @@ end
 
 """
 function empty_chain!(parameters::Parameters2PL)
-    parameters.chain = Vector{Vector{Float64}}(undef,0)
+    parameters.chain = Vector{Vector{Float64}}(undef, 0)
 end
 
 """
@@ -99,13 +99,13 @@ end
 """
 function update_estimate!(parameters::Parameters2PL; sampling = true)
     chain_size = size(parameters.chain, 1)
-    if sampling 
-        chain_matrix = hcat(parameters.chain[(chain_size - min(999, chain_size - 1)) : end]...)
+    if sampling
+        chain_matrix = hcat(parameters.chain[(chain_size-min(999, chain_size - 1)):end]...)
         vals = [sum(i) / min(1000, chain_size) for i in eachrow(chain_matrix)]
     else
         chain_matrix = hcat(parameters.chain...)
-        vals = [sum(i) / chain_size for i in eachrow(chain_matrix)]   
+        vals = [sum(i) / chain_size for i in eachrow(chain_matrix)]
     end
     parameters.a = vals[1]
     parameters.b = vals[2]
-end
+end

src/item/parameters/binary/3pl.jl

@@ -86,5 +86,5 @@ end
 
 """
 function empty_chain!(parameters::Parameters3PL)
-    parameters.chain = Vector{Vector{Float64}}(undef,0)
-end
+    parameters.chain = Vector{Vector{Float64}}(undef, 0)
+end

src/item/parameters/binary/binary.jl

@@ -3,4 +3,4 @@ abstract type AbstractParametersBinary <: AbstractParameters end
 include("1pl.jl")
 include("2pl.jl")
 include("3pl.jl")
-include("Npl.jl")
+include("Npl.jl")

src/likelihood.jl

@@ -147,7 +147,11 @@ end
 
 It computes the likelihood for a 1-dimensional latent variable and item parameters `parameters` with answer `response_val`.
 """
-function likelihood(response_val::Float64, latent::Latent1D, parameters::AbstractParametersBinary)
+function likelihood(
+    response_val::Float64,
+    latent::Latent1D,
+    parameters::AbstractParametersBinary,
+)
     return likelihood(response_val, latent.val, parameters)
 end
 

src/online/design/A.jl

@@ -27,4 +27,4 @@ It returns a `Float64` scalar.
 """
 function A_method(item::AbstractItem, examinee::AbstractExaminee)
     return A_method(item.parameters, examinee.latent)
-end
+end