Package 'OpenMx'

Description

Below we provide a brief, technical description of each status code followed by a more colloquial, less precise desciption.

• 0,‘OK’: Optimization succeeded. Everything seems fine.

• 1,‘OK/green’: Optimization succeeded, but the sequence of iterates has not yet converged (Mx status GREEN). This condition is only detected by NPSOL. The solution is likely okay. You might want to re-run the model from its final esimates to resolve this.

• 2,‘infeasible linear constraint’: The linear constraints and bounds could not be satisfied. The problem has no feasible solution. Right now, it should not be possible obtain this status code, so call Ripley's.

• 3,‘infeasible non-linear constraint’: The nonlinear constraints and bounds could not be satisfied. The problem may have no feasible solution. Sometimes this happens when your starting values do not satisfy the constraints. Also, optimization could not satisfy the constraints and get a better fit.

• 4,‘iteration limit’: Optimization was stopped prematurely because the iteration limit was reached (Mx status BLUE). You might want to rerun: m1 = mxRun(m1) or increase the iteration limit (see mxOption). The optimizer took all the steps it could and did not finish. You can increase the number of steps or get better starting values.

• 5,‘not convex’: The Hessian at the solution does not appear to be convex (Mx status RED). There may be more than one solution to the model. See mxCheckIdentification. I would not trust this solution; it does not appear to be a good one. Perhaps, try mxTryHard.

• 6,‘nonzero gradient’: The model does not satisfy the first-order optimality conditions to the required accuracy, and no improved point for the merit function could be found during the final linesearch (Mx status RED). I would not trust this solution; it does not appear to be a good one. To search nearby, see mxTryHard.

• 7,‘bad deriv’: You have provided analytic derivatives. However, your provided derivatives differ too much from numerically approximated derivatives. Double check your math.

• 9,‘internal error’: An input parameter was invalid. The most likely cause is a bug in the code. Please report occurrences to the OpenMx developers.

• 10,‘infeasible start’: Starting values were infeasible. Modify the start values for one or more parameters. For instance, set means to their measured value, or set variances and covariances to plausible values. See mxAutoStart and mxTryHard.

Usage

as.statusCode(code)

Arguments

See Also

mxBootstrap summary.MxModel

Description

This is an internal class and should not be used directly.

See Also

mxComputeEM, mxComputeGradientDescent, mxComputeHessianQuality, mxComputeIterate, mxComputeNewtonRaphson, mxComputeNumericDeriv

Description

Data set used in some of OpenMx's examples, for instance WLS. The data were reported in Bollen (1989, p. 428, Table 9.4) This set includes data from 75 developing countries each assessed on four measures of democracy measured twice (1960 and 1965), and three measures of industrialization measured once (1960).

Usage

data("Bollen")

Format

A data frame with 75 observations on the following 11 numeric variables.

y1

Freedom of the press, 1960

y2

Freedom of political opposition, 1960

y3

Fairness of elections, 1960

y4

Effectiveness of elected legislature, 1960

y5

Freedom of the press, 1965

y6

Freedom of political opposition, 1965

y7

Fairness of elections, 1965

y8

Effectiveness of elected legislature, 1965

x1

GNP per capita, 1960

x2

Energy consumption per capita, 1960

x3

Percentage of labor force in industry, 1960

Details

Variables y1-y4 and y5-y8 are typically used as indicators of the latent trait of “political democracy” in 1960 and 1965 respectively. x1-x3 are used as indicators of industrialization (1960).

Source

The sem package (in turn, via personal communication Bollen to Fox)

References

Bollen, K. A. (1979). Political democracy and the timing of development. American Sociological Review, 44, 572-587.

Bollen, K. A. (1980). Issues in the comparative measurement of political democracy. American Sociological Review, 45, 370-390.

Bollen, K. A. (1989). Structural equation models. New York: Wiley-Interscience.

Examples

data(Bollen)
str(Bollen)
plot(y1 ~ y2, data = Bollen)

Description

This function returns the vectorization of an input matrix in a column by column traversal of the matrix. The output is returned as a column vector.

Usage

cvectorize(x)

Arguments

See Also

rvectorize, vech, vechs

Examples

cvectorize(matrix(1:9, 3, 3))
cvectorize(matrix(1:12, 3, 4))

Description

Data set used in some of OpenMx's examples.

Usage

data("demoOneFactor")

Format

A data frame with 500 observations on the following 5 numeric variables.

x1

x2

x3

x4

x5

Details

Variables x1-x5 are typically used as indicators of the latent trait.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(demoOneFactor)
cov(demoOneFactor)
cor(demoOneFactor)

Description

Data set used in some of OpenMx's examples.

Usage

data("demoTwoFactor")

Format

A data frame with 500 observations on the following 10 numeric variables.

x1

x2

x3

x4

x5

y1

y2

y3

y4

y5

Details

Variables x1-x5 are typically used as indicators of one latent trait. Variables y1-y5 are typically used as indicators of another latent trait.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(demoTwoFactor)
cov(demoTwoFactor)
cor(demoTwoFactor)

Description

Given an input matrix, diag2vec returns a column vector of the elements along the diagonal.

Usage

diag2vec(x)

Arguments

Details

Similar to the function diag, except that the input argument is always treated as a matrix (i.e., it doesn't have diag()'s functions of returning an Identity matrix from an nrow specification, nor to return a matrix wrapped around a diagonal if provided with a vector). To get vector2matrix functionality, call vec2diag.

See Also

vec2diag

Examples

diag2vec(matrix(1:9, nrow=3))
#      [,1]
# [1,]    1
# [2,]    5
# [3,]    9

diag2vec(matrix(1:12, nrow=3, ncol=4))
#      [,1]
# [1,]    1
# [2,]    5
# [3,]    9

Description

An S4 base class for discrete marginal distributions

See Also

mxMarginalPoisson, mxMarginalNegativeBinomial

Description

Data for extended twin example ETC88.R

Usage

data("dzfData")

Format

A data frame with 2007 observations on the following 37 variables.

famid

a numeric vector

e1

a numeric vector

e2

a numeric vector

e3

a numeric vector

e4

a numeric vector

e5

a numeric vector

e6

a numeric vector

e7

a numeric vector

e8

a numeric vector

e9

a numeric vector

e10

a numeric vector

e11

a numeric vector

e12

a numeric vector

e13

a numeric vector

e14

a numeric vector

e15

a numeric vector

e16

a numeric vector

e17

a numeric vector

e18

a numeric vector

a1

a numeric vector

a2

a numeric vector

a3

a numeric vector

a4

a numeric vector

a5

a numeric vector

a6

a numeric vector

a7

a numeric vector

a8

a numeric vector

a9

a numeric vector

a10

a numeric vector

a11

a numeric vector

a12

a numeric vector

a13

a numeric vector

a14

a numeric vector

a15

a numeric vector

a16

a numeric vector

a17

a numeric vector

a18

a numeric vector

Examples

data(dzfData)
str(dzfData)

Description

Data for extended twin example ETC88.R

Usage

data("dzmData")

Format

A data frame with 1990 observations on the following 37 variables.

famid

a numeric vector

e1

a numeric vector

e2

a numeric vector

e3

a numeric vector

e4

a numeric vector

e5

a numeric vector

e6

a numeric vector

e7

a numeric vector

e8

a numeric vector

e9

a numeric vector

e10

a numeric vector

e11

a numeric vector

e12

a numeric vector

e13

a numeric vector

e14

a numeric vector

e15

a numeric vector

e16

a numeric vector

e17

a numeric vector

e18

a numeric vector

a1

a numeric vector

a2

a numeric vector

a3

a numeric vector

a4

a numeric vector

a5

a numeric vector

a6

a numeric vector

a7

a numeric vector

a8

a numeric vector

a9

a numeric vector

a10

a numeric vector

a11

a numeric vector

a12

a numeric vector

a13

a numeric vector

a14

a numeric vector

a15

a numeric vector

a16

a numeric vector

a17

a numeric vector

a18

a numeric vector

Examples

data(dzmData)
str(dzmData)

Description

Data for extended twin example ETC88.R

Usage

data("dzoData")

Format

A data frame with 3981 observations on the following 37 variables.

famid

a numeric vector

e1

a numeric vector

e2

a numeric vector

e3

a numeric vector

e4

a numeric vector

e5

a numeric vector

e6

a numeric vector

e7

a numeric vector

e8

a numeric vector

e9

a numeric vector

e10

a numeric vector

e11

a numeric vector

e12

a numeric vector

e13

a numeric vector

e14

a numeric vector

e15

a numeric vector

e16

a numeric vector

e17

a numeric vector

e18

a numeric vector

a1

a numeric vector

a2

a numeric vector

a3

a numeric vector

a4

a numeric vector

a5

a numeric vector

a6

a numeric vector

a7

a numeric vector

a8

a numeric vector

a9

a numeric vector

a10

a numeric vector

a11

a numeric vector

