Running examples in ‘mitml-Ex.R’ failed
The error most likely occurred in:

> ### Name: jomoImpute
> ### Title: Impute multilevel missing data using 'jomo'
> ### Aliases: jomoImpute
> ### Keywords: models
> 
> ### ** Examples
> 
> # NOTE: The number of iterations in these examples is much lower than it
> # should be! This is done in order to comply with CRAN policies, and more
> # iterations are recommended for applications in practice!
> 
> data(studentratings)
> data(leadership)
> 
> # ***
> # for further examples, see "panImpute"
> #
> 
> ?panImpute
panImpute                package:mitml                 R Documentation

_I_m_p_u_t_e _m_u_l_t_i_l_e_v_e_l _m_i_s_s_i_n_g _d_a_t_a _u_s_i_n_g '_p_a_n'

_D_e_s_c_r_i_p_t_i_o_n:

     This function provides an interface to the ‘pan’ package for
     multiple imputation of multilevel data (Schafer & Yucel, 2002).
     Imputations can be generated using ‘type’ or ‘formula’, which
     offer different options for model specification.

_U_s_a_g_e:

     panImpute(data, type, formula, n.burn=5000, n.iter=100, m=10, group=NULL, 
       prior=NULL, seed=NULL, save.pred=FALSE, silent=FALSE)
     
_A_r_g_u_m_e_n_t_s:

    data: A data frame containing incomplete and auxiliary variables,
          the cluster indicator variable, and any other variables that
          should be present in the imputed datasets.

    type: An integer vector specifying the role of each variable in the
          imputation model (see details).

 formula: A formula specifying the role of each variable in the
          imputation model. The basic model is constructed by
          ‘model.matrix’, thus allowing to include derived variables in
          the imputation model using ‘I()’ (see details and examples).

  n.burn: The number of burn-in iterations before any imputations are
          drawn. Default is to 5,000.

  n.iter: The number of iterations between imputations. Default is to
          100.

       m: The number of imputed data sets to generate.

   group: (optional) A character string denoting the name of an
          additional grouping variable to be used with the ‘formula’
          argument. When specified, the imputation model is run
          separately within each of these groups.

   prior: (optional) A list with components ‘a’, ‘Binv’, ‘c’, and
          ‘Dinv’ for specifying prior distributions for the covariance
          matrix of random effects and the covariance matrix of
          residuals (see details). Default is to using
          least-informative priors.

    seed: (optional) An integer value initializing ‘pan’'s random
          number generator for reproducible results. Default is to
          using random seeds.

save.pred: (optional) Logical flag indicating if variables derived
          using ‘formula’ should be included in the imputed data sets.
          Default is to ‘FALSE’.

  silent: (optional) Logical flag indicating if console output should
          be suppressed. Default is to ‘FALSE’.

