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 Python

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 latent class/profile models using multiple fit indices, likelihood ratio tests, and classification metrics. The models may have any class counts, including equal class counts.

Usage

compare.model(object1, object2, nrep.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.
nrep.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 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 and adjusted LMR tests, see LRT.test.VLMR

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

• Computes a Bayes factor approximation from the difference in SIC = -0.5 * BIC

Important requirements:

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

• The three likelihood-ratio procedures accept any pair of class counts, including equal class counts. The VLMR component requires models fitted to the same observations in the same order; LPA models must also use the same covariance constraint.

• nrep.bootstrap > 0 requires significant computational resources

Value

An object of class compare.model containing:

N

Named vector of sample sizes for the ordered models.

I

Named vector of indicator counts for the ordered models.

L

Named vector of latent class/profile counts for the ordered models.

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

Mplus TECH11 VLMR and adjusted LMR test results

LRT.Bootstrap.obj

Bootstrap LRT results (if nrep.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

# 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)

---

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	One non-missing, non-empty character string specifying the component to extract. Valid choices depend on the class of object; see Details for the complete class-specific listings.
...	Reserved for S3 method compatibility; no additional arguments are used.

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.

category.levels

List of the ordered observed response categories for each indicator.

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

Backend model object for method="NNE", method="Mplus", method="flexmix", method="Rmixmod", or method="RMixtComp". The latter three are SEM fits only.

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

Backend model object (neural network, Mplus, flexmix SEM, Rmixmod SEM, or RMixtComp SEM).

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.

vcov

Variance-covariance matrix of the free Step 3 coefficients.

information

Observed information matrix for method.SE="Numeric" or "Analytic"; otherwise NULL.

SE.diagnostics

Diagnostics for the selected standard-error method.

bound.diagnostics

Indices of Step 3 coefficients at or near an optimization bound.

iterations

Optimization iterations in Step 3.

converged

Logical indicator of successful NLopt termination.

Log.Lik.history

Step 3 log-likelihood history.

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).

step1.pool

Logical indicating whether Step 1 used the row-bound responses from all time points.

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.

vcov

Variance-covariance matrix of the free Step 3 coefficients.

information

Observed information matrix for method.SE="Numeric" or "Analytic"; otherwise NULL.

SE.diagnostics

Diagnostics for the selected standard-error method.

bound.diagnostics

Indices of Step 3 coefficients at or near an optimization bound.

iterations

Optimization iterations in Step 3.

converged

Logical indicator of successful NLopt termination.

Log.Lik.history

Step 3 log-likelihood history.

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.

ref.class

Reference class for the true regression coefficients.

call

Original simulation function call.

arguments

Input arguments used in simulation.

fit.index

Model fit indices object. Available components:

N

Sample size used to compute sample-size-dependent indices.

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

Schwarz information criterion on the log-likelihood scale ($-0.5 \times 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:

N, I, L

Named vectors giving sample size, indicator count, and class count for each model.

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

Mplus TECH11 VLMR and adjusted LMR test results.

LRT.Bootstrap.obj

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

call

The matched function call used for comparison.

arguments

List containing original input arguments (object1, object2, nrep.bootstrap).

SE

Standard error estimation results. Available components:

se

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

vcov

Variance-covariance matrix for method="Obs" or "Louis"; NULL for bootstrap.

hessian

Observed information matrix for method="Obs" or "Louis"; NULL for bootstrap.

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 available when method = "Obs" or "Louis". 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 participant $n$ belongs to class $l$ given the observed indicator vector $\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:\widehat{Z}_n=l}p_{nl},$

  where $N_l$ is the number of participants assigned to class $l$, and $\widehat{Z}_n=\arg\max_h p_{nh}$.

• 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:\widehat{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. doi: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 classification error probability (CEP) matrices for bias-corrected three-step latent class/profile and latent transition models with covariates.

Usage

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

Arguments

P.Z.Xns

A list of length $T$, where $T$ is the number of time points. Each element must be an $N \times L$ matrix of posterior class-membership probabilities $\tau_{ntl}=P(Z_{nt}=l\mid\mathbf{X}_{nt})$, with: rows corresponding to participants ($n=1,\ldots,N$); columns corresponding to latent classes ($l = 1, \ldots, L$); each row expected to sum to 1. All matrices are expected to have identical dimensions and to be ordered chronologically.

CEP.time.cross

Logical. If FALSE, a separate CEP matrix is estimated for each time point. If TRUE (default), posterior-weighted classification information is pooled across all time points to estimate a single time-invariant CEP matrix, which is then returned for every time point.

Details

The CEP matrix describes the relationship between the latent class and the modal class assignment obtained from posterior class-membership probabilities.

For participant $n$ at time $t$, the modal class assignment is defined as

$\widehat{Z}_{nt} = \arg\max_l \tau_{ntl}.$

For time point $t$, the CEP matrix is estimated as

$\mathrm{CEP}_t(l,k) = P(\widehat{Z}_{nt}=k\mid Z_{nt}=l) = \frac{ \sum_{n=1}^{N} \mathbb{1}(\widehat{Z}_{nt}=k) \tau_{ntl} }{ \sum_{n=1}^{N}\tau_{ntl} }.$

Equivalently, defining the posterior-weighted class prevalence as

$\hat{\pi}_{tl} = \frac{1}{N} \sum_{n=1}^{N} \tau_{ntl},$

the estimator can be written as

$\mathrm{CEP}_t(l,k) = \frac{ \sum_{n=1}^{N} \mathbb{1}(\widehat{Z}_{nt}=k) \tau_{ntl} }{ N\hat{\pi}_{tl} }.$

The resulting matrix is oriented as

$\mathrm{CEP}_t[\mathrm{true},\mathrm{assigned}],$

so that, in the Step-3 likelihood, the probability associated with an observed modal assignment $\widehat{Z}_{nt}$ under candidate latent class $l$ is obtained from

$\mathrm{CEP}_t(l,\widehat{Z}_{nt}).$

In other words, the column corresponding to the participant's observed modal assignment is selected, and the entries across rows give the corresponding classification probabilities under the candidate latent classes.

If CEP.time.cross = FALSE, the above estimator is computed separately for each time point.

If CEP.time.cross = TRUE, the numerator and denominator are pooled across time points before normalization:

$\mathrm{CEP}_{\mathrm{pool}}(l,k) = \frac{ \sum_{t=1}^{T}\sum_{n=1}^{N} \mathbb{1}(\widehat{Z}_{nt}=k) \tau_{ntl} }{ \sum_{t=1}^{T}\sum_{n=1}^{N} \tau_{ntl} }.$

Therefore, the pooled CEP is not the simple arithmetic mean of the time-specific CEP matrices. Rather, it is equivalent to a class-specific posterior-mass-weighted combination of the time-specific matrices.

Using a common pooled CEP across time assumes that the classification-error mechanism

$P(\widehat{Z}_{nt}=k\mid Z_{nt}=l)$

is sufficiently stable across time for a common CEP matrix to be appropriate. This classification-error invariance assumption is conceptually related to, but is not equivalent to, longitudinal measurement invariance.

Value

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

• rows index the latent ("true") class;

• columns index the modal ("assigned" or "predicted") class;

• entry $(l,k)$ estimates $P(\widehat{Z}_{nt}=k\mid Z_{nt}=l)$.

Thus, each row is a conditional probability distribution over modal assignments given a latent class and sums to 1 up to numerical precision. Column sums are not constrained to equal 1.

When CEP.time.cross = TRUE, all elements of the returned list contain the same pooled CEP matrix.

List elements are named "t1", "t2", ..., "tT".

Note

• The function assumes complete posterior-probability matrices; missing values are not explicitly handled.

• All elements of P.Z.Xns are expected to have the same numbers of individuals and latent classes.

• Posterior-probability rows are expected to sum to 1; this condition is not explicitly checked by the function.

• Modal assignment is obtained using which.max(). If two or more classes have exactly equal maximum posterior probabilities, which.max() selects the first maximum.

• If a latent class has zero posterior-weighted prevalence, the CEP for that class is undefined and division by zero may occur.

References

Liang, Q., de la Torre, J., & Law, N. (2023). Latent transition cognitive diagnosis model with covariates: A three-step approach. Journal of Educational and Behavioral Statistics, 48(6), 690–718. doi:10.3102/10769986231163320

Examples

# Simulate posterior probabilities for two time points,
# three latent classes, and 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
)

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

# Pooled CEP matrix used at all time points
cep_pooled <- get.CEP(
  P.Z.Xns,
  CEP.time.cross = TRUE
)

# Under the [true class, assigned class] orientation,
# rows should sum to one
rowSums(cep_time_specific[[1]])

---

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 participant $n$ belonging to class $l$

Note

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

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. doi:10.1080/10705511.2013.824786

Nylund-Gibson, K., & Choi, A. Y. (2018). Ten frequently asked questions about latent class analysis. Translational Issues in Psychological Science, 4(4), 440–461. doi: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)

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:

N

Number of observations used to fit the model

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}$

$\begin{cases} -2\sum_{n=1}^N\log\left\{\sum_{l=1}^L\pi_l \prod_{i=1}^I P(X_{ni}=x_{ni}\mid Z_n=l)\right\}, & \text{for LCA},\\ -2\sum_{n=1}^N\log\left\{\sum_{l=1}^L\pi_l \mathcal{N}(\mathbf{X}_n\mid\boldsymbol{\mu}_l, \boldsymbol{\Sigma}_l)\right\}, & \text{for LPA}, \end{cases}$

where $\pi_l$ is the prior probability of class $l$, and $\mathbf{X}_n$ is participant $n$'s indicator vector.

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

Schwarz information criterion on the log-likelihood scale: $\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} + npar \left[ \log(N) + 1.5 \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.

arguments

List containing the fitted model as object.

call

Matched function call.

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, par, P.Z)

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
par	A 3-dimensional array of dimension $L \times I \times K_{\max}$ containing conditional probabilities, where $par[l, i, q]$ represents $P(X_i = q-1 \mid Z=l)$ (after internal 0-based re-encoding). Must satisfy: For each class $l$ and indicator $i$: $\sum_{q=1}^{K_i} par[l,i,q] = 1$ Probabilities for non-existent categories (where $q > K_i$) are ignored but must be present in the array
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$

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-Conditional Likelihood Contribution: For each participant $n$ and class $l$, local independence gives

  $P(\mathbf{X}_n=\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].

