Olivier Supplisson

Daily joint prediction of CAC40 opening and closing levels

Olivier Supplisson — Sun, 12 Apr 2026 00:00:00 GMT

This application studies a joint forecasting problem for the CAC 40 opening and closing levels. Rather than treating the intraday move as a single response, the specification uses two linked observation equations: one for the opening level and one for the closing level. The link is simple: the opening equation is anchored by the previous close, and the closing equation is anchored by the same-day open.

The aim is to build a model able to maintain a probabilistic view of both levels during the day, quantify uncertainty, and update the implied distribution of the close once the opening level is known.

Data

The code below downloads daily CAC 40 opening and closing data from Yahoo Finance under the ticker ^FCHI and starts the analysis on January 1, 2000.

library(tidyverse)
date_start <- as.Date("2000-01-01")
date_end <- as.Date("2026-04-14")
forecast_start <- as.Date("2026-03-01")
forecast_end <- as.Date("2026-04-14")

time_index <- tibble(date = seq(from = date_start, to = date_end, by = "1 day")) |> 
  mutate(time_id = row_number() + 1)

cac40_xts <- quantmod::getSymbols(
  Symbols = "^FCHI",
  src = "yahoo",
  from = as.Date("1999-01-01"),
  to = date_end,
  auto.assign = FALSE
)

cac40 <- data.frame(
  date = zoo::index(cac40_xts),
  open = as.numeric(quantmod::Op(cac40_xts)),
  close = as.numeric(quantmod::Cl(cac40_xts))
)


cac40 <- cac40 |>
  filter(!is.na(open) & !is.na(close))  |> 
  mutate(intercept = 1) |> 
  mutate(close_lag = lag(close)) |> 
  filter(date >= date_start) |> 
  left_join(time_index, by = "date")

The observed series contains 6715 trading days, from 2000-01-03 to 2026-04-13.

The forecasting exercise below uses the trading days from 2026-03-01 to 2026-04-14 as a rolling one-step-ahead evaluation window. For each trading day in that range, the model is refit using only the data available up to the previous trading day.

The opening and closing levels are shown below.

plot_df <- rbind(
  data.frame(date = cac40$date, series = "Open", value = cac40$open),
  data.frame(date = cac40$date, series = "Close", value = cac40$close)
)

ggplot2::ggplot(plot_df, ggplot2::aes(x = date, y = value, colour = series)) +
  ggplot2::geom_line(linewidth = 0.55) +
  ggplot2::scale_colour_manual(values = c("Open" = "#6baed6", "Close" = "#08519c")) +
  ggplot2::labs(
    x = "Date",
    y = "CAC 40 level",
    title = "Daily CAC 40 opening and closing levels",
    colour = NULL
  ) +
  ggplot2::theme_minimal()

The two series move together over the long run, but the gap between them still changes enough from day to day to justify modeling the opening and closing levels separately.

Model

Let and denote the CAC 40 opening and closing levels on trading day . Since both quantities are strictly positive, the observational layer uses the lognormal likelihood entry from the R-INLA documentation.

Conditional on latent predictors and , the observation model is

The corresponding linear predictors are

where the notation mirrors the code through CloseLag, Open, InterceptOpen, InterceptClose, betaOpen, and betaClose. The previous close enters the opening equation as an offset, while the same-day open enters the closing equation as an offset. The latent terms and are modeled separately, so the dependence between the two equations comes from this sequential conditioning structure rather than from a shared latent field.

Here, I am using a PRW2 latent effect but other approaches could be used with likely little to no change, as highlighted in this methodological post on P-splines in R-INLA. I’ll fit the corresponding model inlabru.

The code below defines the latent components:

Fit

The remaining piece is the observation model. For the lognormal likelihood, the INLA implementation uses an identity link on the log scale together with a precision hyperparameter. In the current code, the opening and closing equations are written as two separate bru_obs() objects. Both equations receive the same PC prior on the observation precision.

prior_prec_likelihood <- list(
  prior = "pc.prec",
  param = c(1, 0.01)
)


likopen <- bru_obs(
  open ~ log(CloseLag)  + InterceptOpen + betaOpen,
  family = "lognormal",
  data = cac40,
  control.family = list(
    link = "identity",
    hyper = list(prec = prior_prec_likelihood)
  )
)

likclose <- bru_obs(
  close ~  log(Open) + InterceptClose + betaClose,
  family = "lognormal",
  data = cac40,
  control.family = list(
    link = "identity",
    hyper = list(prec = prior_prec_likelihood)
  )
)

This is where the two-equation formulation is assembled: likopen and likclose are fitted together in a single bru() call against the same component object cmp.

The fit below keeps the configuration output needed later for posterior simulation, predictive checks, and rolling forecasts.

In-sample posterior predictive check

As a first sanity check, a simple posterior predictive assessment can be carried out. The approach use a shenanigan hidden in this post on the R-INLA discussion forum.

