Package 'LCPA'

Align Latent Class/Profile Models via Optimal Permutation

Description

This function reorders the latent classes/profiles of object2 to best match those in object1 by minimizing the total assignment cost based on posterior class membership (MAP classification). It uses the Linear Sum Assignment Problem (LSAP) solver to find the optimal one-to-one mapping between latent classes. Useful for comparing or averaging models across replications, initializations, or algorithms where class labels may be permuted.

Usage

adjust.model(object1, object2)

Arguments

object1	An object of class "LCA" or "LPA", typically the reference model.
object2	An object of class "LCA" or "LPA", whose latent classes will be reordered to align with object1.

Details

The alignment is performed by:

1. Computing Maximum A Posteriori (MAP) classification matrices for both models.

2. Calculating a distance matrix between classes (typically Euclidean distance between binary MAP vectors).

3. Solving the Linear Sum Assignment Problem (LSAP) via solve_LSAP to find the permutation minimizing total mismatch cost.

4. Reordering all class-specific components of object2 according to this optimal assignment.

Value

A modified version of object2, with all parameters and posterior probabilities reordered to best match the latent class structure of object1. The returned object retains its original class ("LCA" or "LPA") and includes aligned:

• Prior probabilities (P.Z)

• Posterior probabilities (P.Z.Xn)

• MAP classifications (Z)

• Profile/Class-specific parameters:

  • For "LPA": means, covs

  • For "LCA": par, probability

• All relevant dimnames and names are synchronized with object1

Note

• Both models must have identical numbers of observations ($N$), latent classes ($L$), and indicators ($I$).

• Designed for use after fitting multiple models (e.g., different random starts) to ensure consistent class labeling.

• Does not modify object1; only returns a reordered object2.

Examples

## Not run: 
# need Mplus and Pyrthon

library(LCPA)
set.seed(123)

data.obj <- sim.LCA(N = 500, I = 4, L = 3)

# Fit two models with different random seeds
fit1 <- LCA(data.obj$response, L = 3, method = "Mplus", nrep = 1)
fit2 <- LCA(data.obj$response, L = 3, method = "NNE", nrep = 1)

# Align fit2 to fit1's class ordering
fit2_aligned <- adjust.model(fit1, fit2)

# Compare prior probabilities before and after
print("Before alignment:")
print(fit2$params$P.Z)
print("After alignment:")
print(fit2_aligned$params$P.Z)


## End(Not run)

---

Adjust Categorical Response Data for Polytomous Indicators

Description

Standardizes polytomous response data by converting raw category values to consecutive integers starting from 0. Records original category values for potential reverse transformation. Handles varying numbers of response categories across indicators.

Usage

adjust.response(response)

Arguments

response

A matrix or data frame containing response data where: Rows represent respondents ($N$ observations) Columns represent indicators/items/questions ($I$ indicators) Cells contain raw response values (numeric) Non-numeric columns will be coerced to numeric with warning.

Details

The function processes each indicator column independently:

1. Extracts unique response values and sorts them in ascending order

2. Maps smallest value to 0, second smallest to 1, etc.

3. Records original values in poly.orig for possible reverse transformation

4. Handles indicators with different numbers of categories through NA-padding

Missing values (NA) in input are preserved as NA in output.

Value

A named list containing:

poly.orig

$I \times K_{max}$ matrix. Original sorted category values for each indicator. Rows correspond to indicators, columns to category positions. Empty cells filled with NA.

poly.value

Integer vector of length $I$. Number of unique response categories per indicator.

poly.max

Scalar integer. Maximum number of categories across all indicators, i.e., $K_{max}$.

response

$N \times I$ matrix. Adjusted response data where original values are replaced by zero-based category indices (0 to $k-1$ for $k$ categories).

Examples

# Simulate response data with 3 indicators and varying categories
set.seed(123)
resp <- data.frame(
  indicator1 = sample(1:3, 10, replace = TRUE),
  indicator2 = sample(c(0, 5, 10), 10, replace = TRUE),
  indicator3 = sample(1:2, 10, replace = TRUE)
)

# Apply adjustment
adjusted <- adjust.response(resp)

# Inspect results
str(adjusted)
print(adjusted$poly.orig)  # Original category values
print(adjusted$response)   # Standardized responses

---

Validate response matrix against expected polytomous category counts

Description

Checks whether each column in the response matrix contains exactly the number of unique response categories specified in poly.value. Handles edge cases where all indicators have identical category counts efficiently.

Usage

check.response(response, poly.value)

Arguments

response	A numeric matrix of dimension $N \times I$, where: $N$: Number of subjects/observations (rows) $I$: Number of indicators/items/variables (columns) Each cell contains the observed response value for a subject on an indicator.
poly.value	An integer vector of length $I$ specifying the expected number of unique response categories (levels) for each corresponding indicator in response. Values must be positive integers.

Value

Logical value indicating validation status:

• TRUE if either:

  • All columns have identical numbers of unique values (regardless of poly.value specification)

  • Each column's unique value count matches its corresponding poly.value entry

• FALSE if any column's unique value count mismatches its specified poly.value (when columns have varying category counts)

Note

This function contains a specific behavior: When all indicators have identical numbers of unique response categories, it returns TRUE immediately without validating against poly.value. This may lead to unexpected results if poly.value contains inconsistent expectations. Users should ensure poly.value accurately reflects their measurement model.

Examples

# Valid case: Matching category counts
resp_matrix <- matrix(c(1,1,2,2, 1,2,3,1), ncol = 2)
check.response(resp_matrix, poly.value = c(2, 3))  # Returns TRUE

# Invalid case: Mismatched category counts
check.response(resp_matrix, poly.value = c(2, 2))  # Returns FALSE

# Special case: Uniform category counts bypass poly.value check
uniform_resp <- matrix(rep(1:2, each = 4), ncol = 2)
check.response(uniform_resp, poly.value = c(2, 5))  # Returns TRUE (bypass behavior)

---

Model Comparison Tool

Description

Compares two nested latent class/profile models using multiple fit indices, likelihood ratio tests, and classification metrics.

Usage

compare.model(object1, object2, n.Bootstrap = 0)

Arguments

object1	An object of class LCA or LPA, representing the first latent class/profile model.
object2	An object of class LCA or LPA, representing the second latent class/profile model. Must be of the same type as object1.
n.Bootstrap	Integer specifying the number of bootstrap replications for the parametric bootstrap likelihood ratio test (BLRT). Default is 0 (no bootstrap test performed).

Details

This function performs comprehensive model comparison between two nested LCA/LPA models. Key features include:

• Automatically orders models by parameter count (smaller model first)

• Computes multiple fit indices via get.fit.index

• Calculates classification quality metrics (entropy, average posterior probabilities)

• Performs three types of likelihood ratio tests:

  • Standard LRT, see LRT.test

  • VLMR adjusted LRT, see LRT.test.VLMR

  • Parametric bootstrap LRT (computationally intensive but robust), see LRT.test.Bootstrap

• Computes Bayes Factor using Sample-Size Adjusted BIC (SIC)

Important Requirements:

• Both models must be of the same type (LCA or LPA)

• Models must be nested (one model is a constrained version of the other)