• Participant-Level Marginal Likelihood Contribution: For each participant $n$, combine class-specific likelihoods weighted by class probabilities:

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

• Total Observed-Data Log-Likelihood: Sum the log marginal contributions across participants:

  $\log\mathcal{L}_{\mathrm{LCA}}= \sum_{n=1}^N\log\left\{\sum_{l=1}^L\pi_l \prod_{i=1}^I P(X_{ni}=x_{ni}\mid Z_n=l)\right\}.$

Value

A single numeric value equal to the total observed-data log-likelihood $\log\mathcal{L}_{\mathrm{LCA}}$ defined below.

---

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.

Usage

get.Log.Lik.LPA(response, means, covs, P.Z)

Arguments

response	A numeric matrix of dimension $N \times I$ containing continuous observations. Rows represent observations, columns represent variables. Missing values are not permitted.
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.
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$

Details

The log-likelihood calculation follows these steps:

• Class-Conditional Likelihood Contribution: For participant $n$ in profile $l$, the multivariate normal log density is

  $\log\mathcal{N}(\mathbf{X}_n\mid \boldsymbol{\mu}_l,\boldsymbol{\Sigma}_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).$

• Participant-Level Marginal Likelihood Contribution: The marginal density for participant $n$ is

  $P(\mathbf{X}_n)=\sum_{l=1}^L\pi_l \mathcal{N}(\mathbf{X}_n\mid \boldsymbol{\mu}_l,\boldsymbol{\Sigma}_l).$

• Total Observed-Data Log-Likelihood:

  $\log\mathcal{L}_{\mathrm{LPA}}= \sum_{n=1}^N\log\left\{\sum_{l=1}^L\pi_l \mathcal{N}(\mathbf{X}_n\mid \boldsymbol{\mu}_l,\boldsymbol{\Sigma}_l)\right\}.$

Value

A single numeric value equal to the total observed-data log-likelihood $\log\mathcal{L}_{\mathrm{LPA}}$ defined below.

---

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,
  ref.class,
  covariates.time.cross = FALSE
)

Arguments