The first step of this magical trick is to draw samples from the joint posterior distribution of the latent state.

ndraws <- 1000
state <- evaluate_state(
result = fit,
property = "sample",
n = ndraws,
seed = 0L
)

Once these draws are available, they can be combined to rebuild any predictor of interest. Here, the posterior predictive check is performed on the same data set that was used for estimation.

predictor_observed <- evaluate_model(
model = fit$bru_info$model,
result = fit,
state = state,
data = cac40,
predictor = ~data.frame(predictor_close = InterceptClose + betaClose,
                       predictor_open = InterceptOpen + betaOpen,
                       Precision_for_open = Precision_for_the_lognormal_observations,
                       Precision_for_close = Precision_for_the_lognormal_observations_2_)
)

predictor_observed <- purrr::map2_dfr(
  predictor_observed,
  seq_along(predictor_observed),
  ~cbind(.x, cac40) %>% mutate(draw_id = .y)
) %>% 
  dplyr::mutate(
    predicted_open = stats::rlnorm(
      dplyr::n(),
      meanlog = log(close_lag) + predictor_open,
      sdlog = 1 / sqrt(Precision_for_open)
    ),
    predicted_close = stats::rlnorm(
      dplyr::n(),
      meanlog = log(open) + predictor_close,
      sdlog = 1 / sqrt(Precision_for_close)
    )
  ) |> 
  group_by(date) |> 
  summarise(
    mean_predicted_open = mean(predicted_open),
    mean_predicted_close = mean(predicted_close),
    q0.025_predicted_open = quantile(predicted_open, 0.025),
    q0.025_predicted_close = quantile(predicted_close, 0.025),
    q0.975_predicted_open = quantile(predicted_open, 0.975),
    q0.975_predicted_close = quantile(predicted_close, 0.975)
  ) |> 
  left_join(cac40, by = "date")

The figure below compares the observed and replicated series over the 2026 segment.

fun_to_plot_date <- function(str_date_start,
                             str_date_end){
  plot <- predictor_observed |> 
    filter(date >= as.Date(str_date_start),
           date <= as.Date(str_date_end)) |> 
    pivot_longer(cols = c(open,
                          close,
                          mean_predicted_open,
                          mean_predicted_close,
                          q0.025_predicted_open,
                          q0.025_predicted_close,
                          q0.975_predicted_open,
                          q0.975_predicted_close)) |> 
    mutate(facet = case_when(
      str_detect(name, "open") ~ "Open",
      str_detect(name, "close") ~ "Close"
    ),
    type = case_when(
      name %in% c("open", 
                  "close") ~ "Observed",
      name %in% c("q0.025_predicted_open",
                  "q0.025_predicted_close",
                  "q0.975_predicted_open",
                  "q0.975_predicted_close",
                  "mean_predicted_open", 
                  "mean_predicted_close") ~ "Simulated"
    ),
    label_legend = case_when(
      name == "open" ~ "Open",
      name == "close" ~ "Close",
      name == "q0.025_predicted_open" ~ "LB ETI95%",
      name == "q0.025_predicted_close" ~ "LB ETI95%",
      name == "q0.975_predicted_open" ~ "UB ETI95%",
      name == "q0.975_predicted_close" ~ "UB ETI95%",
      name == "mean_predicted_open" ~ "Average", 
     name ==  "mean_predicted_close" ~ "Average"
    )) |> 
      ggplot() + 
      geom_line(aes(x = date, 
                    y = value, 
                    color = label_legend, 
                    linetype = type)) + 
        facet_wrap(~facet, nrow = 2)+
    labs(
      x = "Date",
      y = "Index",
      color = "Series: ",
      linetype = "Type of series: "
    ) +
    theme_minimal()+
    theme(legend.position="bottom")
  
  #Never said this blog was for cood coding practice ;-)
  d <- plot$data |> select(-type, -label_legend, -facet) |> pivot_wider(names_from = name, values_from = value)
  pct_open <- round(100 * mean(with(d, open < q0.025_predicted_open | open > q0.975_predicted_open)), 2)
  pct_close <- round(100 * mean(with(d, close < q0.025_predicted_close | close > q0.975_predicted_close)), 2)
  return(list("plot" = plot,
         "pct_open" = pct_open,
         "pct_close" = pct_close))

}

#From "2026-01-01" to "2026-04-14"
p <- fun_to_plot_date("2026-01-01", date_end)
p["plot"]

$plot

The plot shows that the posterior means can miss individual days, but the interval bands are the more relevant object here because the application is about sequential uncertainty quantification rather than about a single determin

istic path. The observed value is almost always within this uncertainty band. More specifically, only the proportion of values observed outside the ETI95% were equal to `1.43`% and `0`%, for the open and close serie, respectively. Across the full period these % were 1.77% and 2.49%.

