## ----setup, include = FALSE---------------------------------------------------
knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>"
)
library(lotri)

## -----------------------------------------------------------------------------
m <- lotri({
  tka <- 0.45
  tcl <- c(0, 1, 10)

  prior(tka) ~ dnorm(0, 10)
  prior(tcl) ~ dlnorm(1, 0.5)
})

lotriEst(m)

## -----------------------------------------------------------------------------
m1 <- lotri({
  tka <- 0.45
  prior(tka) ~ dnorm(0, 10)
})

m2 <- lotri({
  prior(tka) ~ dnorm(0, 10)
  tka <- 0.45
})

identical(m1, m2)

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tka <- 0.45
  prior(tka) ~ dnorm(0, 10)
}))

## -----------------------------------------------------------------------------
m <- lotri({
  eta.ka ~ 0.3
  prior(eta.ka) ~ dgamma(2, 1)
})

attr(m, "lotriPriors")

## -----------------------------------------------------------------------------
m <- lotri({
  eta.cl + eta.v ~ c(0.1,
                     0.01, 0.2)
  prior(eta.cl, eta.v) ~ lkjCorr(2)
})

attr(m, "lotriPriors")

## -----------------------------------------------------------------------------
m <- lotri({
  eta.cl + eta.v ~ c(0.1,
                     0.01, 0.2)
  eta.ka ~ 0.3
  prior(eta.cl, eta.v) ~ invWishart(4)
  prior(eta.ka) ~ invWishart(2)
})

as.data.frame(m)[, c("name", "est", "prior")]

## -----------------------------------------------------------------------------
m <- lotri({
  eta.cl + eta.v ~ c(0.3,
                     0.01, 0.1)
  eta.ka ~ 0.5
  ~invWishart(4)
})

as.data.frame(m)[, c("name", "est", "prior")]

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  eta.cl + eta.v ~ c(0.3,
                     0.01, 0.1)
  ~invWishart(4)
  prior(eta.cl, eta.v) ~ invWishart(5)
})
})

## -----------------------------------------------------------------------------
lotriEst(lotri({
  e1 + e2 ~ c(1,
              0.1, 1)
  prior(e1, e2) ~ invWishart(4, lotri(e1 + e2 ~ c(2,
                                                  0.5, 2)))
}))
attr(lotri({
  e1 + e2 ~ c(1,
              0.1, 1)
  prior(e1, e2) ~ invWishart(4, lotri(e1 + e2 ~ c(2,
                                                  0.5, 2)))
}), "lotriPriors")

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  e1 + e2 ~ c(1,
              0.1, 1)
  prior(e1, e2) ~ invWishart(1)
})
})

## -----------------------------------------------------------------------------
m <- lotri({
  eta.cl ~ 0.3
  eta.v ~ 0.1
  om.eta.cl ~ 0.01
  om.eta.v ~ 0.04
})

attr(m, "lotriPriors")

## -----------------------------------------------------------------------------
diag(m)

## -----------------------------------------------------------------------------
m2 <- lotri({
  eta.cl + eta.v ~ c(0.3,
                     0.01, 0.1)
  om.eta.cl ~ 0.01
  om.eta.v ~ c(0.001, 0.02)
})

attr(m2, "lotriPriors")[1]

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  eta.ka ~ 0.3
  om.eta.nope ~ 0.1
})
})

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  eta.cl + eta.v ~ c(0.3,
                     0.01, 0.1)
  eta.ka ~ 0.5
  prior(eta.cl, eta.v) ~ invWishart(4)
  om.eta.ka ~ 0.01
})
})

## -----------------------------------------------------------------------------
m <- lotri({
  tcl <- 1
  eta.cl ~ 0.3
  tcl + om.eta.cl ~ c(0.01,
                      0.002, 0.005)
})

lotriEst(m)$prior

## -----------------------------------------------------------------------------
attr(m, "lotriPriors")
diag(m)

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tcl <- 1
  eta.cl ~ 0.3
  prior(tcl, om.eta.cl) ~ multiNormal(c(1, 0.3),
                                      lotri(tcl + om.eta.cl ~ c(0.01,
                                                                0.002, 0.005)))
}))$prior

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tcl <- 1
  eta.cl ~ 0.3
  eta.v ~ 0.1
  tcl + om.eta.cl + om.eta.v ~ c(0.01,
                                 0.002, 0.005,
                                 0.001, 0.0005, 0.004)
}))$prior

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  eta.a ~ 1
  eta.b ~ 1
  prior(eta.a, eta.b) ~ lkjCorr(2)
})
})

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tka <- 1
  tka ~ 4
}))

