double IMMGS::Logp(
const Vector &x,
Vector &g,
Matrix &h,
uint nderiv) const {
double ans = 0;
if (nderiv > 0) {
g = 0;
if (nderiv > 1) {
h = 0;
}
}
const Vector &mu(this->mu());
Vector v = unscaled_variance_diagonal() * sigsq();
for (int i = 0; i < x.size(); ++i) {
ans += dnorm(x[i], mu[i], sqrt(v[i]), true);
if (nderiv > 0) {
g[i] -= -(x[i] - mu[i]) / v[i];
if (nderiv > 1) {
h(i, i) -= 1.0 / v[i];
}
}
}
return ans;
}
double IMMGS::ldsi() const {
double ans = -dim() * log(sigsq());
const Vector &v(unscaled_variance_diagonal());
for (int i = 0; i < dim(); ++i) {
ans -= log(v[i]);
}
return ans;
}
double MGSS::loglike(const Vector &mu_ominv)const{
const ConstVectorView mu(mu_ominv, 0, dim());
SpdMatrix siginv(dim());
Vector::const_iterator b(mu_ominv.cbegin() + dim());
siginv.unvectorize(b, true);
siginv /= sigsq();
return MvnBase::log_likelihood(Vector(mu), siginv, *suf());
}
Vector IMMGS::sim() const {
Vector ans(dim());
double sigma = sqrt(sigsq());
const Vector &v(unscaled_variance_diagonal());
const Vector &mu(this->mu());
for (int i = 0; i < dim(); ++i) {
ans[i] = rnorm(mu[i], sigma * sqrt(v[i]));
}
return ans;
}
Vector ArModel::autocovariance(int number_of_lags)const{
set_filter_coefficients();
Vec ans(number_of_lags + 1);
for(int lag = 0; lag <= number_of_lags; ++lag){
int n = filter_coefficients_.size() - lag;
const ConstVectorView psi(filter_coefficients_, 0, n);
const ConstVectorView lag_psi(filter_coefficients_, lag, n);
ans[lag] = psi.dot(lag_psi);
}
return ans * sigsq();
}
// Log likelihood when beta is empty, so that xbeta = 0. In this
// case the only parameter is sigma^2
double RM::empty_loglike(Vector &g, Matrix &h, uint nd)const{
double v = sigsq();
double n = suf()->n();
double ss = suf()->yty();
const double log2pi = 1.83787706640935;
double ans = -.5*n*(log2pi + log(v)) - .5*ss/v;
if(nd > 0){
double v2 = v*v;
g[0] = -.5*n/v + .5*ss/v2;
if(nd > 1){
h(0,0) = .5*n/v2 - ss/(v2*v);
}
}
return ans;
}
//======================================================================
Ptr<SparseMatrixBlock> ArStateModel::state_variance_matrix(int t)const{
if(!state_variance_is_current_){
state_variance_matrix_->set_value(sigsq());
}
return state_variance_matrix_;
}
double MGSS::ldsi()const{
return omega_.ldsi() - dim() * log(sigsq());
}
const Spd & MGSS::siginv()const{
wsp_ = omega_.ivar() / sigsq();
return wsp_;
}
const Spd & MGSS::Sigma()const{
wsp_ = omega_.var() * sigsq();
return wsp_;
}
double sigma() const {return sqrt(sigsq());}
const SpdMatrix & IMMGS::siginv() const {
sigma_scratch_.resize(dim());
sigma_scratch_.diag() = 1.0 / unscaled_variance_diagonal();
sigma_scratch_.diag() /= sigsq();
return sigma_scratch_;
}
const SpdMatrix & IMMGS::Sigma() const {
sigma_scratch_.resize(dim());
sigma_scratch_.diag() = unscaled_variance_diagonal();
sigma_scratch_.diag() *= sigsq();
return sigma_scratch_;
}
const Spd & IndependentMvnModel::Sigma()const{
sigma_scratch_.set_diag(sigsq());
return sigma_scratch_;
}
double IMMGS::sd_for_element(int i) const {
return sqrt(sigsq() * unscaled_variance_diagonal()[i]);
}
double ZGM::sigma()const{return sqrt(sigsq());}
double IndependentMvnModel::sigma(int i)const{
return sqrt(sigsq(i));
}
double IndependentMvnModel::sigsq(int i)const{
return sigsq()[i];
}
const Spd & IndependentMvnModel::siginv()const{
sigma_scratch_.set_diag(1.0/sigsq());
return sigma_scratch_;
}
