vector<double> autocorrelation(const vector<double>& x,unsigned N)
{
vector<double> rho = autocovariance(x,N);
const double V = rho[0];
for(int i=0;i<rho.size();i++)
rho[i] /= V;
return rho;
}
double autocorrelation(double* series, unsigned int size, unsigned int lag, double mean){
double var = variance(series,size,mean);
double covar = autocovariance(series,size,lag,mean);
return covar / var;
}
Vec ArModel::simulate(int n) const {
int p = number_of_lags();
Vec acf = autocovariance(p);
Spd Sigma(p);
Sigma.diag() = acf[0];
for(int i = 1; i < p; ++i) {
Sigma.subdiag(i) = acf[i];
Sigma.superdiag(i) = acf[i];
}
Vec zero(p, 0.0);
Vec y0 = rmvn(zero, Sigma);
return simulate(n, y0);
}
Vector ArModel::simulate(int n, RNG &rng) const {
int p = number_of_lags();
Vector acf = autocovariance(p);
SpdMatrix Sigma(p);
Sigma.diag() = acf[0];
for (int i = 1; i < p; ++i) {
Sigma.subdiag(i) = acf[i];
Sigma.superdiag(i) = acf[i];
}
Vector zero(p, 0.0);
Vector y0 = rmvn(zero, Sigma);
return simulate(n, y0, rng);
}
double autocorrelation_time(const vector<double>& x,unsigned max)
{
if (x.size() < 2) return 1.0;
vector<double> cv = autocovariance(x,max);
double V = cv[0];
double sum = 0;
for(int i=1;i<cv.size();i++)
sum += cv[i];
return (1.0 + 2.0*sum/V);
}
//======================================================================
SpdMatrix ArStateModel::initial_state_variance()const{
if (initial_state_variance_.nrow() != state_dimension()) {
report_error("Sigma_.nrow() != state_dimension() in "
"ArStateModel::initial_state_mean()");
}
SpdMatrix & Sigma(const_cast<SpdMatrix &>(initial_state_variance_));
if (stationary_initial_distribution_) {
Vector gamma = autocovariance(state_dimension());
Sigma.diag() = gamma[0];
for(int i = 1; i < state_dimension(); ++i){
Sigma.superdiag(i) = gamma[i];
}
Sigma.reflect();
}
return initial_state_variance_;
}
// The variance of a value forecasted far into the future. The mean of the
// forecast is zero.
double stationary_variance() const { return autocovariance(0)[0]; }
double variance(double* series, unsigned int size, double mean){
return autocovariance(series,size,0,mean);
}
virtual double autocorrelation(unsigned lag) const {
return autocovariance(lag)/autocovariance(0);
}