Not bad! However, an in-sample check only tells us whether the fitted model can reproduce the training data. The more relevant exercise is a one-step-ahead forecasting problem.

Out-of-sample day-ahead forecast

In this section, I keep the same state-based workflow as above, but instead of simulating one long path over the whole hold-out period, I refit the model day by day. For each trading day in the evaluation window, both open and close are hidden, the model is rerun using only the earlier observations, and I simulate the same-day opening and closing levels. The opening draw uses the observed lagged close from the previous trading day, while the closing draw uses the simulated opening level from the same posterior draw.

This mirrors the situation where a trader would perform its prediction at end of time for planning its action in time based on the predictive distribution of CAC40 index opening and closing level.

This produces one predictive distribution per day in the hold-out window, which can then be compared with the realised opening and closing levels over the evaluation period.

periodic_forecast |>
  pivot_longer(cols = c(open,
                        close,
                        mean_predicted_open,
                        mean_predicted_close,
                        q0.025_predicted_open,
                        q0.025_predicted_close,
                        q0.975_predicted_open,
                        q0.975_predicted_close)) |>
  mutate(
    facet = case_when(
      str_detect(name, "open") ~ "Open",
      str_detect(name, "close") ~ "Close"
    ),
    type = case_when(
      name %in% c("open", "close") ~ "Observed",
      TRUE ~ "Simulated"
    ),
    label_legend = case_when(
      name == "open" ~ "Open",
      name == "close" ~ "Close",
      name == "q0.025_predicted_open" ~ "LB ETI95%",
      name == "q0.025_predicted_close" ~ "LB ETI95%",
      name == "q0.975_predicted_open" ~ "UB ETI95%",
      name == "q0.975_predicted_close" ~ "UB ETI95%",
      name == "mean_predicted_open" ~ "Average",
      name == "mean_predicted_close" ~ "Average"
    )
  ) |>
  ggplot() +
  geom_line(aes(
    x = date,
    y = value,
    color = label_legend,
    linetype = type
  ))  +
  geom_point(aes(
    x = date,
    y = value,
    color = label_legend
  ), size = 1) +
  facet_wrap(~facet, nrow = 2) +
  labs(
    x = "Date",
    y = "Index",
    color = "Series: ",
    linetype = "Type of series: "
  ) +
  theme_minimal() +
  theme(legend.position = "bottom")

As expected, more observed values are falling outside of the uncertainty interval. More specifically, 24.14% of the observed opening values and 6.9% of the observed closing values fall outside the ETI95% over the hold-out window. Considering a larger uncertainty band, such as the ETI99%, would help decreasing these percentages.

Censored binomial likelihood in R-INLA

Olivier Supplisson — Sun, 12 Apr 2026 00:00:00 GMT

Download cloglike-censored-binomial.c

R-INLA provides a wide range of built-in likelihoods, documented on the project likelihood page. Since INLA 25.08.21, an experimental interface also allows users to implement custom likelihoods. In this post, I use that feature to define a censored binomial likelihood. Notice that censored likelihood are already available for the Poisson and Negative Binomial distribution.

This likelihood is useful when counts are deliberately masked for disclosure control. A common situation is left censoring at a fixed threshold: if the true count is small, the released dataset does not report the exact value and only indicates that it lies below the threshold. For example, some public spatially-indexed health datasets in France suppress counts at or below 10.

Binomial and Censored binomial likelihood

Let denote the number of successes in a sample of size . A natural model is the binomial distribution

where is the success probability. The corresponding probability mass function is

In regression settings, it is standard to connect to a linear predictor through the logit link

Now suppose that counts are left censored at a threshold . We no longer observe exactly for small values. Instead, we observe

The observed-data likelihood therefore has two contributions.

For an uncensored observation, with reported count ,

For a censored observation,

So the censored binomial likelihood is just the usual binomial likelihood for uncensored observations, and the binomial cumulative distribution function for censored observations.

For implementation in INLA it is convenient to write the contribution on the log scale, as this is required by the cloglike interface.

For an uncensored observation with reported count ,

For a censored observation,

In practice, the censored term should be evaluated through the binomial CDF rather than by summing probabilities manually. In R, this corresponds to pbinom(c, size = N, prob = plogis(eta), log.p = TRUE), while the uncensored term is dbinom(z, size = N, prob = plogis(eta), log = TRUE).

Simulation study: why do we have to account for this censoring?

The code above fit a binomial model for the specific case where , , and . The censoring threshold is set to 5. For the fit, a uniform prior on is set.

set.seed(1)
#Packages
library(INLA)
library(inlabru)

#Simulation setup
prob = 0.3
nsample = 10000
N = rpois(n = nsample, lambda = 20)
censoring_threshold <- 5
Y = rbinom(n = nsample, size = N, prob = prob)
censored <- as.integer(Y <= censoring_threshold)
Z = Y
Z[censored == 1L] <- censoring_threshold