params	A named list containing model parameters: beta: Matrix of size $(U_1+1)\times L$ with coefficients for the initial class membership multinomial logit model (time 1). The coefficient vector for the selected reference class is constrained to the zero vector. gamma: Nested list of transition coefficients. For transition to time $t$ (from time $t-1$ to $t$, where $t = 2, \dots, T$): gamma[[t-1]][[from_class]][[to_class]] Coefficient vector of length $U_t+1$ for transition from class from_class at time $t-1$ to class to_class at time $t$. Coefficients for transitions to the selected reference class are constrained to zero vectors for every origin class.
CEP	A list of $L \times L$ matrices (length = number of time points $T$). Element $(l,k)$ in CEP[[t]] estimates: $\mathrm{CEP}_t(l,k)= P(\widehat{Z}_{nt}=k\mid Z_{nt}=l)$ where $\widehat{Z}_{nt}$ is the modal class assignment and $Z_{nt}$ is the 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 participant $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 $\widehat{Z}_{nt}$ for participant $n$ at time $t$.
covariates	A list of design matrices (length = $T$). For time $t$, matrix dimension is $N\times(U_t+1)$. Must include an intercept column (all 1s) as the first column, i.e., $\boldsymbol{\zeta}_{nt}= (1,\zeta_{nt1},\ldots,\zeta_{ntU_t})^\top$. Covariates may differ across time points and between initial status ($t=1$) and transitions ($t \geq 2$).
ref.class	Integer between 1 and L; zero-coded reference class in params$beta and the destination-specific params$gamma coefficients.
covariates.time.cross	Logical. If TRUE, forces identical transition coefficients across all time points (gamma[[t]] is copied from gamma[[1]] for $t>1$). Default is FALSE.

Details

The log-likelihood calculation follows these steps:

1. Initial class probabilities (time 1): For participant $n$, compute using multinomial logit with covariates $\boldsymbol{\zeta}_{n1}$:

   $P(Z_{n1}=l\mid\boldsymbol{\zeta}_{n1}) = \frac{\exp(\boldsymbol{\beta}_l^\top\boldsymbol{\zeta}_{n1})} {\sum_{h=1}^L\exp(\boldsymbol{\beta}_h^\top \boldsymbol{\zeta}_{n1})}$

   where $\boldsymbol{\beta}_{l_0}=\mathbf{0}$ for reference class $l_0$ represented in params.

2. 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,\boldsymbol{\zeta}_{nt}) = \frac{\exp(\boldsymbol{\gamma}_{klt}^\top\boldsymbol{\zeta}_{nt})} {\sum_{h=1}^L\exp(\boldsymbol{\gamma}_{kht}^\top \boldsymbol{\zeta}_{nt})}$

   where $\boldsymbol{\gamma}_{k,l_0,t}=\mathbf{0}$ for every origin class $k$ and reference destination $l_0$.

3. Scaled forward recursion: Initialize

   $\alpha_{n1}(l)=P(Z_{n1}=l\mid\boldsymbol{\zeta}_{n1}) \mathrm{CEP}_1(l,\widehat{Z}_{n1})$

   and recursively compute

   $\alpha_{nt}(l)=\mathrm{CEP}_t(l,\widehat{Z}_{nt}) \sum_{k=1}^L\alpha_{n,t-1}(k) P(Z_{nt}=l\mid Z_{n,t-1}=k,\boldsymbol{\zeta}_{nt}).$

   This forward recursion marginalizes exactly over all latent paths without explicitly constructing the $L^T$ paths.

4. Analytic score: Optimization uses the corresponding scaled backward recursion to obtain state and transition posterior probabilities for the exact multinomial-logit score.

Value

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

$\begin{aligned} \log \mathcal{L}(\boldsymbol{\beta},\boldsymbol{\gamma}) &= \sum_{n=1}^N \log \Biggl[ \sum_{z_{n1}=1}^L\cdots\sum_{z_{nT}=1}^L \Bigl(\prod_{t=1}^T \mathrm{CEP}_t(z_{nt},\widehat{Z}_{nt})\Bigr) \cdot \\ &\quad P(Z_{n1}=z_{n1}\mid\boldsymbol{\zeta}_{n1}) \cdot \prod_{t=2}^T P(Z_{nt}=z_{nt}\mid Z_{n,t-1}=z_{n,t-1}, \boldsymbol{\zeta}_{nt}) \Biggr] \end{aligned}$

where $z_{n1},\ldots,z_{nT}$ is a latent class path and Zs[[t]][n] stores the modal assignment $\widehat{Z}_{nt}$.

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: $L\sum_{i=1}^I(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=q\mid Z=l)$

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

• The $L$ class-specific sum-to-one constraints leave $L(K_i-1)$ free parameters per variable

Value

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

$\text{npar} = L\sum_{i=1}^I(K_i-1) + (L-1)$

Examples

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

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

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

---

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.time.cross = FALSE)

Arguments

