Source version: 1.0.0.9000. For versioned archives, manuals and publication status, see the repository manifest and GitHub releases. These repository records are excluded from the package archive; this source version does not assert that a corresponding release has been published.
This development line follows the 1.0.0 release, which CRAN published on 2026-11-01. The published 1.0.0 archive, its numerical engines, acceptance rules and every estimate are unchanged.
This version retains the formula interface and historical release evidence while adding the capabilities below. No numerical acceptance threshold was loosened; where an optimizer path changed, the change is named.
Installed tests run their long comparisons only when NOT_CRAN=true, which
scripts/run_validation.py and the no-long-double CI job set; a check
without it, as on CRAN's ten-minute check farm, still runs every file and
every feature at small size and announces each skipped comparison with a
SKIP: line (tests/README.md). The first upload of this version was
refused by CRAN's pre-test for its check time alone, 15 minutes on the
Windows machine with both check logs clean.
The compiled selected inverse protects both dim attribute lookups in
gt_selected_contractions() and reads the design width before
unprotecting, closing the one unprotected-variable report rchk gave on the
first archive; checks and messages are unchanged.
tests/package-bootstrap.R keeps its forked two-core comparison off under
valgrind, whose __libc_freeres at a forked child's exit rewinds the script
offset the child shares with the parent.
Observation identities now preserve exact numeric design identifiers, independently of number-display settings. Format 2 treats integer/double storage as equivalent and factor/character labels as equivalent. Older format-1 digests require retained observations or a refit; they cannot recover numeric precision that was lost by formatting.
Workflow inventory ignores comment-only lines before determining mapping boundaries, so valid YAML comments cannot hide later required checks.
The optional sparse nominal analytic gradient now forms curvature-vector products directly from stable diagonal and off-diagonal entries. This preserves tail contributions when a category probability rounds to one; the default finite-difference route and acceptance rules are unchanged.
Release-policy checks now include the exact-archive macOS and Windows jobs, expand supported inline matrices, and refuse unsupported matrix forms instead of silently omitting required checks.
Object bootstrap resampling now verifies that supplied data contain the original modeled values, identifiers and row order. Fits retain a versioned SHA-256 signature when data retention is disabled. Supplied refit controls must preserve the original fixed covariance matrices, and results record the effective controls, jackknife setting and seed policy.
Help distinguishes default delta-method intervals from explicit bootstrap intervals, and dates the macOS/Linux full-data reproduction to its checked candidate rather than transferring it to later archive bytes.
An installed native-data workflow defines the two scoped joint examples from their frozen public-data requests, with explicit fitting controls, output tables, refusal handling and numerical comparison tolerances. Sourcing the script defines its functions; full-data fitting is an explicit long-running action. Its small synthetic mode checks the same reporting contract.
Reproducibility guidance distinguishes exact inputs and settings from floating-point equality. Cross-platform comparisons retain acceptance and uncertainty decisions and compare unrounded quantities to declared tolerances.
The introduction and help state the scope of the two joint examples and when intervals are unavailable or conditional on held boundary sources. First-order Laplace approximation and near-boundary/weak-signal statistical limitations remain unchanged.
gt_control(discrete = list(engine = "sparse")),
including eligible equal fixed-call effects. Both engines calculate the same
first-order Laplace objective under the same acceptance rules. Preflight
applies the selected engine's memory budget; the default row,
random-dimension and parameter limits remain in force.max_sparse_bytes against
the design's structural pattern instead of a dense square. The complete-fill
bound is kept while it fits the budget; otherwise the exact count of the
conditional Hessian's structural nonzeros, from the observed pairs of group
levels, refuses before any pattern is built, or the structural pattern (every
factor entry nonzero, every latent dimension of an observation coupled) is
factorized once and the counted Hessian and factor entries give the
estimate. The counted fill is a planning estimate with the multiplier as
allowance, not a bound: the fit recomputes its own fill-reducing ordering.
The old bound made the bundled joint native panels infeasible at their
declared 8 GiB budget (dense squares of 32 and 73 GiB); the structural
estimate reports what the design needs, which the joint 21,600-row panels
still place above the 512 MiB default. Preflight records
the method and the counts. A feasible factorization establishes neither
acceptance nor approximation accuracy at that size.gradient = "analytic" in the discrete control gives sparse L-BFGS-B fits
the analytic gradient of the first-order Laplace objective in place of
the finite-difference gradient inside every attempt;
"finite_difference" stays the default and leaves fits unchanged. The
gradient reuses the objective's record at the same point, and a refused
gradient ends its attempt with no finite-difference fallback. The
stationarity check, restart stability and every other acceptance rule are
unchanged. Natural Cholesky, log-Cholesky and fixed covariances are
supported; direct and exchangeable variances are refused at fit start,
because their derivative at an exact zero is not available. The fit records
the route's ledger and the analytic gradient at the selected point beside
the stationarity check's score, and gt_preflight() reports the route's
coordinates and compiled caps. On the characterization panels the two
routes reach the same accepted points with between six and seventeen
times fewer objective evaluations.check_hessian = TRUE on the analytic route, observed information is
formed from central differences of the analytic gradient, 4p gradients,
instead of second differences of the objective, about 4p^2 evaluations.
The asymmetry of the difference matrix is checked against
hessian_tolerance before it is symmetrized; the step-discrepancy,
eigenvalue and inverse checks, the acceptance refusal and the boundary rule
are those of the other method, and a refused gradient makes information unavailable without
falling back. On the information reference panels the two methods agree
within 2e-7 at the same parameters on macOS and Linux. fit$uncertainty
names the method.R/discrete_gradient.R) comes from the
compiled selected inverse, per-observation local contractions, the
response third derivatives and one adjoint solve, in stored coordinates,
for natural Cholesky, log-Cholesky, variance, exchangeable and fixed
covariance coordinates, refusing at an exact zero of a square-root
coordinate. Its selected inverse runs on the structural derivative
envelope (R/discrete_sparse_envelope.R): the numeric conditional Hessian
overlaid on the design's all-ones pattern with explicit zeros kept,
checked against the production factor's log determinant and probes.
Checked against finite differences of the objective on thirteen fixtures
with negative controls..gt_d_ordinal_interval(third = TRUE), .gt_d_response_third()) are
computed in the same regime as the curvature: closed forms, the paired
form on crossing intervals, rescaled before multiplication so that wide
intervals admitted by explicit threshold-gap overrides do not overflow,
the 16-node rule's third moment on narrow probit intervals, and a
tilted-exponential quadrature on same-side probit tails where the closed
cumulant cancels. Binary blocks take the one-cut interval route; a clipped
curvature refuses. Checked against 160-digit references on 108 fixed
intervals, with installed regressions for the finite-zero and nonfinite
failures, mirrored intervals and branch transitions. The existing
probability, score and curvature outputs are unchanged.src/gt_selected_inverse.c,
registered .Call entry points wrapped by R/selected_inverse.R), giving
the inverse's entries on the factor's pattern, original-coordinate queries
and traces, and per-observation local contractions, accumulated in long
double where the platform has it. An entry outside the factor's pattern is
refused, never read as zero, and every declared cap refuses by name.optim()'s own rule so the optimizer's
path is unchanged, and names each evaluation's role: function evaluations
start from the centre mode and become the new centre, and every probe of one
gradient starts from the mode at the point it differentiates. The
conditional objective is strictly concave in the random effects, so a start
changes the path to the mode and never the mode: on the frozen calibration
points and the 21,600-row synthetic panel, warm and cold objectives agree
within 4.4e-9 at the coarse tolerance and 1.9e-10 at the validation
tolerance, and at the native 21,600-row panel's starting values within
1.5e-7 (coarse) and 3.6e-12 (validation), while an evaluation needs about
three Newton steps instead of seven or eight. Every attempt begins with a
cold solve; the final checks, the stationarity probes, the information step
and every nlminb evaluation remain cold solves from zero modes. A warm
solve that stops short of the mode is replaced by the cold solve, which keeps
the retry from the last valid mode. The evaluation record counts
warm_started and cold_fallbacks. The sparse mode solver no longer
computes the factor's fill counts on every Newton step; .gt_d_sparse_factor()
computes them only when asked, which the diagnostics, tests and profile
study still do.sqrt(.Machine$double.eps) and still refuses inputs that
are not probabilities.start so that the parameter scales are
recomputed, only when the search converged, lies within the bounds, and the
independent deviance reproduces its value within 1e-5. It consumes an existing attempt, adds none, and decides nothing;
gt_control(gaussian = list(initialization = "none")) disables it, and
gt_diagnostics(fit)$initialization records the outcome. An accepted
primary attempt is identical under both settings. Continuation restarts now
perturb the best attempt whose likelihood was independently reconstructed, or
the original start when there is none; a result whose native objective the
independent evaluation contradicted never seeds a restart, and the attempt
table records this in retry_anchor_eligible and retry_anchor_attempt.
The six-flag
mental-health panel, whose default start led into a region where the
algebraic objective was invalid, is what this repairs.gt_dstudy(projection = "balanced") projects to a separately declared
complete allocation; reliability of the incomplete allocation and joint
incomplete Gaussian fitting remain unsupported.gt_reliability() and gt_dstudy() report the mean of the generalized
eigenvalues of the universe covariance relative to universe plus error on
the K - 1 category contrasts, with Erho2_min, Erho2_max, Phi_min and
Phi_max giving their range and latent_dimensions the contrast count;
the residual is (pi^2/6)(I + 11'), so two categories give the binary logit
coefficient. Generalized eigenvalues are invariant to any change of the
contrast basis, so the coefficients do not depend on the reference category;
on a synthetic panel fitted under three references they agree to the
optimizer's tolerance while a trace ratio moves by 0.005. The delta-method
interval of the mean uses the observed information and matches a
finite-difference gradient. A diagonal covariance on the contrasts is a
different model for each reference, so its coefficient is refused, as is a
weighted composite with a nominal outcome. Preflight identifies the
supported nominal latent coefficients, and nominal D-studies use a symmetric
eigenproblem and preserve unavailable rows at unresolved allocations.covariance = "exchangeable" for discrete fits with a nominal outcome:
each source gives every category its own random utility with one variance,
sigma^2 (I + 11') on the contrasts, one parameter per source and outcome
instead of K(K - 1)/2, in exact-zero-capable variance coordinates; binary and
ordinal outcomes in the same fit keep one variance each, and outcomes are
independent within a source. Both engines, the stationarity check, the
observed information, preflight and the Laplace check support it."log_cholesky" remains
available; the paths of joint unstructured fits under "auto" change.
The characterization case discrete_categorical, one three-category nominal
outcome, now reaches its rater covariance's singular boundary: -2 log
likelihood falls by 1.0e-5, no variance moves by more than 0.14%, and rater
joins item among the boundary sources. Its stored baseline was recaptured
for that case only.gt_categorical_target() separately defines observed-score,
relabeling-invariant category-vector and plurality-decision targets.
Decision diversity accompanies agreement, and Monte Carlo errors describe
integration uncertainty at fixed model parameters. Categorical shared-call
refusals point to this repeated-panel target API.2 * (1 + 2 * p^2) marginal
likelihood evaluations for p stored parameters, all from cold conditional
modes, so information can cost much more than point estimation.1e-6, the fit's rule) no longer makes discrete observed information
unavailable. Such a source has no ordinary Wald error: its stored
coordinates sit on or within a difference step of their natural bound, and
along a zero factor column the covariance moves only to second order. It is
held fixed at its fitted covariance and the information is inverted over the
remaining coordinates, nuisance ones included, which is the Gaussian
engine's interior-block estimand. fit$uncertainty records
restricted_to_interior, fixed_components, fixed_component_kinds
("zero" or "singular_nonzero") and information_coordinates; the held
source has no standard error, and reliability tables, prints and reports name
the conditioning. Information is unavailable when every estimated source is
on its boundary. Fits without a boundary source are unchanged. Held at zero,
the information equals that of the model without the source at the same
parameters; at a zero and at a rank-one source the two Hessian methods agree
within 5e-7 at the same parameters. The 2026-10-23 recovery campaign
predates this rule and counted such fits as having no interval, so the
coverage of conditional discrete intervals has not been assessed.gt_bootstrap() is an object bootstrap for any accepted fit whose objects
share one instrumentation layout, without declared batches. Objects are drawn
with replacement, each with its complete
instrumentation panel, and an object drawn twice enters as two objects. Every
resample is refitted under the fit's design, families, estimator, resolved
covariance structures and controls, and must pass the same numerical
acceptance; refused and failed refits are recorded with their reasons and
never counted. gt_reliability() and gt_dstudy() take percentile or BCa
intervals from it (bootstrap =, interval_type =), with the fit's own
point estimates, and summary() gives intervals for every source covariance
entry. BCa uses optional leave-one-object-out refits. An interval needs at
least 50 finite replicate values, and an endpoint beyond the replicates'
support is unavailable. Each attempt draws from its own seed, so the
replicates do not depend on cores or on the attempt budget; discrete refits
start at the original estimates, except that a boundary source starts from
the original starting values. The intervals describe object sampling
conditional on the observed instrumentation levels, not the sampling of the
facet levels. In a frozen Gaussian pilot of 24 items with three or six
raters, 200 REML panels per setting, percentile intervals covered the
population coefficients in 92.0–94.0% of panels for Erho2 and 89.5–92.5%
for Phi, BCa intervals in 89.1–93.8% of the panels where they were
available (85–99%), and delta-method intervals in 95.0–97.0%
(validation-studies/bootstrap-coverage); coverage
for other designs and for discrete fits is unassessed. Tests compare
replicates with direct fits of independently built resamples and intervals
with closed-form coefficients and a hand-computed BCa, and check determinism
across cores and budgets and the refusal, error and guard paths.gt_bootstrap() refits labeled binary outcomes from the fit's retained data.
The retained frame holds them as 0/1 codes, which refits read as the labels
"0" and "1"; the codes are returned to the recorded labels in their recorded
order first, so labeled, reversed-level and mixed binary/ordinal fits no
longer need data =.gt_bootstrap() refuses a fit whose objects do not share one
instrumentation layout: the same facet-level combinations, as often, with the
same outcomes observed. In such a panel, for example an observed-row lme4
fit with an evaluator who rated one item only, a resample that omitted that
item lost the evaluator, although the intervals are stated to hold the
observed levels fixed. Objects that share one partial layout are still
bootstrapped.retry_seed, in the fit's controls or in
control =, is used by every refit and is now recorded, instead of an
unused seed from the stream.gt_report() takes bootstrap = and accepts reliability and D-study tables
with object-bootstrap intervals, recalculating them with that bootstrap after
checking that it belongs to the fit. Edited tables, unrelated bootstraps and
bootstrap tables without their bootstrap are still refused, and the report
keeps only the bootstrap's aggregate counts.gt_plan() can screen the categorical targets over a bounded allocation
grid using declared costs, and works on fits with nominal outcomes: it built
one weight per outcome while the covariance matrices are indexed by latent
dimension, so a three-category nominal outcome made every plan fail with
non-conformable arguments; weights now follow the fit's latent dimensions,
a nominal outcome is screened and costed on its mean generalized-eigenvalue
coefficient, and its scalar universe and error variances and source
contributions are NA, with provenance$decomposition saying why.gt_simulate() and the categorical pilots refuse covariance overrides that
break an exchangeable fit's structure: a nominal block must be
sigma^2 (I + 11') and outcomes stay independent within a source; unequal
diagonals, equal diagonals without the off-diagonal term, and covariance
across outcomes were previously accepted and simulated under the fit's
"exchangeable" label. Simulated score and category-vector noise use
nonnegative variance sums instead of subtracting nearly equal moments, and
item summaries align shuffled groups of unequal sizes and reject invalid
group identifiers.boundary_escape = "projected" in the discrete control lets an
analytic-route fit leave a singular source covariance that its gradient steps
cannot leave. In natural Cholesky coordinates the derivative along an exact
zero factor column vanishes, so the analytic route's optimizer stays on such a
boundary even when the covariance-direction score says that adding variance in
the missing direction improves the fit, and the stationarity check then
refuses the point; the finite-difference route's one-sided difference at the
bound can move off it.
After each completed tight attempt, every singular source whose projected
score points inward has its covariance moved by a projected step that stays
positive semidefinite, with the step length chosen by the objective, and
the tight attempt is rerun from there, at most three times, each rerun kept
as an attempt. The default "none" leaves fits unchanged, a source
legitimately at zero is left alone, and acceptance is unchanged. On a joint
panel fitted from a start with an exact zero column the analytic route is
refused without the step and accepted with it at the reference optimum.1/sqrt(rows), which makes the first
step the per-row gradient; the collapsed run is kept in the attempt's
first_step_rescue record. Attempts that move, attempts that ended in an
optimizer exception, and attempts whose result is unusable are never rerun,
so a failed attempt stays visible and no other path changes. Tight attempts
and nlminb are not scaled.optimizer_scaling = "start" for
per-attempt coordinate preconditioning. Every metric is recorded; original
finite-difference steps and independent acceptance checks are unchanged.
The default optimizer paths remain unchanged.parameter_bounds overrides for
artificial optimizer coordinates. Fitting, preflight and saved-fit Laplace
checks share the domain validation; natural zero boundaries, default domains
and all acceptance thresholds remain unchanged. Requested and effective
domains are recorded, and artificial-bound contact still refuses acceptance.
Alternative starts remain inside narrowly declared domains; ordinary domains
retain their existing start coordinates.gt_laplace_check() reads a fit's retained
responses as the engine's encoding: a binary outcome fitted with labels other
than "0"/"1" is retained as 0/1 integers, and the diagnostic refused
those encodings as new data. Data supplied through data = is still
validated as new data.gt_example(coding = "numeric") names the coding that returns the category
codes as numbers with Gaussian working-score families. coding = "manuscript"
still returns the same tables, with a deprecation warning; the bundled data
files are unchanged.
Formula reconstruction preserves unusual column names. Formula updates refuse declarations whose explicit nesting or source-free facets would be lost; ordinary argument updates retain the design.
gt_reliability() and gt_dstudy() without a projection on an observed-row
Gaussian fit name gt_dstudy(projection = "balanced") in their refusal. The
shipped example scripts and help examples read acceptance and attempt
records through gt_diagnostics() rather than fit fields.
Help and guides no longer say that no scalar nominal coefficient exists, the latent-scale guidance names nominal outcomes, and help clarifies stored information coordinates, quadratic information cost, and the distinction between missing cells and partially observed outcome vectors. The retained profiling harness's README says to create the lock's parent directory when the harness is copied outside the checkout.
Validation summaries, package checks, artifact checks and public-content
audits refuse reused evidence destinations; the manual builder protects
both the existing PDF and prior build logs. New regressions ship with the
installed package, including a nominal fit with estimated exchangeable
covariance and independent coefficient checks, the ordinal and nominal tail
contracts, the categorical-target moment contract, the two-stage sparse
memory estimate and the square-root recovery; every test file is listed in
tests/README.md.
Focused reference and refusal tests accompany these routes. This is not a released or fully qualified 1.0 package: full-panel solver qualification, approximation assessment, recovery and coverage studies, and final cross-platform archive validation remain separate gates. Earlier version records below apply only to their recorded source and archive identities.
Four corrections to the 0.6.0 Model Interface release, found in an independent review. The numerical engines, the acceptance tolerances and every estimate of an accepted fit are unchanged.
gt_laplace_check() reads a fit's retained responses as the engine's
encoding. A binary outcome fitted with labels other than "0"/"1" is
retained as 0/1 integers, and the diagnostic refused those encodings as if
they were new data; data supplied through data = is still validated.fit$parameters is accepted.gt_laplace_check() estimates its dense reconstruction and integration
workspace and refuses, before allocating, a comparison whose estimate
exceeds the discrete max_dense_bytes budget; the estimate is recorded as
resources.This version gives the interface the conventions of other R model objects. The published 0.5.0 archive, its numerical engines, acceptance rules and every estimate are unchanged.
gt_fit() and gt_preflight() accept a two-sided model formula in place of
the outcome names and the design: gt_fit(score ~ item * rater, data) or
gt_fit(cbind(efficacy, safety) ~ item + rater, data), with the data frame
before or after the formula and a family in the third position as glm()
users expect, or under its own name as formula =. The object of
measurement is named by measured =, or else is the first variable on the
right-hand side, and every print of the fit or its design says which; the
other variables are the facets. The resolved design is the one gt_design()
builds, recorded with its formula in fit$design$formula. The source grammar
gains /, so question / item_code declares question + question:item_code.
Replicates, batches and the automatic nesting selectors still need
gt_design().formula(fit) returns the model formula of any fit, also one declared with
gt_design(), and update(fit, . ~ . + item:rater) refits it from the
recorded call with the object of measurement carried along; the recorded
fit$call names each argument whichever order it was given in.c("gt_gaussian_fit", "gt_fit") or
c("gt_discrete_fit", "gt_fit"). The Gaussian engine's internal class label
and the discrete engine's bare "list" no longer appear in class(fit).summary(fit) carries a Gaussian fit's observed-score reliability at the
fitted facet counts, or the reason none is reported, and prints it after the
source variances. deviance(fit) returns the fitted objective for every fit,
including one that failed numerical acceptance; logLik() still refuses one.gt_control(gaussian = list(engine = "lme4"))
fits the declared sources as random intercepts with lme4, one outcome at a
time and with the call source when a batch is modelled. The fit is accepted
only when lme4's optimizer completes without a convergence warning, the
package's own stationarity check on lme4's deviance function passes (lme4's
Cholesky-scaled gradient statistic over interior parameters, and no inward
one-sided derivative at a parameter on its zero bound), a restart reproduces
the solution, and the exact balanced deviance evaluated at the estimates
agrees with lme4's criterion. It computes no source-variance standard errors,
so reliability-coefficient intervals are unavailable on this path. gt_diagnostics() now records
engine, optimizer and approximation as three separate facts, and exposes the
stationarity record and, for the lme4 engine, the likelihood agreement
record at its top level.gt_laplace_check(fit) compares the first-order Laplace objective of a
discrete fit, at its fitted parameters, with a refined numerical estimate of
the marginal likelihood: adaptive Gauss-Hermite quadrature up to four
random-effect dimensions, defensive-mixture importance sampling otherwise,
with the Monte Carlo standard error and effective sample size. The mixture
contains 90% Laplace Gaussian and 10% random-effect prior and uses the full
mixture density for all weights; the prior component guarantees finite
weight moments for the categorical probability likelihoods. Monte Carlo
precision remains a finite-sample diagnostic, not an error bound.
Limits are applied before anything is allocated, every new solve is
verified, an unevaluable point makes the estimate unavailable rather than
zero, and each result carries a usability verdict. The comparison estimates
a fixed-parameter objective discrepancy, with finite-sample limitations; it
does not assess parameter bias or refit the model.gt_diagnostics() exposes a parameter_map linking each
retained theta and derivative position to its scientific source and lme4
parameter identity, including when the engine model is not retained. Existing
numeric order, integer boundary positions and acceptance arithmetic are
unchanged. The lme4 path returns source covariance estimates; its unavailable
quantity is their sampling covariance, not those estimates.gt_design(), gt_family(), gt_control(), gt_batch(), gt_score() and
gt_example() results print as short descriptions instead of raw lists, and
gt_pilot_plan() returns a classed gt_pilot_plan with print() and
as.data.frame() methods. The elements of every object are unchanged. Print methods wrap long sentences to the console width
(getOption("width")), as R's own printing does.This version adds bounded study-planning tools. Historical release assets and the numerical acceptance rules are unchanged.
gt_batch_reliability() and gt_batch_dstudy() project item-score, named
contrast and aggregate error under a fitted equal fixed Gaussian batching
layout. Targets are conditional on that layout; no new-batch-size effect or
universal batch-adjusted G is inferred.gt_plan() enumerates supplied allocation grids and ranks them using dated,
user-supplied cost assumptions, constraints and point or available lower-bound
targets. It retains infeasible candidates, Pareto options and baseline
marginal benefits without changing the declared score universe.gt_simulate() generates balanced Gaussian studies and gt_pilot_plan()
refits prospective pilot designs, retaining all attempts, numerical refusals,
interval availability and Monte Carlo uncertainty. These are model-based
design simulations, not calibrated bootstrap intervals or coverage guarantees.layout$item keys to name contrast and aggregate weights. This
corrects a false refusal after an otherwise valid fit; covariance estimation
and projection arithmetic are unchanged.0.4.0 was tagged and its bundle staged, but it was not published or submitted: its release check on R built without long double refused a fit on one machine and the test could not say so. 0.4.1 is 0.4.0 with that test corrected and no other change to the package.
tests/package-characterization.R required every discrete case to be
numerically accepted. On some machines the discrete optimizer reports
completion without reaching a stationary point (#59), the engine refuses the
fit through its stationarity and restart-stability safeguards, and the test
then stopped at the coefficients it could not compute. The ordinal case, the
one case observed to be refused this way, is now reported as that platform's
outcome when it is refused by those two safeguards and by nothing else: its
estimates are not compared there, but it must still carry every other
recorded field, the same model terms and the same variance names. Any other
case refused this way, a refusal for any other reason, or accepted numbers
that moved still fail. The acceptance and completion flags are recorded as
the engine set them, and a fit without a single TRUE or FALSE flag stops the
test. The comparison and the recording are exercised with constructed
records and fits before any fit is compared. The engine is unchanged.Changes since 0.2.0. The development line was versioned 0.3.0.9000 and then
0.4.0.9000; no 0.3.0 was released. For a design without a batch declaration,
every estimate, coefficient and acceptance decision in
tests/package-characterization.R reproduces its values: the fitting
arithmetic is untouched, and the changes add refusals, evidence and reporting.
The one new model is the shared call effect a Gaussian fit estimates for a
design that declares equal fixed batches, described first below.
tests/package-discrete-safety.R, where one ordinal fit on a boundary panel
was required to be numerically accepted. On that build the optimizer reports
completion without leaving its starting values, and the fit is refused by
the stationarity check. Refusing it is the correct outcome; requiring
acceptance was the test's error.gt_batch() declares that items were annotated several to a call, and
gt_design() carries the declaration to every function that receives the
design or a fit. With none declared, items are independent given the
declared sources and every result is what it was. By default a declaration
assumes items in one call affect each other equally; sequential and
neighbor, both off by default, declare that an item may be affected by a
stated number of preceding items or of items on either side, at most one
less than the batch size. by names a facet, such as the evaluator, across
whose levels the dependence may differ.id, batches are
cut from the item order and are the same in every condition; that is a
reconstruction, and it cannot detect items removed after collection. With
id naming a column that identifies each row's call, the calls are read
from the data and may differ between conditions and in size.gt_preflight() audits a declaration: the batches, conditions and calls it
implies or records, whether it describes the data, and, for inferred batches
whose rows are stored call by call, whether that storage agrees with it.
Implied calls count one for each batch, condition and declared replicate. A
call with fewer items present than declared is reported, not treated as a
mismatch. Recorded calls are counted from the rows supplied: the audit says
that a call sent short and a call that lost rows afterwards look the same,
that a call with no row left is not counted, and that positions are ranks
among the items present, not necessarily the positions at which they were
sent.Call with its standard error, by the exact balanced likelihood, in which
an item is a batch-by-slot cell. REML and ML fits match lme4's in criterion
and variances, including a call variance of zero. gt_preflight() says
beforehand whether a fit will model the batches, and why not when it will
not; its source table, parameter counts and strata describe the sources the
fit will estimate, the call among them. Whether the batches were modelled is
recorded for each fit, so a fitted design reused for another outcome family
does not carry the earlier fit's answer.gt_reliability() and gt_dstudy() refuse it. sequential, neighbor
and by are recorded and not yet estimated.not_declared, declared_not_modelled with the reason, or modelled;
coefficients and decision studies print it, their data-frame exports and
gt_dstudy_target() carry batch_status, the plots state it where a
caller's own subtitle cannot replace it, and gt_report() records it. The
exports gain that one column for every design.as.data.frame() methods.
Allocation columns are prefixed, and D-study metadata is joined by design
identity. Scale, extrapolation and uncertainty status travel with exported
estimates, including unavailable intervals.gt_dstudy_target() screens one outcome or composite against an estimated
G/Phi target within the supplied allocation grid. It preserves all candidates
and ties; it does not search for a global or monetary optimum.sparse_newton_solve_invalid or sparse_final_factor_invalid, exactly as the
dense solver refuses; there is no fallback, regularization or looser
tolerance. tests/test_discrete_sparse_validity.R injects a corrupted step
and a factor of a different matrix and checks the refusal, its reason and
its retained measurements, on the sparse mode solver and end to end through
the private evaluator seam. The frozen fixed-parameter, conditional-mode and
fitted sparse contracts reproduce unchanged with the checks in place.reason=,
backward_error=, solve_validity_bound=, random_dimension= and
probe_index= fields are unchanged.fit$diagnostics$evaluations records the count of
evaluations, the count the optimizer could not use, the count of valid
conditional solves that ended at the inner iteration budget, and, for at most
eight invalid evaluations, the parameters asked about and the measurements
reported; the conditional-mode diagnostic stage reports the three counts.
The arithmetic is unchanged, because details selects what a mode solver
returns and never what it computes.GTHEORY_DISCRETE_SPECIMEN_DIR to a
directory writes a specimen file for each refused start and each retained
invalid evaluation: the failed operation's matrix, right-hand side, step and
factor where the failure produced them, the parameters, the measurements and
the identity of the numerical environment, as numeric objects that can be
reloaded and replayed. It holds no observations. Off by default; a failed
write is reported in the refusal message and never masks the refusal.
SECURITY.md says so.inner_iterations, whether the line search failed to improve the penalised
objective (inner_line_search_failed) and whether the final factorization
was unavailable. Previously a failed evaluation carried no iteration count,
so the retained scale-risk profile could not attribute its invalid
evaluations; see the replay recorded in
validation-studies/discrete-sparse-profile/results.md. The profile's work
pass now reports those stop causes.scripts/replay_specimen.R reads a specimen back and answers three
questions separately: whether the stored step still fails the stored
system, whether the stored factor still fails on this host, and whether a
fresh factorization here fails too. Its verdict describes those observations
without inferring a defective matrix, a responsible host, or portability
from one replay. Reproducing the recorded backward error also requires
agreement at numerical precision and the same solve-validity decision.
tests/test_specimen_replay.R exercises it on dense and sparse specimens
written through the real refusal site.tests/test_interface.R:
the FALSE-only rule it replaced accepts a discrete fixture whose flag is
NA, and the test proves that its own assertion catches that.tight specimen reported 1e-7 for an
evaluation that ran at 1e-9. The fit and its acceptance were unaffected.fit$diagnostics$evaluations$validity_events counts every
one. These limits and counts cover the optimizer's logged evaluations, not
final checks.fit$diagnostics$final_checks, and
writes its failed operation as a specimen when a directory is configured.
Only a raised error's text was kept before, so a refusal returned without
an error blocked acceptance and left no account of why.fit$diagnostics$outer_stationarity$failure, and writes its
failed operation as a specimen when a directory is configured. Its retained
error named only "invalid conditional mode"; for a solve- or
factor-validity refusal it now also names the reason and its measurements.
A probe that merely did not converge keeps the established message.do.call(), or with the data written inline, gt_preflight() stored
the whole data frame in $call, unused columns included, whatever
max_examples was. A data argument that is not a plain object name is now
recorded as a marker, as a fit records it when its data is dropped.0.2.0 archive, manual, manifest and tag are retained
unchanged.plot() on a decision study accepts col, pch, ylim, xlab and ylab
through .... They were supplied explicitly before the dots were forwarded,
so passing any of them failed with a duplicate-argument error; they are now
defaults that a named argument replaces (#39, plotting).logLik(), and through it AIC() and BIC(), apply the same acceptance
rule as gt_reliability() and gt_dstudy(), from one shared predicate: a
Gaussian fit is refused on an explicit failure, and a discrete fit must carry
an affirmative acceptance. A discrete object whose acceptance flag is missing
or NA is refused rather than read as accepted. Freshly fitted objects are
unaffected; every fitted discrete object carries the flag.engine
(sparse_joint_discrete_laplace), derived from the retained
marginal_backend, so a fit never describes itself as the dense engine when
another implementation produced it. Dense fits are unchanged, and
reliability, decision studies and preflight no longer key on the dense
engine string. No public entry point selects the sparse backend.cal_tail) was built with the five-level tail-mass
construction on a three-level scale, because the level selector recognised
the exact geometry name while the panel builder recognised any name
containing "tail": its categories were 15/60/165, with 68.75% of the panel in
the top category. One explicit definition, EQ_TAIL_GEOMETRIES, now serves
both, and the freeze test asserts the category composition of every
tail-mass panel rather than only its digest. The original and corrected
fixture identities are recorded as a pre-calibration amendment in
CALIBRATION.md; the scored case C12 and every other fixture are unchanged,
and no tolerance had been derived from the defective panel.validation-studies/discrete-sparse-profile/results.md.budget-experiment.R: a doubled inner budget recovers 32 of
the 48 unusable evaluations and all 40 marginal solves cold, and a warm
start from the previous evaluation's mode recovers 38 of 48 at the ordinary
budget in a median of 9 iterations; 16 evaluations do not converge cold
within 300 iterations and are not a budget question. The roadmap and
development status now state the 0.4.0 release gates and this line's
position against them.Cut from the 0.2.0 development line for the CRAN resubmission. Every estimate,
coefficient and acceptance decision in tests/package-characterization.R
reproduces the 0.1.0 values within the tolerances recorded there. The one change
to fitting itself is the refusal of a dense conditional solve that does not
solve its own system, recorded under engineering below. Everything else is new
reporting, corrections, engineering behind private seams, and the release
maintenance that followed 0.1.0.
gt_diagnostics() gains a stages element summarising the numerical checks
a fit passed through: optimizer completion, conditional mode, independent
stationarity, restart and tolerance stability, numerical acceptance, and
approximation assessment, each with a status, a reason and its supporting
measurements, so a rejection names the stage responsible without the caller
reading private optimizer records. The status is passed, failed,
not_assessed for a check that did not run or does not apply to the engine,
or inconclusive for one that ran without a clear verdict; absent evidence
is never read as a pass. The summary is derived from evidence the fit already
retained, including the tolerances that governed the retained solve: it never
refits and never changes an acceptance decision. Print methods are registered
for the stage summary and for a single stage.passed when a
record says its solve was tightened but does not retain the tolerance that
governed it. That record now reports inconclusive, because the retained
evidence cannot establish that the solve met what was asked of it. This
changes reporting only, and only for incomplete or older fit objects: a fit
produced by this version retains that tolerance. Fitting, numerical
acceptance, and reliability and D-study eligibility are unchanged.docs/, scripts/VALIDATION.md, validation-studies/, artifacts/,
SECURITY.md, LICENSE) are now absolute repository URLs. CRAN's incoming
check reported the relative scripts/VALIDATION.md and LICENSE links of
the 0.0.6 submission as invalid file URIs; a test now refuses any README or
NEWS link to a file that .Rbuildignore keeps out of the archive.SECURITY.md named a control that does not exist. The retention switch is
gt_control(retain = list(data = FALSE)).BIC() on a REML fit is documented, and its convention, N response vectors
with the covariance parameters only, is recorded as
reml_BIC_response_vectors_variance_parameters. help("gt_fit") no longer
says the generic criteria are unavailable for REML: the fit's own AIC and
BIC elements are NA, the generics are not.load_functions.R sources R/discrete_sparse_mode.R, matching the Collate
field; a test keeps the two lists equal.print(gt_diagnostics(fit)) states the standard-error availability once.gt_component_vcov()
adds conditional_on_fixed naming every fixed component, and
conditional_on_zero now names only the zero ones. The boundary flag, the
point estimates and the interval arithmetic are unchanged (#36).logLik(), and through it AIC() and BIC(), refuse a fit that failed
numerical acceptance, as gt_reliability() already did; the objective
stays in minus2loglik for diagnosis. The generics previously returned
ordinary values while print(fit) called the estimates diagnostic only.gt_control(retain = list(data = FALSE)) now removes every copy of the
observations. The retained Gaussian OpenMx model carried the raw outcomes as
summary metadata, so a fit saved after dropping the data still held them,
and the recorded call held the whole data frame, unused columns included,
when the fit came through do.call() or with the data written inline.
The observations are stripped from the retained model, which nothing reads
after fitting, the call's data argument is replaced by a marker, and a
test hunts a sentinel observation and a sentinel unused column through the
serialized fit for direct, programmatic and inline calls. SECURITY.md
says so.1e15 and 1e15 + 1,
passed gt_preflight() and were then refused by gt_fit() as duplicate
cells; they now fit (#39, facet identity).1e12 moved accepted estimates in
their fifth digit and 1e15 in their second. A regression fits the same
represented panel at the origin and at an offset of 1e12 and requires
identical variances and deviance.summary() of an ordinal fit no longer lists the outcome's location under
"Fixed location or contrast estimates": it is fixed at zero for
identification and is now printed as such. Binary intercepts and
categorical contrasts are still printed as estimates.gt_diagnostics(), no longer carry
the constructor's specification-only note after the engine's data checks
have run; the discrete path now records its validation scope through the
same step the Gaussian path uses.scripts/prepare_release.py --from-checked-candidate refuses a candidate
directory without a check report recording a successful R-devel check of
exactly those archive bytes, and records the checking R version in the
manifest's provenance.dense_newton_solve_invalid, dense_final_factor_invalid),
reporting the backward error and its bound when the refusal happens at the
starting values. A native Cholesky can return successfully and still hand
back a factor of some other matrix; issue #14 captured one such instance on a
hosted runner, and a returned factor is no longer treated as valid merely
because no error was raised.Matrix and methods joined Imports for
the private sparse random-design, Hessian, factorization and conditional-mode
files behind a private evaluator seam. None of it is public API: no public
entry point selects the sparse path, and every fit still runs through the
dense engine. The compatibility matrix runs the sparse factorization test on
every platform.First 0.1 release. An earlier 0.1.0 candidate was prepared locally but never
tagged or published, so this release is cut from the hardened sources instead
and supersedes it; the notes below cover both. The statistical models are
unchanged from that candidate: every estimate, coefficient and acceptance
decision in tests/package-characterization.R reproduces its values within the
tolerances recorded there.
p x (i:h) and for p x (i:h) x r with a fixed facet, with every
expected coefficient written out from the published formulas rather than
produced by the code under test. Nested designs were previously exercised only
at the specification level: no nested model was fitted, and no nested
reliability or decision study was computed.help("gt_design"), help("gt_reliability") and help("gt_dstudy") now
define balanced coded panel explicitly, with a worked contrast between
globally unique child labels and within-parent codes.R/gaussian_retry.R. Every attempt now
records a real optimizer status; previously a trial run inside OpenMx's own
retry loop could be recorded with an unknown status, and a change in OpenMx's
message wording could fail an otherwise valid fit.fit$retry_attempts gains start_type (replacing start) and
optimizer_success, and drops the transcript-specific native_attempt,
invocation, continuation_reason and native_returned_fit columns.
attempt, optimizer, status, minus2loglik, external_accepted,
external_rejection_reason, error and returned_fit are unchanged.
fit$retry_settings$native_invocations becomes optimizer_runs.extra_tries + 1 runs, each
unsuccessful run followed by OpenMx's own bounded uniform perturbation of the
best model so far, stopping at the first externally accepted run.logLik(), nobs() and coef() methods for gt_fit, and a print
method for gt_diagnostics(), which now returns a classed object.AIC() and BIC() reproduce the fit's own recorded conventions: an ML fit's
ml_AIC and ml_BIC_response_vectors, a REML fit's
reml_AIC_variance_parameters. A REML logLik carries REML = TRUE; a
discrete one is labelled as a first-order Laplace approximation.gt_component_vcov() for the sampling covariance of the estimated source
covariances, which is what gt_reliability() propagates into an interval.vcov() on a fit raises an error rather than returning that matrix. In R,
vcov(fit) is the covariance of coef(fit), and generic tooling relies on
the pairing; this package does not estimate it, because Gaussian outcome means
are profiled out of the likelihood and the discrete engine computes no
observed information. The error names the reason and points at
gt_component_vcov().gt_control() gains retain, choosing which optional components a fit keeps:
data, model, retry_log and session. Every default is TRUE, so an
existing call is unaffected. Dropping all four reduced a 600-row Gaussian fit
from 525 KB to 64 KB with every reported result identical, including
reliability, decision studies, diagnostics, correlations and the component
covariance.panel summary, so reliability and decision
studies remain available when the modelled data was not kept. Where the data
is kept it is still what the balanced-panel rules are checked against, so a
panel edited after fitting is still caught.max_dense_bytes (default 512 MiB), checked before
allocation. The other discrete limits bound counts; this bounds the dense
algebra those counts imply, which is what protects a caller who raises them.
The refusal names the estimate, the limit, the observation count, the random
dimension, the size of the random-design matrix, and the alternatives. It does
not bind for any model the existing count limits already allow.artifacts/manifest.json declares release_state, and the marked README and
NEWS blocks declare it too. Publication is now checked against git: a
published claim requires the version tag, and a prepared claim fails once
that tag exists. Nothing calls a bundle published before it is.scripts/prepare_release.py, which derives every version from
DESCRIPTION, validates, builds the archive and manual, writes the manifest,
rewrites the release blocks, verifies the result, and stops. It never tags,
pushes, uploads or submits.scripts/check_public_contents.py no longer hard-codes the version: the
package name comes from DESCRIPTION and the bundle version from the manifest,
which is what lets a development checkout retain the preceding bundle.docs/REPOSITORY_POLICY.md with the required branch-protection state,
docs/branch-protection.json as the exact payload, and
scripts/check_branch_protection.py to verify it. The declared branch
protection was applied to main after the release was published.SECURITY.md and CODEOWNERS.R CMD Rd2pdf when R's
generated LaTeX is not the layout its customized cover knows how to reflow,
and reports which route it took and whether the overfull-box gate could run.
The manual gate now requires both pdflatex and makeindex before claiming
it can run, and names the missing tool when it skips.scripts/dependency-locks/renv-bootstrap.json,
verified by SHA-256 before installation, and preferentially taken from a cache
that both locked workflows now keep. Pinning a version says which renv is
used; the digest and the cache are what make retrieving it checkable and
possible.plot() on a decision study now reports an invalid coefficient instead of
failing on a zero-length condition.gt_preflight() and gt_fit() now share one definition of the covariance and
residual rules, so a request one accepts is a request the other accepts.
Previously preflight admitted a Residual covariance override that fitting
refused, and fitting completed abbreviated residual names that preflight
rejected. Both now refuse both, with the same message.T in the discrete engine no longer shadows the TRUE
alias.docs/LIMITATIONS.md collects every limitation in one place; the other
documents link to it. docs/ROADMAP.md records planned work.
docs/DEVELOPMENT_STATUS.md now holds only the current state.The capability this release ships, unchanged from the earlier candidate.
The version change does not add sparse fitting, unbalanced Gaussian estimation or reliability, cost-aware planning, bootstrap/jackknife, or discrete intervals. GitHub publication and package checks are separate from CRAN submission and acceptance.
variance covariance coordinates, which auto now selects for every
univariate or diagonal discrete model, treated any negative coordinate as an
error. A bounded optimizer evaluates a few ulps outside a bound while
projecting onto it, so a coordinate of -3.4e-17 recorded an attempt error,
set computation_failed, and rejected the entire fit. Zero is this
parameterization's natural domain boundary, so rounding noise is now
projected onto it; a coordinate meaningfully below zero still stops. This
rejected fits whose estimates were already correct, including the ordinal fit
in examples/standalone_usage.R.NA rather than a
number whenever the joint Hessian happened to stay invertible, matching what
it already reported when the Hessian did not. No symmetric interval follows
from curvature at a boundary. The full entry covariance matrix is unchanged
in $uncertainty, and coefficient intervals still use it.R CMD build write build/vignette.rds and
inst/doc/ products into the archive, which no release gate expected. The
public-content audit rejected the build index as an unexpected build file and
then as a malformed example resource; the committed-artifact gate would have
reported every generated vignette product as content missing from git at the
next release. Both now account for them, and inst/doc/ products are derived
from the vignettes declared in the source commit rather than excused by
prefix, so an unexpected file there still fails.R CMD check failed the whole
package on Packages suggested but not available, reporting a missing
documentation toolchain as a package defect. The gate now checks with
_R_CHECK_FORCE_SUGGESTS_=false in exactly that case, and accepts the single
extra --as-cran line about a missing vignette index only when vignettes
were genuinely skipped, so it can never excuse a real one.fs needs
libuv headers, and install.packages() only warns when a build fails, so the
step passed while the toolchain was absent. The workflow installs libuv1-dev
and the step now asserts the result instead of reporting success either way.fixed = "temp" selects a reliability estimand after fitting;
it does not alter the fitted variance model. A within-temperature analysis is
one conditional sensitivity analysis when pooling is questionable.2 * H^-1 and keeps it. Reconstructed values match OpenMx's
own standard errors to machine precision and match the classical mean-square
formulas for a crossed two-way design to five significant figures.gt_reliability() and gt_dstudy(), per outcome and for weighted composites.
New level argument; new Erho2_se, Erho2_lower, Erho2_upper, Phi_se,
Phi_lower, and Phi_upper columns. plot.gt_dstudy() draws the bounds.
Deterministic tests check the delta-method mapping. A previously reported
pilot coverage range has no reproducible protocol/results in the public
repository and does not define a validated operating range.NA, never a structural zero that would read as certainty.check_hessian is
disabled or the curvature is unusable. The discrete Laplace engine computes no
observed information and says so rather than leaving the field empty.fixed to gt_reliability() and gt_dstudy(), implementing the mixed
model of Brennan (2001): the object-by-fixed-facet variance is averaged over
that facet's levels and joins universe-score variance, a source built only
from fixed facets shifts every object equally and leaves the model, and every
other source keeps its usual divisor. With no fixed facet the decomposition is
unchanged. $source_roles records the role each source took.full_cell to gt_design(). full_cell = FALSE removes exactly the
object-by-all-facets source and leaves every other requested source
unchanged, which is how a binary or ordinal study with one observation per
cell declares the default crossed design. The discrete rejection message now
names that argument. The source is still never dropped automatically.browseVignettes("Gtheory4LLM") finds it. system.file("doc", "LLM-workflow.R") and the installed HTML keep working.man/*.Rd and NAMESPACE the only documentation source of truth. The R
files previously carried roxygen blocks that were not the source of the richer
hand-written Rd pages; running roxygen2 would have replaced them and dropped
the S3 methods registered in NAMESPACE. Those blocks are now plain comments.R (>= 4.5.0) floor comes from OpenMx's under-declared C API
requirement rather than from this package's own code.covariance_parameterization
default change, and adds installed-package regression tests for standard
errors, the delta-method mapping, coefficient intervals, mixed-model fixed
facets, and full_cell..DS_Store, which git already ignores and a desktop
environment recreates. The exemption is by exact filename, is reported under
skipped_os_metadata, and never applies inside an archive.scripts/check_package.py needs
knitr, rmarkdown, and pandoc. When they are absent it records that, builds
with --no-build-vignettes, checks with --ignore-vignettes, and the
installed-tutorial stage prints NOT RUN rather than passing silently. The
three workflows install the toolchain.counts to gt_reliability() with the existing design argument retained
as a compatibility alias.auto: direct variances for
univariate/diagonal models and log-Cholesky for joint unstructured models.
Explicit choices and numerical acceptance criteria remain available.gt_preflight() to report resolved sources, covariance and random-effect
dimensions, replication/completeness, resource limits, and supported scales.Scope at 0.0.6 was exact balanced Gaussian likelihood and small-model first-order Laplace discrete likelihood. Discrete latent random effects remain Gaussian. Binary/ordinal reliability requires an explicit latent scale; unordered categorical scalar reliability, observed-score discrete reliability, joint Gaussian-discrete fitting, bootstrap/jackknife, and uncertainty intervals of any kind were not implemented in that release. (The development version adds asymptotic Wald standard errors and delta-method coefficient intervals for Gaussian fits only; see above.) Numerical tests do not establish parameter recovery, approximation adequacy, or application-wide statistical validity.