#Bru components
comp <- ~ p(
  1,
  mean.linear = 0,
  prec.linear = 1,
  marginal = bm_marginal(qbeta, pbeta, dbeta, shape1 = 1, shape2 = 1)
)

#Uncensored fit
likelihood_uncensored <- bru_obs(
  formula = Y ~ 0 + qlogis(p),
  family = "binomial",
  data = data.frame(Y,N),
  Ntrials = N,
  control.family = list(link = "logit")
)

fit_uncensored <- bru(comp, 
                      likelihood=likelihood_uncensored, 
                      options = list(verbose = FALSE,
                                     bru_verbose = 0
                                     )
                      )

#Censored fit
likelihood_censored <- bru_obs(
  formula = Z ~ 0 + qlogis(p),
  family = "binomial",
  data = data.frame(Z,N),
  Ntrials = N,
  control.family = list(link = "logit")
)

fit_censored <- bru(comp, 
                      likelihood=likelihood_censored, 
                      options = list(verbose = FALSE,
                                     bru_verbose = 0
                                     )
                      )

#Compute the posterior mean and ETI95% of p
draws_uncensored <- predict(fit_uncensored, 100, ~data.frame(p=p))
draws_censored <- predict(fit_censored, 100, ~data.frame(p=p))

fmt2 <- function(x) sub("\\.", ",", sprintf("%.4f", x))

result_uncensored <- paste0(
  fmt2(draws_uncensored$mean), " [",
  fmt2(draws_uncensored$q0.025), ", ",
  fmt2(draws_uncensored$q0.975), "]"
)

result_censored <- paste0(
  fmt2(draws_censored$mean), " [",
  fmt2(draws_censored$q0.025), ", ",
  fmt2(draws_censored$q0.975), "]"
)

The mean [ETI95%] found is 0,3007 [0,2985, 0,3024] for the uncensored fit and 0,3263 [0,3243, 0,3282] for the censored one, showing that not accounting for the censoring will induce an upward inflation in the inferred parameter.

Censored binomial implementation

The cloglike-censored-binomial.c file, downloadable at the start of this post, implements the censored binomial likelihood. Let us give it a try with the previous setpup.

The cloglike fit needs a matrix-valued response passed through data=, with a response name that matches the left-hand side of the formula, as examplified below.

#Look at the rgeneric vignette for the process
cloglike <- inla.cloglike.define(model = "inla_cloglike_censored_binomial", shlib = shlib)

#INLA response
Y_cens <- INLA::inla.mdata(cbind(Z, N, censored))

#Bru likelihood
likelihood_censored_new <- bru_obs(
  formula = Y_cens ~ 0 + qlogis(p),
  family = "cloglike",
  data = list(
    Y_cens = Y_cens
  ),
  control.family = list(cloglike = cloglike),
  is_rowwise = FALSE
)

#Fit
fit_censored_new <- bru(
  comp,
  likelihood = likelihood_censored_new,
  options = list(
    verbose = F,
    bru_verbose = 0
  )
)

#Posterior draws
draws_censored_new <- predict(fit_censored_new, 100, ~data.frame(p=p))

#Summary
result_censored_new <- paste0(
  fmt2(draws_censored_new$mean), " [",
  fmt2(draws_censored_new$q0.025), ", ",
  fmt2(draws_censored_new$q0.975), "]"
)

With this likelihood implementation, the correct parameter is recovered, as the posterior mean [ETI95%] is 0,3006 [0,2990, 0,3026].

Univariate P-splines in R-INLA and inlabru

Olivier Supplisson — Sun, 12 Apr 2026 00:00:00 GMT

P-splines combine a flexible B-spline basis with a roughness penalty on the coefficients. Their main practical objective is to make model specification more robust to the number and locations of the knots used to define the basis. In a Bayesian setting, that penalty is naturally represented by an n-th-order random walk prior on the spline weights. This short blog post shows how to fit a smoothing P-spline in R-INLA.

Useful academic work on P-splines include:

Paul Eilers and Brian Marx’s original article introducing P-splines, Flexible Smoothing with B-splines and Penalties, https://projecteuclid.org/journals/statistical-science/volume-11/issue-2/Flexible-smoothing-with-B-splines-and-penalties/10.1214/ss/1038425655.pdf.
Paul Eilers and Brian Marx’s masterpiece Practical Smoothing: The Joys of P-splines, https://psplines.bitbucket.io/.
Stefan Lang and Andreas Brezger’s Bayesian P-splines paper, https://www.tandfonline.com/doi/abs/10.1198/1061860043010.
Aritz Adin Urtasun’s Ph.D. thesis Hierarchical and spline-based models in space-time disease mapping. I could not find the original link, so I uploaded the file to my personal Google Drive here.
Dae-Jin Lee’s Ph.D. thesis Smoothing mixed models for spatial and spatio-temporal data, https://e-archivo.uc3m.es/entities/publication/72bffb09-ff83-48eb-acba-8aaed8de45f4.

