rename parameter_type to relation

for clarity

Author: alyst

src/frontend/fit/summary.jl

@@ -93,19 +93,13 @@ function sem_summary(
     sorted_columns = [:to, :estimate, :param, :value_fixed, :start]
     loading_columns = sort_partially(sorted_columns, columns)
     header_cols = copy(loading_columns)
-    replace!(header_cols, :parameter_type => :type)
 
     for var in partable.latent_vars
         indicator_indices = findall(
             (partable.columns[:from] .== var) .&
-            (partable.columns[:parameter_type] .== :→) .&
+            (partable.columns[:relation] .== :→) .&
             (partable.columns[:to] .∈ [partable.observed_vars]),
         )
-        loading_array = reduce(
-            hcat,
-            check_round(partable.columns[c][indicator_indices]; digits = digits) for
-            c in loading_columns
-        )
 
         printstyled(var; color = secondary_color)
         print("\n")
@@ -122,7 +116,7 @@ function sem_summary(
     printstyled("Directed Effects: \n"; color = color)
 
     regression_indices = findall(
-        (partable.columns[:parameter_type] .== :→) .& (
+        (partable.columns[:relation] .== :→) .& (
             (
                 (partable.columns[:to] .∈ [partable.observed_vars]) .&
                 (partable.columns[:from] .∈ [partable.observed_vars])
@@ -138,7 +132,7 @@ function sem_summary(
         ),
     )
 
-    sorted_columns = [:from, :parameter_type, :to, :estimate, :param, :value_fixed, :start]
+    sorted_columns = [:from, :relation, :to, :estimate, :param, :value_fixed, :start]
     regression_columns = sort_partially(sorted_columns, columns)
 
     regression_array = reduce(
@@ -147,7 +141,6 @@ function sem_summary(
         c in regression_columns
     )
     regression_columns[2] = Symbol("")
-    replace!(regression_columns, :parameter_type => :type)
 
     print("\n")
     pretty_table(
@@ -161,11 +154,11 @@ function sem_summary(
     printstyled("Variances: \n"; color = color)
 
     variance_indices = findall(
-        (partable.columns[:parameter_type] .== :↔) .&
+        (partable.columns[:relation] .== :↔) .&
         (partable.columns[:to] .== partable.columns[:from]),
     )
 
-    sorted_columns = [:from, :parameter_type, :to, :estimate, :param, :value_fixed, :start]
+    sorted_columns = [:from, :relation, :to, :estimate, :param, :value_fixed, :start]
     variance_columns = sort_partially(sorted_columns, columns)
 
     variance_array = reduce(
@@ -174,7 +167,6 @@ function sem_summary(
         c in variance_columns
     )
     variance_columns[2] = Symbol("")
-    replace!(variance_columns, :parameter_type => :type)
 
     print("\n")
     pretty_table(
@@ -188,11 +180,11 @@ function sem_summary(
     printstyled("Covariances: \n"; color = color)
 
     variance_indices = findall(
-        (partable.columns[:parameter_type] .== :↔) .&
+        (partable.columns[:relation] .== :↔) .&
         (partable.columns[:to] .!= partable.columns[:from]),
     )
 
-    sorted_columns = [:from, :parameter_type, :to, :estimate, :param, :value_fixed, :start]
+    sorted_columns = [:from, :relation, :to, :estimate, :param, :value_fixed, :start]
     variance_columns = sort_partially(sorted_columns, columns)
 
     variance_array = reduce(
@@ -201,7 +193,6 @@ function sem_summary(
         c in variance_columns
     )
     variance_columns[2] = Symbol("")
-    replace!(variance_columns, :parameter_type => :type)
 
     print("\n")
     pretty_table(
@@ -213,15 +204,13 @@ function sem_summary(
     print("\n")
 
     mean_indices = findall(
-        (partable.columns[:parameter_type] .== :→) .&
-        (partable.columns[:from] .== Symbol("1")),
+        (partable.columns[:relation] .== :→) .& (partable.columns[:from] .== Symbol("1")),
     )
 
     if length(mean_indices) > 0
         printstyled("Means: \n"; color = color)
 
-        sorted_columns =
-            [:from, :parameter_type, :to, :estimate, :param, :value_fixed, :start]
+        sorted_columns = [:from, :relation, :to, :estimate, :param, :value_fixed, :start]
         variance_columns = sort_partially(sorted_columns, columns)
 
         variance_array = reduce(
@@ -230,7 +219,6 @@ function sem_summary(
             c in variance_columns
         )
         variance_columns[2] = Symbol("")
-        replace!(variance_columns, :parameter_type => :type)
 
         print("\n")
         pretty_table(

src/frontend/specification/ParameterTable.jl

@@ -18,7 +18,7 @@ end
 # optionally pre-allocate data for nrows
 empty_partable_columns(nrows::Integer = 0) = Dict{Symbol, Vector}(
     :from => fill(Symbol(), nrows),
-    :parameter_type => fill(Symbol(), nrows),
+    :relation => fill(Symbol(), nrows),
     :to => fill(Symbol(), nrows),
     :free => fill(true, nrows),
     :value_fixed => fill(NaN, nrows),
@@ -93,7 +93,7 @@ end
 
 function Base.show(io::IO, partable::ParameterTable)
     relevant_columns =
-        [:from, :parameter_type, :to, :free, :value_fixed, :start, :estimate, :se, :param]
+        [:from, :relation, :to, :free, :value_fixed, :start, :estimate, :se, :param]
     shown_columns = filter!(
         col -> haskey(partable.columns, col) && length(partable.columns[col]) > 0,
         relevant_columns,
@@ -118,7 +118,7 @@ end
 # Iteration --------------------------------------------------------------------------------
 ParameterTableRow = @NamedTuple begin
     from::Symbol
-    parameter_type::Symbol
+    relation::Symbol
     to::Symbol
     free::Bool
     value_fixed::Any
@@ -127,7 +127,7 @@ end
 
 Base.getindex(partable::ParameterTable, i::Integer) = (
     from = partable.columns[:from][i],
-    parameter_type = partable.columns[:parameter_type][i],
+    relation = partable.columns[:relation][i],
     to = partable.columns[:to][i],
     free = partable.columns[:free][i],
     value_fixed = partable.columns[:value_fixed][i],
@@ -168,8 +168,8 @@ function sort_vars!(partable::ParameterTable)
     ]
 
     is_regression = [
-        (partype == :→) && (from != Symbol("1")) for (partype, from) in
-        zip(partable.columns[:parameter_type], partable.columns[:from])
+        (rel == :→) && (from != Symbol("1")) for
+        (rel, from) in zip(partable.columns[:relation], partable.columns[:from])
     ]
 
     to = partable.columns[:to][is_regression]
@@ -451,7 +451,7 @@ function lavaan_param_values!(
     for (from, to, type, id) in zip(
         [
             view(partable.columns[k], partable_mask) for
-            k in [:from, :to, :parameter_type, :param]
+            k in [:from, :to, :relation, :param]
         ]...,
     )
         lav_ind = nothing

src/frontend/specification/RAMMatrices.jl

@@ -177,34 +177,34 @@ function RAMMatrices(
         col_ind = r.from != Symbol("1") ? positions[r.from] : nothing
 
         if !r.free
-            if (r.parameter_type == :→) && (r.from == Symbol("1"))
+            if (r.relation == :→) && (r.from == Symbol("1"))
                 push!(constants, RAMConstant(:M, row_ind, r.value_fixed))
-            elseif r.parameter_type == :→
+            elseif r.relation == :→
                 push!(
                     constants,
                     RAMConstant(:A, CartesianIndex(row_ind, col_ind), r.value_fixed),
                 )
-            elseif r.parameter_type == :↔
+            elseif r.relation == :↔
                 push!(
                     constants,
                     RAMConstant(:S, CartesianIndex(row_ind, col_ind), r.value_fixed),
                 )
             else
-                error("Unsupported parameter type: $(r.parameter_type)")
+                error("Unsupported parameter type: $(r.relation)")
             end
         else
             par_ind = params_index[r.param]
-            if (r.parameter_type == :→) && (r.from == Symbol("1"))
+            if (r.relation == :→) && (r.from == Symbol("1"))
                 push!(M_ind[par_ind], row_ind)
-            elseif r.parameter_type == :→
+            elseif r.relation == :→
                 push!(A_ind[par_ind], row_ind + (col_ind - 1) * n_node)
-            elseif r.parameter_type == :↔
+            elseif r.relation == :↔
                 push!(S_ind[par_ind], row_ind + (col_ind - 1) * n_node)
                 if row_ind != col_ind
                     push!(S_ind[par_ind], col_ind + (row_ind - 1) * n_node)
                 end
             else
-                error("Unsupported parameter type: $(r.parameter_type)")
+                error("Unsupported parameter type: $(r.relation)")
             end
         end
     end
@@ -301,7 +301,8 @@ end
 ### Additional Functions
 ############################################################################################
 
-function matrix_to_parameter_type(matrix::Symbol)
+# return the `from □ to` variables relation symbol (□) given the name of the source RAM matrix
+function matrix_to_relation(matrix::Symbol)
     if matrix == :A
         return :→
     elseif matrix == :S
@@ -319,7 +320,7 @@ end
 
 partable_row(c::RAMConstant, position_names::AbstractDict) = (
     from = position_names[c.index[2]],
-    parameter_type = matrix_to_parameter_type(c.matrix),
+    relation = matrix_to_relation(c.matrix),
     to = position_names[c.index[1]],
     free = false,
     value_fixed = c.value,
@@ -349,7 +350,7 @@ function partable_row(
 
     return (
         from = from,
-        parameter_type = matrix_to_parameter_type(matrix),
+        relation = matrix_to_relation(matrix),
         to = to,
         free = true,
         value_fixed = 0.0,

src/frontend/specification/StenoGraphs.jl

@@ -43,7 +43,7 @@ function ParameterTable(
 
     columns = empty_partable_columns(n)
     from = columns[:from]
-    parameter_type = columns[:parameter_type]
+    relation = columns[:relation]
     to = columns[:to]
     free = columns[:free]
     value_fixed = columns[:value_fixed]
@@ -56,9 +56,9 @@ function ParameterTable(
         from[i] = edge.src.node
         to[i] = edge.dst.node
         if edge isa DirectedEdge
-            parameter_type[i] = :→
+            relation[i] = :→
         elseif edge isa UndirectedEdge
-            parameter_type[i] = :↔
+            relation[i] = :↔
         else
             throw(
                 ArgumentError(