rename n_man() -> nobserved_vars()

for missing data pattern: nobserved_vars() -> nmeasured_vars(),
obs_cov/obs_mean -> measured_cov/measured_mean

Author: alyst

src/StructuralEquationModels.jl

@@ -84,7 +84,6 @@ include("frontend/fit/fitmeasures/df.jl")
 include("frontend/fit/fitmeasures/minus2ll.jl")
 include("frontend/fit/fitmeasures/p.jl")
 include("frontend/fit/fitmeasures/RMSEA.jl")
-include("frontend/fit/fitmeasures/n_man.jl")
 include("frontend/fit/fitmeasures/fit_measures.jl")
 # standard errors
 include("frontend/fit/standard_errors/hessian.jl")
@@ -167,7 +166,6 @@ export AbstractSem,
     nsamples,
     p_value,
     RMSEA,
-    n_man,
     EmMVNModel,
     se_hessian,
     se_bootstrap,

src/frontend/fit/fitmeasures/chi2.jl

@@ -20,7 +20,8 @@ function χ² end
 
 # RAM + SemML
 χ²(sem_fit::SemFit, observed, imp::Union{RAM, RAMSymbolic}, optimizer, loss_ml::SemML) =
-    (nsamples(sem_fit) - 1) * (sem_fit.minimum - logdet(observed.obs_cov) - observed.n_man)
+    (nsamples(sem_fit) - 1) *
+    (sem_fit.minimum - logdet(observed.obs_cov) - nobserved_vars(observed))
 
 # bollen, p. 115, only correct for GLS weight matrix
 χ²(sem_fit::SemFit, observed, imp::Union{RAM, RAMSymbolic}, optimizer, loss_ml::SemWLS) =
@@ -53,7 +54,7 @@ function χ²(sem_fit::SemFit, model::SemEnsemble, lossfun::L) where {L <: SemML
     check_lossfun_types(model, L)
     F_G = sem_fit.minimum
     F_G -= sum([
-        w * (logdet(m.observed.obs_cov) + m.observed.n_man) for
+        w * (logdet(m.observed.obs_cov) + nobserved_vars(m.observed)) for
         (w, m) in zip(model.weights, model.sems)
     ])
     return (nsamples(model) - 1) * F_G

src/frontend/fit/fitmeasures/df.jl

@@ -11,10 +11,10 @@ df(sem_fit::SemFit) = df(sem_fit.model)
 df(model::AbstractSem) = n_dp(model) - nparams(model)
 
 function n_dp(model::AbstractSemSingle)
-    nman = n_man(model)
-    ndp = 0.5(nman^2 + nman)
+    nvars = nobserved_vars(model)
+    ndp = 0.5(nvars^2 + nvars)
     if !isnothing(model.imply.μ)
-        ndp += n_man(model)
+        ndp += nvars
     end
     return ndp
 end

src/frontend/fit/fitmeasures/minus2ll.jl

@@ -25,7 +25,7 @@ minus2ll(sem_fit::SemFit, obs, imp, optimizer, args...) =
 
 # SemML ------------------------------------------------------------------------------------
 minus2ll(minimum::Number, obs, imp::Union{RAM, RAMSymbolic}, optimizer, loss_ml::SemML) =
-    nsamples(obs) * (minimum + log(2π) * n_man(obs))
+    nsamples(obs) * (minimum + log(2π) * nobserved_vars(obs))
 
 # WLS --------------------------------------------------------------------------------------
 minus2ll(minimum::Number, obs, imp::Union{RAM, RAMSymbolic}, optimizer, loss_ml::SemWLS) =
@@ -42,7 +42,7 @@ function minus2ll(
 )
     F = minimum
     F *= nsamples(observed)
-    F += sum(log(2π) * observed.pattern_nsamples .* observed.pattern_nvar_obs)
+    F += sum(log(2π) * observed.pattern_nsamples .* observed.pattern_nobs_vars)
     return F
 end
 
@@ -59,7 +59,7 @@ function minus2ll(observed::SemObservedMissing)
             observed.obs_mean,
             observed.obs_cov,
             observed.pattern_nsamples,
-            observed.pattern_nvar_obs,
+            observed.pattern_nobs_vars,
         )
     else
         em_mvn(observed)
