lotri

Provides a simple mechanism to specify a symmetric block diagonal matrices (often used for covariance matrices). This is based on the domain specific language implemented in 'nlmixr2' but expanded to create matrices in R generally instead of specifying parts of matrices to estimate. It has expanded to include some matrix manipulation functions that are generally useful for 'rxode2' and 'nlmixr2'.

Releases

14

Needs compilation

Yes

Needs R

>= 3.4.0

Config/roxygen2/version

8.1.0

Config/testthat/edition

3

Language

en-US

• Matrix classes and algebra

Since March 2026

• armadillo4r
• checkmate
• cpp4r
• crayon
• methods
• stats
• utils

Installing it adds

5 packages, 1.5 MB of source

Of those, need compilation

2

• ggplot2
• knitr
• Matrix
• memuse
• microbenchmark
• rmarkdown
• testthat

Lines by kind (18,543)

Lines by language

Languages are counted from file extensions.

Files

107

R functions

137

Compiled functions

50

Object systems

S3: 11 methods

Median

4

Mean

7.54

Highest

66

Median lines per function

14

R functions

137

Calls

208

Unconnected

13

Groups

2

Has tests

Yes

Test frameworks

testthat

Test cases

293

Snapshot tests

4

Test lines per line of code

1.33

• Lotri Motivation
• Prior distributions in lotri
• Repeated blocks with same() in lotri

README

Yes, 1,342 words

Release notes file

Yes

Help pages

14

Lines of documentation

923

Commits

490

Open pull requests

4

Tagged releases

9

Latest tagged release

v1.0.5, 11 Sep 2026

Issues closed in

2 days (median)

Pull requests closed in

0 days (median)

Pull requests merged

92%

Created

1 Dec 2021

Licence file reads as

–

Method, repository practices

Across nlmixr2

New features

• A block can now be repeated with same(), which is NONMEM's $OMEGA BLOCK(n) SAME:

```r

lotri({

iov.cl1 + iov.v1 ~ c(0.1,

0.01, 0.2)

iov.cl2 + iov.v2 ~ same()

iov.cl3 + iov.v3 ~ same()

})

```

This is one estimated 2x2 covariance shared by three blocks, which is

how inter-occasion variability is parameterized when every occasion

draws its own random effects from one shared covariance -- and it is

what lets those random effects be *correlated*.

same() repeats the immediately preceding block under new names and

takes no arguments. A further same() repeats that same original

block rather than the copy, the way NONMEM chains SAME. It works

with a condition (iov.cl2 + iov.v2 ~ same() | occ), it inherits the

fixed flags of the block it repeats, and it composes with the

cnd(same = n) nesting property that lotriSep() uses.

• The `condition` column can now carry a `:same:` suffix. Rather than adding a column to the data frame from as.data.frame(), a repeated block records the element it mirrors in the existing condition column, naming it: `` <baseCondition>:same:<masterEta> # diagonal row <baseCondition>:same:<masterEta1>:<masterEta2> # covariance row ` The master is named rather than indexed because neta1/neta2 are renumbered whenever parameters are added, dropped or reordered. A copy keeps its master's est and fix, so a consumer that does not understand the suffix still sees a numerically correct matrix -- just with more free parameters than the model really has. Four helpers are exported for reading that column, and code that compares condition directly (condition == "id"`) should move to them, since such a test misclassifies a repeated block:
• lotriBaseCondition() strips the suffix,
• lotriIsSame() says whether a row mirrors another,
• lotriSameMap() maps each eta to the eta it mirrors,
• lotriSameBreak() drops the linkage for a block that has been structurally changed.

same() round trips through as.data.frame(), as.lotri() and

as.expression(), and the linkage is carried across lotriMat().

A repetition that no longer describes a real mirror -- because the

blocks it was built from were reordered or dropped, or because it

carries something same() cannot express -- is written out with its

explicit values instead. That loses the annotation, never the

numbers.

A prior cannot be put on a repeated block -- it is not a parameter of

its own, so the prior belongs on the block it mirrors. Without this

a model could carry two different priors on what is one estimated

parameter.

same() cannot be combined with a cov function, nor with

rcm=TRUE on a matrix the permutation would actually reorder; both

would move a repeated block away from the block it repeats, and are

refused rather than silently producing a matrix whose repetition is

no longer true. A same() matrix that is already block diagonal is

left alone, since there rcm is a no-op, which keeps rxode2's

ini({}) -- which always passes rcm=TRUE -- working.

• Prior distributions can now be specified in a lotri({}) (and therefore ini({})) block with prior(name) ~ dist(...), ie:

```r

lotri({

tka <- 0.45

tcl <- c(0, 1, 10)

eta.cl + eta.v ~ c(0.1,

0.01, 0.2)

prior(tka) ~ dnorm(0, 10)

prior(tcl) ~ dlnorm(1, 0.5)

prior(eta.cl, eta.v) ~ lkjCorr(2)

})

```

Because the statement names its target, prior lines may be given

anywhere in the block. Priors may be put on population estimates,

on individual etas, and on whole covariance blocks (with the

matrix-valued distributions like lkjCorr() and invWishart()).

Every distribution has three accepted spellings: the R name where R