• n.Bootstrap > 0 requires significant computational resources

Value

An object of class compare.model containing:

npar

Named vector with number of free parameters for each model

entropy

Named vector with entropy values (classification accuracy measure) for each model

AvePP

List containing average posterior probabilities per latent class/profile

fit.index

List of get.fit.index objects for both models

BF

Bayes Factor for model comparison (based on SIC)

LRT.obj

Likelihood ratio test (LRT) results

LRT.VLMR.obj

Vuong-Lo-Mendell-Rubin (VLMR) adjusted LRT results

LRT.Bootstrap.obj

Bootstrap LRT results (if n.Bootstrap > 0)

call

The matched function call

arguments

List containing the original arguments passed to the function

See Also

LCA, LPA, get.fit.index, extract, LRT.test, LRT.test.VLMR

Examples

library(LCPA)
set.seed(123)

data.obj <- sim.LPA(N = 500, I = 5, L = 3, constraint = "V0")
response <- data.obj$response

# need Mplus
## Not run: 
# Compare 3-class vs 4-class LPA models
object1 <- LPA(response, L = 3, method = "Mplus", constraint = "V0")
object2 <- LPA(response, L = 4, method = "Mplus", constraint = "V0")

compare.model.obj <- compare.model(object1, object2)

print(compare.model.obj)

## End(Not run)

---

S3 Methods: extract

Description

A generic S3 extractor function designed to retrieve internal components from various model and simulation objects produced by the LCPA package. This function provides a consistent interface across different classes, allowing users to access estimated parameters, fit statistics, simulation truths, standard errors, and more.

Usage

extract(object, what, ...)

## S3 method for class 'LCA'
extract(object, what, ...)

## S3 method for class 'LPA'
extract(object, what, ...)

## S3 method for class 'LCPA'
extract(object, what, ...)

## S3 method for class 'LTA'
extract(object, what, ...)

## S3 method for class 'sim.LCA'
extract(object, what, ...)

## S3 method for class 'sim.LPA'
extract(object, what, ...)

## S3 method for class 'sim.LTA'
extract(object, what, ...)

## S3 method for class 'fit.index'
extract(object, what, ...)

## S3 method for class 'compare.model'
extract(object, what, ...)

## S3 method for class 'SE'
extract(object, what, ...)

Arguments

object	An object of one of the following classes: LCA — Latent Class Analysis model results. LPA — Latent Profile Analysis model results. LCPA — Latent Class/Profile Analysis with covariates. LTA — Latent Transition Analysis model results. sim.LCA — Simulated LCA data with known truth. sim.LPA — Simulated LPA data with known truth. sim.LTA — Simulated LTA data with known truth. get.fit.index — Model fit indices object. compare.model — Model comparison results. get.SE — Standard error estimation results.
what	A character string specifying the name of the component to extract. Valid choices depend on the class of object. See Details section for full listings.
...	Additional arguments passed to methods (currently ignored).

Details

This function supports extraction from ten primary object classes. Below are available components for each:

LCA

Latent Class Analysis model results. Available components:

params

List containing all estimated model parameters.

par

3D array ($L \times I \times K_{\max}$) of conditional response probabilities.

P.Z

Vector of length $L$ with latent class prior probabilities.

npar

Number of free parameters in the model.

Log.Lik

Log-likelihood of the final model.

AIC

Akaike Information Criterion.

BIC

Bayesian Information Criterion.

best_BIC

Best BIC value across replication runs (if nrep > 1).

P.Z.Xn

$N \times L$ matrix of posterior class probabilities.

Z

Vector of length $N$ with MAP-classified latent class memberships.

probability

List of formatted conditional probability matrices per item.

Log.Lik.history

Vector tracking log-likelihood at each EM iteration.

Log.Lik.nrep

Vector of log-likelihoods from each replication run.

model

Trained neural network model object (only when method="NNE").

call

The original function call used for model estimation.

arguments

List containing all input arguments passed to the LCA function.

LPA

Latent Profile Analysis model results. Available components:

params

List containing all estimated model parameters.

means

$L \times I$ matrix of estimated mean vectors for each profile.

covs

$I \times I \times L$ array of estimated covariance matrices.

P.Z

Vector of length $L$ with profile prior probabilities.

npar

Number of free parameters (depends on constraint).

Log.Lik

Log-likelihood of the final model.

AIC

Akaike Information Criterion.

BIC

Bayesian Information Criterion.

best_BIC

Best BIC value across replication runs (if nrep > 1).

P.Z.Xn

$N \times L$ matrix of posterior profile probabilities.

Z

Vector of length $N$ with MAP-classified profile memberships.

Log.Lik.history

Vector tracking log-likelihood at each EM iteration.

Log.Lik.nrep

Vector of log-likelihoods from each replication run.

model

Trained model object (neural network or Mplus).

call

The original function call used for model estimation.

arguments

List containing all input arguments passed to the LPA function.

constraint

Covariance structure constraints applied during estimation (from original arguments).

LCPA

Latent Class/Profile Analysis (with covariates). Available components:

beta

Initial class coefficients (p1 x L matrix).

beta.se

Standard errors for beta.

beta.Z.sta

Z-statistics for beta.

beta.p.value.tail1

One-tailed p-values for beta.

beta.p.value.tail2

Two-tailed p-values for beta.

P.Z.Xn

Posterior probabilities (N x L).

P.Z

Prior proportions (length L).

Z

Modal class assignments (length N).

npar

Number of free parameters.

Log.Lik

Log-likelihood.

AIC

AIC.

BIC

BIC.

iterations

Optimization iterations in Step 3.

coveraged

Logical: did optimization converge early?

params

Step 1 model parameters (LCA/LPA output).

call

Function call.

arguments

Input arguments list.

LTA

Latent Transition Analysis model results. Available components:

beta

Initial class coefficients (p1 x L matrix).

gamma

Transition coefficients (nested list).

beta.se

Standard errors for beta.

gamma.se

Standard errors for gamma.

beta.Z.sta

Z-statistics for beta.

gamma.Z.sta

Z-statistics for gamma.

beta.p.value.tail1

One-tailed p-values for beta.

gamma.p.value.tail1

One-tailed p-values for gamma.

beta.p.value.tail2

Two-tailed p-values for beta.

gamma.p.value.tail2

Two-tailed p-values for gamma.

P.Z.Xns

List of posterior probabilities per time (each N x L).

P.Zs

List of prior proportions per time (each length L).

Zs

List of modal class assignments per time (each length N).

npar

Number of free parameters.

Log.Lik

Log-likelihood.

AIC

AIC.

BIC

BIC.

iterations

Optimization iterations in Step 3.

coveraged

Logical: did optimization converge early?

params

Step 1 model parameters (LCA/LPA output).

call

Function call.

arguments

Input arguments list.

sim.LCA

Simulated Latent Class Analysis data. Available components:

response

Integer matrix ($N \times I$) of simulated categorical observations.

par

Array ($L \times I \times P_{\max}$) of true class-specific category probabilities.

Z

Integer vector (length $N$) of true latent class assignments.

P.Z

Numeric vector (length $L$) of true class proportions.

poly.value

Integer vector (length $I$) specifying categories per variable.