## -----------------------------------------------------------------------------
m <- lotri({
  tka <- 1
  tcl <- 3
  tv  <- 4
  tcl + tv ~ c(1,
               0.01, 1)
})

lotriEst(m)$prior

## -----------------------------------------------------------------------------
.eta <- lotri({ a + b ~ c(1,
                          0.5, 2) })

.prior <- lotri({
  a <- 1
  b <- 2
  a + b ~ c(1,
            0.5, 2)
})

## pull the covariance back out of the stored prior
identical(unname(as.matrix(eval(str2lang(lotriEst(.prior)$prior[1])[[3]]))),
          unname(as.matrix(.eta)))

## -----------------------------------------------------------------------------
m2 <- lotri({
  tka <- 1
  tcl <- 3
  tv  <- 4
  tcl ~ 1
  tv ~ c(0.01, 1)
})

identical(m, m2)

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tcl <- 3
  tv  <- 4
  tcl + tv ~ c(1,
               0, 1)
}))$prior

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tcl <- 3
  tv  <- 4
  tcl + tv ~ sd(2,
                0.5, 3)
}))$prior

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  tka <- 1
  tka ~ 0
})
})

## -----------------------------------------------------------------------------
a <- lotri({ tka <- 0.45; prior(tka) ~ dnorm(0, 10) })
b <- lotri({ tka <- 0.45; prior(tka) ~ normal(0, 10) })

identical(a, b)
lotriEst(a)$prior

## -----------------------------------------------------------------------------
.camel <- lotri({ e1 ~ 1; prior(e1) ~ invWishart(2) })
.stan  <- lotri({ e1 ~ 1; prior(e1) ~ inv_wishart(2) })

identical(.camel, .stan)
attr(.camel, "lotriPriors")

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tka <- 0.45
  prior(tka) ~ dnorm(sd=10, mean=0)
}))$prior

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  tka <- 0.45
  prior(tka) ~ dt(3)
})
})

## -----------------------------------------------------------------------------
lotriEst(lotri({
  tka <- 0.45
  prior(tka) ~ studentT(3, 0, 10)
}))$prior

## -----------------------------------------------------------------------------
d <- lotriPriorDists()
nrow(d)
head(d, 10)

## -----------------------------------------------------------------------------
subset(d, kind == "matrix", select=c(name, stanName, parNames))

## -----------------------------------------------------------------------------
m <- lotri({
  propSd <- c(0, 0.1)
  prior(propSd) ~ dcauchy(0, 5)
})

as.data.frame(m)[, c("name", "lower", "est", "upper", "prior")]

## ----error=TRUE---------------------------------------------------------------
try({
lotri({
  a <- c(-10, 1, 10)
  prior(a) ~ dlnorm(0, 1)
})
})

## ----error=TRUE---------------------------------------------------------------
try({
lotri({ a <- 1; prior(a) ~ dnorml(0, 1) })
})

## ----error=TRUE---------------------------------------------------------------
try({
lotri({ a <- 1; prior(a) ~ dnorm(0) })
})

## ----error=TRUE---------------------------------------------------------------
try({
lotri({ a <- 1; prior(a) ~ dnorm(mu=0, sd=1) })
})

## -----------------------------------------------------------------------------
m <- lotri({
  tka <- 0.45
  label("Ka")
  tcl <- c(0, 1, 10)

  eta.cl + eta.v ~ c(0.1,
                     0.01, 0.2)
  eta.ka ~ 0.3

  prior(tka) ~ dnorm(0, 10)
  prior(tcl) ~ dlnorm(1, 0.5)
  prior(eta.ka) ~ dgamma(2, 1)
  prior(eta.cl, eta.v) ~ lkjCorr(2)
})

as.data.frame(m)[, c("name", "est", "condition", "prior")]

## -----------------------------------------------------------------------------
as.expression(m)

## -----------------------------------------------------------------------------
identical(as.data.frame(eval(as.expression(m))), as.data.frame(m))

## -----------------------------------------------------------------------------
m <- lotri({
  a ~ 1
  b ~ c(0, 1)
  c ~ c(0.5, 0, 1)
  prior(a) ~ dgamma(1, 1)
}, rcm=TRUE)

dimnames(m)[[1]]
attr(m, "lotriPriors")

## -----------------------------------------------------------------------------
m <- lotri({
  tka <- 0.45
  prior(tka) ~ dnorm(0, 10)
})

.df <- as.data.frame(m)
.p <- .df$prior[!is.na(.df$prior)]
.p

## map the canonical name to the Stan one
.fn <- as.character(str2lang(.p)[[1]])
lotriPriorDists()$stanName[lotriPriorDists()$name == .fn]