B-spline basis

For a scalar covariate , a P-spline smooth approximates the unknown function through a finite-dimensional decomposition:

where are spline basis functions defined over the full domain of . The basis itself is determined by two ingredients: a polynomial degree and a knot sequence. The knots split the covariate range into intervals, and on each interval every is an ordinary polynomial. In practice one often uses cubic B-splines, that is, splines of degree 3, because they are flexible while remaining smooth enough for most regression problems.

A central property of B-splines is local support. Each is zero outside a limited portion of the covariate range, so at a fixed location only a few basis functions are active. For splines of degree , at most basis functions are nonzero at the same . This is what makes the basis local: changing one coefficient mainly perturbs the fitted curve near the associated knot region instead of changing the function everywhere.

Another useful property is that the basis functions form a partition of unity, meaning

This makes the spline behave like a local weighted average of the coefficients. It also clarifies why one has to think about identifiability: if the basis can already represent constant functions, then the intercept and the spline part are not automatically separated unless one imposes a constraint or centers the smooth.

The coefficients control the contribution of each basis function. For observations , the basis enters the model through the design matrix

Row shows how the basis combines to represent the smooth at , and column shows where coefficient contributes. Because of local support, this matrix is typically sparse or at least strongly banded in structure, which is one of the reasons B-splines are computationally attractive.

However, the fit quality of B-splines has been shown to be highly sensitive to the number and locations of the knots used to define the basis, leading to poor representation when too few knots are used and to overfitting when too many are used.

P-splines provide a fallback solution to this issue: instead of leaving the parameters unconstrained, they penalise their finite differences so that neighbouring coefficients are encouraged to vary smoothly. With the standard second-order penalty, the second differences satisfy

Large values of shrink the second differences more strongly and therefore produce smoother functions, while smaller values allow more local curvature. The role of the P-spline is therefore split into two parts: the B-spline basis provides a rich approximation space, and the RW2 penalty regularises that space so that the fitted curve remains smooth.

Although it is possible to construct P-splines in several ways, I keep the rest of this post close to plain R-INLA so the basis construction and the RW2 penalty remain explicit.

Data import

To keep the discussion concrete, I will work with daily closing values of the CAC 40 index. On Yahoo Finance, the CAC 40 index is available under the ticker ^FCHI.

For the purpose of this blog post, I will use

Basis construction

For illustrative purposes, I will model the closing series y as a smooth function of the trading-day index x. With (n = 1608), the B-spline basis is built as follows. To reduce boundary effects, I extend the covariate range slightly and construct the basis on the augmented grid from -5 to n + 5, then evaluate it back on the observed index.

k <- 80L
B_aug <- seq(-5, max(x) + 5, by = 1)
B_basis <- bs(
  x,
  df = k,
  degree = 3,
  intercept = FALSE,
  Boundary.knots = range(B_aug)
)
B <- unclass(B_basis)
A_ps <- Matrix(B, sparse = TRUE)

Here B is the B-spline design matrix evaluated at the observed covariate values. The argument k controls the basis dimension and therefore the richness of the spline representation. The extended boundary knots help stabilise the fitted spline near the endpoints. With the chosen degree, this induces the following internal knot locations:

print(attr(B_basis, "knots"))

 [1]   21.60256   42.20513   62.80769   83.41026  104.01282  124.61538
 [7]  145.21795  165.82051  186.42308  207.02564  227.62821  248.23077
[13]  268.83333  289.43590  310.03846  330.64103  351.24359  371.84615
[19]  392.44872  413.05128  433.65385  454.25641  474.85897  495.46154
[25]  516.06410  536.66667  557.26923  577.87179  598.47436  619.07692
[31]  639.67949  660.28205  680.88462  701.48718  722.08974  742.69231
[37]  763.29487  783.89744  804.50000  825.10256  845.70513  866.30769
[43]  886.91026  907.51282  928.11538  948.71795  969.32051  989.92308
[49] 1010.52564 1031.12821 1051.73077 1072.33333 1092.93590 1113.53846
[55] 1134.14103 1154.74359 1175.34615 1195.94872 1216.55128 1237.15385
[61] 1257.75641 1278.35897 1298.96154 1319.56410 1340.16667 1360.76923
[67] 1381.37179 1401.97436 1422.57692 1443.17949 1463.78205 1484.38462
[73] 1504.98718 1525.58974 1546.19231 1566.79487 1587.39744

The resulting basis functions along the covariate index are shown below.

basis_df <- data.frame(
  x = rep(x, times = ncol(B)),
  basis = factor(rep(seq_len(ncol(B)), each = nrow(B))),
  value = c(B)
)