P.Z.Xn

Binary matrix ($N \times L$) of true class membership indicators.

call

The original function call used for simulation.

arguments

List containing all input arguments passed to sim.LCA.

sim.LPA

Simulated Latent Profile Analysis data. Available components:

response

Numeric matrix ($N \times I$) of simulated continuous observations.

means

$L \times I$ matrix of true class-specific means.

covs

$I \times I \times L$ array of true class-specific covariance matrices.

P.Z.Xn

$N \times L$ matrix of true class membership indicators.

P.Z

Numeric vector (length $L$) of true class proportions.

Z

Integer vector (length $N$) of true profile assignments.

constraint

Original constraint specification passed to sim.LPA.

call

The original function call used for simulation.

arguments

List containing all input arguments passed to sim.LPA.

sim.LTA

Simulated Latent Transition Analysis data. Available components:

responses

List of response matrices per time point.

Zs

List of true latent class assignments per time.

P.Zs

List of true class proportions per time.

par

True conditional probabilities (for categorical items).

means

True profile means (for continuous variables).

covs

True covariance matrices per class and time.

poly.value

Categories per variable (for categorical items).

rate

Transition rate matrix or structure.

covariates

Simulated covariate matrix.

beta

True initial class coefficients.

gamma

True transition coefficients.

call

Original simulation function call.

arguments

Input arguments used in simulation.

fit.index

Model fit indices object. Available components:

npar

Number of free parameters in the model.

Log.Lik

Log-likelihood of the model.

-2LL

Deviance statistic (-2 times log-likelihood).

AIC

Akaike Information Criterion.

BIC

Bayesian Information Criterion.

SIC

Sample-Size Adjusted BIC (-0.5 * BIC).

CAIC

Consistent AIC.

AWE

Approximate Weight of Evidence.

SABIC

Sample-Size Adjusted BIC (alternative formulation).

call

Original function call that generated the fit indices.

arguments

List containing input arguments (includes original model object).

compare.model

Model comparison results. Available components:

npar

Named numeric vector with free parameters for each model (model1, model2).

entropy

Named numeric vector with entropy values for each model.

AvePP

List of average posterior probabilities per class/profile for each model.

fit.index

List of get.fit.index objects for both models.

BF

Bayes Factor comparing models (based on SIC differences).

LRT.obj

Standard likelihood ratio test results (requires nested models).

LRT.VLMR.obj

Vuong-Lo-Mendell-Rubin adjusted likelihood ratio test results.

LRT.Bootstrap.obj

Parametric bootstrap likelihood ratio test results (if n.Bootstrap > 0).

call

The matched function call used for comparison.

arguments

List containing original input arguments (object1, object2, n.Bootstrap).

SE

Standard error estimation results. Available components:

se

List containing standard errors for parameters (components depend on model type).

vcov

Variance-covariance matrix (only for method="Obs").

hessian

Observed information matrix (only for method="Obs").

diagnostics

Method-specific diagnostic information (e.g., estimation method).

call

Function call that generated the object.

arguments

Input arguments used in estimation.

means

Standard errors for profile means (LPA models only — accessed via se list).

covs

Standard errors for covariance parameters (LPA models only — accessed via se list).

P.Z

Standard errors for class proportions (both LCA/LPA — accessed via se list).

par

Standard errors for conditional probabilities (LCA models only — accessed via se list).

Value

The requested component. Return type varies depending on what and the class of object. If an invalid what is provided, an informative error is thrown listing valid options.

Methods (by class)

• extract(LCA): Extract fields from a LCA object

• extract(LPA): Extract fields from a LPA object

• extract(LCPA): Extract fields from a LCPA object

• extract(LTA): Extract fields from a LTA object

• extract(sim.LCA): Extract fields from a sim.LCA object

• extract(sim.LPA): Extract fields from a sim.LPA object

• extract(sim.LTA): Extract fields from a sim.LTA object

• extract(fit.index): Extractor method for fit.index objects

• extract(compare.model): Extract fields from a compare.model object

• extract(SE): Extract fields from a SE object

Usage Notes

• For LCA, LPA, LCPA, and LTA objects, components reflect estimated parameters.

• For sim.LCA, sim.LPA, and sim.LTA objects, components reflect true data-generating parameters.

• In SE objects:

  • Top-level components like vcov and hessian are only available when method = "Obs". Requesting them under Bootstrap triggers a warning and returns NULL.

  • Parameter-specific SEs (e.g., means, par) are stored within the se list. You can extract them directly by name (e.g., extract(se_obj, "means")).

  • Attempting to extract unavailable parameter SEs (e.g., par from an LPA model) triggers an error with available options.

• For fit.index and compare.model objects, valid components are dynamically determined from the object’s names.

• All methods ignore additional arguments (...).

Examples

set.seed(123)

# Simulate LPA data: 500 observations, 3 continuous variables, 2 latent profiles
# Constraint "E0": Equal variances across classes, zero covariances
data.obj <- sim.LPA(N = 500, I = 3, L = 2, constraint = "E0")

# Extract the simulated response matrix (N x I) for model fitting
response <- extract(data.obj, "response")

# Extract the TRUE covariance matrices (I x I x L array)
extract(data.obj, "covs")

# Fit an LPA model to the simulated data using the SAME constraint ("E0")
fit_E0 <- LPA(response, L = 2, constraint = "E0")

# Extract the ESTIMATED covariance matrices from the fitted model
extract(fit_E0, "covs")

# Simulate LCA data: 30 observations, 5 categorical items, 3 latent classes
sim_data <- sim.LCA(N = 30, I = 5, L = 3)

# Extract the TRUE conditional probability array
extract(sim_data, "par")

---

Calculate Average Posterior Probability (AvePP)

Description

Computes the average posterior probability for the most likely class assignment in latent class/profile analysis. This metric quantifies classification precision. The total average posterior probability $\geq 0.70$ (Nylund-Gibson & Choi, 2018) indicate adequate classification quality.

Usage

get.AvePP(object)

Arguments

object

An object of class "LCA" or "LPA" returned by LCA or LPA, or any object containing: P.Z.Xn: $N \times L$ matrix of posterior class probabilities, where: $N$ = Total number of observations ($n = 1, 2, \dots, N$) $L$ = Number of latent classes ($l = 1, 2, \dots, L$) Element $p_{nl} = P(Z_n = l \mid \mathbf{X}_n)$ denotes the posterior probability that observation $n$ belongs to class $l$ given observed data $\mathbf{X}_n$

Value

A $(L+1) \times (L+1)$ matrix with the following structure:

• Rows: Represent each latent class (1 to L) and a final "Total" row.

• Columns: Represent each latent class (1 to L) and a final "Total" column.

• Diagonal elements $\text{ave}[l,l]$: Average posterior probability for observations assigned to class $l$. That is,

  $\overline{P}_{ll} = \frac{1}{N_l} \sum_{n: \hat{z}_n = l} p_{nl},$

  where $N_l$ is the number of observations assigned to class $l$, and $\hat{z}_n = \arg\max_{l'} p_{nl'}$.