a12

a numeric vector

a13

a numeric vector

a14

a numeric vector

a15

a numeric vector

a16

a numeric vector

a17

a numeric vector

a18

a numeric vector

Examples

data(dzoData)
str(dzoData)

Description

eigenval computes the real parts of the eigenvalues of a square matrix. eigenvec computes the real parts of the eigenvectors of a square matrix. ieigenval computes the imaginary parts of the eigenvalues of a square matrix. ieigenvec computes the imaginary parts of the eigenvectors of a square matrix. eigenval and ieigenval return nx1 matrices containing the real or imaginary parts of the eigenvalues, sorted in decreasing order of the modulus of the complex eigenvalue. For eigenvalues without an imaginary part, this is equivalent to sorting in decreasing order of the absolute value of the eigenvalue. (See Mod for more info.) eigenvec and ieigenvec return nxn matrices, where each column corresponds to an eigenvector. These are sorted in decreasing order of the modulus of their associated complex eigenvalue.

Usage

eigenval(x)
eigenvec(x)
ieigenval(x)
ieigenvec(x)

Arguments

Details

Eigenvectors returned by eigenvec and ieigenvec are normalized to unit length.

See Also

eigen

Examples

A <- mxMatrix(values = runif(25), nrow = 5, ncol = 5, name = 'A')
G <- mxMatrix(values = c(0, -1, 1, -1), nrow=2, ncol=2, name='G')

model <- mxModel(A, G, name = 'model')

mxEval(eigenvec(A), model)
mxEval(eigenvec(G), model)
mxEval(eigenval(A), model)
mxEval(eigenval(G), model)
mxEval(ieigenvec(A), model)
mxEval(ieigenvec(G), model)
mxEval(ieigenval(A), model)
mxEval(ieigenval(G), model)

Description

Data set used in some of OpenMx's examples.

Usage

data("example1")

Format

A data frame with 400 observations on the following variables.

IDNum

Twin pair ID

Zygosity

Zygosity of the twin pair

X1

X variable for twin 1

Y1

Y variable for twin 1

X2

X variable for twin 2

Y2

Y variable for twin 2

Details

Same as example2 but in wide format instead of tall.

Source

Classic Mx Manual.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(example1)
plot(X2 ~ X1, data = example1)

Description

Data set used in some of OpenMx's examples.

Usage

data("example2")

Format

A data frame with 800 observations on the following variables.

IDNum

ID number

TwinNum

Twin ID number

Zygosity

Zygosity of the twin

X

X variable for twins 1 and 2

Y

Y variable for twins 1 and 2

Details

Same as example1 but in tall format instead of wide.

Source

Classic Mx Manual.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation.

Examples

data(example2)
plot(Y ~ X, data = example2)

Description

Matrix exponential

Usage

expm(x)

Arguments

Description

Data set used in some of OpenMx's examples.

Usage

data("factorExample1")

Format

A data frame with 500 observations on the following variables.

x1

x2

x3

x4

x5

x6

x7

x8

x9

Details

This appears to be a three factor model, but perhaps with an odd loading structure.

Source

Simulated

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(factorExample1)
round(cor(factorExample1), 2)

factanal(covmat=cov(factorExample1), factors=3, rotation="promax")

Description

Data set used in some of OpenMx's examples.

Usage

data("factorScaleExample1")

Format

A data frame with 200 observations on the following variables.

X1

X2

X3

X4

X5

X6

X7

X8

X9

X10

X11

X12

Details

This appears to be a three factor model with factor 1 loading on X1-X4, factor 2 on X5-X8, and factor 3 on X9-X12.

Source

Simulated

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(factorScaleExample1)
round(cor(factorScaleExample1), 2)

Description

Data set used in some of OpenMx's examples.

Usage

data("factorScaleExample2")

Format

A data frame with 200 observations on the following variables.

X1

X2

X3

X4

X5

X6

X7

X8

X9

X10

X11

X12

Details

Three-factor data with factor 1 loading on X1-X4, factor 2 on X5-X8, and factor 3 on X9-X12. It differs from factorScaleExample1 in the scaling of the variables.

Source

Simulated

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(factorScaleExample2)
round(cor(factorScaleExample2), 2)

data(factorScaleExample2)
plot(sapply(factorScaleExample1, var), type='l', ylim=c(0, 6), lwd=3)
lines(1:12, sapply(factorScaleExample2, var), col='blue', lwd=3)

Description

If there is an expectation, then the fitfunction should always depend on it. Hence, subclasses that implement this method must ignore the passed-in dependencies and use "dependencies <- callNextMethod()" instead.

Usage

## S4 method for signature 'MxBaseFitFunction'
genericFitDependencies(.Object, flatModel, dependencies)

Arguments

Description

This classic data set contains of intelligence-test scores from 301 children on 26 tests of cognitive ability.

The tests cover mental speed, memory, mathematical-ability, spatial, and verbal ability as listed below.

The data are also available in the MBESS package.

Usage

data("HS.ability.data")

Format

A data frame comprising 301 observations on 22 variables:

id

student ID number (int)

Gender

Sex (Factor w/ 2 levels “Female” and “Male”)

grade

Grade in school (integer 7 or 8)

agey

Age in years (integer)

agem

Age in months (integer)

school

School attended (Factor w/2 levels “Grant-White” and “Pasteur”)

addition

A speed test of addition (numeric)

code

A speed test (numeric)

counting

A speed test of counting groups of dots (numeric)

straight

A speed test discriminating straight and curved capitals (numeric)

wordr

A memory subtest of word recognition

numberr

A memory subtest of number recognition

figurer

A memory subtest of figure recognition

object

A memory subtest: object-number test

numberf

A memory subtest: number-figure test

figurew

A memory subtest: figure-word test

deduct

A mathematical subtest of deduction

numeric

A mathematical subtest of numerical puzzles

problemr

A mathematical subtest of problem reasoning

series

A mathematical subtest of series completion

arithmet

A mathematical subtest: Woody-McCall mixed fundamentals, form I

visual

A spatial subtest of visual perception

cubes

A spatial subtest

paper

A spatial subtest paper form board

flags

A spatial subtest (also known as lozenges)

paperrev

A spatial subtest additional paper form board test (can substitute for paper)

flagssub

A spatial subtest additional lozenges test (can substitute for flags)

general

A verbal subtest of general information

paragrap

A verbal subtest of paragraph comprehension

sentence

A verbal subtest of sentence completion

wordc

A verbal subtest of word classification

wordm

A verbal subtest of word meaning

Details

The data are from children who differ in grade (seventh- and eighth-grade) and are nested in one of two schools (Pasteur and Grant-White). You will see it in use elsewhere, both in R (lavaan, and MBESS), and in Joreskog (1969) reporting a CFA on the Grant-White school subject subset.

Some tests are alternate or substitute forms, e.g. paperrev (a paper form board test) can substitute for paper and flagssub for the lozenges test flags.

Source

Holzinger, K., and Swineford, F. (1939).

References

Holzinger, K., and Swineford, F. (1939). A study in factor analysis: The stability of a bifactor solution. Supplementary Educational Monograph, no. 48. Chicago: University of Chicago Press.

Joreskog, K. G. (1969). A general approach to confirmatory maximum likelihood factor analysis. Psychometrika, 34, 183-202.

Examples

data(HS.ability.data)
str(HS.ability.data)
levels(HS.ability.data$school)
plot(flags ~ flagssub, data = HS.ability.data)

Description

The dependency tracking system ensures that algebra and fitfunctions are not recomputed if their inputs have not changed. Dependency information is computed prior to handing the model off to the optimizer to reduce overhead during optimization.

Usage

imxAddDependency(source, sink, dependencies)

Arguments

Details

Each free parameter keeps track of all the objects that store that free parameter and the transitive closure of all algebras and fit functions that depend on that free parameter. Similarly, each definition variable keeps track of all the objects that store that free parameter and the transitive closure of all the algebras and fit functions that depend on that free parameter. At each iteration of the optimization, when the free parameter values are updated, all of the dependencies of that free parameter are marked as dirty (see omxFitFunction.repopulateFun). After an algebra or fit function is computed, omxMarkClean() is called to to indicate that the algebra or fit function is updated. Similarly, when definition variables are populated in FIML, all of the dependencies of the definition variables are marked as dirty. Particularly for FIML, the fact that non-definition-variable dependencies remain clean is a big performance gain.

Description

Convert "Auto" placeholders in global mxOptions to actual default values.

Usage

imxAutoOptionValue(optionName, optionList = options()$mxOption)

Arguments

Details