knot_df <- data.frame(knot = unname(attr(B_basis, "knots")))

ggplot(basis_df, aes(x = x, y = value, group = basis, color = basis)) +
  geom_line(linewidth = 0.35, show.legend = FALSE) +
  geom_vline(
    data = knot_df,
    aes(xintercept = knot),
    inherit.aes = FALSE,
    colour = "grey45",
    linetype = 3
  ) +
  scale_color_manual(values = grDevices::hcl.colors(ncol(B), palette = "Dynamic")) +
  labs(
    x = "Trading-day index",
    y = "Basis value",
    title = "B-spline basis along x"
  ) +
  theme_minimal()

The same object can also be viewed directly as a matrix. This makes the local support of the basis especially visible: each column is active only over a limited range of rows, which gives the design matrix its banded structure.

B_long <- data.frame(
  row = rep(seq_len(nrow(B)), times = ncol(B)),
  basis = rep(seq_len(ncol(B)), each = nrow(B)),
  value = c(B)
)

ggplot(B_long, aes(x = row, y = basis, fill = value)) +
  geom_raster() +
  geom_vline(
    data = knot_df,
    aes(xintercept = knot),
    inherit.aes = FALSE,
    colour = "grey45",
    linetype = 3
  ) +
  scale_fill_gradientn(colors = grDevices::hcl.colors(64, palette = "YlOrRd", rev = TRUE)) +
  labs(
    x = "Trading-day index",
    y = "Basis index",
    fill = "Value",
    title = "B-spline design matrix B"
  ) +
  theme_minimal()

RW precision structure

Usual choices for P-splines are RW(1) and RW(2) precision structures. They enforce smoothness while keeping the precision matrix sparse, which is one of the main computational advantages of these priors. If denotes the spline coefficient vector, the first- and second-order difference operators are

The associated intrinsic precision matrices are then

In R, these objects can be derived directly from sparse finite-difference matrices:

n_basis <- ncol(B)
I_k <- Diagonal(n_basis)

D_rw1 <- diff(I_k, differences = 1)
D_rw2 <- diff(I_k, differences = 2)

Q_rw1 <- crossprod(D_rw1)
Q_rw2 <- crossprod(D_rw2)

print(as.matrix(Q_rw1[1:8, 1:8]))

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    1   -1    0    0    0    0    0    0
[2,]   -1    2   -1    0    0    0    0    0
[3,]    0   -1    2   -1    0    0    0    0
[4,]    0    0   -1    2   -1    0    0    0
[5,]    0    0    0   -1    2   -1    0    0
[6,]    0    0    0    0   -1    2   -1    0
[7,]    0    0    0    0    0   -1    2   -1
[8,]    0    0    0    0    0    0   -1    2

print(as.matrix(Q_rw2[1:8, 1:8]))

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    1   -2    1    0    0    0    0    0
[2,]   -2    5   -4    1    0    0    0    0
[3,]    1   -4    6   -4    1    0    0    0
[4,]    0    1   -4    6   -4    1    0    0
[5,]    0    0    1   -4    6   -4    1    0
[6,]    0    0    0    1   -4    6   -4    1
[7,]    0    0    0    0    1   -4    6   -4
[8,]    0    0    0    0    0    1   -4    6

The RW1 precision penalizes successive differences in the coefficients, while the RW2 precision penalizes local curvature through second differences. Both matrices are sparse. RW1 has constant vectors in its null space, whereas RW2 has both constant and linear vectors in its null space, which is why additional constraints or an explicit intercept are usually required for identifiability.

R-INLA model component

In matrix form, the spline contribution can be written as . The previous construction makes explicit the precision matrix associated with the prior on :

Here denotes the generalised inverse of , with the precision hyperparameter, equal to , where is the standard deviation. Such custom latent components can be specified in R-INLA using the Generic0 latent component, described here.

Fit with inlabru

The generic0 latent model takes a structure matrix Cmatrix and internally uses the precision form . Here we simply supply Q_rw2 as the structure matrix. On the inlabru side, bm_matrix(n_basis) tells the component system to interpret the matrix-valued input as a direct matrix multiplication between the supplied basis matrix and the latent state vector. Since CAC 40 closing values are strictly positive, I use a Gamma likelihood instead of a Gaussian one. INLA’s Gamma likelihood uses a default log-link for the mean, so the spline acts on the log-mean scale. For the precision hyperparameter, I use a PC prior of the form , implemented in INLA through prior = "pc.prec".

To learn more about PC-priors, see:

Daniel Simpson, Håvard Rue, Andrea Riebler, Thiago G. Martins, Sigrunn H. Sørbye, Penalising Model Component Complexity: A Principled, Practical Approach to Constructing Priors, DOI: 10.1214/16-STS576
Daniel Simpson’s blog post: https://dansblog.netlify.app/#category=PC%20priors