covariates.ncol	An integer vector of length $T$ (number of time points). Each element equals $U_t+1$: $U_t$ observed covariates plus the all-ones intercept column at time $t$.
L	Integer scalar. Number of latent classes ($L \geq 2$).
covariates.time.cross	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., $U_2=U_3=\cdots=U_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 (one class is the reference). Number of free parameters: $(U_1+1)(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 $U_{t+1}+1$. Total per transition: $L(L-1)(U_{t+1}+1)$ parameters. The constraint covariates.time.cross determines whether these parameters are shared across transitions.

Value

Integer representing the total number of free parameters:

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

where:

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

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

Note

Critical assumptions:

• One latent class is selected as the reference category for all logits; this choice does not change the count.

• When covariates.time.cross = TRUE, it is assumed that all time points after the first have identical covariate structures ($U_2=U_3=\cdots=U_T$). If violated, the function requires the transition design matrices at times 2 through $T$ to have the same number of columns.

• 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; this determines the shared transition block
covariates.ncol <- c(2, 3)
L <- 2
get.npar.LTA(covariates.ncol, L, covariates.time.cross = TRUE)

# Example 2: Same as above but time-varying coefficients
get.npar.LTA(covariates.ncol, L, covariates.time.cross = 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.time.cross = 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.time.cross = 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, category.levels)

Arguments

response	Numeric matrix ($N \times I$) of categorical responses.
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, q] = $P(X_i=q-1\mid Z=l)$ (using 1-based array indexing for the dimension corresponding to category $q-1$).
P.Z	Vector of length $L$ with fixed class prior probabilities ($\pi_l$). These values are used directly without re-estimation.
category.levels	List of length $I$. Element $i$ contains the ordered response categories for indicator $i$ as fixed in Step 1. Categories absent from the current sample remain in this mapping.

Details

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

$\tau_{nl}=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_{h=1}^L\pi_h\prod_{i=1}^I P(X_{ni}=x_{ni}\mid Z_n=h)}$

where the class probabilities and conditional response probabilities are fixed by the P.Z and par arguments.

Value

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

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,
  category.levels = fit$params$category.levels
)
head(P.Z.Xn)

---

Compute Posterior Latent Profile Probabilities Based on Fixed Parameters

Description

Computes posterior probabilities of latent profile membership for each observation using fixed profile parameters (means, covariances) and fixed prior probabilities.

Usage

get.P.Z.Xn.LPA(response, means, covs, P.Z)

Arguments

response	Numeric matrix ($N \times I$) of continuous responses. Missing values are not allowed. Data should typically be standardized prior to analysis.
means	Numeric matrix ($L \times I$) of fixed profile means where: $L$ = number of latent profiles $I$ = number of observed variables Row $l$ contains profile-specific means $\boldsymbol{\mu}_l$.
covs	3D array ($I \times I \times L$) of fixed profile covariance matrices where: covs[, , l] = profile-specific covariance matrix $\boldsymbol{\Sigma}_l$ Each slice must be symmetric and positive definite.
P.Z	Vector of length $L$ with fixed profile prior probabilities ($\pi_l$). These values are used directly without re-estimation.

Details

Unlike an EM algorithm, this function does NOT iteratively update profile prevalences. It performs a single E-step calculation:

$\tau_{nl}=P(Z_n=l\mid\mathbf{X}_n)= \frac{\pi_l\mathcal{N}(\mathbf{X}_n\mid \boldsymbol{\mu}_l,\boldsymbol{\Sigma}_l)} {\sum_{h=1}^L\pi_h\mathcal{N}(\mathbf{X}_n\mid \boldsymbol{\mu}_h,\boldsymbol{\Sigma}_h)}$

where the profile probabilities, means, and covariance matrices are fixed by the P.Z, means, and covs arguments.

Value

Numeric matrix ($N \times L$) of posterior probabilities. Rows sum to 1. Columns are named "Profile 1", "Profile 2", and so on.

Examples

library(LCPA)
set.seed(123)
data.obj <- sim.LPA(N = 300, I = 2, L = 2, constraint = "VV")
fit <- LPA(data.obj$response, L = 2, method = "EM", nrep = 5)

# Calculate posteriors using fixed parameters from a fitted model
P.Z.Xn <- get.P.Z.Xn.LPA(
  response = data.obj$response,
  means = fit$params$means,
  covs = fit$params$covs,
  P.Z = fit$params$P.Z
)
head(P.Z.Xn)

---