_D_e_t_a_i_l_s:

     This function serves as an interface to the ‘pan’ algorithm. The
     imputation model can be specified using either the ‘type’ or the
     ‘formula’ argument.

     The ‘type’ interface is designed to provide quick-and-easy
     imputations using ‘pan’. The ‘type’ argument must be an integer
     vector denoting the role of each variable in the imputation model:

        • ‘1’: target variables containing missing data

        • ‘2’: predictors with fixed effect on all targets (completely
          observed)

        • ‘3’: predictors with random effect on all targets (completely
          observed)

        • ‘-1’: grouping variable within which the imputation is run
          separately

        • ‘-2’: cluster indicator variable

        • ‘0’: variables not featured in the model

     At least one target variable and the cluster indicator must be
     specified. The intercept is automatically included both as a fixed
     and random effect. If a variable of type ‘-1’ is found, then
     separate imputations are performed within each level of that
     variable.

     The ‘formula’ argument is intended as more flexible and
     feature-rich interface to ‘pan’. Specifying the ‘formula’ argument
     is similar to specifying other formulae in R. Given below is a
     list of operators that ‘panImpute’ currently understands:

        • ‘~’: separates the target (left-hand) and predictor
          (right-hand) side of the model

        • ‘+’: adds target or predictor variables to the model

        • ‘*’: adds an interaction term of two or more predictors

        • ‘|’: denotes cluster-specific random effects and specifies
          the cluster indicator (i.e., ‘1|ID’)

        • ‘I()’: defines functions to be interpreted by ‘model.matrix’

     Predictors are allowed to have fixed effects, random effects, or
     both on all target variables. The intercept is automatically
     included both as a fixed and a random effect, but it can be
     constrained if necessary (see examples). Note that, when
     specifying random effects other than the intercept, these will
     _not_ be automatically added as fixed effects and must be included
     explicitly. Any predictors defined by ‘I()’ will be used for
     imputation but not included in the data set unless
     ‘save.pred=TRUE’.

     In order to run separate imputations for each level of an
     additional grouping variable, the ‘group’ argument may be used.
     The name of the grouping variable must be given in quotes.

     As a default prior, ‘panImpute’ uses "least informative"
     inverse-Wishart priors for the covariance matrix of random effects
     and the covariance matrix of residuals, that is, with minimum
     degrees of freedom (largest dispersion) and identity matrices for
     scale. For better control, the ‘prior’ argument may be used for
     specifying alternative prior distributions. These must be supplied
     as a list containing the following components:

        • ‘a’: degrees of freedom for the covariance matrix of
          residuals

        • ‘Binv’: scale matrix for the covariance matrix of residuals

        • ‘c’: degrees of freedom for the covariance matrix of random
          effects

        • ‘Dinv’: scale matrix for the covariance matrix of random
          effects

     A sensible choice for a diffuse non-default prior is to set the
     degrees of freedom to the lowest value possible, and the scale
     matrices according to a prior guess of the corresponding
     covariance matrices (see Schafer & Yucel, 2002).

