n_par() -> nparams()

Alexey Stukalov · alyst · commit a569d0e718f8 · 2024-05-03T19:42:31.000-07:00
for clarity and aligning to Julia naming conventions
diff --git a/docs/src/developer/imply.md b/docs/src/developer/imply.md
@@ -30,10 +30,10 @@ To make stored computations available to loss functions, simply write a function
 
 Additionally, you can specify methods for `gradient` and `hessian` as well as the combinations described in [Custom loss functions](@ref).
 
-The last thing nedded to make it work is a method for `n_par` that takes your imply type and returns the number of parameters of the model:
+The last thing nedded to make it work is a method for `nparams` that takes your imply type and returns the number of parameters of the model:
 
 ```julia
-n_par(imply::MyImply) = ...
+nparams(imply::MyImply) = ...
 ```
 
 Just as described in [Custom loss functions](@ref), you may define a constructor. Typically, this will depend on the `specification = ...` argument that can be a `ParameterTable` or a `RAMMatrices` object.
diff --git a/src/StructuralEquationModels.jl b/src/StructuralEquationModels.jl
@@ -150,14 +150,14 @@ export AbstractSem,
     sort_vars,
     RAMMatrices,
     params,
+    nparams,
     fit_measures,
     AIC,
     BIC,
     χ²,
     df,
     fit_measures,
     minus2ll,
-    n_par,
     n_obs,
     p_value,
     RMSEA,
