help ml
-------------------------------------------------------------------------------
Title
[R] ml -- Maximum likelihood estimation
Syntax
ml model in interactive mode
ml model method progname eq [eq ...] [if] [in] [weight] [,
model_options svy diparm_options]
ml model method funcname() eq [eq ...] [if] [in] [weight] [,
model_options svy diparm_options]
ml model in noninteractive mode
ml model method progname eq [eq ...] [if] [in] [weight], maximize
[model_options svy diparm_options noninteractive_options]
ml model method funcname() eq [eq ...] [if] [in] [weight],
maximize [model_options svy diparm_options
noninteractive_options]
Noninteractive mode is invoked by specifying the maximize option. Use
maximize when ml will be used as a subroutine of another ado-file or
program and you want to carry forth the problem, from definition to
posting of results, in one command.
ml clear
ml query
ml check
ml search [[/]eqname[:] #lb #ub ] [...] [, search_options]
ml plot [eqname:]name [# [# [#]]] [, saving(filename[, replace])]
ml init { [eqname:]name=# | /eqname=# } [...]
ml init # [# ...], copy
ml init matname [, copy skip ]
ml report
ml trace { on | off }
ml count [ clear | on | off ]
ml maximize [, ml_maximize_options display_options eform_option]
ml graph [#] [, saving(filename[, replace]) ]
ml display [, display_options eform_option]
ml footnote
ml score newvar [if] [in] [, ml_score_options]
ml score newvarlist [if] [in] [, missing]
ml score [type] stub* [if] [in] [, missing]
where method is one of
lf d0 v0
d1 e1 v1
d1debug e1debug v1debug
d2 e2 v2
d2debug e2debug v2debug
eq is the equation to be estimated, enclosed in parentheses, and
optionally with a name to be given to the equation, preceded by a
colon,
( [eqname:] [varlist_y =] [varlist_x] [, eq_options] )
or eq is the name of a parameter, such as sigma, with a slash in
front
/eqname which is equivalent to (eqname:)
and diparm_options is one or more diparm(diparm_args) options where
diparm_args is either __sep__ or anything accepted by the
"undocumented" _diparm command; see [P] _diparm.
eq_options description
-------------------------------------------------------------------------
noconstant do not include an intercept in the equation
offset(varname_o) include varname_o in model with coefficient
constrained to 1
exposure(varname_e) include ln(varname_e) in model with
coefficient constrained to 1
-------------------------------------------------------------------------
model_options description
-------------------------------------------------------------------------
vce(vcetype) vcetype may be robust, cluster clustvar,
oim, or opg
constraints(numlist) constraints by number to be applied
constraints(matname) matrix that contains the constraints to be
applied
nocnsnotes do not display notes when constraints are
dropped
title(string) place a title on the estimation output
nopreserve do not preserve the estimation subsample in
memory
collinear keep collinear variables within equations
missing keep observations containing variables with
missing values
lf0(#k #ll) number of parameters and log-likelihood
value of the constant-only model
continue specifies that a model has been fit and
sets the initial values b_0 for the model
to be fit based on those results
waldtest(#) perform a Wald test; see Options for use
with ml model in interactive or
noninteractive mode below
obs(#) number of observations
crittype(string) describe the criterion optimized by ml
subpop(varname) compute estimates for the single
subpopulation
nosvyadjust carry out Wald test as W/k distributed
F(k,d)
technique(nr) Stata's modified Newton-Raphson (NR)
algorithm
technique(bhhh) Berndt-Hall-Hall-Hausman (BHHH) algorithm
technique(dfp) Davidon-Fletcher-Powell (DFP) algorithm
technique(bfgs) Broyden-Fletcher-Goldfarb-Shanno (BFGS)
algorithm
-------------------------------------------------------------------------
noninteractive_options description
-------------------------------------------------------------------------
init(ml_init_args) set the initial values b_0
search(on) equivalent to ml search, repeat(0); the
default
search(norescale) equivalent to ml search, repeat(0)
norescale
search(quietly) same as search(on), except that output is
suppressed
search(off) prevents calling ml search
repeat(#) ml search's repeat() option; see below
bounds(ml_search_bounds) specify bounds for ml search
nowarning suppress "convergence not achieved" message
of iterate(0)
novce substitute the zero matrix for the variance
matrix
negh indicates that the evaluator returns the
negative Hessian matrix
score(newvars) new variables containing the contribution
to the score
maximize_options control the maximization process; seldom
used
-------------------------------------------------------------------------
search_options description
-------------------------------------------------------------------------
repeat(#) number of random attempts to find better
initial-value vector; default is
repeat(10) in interactive mode and
repeat(0) in noninteractive mode
restart use random actions to find starting values;
not recommended
norescale do not rescale to improve vector parameter;
not recommended
maximize_options control the maximization process; seldom
used
-------------------------------------------------------------------------
ml_maximize_options description
-------------------------------------------------------------------------
nowarning suppress "convergence not achieved" message
of iterate(0)
novce substitute the zero matrix for the variance
matrix
negh indicates that the evaluator returns the
negative Hessian matrix
score(newvars | stub*) new variables containing the contribution
to the score
nooutput suppress display of final results
noclear do not clear ml problem definition after
model has converged
maximize_options control the maximization process; seldom
used
-------------------------------------------------------------------------
display_options description
-------------------------------------------------------------------------
noheader suppress header display above the
coefficient table
nofootnote suppress footnote display below the
coefficient table
level(#) set confidence level; default is level(95)
first display coefficient table reporting results
for first equation only
neq(#) display coefficient table reporting first #
equations
showeqns display equation names in the coefficient
table
plus display coefficient table ending in
dashes-plus-sign-dashes
nocnsreport suppress constraints display above the
coefficient table
noomitted suppress display of omitted variables
vsquish suppress blank space separating
factor-variable terms or
time-series-operated variables from other
variables
noemptycells suppress empty cells for interactions of
factor variables
baselevels report base levels of factor variables and
interactions
allbaselevels display all base levels of factor variables
and interactions
coeflegend display coefficients' legend instead of
coefficient table
-------------------------------------------------------------------------
eform_option description
-------------------------------------------------------------------------
eform(string) display exponentiated coefficients; column
title is "string"
eform display exponentiated coefficients; column
title is "exp(b)"
hr report hazard ratios
shr report subhazard ratios
irr report incidence-rate ratios
or report odds ratios
rrr report relative-risk ratios
-------------------------------------------------------------------------
fweights, aweights, iweights, and pweights are allowed; see weight. With
all but method lf, you must write your likelihood-evaluation program
carefully if pweights are to be specified, and pweights may not be
specified with method d0, d1, d1debug, d2, or d2debug. See Gould,
Pitblado, and Sribney (2006, chap. 4) for details.
See estcom for more capabilities of estimation commands. To redisplay
results, type ml display.
Description
ml model defines the current problem.
ml clear clears the current problem definition. This command is rarely
used because when you type ml model, any previous problem is
automatically cleared.
ml query displays a description of the current problem.
ml check verifies that the log-likelihood evaluator you have written
works. We strongly recommend using this command.
ml search searches for (better) initial values. We recommend using this
command.
ml plot provides a graphical way of searching for (better) initial
values.
ml init provides a way to specify initial values.
ml report reports ln L's values, gradient, and Hessian at the initial
values or current parameter estimates.
ml trace traces the execution of the user-defined log-likelihood
evaluation program.
ml count counts the number of times the user-defined log-likelihood
evaluation program is called; this command is seldom used. ml count
clear clears the counter. ml count on turns on the counter. ml count
without arguments reports the current values of the counter. ml count
off stops counting calls.
ml maximize maximizes the likelihood function and reports results. Once
ml maximize has successfully completed, the previously mentioned ml
commands may no longer be used unless noclear is specified. ml graph and
ml display may be used whether or not noclear is specified.
ml graph graphs the log-likelihood values against the iteration number.
ml display redisplays results.
ml footnote displays a warning message when the model did not converge
within the specified number of iterations.
ml score creates new variables containing the equation-level scores. The
variables generated by ml score are equivalent to those generated by
specifying the score() option of ml maximize (and ml model ..., ...
maximize).
progname is the name of a Stata program you write to evaluate the
log-likelihood function.
funcname() is the name of a Mata function you write to evaluate the
log-likelihood function.
In this documentation, progname and funcname() are referred to as the
user-written evaluator, the likelihood evaluator, or sometimes simply as
the evaluator. The program you write is written in the style required by
the method you choose. The methods are lf, d0, d1, d2, e1, e2, v1, and
v2. Thus, if you choose to use method lf, your program is called a
method of lf evaluator. mlmethod shows outlines of evaluator programs for
each of these methods.
Several commands are helpful in writing a user-written evaluator for use
with ml. See mleval for details of the mleval, mlsum, mlvecsum,
mlmatsum, and mlmatbysum commands if your evaluator is a Stata program.
See moptimize() for details on moptimize_util_sum(),
moptimize_util_vecsum(), moptimize_util_matsum(), and
moptimize_util_matbysum() functions if your evaluator is a Mata function.
Options for use with ml model in interactive or noninteractive mode
vce(vcetype) specifies the type of standard error reported, which
includes types that are robust to some kinds of misspecification,
that allow for intragroup correlation, and that are derived from
asymptotic theory; see [R] vce_option.
vce(robust), vce(cluster clustvar), pweight, and svy will work with
method lf, e1, e2, v0, v1, and v2 evaluators; all you need to do is
specify them.
These options will not work with method d0, d1, or d2 evaluators, and
specifying these options will produce an error message.
constraints(numlist | matname) specifies the linear constraints to be
applied during estimation. constraints(numlist) specifies the
constraints by number. Constraints are defined using the constraint
command; see [R] constraint. constraint(matname) specifies a matrix
that contains the constraints.
nocnsnotes prevents notes from being displayed when constraints are
dropped. A constraint will be dropped if it is inconsistent,
contradicts other constraints, or causes some other error when the
constraint matrix is being built. Constraints are checked in the
order in which they are specified.
title(string) specifies the title for the estimation output when results
are complete.
nopreserve specifies that ml need not ensure that only the estimation
subsample is in memory when the user-written likelihood evaluator is
called. nopreserve is irrelevant when you use method lf. See [R] ml
for more details.
collinear specifies that ml not remove the collinear variables within
equations. There is no reason to leave collinear variables in place,
but this option is of interest to programmers who, in their code,
have already removed collinear variables and do not want ml to waste
computer time checking again.
missing specifies that observations containing variables with missing
values not be eliminated from the estimation sample. There are two
reasons you might want to specify missing:
Programmers may wish to specify missing because, in other parts of
their code, they have already eliminated observations with missing
values and do not want ml to waste computer time looking again.
You may wish to specify missing if your model explicitly deals with
missing values. Stata's heckman command is a good example of this.
In such cases, there will be observations where missing values are
allowed and other observations where they are not -- where their
presence should cause the observation to be eliminated. If you
specify missing, it is your responsibility to specify an if exp that
eliminates the irrelevant observations.
lf0(#k #ll) is typically used by programmers. It specifies the number of
parameters and log-likelihood value of the constant-only model so
that ml can report a likelihood-ratio test rather than a Wald test.
Also see the continue option directly below.
If you specify lf0(), it must be safe for you to specify the missing
option, too, else how did you calculate the log likelihood for the
constant-only model on the same sample? You must have identified the
estimation sample, and done so correctly, so there is no reason for
ml to waste time rechecking your results. All of which is to say, do
not specify lf0() unless you are certain your code identifies the
estimation sample correctly.
lf0(), even if specified, is ignored if vce(robust), vce(cluster
clustvar), pweight, or svy is specified because, in that case, a
likelihood-ratio test would be inappropriate.
continue is typically specified by programmers and does two things:
First, it specifies that a model has just been fit by either ml or
some other estimation command, such as logit, and that the likelihood
value stored in e(ll) and the number of parameters stored in e(b) as
of that instant are the relevant values of the constant-only model.
The current value of the log likelihood is used to present a
likelihood-ratio test unless vce(robust), vce(cluster clustvar),
pweight, svy, or constraints() is specified. A likelihood-ratio test
is inappropriate when vce(robust), vce(cluster clustvar), pweight, or
svy is specified. We suggest using lrtest when constraints() is
specified.
Second, continue sets the initial values b_0 for the model about to
be fit according to the e(b) currently stored.
The comments made about specifying missing with lf0() apply equally
well here.
waldtest(#) is typically specified by programmers. By default, ml
presents a Wald test, but that is overridden if the lf0() or continue
option is specified. A Wald test is performed if vce(robust),
vce(cluster clustvar), or pweight is specified.
waldtest(0) prevents even the Wald test from being reported.
waldtest(-1) is the default. It specifies that a Wald test be
performed by constraining all coefficients except the intercept to 0
in the first equation. Remaining equations are to be unconstrained.
A Wald test is performed if neither lf0() nor continue was specified,
and a Wald test is forced if vce(robust), vce(cluster clustvar), or
pweight was specified.
waldtest(k) for k < -1 specifies that a Wald test be performed by
constraining all coefficients except intercepts to 0 in the first |k|
equations; remaining equations are to be unconstrained. A Wald test
is performed if neither lf0() nor continue was specified, and a Wald
test is forced if vce(robust), vce(cluster clustvar), or pweight was
specified.
waldtest(k) for k > 1 works like the options above, except that it
forces a Wald test to be reported even if the information to perform
the likelihood-ratio test is available and even if none of
vce(robust), vce(cluster clustvar), or pweight was specified.
waldtest(k), k > 1, may not be specified with lf0().
obs(#) is used mostly by programmers. It specifies that the number of
observations reported and ultimately stored in e(N) be #.
Ordinarily, ml works that out for itself. Programmers may want to
specify this option when, for the likelihood evaluator to work for N
observations, they first had to modify the dataset so that it
contained a different number of observations.
crittype(string) is used mostly by programmers. It allows programmers to
supply a string (up to 32 characters long) that describes the
criterion that is being optimized by ml. The default is "log
likelihood" for nonrobust and "log pseudolikelihood" for robust
estimation.
svy indicates that ml is to pick up the svy settings set by svyset and
use the robust variance estimator. This option requires the data to
be svyset. svy may not be specified with vce() or weights.
subpop(varname) specifies that estimates be computed for the single
subpopulation defined by the observations for which varname != 0.
Typically, varname = 1 defines the subpopulation and varname = 0
indicates observations not belonging to the subpopulation. For
observations whose subpopulation status is uncertain, varname should
be set to missing ('.'). This option requires the svy option.
nosvyadjust specifies that the model Wald test be carried out as W/k
distributed F(k,d), where W is the Wald test statistic, k is the
number of terms in the model excluding the constant term, d is the
total number of sampled PSUs minus the total number of strata, and
F(k,d) is an F distribution with k numerator degrees of freedom and d
denominator degrees of freedom. By default, an adjusted Wald test is
conducted: (d-k+1)W/(kd) distributed F(k,d-k+1). See Korn and
Graubard (1990) for a discussion of the Wald test and the adjustments
thereof. This option requires the svy option.
technique(algorithm_spec) specifies how the likelihood function is to be
maximized. The following algorithms are currently implemented in ml.
For details, see Gould, Pitblado, and Sribney (2006).
technique(nr) specifies Stata's modified Newton-Raphson (NR)
algorithm.
technique(bhhh) specifies the Berndt-Hall-Hall-Hausman (BHHH)
algorithm.
technique(dfp) specifies Davidon-Fletcher-Powell (DFP) algorithm.
technique(bfgs) specifies the Broyden-Fletcher-Goldfarb-Shanno (BFGS)
algorithm.
The default is technique(nr).
You can switch between algorithms by specifying more than one in the
technique() option. By default, ml will use an algorithm for five
iterations before switching to the next algorithm. To specify a
different number of iterations, include the number after the
technique in the option. For example, specifying technique(bhhh 10
nr 1000) requests that ml perform 10 iterations using the BHHH
algorithm, followed by 1,000 iterations using the NR algorithm, and
then switch back to BHHH for 10 iterations, and so on. The process
continues until convergence or until reaching the maximum number of
iterations.
Options for use with ml model in noninteractive mode
The following extra options are for use with ml model in noninteractive
mode. Noninteractive mode is for programmers who use ml as a subroutine
and want to issue one command that will carry forth the estimation from
start to finish.
maximize is required. It specifies noninteractive mode.
init(ml_init_args) sets the initial values, b_0. ml_init_args are
whatever you would type after the ml init command.
search(on|norescale|quietly|off) specifies whether ml search is to be
used to improve the initial values. search(on) is the default and is
equivalent to separately running ml search, repeat(0).
search(norescale) is equivalent to separately running ml search,
repeat(0) norescale. search(quietly) is equivalent to search(on),
except that it suppresses ml search's output. search(off) prevents
calling ml search.
repeat(#) is ml search's repeat() option. repeat(0) is the default.
bounds(ml_search_bounds) specifies the search bounds. The ml model
command issues ml search ml_search_bounds, repeat(#). Specifying
search bounds is optional.
nowarning, novce, negh, and score() are ml maximize's equivalent options.
maximize_options: difficult, technique(algorithm_spec), iterate(#),
[no]log, trace, gradient, showstep, hessian, showtolerance,
tolerance(#), ltolerance(#), nrtolerance(#), nonrtolerance,
from(init_specs); see [R] maximize. These options are seldom used.
Options for use when specifying equations
noconstant specifies that the equation not include an intercept.
offset(varname_o) specifies that the equation be xb + varname_o -- that
it include varname_o with coefficient constrained to be 1.
exposure(varname_e) is an alternative to offset(varname_o); it specifies
that the equation be xb + ln(varname_e). The equation is to include
ln(varname_e) with coefficient constrained to be 1.
Options for use with ml search
repeat(#) specifies the number of random attempts that are to be made to
find a better initial-value vector. The default is repeat(10).
repeat(0) specifies that no random attempts be made. More precisely,
repeat(0) specifies that no random attempts be made if the first
initial-value vector is a feasible starting point. If not, ml search
will make random attempts, even if you specify repeat(0), because it
has no alternative. The repeat() option refers to the number of
random attempts to be made to improve the initial values. When the
initial starting value vector is not feasible, ml search will make up
to 1,000 random attempts to find starting values. It stops when it
finds one set of values that works and then moves into its
improve-initial-values logic.
repeat(k), k > 0, specifies the number of random attempts to be made
to improve the initial values.
restart specifies that random actions be taken to obtain starting values
and that the resulting starting values not be a deterministic
function of the current values. Generally, you should not specify
this option because, with restart, ml search intentionally does not
produce as good a set of starting values as it could. restart is
included for use by the optimizer when it gets into serious trouble.
The random actions ensure that the optimizer and ml search, working
together, do not cause an endless loop.
restart implies norescale, which is why we recommend that you do not
specify restart. In testing, sometimes rescale worked so well that,
even after randomization, the rescaler would bring the starting
values right back to where they had been the first time and thus
defeat the intended randomization.
norescale specifies that ml search not engage in its rescaling actions to
improve the parameter vector. We do not recommend specifying this
option because rescaling tends to work so well.
maximize_options: [no]log, trace; see [R] maximize. These options are
seldom used.
Option for use with ml plot
saving(filename[, replace]) specifies that the graph be saved in
filename.gph.
Options for use with ml init
copy specifies that the list of numbers or the initialization vector be
copied into the initial-value vector by position rather than by name.
skip specifies that any parameters found in the specified initialization
vector that are not also found in the model be ignored. The default
action is to issue an error message.
Options for use with ml maximize
nowarning is allowed only with iterate(0). nowarning suppresses the
"convergence not achieved" message. Programmers might specify
iterate(0) nowarning when they have a vector b already containing the
final estimates and want ml to calculate the variance matrix and post
estimation results. Then specify
init(b) search(off) iterate(0) nowarning nolog.
novce is allowed only with iterate(0). novce substitutes the zero matrix
for the variance matrix, which in effect posts estimation results as
fixed constants.
negh indicates that the evaluator returns the negative Hessian matrix.
By default, ml assumes d2, e2, and v2 evaluators return the Hessian
matrix.
score(newvars | stub*) creates new variables containing the contributions
to the score for each equation and ancillary parameter in the model;
see [U] 20.17 Obtaining scores.
If score(newvars) is specified, the newvars must contain k new
variables, one for each equation in the model. If score(stub*) is
specified, variables named stub1, stub2, ..., stubk are created.
The first variable contains d(ln L_j)/d(x_1j b_1), the second
variable contains d(ln L_j)/d(x_2j b_2), and so on.
nooutput suppresses display of results. This option is different from
prefixing ml maximize with quietly in that the iteration log is still
displayed (assuming that nolog is not specified).
noclear specifies that the ml problem definition not be cleared after the
model has converged. Perhaps you are having convergence problems and
intend to run the model to convergence. If so, use ml search to see
if those values can be improved, and then restart the estimation.
maximize_options: difficult, iterate(#), [no]log, trace, gradient,
showstep, hessian, showtolerance, tolerance(#), ltolerance(#),
nrtolerance(#), nonrtolerance; see [R] maximize. These options are
seldom used.
display_options; see Options for use with ml display.
eform_option; see Options for use with ml display.
Option for use with ml graph
saving(filename[, replace]) specifies that the graph be saved in
filename.gph.
Options for use with ml display
noheader suppresses the header display above the coefficient table that
displays the final log-likelihood value, the number of observations,
and the model significance test.
nofootnote suppresses the footnote display below the coefficient table,
which displays a warning if the model fit did not converge within the
specified number of iterations. Use ml footnote to display the
warning if 1) you add to the coefficient table by using the plus
option or 2) you have your own footnotes and want the warning to be
last.
level(#) is the standard confidence-level option. It specifies the
confidence level, as a percentage, for confidence intervals of the
coefficients. The default is level(95) or as set by set level; see
[R] level.
first displays a coefficient table reporting results for the first
equation only, and the report makes it appear that the first equation
is the only equation. This option is used by programmers who
estimate ancillary parameters in the second and subsequent equations
and who wish to report the values of such parameters themselves.
neq(#) is an alternative to first. neq(#) displays a coefficient table
reporting results for the first # equations. This option is used by
programmers who estimate ancillary parameters in the #+1 and
subsequent equations and who wish to report the values of such
parameters themselves.
showeqns is a seldom-used option that displays the equation names in the
coefficient table. ml display uses the numbers stored in e(k_eq) and
e(k_aux) to determine how to display the coefficient table. e(k_eq)
identifies the number of equations and e(k_aux) identifies how many
of these are for ancillary parameters. The first option is implied
when showeqns is not specified and all but the first equation are for
ancillary parameters.
plus displays the coefficient table and ends it in
dashes-plus-sign-dashes rather than just dashes. This is so that
programmers can write additional display code to add more results to
the table and make it appear as if the combined result is one table.
Programmers typically specify plus with the first or neq() options.
This option implies nofootnote.
nocnsreport suppresses the display of constraints above the coefficient
table. This option is ignored if constraints were not used to fit
the model.
noomitted specifies that variables that were omitted because of
collinearity not be displayed. The default is to include in the
table any variables omitted because of collinearity and to label them
as "(omitted)".
vsquish specifies that the blank space separating factor-variable terms
or time-series-operated variables from other variables in the model
be suppressed.
noemptycells specifies that empty cells for interactions of factor
variables not be displayed. The default is to include in the table
interaction cells that do not occur in the estimation sample and to
label them as "(empty)".
baselevels and allbaselevels control whether the base levels of factor
variables and interactions are displayed. The default is to exclude
from the table all base categories.
baselevels specifies that base levels be reported for factor
variables and for interactions whose bases cannot be inferred
from their component factor variables.
allbaselevels specifies that all base levels of factor variables and
interactions be reported.
coeflegend specifies that the legend of the coefficients and how to
specify them in an expression be displayed rather than the
coefficient table.
eform_option: eform(string), eform, hr, shr, irr, or, and rrr display the
coefficient table in exponentiated form: for each coefficient,
exp(b) rather than b is displayed, and standard errors and confidence
intervals are transformed. Display of the intercept, if any, is
suppressed. string is the table header that will be displayed above
the transformed coefficients and must be 11 characters or shorter in
length -- for example, eform("Odds ratio"). The options eform, hr,
shr, irr, or, and rrr provide a default string equivalent to
"exp(b)", "Haz. Ratio", "SHR", "IRR", "Odds Ratio", and "RRR",
respectively. These options may not be combined.
ml display looks at e(k_eform) to determine how many equations are
affected by an eform_option; by default, only the first equation is
affected.
Examples
See [R] ml for examples. More examples are available in Gould, Pitblado,
and Sribney (2006) -- available from StataCorp.
Saved results
For results saved by ml without the svy options, see [R] maximize.
For results saved by ml with the svy options, see [SVY] svy.
References
Gould, W. W., J. Pitblado, and W. M. Sribney. 2006. Maximum Likelihood
Estimation with Stata. 3rd ed. College Station, TX: Stata Press.
Korn, E. L., and B. I. Graubard. 1990. Simultaneous testing of
regression coefficients with complex survey data: Use of Bonferroni t
statistics. American Statistician 44: 270-276.
Also see
Manual: [R] ml
Help: [R] maximize, ml score, [R] ml (mleval), [R] nl, [M-5]
moptimize(), [M-5] optimize()
