/* finds the desired result, given y, the primes to be killed, the denominators, the full set of initial primes, and the density of relative primes */ extern BigNum find_M(BigNum * guess, BigNum * y, struct BIGNUM_ARRAY_TYPE left_to_kill, struct BIGNUM_ARRAY_TYPE denom, struct BIGNUM_ARRAY_TYPE initial_primes, BigRat *magic) { BigNum temp, temp2, current_mu; #if 0 Mu(¤t_mu, guess, left_to_kill, denom); temp = y - current_mu; temp2 = b_abs(temp); while (b_cmp(temp2, LINEAR_SEARCH_LIMIT) > 0) { temp2 = guess_mu_inverse(&temp, magic); (*guess) = (*guess) + temp2; Mu(¤t_mu, guess, left_to_kill, denom); temp = y - current_mu; temp2 = b_abs(temp); } temp = b_clear(); temp2 = b_clear(); #else *guess = "11"; current_mu = "1"; #endif return(linear_find(y, ¤t_mu, guess, initial_primes)); }
yarp::sig::Matrix idynChainGetMoments_usingKDL(iCub::iDyn::iDynChain & idynChain,yarp::sig::Vector & ddp0) { KDL::Wrenches f_i; int nj = idynChain.getN(); yarp::sig::Vector mu(3),f(3); yarp::sig::Matrix Mu(3,nj); Mu.zero(); f_i = idynChainGet_usingKDL_aux(idynChain,ddp0); //Debug /* std::cout << "f_i without sensor " << std::endl; for(int p=0;p<f_i.size();p++) { std::cout << f_i[p] << std::endl; } */ for(int i=0; i < nj; i++ ) { if( i != nj -1 ) { to_iDyn(f_i[i+1].force,f); f = (idynChain[i+1]).getR()*f; to_iDyn(f_i[i+1].torque,mu); yarp::sig::Vector r_n = ((idynChain)[i+1]).getH().subcol(0,3,3); mu = ((idynChain)[i+1]).getR()*mu+cross(r_n,f); } else { mu.zero(); } Mu.setCol(i,mu); } return Mu; }
/* Efficient caluculation of mu */ extern void Mu(BigNum * result, BigNum * x, struct BIGNUM_ARRAY_TYPE left_to_kill, struct BIGNUM_ARRAY_TYPE the_final_denom) { BigNum subout, first, second; struct BIGNUM_ARRAY_TYPE new_kill; if (left_to_kill.size <= 0) { mu_eval(result, x, the_final_denom); } else { subout = (*x) / left_to_kill.list[0]; new_kill.size = left_to_kill.size - 1; new_kill.list = &(left_to_kill.list[1]); Mu(&first, x, new_kill, the_final_denom); Mu(&second, &subout, new_kill, the_final_denom); *result = first - second; first.b_clear(); second.b_clear(); subout.b_clear(); } }
int main() { // Set all ranges Range<double> X(Xfrom,Xto); Range<double> T(Yfrom,Yto); // Declare all TwoVarDFunctions TwoVarDFunction<double,double,double> Sigma(*sigma); TwoVarDFunction<double,double,double> Mu(*mu); TwoVarDFunction<double,double,double> Forcing(*forcing); TwoVarDFunction<double,double,double> B(*b); // Declare all AtomicDFunctions AtomicDFunction<double,double> Ic(*IC); // Change from Call<->Put // AtomicDFunction<double,double> Bcr(*BCR_Topper_p11); AtomicDFunction<double,double> Bcr(*BCR);// Change from Call<->Put AtomicDFunction<double,double> Bcl(*BCL);// Change from Call<->Put // Declare the pde ParabolicPDE<double,double,double> pde(X,T,Sigma,Mu,B,Forcing,Ic,Bcl,Bcr); // Declare the finite difference scheme // ParabolicFDM<double,double,double> FDM(pde,XINTERVALS,YINTERVALS,THETA); // V1 int choice = 3; cout << "1) Explicit Euler 2) Implicit Euler 3) Crank Nicolson "; cin >> choice; //OptionType type = AmericanCallType; OptionType type = EuropeanCallType; ParabolicFDM<double,double,double> FDM(pde,XINTERVALS,YINTERVALS,choice, type); // compute option prices FDM.start(); // Retrieve and store option prices Vector <double,long> result = FDM.line(); // Does include ENDS!! /////////////////////////////////////////////////////////// Vector<double, long> xArr = FDM.xarr(); Vector<double, long> tArr = FDM.tarr(); double h = xArr[2] - xArr[1]; double k = tArr[2] - tArr[1]; cout << "h " << h << endl; // Create and fill Delta vector Vector <double,long> DeltaMesh(xArr.Size()-2, xArr.MinIndex()); for (long kk = DeltaMesh.MinIndex(); kk <= DeltaMesh.MaxIndex(); kk++) { DeltaMesh[kk] = xArr[kk+1]; } Vector <double,long> Delta(result.Size()-2,result.MinIndex()); for (long i = Delta.MinIndex(); i <= Delta.MaxIndex(); i++) { Delta[i] = (result[i+1] - result[i])/(h); } print(result); print(Delta); // Create and fill Gamma vector Vector <double,long> GammaMesh(DeltaMesh.Size()-2, DeltaMesh.MinIndex()); for (long p = GammaMesh.MinIndex(); p <= GammaMesh.MaxIndex(); p++) { GammaMesh[p] = DeltaMesh[p+1]; } Vector <double,long> Gamma(Delta.Size()-2, Delta.MinIndex()); for (long n = Gamma.MinIndex(); n <= Gamma.MaxIndex(); n++) { Gamma[n] = (Delta[n+1] - Delta[n])/(h); } /*// Create and fill Theta vector Vector <double,long> ThetaMesh(tArr.Size()-1, tArr.MinIndex()); for (long m = ThetaMesh.MinIndex(); m <= ThetaMesh.MaxIndex(); m++) { ThetaMesh[m] = tArr[m+1]; }*/ long NP1 = FDM.result().MaxRowIndex(); long NP = FDM.result().MaxRowIndex() -1; Vector <double,long> Theta(result.Size(), result.MinIndex()); for (long ii = Theta.MinIndex(); ii <= Theta.MaxIndex(); ii++) { Theta[ii] = -(FDM.result()(NP1, ii) -FDM.result()(NP, ii) )/k; } try { printOneExcel(FDM.xarr(), result, string("Price")); printOneExcel(DeltaMesh, Delta, string("Delta")); printOneExcel(GammaMesh, Gamma, string("Gamma")); printOneExcel(FDM.xarr(), Theta, string("Theta")); } catch(DatasimException& e) { e.print(); ExcelDriver& excel = ExcelDriver::Instance(); excel.MakeVisible(true); long y = 1; excel.printStringInExcel(e.Message(), y, y, string("Err")); list<string> dump; dump.push_back(e.MessageDump()[0]); dump.push_back(e.MessageDump()[1]); dump.push_back(e.MessageDump()[2]); excel.printStringInExcel(dump, 1, 1, string("Err")); return 0; } return 0; }
int main(int argc, char** argv){ ros::init(argc, argv, "wkmeans_test"); ros::NodeHandle node; ros::Rate rate(100); std::size_t K = 10; arma::vec pi = arma::randu<arma::vec>(3); pi = arma::normalise(pi); std::vector<arma::vec> Mu(K); std::vector<arma::mat> Sigma(K); float a = -2; float b = 2; for(std::size_t k = 0; k < K;k++){ Mu[k] = (b - a) * arma::randu<arma::vec>(3) + a; Sigma[k].zeros(3,3); arma::vec tmp = 0.3 * arma::randu<arma::vec>(3) + 0.2; Sigma[k](0,0) =tmp(0); Sigma[k](1,1) =tmp(1); Sigma[k](2,2) =tmp(2); } GMM gmm; gmm.setParam(pi,Mu,Sigma); std::size_t nb_samples = 10000; arma::colvec weights; arma::mat X(nb_samples,3); gmm.sample(X); arma::vec L(nb_samples); gmm.P(X,L); L = L / arma::max(L); // L.elem(q1).zeros(); unsigned char rgb[3]; std::vector<std::array<float,3> > colors(nb_samples); for(std::size_t i = 0 ; i < L.n_elem;i++){ ColorMap::jetColorMap(rgb,L(i),0,1); colors[i][0] = ((float)rgb[0])/255; colors[i][1] = ((float)rgb[1])/255; colors[i][2] = ((float)rgb[2])/255; } arma::uvec q1 = arma::find(L > 0.6*arma::max(L)); std::vector<std::array<float,3> > colors2(q1.n_elem); arma::mat X_W(q1.n_elem,3); for(std::size_t i = 0; i < q1.n_elem;i++){ assert(q1(i) < colors.size()); assert(q1(i) < X.n_rows); colors2[i] = colors[q1(i)]; X_W.row(i) = X.row(q1(i)); } Weighted_Kmeans<double> weighted_kmeans; weighted_kmeans.cluster(X_W.st(),L); weighted_kmeans.centroids.print("centroids"); opti_rviz::Vis_points points(node,"centroids"); points.scale = 0.1; points.r = 1; points.b = 1; arma::fmat c = arma::conv_to<arma::fmat>::from(weighted_kmeans.centroids.st()); points.initialise("world",c); opti_rviz::Vis_point_cloud vis_point(node,"samples"); vis_point.set_display_type(opti_rviz::Vis_point_cloud::DEFAULT); vis_point.initialise("world",X_W); opti_rviz::Vis_gmm vis_gmm(node,"gmm"); vis_gmm.initialise("world",pi,Mu,Sigma); while(node.ok()){ vis_gmm.update(pi,Mu,Sigma); vis_gmm.publish(); vis_point.update(X_W,colors2,weights); vis_point.publish(); points.update(c); points.publish(); ros::spinOnce(); rate.sleep(); } }
yarp::sig::Matrix idynChainGetMoments_usingKDL(iCub::iDyn::iDynChain & idynChain,iCub::iDyn::iDynInvSensor & idynSensor,yarp::sig::Vector & ddp0) { KDL::Wrenches f_i; int nj = idynChain.getN(); int ns = nj+1; int sensor_link = idynSensor.getSensorLink(); yarp::sig::Vector mu(3),f(3); yarp::sig::Matrix Mu(3,nj); Mu.zero(); f_i = idynChainGet_usingKDL_aux(idynChain,idynSensor,ddp0); //Debug /* std::cout << "f_i with sensor " << std::endl; for(int p=0;p<f_i.size();p++) { std::cout << f_i[p] << std::endl; } */ int i,j; for(i=0,j=0; i < ns; i++) { mu.zero(); if( i < sensor_link-1 ) { assert(i != ns -1); to_iDyn(f_i[i+1].force,f); f = ((idynChain)[i+1]).getR()*f; to_iDyn(f_i[i+1].torque,mu); yarp::sig::Vector r_n = ((idynChain)[i+1]).getH().subcol(0,3,3); mu = ((idynChain)[i+1]).getR()*mu+cross(r_n,f); } if( i == sensor_link-1 ) { assert(i != ns -1); //pay attention to this, for KDL the wrench is referred to the sensor reference frame iCub::iKin::iKinLink link_sensor = idynChain[sensor_link]; //double angSensorLink = link_sensor.getAng(); yarp::sig::Matrix H_sensor_link = (link_sensor.getH()); //link_sensor.setAng(angSensorLink); yarp::sig::Matrix H_0 = H_sensor_link * (idynSensor.getH()); to_iDyn(f_i[i+1].force,f); f = H_0.submatrix(0,2,0,2)*f; to_iDyn(f_i[i+1].torque,mu); yarp::sig::Vector r_n = H_0.subcol(0,3,3); mu = H_0.submatrix(0,2,0,2)*mu+cross(r_n,f); } if( i > sensor_link-1 ) { if( i != ns-1 ) { to_iDyn(f_i[i+1].force,f); f = ((idynChain)[i]).getR()*f; to_iDyn(f_i[i+1].torque,mu); yarp::sig::Vector r_n = ((idynChain)[i]).getH().subcol(0,3,3); mu = ((idynChain)[i]).getR()*mu+yarp::math::cross(r_n,f); } else { mu.zero(); } } if(i!=sensor_link) { Mu.setCol(j,mu); j++; } } /*for(int i=0; i < nj; i++ ) { if( i != nj -1 ) { to_iDyn(f_i[i+1].force,f); f = (idynChain[i+1]).getR()*f; to_iDyn(f_i[i+1].torque,mu); Vector r_n = ((idynChain)[i+1]).getH().subcol(0,3,3); mu = ((idynChain)[i+1]).getR()*mu+cross(r_n,f); } else { mu.zero(); }*/ return Mu; }
SEXP MADBayes( SEXP _b, SEXP _clusterLabels, SEXP _Theta, SEXP _Mu, SEXP _D, SEXP _Gamma, SEXP _Y, SEXP _lambdap, SEXP _lambdaw, SEXP _lambda) { // The following values are 1updated in MCMC iterations IntegerVector b(_b); // length I IntegerVector clusterLabels(_clusterLabels); // length I IntegerMatrix Theta(_Theta); // K by I //NumericMatrix W(_W); // KS by I + 1 //NumericMatrix P(_P); // I by S NumericMatrix Mu(_Mu); // N by S IntegerVector D(_D); // Length N, valued in {0, 1, ..., K-1} double lambda = as<double>(_lambda); // The following values are piror parameters and are fixed double lambdap = as<double>(_lambdap); double lambdaw = as<double>(_lambdaw); // The following is the external information. NumericMatrix Gamma(_Gamma); // N*S by I NumericMatrix Y(_Y); // N by I // extract the dimensions int I = b.size(); int S = Mu.ncol(); int K = Theta.nrow(); int N = D.size(); // The following will be computed NumericMatrix W(K * S, I + 1); NumericMatrix P(I, S); // iterators int i, j, k = 0, s = 0, n, i1;//, likid; double loss; double _LOW = 1e-10; int ClusterSize[I + 1]; for(i = 0; i < I + 1; i ++) { ClusterSize[i] = 0; } // Compute J int J = 0; for(i = 0; i < I; i ++) { if(J < clusterLabels[i]) { J = clusterLabels[i]; } ClusterSize[clusterLabels[i]] ++; } J ++; // Update W for(j = 0; j < J; j ++) { for(k = 0; k < K; k ++) { double tmp[S + 1]; tmp[S] = 0; for(s = 0; s < S; s ++) { tmp[s] = _LOW; tmp[S] += tmp[s]; W(s * K + k, j) = 0; } for(i = 0; i < I; i ++) { if(b[i] == 0 && clusterLabels[i] == j) { tmp[Theta(k, i)] ++; tmp[S] ++; } } for(s = 0; s < S; s ++) { W(s * K + k, j) = tmp[s] / tmp[S]; } } } // update P for(i = 0; i < I; i ++) { double tmp[S + 1]; tmp[S] = 0; for(s = 0; s < S; s++) { tmp[s] = _LOW; tmp[S] += _LOW; P(i, s) = 0; } for(k = 0; k < K; k ++) { tmp[Theta(k, i)] ++; tmp[S] ++; } for(s = 0; s < S; s ++) { P(i, s) = tmp[s] / tmp[S]; } } // update b for(i = 0; i < I; i ++) { double tmp = 0; for(k = 0; k < K; k ++) { tmp += 2 * lambdap * (1 - P(i, Theta(k, i))); } for(k = 0; k < K; k ++) { tmp -= 2 * lambdaw * (1 - W(Theta(k, i) * K + k, clusterLabels[i])); } if(tmp < 0) b[i] = 1; else b[i] = 0; } loss = 0; for(i = 0; i < I; i ++) { for(n = 0; n < N; n ++) { k = D[n]; s = Theta(k, i); loss += (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)) * (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)); } if(b[i] == 1) { for(k = 0; k < K; k ++) { loss += 2 * lambdap * (1 - P(i, Theta(k, i))); } } else { for(k = 0; k < K; k ++) { loss += 2 * (1 - W(Theta(k, i) * K + k, clusterLabels[i])) * lambdaw; } } } loss += lambda * (J - 1); //printf("b, Loss function = %3.3f, number of clusters = %d\n", loss, J); // update Theta for(i = 0; i < I; i ++) { for(k = 0; k < K; k ++) { double tmp[S]; for(s = 0; s < S; s ++) { // initialize tmp[s] = 0; // for(n = 0; n < N; n ++) { if(D[n] == k) { tmp[s] += (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)) * (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)); } } if(b[i] == 1) { tmp[s] += 2 * lambdap * (1 - P(i, s)); } else { tmp[s] += 2 * lambdaw * (1 - W(s * K + k, clusterLabels[i])); } } // Assign new values Theta(k, i) = 0; for(s = 1; s < S; s ++) { if(tmp[s] < tmp[Theta(k, i)]) Theta(k, i) = s; } } } loss = 0; for(i = 0; i < I; i ++) { for(n = 0; n < N; n ++) { k = D[n]; s = Theta(k, i); loss += (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)) * (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)); } if(b[i] == 1) { for(k = 0; k < K; k ++) { loss += 2 * lambdap * (1 - P(i, Theta(k, i))); } } else { for(k = 0; k < K; k ++) { loss += 2 * (1 - W(Theta(k, i) * K + k, clusterLabels[i])) * lambdaw; } } } loss += lambda * (J - 1); //printf("theta, Loss function = %3.3f, number of clusters = %d\n", loss, J); //update clusters for(i = 0; i < I; i ++) { // do not update cluster if this is a singleton if(b[i] == 1) continue; int oldState = clusterLabels[i]; ClusterSize[clusterLabels[i]] --; double tmp[J]; double mintmp = lambda;// cost of starting a new cluster int newState = J; for(j = 0; j < J; j ++) { tmp[j] = 0; for(k = 0; k < K; k ++) { tmp[j] += 2 * (1 - W(Theta(k, i) * K + k, j)) * lambdaw; } // assign the minimum cost if(tmp[j] < mintmp) { mintmp = tmp[j]; newState = j; } } clusterLabels[i] = newState; ClusterSize[newState] ++; if(mintmp >= lambda) { // a new cluster is formed if(J != newState) { printf("Error: new state is not J = %d.", J); exit(1); } for(s = 0; s < S; s ++) { for(k = 0; k < K; k ++) { if(Theta(k, i) != s) { W(s * K + k, J) = _LOW; } else { W(s * K + k, J) = 1 - (S - 1) * _LOW; } } } J ++; } if(ClusterSize[oldState] == 0) { // an old cluster should be removed W(_, oldState) = W(_, J - 1); for(k = 0; k < K * S; k ++) { W(k, J - 1) = 0; } for(i1 = 0; i1 < I; i1 ++) { if(clusterLabels[i1] == J - 1) clusterLabels[i1] = oldState; } ClusterSize[oldState] = ClusterSize[J - 1]; ClusterSize[J - 1] = 0; J --; } } loss = 0; for(i = 0; i < I; i ++) { for(n = 0; n < N; n ++) { k = D[n]; s = Theta(k, i); loss += (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)) * (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)); } if(b[i] == 1) { for(k = 0; k < K; k ++) { loss += 2 * lambdap * (1 - P(i, Theta(k, i))); } } else { for(k = 0; k < K; k ++) { loss += 2 * (1 - W(Theta(k, i) * K + k, clusterLabels[i])) * lambdaw; } } } loss += lambda * (J - 1); //printf("z, Loss function = %3.3f, number of clusters = %d\n", loss, J); // update mu for(n = 0; n < N; n ++) { double denom = 0, numer = 0; for(i = 0; i < I; i ++) { denom += Gamma(n + s * N, i); numer += Y(n, i); } for(s = 0; s < S; s ++) { Mu(n, s) = numer / denom; } for(s = 0; s < S; s ++) { denom = 0; numer = 0; for(i = 0; i < I; i ++) { if(Theta(D[n], i) == s) { numer += Y(n, i); denom += Gamma(n + s * N, i); } } if(denom > 0) { Mu(n, s) = numer / denom; } } } // calculate the loss function loss = 0; for(i = 0; i < I; i ++) { for(n = 0; n < N; n ++) { k = D[n]; s = Theta(k, i); loss += (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)) * (Y(n, i) - Mu(n, s) * Gamma(s * N + n, i)); } if(b[i] == 1) { for(k = 0; k < K; k ++) { loss += 2 * lambdap * (1 - P(i, Theta(k, i))); } } else { for(k = 0; k < K; k ++) { loss += 2 * (1 - W(Theta(k, i) * K + k, clusterLabels[i])) * lambdaw; } } } loss += lambda * (J - 1); //printf("Loss function = %3.3f, number of clusters = %d\n", loss, J); Rcpp::List ret = Rcpp::List::create( Rcpp::Named("Theta") = Theta, Rcpp::Named("clusterLabels") = clusterLabels, Rcpp::Named("b") = b, Rcpp::Named("W") = W, Rcpp::Named("P") = P, Rcpp::Named("Mu") = Mu, Rcpp::Named("loss") = loss //,Rcpp::Named("oldlik") = oldlik ); return( ret ); }
/* Hyperparameters - vector of length 7 (if of length 6, then default value of 1.0 is used for Hyperparameters(3)) Sets prior_X and prior_Y */ void SBVAR_symmetric::SimsZhaDummyObservations(const TDenseVector &Hyperparameters, double PeriodsPerYear, double VarianceScale) { // check hyperparameters TDenseVector Mu(7); if (Hyperparameters.dim == 6) { for (int i=0; i < 7; i++) if (i < 3) Mu(i)=Hyperparameters(i); else if (i == 3) Mu(i)=1.0; else Mu(i)=Hyperparameters(i-1); } else if (Hyperparameters.dim == 7) Mu=Hyperparameters; else throw dw_exception("Sims-Zha prior requires seven hyperparameters"); if (PeriodsPerYear <= 0) throw dw_exception("Periods per year must be positive"); if (VarianceScale <= 0) throw dw_exception("variance scale must be positive"); for (int i=6; i >= 0; i--) if (Mu(i) <= 0) throw dw_exception("Sims-Zha hyperparameters must be positive"); // data info int n_obs=NumberObservations(); TDenseMatrix Y=Data(); TDenseMatrix X=PredeterminedData(); // compute mean of initial data contained in the first observaton of the predetermined data TDenseVector m(n_vars,0.0); if (n_lags > 0) { for (int i=n_lags-1; i >= 0; i--) for (int j=n_vars-1; j >= 0; j--) m(j)+=X(0,i*n_vars+j); m=(1.0/(double)n_lags)*m; } // compute variance of univariate AR residuals TDenseVector s(n_vars,0.0), y(n_obs), e(n_obs); TDenseMatrix Q, R, M(n_obs,n_lags+1); for (int i=n_vars-1; i >= 0; i--) { for (int j=n_lags-1; j >= 0; j--) M.Insert(0,j,X,0,n_obs-1,j*n_vars+i,j*n_vars+i); M.Insert(0,n_lags,X,0,n_obs-1,n_predetermined-1,n_predetermined-1); QR(Q,R,M); y.ColumnVector(Y,i); e=y - Q*(Transpose(Q)*y); s(i)=Norm(e)/sqrt((double)n_obs); } // dummy observations prior_Y.Zeros(2+n_vars*(n_lags+2),n_vars); prior_X.Zeros(2+n_vars*(n_lags+2),n_predetermined); // prior on a(k,i): dummy observations of the form // y=s(i)/mu(1) * e(i,n_vars) // x=0 int row=0; for (int i=0; i < n_vars; i++) prior_Y(row+i,i)=s(i)/Mu(0); row+=n_vars; // prior on constant: dummy observation of the form // y=0 // x=1.0/(mu(1)*mu(3)) * e(n_predermined,n_predetermined) prior_X(row,n_predetermined-1)=1.0/(Mu(0)*Mu(2)); row+=1; if (n_lags > 0) { // random walk prior: dummy observations of the form // y=s(i)/(mu(2)*mu(1)) * e(i,n_vars) // x=s(i)/(mu(2)*mu(1)) * e(i,n_predetermined) for (int i=0; i < n_vars; i++) { prior_Y(row+i,i)=s(i)/(Mu(0)*Mu(1)); prior_X(row+i,i)=s(i)/(Mu(0)*Mu(1)); } row+=n_vars; // lag decay prior: dummy observations of the form // y=0 // x=s(i)*(4*j/PeriodsPerYear+1)^mu(4)/(mu(1)*mu(2)) * e(j)*nvars+i,n_pred) for (int j=1; j < n_lags; j++) { for (int i=0; i < n_vars; i++) prior_X(row+i,j*n_vars+i)=s(i)*pow(4.0*Mu(3)*(double)j/PeriodsPerYear+1.0,Mu(4))/(Mu(0)*Mu(1)); row+=n_vars; } // sums-of-coefficients prior: dummy observations of the form // y=mu(5)*m(i) * e(i,n_vars) // x=sum_j { mu(5)*m(i) * e((j-1)*n_vars+i,n_pred) } for (int i=0; i < n_vars; i++) { prior_Y(row+i,i)=Mu(5)*m(i); for (int j=0; j < n_lags; j++) prior_X(row+i,j*n_vars+i)=Mu(5)*m(i); } row+=n_vars; // co-persistence prior: dummy observation of the form // y=sum_i { mu(6)*m(i) * e(i,n_vars) } // x=sum_i,j { mu(6)*m(i) * e((j-1)*n_vars+i,n_pred) } + mu(6) * e(n_pred,n_pred) for (int i=0; i < n_vars; i++) { prior_Y(row,i)=Mu(6)*m(i); for (int j=0; j < n_lags; j++) prior_X(row,j*n_vars+i)=Mu(6)*m(i); } prior_X(row,n_predetermined-1)=Mu(6); } // variance scale prior_Y=sqrt(1.0/VarianceScale)*prior_Y; prior_X=sqrt(1.0/VarianceScale)*prior_X; }