_V_a_l_u_e:

     Returns an object of class ‘mitml’, containing the following
     components:

    data: The original (incomplete) data set, sorted according to the
          cluster variable and (if given) the grouping variable, with
          several attributes describing the original row order
          (‘"sort"’) and grouping (‘"group"’.

replacement.mat: A matrix containing the multiple replacements (i.e.,
          imputations) for each missing value. The replacement matrix
          contains one row for each missing value and one one column
          for each imputed data set.

index.mat: A matrix containing the row and column index for each
          missing value. The index matrix is used to _link_ the missing
          values in the data set with their corresponding rows in the
          replacement matrix.

    call: The matched function call.

   model: A list containing the names of the cluster variable, the
          target variables, and the predictor variables with fixed and
          random effects, respectively.

random.L1: A character string denoting the handling of random residual
          covariance matrices (not used here; see ‘jomoImpute’).

   prior: The prior parameters used in the imputation model.

    iter: A list containing the number of burn-in iterations, the
          number of iterations between imputations, and the number of
          imputed data sets.

par.burnin: A multi-dimensional array containing the parameters of the
          imputation model from the burn-in phase.

par.imputation: A multi-dimensional array containing the parameters of
          the imputation model from the imputation phase.

_N_o_t_e:

     For objects of class ‘mitml’, methods for the generic functions
     ‘print’, ‘summary’, and ‘plot’ have been defined. ‘mitmlComplete’
     is used for extracting the imputed data sets.

_A_u_t_h_o_r(_s):

     Simon Grund, Alexander Robitzsch, Oliver Luedtke

_R_e_f_e_r_e_n_c_e_s:

     Schafer, J. L., and Yucel, R. M. (2002). Computational strategies
     for multivariate linear mixed-effects models with missing values.
     _Journal of Computational and Graphical Statistics, 11_, 437-457.

_S_e_e _A_l_s_o:

     ‘jomoImpute’, ‘mitmlComplete’, ‘summary.mitml’, ‘plot.mitml’

_E_x_a_m_p_l_e_s:

     # NOTE: The number of iterations in these examples is much lower than it
     # should be! This is done in order to comply with CRAN policies, and more
     # iterations are recommended for applications in practice!
     
     data(studentratings)
     
     # *** ................................
     # the 'type' interface
     # 
     
     # * Example 1.1: 'ReadDis' and 'SES', predicted by 'ReadAchiev' and 
     # 'CognAbility', with random slope for 'ReadAchiev'
     
     type <- c(-2,0,0,0,0,0,3,1,2,0)
     names(type) <- colnames(studentratings)
     type
     
     imp <- panImpute(studentratings, type=type, n.burn=1000, n.iter=100, m=5)
     
     # * Example 1.2: 'ReadDis' and 'SES' groupwise for 'FedState',
     # and predicted by 'ReadAchiev'
     
     type <- c(-2,-1,0,0,0,0,2,1,0,0)
     names(type) <- colnames(studentratings)
     type
     
     imp <- panImpute(studentratings, type=type, n.burn=1000, n.iter=100, m=5)
     
     # *** ................................
     # the 'formula' interface
     # 
     
     # * Example 2.1: imputation of 'ReadDis', predicted by 'ReadAchiev'
     # (random intercept)
     
     fml <- ReadDis ~ ReadAchiev + (1|ID)
     imp <- panImpute(studentratings, formula=fml, n.burn=1000, n.iter=100, m=5)
     
     # ... the intercept can be suppressed using '0' or '-1' (here for fixed intercept)
     fml <- ReadDis ~ 0 + ReadAchiev + (1|ID)
     imp <- panImpute(studentratings, formula=fml, n.burn=1000, n.iter=100, m=5)
     
     # * Example 2.2: imputation of 'ReadDis', predicted by 'ReadAchiev'
     # (random slope)
     
     fml <- ReadDis ~ ReadAchiev + (1+ReadAchiev|ID)
     imp <- panImpute(studentratings, formula=fml, n.burn=1000, n.iter=100, m=5)
     
     # * Example 2.3: imputation of 'ReadDis', predicted by 'ReadAchiev',
     # groupwise for 'FedState'
     
     fml <- ReadDis ~ ReadAchiev + (1|ID)
     imp <- panImpute(studentratings, formula=fml, group="FedState", n.burn=1000,
     n.iter=100, m=5)
     
     # * Example 2.4: imputation of 'ReadDis', predicted by 'ReadAchiev'
     # including the cluster mean of 'ReadAchiev' as an additional predictor
     
     fml <- ReadDis ~ ReadAchiev + I(clusterMeans(ReadAchiev,ID)) + (1|ID)
     imp <- panImpute(studentratings, formula=fml, n.burn=1000, n.iter=100, m=5)
     
     # ... using 'save.pred' to save the calculated cluster means in the data set
     fml <- ReadDis ~ ReadAchiev + I(clusterMeans(ReadAchiev,ID)) + (1|ID)
     imp <- panImpute(studentratings, formula=fml, n.burn=1000, n.iter=100, m=5,
     save.pred=TRUE)
     
     head(mitmlComplete(imp,1))
     

> 
> # *** ................................
> # the 'type' interface
> # 
> 
> # * Example 1.1 (studentratings): 'ReadDis' and 'SES', predicted by 'ReadAchiev'
> # (random slope)
> 
> type <- c(-2,0,0,0,0,1,3,1,0,0)
> names(type) <- colnames(studentratings)
> type
         ID    FedState         Sex  MathAchiev     MathDis         SES 
         -2           0           0           0           0           1 
 ReadAchiev     ReadDis CognAbility  SchClimate 
          3           1           0           0 
> 
> imp <- jomoImpute(studentratings, type=type, n.burn=100, n.iter=10, m=5)
Running burn-in phase ...
Creating imputed data set ( 1 / 5 ) ...
Creating imputed data set ( 2 / 5 ) ...
Creating imputed data set ( 3 / 5 ) ...
Creating imputed data set ( 4 / 5 ) ...
Creating imputed data set ( 5 / 5 ) ...
Done!
> 
> # * Example 1.2 (leadership): all variables (mixed continuous and categorical
> # data with missing values at level 1 and level 2)
> 
> type.L1 <- c(-2,1,0,1,1)   # imputation model at level 1
> type.L2 <- c(-2,0,1,0,0)   # imputation model at level 2
> names(type.L1) <- names(type.L2) <- colnames(leadership)
> 
> type <- list(type.L1, type.L2)
> type
[[1]]
  GRPID  JOBSAT   COHES NEGLEAD   WLOAD 
     -2       1       0       1       1 

[[2]]
  GRPID  JOBSAT   COHES NEGLEAD   WLOAD 
     -2       0       1       0       0 

> 
> imp <- jomoImpute(leadership, type=type, n.burn=100, n.iter=10, m=5)

 *** caught segfault ***
address 2ef, cause 'memory not mapped'