diff --git a/src/additional_functions/simulation.jl b/src/additional_functions/simulation.jl
@@ -73,7 +73,7 @@ function swap_observed(
     # update imply
     imply = update_observed(imply, new_observed; kwargs...)
     kwargs[:imply] = imply
-    kwargs[:n_par] = n_par(imply)
+    kwargs[:nparams] = nparams(imply)
 
     # update loss
     loss = update_observed(loss, new_observed; kwargs...)
diff --git a/src/frontend/fit/SemFit.jl b/src/frontend/fit/SemFit.jl
@@ -47,7 +47,7 @@ end
 ############################################################################################
 
 params(fit::SemFit) = params(fit.model)
-n_par(fit::SemFit) = n_par(fit.model)
+nparams(fit::SemFit) = nparams(fit.model)
 
 # access fields
 minimum(sem_fit::SemFit) = sem_fit.minimum
diff --git a/src/frontend/fit/fitmeasures/AIC.jl b/src/frontend/fit/fitmeasures/AIC.jl
@@ -3,4 +3,4 @@
 
 Return the akaike information criterion.
 """
-AIC(sem_fit::SemFit) = minus2ll(sem_fit) + 2n_par(sem_fit)
+AIC(sem_fit::SemFit) = minus2ll(sem_fit) + 2nparams(sem_fit)
diff --git a/src/frontend/fit/fitmeasures/BIC.jl b/src/frontend/fit/fitmeasures/BIC.jl
@@ -3,4 +3,4 @@
 
 Return the bayesian information criterion.
 """
-BIC(sem_fit::SemFit) = minus2ll(sem_fit) + log(n_obs(sem_fit)) * n_par(sem_fit)
+BIC(sem_fit::SemFit) = minus2ll(sem_fit) + log(n_obs(sem_fit)) * nparams(sem_fit)
diff --git a/src/frontend/fit/fitmeasures/df.jl b/src/frontend/fit/fitmeasures/df.jl
@@ -8,7 +8,7 @@ function df end
 
 df(sem_fit::SemFit) = df(sem_fit.model)
 
-df(model::AbstractSem) = n_dp(model) - n_par(model)
+df(model::AbstractSem) = n_dp(model) - nparams(model)
 
 function n_dp(model::AbstractSemSingle)
     nman = n_man(model)
diff --git a/src/frontend/fit/fitmeasures/fit_measures.jl b/src/frontend/fit/fitmeasures/fit_measures.jl
@@ -1,5 +1,5 @@
 fit_measures(sem_fit) =
-    fit_measures(sem_fit, n_par, df, AIC, BIC, RMSEA, χ², p_value, minus2ll)
+    fit_measures(sem_fit, nparams, df, AIC, BIC, RMSEA, χ², p_value, minus2ll)
 
 function fit_measures(sem_fit, args...)
     measures = Dict{Symbol, Union{Float64, Missing}}()
diff --git a/src/frontend/fit/summary.jl b/src/frontend/fit/summary.jl
@@ -16,7 +16,7 @@ function sem_summary(
     println("Convergence:                 $(convergence(sem_fit))")
     println("No. iterations/evaluations:  $(n_iterations(sem_fit))")
     print("\n")
-    println("Number of parameters:        $(n_par(sem_fit))")
+    println("Number of parameters:        $(nparams(sem_fit))")
     println("Number of observations:      $(n_obs(sem_fit))")
     print("\n")
     printstyled(
diff --git a/src/frontend/specification/ParameterTable.jl b/src/frontend/specification/ParameterTable.jl
@@ -143,7 +143,7 @@ Base.iterate(partable::ParameterTable, i::Integer) =
     i > length(partable) ? nothing : (partable[i], i + 1)
 
 params(partable::ParameterTable) = partable.params
-n_par(partable::ParameterTable) = length(params(partable))
+nparams(partable::ParameterTable) = length(params(partable))
 
 # Sorting ----------------------------------------------------------------------------------
 
diff --git a/src/frontend/specification/RAMMatrices.jl b/src/frontend/specification/RAMMatrices.jl
@@ -63,7 +63,7 @@ struct RAMMatrices <: SemSpecification
     size_F::Tuple{Int, Int}
 end
 
-n_par(ram::RAMMatrices) = length(ram.A_ind)
+nparams(ram::RAMMatrices) = length(ram.A_ind)
 params(ram::RAMMatrices) = ram.params
 
 ############################################################################################
diff --git a/src/frontend/specification/Sem.jl b/src/frontend/specification/Sem.jl
@@ -73,7 +73,7 @@ function get_fields!(kwargs, observed, imply, loss, optimizer)
     end
 
     kwargs[:imply] = imply
-    kwargs[:n_par] = n_par(imply)
+    kwargs[:nparams] = nparams(imply)
 
     # loss
     loss = get_SemLoss(loss; kwargs...)
diff --git a/src/imply/RAM/generic.jl b/src/imply/RAM/generic.jl
@@ -34,8 +34,8 @@ and for models with a meanstructure, the model implied means are computed as
 ```
 
 ## Interfaces
-- `params(::RAM) `-> Dict containing the parameter labels and their position
-- `n_par(::RAM)` -> Number of parameters
+- `params(::RAM) `-> vector of parameter labels
+- `nparams(::RAM)` -> number of parameters
 
 - `Σ(::RAM)` -> model implied covariance matrix
 - `μ(::RAM)` -> model implied mean vector
@@ -107,7 +107,7 @@ function RAM(;
     ram_matrices = convert(RAMMatrices, specification)
 
     # get dimensions of the model
-    n_par = length(ram_matrices.params)
+    n_par = nparams(ram_matrices)
     n_var, n_nod = ram_matrices.size_F
     F = zeros(ram_matrices.size_F)
     F[CartesianIndex.(1:n_var, ram_matrices.F_ind)] .= 1.0
diff --git a/src/imply/RAM/symbolic.jl b/src/imply/RAM/symbolic.jl
@@ -29,8 +29,8 @@ Subtype of `SemImply` that implements the RAM notation with symbolic precomputat
 Subtype of `SemImply`.
 
 ## Interfaces
-- `params(::RAMSymbolic) `-> Dict containing the parameter labels and their position
-- `n_par(::RAMSymbolic)` -> Number of parameters
+- `params(::RAMSymbolic) `-> vector of parameter ids
+- `nparams(::RAMSymbolic)` -> number of parameters
 
 - `Σ(::RAMSymbolic)` -> model implied covariance matrix
 - `μ(::RAMSymbolic)` -> model implied mean vector
@@ -97,7 +97,7 @@ function RAMSymbolic(;
 )
     ram_matrices = convert(RAMMatrices, specification)
 
-    n_par = length(ram_matrices.params)
+    n_par = nparams(ram_matrices)
     n_var, n_nod = ram_matrices.size_F
 
     par = (Symbolics.@variables θ[1:n_par])[1]
@@ -141,7 +141,6 @@ function RAMSymbolic(;
 
     if hessian & !approximate_hessian
         n_sig = length(Σ_symbolic)
-        n_par = size(par, 1)
         ∇²Σ_symbolic_vec = [Symbolics.sparsehessian(σᵢ, [par...]) for σᵢ in vec(Σ_symbolic)]
 
         @variables J[1:n_sig]
diff --git a/src/imply/empty.jl b/src/imply/empty.jl
@@ -19,8 +19,8 @@ model per group and an additional model with `ImplyEmpty` and `SemRidge` for the
 # Extended help
 
 ## Interfaces
-- `params(::RAMSymbolic) `-> Dict containing the parameter labels and their position
-- `n_par(::RAMSymbolic)` -> Number of parameters
+- `params(::RAMSymbolic) `-> Vector of parameter labels
+- `nparams(::RAMSymbolic)` -> Number of parameters
 
 ## Implementation
 Subtype of `SemImply`.
diff --git a/src/loss/regularization/ridge.jl b/src/loss/regularization/ridge.jl
@@ -8,18 +8,18 @@ Ridge regularization.
 
 # Constructor
 
-    SemRidge(;α_ridge, which_ridge, n_par, parameter_type = Float64, imply = nothing, kwargs...)
+    SemRidge(;α_ridge, which_ridge, nparams, parameter_type = Float64, imply = nothing, kwargs...)
 
 # Arguments
 - `α_ridge`: hyperparameter for penalty term
 - `which_ridge::Vector`: Vector of parameter labels (Symbols) or indices that indicate which parameters should be regularized.
-- `n_par::Int`: number of parameters of the model
+- `nparams::Int`: number of parameters of the model
 - `imply::SemImply`: imply part of the model
 - `parameter_type`: type of the parameters
 
 # Examples
 ```julia
-my_ridge = SemRidge(;α_ridge = 0.02, which_ridge = [:λ₁, :λ₂, :ω₂₃], n_par = 30, imply = my_imply)
+my_ridge = SemRidge(;α_ridge = 0.02, which_ridge = [:λ₁, :λ₂, :ω₂₃], nparams = 30, imply = my_imply)
 ```
 
 # Interfaces
@@ -45,7 +45,7 @@ end
 function SemRidge(;
     α_ridge,
     which_ridge,
-    n_par,
+    nparams,
     parameter_type = Float64,
     imply = nothing,
     kwargs...,
@@ -68,8 +68,8 @@ function SemRidge(;
         α_ridge,
         which,
         which_H,
-        zeros(parameter_type, n_par),
-        zeros(parameter_type, n_par, n_par),
+        zeros(parameter_type, nparams),
+        zeros(parameter_type, nparams, nparams),
     )
 end
 
diff --git a/src/types.jl b/src/types.jl
@@ -21,14 +21,14 @@ Return the vector of SEM model parameters.
 params(model::AbstractSem) = model.params
 
 """
-    n_par(semobj)
+    nparams(semobj)
 
 Return the number of SEM model parameters.
 """
-n_par(model::AbstractSem) = length(params(model))
+nparams(model::AbstractSem) = length(params(model))
 
 params(model::AbstractSemSingle) = params(model.imply)
-n_par(model::AbstractSemSingle) = n_par(model.imply)
+nparams(model::AbstractSemSingle) = nparams(model.imply)
 
 """
     SemLoss(args...; loss_weights = nothing, ...)
@@ -93,7 +93,7 @@ If you would like to implement a different notation, e.g. LISREL, you should imp
 abstract type SemImply end
 
 params(imply::SemImply) = params(imply.ram_matrices)
-n_par(imply::SemImply) = n_par(imply.ram_matrices)
+nparams(imply::SemImply) = nparams(imply.ram_matrices)
 
 "Subtype of SemImply for all objects that can serve as the imply field of a SEM and use some form of symbolic precomputation."
 abstract type SemImplySymbolic <: SemImply end
@@ -185,7 +185,6 @@ end
 
 function SemEnsemble(models...; optimizer = SemOptimizerOptim, weights = nothing, kwargs...)
     n = length(models)
-    npar = n_par(models[1])
 
     # default weights
 
@@ -213,7 +212,7 @@ function SemEnsemble(models...; optimizer = SemOptimizerOptim, weights = nothing
 end
 
 params(ensemble::SemEnsemble) = ensemble.params
-n_par(ensemble::SemEnsemble) = length(ensemble.params)
+nparams(ensemble::SemEnsemble) = length(ensemble.params)
 
 """
     n_models(ensemble::SemEnsemble) -> Integer
diff --git a/test/examples/helper.jl b/test/examples/helper.jl
@@ -46,15 +46,15 @@ fitmeasure_names_ml = Dict(
     :df => "df",
     :χ² => "chisq",
     :p_value => "pvalue",
-    :n_par => "npar",
+    :nparams => "npar",
     :RMSEA => "rmsea",
 )
 
 fitmeasure_names_ls = Dict(
     :df => "df",
     :χ² => "chisq",
     :p_value => "pvalue",
-    :n_par => "npar",
+    :nparams => "npar",
     :RMSEA => "rmsea",
 )
 
diff --git a/test/examples/political_democracy/by_parts.jl b/test/examples/political_democracy/by_parts.jl
@@ -15,7 +15,7 @@ ml = SemML(observed = observed)
 
 wls = SemWLS(observed = observed)
 
-ridge = SemRidge(α_ridge = 0.001, which_ridge = 16:20, n_par = 31)
+ridge = SemRidge(α_ridge = 0.001, which_ridge = 16:20, nparams = 31)
 
 constant = SemConstant(constant_loss = 3.465)
 
diff --git a/test/examples/recover_parameters/recover_parameters_twofact.jl b/test/examples/recover_parameters/recover_parameters_twofact.jl
@@ -63,7 +63,7 @@ Random.seed!(1234)
 x = transpose(rand(true_dist, 100000))
 semobserved = SemObservedData(data = x, specification = nothing)
 
-loss_ml = SemLoss(SemML(; observed = semobserved, n_par = length(start)))
+loss_ml = SemLoss(SemML(; observed = semobserved, nparams = length(start)))
 
 optimizer = SemOptimizerOptim(
     BFGS(; linesearch = BackTracking(order = 3), alphaguess = InitialHagerZhang()),# m = 100),