This is an internal function exported for documentation purposes. Its primary purpose is to convert the on-load value of "Auto"to valid values for mxOptions ‘Gradient step size’, ‘Gradient iterations’, and ‘Function precision’–respectively, 1.0e-7, 1L, and 1e-14.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxCheckMatrices(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxCheckVariables(flatModel, namespace)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxConDecMatrixSlots(object)

Arguments

Description

A string vector of valid constraint binary relations.

Usage

imxConstraintRelations

Format

An object of class character of length 3.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxConvertIdentifier(identifiers, modelname, namespace, strict = FALSE)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxConvertLabel(label, modelname, dataname, namespace)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxConvertSubstitution(substitution, modelname, namespace)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxCreateMatrix(
  .Object,
  labels,
  values,
  free,
  lbound,
  ubound,
  nrow,
  ncol,
  byrow,
  name,
  condenseSlots,
  joinKey,
  joinModel
)

Arguments

Description

Valid types of data that can be contained by MxData

Usage

imxDataTypes

Format

An object of class character of length 4.

Description

Returns a list of display-friendly object slot names This is an internal function exported for those people who know what they are doing.

Usage

imxDefaultGetSlotDisplayNames(x, pattern = ".*")

Arguments

Description

Deparse for MxObjects

Usage

imxDeparse(object, indent = "   ")

Arguments

Description

Are submodels dependence?

Usage

imxDependentModels(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxDetermineDefaultOptimizer()

Details

Returns a character, the default optimizer

Description

This API is visible to permit testing. Please do not use.

Usage

imxDmvnorm(loc, mean, sigma)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxEvalByName(name, model, compute = FALSE, show = FALSE)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxExtractMethod(model, index)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxExtractNames(lst)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxExtractReferences(lst)

Arguments

Description

Checks for and extracts a slot from the object This is an internal function exported for those people who know what they are doing.

Usage

imxExtractSlot(x, name)

Arguments

Description

Remove hierarchical structure from model

Usage

imxFlattenModel(model, namespace, unsafe = FALSE)

Arguments

Description

Remove free parameters and fit function from model.

Usage

imxFreezeModel(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxGenerateLabels(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxGenerateNamespace(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxGenericModelBuilder(
  model,
  lst,
  name,
  manifestVars,
  latentVars,
  productVars,
  submodels,
  remove,
  independent
)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxGenSwift(tc, sites, sfile)

Arguments

Description

Resize an MxMatrix while preserving entries

Usage

imxGentleResize(matrix, dimnames)

Arguments

Value

a resized MxMatrix

Examples

m1 <- mxMatrix(values=1:9, nrow=3, ncol=3,
               dimnames=list(paste0('r',1:3), paste0('c',1:3)))

imxGentleResize(m1, dimnames=list(paste0('r',c(1,3,5)),
                                  paste0('c',c(2,4,6))))

Description

This is an internal function exported for those people who know what they are doing.

This function hard codes responses to a set of environments, like detecting snowfall, or running on a cluster where "OMP_NUM_THREADS" is set or otherwise returning 1 or 2 cores to avoid consuming all the resources on CRAN's test machines during release cycles.

This makes it not suitable for getting the number of available threads.

To get the number of cores available locally you want omxDetectCores or perhaps the detectCores function in the parallel package.

Usage

imxGetNumThreads()

Description

Returns a list of display-friendly object slot names This is an internal function exported for those people who know what they are doing.

Usage

imxGetSlotDisplayNames(
  object,
  pattern = ".*",
  slotList = slotNames(object),
  showDots = FALSE,
  showEmpty = FALSE
)

Arguments

Description

This is an internal function exported for those people who know what they are doing. This function checks if a model (or its submodels) has at least one MxConstraint.

Usage

imxHasConstraint(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing. This function checks if a model (or its submodels) has at least one definition variable.

Usage

imxHasDefinitionVariable(model)

Arguments

Description

imxHasNPSOL

Usage

imxHasNPSOL()

Value

Returns TRUE if the NPSOL proprietary optimizer is compiled and linked with OpenMx. Otherwise FALSE.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxHasOpenMP()

Description

This is an internal function exported for those people who know what they are doing. This function checks if a model (or its submodels) has any thresholds.

Usage

imxHasThresholds(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing. This function checks if a model uses a fitfunction with WLS units.

Usage

imxHasWLS(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxIdentifier(namespace, name)

Arguments

Description

Are submodels independent?

Usage

imxIndependentModels(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxInitModel(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxIsDefinitionVariable(name)

Arguments

Description

This is an internal function exported for those people who know what they are doing. If you don't know what you're doing, but want to, here's a brief description of the function. You give this function an MxModel. It returns TRUE if the model is multilevel and FALSE otherwise.

Usage

imxIsMultilevel(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxIsPath(value)

Arguments

Description

This is an internal function exported for those people who know what they are doing. If you don't know what you're doing, but want to, here's a brief description of the function. You give this function an MxModel. It returns TRUE if the model is a state space model and FALSE otherwise.

Usage

imxIsStateSpace(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxLocateFunction(function_name)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxLocateIndex(model, name, referant)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxLocateLabel(label, model, parameter)

Arguments

Description

This is the code that the backend uses to write diagnostic information to standard error. This function should not be called from R. We make it available only for testing.

Usage

imxLog(str)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxLookupSymbolTable(name)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxModelBuilder(
  model,
  lst,
  name,
  manifestVars,
  latentVars,
  productVars,
  submodels,
  remove,
  independent
)

Arguments

Details

TODO: It probably makes sense to split this into separate methods. For example, modelAddVariables and modelRemoveVariables could be their own methods. This would reduce some cut&paste duplication.

Description

A list of supported model types

Usage

imxModelTypes

Format

An object of class list of length 3.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxMpiWrap(fun)

Arguments

Description

For this to work, classic mx must be installed, and callable from the command line.

Usage

imxOriginalMx(mx.filename, output.directory)

Arguments

Value

processed matrix output.

Examples

## Not run: 
output = imxOriginalMx(mx.filename = "power1.mx", "~/Desktop")

## End(Not run)

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxPenaltyTypes

Format

An object of class character of length 3.

Details

Types of regularization penalties.

Description

Potentially enable the PPML optimization for the given model.

Usage

imxPPML(model, flag = TRUE)

Arguments

Description

PPML can be applied to a number of special cases. This function will test the given model for all of these special cases.

Usage

imxPPML.Test.Battery(
  model,
  verbose = FALSE,
  testMissingness = TRUE,
  testPermutations = TRUE,
  testEstimates = TRUE,
  testFakeLatents = TRUE,
  tolerances = c(0.001, 0.001, 0.001)
)

Arguments

Details

Requirements for model passed to this function: - Path-specified - Means vector must be present - Covariance data (with data means vector) - (Recommended) All error variances should be specified on the diagonal of the S matrix, and not as a latent with a loading only on to that manifest

Function will test across all permutations of: - Covariance vs Raw data - Means vector present vs Means vector absent - Path versus Matrix specification - All orders of permutations of latents with manifests

Description

Test that PPML solutions match non-PPML solutions.

Usage

imxPPML.Test.Test(
  model,
  checkLL = TRUE,
  checkByName = FALSE,
  tolerance = 0.5,
  testEstimates = TRUE
)

Arguments

Details

This is an internal function used for comparing PPML and non-PPML solutions. Generally, non-developers will not use this function.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxPreprocessModel(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxReplaceMethod(x, name, value)

Arguments

Description

Replace parts of a model

Usage

imxReplaceModels(model, replacements)

Arguments

Description

Checks for and replaces a slot from the object This is an internal function exported for those people who know what they are doing.

Usage

imxReplaceSlot(x, name, value, check = TRUE)

Arguments

Description

Prints a show status string to the console without emitting a newline.

Usage

imxReportProgress(info, eraseLen)

Arguments

Examples

library(OpenMx)

previousLen <<- 0

easyReportProcess <- function(msg) {
	imxReportProgress(msg, previousLen)
	previousLen <<- nchar(msg)
}

demo <- function() {
	easyReportProcess("abc123")
	Sys.sleep(1)
	easyReportProcess("this is much longer")
	Sys.sleep(1)
	easyReportProcess("this is short")
	Sys.sleep(1)
	easyReportProcess("almost done")
	Sys.sleep(1)
	easyReportProcess("")
	cat("DONE!", fill=TRUE)
}

demo()

Description

Vector of reserved names

Usage

imxReservedNames

Format

An object of class character of length 7.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxReverseIdentifier(model, name)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxRobustSE(model, details = FALSE, dependencyModels = character(0))

Arguments

Details

This function computes robust standard errors via a sandwich estimator. The "bread" of the sandwich is the numerically computed inverse Hessian of the likelihood function. This is what is typically used for standard errors throughout OpenMx. The "meat" of the sandwich is proportional to the covariance matrix of the numerically computed row derivatives of the likelihood function (i.e. row gradients).

When details=FALSE, only the standard errors are returned.

When details=TRUE, a list with five named elements is returned. Element SE is the vector of standard errors that is also returned when details=FALSE. Element cov is the full robust covariance matrix of the parameter estimates; the square root of the diagonal of cov gives the standard errors. Element bread is the aforementioned "bread"–the naive (non-robust) covariance matrix of the parameter estimates. Element meat is the aforementioned "meat," proportional to the covariance matrix of the row gradients. Element TIC is the model's Takeuchi Information Criterion, which is a generalization of AIC calculated from the "bread," the "meat," and the loglikelihood at the maximum-likelihood solution.

This function does not work correctly with multigroup models in which the groups themselves contain subgroups. This function also does not correctly handle multilevel data.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxRowGradients(model, robustSE = FALSE, dependencyModels = character(0))

Arguments

Details

This function computes the gradient for each row of data. The returned object is a matrix with the same number of rows as the data, and the same number of columns as there are free parameters.

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxSameType(a, b)

Arguments

Description

The character between the model name and the named entity inside the model.

Usage

imxSeparatorChar

Format

An object of class character of length 1.

Description

As of snowfall 1.84, the snowfall supervisor process stores an internal state information in a variable named ".sfOption" that is located in the "snowfall" namespace. The snowfall client processes store internal state information in a variable named ".sfOption" that is located in the global namespace.

Usage

imxSfClient()

Details

As long as the previous statement is true, then the current process is a snowfall client if-and-only-if exists(".sfOption").

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxSimpleRAMPredicate(model)

Arguments

Description

This API is visible to permit testing. Please do not use.

Usage

imxSparseInvert(mat)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxSquareMatrix(.Object)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxSymmetricMatrix(.Object)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxTypeName(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxUntitledName()

Details

Returns a character, the name of the next untitled entity

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxUntitledNumber()

Details

Increments the untitled number counter and returns its value

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxUntitledNumberReset()

Details

Resets the imxUntitledNumber counter

Description

Deprecated. This function does not handle parameters with equality constraints. Do not use.

Usage

imxUpdateModelValues(model, flatModel, values)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxVariableTypes

Format

An object of class character of length 2.

Details

The acceptable variable types

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxVerifyMatrix(.Object)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxVerifyModel(model)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxVerifyName(name, stackNumber)

Arguments

Description

This is an internal function exported for those people who know what they are doing.

Usage

imxVerifyReference(reference, stackNumber)

Arguments

Description

This is an internal function used to calculate the Chi Square distributed fit statistic for weighted least squares models.

Usage

imxWlsChiSquare(model, J=NA)

Arguments

Details

The Chi Square fit statistic for models fit with maximum likelihood depends on the difference in model fit in minus two log likelihood units between the saturated model and the more restricted model under investigation. For models fit with weighted least squares a different expression is required. If $J$ is the first derivative (Jacobian) of the mapping from the free parameters to the unique elements of the expected covariance, means, and threholds, $J_c$ is the orthogonal complement of $J$, $W$ is the inverse of the full weight matrix, and $e$ is the difference between the sample-estimated and model-implied covariance, means, and thresholds, then the Chi Square fit statistic is

$\chi^2 = e' J_c (J'_c W J_c)^-1 J'_c e$

with $e'$ indicating the transpose of $e$. This Equation 2.20a from Browne (1984) where he showed that this statistic is chi-square distributed with the conventional degrees of freedom.

Mean and variance adjusted Chi Square statistics are also computed following Asparouhov and Muthen (2006).

Value

A named list with components

Chi

numeric value of the Chi Square fit statistic.

ChiDoF

degrees of freedom for the Chi Square fit statistic.

ChiM

numeric value of the mean adjusted Chi Square fit statistic

ChiMV

numeric value of the mean and variance adjusted Chi Square fit statistic

mAdjust

numeric value of the mean adjustment

mvAdjust

numeric value of the mean and variance adjustment

dstar

adjusted degrees of freedom for the mean and variance adjusted Chi Square fit statistic

References

M. W. Browne. (1984). Asymptotically Distribution-Free Methods for the Analysis of Covariance Structures. British Journal of Mathematical and Statistical Psychology, 37, 62-83.

T. Asparouhov and B. O. Muthen. (2006). Robust Chi Square Difference Testing with Mean and Variance Adjusted Test Statistics. Mplus Web Notes: No. 10.

Description

This is an internal function used to calculate standard errors for weighted least squares models.

Usage

imxWlsStandardErrors(model)

Arguments

Details

The standard errors for models fit with maximum likelihood are related to the second derivative (Hessian) of the likelihood function with respect to the free parameters. For models fit with weighted least squares a different expression is required. If $J$ is the first derivative (Jacobian) of the mapping from the free parameters to the unique elements of the expected covariance, means, and thresholds, $V$ is the weight matrix used, $W$ is the inverse of the full weight matrix, and $U= V J (J' V J)^{-1}$, then the asymptotic covariance matrix of the free parameters is

$Acov(\theta) = U' W U$

with $U'$ indicating the transpose of $U$.

Value

A named list with components

SE

The standard errors of the free parameters

Cov

The full covariance matrix of the free parameters. The square root of the diagonal elements of Cov equals SE.

Jac

The Jacobian computed to obtain the standard errors.

References

M. W. Browne. (1984). Asymptotically Distribution-Free Methods for the Analysis of Covariance Structures. British Journal of Mathematical and Statistical Psychology, 37, 62-83.

F. Yang-Wallentin, K. G. Jöreskog, & H. Luo. (2010). Confirmatory Factor Analysis of Ordinal Variables with Misspecified Models. Structural Equation Modeling, 17, 392-423.

Description

Data set used in some of OpenMx's examples.

Usage

data("jointdata")

Format

A data frame with 250 observations on the following variables.

z1

Continuous variable

z2

Ordinal variable with 2 levels (0, 1)

z3

Continuous variable

z4

Ordinal variable with 4 levels (0, 1, 2, 3)

z5

Ordinal variable with 3 levels (0, 1, 3)

Details

Data generated to test the joint ML algorithm thoroughly.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(jointdata)
head(jointdata)

Description

Data set used in some of OpenMx's examples.

Usage

data("latentMultipleRegExample1")

Format

A data frame with 200 observations on the following variables.

X1

Factor 1 indicator

X2

Factor 1 indicator

X3

Factor 1 indicator

X4

Factor 1 indicator

X5

Factor 2 indicator

X6

Factor 2 indicator

X7

Factor 2 indicator

X8

Factor 2 indicator

X9

Factor 3 indicator

X10

Factor 3 indicator

X11

Factor 3 indicator

X12

Factor 3 indicator

Details

Factor 1 strongly predicts factor 3. Factor 2 weakly predicts factor 3.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(latentMultipleRegExample1)
round(cor(latentMultipleRegExample1), 2)

Description

Data set used in some of OpenMx's examples.

Usage

data("latentMultipleRegExample2")

Format

A data frame with 200 observations on the following variables.

X1

Factor 1 indicator

X2

Factor 1 indicator

X3

Factor 1 indicator

X4

Factor 1 indicator

X5

Factor 2 indicator

X6

Factor 2 indicator

X7

Factor 2 indicator

X8

Factor 2 indicator

X9

Factor 3 indicator

X10

Factor 3 indicator

X11

Factor 3 indicator

X12

Factor 3 indicator

Details

Factor 1 strongly predicts factor 3. Factor 2 weakly predicts factor 3. Very similar to latentMultipleRegExample1.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(latentMultipleRegExample2)
round(cor(latentMultipleRegExample2), 2)

Description

Data set used in some of OpenMx's examples.

Usage

data("lazarsfeld")

Format

A data frame with 1000 observations on four dichotomous items.

armyrun

In general how do you feel the Army is run?

favatt

Do you think when you are discharged you will [have] a favorable attitude toward the Army?

squaredeal

In general do you feel you yourself have gotten a square deal from the Army?

welfare

Do you feel that the Army is trying its best to look out for the welfare of enlisted men?

frequency

Frequency of response pattern.

Details

A straightforward descriptive analysis of these data shows that negative responses are more numerous except on item 1; and that there is a positive association between each pair of items. A soldier who responds positively to any one item is more likely to respond positively to a second item. Lazarsfeld's analysis is based on the assumption that each soldier can be thought of as belong to one of two latent classes. The probability of positive response to an item is different in one group than in the other. Most importantly, he is willing to assume that for an individual respondent the responses to items are statistically independent.

Source

Lazarsfeld, Paul F. (1950b) "Some Latent Structures", Chapter 11 in Stouffer (1950).

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

http://www.people.vcu.edu/~nhenry/LSA50.htm

Examples

data(lazarsfeld)

Description

Matrix logarithm

Usage

logm(x, tol = .Machine$double.eps)

Arguments

Description

Four-timepoint longitudinal data generated from an arbitrary Monte Carlo simulation, for 1000 simulees. The response variable is a discrete count variable. There are three time-invariant covariates. The data are available in both "wide" and "long" format.

Usage

data("LongitudinalOverdispersedCounts")

Format

The "long" format dataframe, longData, has 4000 rows and the following variables (columns):

1. id: Factor; simulee ID code.

2. tiem: Numeric; represents the time metric, wave of assessment.

3. x1: Numeric; time-invariant covariate.

4. x2: Numeric; time-invariant covariate.

5. x3: Numeric; time-invariant covariate.

6. y: Numeric; the response ("dependent") variable.

The "wide" format dataset, wideData, is a numeric 1000x12 matrix containing the following variables (columns):

1. id: Simulee ID code.

2. x1: Time-invariant covariate.

3. x3: Time-invariant covariate.

4. x3: Time-invariant covariate.

5. y0: Response at initial wave of assessment.

6. y1: Response at first follow-up.

7. y2: Response at second follow-up.

8. y3: Response at third follow-up.

9. t0: Time variable at initial wave of assessment (in this case, 0).

10. t1: Time variable at first follow-up (in this case, 1).

11. t2: Time variable at second follow-up (in this case, 2).

12. t3: Time variable at third follow-up (in this case, 3).

Examples

data(LongitudinalOverdispersedCounts)
head(wideData)
str(longData)
#Let's try ordinary least-squares (OLS) regression:
olsmod <- lm(y~tiem+x1+x2+x3, data=longData)
#We will see in the diagnostic plots that the residuals are poorly approximated by normality, 
#and are heteroskedastic.  We also know that the residuals are not independent of one another, 
#because we have repeated-measures data:
plot(olsmod)
#In the summary, it looks like all of the regression coefficients are significantly different 
#from zero, but we know that because the assumptions of OLS regression are violated that 
#we should not trust its results:
summary(olsmod)

#Let's try a generalized linear model (GLM).  We'll use the quasi-Poisson quasilikelihood 
#function to see how well the y variable is approximated by a Poisson distribution 
#(conditional on time and covariates):
glm.mod <- glm(y~tiem+x1+x2+x3, data=longData, family="quasipoisson")
#The estimate of the dispersion parameter should be about 1.0 if the data are 
#conditionally Poisson.  We can see that it is actually greater than 2, 
#indicating overdispersion:
summary(glm.mod)

Description

Data set used in some of OpenMx's examples.

Usage

data("multiData1")

Format

A data frame with 500 observations on the following variables.

x1

x2

x3

x4

y

Details

x1-x4 are predictor variables, and y is the outcome.

Source

Simulated.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

Examples

data(multiData1)
summary(lm(y ~ ., data=multiData1))
#results can be replicated in OpenMx.

Description

This function creates a new MxAlgebra. The common use is to compute a value in a model: for instance a standardized value of a parameter, or a parameter which is a function of other values. It is also used in models with an mxFitFunctionAlgebra objective function.

note: Unless needed in the model objective, algebras are only computed twice: once at the beginning and once at the end of running a model, so adding them doesn't often add a lot of overhead.

Usage

mxAlgebra(expression, name = NA, dimnames = NA, ..., fixed = FALSE,
          joinKey=as.character(NA), joinModel=as.character(NA),
	verbose=0L, initial=matrix(as.numeric(NA),1,1),
        recompute=c('always','onDemand'))

Arguments

Details

The mxAlgebra function is used to create algebraic expressions that operate on one or more MxMatrix objects. To evaluate an MxAlgebra object, it must be placed in an MxModel object, along with all referenced MxMatrix objects and the mxFitFunctionAlgebra function. The mxFitFunctionAlgebra function must reference by name the MxAlgebra object to be evaluated.

Note: f the result for an MxAlgebra depends upon one or more "definition variables" (see mxMatrix()), then the value returned after the call to mxRun() will be computed using the values of those definition variables in the first (i.e., first before any automated sorting is done) row of the raw dataset.

The following operators and functions are supported in mxAlgebra:

Operators

solve()

Inversion

t()

Transposition

^

Elementwise powering

%^%

Kronecker powering

+

Addition

-

Subtraction

%*%

Matrix Multiplication

*

Elementwise product

/

Elementwise division

%x%

Kronecker product

%&%

Quadratic product: pre- and post-multiply B by A and its transpose t(A), i.e: A %&% B == A %*% B %*% t(A)

Functions

cov2cor

Convert covariance matrix to correlation matrix

chol

Cholesky Decomposition

cbind

Horizontal adhesion

rbind

Vertical adhesion

colSums

Matrix column sums as a column vector

rowSums

Matrix row sums as a column vector

det

Determinant

tr

Trace

sum

Sum

mean

Arithmetic mean

prod

Product

max

Maximum

min

Min

abs

Absolute value

sin

Sine

sinh

Hyperbolic sine

asin

Arcsine

asinh

Inverse hyperbolic sine

cos

Cosine

cosh

Hyperbolic cosine

acos

Arccosine

acosh

Inverse hyperbolic cosine

tan

Tangent

tanh

Hyperbolic tangent

atan

Arctangent

atanh

Inverse hyperbolic tangent

exp

Exponent

log

Natural Logarithm

mxRobustLog

Robust natural logarithm

sqrt

Square root

p2z

Standard-normal quantile

logp2z

Standard-normal quantile from log probabilities

lgamma

Log-gamma function

lgamma1p

Compute log(gamma(x+1)) accurately for small x

eigenval

Eigenvalues of a square matrix. Usage: eigenval(x); eigenvec(x); ieigenval(x); ieigenvec(x)

rvectorize

Vectorize by row

cvectorize

Vectorize by column

vech

Half-vectorization

vechs

Strict half-vectorization

vech2full

Inverse half-vectorization

vechs2full

Inverse strict half-vectorization

vec2diag

Create matrix from a diagonal vector (similar to diag)

diag2vec

Extract diagonal from matrix (similar to diag)

expm

Matrix Exponential

logm

Matrix Logarithm

omxExponential

Matrix Exponential

omxMnor

Multivariate Normal Integration

omxAllInt

All cells Multivariate Normal Integration

omxNot

Perform unary negation on a matrix

omxAnd

Perform binary and on two matrices

omxOr

Perform binary or on two matrices

omxGreaterThan

Perform binary greater on two matrices

omxLessThan

Perform binary less than on two matrices

omxApproxEquals

Perform binary equals to (within a specified epsilon) on two matrices

omxSelectRows

Filter rows from a matrix

omxSelectCols

Filter columns from a matrix

omxSelectRowsAndCols

Filter rows and columns from a matrix

mxEvaluateOnGrid

Evaluate an algebra on an abscissa grid and collect column results

mpinv

Moore-Penrose Inverse

If solve is used on an uninvertible square matrix in R, via mxEval(), it will fail with an error will; if solve is used on an uninvertible square matrix during runtime, it will fail silently.

mxRobustLog is the same as log except that it returns -745 instead of -Inf for an argument of 0. The value -745 is less than log(4.94066e-324), a good approximation of negative infinity because the log of any number represented as a double will be of smaller absolute magnitude.

There are also several multi-argument functions usable in MxAlgebras, which apply themselves elementwise to the matrix provided as their first argument. These functions have slightly different usage from their R counterparts. Their result is always a matrix with the same dimensions as that provided for their first argument. Values must be provided for ALL arguments of these functions, in order. Provide zeroes as logical values of FALSE, and non-zero numerical values as logical values of TRUE. For most of these functions, OpenMx cycles over values of arguments other than the first, by column (i.e., in column-major order), to the length of the first argument. Notable exceptions are the log, log.p, and lower.tail arguments to probability-distribution-related functions, for which only the [1,1] element is used. It is recommended that all arguments after the first be either (1) scalars, or (2) matrices with the same dimensions as the first argument.

Value

Returns a new MxAlgebra object.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

MxAlgebra for the S4 class created by mxAlgebra. mxFitFunctionAlgebra for an objective function which takes an MxAlgebra or MxMatrix object as the function to be minimized. MxMatrix and mxMatrix for objects which may be entered in the expression argument and the function that creates them. More information about the OpenMx package may be found here.

Examples

A <- mxMatrix("Full", nrow = 3, ncol = 3, values=2, name = "A")

# Simple example: algebra B simply evaluates to the matrix A
B <- mxAlgebra(A, name = "B")

# Compute A + B
C <- mxAlgebra(A + B, name = "C")

# Compute sin(C)
D <- mxAlgebra(sin(C), name = "D")

# Make a model and evaluate the mxAlgebra object 'D'
A <- mxMatrix("Full", nrow = 3, ncol = 3, values=2, name = "A")
model <- mxModel(model="AlgebraExample", A, B, C, D )
fit   <- mxRun(model)
mxEval(D, fit)


# Numbers in mxAlgebras are upgraded to 1x1 matrices
# Example of Kronecker powering (%^%) and multiplication (%*%)
A  <- mxMatrix(type="Full", nrow=3, ncol=3, value=c(1:9), name="A")
m1 <- mxModel(model="kron", A, mxAlgebra(A %^% 2, name="KroneckerPower"))
mxRun(m1)$KroneckerPower

# Running kron
# mxAlgebra 'KroneckerPower'
# $formula:  A %^% 2
# $result:
#      [,1] [,2] [,3]
# [1,]    1   16   49
# [2,]    4   25   64
# [3,]    9   36   81

Description

MxAlgebra is an S4 class. An MxAlgebra object is a named entity. New instances of this class can be created using the function mxAlgebra.

Details

The MxAlgebra class has the following slots:

The ‘name’ slot is the name of the MxAlgebra object. Use of MxAlgebra objects in the mxConstraint function or an objective function requires reference by name.

The ‘formula’ slot is an expression containing the expression to be evaluated. These objects are operated on or related to one another using one or more operations detailed in the mxAlgebra help file.

The ‘result’ slot is used to hold the results of computing the expression in the ‘formula’ slot. If the containing model has not been executed, then the ‘result’ slot will hold a 0 x 0 matrix. Otherwise the slot will store the computed value of the algebra using the final estimates of the free parameters.

Slots may be referenced with the $ symbol. See the documentation for Classes and the examples in the mxAlgebra document for more information.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

mxAlgebra, mxMatrix, MxMatrix

Description

This is an internal class for the formulas used in mxAlgebra calls.

Description

Create MxAlgebra object from a string

Usage

mxAlgebraFromString(algString, name = NA, dimnames = NA, ...)

Arguments

See Also

mxAlgebra

Examples

A <- mxMatrix(values = runif(25), nrow = 5, ncol = 5, name = 'A')
B <- mxMatrix(values = runif(25), nrow = 5, ncol = 5, name = 'B')
model <- mxModel(A, B, name = 'model',
  mxAlgebraFromString("A * (B + A)", name = 'test'))
model <- mxRun(model)
model[['test']]$result
A$values * (B$values + A$values)

Description

WARNING: Objective functions have been deprecated as of OpenMx 2.0.

Please use MxFitFunctionAlgebra() instead. As a temporary workaround, MxAlgebraObjective returns a list containing a NULL MxExpectation object and an MxFitFunctionAlgebra object.

All occurrences of

mxAlgebraObjective(algebra, numObs = NA, numStats = NA)

Should be changed to

mxFitFunctionAlgebra(algebra, numObs = NA, numStats = NA)

Arguments

Details

NOTE: THIS DESCRIPTION IS DEPRECATED. Please change to using mxFitFunctionAlgebra as shown in the example below.

Fit functions are functions for which free parameter values are chosen such that the value of the objective function is minimized. While the other fit functions in OpenMx require an expectation function for the model, the mxAlgebraObjective function uses the referenced MxAlgebra or MxMatrix object as the function to be minimized.

If a model's primary objective function is a mxAlgebraObjective objective function, then the referenced algebra in the objective function must return a 1 x 1 matrix (when using OpenMx's default optimizer). There is no restriction on the dimensions of an objective function that is not the primary, or ‘topmost’, objective function.

To evaluate an algebra objective function, place the following objects in a MxModel object: a MxAlgebraObjective, MxAlgebra and MxMatrix entities referenced by the MxAlgebraObjective, and optional MxBounds and MxConstraint entities. This model may then be evaluated using the mxRun function. The results of the optimization may be obtained using the mxEval function on the name of the MxAlgebra, after the model has been run.

Value

Returns a list containing a NULL MxExpectation object and an MxFitFunctionAlgebra object. MxFitFunctionAlgebra objects should be included with models with referenced MxAlgebra and MxMatrix objects.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

mxAlgebra to create an algebra suitable as a reference function to be minimized. More information about the OpenMx package may be found here.

Examples

# Create and fit a very simple model that adds two numbers using mxFitFunctionAlgebra

library(OpenMx)

# Create a matrix 'A' with no free parameters
A <- mxMatrix('Full', nrow = 1, ncol = 1, values = 1, name = 'A')

# Create an algebra 'B', which defines the expression A + A
B <- mxAlgebra(A + A, name = 'B')

# Define the objective function for algebra 'B'
objective <- mxFitFunctionAlgebra('B')

# Place the algebra, its associated matrix and 
# its objective function in a model
tmpModel <- mxModel(model="Addition", A, B, objective)

# Evalulate the algebra
tmpModelOut <- mxRun(tmpModel)

# View the results
tmpModelOut$output$minimum

Description

Automatically set starting values for an MxModel

Usage

mxAutoStart(model, type = c("ULS", "DWLS"))

Arguments

Details

This function automatically picks very good starting values for many models (RAM, LISREL, Normal), including multiple group versions of these. It works for models with algebras. Models of continuous, ordinal, and joint ordinal-continuous variables are also acceptable. It works for models with covariance or raw data. However, it does not currently work for models with definition variables, state space models, item factor analysis models, or multilevel models.

The method used to obtain new starting values is quite simple. The user's model is changed to an unweighted least squares (ULS) model. The ULS model is estimated and its final point estimates are returned as the new starting values. Optionally, diagonally weighted least squares (DWLS) can be used instead with the type argument.

Please note that ULS is sensitive to the scales of your variables. For example, if you have variables with means of 20 and variances of 0.001, then ULS will "weight" the means 20,000 times more than the variances and might result in zero variance estimates. Likewise if one variable has a variance of 20 and another has a variance of 0.001, the same problem may arise. To avoid this, make sure your variables are scaled accordingly. You could also use type='DWLS' to have the function use diagonally weighted least squares to obtain starting values. Of course, using diagonally weighted least squares will take much much longer and will usually not provide better starting values than unweighted least squares.

Also note that if model contains a GREML expectation, argument type is ignored, and the function always uses a form of ULS.

Value

an MxModel with new free parameter values

Examples

# Use the frontpage model with negative variances to show better
# starting values
library(OpenMx)
data(demoOneFactor)

latents  = c("G") # the latent factor
manifests = names(demoOneFactor) # manifest variables to be modeled

m1 <- mxModel("One Factor", type = "RAM",
	manifestVars = manifests, latentVars = latents,
	mxPath(from = latents, to = manifests),
	mxPath(from = manifests, arrows = 2, values=-.2),
	mxPath(from = latents, arrows = 2, free = FALSE, values = 1.0),
	mxPath(from = "one", to = manifests),
	mxData(demoOneFactor, type = "raw")
)

# Starting values imply negative variances!
mxGetExpected(m1, 'covariance')

# Use mxAutoStart to get much better starting values
m1s <- mxAutoStart(m1)
mxGetExpected(m1s, 'covariance')

Description

List the Optimizers available in this version, e.g. "SLSQP" "CSOLNP"

Usage

mxAvailableOptimizers()

Details

note for advanced users: Special-purpose optimizers like Newton-Raphson or EM are not included in this list.

Value

- list of valid Optimizer names

See Also

- mxOption(model, "Default optimizer")

Examples

mxAvailableOptimizers()

Description

The virtual base class for all expectations. Expectations contain enough information to generate simulated data. This is an internal class and should not be used directly.

See Also

mxExpectationNormal, mxExpectationRAM, mxExpectationLISREL, mxExpectationStateSpace, mxExpectationBA81

Description

The virtual base class for all fit functions. This is an internal class and should not be used directly.

See Also

mxFitFunctionAlgebra, mxFitFunctionML, mxFitFunctionMultigroup, mxFitFunctionR, mxFitFunctionWLS, mxFitFunctionRow, mxFitFunctionGREML

Description

This is an internal class and should not be used directly. It is the base class for named entities. Fit functions, expectations, and computes contain this class.

Description

This is an internal class and should not be used directly. It is the virtual base class for all objective functions meta-data

Description

Bootstrapping is used to quantify the variability of parameter estimates. A new sample is drawn from the model data (uniformly sampling the original data with replacement). The model is re-fitted to this new sample. This process is repeated many times. This yields a series of estimates from these replications which can be used to assess the variability of the parameters.

note: mxBootstrap only bootstraps free model parameters:

To bootstrap algebras, see mxBootstrapEval

To report bootstrapped standardized paths in RAM models, mxBootstrap the model, and then run through mxBootstrapStdizeRAMpaths

Usage

mxBootstrap(model, replications=200, ...,
                        data=NULL, plan=NULL, verbose=0L,
                        parallel=TRUE, only=as.integer(NA),
			OK=mxOption(model, "Status OK"), checkHess=FALSE, unsafe=FALSE)

Arguments

Details

By default, all datasets in the given model are resampled independently. If resampling is desired from only some of the datasets then the models containing them can be listed in the ‘data’ parameter.

The frequency column in the mxData object is used represent a resampled dataset. When resampling, the original row proportions, as given by the original frequency column, are respected.

When the model has a default compute plan and ‘checkHess’ is kept at FALSE then the Hessian will not be approximated or checked. On the other hand, ‘checkHess’ is TRUE then the Hessian will be approximated by finite differences. This procedure is of some value because it can be informative to check whether the Hessian is positive definite (see mxComputeHessianQuality). However, approximating the Hessian is often costly in terms of CPU time. For bootstrapping, the parameter estimates derived from the resampled data are typically of primary interest.

On occasion, replications will fail. Sometimes it can be helpful to exactly reproduce a failed replication to attempt to pinpoint the cause of failure. The ‘only’ option facilitates this kind of investigation. In normal operation, mxBootstrap uses the regular R random number generator to generate a seed for each replication. This seed is used to seed an internal pseudorandom number generator (currently the Mersenne Twister algorithm). These per-replication seeds are stored as part of the bootstrap output. When ‘only’ is specified, the associated stored seed is used to seed the internal random number generator so that identical weights can be regenerated.

mxBootstrap does not currently offer special support for nested, multilevel, or other dependent data structures. mxBootstrap assumes rows of data are independent. Multilevel models and state space models violate the independence assumption employed by mxBootstrap. By default the unsafe argument prevents multilevel and state space models from using mxBootstrap; however, setting unsafe=TRUE allows multilevel and state space models to use bootstrapping under the – perhaps foolish – assumption that the user is sufficiently knowledgeable to interpret the results.

Value

The given model is returned with the compute plan modified to consist of mxComputeBootstrap. Results of the bootstrap replications are stored inside the compute plan. mxSummary can be used to obtain per-parameter quantiles and standard errors.

See Also

mxBootstrapEval, mxComputeBootstrap, mxSummary, mxBootstrapStdizeRAMpaths, as.statusCode

Examples

library(OpenMx)

data(multiData1)

manifests <- c("x1", "x2", "y")

biRegModelRaw <- mxModel(
  "Regression of y on x1 and x2",
  type="RAM",
  manifestVars=manifests,
  mxPath(from=c("x1","x2"), to="y", 
         arrows=1, 
         free=TRUE, values=.2, labels=c("b1", "b2")),
  mxPath(from=manifests, 
         arrows=2, 
         free=TRUE, values=.8, 
         labels=c("VarX1", "VarX2", "VarE")),
  mxPath(from="x1", to="x2",
         arrows=2, 
         free=TRUE, values=.2, 
         labels=c("CovX1X2")),
  mxPath(from="one", to=manifests, 
         arrows=1, free=TRUE, values=.1, 
         labels=c("MeanX1", "MeanX2", "MeanY")),
  mxData(observed=multiData1, type="raw"))

biRegModelRawOut <- mxRun(biRegModelRaw)

boot <- mxBootstrap(biRegModelRawOut, 10)   # start with 10
summary(boot)

# Looks good, now do the rest
boot <- mxBootstrap(boot)
summary(boot)

# examine replication 3
boot3 <- mxBootstrap(boot, only=3)

print(coef(boot3))
print(boot$compute$output$raw[3,names(coef(boot3))])

Description

This function can be used to evaluate an arbitrary R expression that includes named entities from a MxModel object, or labels from a MxMatrix object.

Usage

mxBootstrapEval(expression, model, defvar.row = 1, ...,
 bq=c(.25,.75), method=c('bcbci','quantile'))

mxBootstrapEvalByName(name, model, defvar.row = 1, ...,
 bq=c(.25,.75), method=c('bcbci','quantile'))

omxBootstrapEval(expression, model, defvar.row = 1L, ...)

omxBootstrapEvalCov(expression, model, defvar.row = 1L, ...)

omxBootstrapEvalByName(name, model, defvar.row=1L, ...)

Arguments

Details

The argument ‘expression’ is an arbitrary R expression. Any named entities that are used within the R expression are translated into their current value from the model. Any labels from the matrices within the model are translated into their current value from the model. Finally the expression is evaluated and the result is returned. To enable debugging, the ‘show’ argument has been provided. The most common mistake when using this function is to include named entities in the model that are identical to R function names. For example, if a model contains a named entity named ‘c’, then the following mxEval call will return an error: mxEval(c(A, B, C), model).

The mxEvalByName function is a wrapper around mxEval that takes a character instead of an R expression.

nb: ‘bcbci’ stands for ‘bias-corrected bootstrap confidence interval’

The default behavior is to use the ‘bcbci’ method, due to its superior theoretical properties.

Value

omxBootstrapEval and omxBootstrapEvalByName return the raw matrix of cvectorize'd results. omxBootstrapEvalCov returns the covariance matrix of the cvectorize'd results. mxBootstrapEval and mxBootstrapEvalByName return the cvectorize'd results summarized by method at quantiles bq.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

mxAlgebra to create algebraic expressions inside your model and mxModel for the model object mxEval looks inside when evaluating. mxBootstrap to create bootstrap data.

Examples

library(OpenMx)
# make a unit-weighted 10-row data set of values 1 thru 10
myData = mxData(data.frame(weight=1.0, value=1:10), "raw", weight = "weight")
sum(1:10)

# Model sums data$value (sum(1:10)= 55), subtracts "A", squares the result, 
# and tries to minimize this (achieved by setting A=55)
testModel = mxModel(model = "testModel1", myData,
	mxMatrix(name  = "A", "Full", nrow = 1, ncol = 1, values = 1, free=TRUE),
	# nb: filteredDataRow is an auto-generated matrix of
	# non-missing data from the present row.
	# This is placed into the "rowResults" matrix (also auto-generated)
	mxAlgebra(name = "rowAlg", data.weight * filteredDataRow),
	# Algebra to turn the rowResults into a single number
	mxAlgebra(name = "reduceAlg", (sum(rowResults) - A)^2),
	mxFitFunctionRow(
		rowAlgebra    = "rowAlg",
		reduceAlgebra = "reduceAlg",
		dimnames      = "value"
	)
	# no need for an MxExpectation object when using mxFitFunctionRow
)

testModel = mxRun(testModel) # A is estimated at 55, with SE= 1
testBoot = mxBootstrap(testModel)
summary(testBoot) # A is estimated at 55, with SE= 0

# Let's compute A^2 (55^2 = 3025)
mxBootstrapEval(A^2, testBoot)
#      SE 25.0% 75.0%
# [1,]  0  3025  3025

Description

Uses the distribution of a bootstrapped RAM model's raw parameters to create a bootstrapped estimate of its standardized path coefficients.

note: Model must have already been run through mxBootstrap.

Usage

mxBootstrapStdizeRAMpaths(model, bq= c(.25, .75), 
	method= c('bcbci','quantile'), returnRaw= FALSE)

Arguments

Details

mxBootstrapStdizeRAMpaths applies mxStandardizeRAMpaths to each bootstrap replication, thus creating a distribution of standardized estimates for each nonzero path coefficient.

The default bq (bootstrap quantiles) of c(.25, .75) correspond to a 50% CI. This default is chosen as many more bootstraps are required to accurately estimate more extreme quantiles. For a 95% CI, use bq=c(.025,.0975).

nb: ‘bcbci’ stands for ‘bias-corrected bootstrap confidence interval’ To learn more about bcbci and quantile methods, see Efron (1982) and Efron and Tibshirani (1994).

note 1: It is possible (though unlikely) that the number of nonzero paths (elements of the A and S RAM matrices) may vary among bootstrap replications. This precludes a simple summary of the standardized paths' bootstrapping results. In this rare case, if returnRaw=TRUE, a raw list of bootstrapping results is returned, with a warning. Otherwise an error is thrown.

note 2: mxBootstrapStdizeRAMpaths ignores sub-models. To standardize bootstrapped sub-models, run it on the sub-models directly.

Value

If returnRaw=FALSE (default), it returns a dataframe containing, among other things, the standardized path coefficients as estimated from the real data, their bootstrap SEs, and the lower and upper limits of a bootstrap confidence interval. If returnRaw=TRUE, typically, a matrix containing the raw bootstrap results is returned; this matrix has one column per non-zero path coefficient, and one row for each successfully converged bootstrap replication or, if the number of paths varies between bootstraps, a raw list of results is returned.

References

Efron B. (1982). The Jackknife, the Bootstrap, and Other Resampling Plans. Philadelphia: Society for Industrial and Applied Mathematics.

Efron B, Tibshirani RJ. (1994). An Introduction to the Bootstrap. Boca Raton: Chapman & Hall/CRC.

See Also

mxBootstrap(), mxStandardizeRAMpaths(), mxBootstrapEval, mxSummary

Examples

require(OpenMx)
data(myFADataRaw)
manifests = c("x1","x2","x3","x4","x5","x6")

# Build and run 1-factor raw-data CFA
m1 = mxModel("CFA", type="RAM", manifestVars=manifests, latentVars="F1",
	# Factor loadings
	mxPath("F1", to = manifests, values=1),

	# Means and variances of F1 and manifests
	mxPath(from="F1", arrows=2, free=FALSE, values=1), # fix var  F1 @1
	mxPath("one", to= "F1", free= FALSE, values = 0),  # fix mean F1 @0

	# Freely-estimate means and residual variances of manifests
	mxPath(from = manifests, arrows=2, free=TRUE, values=1),
	mxPath("one", to= manifests, values = 1),

	mxData(myFADataRaw, type="raw")
)
m1 = mxRun(m1)
set.seed(170505) # Desirable for reproducibility

# ==========================
# = 1. Bootstrap the model =
# ==========================

m1_booted = mxBootstrap(m1)

# =================================================
# = 2. Estimate and accumulate a distribution of  =
# =    standardized values from each bootstrap.   =
# =================================================

tmp = mxBootstrapStdizeRAMpaths(m1_booted)
#          name label matrix row col Std.Value    Boot.SE     25.0%     75.0%
# 1  CFA.A[1,7]    NA      A  x1  F1 0.8049842 0.01583737 0.7899938 0.8124311
# 2  CFA.A[2,7]    NA      A  x2  F1 0.7935255 0.01373320 0.7865666 0.8045558
# 3  CFA.A[3,7]    NA      A  x3  F1 0.7772050 0.01629684 0.7698374 0.7907878
# 4  CFA.A[4,7]    NA      A  x4  F1 0.8248493 0.01315534 0.8150299 0.8351416
# 5  CFA.A[5,7]    NA      A  x5  F1 0.7995083 0.01479210 0.7869158 0.8057788
# 6  CFA.A[6,7]    NA      A  x6  F1 0.8126734 0.01527586 0.8012809 0.8218805
# 7  CFA.S[1,1]    NA      S  x1  x1 0.3520004 0.02546392 0.3399556 0.3759097
# 8  CFA.S[2,2]    NA      S  x2  x2 0.3703173 0.02171159 0.3526899 0.3813130
# 9  CFA.S[3,3]    NA      S  x3  x3 0.3959524 0.02529583 0.3746547 0.4073505
# 10 CFA.S[4,4]    NA      S  x4  x4 0.3196237 0.02163979 0.3025384 0.3357263
# 11 CFA.S[5,5]    NA      S  x5  x5 0.3607865 0.02364008 0.3507206 0.3807635
# 12 CFA.S[6,6]    NA      S  x6  x6 0.3395619 0.02476480 0.3245124 0.3579489
# 13 CFA.S[7,7]    NA      S  F1  F1 1.0000000 0.00000000 1.0000000 1.0000000
# 14 CFA.M[1,1]    NA      M   1  x1 2.9950397 0.08745209 2.9368758 3.0430917
# 15 CFA.M[1,2]    NA      M   1  x2 2.9775235 0.07719970 2.9109289 3.0197492
# 16 CFA.M[1,3]    NA      M   1  x3 3.0133665 0.08645522 2.9598062 3.0779683
# 17 CFA.M[1,4]    NA      M   1  x4 3.0505604 0.08210810 2.9952130 3.1103674
# 18 CFA.M[1,5]    NA      M   1  x5 2.9776983 0.07973619 2.9362410 3.0311999
# 19 CFA.M[1,6]    NA      M   1  x6 2.9830050 0.07632118 2.9360469 3.0416504

Description

This function creates a new MxBounds object.

Usage

mxBounds(parameters, min = NA, max = NA)

Arguments

Details

Creates a set of boundaries or limits for a parameter or set of parameters. Parameters may be any free parameter or parameters from an MxMatrix object. Parameters may be referenced either by name or by referring to their position in the 'spec' matrix of an MxMatrix object.

Minima and maxima may be specified as scalar numeric values.

Value

Returns a new MxBounds object. If used as an argument in an MxModel object, the parameters referenced in the 'parameters' argument must also be included prior to optimization.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

MxBounds for the S4 class created by mxBounds. MxMatrix and mxMatrix for free parameter specification. More information about the OpenMx package may be found here.

Examples

#Create lower and upper bounds for parameters 'A' and 'B'
bounds <- mxBounds(c('A', 'B'), 3, 5)

#Create a lower bound of zero for a set of variance parameters
varianceBounds <- mxBounds(c('Var1', 'Var2', 'Var3'), 0)

Description

MxBounds is an S4 class. New instances of this class can be created using the function mxBounds.

Details

The MxBounds class has the following slots:

The 'min' and 'max' slots hold scalar numeric values for the lower and upper bounds on the list of parameters, respectively.

Parameters may be any free parameter or parameters from an MxMatrix object. Parameters may be referenced either by name or by referring to their position in the 'spec' matrix of an MxMatrix object. To affect an estimation or optimization, an MxBounds object must be included in an MxModel object with all referenced MxAlgebra and MxMatrix objects.

Slots may be referenced with the $ symbol. See the documentation for Classes and the examples in the mxBounds document for more information.

References

The OpenMx User's guide can be found at https://openmx.ssri.psu.edu/documentation/.

See Also

mxBounds for the function that creates MxBounds objects. MxMatrix and mxMatrix for free parameter specification. More information about the OpenMx package may be found here.

Description

A character, list or NULL

Description

A character or logical

Description

A character or integer

Description

Use the dimension of the null space of the Jacobian to determine whether or not a model is identified local to its current parameter values. The output is a list of the the identification status, the Jacobian, and which parameters are not identified.

Usage

mxCheckIdentification(model, details=TRUE)

Arguments

Details

The mxCheckIdentification function is used to check that a model is identified. That is, the function will tell you if the model has a unique solution in parameter space. The function is most useful when applied to either (a) a model that has been run and had some NA standard errors, or (b) a model that has not been run but has reasonable starting values. In the former situation, mxCheckIdentification is used as a diagnostic after a problem was indicated. In the latter situation, mxCheckIdentification is used as a sanity check.

The method uses the Jacobian of the model expected means and the unique elements of the expected covariance matrix with respect to the free parameters. It is the first derivative of the mapping between the free parameters and the sufficient statistics for the Normal distribution. The method does not depend on data, but does depend on the current values of the free parameters. Thus, it only provides local identification, not global identification. You might get different answers about model identification depending on the free parameter values. Because the method does not depend on data, the model still could be empirically unidentified due to missing data.

The Jacobian is evaluated numerically and generally takes a few seconds, but much less than a minute.

The identification may not be accurate for models using definition variables. Currently, only the first row of the definition variable is evaluated.

Model identification should be accurate for models with linear or nonlinear equality and inequality constraints. When there are constraints, mxCheckIdentification uses the Jacobian of the summary statistics with respect to the free parameters and the Jacobian of the summary statistics with respect to the constraints. The combined extended Jacobian must have rank equal to the number of free parameters for the model to be identified. So, a model can be identified with constraints that is not identified without constraints.

When TRUE, the 'details' argument provides the names of the non-identified parameters. Otherwise, only the status and Jacobian are returned.

Value

A named list with components

status

logical. TRUE if the model is locally identified; otherwise FALSE.

jacobian

matrix. The numerically evaluated Jacobian.

non_identified_parameters

vector. The free parameter names that are not identified

References

Bekker, P.A., Merckens, A., Wansbeek, T.J. (1994). Identification, Equivalent Models and Computer Algebra. Academic Press: Orlando, FL.

Bollen, K. A. & Bauldry, S. (2010). Model Identification and Computer Algebra. Sociological Methods & Research, 39, p. 127-156.

See Also

mxModel

Examples

require(OpenMx)

data(demoOneFactor)
manifests <- names(demoOneFactor)
latents <- "G1"
model2 <- mxModel(model="One Factor", type="RAM",
      manifestVars = manifests,
      latentVars = latents,
      mxPath(from = latents[1], to=manifests[1:5]),
      mxPath(from = manifests, arrows = 2, lbound=1e-6),
      mxPath(from = latents, arrows = 2, free = FALSE, values = 1.0),
      mxData(cov(demoOneFactor), type = "cov", numObs=500)
)
fit2 <- mxRun(model2)

id2 <- mxCheckIdentification(fit2)
id2$status
# The model is locally identified

# Build a model from the solution of the previous one
#  but now the factor variance is also free
model2n <- mxModel(fit2, name="Non Identified Two Factor",
      mxPath(from=latents[1], arrows=2, free=TRUE, values=1)
)

mid2 <- mxCheckIdentification(model2n)
mid2$non_identified_parameters
# The factor loadings and factor variance
#  are not identified.

Description

This function creates a new MxCI object, which allows estimation of likelihood-based confidence intervals in a model (note: to estimate SEs around arbitrary objects, see mxSE)

Usage

mxCI(reference, interval = 0.95, type=c("both", "lower", "upper"), ..., boundAdj=TRUE)

Arguments

Details

The mxCI function creates MxCI objects, which can be used as arguments in MxModel objects. When models containing MxCI objects are optimized using mxRun with the ‘intervals’ argument set to TRUE, likelihood-based confidence intervals are returned. The likelihood-based confidence intervals calculated by MxCI objects are symmetric with respect to the change in likelihood in either direction, and are not necessarily symmetric around the parameter estimate. Estimation of confidence intervals requires both that an MxCI object be included in the model and that the ‘intervals’ argument of the mxRun function is set to TRUE. When estimated, confidence intervals can be accessed in the model output at $output$confidenceIntervals or by using summary on a fitted MxModel object.