@@ -72,7 +72,7 @@ function minus2ll(observed::SemObservedMissing)
             observed.obs_mean,
             observed.obs_cov,
             observed.pattern_nsamples,
-            observed.pattern_nvar_obs,
+            observed.pattern_nobs_vars,
         )
     end
 end
@@ -86,7 +86,7 @@ function minus2ll(
     obs_mean,
     obs_cov,
     pattern_nsamples,
-    pattern_nvar_obs,
+    pattern_nobs_vars,
 )
     F = 0.0
 
@@ -106,7 +106,7 @@ function minus2ll(
         F += F_one_pattern(meandiffᵢ, Σᵢ⁻¹, Sᵢ, ld, nᵢ)
     end
 
-    F += sum(log(2π) * pattern_nsamples .* pattern_nvar_obs)
+    F += sum(log(2π) * pattern_nsamples .* pattern_nobs_vars)
     #F *= N
 
     return F

src/frontend/fit/fitmeasures/n_man.jl

@@ -111,7 +111,7 @@ function RAM(;
     n_obs = nobserved_vars(ram_matrices)
     n_var = nvars(ram_matrices)
     F = zeros(ram_matrices.size_F)
-    F[CartesianIndex.(1:n_var, ram_matrices.F_ind)] .= 1.0
+    F[CartesianIndex.(1:n_obs, ram_matrices.F_ind)] .= 1.0
 
     # get indices
     A_indices = copy(ram_matrices.A_ind)
@@ -146,7 +146,7 @@ function RAM(;
         has_meanstructure = Val(true)
         !isnothing(M_indices) || throw(ArgumentError("You set `meanstructure = true`, but your model specification contains no mean parameters."))
         ∇M = gradient ? matrix_gradient(M_indices, n_var) : nothing
-        μ = zeros(n_var)
+        μ = zeros(n_obs)
     else
         has_meanstructure = Val(false)
         M_indices = nothing
@@ -257,7 +257,7 @@ objective_gradient_hessian!(imply::RAM, par, model::AbstractSemSingle, has_means
 ############################################################################################
 
 function update_observed(imply::RAM, observed::SemObserved; kwargs...)
-    if n_man(observed) == size(imply.Σ, 1)
+    if nobserved_vars(observed) == size(imply.Σ, 1)
         return imply
     else
         return RAM(; observed = observed, kwargs...)

src/imply/RAM/generic.jl

@@ -236,7 +236,7 @@ objective_gradient_hessian!(imply::RAMSymbolic, par, model) = gradient!(imply, p
 ############################################################################################
 
 function update_observed(imply::RAMSymbolic, observed::SemObserved; kwargs...)
-    if n_man(observed) == size(imply.Σ, 1)
+    if nobserved_vars(observed) == size(imply.Σ, 1)
         return imply
     else
         return RAMSymbolic(; observed = observed, kwargs...)

src/imply/RAM/symbolic.jl

@@ -47,20 +47,20 @@ end
 ############################################################################################
 
 function SemFIML(; observed, specification, kwargs...)
-    inverses = broadcast(x -> zeros(x, x), Int64.(pattern_nvar_obs(observed)))
+    inverses = broadcast(x -> zeros(x, x), pattern_nobs_vars(observed))
     choleskys = Array{Cholesky{Float64, Array{Float64, 2}}, 1}(undef, length(inverses))
 
     n_patterns = size(rows(observed), 1)
     logdets = zeros(n_patterns)
 
-    imp_mean = zeros.(Int64.(pattern_nvar_obs(observed)))
-    meandiff = zeros.(Int64.(pattern_nvar_obs(observed)))
+    imp_mean = zeros.(pattern_nobs_vars(observed))
+    meandiff = zeros.(pattern_nobs_vars(observed))
 
-    nman = Int64(n_man(observed))
-    imp_inv = zeros(nman, nman)
+    nobs_vars = nobserved_vars(observed)
+    imp_inv = zeros(nobs_vars, nobs_vars)
     mult = similar.(inverses)
 
-    ∇ind = vec(CartesianIndices(Array{Float64}(undef, nman, nman)))
+    ∇ind = vec(CartesianIndices(Array{Float64}(undef, nobs_vars, nobs_vars)))
     ∇ind =
         [findall(x -> !(x[1] ∈ ind || x[2] ∈ ind), ∇ind) for ind in patterns_not(observed)]
 
@@ -189,8 +189,8 @@ function F_FIML(rows, semfiml, model, params)
 end
 
 function ∇F_FIML(rows, semfiml, model)
-    Jμ = zeros(Int64(n_man(model)))
-    JΣ = zeros(Int64(n_man(model)^2))
+    Jμ = zeros(nobserved_vars(model))
+    JΣ = zeros(nobserved_vars(model)^2)
 
     for i in 1:size(rows, 1)
         ∇F_one_pattern(

src/loss/ML/FIML.jl

@@ -64,7 +64,7 @@ function SemWLS(;
 
     # compute V here
     if isnothing(wls_weight_matrix)
-        D = duplication_matrix(n_man(observed))
+        D = duplication_matrix(nobserved_vars(observed))
         S = inv(obs_cov(observed))
         S = kron(S, S)
         wls_weight_matrix = 0.5 * (D' * S * D)

src/loss/WLS/WLS.jl

@@ -29,15 +29,15 @@ function em_mvn(
     rtol_em = 1e-4,
     kwargs...,
 )
-    n_man = observed.n_man
+    nvars = nobserved_vars(observed)
     nsamps = nsamples(observed)
 
     # preallocate stuff?
-    𝔼x_pre = zeros(n_man)
-    𝔼xxᵀ_pre = zeros(n_man, n_man)
+    𝔼x_pre = zeros(nvars)
+    𝔼xxᵀ_pre = zeros(nvars, nvars)
 
     ### precompute for full cases
-    if length(observed.patterns[1]) == observed.n_man
+    if length(observed.patterns[1]) == nvars
         for row in observed.rows[1]
             row = observed.data_rowwise[row]
             𝔼x_pre += row
@@ -50,11 +50,11 @@ function em_mvn(
 
     # initialize
     em_model = start_em(observed; kwargs...)
-    em_model_prev = EmMVNModel(zeros(n_man, n_man), zeros(n_man), false)
+    em_model_prev = EmMVNModel(zeros(nvars, nvars), zeros(nvars), false)
     iter = 1
     done = false
-    𝔼x = zeros(n_man)
-    𝔼xxᵀ = zeros(n_man, n_man)
+    𝔼x = zeros(nvars)
+    𝔼xxᵀ = zeros(nvars, nvars)
 
     while !done
         em_mvn_Estep!(𝔼x, 𝔼xxᵀ, em_model, observed, 𝔼x_pre, 𝔼xxᵀ_pre)
@@ -153,7 +153,7 @@ end
 
 # use μ and Σ of full cases
 function start_em_observed(observed::SemObservedMissing; kwargs...)
-    if (length(observed.patterns[1]) == observed.n_man) & (observed.pattern_nsamples[1] > 1)
+    if (length(observed.patterns[1]) == nobserved_vars(observed)) & (observed.pattern_nsamples[1] > 1)
         μ = copy(observed.obs_mean[1])
         Σ = copy(Symmetric(observed.obs_cov[1]))
         if !isposdef(Σ)
@@ -167,11 +167,11 @@ end
 
 # use μ = O and Σ = I
 function start_em_simple(observed::SemObservedMissing; kwargs...)
-    n_man = Int(observed.n_man)
-    μ = zeros(n_man)
-    Σ = rand(n_man, n_man)
+    nvars = nobserved_vars(observed)
+    μ = zeros(nvars)
+    Σ = rand(nvars, nvars)
     Σ = Σ * Σ'
-    # Σ = Matrix(1.0I, n_man, n_man)
+    # Σ = Matrix(1.0I, nvars, nvars)
     return EmMVNModel(Σ, μ, false)
 end