pc_prec <- list(
  prior = "pc.prec",
  param = c(5, 0.01)
)

cmp_ps_generic0 <- ~
  Intercept(1,
            prec.linear = 5,
            mean.linear = 0) +
  pspline(
    B,
    model = "generic0",
    mapper = bm_matrix(n_basis),
    Cmatrix = Q_rw2,
    rankdef = 2,
    constr = TRUE,
    diagonal = 1e-06,
    hyper = list(prec = pc_prec)
  )

lik_ps_generic0 <- bru_obs(
  y ~ Intercept + pspline,
  family = "gamma",
  data = data.frame(y = y)
)

fit_ps_generic0_bru <- bru(
  cmp_ps_generic0,
  lik_ps_generic0
)

The arguments rankdef = 2 and constr = TRUE reflect the intrinsic rank deficiency of the RW2 precision matrix. The small diagonal inflation is a standard numerical stabilisation for intrinsic models represented through generic0. The PC prior above is interpreted as .

Posterior predictive check

Let us perform a simple posterior predictive check by comparing the observed series with the posterior fitted band on the response scale.

obs_idx <- seq_len(length(y))
fitted_obs <- fit_ps_generic0_bru$summary.fitted.values[obs_idx, , drop = FALSE]

ppc_df <- data.frame(
  x = x,
  y = y,
  fitted_mean = fitted_obs$mean,
  fitted_q025 = fitted_obs$`0.025quant`,
  fitted_q975 = fitted_obs$`0.975quant`
)

ggplot(ppc_df, aes(x = x)) +
  geom_ribbon(
    aes(
      ymin = fitted_q025,
      ymax = fitted_q975,
      fill = "95% credible band"
    ),
    alpha = 0.35
  ) +
  geom_line(
    aes(y = fitted_mean, colour = "Posterior mean", linetype = "Posterior mean"),
    linewidth = 0.7
  ) +
  geom_line(
    aes(y = fitted_q025, colour = "Lower 95% bound", linetype = "Lower 95% bound"),
    linewidth = 0.5
  ) +
  geom_line(
    aes(y = fitted_q975, colour = "Upper 95% bound", linetype = "Upper 95% bound"),
    linewidth = 0.5
  ) +
  geom_line(
    aes(y = y, colour = "Observed", linetype = "Observed"),
    linewidth = 0.35,
    alpha = 0.75
  ) +
  scale_colour_manual(
    name = NULL,
    values = c(
      "Observed" = "black",
      "Posterior mean" = "#08519c",
      "Lower 95% bound" = "#3182bd",
      "Upper 95% bound" = "#3182bd"
    ),
    breaks = c("Observed", "Posterior mean", "Lower 95% bound", "Upper 95% bound")
  ) +
  scale_linetype_manual(
    name = NULL,
    values = c(
      "Observed" = "solid",
      "Posterior mean" = "solid",
      "Lower 95% bound" = "dashed",
      "Upper 95% bound" = "dotdash"
    ),
    breaks = c("Observed", "Posterior mean", "Lower 95% bound", "Upper 95% bound")
  ) +
  scale_fill_manual(
    name = NULL,
    values = c("95% credible band" = "#9ecae1")
  ) +
  guides(
    colour = guide_legend(order = 1),
    linetype = guide_legend(order = 1),
    fill = guide_legend(
      order = 2,
      override.aes = list(alpha = 0.35)
    )
  ) +
  labs(
    x = "Trading-day index",
    y = "CAC 40 close",
    title = "Observed values and posterior fitted band"
  ) +
  theme_minimal() +
  theme(
    legend.position = "bottom",
    legend.box = "vertical"
  )

Other competing possibilities within R-INLA: RW2, PRW2, and SPDE

R-INLA offers a wide range of latent effects related to the P-spline construction presented above for temporal modelling. Below I briefly highlight three possibilities:

RW2 latent effect, which differs from the previous P-spline construction in that there is no spline basis (see https://inla.r-inla-download.org/r-inla.org/doc/latent/rw2.pdf);
PRW2, which is the non-intrinsic version of the RW2 latent effect (see https://inla.r-inla-download.org/r-inla.org/doc/latent/prw2.pdf);
Gaussian process implemented using the finite element representation presented in Finn Lindgren, Håvard Rue, Johan Lindström 2011 article An explicit link between Gaussian fields and Gaussian Markov random fields: the stochastic partial differential equation approach, https://doi.org/10.1111/j.1467-9868.2011.00777.x

Other latent effects, such as AR(1), AR(p), or Fractional Gaussian Noise are also available, see https://inla.r-inla-download.org/r-inla.org/doc/latent/.

#Case 1: direct RW2 latent effect
cmp_ps_rw2 <- ~
  Intercept(1,
            prec.linear = 5,
            mean.linear = 0) +
  rw2(
    x,
    model = "rw2",
    rankdef = 2,
    constr = TRUE,
    diagonal = 1e-06,
    hyper = list(prec = pc_prec)
  )
lik_rw2 <- bru_obs(
  y ~ Intercept + rw2,
  family = "gamma",
  data = data.frame(y = y, x = x)
)
fit_ps_rw2_bru <- bru(
  cmp_ps_rw2,
  lik_rw2
)
#Case 2: PRW2 latent effect
pc_prw2_range <- list(
  prior = "pc.prw2.range",
  param = c(25, 0.01, 1, 0.01)
)
cmp_ps_prw2 <- ~
  Intercept(1,
            prec.linear = 5,
            mean.linear = 0) +
  prw2(
    x,
    model = "prw2",
    diagonal = 1e-06,
    hyper = list(
      prec = pc_prec,
      range = pc_prw2_range
    )
  )
lik_prw2 <- bru_obs(
  y ~ Intercept + prw2,
  family = "gamma",
  data = data.frame(y = y, x = x)
)
fit_ps_prw2_bru <- bru(
  cmp_ps_prw2,
  lik_prw2
)
#Case 3: Gaussian process
mesh1d <- fmesher::fm_mesh_1d(
  seq(min(x) - 5, max(x) + 5, length.out = 80),
  boundary = "free"
)
matern_1d <- INLA::inla.spde2.pcmatern(
  mesh1d,
  prior.range = c(25, 0.01),
  prior.sigma = c(5, 0.01),
  constr = TRUE
)
cmp_ps_gp <- ~
  Intercept(1,
            prec.linear = 5,
            mean.linear = 0) +
  gp(
    x,
    model = matern_1d
  )
lik_gp <- bru_obs(
  y ~ Intercept + gp,
  family = "gamma",
  data = data.frame(y = y, x = x),
  domain = list(x = mesh1d)
)
fit_ps_gp_bru <- bru(
  cmp_ps_gp,
  lik_gp
)

The posterior mean fitted values from the four approaches can be compared directly on the response scale.

obs_idx <- seq_len(length(y))

extract_obs_mean <- function(fit) {
  fit$summary.fitted.values[obs_idx, "mean"]
}

fit_compare_df <- data.frame(
  x = x,
  Observed = y,
  Generic0 = extract_obs_mean(fit_ps_generic0_bru),
  RW2 = extract_obs_mean(fit_ps_rw2_bru),
  PRW2 = extract_obs_mean(fit_ps_prw2_bru),
  GP = extract_obs_mean(fit_ps_gp_bru)
)

fit_compare_long <- rbind(
  data.frame(x = x, series = "Observed", value = fit_compare_df$Observed),
  data.frame(x = x, series = "Generic0", value = fit_compare_df$Generic0),
  data.frame(x = x, series = "RW2", value = fit_compare_df$RW2),
  data.frame(x = x, series = "PRW2", value = fit_compare_df$PRW2),
  data.frame(x = x, series = "Gaussian process", value = fit_compare_df$GP)
)

ggplot(fit_compare_long, aes(x = x, y = value, colour = series, linetype = series, alpha = series)) +
  geom_line(linewidth = 1) +
  scale_colour_manual(
    values = c(
      "Observed" = "black",
      "Generic0" = "#08519c",
      "RW2" = "#2ca25f",
      "PRW2" = "#cb181d",
      "Gaussian process" = "#756bb1"
    )
  ) +
  scale_linetype_manual(
    values = c(
      "Observed" = "solid",
      "Generic0" = "solid",
      "RW2" = "longdash",
      "PRW2" = "dotdash",
      "Gaussian process" = "twodash"
    )
  ) +
  scale_alpha_manual(
    values = c(
      "Observed" = 0.7,
      "Generic0" = 1,
      "RW2" = 1,
      "PRW2" = 1,
      "Gaussian process" = 1
    )
  ) +
  labs(
    x = "Trading-day index",
    y = "CAC 40 close",
    colour = NULL,
    linetype = NULL,
    title = "Posterior mean comparison across four latent-effect choices"
  ) +
  theme_minimal() +
  theme(
    legend.position = "bottom",
    legend.box = "vertical"
  ) +
  guides(alpha = "none")

The negligible differences can be explained primarily by how each effect approximates the continuous target function. The usual P-spline uses 80 basis functions to define the approximation, much like the SPDE approximation of the Gaussian process, which relies on a mesh with a comparable resolution. By contrast, the RW2 and PRW2 effects use one latent value for each trading-day index.

Welcome!

Olivier Supplisson — Sun, 12 Apr 2026 00:00:00 GMT

Welcome to my brand-new blog. If you would like to know more about my academic and professional background, you can visit my LinkedIn or read my CV. I hope you will find the posts useful.

You can reach out directly on LinkedIn or by email at osupplis@gmail.com.