• Off-diagonal elements $\text{ave}[l,k]$ ($l \ne k$): Average posterior probability of class $k$ among observations assigned to class $l$. Useful for assessing classification confusion.

  $\overline{P}_{lk} = \frac{1}{N_l} \sum_{n: \hat{z}_n = l} p_{nk}.$

• Bottom-right corner $\text{ave}[L+1,L+1]$: Overall average posterior probability across all observations,

  $\overline{P}_{\text{total}} = \frac{1}{N} \sum_{n=1}^N \max_{l} p_{nl}.$

Note

Classification quality is considered acceptable if $\overline{P}_{\text{total}} \geq 0.70$ (Nylund-Gibson & Choi, 2018).

References

Nylund-Gibson, K., & Choi, A. Y. (2018). Ten frequently asked questions about latent class analysis. Translational Issues in Psychological Science, 4(4), 440-461. https://doi.org/10.1037/tps0000176

Examples

# Example with simulated data
set.seed(123)
data.obj <- sim.LCA(N = 500, I = 4, L = 2, IQ=0.9)
response <- data.obj$response

# Fit 2-class model with EM algorithm

fit.em <- LCA(response, L = 2, method = "EM", nrep = 10)

AvePP_value <- get.AvePP(fit.em)
print(AvePP_value)

---

Compute Classification Error Probability (CEP) Matrices

Description

Computes the Classification Error Probability (CEP) matrices (Liang et al., 2023) used in the bias-corrected three-step estimation of Latent Class/Profile Analysis with Covariates.

Usage

get.CEP(P.Z.Xns, time.cross = TRUE)

Arguments

P.Z.Xns	A list of length $T$ (number of time points). Each element is an $N \times L$ matrix of posterior probabilities $P(Z_{it} = l \mid X_i)$ from the first-step model. Rows correspond to individuals ($i = 1, \dots, N$); Columns correspond to latent classes ($l = 1, \dots, L$); Each row must sum to 1. The list must be ordered chronologically (e.g., time 1 to $T$).
time.cross	Logical. If TRUE (default), returns a list where every element is the same pooled CEP matrix (averaged across all time points). If FALSE, returns time-specific CEP matrices.

Details

The CEP matrix at time $t$ gives the probability that an individual truly belongs to latent class $l'$ given that they were assigned (via modal assignment) to class $l$ at time $t$.

Formally, for time point $t$:

