filter_covlagh_operator: Calculate the lag-h autocovariance operator for FTS defined...

In tomasrubin/specsimfts: Spectral domain simulation methods for functional time series

Description

Numerically calculate the lag-h covariance operators for functional time series dynamics defined as a filter of a white noise. The calculation is done by numerically integrating the inverse formula, i.e. the spectral density multiplied by exp(-1i*lag*omega)

Usage

filter_covlagh_operator(
  theta,
  lag,
  n_grid,
  sigma = NULL,
  sigma_eigenvalues = NULL,
  sigma_eigenfunctions = NULL,
  n_grid_freq = 1000
)

Arguments

theta	The frequency response operator Theta(omega) of the filter used for the definition of filtered white noise. A function of two variables, omega and f, where f is a vector (discretisation of a function) on which the operator Theta at frequency omega is applied onto. See the example bellow to inspect how you can define Theta(omega). The functions rank_one_tensor and kernel_operator might be useful for the definition of Theta. Must be well defined for frequencies (0,pi]. The interval [pi,2pi) is not used and is calculated by mirroring of (0,pi].
lag	The lag of the autocovariance to evaluate.
n_grid	Number of grid points (spatial resolution) of the discretisation of [0,1]^2 for the operator kernel to evaluate.
sigma	The covariance operator of the white noise innovation. A function of two variables, x and y, returns the value of the covariance kernel evaluated at (x,y).
sigma_eigenvalues	Alternatively, you can define the white noise innovation covariance operator through its eigendecomposition, in which case supply the arguments sigma_eigenvalues and sigma_eigenfunctions but leave out sigma (or set it NULL). The eigendecomposition can be defined either as (i) a list of finite number of eigenvalues/eigenfunctions, or (ii) a function returning the eigenvalue/eigenfunction of given order. In the case (i), the sigma_eigenvalues parameter is simply a vector of eigenvalues. In the case (ii), the sigma_eigenvalues parameter is a function of the variable n which returns the n-th eigenvalue. See the example bellow for the implementation of the two cases.
sigma_eigenfunctions	See sigma_eigenvalues before. In the case (i), the sigma_eigenfunctions parameter is a list of functions with the same length as the parameter sigma_eigenvalues. Each function is a function of the variable x that returns the value of the eigenfunction at point x. The order of the functions in the list determine the order of eigenfunctions. In the case (ii), the sigma_eigenfunctions parameter is a function of two variables, n and x, that returns the value of the n-th eigenfunction at the point x.
n_grid_freq	The grid points for the spectral density to evaluate at. Partition of [0,pi].

Value

lag-h autocovariance operator, matrix of size (n_grid,n_grid)

References

Rubin, Panaretos. Simulation of stationary functional time series with given spectral density. arXiv, 2020

See Also

filter_simulate

Examples

# define the white noise covariance operator (Brownian motion)
sigma <- function(x,y) { pmin(x,y) }

# # Alternatively defined the sigma covariance through its eigendecomposition, and supply it to the function 'filter_simulate'
# sigma_eigenvalues <- function(n) { 1/((n-0.5)*pi)^2 }
# sigma_eigenfunctions <- function(n,x) { sqrt(2)*sin((n-0.5)*pi*x) }

# # Alternatively, define the innovation covariance as low-rank (through a list)
# sigma_eigenvalues <- c(1, 0.6, 0.3, 0.1, 0.1, 0.1, 0.05, 0.05, 0.05, 0.05)
# sigma_eigenfunctions <- list(
#   function(x){ sin(2*pi*x) },
#   function(x){ cos(2*pi*x) },
#   function(x){ sin(4*pi*x) },
#   function(x){ cos(4*pi*x) },
#   function(x){ sin(6*pi*x) },
#   function(x){ cos(6*pi*x) },
#   function(x){ sin(8*pi*x) },
#   function(x){ cos(8*pi*x) },
#   function(x){ sin(10*pi*x) },
#   function(x){ cos(10*pi*x) }
# )

# define filter
theta <- function(omega,f){
2*f+
 1i*rev(f) +
 omega*cumsum(f)/length(f) +
 rank_one_tensor( function(x){sin(x)}, function(x){exp(x)}, f ) +
 kernel_operator( function(x,y){sin(omega+x+2*y)}, f )
}

# simulation setting
t_max <- 1000
n_grid <- 101

# evaluation setting
lag <- 1 # change here to evaluate different lag-h autocovariance operator. put "lag <- 0" for lag-0 covariance operator
n_grid <- 101

# numerically evaluate lag-h autocovariance operator - WARNING: this takes a minute or so
lag <- 0
covlagh <- filter_covlagh_operator(theta, lag, n_grid, sigma=sigma)

# # Alternatively simulate with the known eigendecomposition of sigma
# covlagh <- filter_covlagh_operator(theta, lag, n_grid, sigma_eigenfunctions = sigma_eigenfunctions, sigma_eigenvalues=sigma_eigenvalues)

# visualise as a surface plot
persp(covlagh)

tomasrubin/specsimfts documentation built on March 26, 2021, 1:37 p.m.