$\mathrm{CEP}_t(l, l') = P(Z_t = l \mid \hat{Z}_t = l') = \frac{ \sum_{i:\,\hat{z}_{it} = l'} P(Z_{it} = l \mid X_i) }{ N \, \hat{\pi}_{tl} }$

where:

• $Z_{it}$ is the true latent class of individual $i$ at time $t$;

• $P(Z_{it} = l \mid X_i)$ is the posterior probability from the first-step model;

• $\hat{z}_{it} = \arg\max_l P(Z_{it} = l' \mid X_i)$ is the modal (most likely) assigned class;

• $\hat{\pi}_{tl} = \frac{1}{N} \sum_{i=1}^N I(\hat{z}_{it} = l)$ is the observed proportion assigned to class $l$ at time $t$;

• $N$ is the total sample size.

If time.cross = TRUE (default), a single pooled CEP matrix is computed by aggregating counts across all time points. This assumes the classification error structure is invariant over time (i.e., measurement invariance), as in Liang et al. (2023). The same pooled matrix is then returned for every time point.

Value

A named list of length $T$. Each element is an $L \times L$ matrix:

• Row $l$: true latent class;

• Column $l'$: individuals assigned to class $l'$;

• Entry $(l, l')$: estimated $P(\text{assigned class} = l' \mid \text{true class} = l)$.

When time.cross = TRUE, all matrices in the list are identical. Names are "t1", "t2", ..., "tT".

Note

• Assumes complete data (no missing values in posterior matrices).

• All matrices in P.Z.Xns must have identical dimensions (same $N$ and $L$).

• Assignment is based on modal class (which.max).

• If no individual is assigned to a class at a time point, division by zero may occur.

References

Liang, Q., la Torre, J. d., & Law, N. (2023). Latent Transition Cognitive Diagnosis Model With Covariates: A Three-Step Approach. Journal of Educational and Behavioral Statistics, 48(6), 690-718. https://doi.org/10.3102/10769986231163320

Examples

# Simulate posterior probabilities for 2 time points, 3 classes, 100 individuals
set.seed(123)
N <- 100; L <- 3; times <- 2
P.Z.Xns <- replicate(times,
  t(apply(matrix(runif(N * L), N, L), 1, function(x) x / sum(x))),
  simplify = FALSE)

# Compute time-specific CEP matrices
cep_time_specific <- get.CEP(P.Z.Xns, time.cross = FALSE)

# Compute time-invariant (pooled) CEP matrix
cep_pooled <- get.CEP(P.Z.Xns, time.cross = TRUE)

---

Calculate Classification Entropy

Description

Computes the relative entropy statistic to evaluate classification quality in Latent Class Analysis (LCA) or Latent Profile Analysis (LPA) models. Entropy measures how accurately cases are assigned to latent classes based on posterior probabilities, with values closer to 1 indicating better separation between classes.

Usage

get.entropy(object)

Arguments

object

An object of class "LCA" or "LPA" returned by LCA or LPA functions, or any other object containing: P.Z.Xn: $N \times L$ matrix of posterior class probabilities for each observation. params$P.Z: Vector of length $L$ with latent class prior probabilities.

Value

A numeric value between 0 and 1 representing the relative entropy (Nylund-Gibson et al., 2018; Clark et al., 2013):

• 1.0: Perfect classification (each case belongs exclusively to one class)

• 0.8-1.0: Good classification quality

• 0.6-0.8: Moderate classification quality

• < 0.6: Poor classification quality (consider model simplification)

Calculated using the formula:

$1 - \frac{\sum_{n=1}^N \sum_{l=1}^L -p_{nl} \ln(p_{nl})}{N \ln(L)}$

where:

• $N$ = Sample size

• $L$ = Number of latent classes

• $p_{nl}$ = Posterior probability of observation $n$ belonging to class $l$

Note

The calculation includes a small constant (1e-10) to avoid log(0) instability when posterior probabilities are exactly zero.

Values should be interpreted alongside other diagnostics (BIC, bootstrapped LRT) as high entropy alone doesn't guarantee model validity. Low entropy may indicate:

• Overly complex model (too many classes)

• Poorly measured latent constructs

• Violation of local independence assumption

References

Nylund-Gibson, K., & Choi, A. Y. (2018). Ten frequently asked questions about latent class analysis. Translational Issues in Psychological Science, 4(4), 440-461. https://doi.org/10.1037/tps0000176

Clark, S. L., Muthén, B., Kaprio, J., D'Onofrio, B. M., Viken, R., & Rose, R. J. (2013). Models and Strategies for Factor Mixture Analysis: An Example Concerning the Structure Underlying Psychological Disorders. Structural Equation Modeling: A Multidisciplinary Journal, 20(4), 681-703. https://doi.org/10.1080/10705511.2013.824786

Examples

# Example with simulated data
set.seed(123)
data.obj <- sim.LCA(N = 500, I = 4, L = 2, IQ=0.9)
response <- data.obj$response

# Fit 2-class model with EM algorithm

fit.em <- LCA(response, L = 2, method = "EM", nrep = 10)

entropy_value <- get.entropy(fit.em)
cat("Classification entropy:", round(entropy_value, 3), "\n")

---

Calculate Fit Indices

Description

Computes a comprehensive set of model fit indices for objects returned by LCA or LPA. These indices balance model fit (log-likelihood) with model complexity (number of parameters) to facilitate model selection. All indices are derived from the observed-data log-likelihood and parameter count.

Usage

get.fit.index(object)

Arguments

object

An object of class "LCA" or "LPA" returned by LCA, LPA or any object containing: Log.Lik: Log-likelihood value npar: Number of free parameters $N$ = Total number of observations ($n = 1, 2, \dots, N$)

Value

An object of class "fit.index" containing:

npar

Number of free parameters in the model

Log.Lik

Log-likelihood of the model: $\log \mathcal{L}$

-2LL

Deviance statistic: $-2 \log \mathcal{L}$

$-2 \sum_{n=1}^N \log \left[ \sum_{l=1}^L \pi_l \cdot f(\mathbf{x}_n \mid \boldsymbol{\theta}_l) \right]$

, where $\pi_l$ is the prior probability of class $l$, $f(\cdot)$ is the probability density/mass function (multivariate normal for LPA, multinomial for LCA), and $\boldsymbol{\theta}_l$ are class-specific parameters.

AIC

Akaike Information Criterion: $\mathrm{AIC} = -2 \log \mathcal{L} + 2k$, where $npar$ = number of free parameters. Lower values indicate better fit.

BIC

Bayesian Information Criterion: $\mathrm{BIC} = -2 \log \mathcal{L} + npar \log(N)$, where $N$ = sample size. Incorporates stronger penalty for complexity than AIC.

SIC

Sample-Size Adjusted BIC: $\mathrm{SIC} = -\frac{1}{2} \mathrm{BIC}$. Equivalent to $\log \mathcal{L} - \frac{npar}{2} \log(N)$. Often used in latent class modeling.

CAIC

Consistent AIC: $\mathrm{CAIC} = -2 \log \mathcal{L} + npar \left[ \log(N) + 1 \right]$. Consistent version of AIC that converges to true model as $N \to \infty$.

AWE

Approximate Weight of Evidence: $\mathrm{AWE} = -2 \log \mathcal{L} + 1.5k \left[ \log(N) + 1 \right]$. Penalizes complexity more heavily than CAIC.

SABIC

Sample-Size Adjusted BIC: $\mathrm{SABIC} = -2 \log \mathcal{L} + npar \log \left( \frac{N + 2}{24} \right)$. Recommended for latent class/profile analysis with moderate sample sizes.

Examples

# Fit LPA model
set.seed(123)
data.obj <- sim.LPA(N = 100, I = 3, L = 2, constraint = "E0")
fit <- LPA(data.obj$response, L = 2, constraint = "VV", method = "EM")

# Compute fit indices
fit_indices <- get.fit.index(fit)

fit_indices

extract(fit_indices, "SABIC")

---

Calculate Log-Likelihood for Latent Class Analysis

Description

Computes the log-likelihood of observed categorical data under a Latent Class Analysis (LCA) model given class probabilities and conditional response probabilities. The calculation assumes local independence of responses conditional on latent class membership.

Usage

get.Log.Lik.LCA(response, P.Z, par)

Arguments

response	A numeric matrix of dimension $N \times I$ containing discrete responses. Values can be any categorical encoding (e.g., 1/2/3, A/B/C, or 0/1). The function automatically: Converts all responses to 0-based integer encoding internally Determines the maximum number of categories ($K_{\max}$) across indicators
P.Z	A numeric vector of length $L$ containing prior probabilities for latent classes. Must satisfy: $\sum_{l=1}^L \pi_l = 1$ $\pi_l > 0$ for all $l = 1, \dots, L$
par	A 3-dimensional array of dimension $L \times I \times K_{\max}$ containing conditional probabilities, where $par[l, i, k]$ represents $P(X_i = k-1 \mid Z=l)$ (after internal 0-based re-encoding). Must satisfy: For each class $l$ and indicator $i$: $\sum_{k=1}^{K_i} par[l,i,k] = 1$ Probabilities for non-existent categories (where $k > K_i$) are ignored but must be present in the array

Details

The log-likelihood calculation follows these steps:

• Response Standardization: Original responses are converted to 0-based integers using adjust.response. For example, original values {1,2,5} become {0,1,2} (ordered and relabeled sequentially).

• Class-Specific Likelihood: For each observation $n$ and class $l$, compute:

  $P(\mathbf{X}_n \mid Z_n=l) = \prod_{i=1}^I P(X_{ni} = x_{ni} \mid Z_n=l)$

  where $x_{ni}$ is the standardized response value, and probabilities are taken from par[l, i, x_{ni}+1].

• Marginal Likelihood: For each observation $n$, combine class-specific likelihoods weighted by class probabilities:

  $P(\mathbf{X}_n) = \sum_{l=1}^L \pi_l \cdot P(\mathbf{X}_n \mid Z_n=l)$

• Log Transformation: Sum log-transformed marginal likelihoods across all observations:

  $\log \mathcal{L} = \sum_{n=1}^N \log P(\mathbf{X}_n)$

Value

A single numeric value representing the total log-likelihood:

$\log \mathcal{L} = \sum_{n=1}^N \log \left[ \sum_{l=1}^L \pi_l \prod_{i=1}^I P(X_{ni} = x_{ni} \mid Z=l) \right]$

where $x_{ni}$ is the standardized (0-based) response for person $n$ on indicator $i$.

---

Calculate Log-Likelihood for Latent Profile Analysis

Description

Computes the log-likelihood of observed continuous data under a Latent Profile Analysis (LPA) model with multivariate normal distributions within each latent profile. Implements robust numerical techniques to handle near-singular covariance matrices.

Usage

get.Log.Lik.LPA(response, P.Z, means, covs, jitter = 1e-10)

Arguments

response	A numeric matrix of dimension $N \times I$ containing continuous observations. Rows represent observations, columns represent variables. Missing values are not permitted.
P.Z	A numeric vector of length $L$ containing prior probabilities for latent profiles. Must satisfy: $\sum_{l=1}^L \pi_l = 1$ $\pi_l > 0$ for all $l = 1, \dots, L$
means	A matrix of dimension $L \times I$ where row $l$ contains the mean vector $\boldsymbol{\mu}_l$ for profile $l$.
covs	An array of dimension $I \times I \times L$ where slice $l$ contains the covariance matrix $\boldsymbol{\Sigma}_l$ for profile $l$. Must be symmetric positive semi-definite.
jitter	A small positive constant (default: 1e-10) added to diagonal elements of covariance matrices to ensure numerical stability during Cholesky decomposition.

Details

The log-likelihood calculation follows these steps:

• Covariance Stabilization: Each covariance matrix $\boldsymbol{\Sigma}_l$ is symmetrized as $(\boldsymbol{\Sigma}_l + \boldsymbol{\Sigma}_l^\top)/2$. If Cholesky decomposition fails:

  • Add jitter to diagonal elements iteratively (up to 10 attempts, scaling jitter by 10x each attempt)

  • Fall back to diagonal covariance matrix if decomposition still fails

• Profile-Specific Density for observation $n$ in profile $l$:

  $\log f(\mathbf{x}_n \mid Z_n=l) = -\frac{I}{2}\log(2\pi) - \frac{1}{2}\log|\boldsymbol{\Sigma}_l| - \frac{1}{2}(\mathbf{x}_n - \boldsymbol{\mu}_l)^\top \boldsymbol{\Sigma}_l^{-1} (\mathbf{x}_n - \boldsymbol{\mu}_l)$

  Computed efficiently using Cholesky decomposition $\boldsymbol{\Sigma}_l = \mathbf{R}^\top\mathbf{R}$ where applicable.

• Joint Probability for observation $n$ and profile $l$:

  $\log[\pi_l \cdot f(\mathbf{x}_n \mid Z_n=l)] = \log(\pi_l) + \log f(\mathbf{x}_n \mid Z_n=l)$

  $\log(\pi_l)$ uses $\log(\pi_l + 10^{-12})$ to avoid undefined values.

• Marginal Likelihood per observation using log-sum-exp trick for numerical stability:

  $\log f(\mathbf{x}_n) = a_{\max} + \log\left( \sum_{l=1}^L \exp\left\{ \log[\pi_l \cdot f(\mathbf{x}_n \mid Z_n=l)] - a_{\max} \right\} \right)$

  where $a_{\max} = \max_l \log[\pi_l \cdot f(\mathbf{x}_n \mid Z_n=l)]$.

• Total Log-Likelihood: Sum of $\log f(\mathbf{x}_n)$ across all observations $n=1,\dots,N$.

Value

A single numeric value representing the total log-likelihood:

$\log \mathcal{L} = \sum_{n=1}^N \log \left[ \sum_{l=1}^L \pi_l \cdot \mathcal{N}(\mathbf{x}_n \mid \boldsymbol{\mu}_l, \boldsymbol{\Sigma}_l) \right]$

where $\mathcal{N}(\cdot)$ denotes the multivariate normal density function.

Note

Critical implementation details:

• Cholesky Decomposition: For non-degenerate cases ($I>1$), used to compute: $\log|\boldsymbol{\Sigma}_l| = 2\sum_{i=1}^I \log(r_{ii})$ and quadratic form $\|\mathbf{R}^{-\top}(\mathbf{x}_n - \boldsymbol{\mu}_l)\|^2$

• Univariate Handling: When $I=1$, computes density directly without decomposition

• Numerical Safeguards:

  • Densities clamped to $-10^{10}$ when non-finite

  • Marginal likelihoods clamped to $-10^{10}$ when non-finite

  • Explicit dimension checks for means and covs

• Assumptions:

  • Multivariate normality within profiles

  • No missing data in response

  • Positive-definite covariance matrices (after stabilization)

---

Calculate Log-Likelihood for Latent Transition Analysis

Description

Computes the observed-data log-likelihood for a Latent Transition Analysis (LTA) model using the three-step approach with measurement error correction. The likelihood integrates over all possible latent class paths while incorporating classification uncertainty via Classification Error Probability (CEP) matrices. This function is designed to work with parameters estimated from the LTA function.

Usage

get.Log.Lik.LTA(
  params,
  CEP,
  P.Z.Xns,
  Zs,
  covariates,
  covariates.timeCross = FALSE
)

Arguments

params	A named list containing model parameters: beta: Matrix of size $p_1 \times L$ with coefficients for the initial class membership multinomial logit model (time 1). The coefficient vector for reference class $L$ is constrained to $\boldsymbol{\beta}_L = \mathbf{0}$. gama: Nested list of transition coefficients. For transition to time $t$ (from time $t-1$ to $t$, where $t = 2, \dots, T$): gama[[t-1]][[from_class]][[to_class]] Coefficient vector of length $p_t$ for transition from class from_class at time $t-1$ to class to_class at time $t$. Coefficients for transitions to reference class $L$ are constrained to zero vectors ($\boldsymbol{\gamma}_{kl t} = \mathbf{0}$ when $k = L$).
CEP	A list of $L \times L$ matrices (length = number of time points $T$). Element $(k,l)$ in CEP[[t]] estimates: $P(\hat{Z}_{nt} = l \mid Z_{nt} = k)$ where $\hat{Z}_{nt}$ is the modal class assignment and $Z_{nt}$ is the true latent class. Computed via non-parametric approximation in Step 2 of three-step LTA.
P.Z.Xns	A list of matrices (length = $T$). Each matrix has dimensions $N \times L$, where element $(n,l)$ is: $P(Z_{nt} = l \mid \mathbf{X}_{nt})$ the posterior probability of individual $n$ belonging to class $l$ at time $t$ from Step 1 latent class/profile analysis.
Zs	A list of integer vectors (length = $T$). Each vector has length $N$, where Zs[[t]][n] is the modal (most likely) class assignment $\hat{Z}_{nt}$ for individual $n$ at time $t$.
covariates	A list of design matrices (length = $T$). For time $t$, matrix dimension is $N \times p_t$. Must include an intercept column (all 1s) as the first column, i.e., $\mathbf{X}_{nt} = (X_{nt0}, X_{nt1}, \dots, X_{ntM})^\top$ with $X_{nt0} = 1$. Covariates may differ across time points and between initial status ($t=1$) and transitions ($t \geq 2$).
covariates.timeCross	Logical. If TRUE, forces identical transition coefficients across all time points (gama[[t]] is copied from gama[[1]] for $t>1$). Default is FALSE.

Details

The log-likelihood calculation follows these steps:

1. Latent Path Enumeration: All $L^T$ possible latent class trajectories $\mathbf{z}_n$ are generated and cached.

2. Initial Class Probabilities (time 1): For individual $n$, compute using multinomial logit with covariates $\mathbf{X}_{n1}$:

   $P(Z_{n1} = l \mid \mathbf{X}_{n1}) = \frac{\exp(\boldsymbol{\beta}_l^\top \mathbf{X}_{n1})} {\sum_{k=1}^L \exp(\boldsymbol{\beta}_k^\top \mathbf{X}_{n1})}$

   where $\boldsymbol{\beta}_L = \mathbf{0}$ (reference class constraint). Numerical stabilization is applied via subtraction of the maximum linear predictor.

3. Transition Probabilities (times $t \geq 2$): For transition from class $k$ at time $t-1$ to class $l$ at time $t$:

   $P(Z_{nt} = l \mid Z_{n,t-1} = k, \mathbf{X}_{nt}) = \frac{\exp(\boldsymbol{\gamma}_{kl t}^\top \mathbf{X}_{nt})} {\sum_{j=1}^L \exp(\boldsymbol{\gamma}_{kj t}^\top \mathbf{X}_{nt})}$

   where $\boldsymbol{\gamma}_{kL t} = \mathbf{0}$ for all $k$ (reference class constraint).

4. Path-Specific Likelihood: For each path $\mathbf{z}_n$ and individual $n$:

   1. Compute path probability: $P(Z_{n1}=z_{n1} \mid \mathbf{X}_{n1}) \times \prod_{t=2}^T P(Z_{nt}=z_{nt} \mid Z_{n,t-1}=z_{n,t-1}, \mathbf{X}_{nt})$

   2. Apply CEP weights: $\prod_{t=1}^T P(\hat{Z}_{nt} = \hat{z}_{nt} \mid Z_{nt} = z_{nt}) = \prod_{t=1}^T \text{CEP}_t(z_{nt}, \hat{z}_{nt})$

   3. Multiply path probability by CEP weights

5. Marginalization: Sum path-specific likelihoods over all $L^T$ paths for each individual $n$, then sum log-transformed marginal likelihoods across all individuals.

Value

A single numeric value representing the total observed-data log-likelihood:

$\begin{aligned} \log \mathcal{L}(\boldsymbol{\theta}) &= \sum_{n=1}^N \log \Biggl[ \sum_{\mathbf{z}_n \in \{1,\dots,L\}^T} \Bigl( \prod_{t=1}^T \text{CEP}_t(z_{nt}, \hat{z}_{nt}) \Bigr) \cdot \\ &\quad P(Z_{n1}=z_{n1} \mid \mathbf{X}_{n1}) \cdot \prod_{t=2}^T P(Z_{nt}=z_{nt} \mid Z_{n,t-1}=z_{n,t-1}, \mathbf{X}_{nt}) \Biggr] \end{aligned}$

where $\mathbf{z}_n = (z_{n1},\dots,z_{nT})$ is a latent class path, $\hat{z}_{nt} = \texttt{Zs[[t]][n]}$ is the modal assignment, and $\boldsymbol{\theta}$ denotes all model parameters (beta, gama).

Note

When no covariates are included:

• Initial probabilities reduce to $P(Z_{n1} = l) = \pi_l$ (multinomial probabilities)

• Transition probabilities reduce to $P(Z_{nt} = l \mid Z_{n,t-1} = k) = \tau_{kl}^{(t)}$ (time-specific Markov transition probabilities)

See Also

LTA for three-step LTA estimation, get.CEP for CEP matrix computation

---

Calculate Number of Free Parameters in Latent Class Analysis

Description

Computes the total number of free parameters in an LCA model based on the number of categories per observed variable and the number of latent classes. This follows standard LCA parameterization with local independence assumption.

Usage

get.npar.LCA(poly.value, L)

Arguments

poly.value	A numeric vector of length $I$ where each element $K_i$ represents the number of response categories for observed variable $i$.
L	Integer specifying the number of latent classes.

Details

Parameter count derivation:

Fixed components (always present):

• Conditional response probabilities: $\sum_{i=1}^I (L \times K_i - 1)$ parameters

• Independent class proportions: $L-1$ parameters (since $\sum_{l=1}^L \pi_l = 1$)

Per-variable parameterization:

For each observed variable $i$ with $K_i$ categories:

• Each latent class requires $K_i$ conditional probabilities $P(X_i=k|Z=l)$

• With constraints $\sum_{k=1}^{K_i} P(X_i=k|Z=l) = 1$ for each class $l$

• Global constraints reduce total parameters to $L \times K_i - 1$ per variable

Value

Integer representing the total number of free parameters in the model:

$\text{npar} = \sum_{i=1}^I \underbrace{(L \times K_i - 1)}_{\text{free parameters}} + \underbrace{(L-1)}_{\text{class proportions}}$

Examples

# Example 1: 3 binary variables (K_i=2), 2 latent classes
poly.value <- c(2, 2, 2)  # Three binary variables
L <- 2
npar <- sum(poly.value * L - 1) + (L - 1)  # = (4-1)+(4-1)+(4-1) + 1 = 3+3+3+1 = 10
get.npar.LCA(poly.value, L)  # Returns 10

# Example 2: Mixed variable types (binary, ternary, quaternary)
poly.value <- c(2, 3, 4)  # Variables with 2, 3, and 4 categories
L <- 3
npar <- sum(poly.value * L - 1) + (L - 1)  # = (6-1)+(9-1)+(12-1) + 2 = 5+8+11+2 = 26
get.npar.LCA(poly.value, L)  # Returns 26

# Example 3: Single polytomous variable with 5 categories, 4 latent classes
poly.value <- 5
L <- 4
npar <- sum(poly.value * L - 1) + (L - 1)  # = (20-1) + 3 = 19+3 = 22
get.npar.LCA(poly.value, L)  # Returns 22

---

Calculate Number of Free Parameters in Latent Profile Analysis

Description

Computes the total number of free parameters in an LPA model based on the number of observed variables ($I$), number of latent profiles ($L$), and covariance structure constraints.

Usage

get.npar.LPA(I, L, constraint = "VV")

Arguments

I	Integer specifying the number of continuous observed variables.
L	Integer specifying the number of latent profiles.
constraint	Character string specifying covariance structure constraints. Supported options: Univariate case ($I = 1$): "UE" Equal variance across all profiles (1 shared variance parameter). "UV" Varying variances across profiles ($L$ profile-specific variance parameters). Multivariate case ($I > 1$): "E0" Equal variances across profiles, zero covariances. Requires $I$ variance parameters. "V0" Varying variances across profiles, zero covariances. Requires $L \times I$ variance parameters. "EE" Equal variances and equal covariances across profiles (homogeneous covariance matrix). Requires $\frac{I(I+1)}{2}$ parameters. "VE" Varying variances per profile, but equal covariances across profiles. Requires $L \times I + \frac{I(I-1)}{2}$ parameters. "EV" Equal variances across profiles, but varying covariances per profile. Requires $I + L \times \frac{I(I-1)}{2}$ parameters. "VV" Varying variances and varying covariances across profiles (heterogeneous covariance matrices). Requires $L \times \frac{I(I+1)}{2}$ parameters. list Custom constraints. Each element is a 2-element integer vector specifying variables whose covariance parameters are constrained equal across all classes. The constraint applies to: Variances: When both indices are identical (e.g., c(3,3) forces variance of variable 3 to be equal across classes) Covariances: When indices differ (e.g., c(1,2) forces covariance between variables 1 and 2 to be equal across classes) Constraints are symmetric (e.g., c(1,2) automatically constrains c(2,1)). All unconstrained parameters vary freely across classes while maintaining positive definiteness. Default: "VV".

Details

Parameter count breakdown:

1. Fixed components (always present):

   • Profile-specific means: $L \times I$ parameters

   • Independent class proportions: $L-1$ parameters (since $\sum_{l=1}^L \pi_l = 1$)

2. Covariance parameters (varies by constraint):

   $I = 1$:

   • "UE": 1 shared variance parameter

   • "UV": $L$ profile-specific variance parameters

   $I > 1$:

   • "E0": $I$ shared variance parameters (no covariances)

   • "V0": $L \times I$ profile-specific variance parameters (no covariances)

   • "EE": $\frac{I(I+1)}{2}$ parameters for one shared full covariance matrix

   • "VE": $L \times I$ diagonal variances (free per profile) + $\frac{I(I-1)}{2}$ off-diagonal covariances (shared across profiles)

   • "EV": $I$ diagonal variances (shared across profiles) + $L \times \frac{I(I-1)}{2}$ off-diagonal covariances (free per profile)

   • "VV": $L \times \frac{I(I+1)}{2}$ parameters for $L$ distinct full covariance matrices

Value

Integer representing the total number of free parameters in the model:

$\text{npar} = \underbrace{L \times I}_{\text{means}} + \underbrace{(L-1)}_{\text{class proportions}} + \underbrace{\text{covariance parameters}}_{\text{depends on constraint}}$

Note

Important considerations:

• For $I = 1$, only "UE" and "UV" are meaningful; "EE", "E0", "VV", "V0", etc., are treated as "UE" or "UV" respectively.

• Covariance parameters count only free elements in symmetric matrices (diagonal + upper triangle).

• If an user-defined constraint is provided, the function defaults to "VV" behavior but subtracts $(L-1) \times \text{length(constraint)}$.

• "VE" and "EV" constraints require $I > 1$ to be meaningful (otherwise no covariances exist).

Examples

# Univariate examples (I=1)
get.npar.LPA(I = 1, L = 2, constraint = "UE")
get.npar.LPA(I = 1, L = 3, constraint = "UV")

# Multivariate examples (I=3)
get.npar.LPA(I = 3, L = 2, constraint = "E0")
get.npar.LPA(I = 3, L = 2, constraint = "V0")
get.npar.LPA(I = 3, L = 2, constraint = "EE")
get.npar.LPA(I = 3, L = 2, constraint = "VV")
get.npar.LPA(I = 3, L = 2, constraint = "VE")
get.npar.LPA(I = 3, L = 2, constraint = "EV")

# User defined example
get.npar.LPA(I = 3, L = 2, constraint = list(c(1, 2), c(3, 3)))

---

Calculate Number of Free Parameters in Latent Transition Analysis

Description

Computes the total number of free parameters in a Latent Transition Analysis (LTA) model estimated via the three-step approach. The count depends on the number of latent classes, the number of time points, the number of covariates at each time point, and whether transition coefficients are constrained to be equal across time.

Usage

get.npar.LTA(covariates.ncol, L, covariates.timeCross = FALSE)

Arguments

covariates.ncol	An integer vector of length $T$ (number of time points). Each element $M_t$ represents the number of covariates (columns) for time point $t$. Must include an intercept column (all 1s) as the first covariate.
L	Integer scalar. Number of latent classes ($L \geq 2$).
covariates.timeCross	Logical. If TRUE, transition coefficients are constrained to be identical across all transitions (time-invariant effects). This requires that the number of covariates is the same for all time points after the first (i.e., $M_2 = M_3 = \dots = M_T$). If FALSE (default), each transition has its own set of coefficients.

Details

Parameterization:

Initial status model (time 1):

Multinomial logit model with $L$ classes (last class is reference). Number of free parameters: $M_1 \times (L-1)$.

Transition models (time $t \to t+1$):

For each transition, a multinomial logit model conditioned on previous class. For each origin class $k$ and destination class $l$ ($l \neq L$), there is a coefficient vector of length $M_{t+1}$. Total per transition: $L \times (L-1) \times M_{t+1}$ parameters. The constraint covariates.timeCross determines whether these parameters are shared across transitions.

Value

Integer representing the total number of free parameters:

$npar = M_1 \times (L-1) + \begin{cases} L \times (L-1) \times M_2 & \text{if } T>1 \text{ and time-invariant effects} \\ \sum_{t=2}^T L \times (L-1) \times M_t & \text{if } T>1 \text{ and time-varying effects} \\ 0 & \text{if } T=1 \end{cases}$

where:

• time-invariant effects corresponds to covariates.timeCross = TRUE

• time-varying effects corresponds to covariates.timeCross = FALSE

Note

Critical assumptions:

• The last latent class ($L$) is always the reference category for all logits.

• When covariates.timeCross = TRUE, it is assumed that all time points after the first have identical covariate structures ($M_2 = M_3 = \dots = M_T$). If violated, the function uses $M_1$ for all transitions to match LTA's internal behavior.

• For $T=1$, no transition parameters are estimated (pure latent class/profile analysis).

Examples

# Example 1: 2 time points, 2 classes, time-invariant transition coefficients
#   Time1: 2 covariates (intercept + 1 predictor)
#   Time2: 3 covariates (but constrained to match Time1 due to timeCross=TRUE)
covariates.ncol <- c(2, 3)
L <- 2
get.npar.LTA(covariates.ncol, L, covariates.timeCross = TRUE)

# Example 2: Same as above but time-varying coefficients
get.npar.LTA(covariates.ncol, L, covariates.timeCross = FALSE)

# Example 3: 3 time points, 3 classes, time-invariant coefficients
covariates.ncol <- c(2, 2, 2)  # All time points have identical covariates
L <- 3
get.npar.LTA(covariates.ncol, L, covariates.timeCross = TRUE)

# Example 4: 3 time points, 3 classes, time-varying coefficients
covariates.ncol <- c(2, 3, 4)
L <- 3
get.npar.LTA(covariates.ncol, L, covariates.timeCross = FALSE)

# Example 5: Single time point (equivalent to LCA)
covariates.ncol <- c(3)
L <- 4
get.npar.LTA(covariates.ncol, L)

---

Compute Posterior Latent Class Probabilities Based on Fixed Parameters

Description

Computes posterior probabilities of latent class membership for each observation using fixed conditional response probabilities (par) and fixed class prior probabilities (P.Z).

Usage

get.P.Z.Xn.LCA(response, par, P.Z)

Arguments

response	Numeric matrix ($N \times I$) of categorical responses. Categories are automatically remapped to 0-based integers internally via adjust.response.
par	3D array ($L \times I \times K_{\max}$) of fixed conditional response probabilities where: $L$ = number of latent classes $I$ = number of indicators $K_{\max}$ = maximum categories across indicators par[l, i, k] = $P(X_i = k-1 \mid Z = l)$ (using 1-based indexing for the array dimension corresponding to category k-1).
P.Z	Vector of length $L$ with fixed class prior probabilities ($\pi_l$). These values are used directly without re-estimation.

Details

Unlike an EM algorithm, this function does NOT iteratively update class prevalences. It performs a single calculation step based on Bayes' theorem:

$P(Z_n = l \mid \mathbf{X}_n) = \frac{\pi_l \prod_{i=1}^I P(X_{ni} = x_{ni} \mid Z_n = l)} {\sum_{k=1}^L \pi_k \prod_{i=1}^I P(X_{ni} = x_{ni} \mid Z_n = k)}$

where $\pi_l$ are the fixed priors provided in the P.Z argument.

Value

Numeric matrix ($N \times L$) of posterior probabilities. Rows sum to 1. Columns are named "Class.1", "Class.2", etc.

Examples

library(LCPA)
set.seed(123)
# Simulate data
data.obj <- sim.LCA(N = 200, I = 3, L = 2, IQ = 0.85)

# Fit a model to get parameters
fit <- LCA(data.obj$response, L = 2, method = "EM", nrep = 5)

# Calculate posteriors using fixed parameters from the fitted model
P.Z.Xn <- get.P.Z.Xn.LCA(
  response = data.obj$response,
  par = fit$params$par,
  P.Z = fit$params$P.Z
)
head(P.Z.Xn)

---