void StateModel::simulate_initial_state(VectorView eta)const{ if(eta.size() != state_dimension()){ std::ostringstream err; err << "output vector 'eta' has length " << eta.size() << " in StateModel::simulate_initial_state. Expected length " << state_dimension(); report_error(err.str()); } eta = rmvn(initial_state_mean(), initial_state_variance()); }
template <> void LapHessenberg( MatrixView<double> A, VectorView<double> Ubeta) { TMVAssert(A.iscm()); TMVAssert(A.colsize() == A.rowsize()); TMVAssert(Ubeta.size() == A.rowsize()-1); TMVAssert(A.ct()==NonConj); int n = A.rowsize(); int ilo = 1; int ihi = n; int lda = A.stepj(); int Lap_info=0; #ifndef LAPNOWORK int lwork = n*LAP_BLOCKSIZE; double* work = LAP_DWork(lwork); #endif LAPNAME(dgehrd) ( LAPCM LAPV(n),LAPV(ilo),LAPV(ihi), LAPP(A.ptr()),LAPV(lda),LAPP(Ubeta.ptr()) LAPWK(work) LAPVWK(lwork) LAPINFO); #ifdef LAPNOWORK LAP_Results(Lap_info,"dgehrd"); #else LAP_Results(Lap_info,int(work[0]),m,n,lwork,"dgehrd"); #endif }
template <> void LapHessenberg( MatrixView<std::complex<float> > A, VectorView<std::complex<float> > Ubeta) { TMVAssert(A.iscm()); TMVAssert(A.colsize() >= A.rowsize()); TMVAssert(Ubeta.size() == A.rowsize()); TMVAssert(A.ct()==NonConj); int n = A.rowsize(); int ilo = 1; int ihi = n; int lda = A.stepj(); int Lap_info=0; #ifndef LAPNOWORK int lwork = n*LAP_BLOCKSIZE; std::complex<float>* work = LAP_CWork(lwork); #endif LAPNAME(cgehrd) ( LAPCM LAPV(n),LAPV(ilo),LAPV(ihi), LAPP(A.ptr()),LAPV(lda),LAPP(Ubeta.ptr()) LAPWK(work) LAPVWK(lwork) LAPINFO); Ubeta.ConjugateSelf(); #ifdef LAPNOWORK LAP_Results(Lap_info,"cgehrd"); #else LAP_Results(Lap_info,int(REAL(work[0])),m,n,lwork,"cgehrd"); #endif }
double ZGS::increment_log_prior_gradient(const ConstVectorView ¶meters, VectorView gradient) const { if (parameters.size() != 1 || gradient.size() != 1) { report_error( "Wrong size arguments passed to " "ZeroMeanGaussianConjSampler::increment_log_prior_gradient."); } return log_prior(parameters[0], &gradient[0], nullptr); }
static void NonBlockHessenberg( MatrixView<T> A, VectorView<T> Ubeta) { #ifdef XDEBUG cout<<"Start NonBlock Hessenberg Reduction: A = "<<A<<endl; Matrix<T> A0(A); #endif // Decompose A into U H Ut // H is a Hessenberg Matrix // U is a Unitary Matrix // On output, H is stored in the upper-Hessenberg part of A // U is stored in compact form in the rest of A along with // the vector Ubeta. const ptrdiff_t N = A.rowsize(); TMVAssert(A.colsize() == A.rowsize()); TMVAssert(N > 0); TMVAssert(Ubeta.size() == N-1); TMVAssert(A.iscm() || A.isrm()); TMVAssert(!Ubeta.isconj()); TMVAssert(Ubeta.step()==1); // We use Householder reflections to reduce A to the Hessenberg form: T* Uj = Ubeta.ptr(); T det = 0; // Ignore Householder det calculations for(ptrdiff_t j=0;j<N-1;++j,++Uj) { #ifdef TMVFLDEBUG TMVAssert(Uj >= Ubeta._first); TMVAssert(Uj < Ubeta._last); #endif *Uj = Householder_Reflect(A.subMatrix(j+1,N,j,N),det); if (*Uj != T(0)) Householder_LMult(A.col(j+2,N),*Uj,A.subMatrix(0,N,j+1,N).adjoint()); } #ifdef XDEBUG Matrix<T> U(N,N,T(0)); U.subMatrix(1,N,1,N) = A.subMatrix(1,N,0,N-1); U.upperTri().setZero(); Vector<T> Ubeta2(N); Ubeta2.subVector(1,N) = Ubeta; Ubeta2(0) = T(0); GetQFromQR(U.view(),Ubeta2); Matrix<T> H = A; if (N>2) LowerTriMatrixViewOf(H).offDiag(2).setZero(); Matrix<T> AA = U*H*U.adjoint(); if (Norm(A0-AA) > 0.001*Norm(A0)) { cerr<<"NonBlock Hessenberg: A = "<<Type(A)<<" "<<A0<<endl; cerr<<"A = "<<A<<endl; cerr<<"Ubeta = "<<Ubeta<<endl; cerr<<"U = "<<U<<endl; cerr<<"H = "<<H<<endl; cerr<<"UHUt = "<<AA<<endl; abort(); } #endif }
inline ::Eigen::Map<const ::Eigen::VectorXd, ::Eigen::Unaligned, ::Eigen::InnerStride<::Eigen::Dynamic>> EigenMap(const VectorView &view) { return ::Eigen::Map<const ::Eigen::VectorXd, ::Eigen::Unaligned, ::Eigen::InnerStride<::Eigen::Dynamic>>( view.data(), view.size(), ::Eigen::InnerStride<::Eigen::Dynamic>(view.stride())); }
void LMAT::Tmult(VectorView lhs, const ConstVectorView &rhs)const { if(lhs.size()!=3) { report_error("lhs is the wrong size in LMAT::Tmult"); } if(rhs.size()!=3) { report_error("rhs is the wrong size in LMAT::Tmult"); } lhs[0] = rhs[0]; double phi = phi_->value(); lhs[1] = rhs[0] + phi * rhs[1]; lhs[2] = (1-phi) * rhs[1] + rhs[2]; }
// TODO(stevescott): test void ASSR::simulate_initial_state(VectorView state0)const { // First, simulate the initial state of the client state vector. VectorView client_state(state0, 0, state0.size()-2); StateSpaceModelBase::simulate_initial_state(client_state); // Next simulate the initial value of the first latent weekly // observation. double mu = StateSpaceModelBase::observation_matrix(0).dot(client_state); state0[state_dimension() - 2] = rnorm(mu, regression_->sigma()); // Finally, the initial state of the cumulator variable is zero. state0[state_dimension() - 1] = 0; }
static inline void NonLapHessenberg( MatrixView<T> A, VectorView<T> Ubeta) { TMVAssert(A.rowsize() == A.colsize()); TMVAssert(A.rowsize() > 0); TMVAssert(Ubeta.size() == A.rowsize()-1); #if 0 if (A.rowsize() > HESS_BLOCKSIZE) BlockHessenberg(A,Ubeta,Vbeta,D,E,det); else #endif NonBlockHessenberg(A,Ubeta); }
/**************************************************************************** * * StreamInfo1::Configure( ) * * Set configuration of stream information. * ****************************************************************************/ bool StreamInfo1::Configure ( VectorView& sieves, // vector of sieve sizes std::vector<PMineralInfo1>& minerals, // collection of minerals double liquidSG // density of liquid phase ) { // ensure reasonable number of sieves if( sieves.size() <= 2 ) goto initFailed; // ensure reasonable number of minerals if( minerals.size() < 1 ) goto initFailed; // set implementation to supplied size distribution nSize_ = sieves.size(); sizes_.resize( nSize_ ); sizes_ = sieves; // set implementation to supplied mineral collection nType_ = static_cast<long>( minerals.size() ); minerals_.clear( ); minerals_.assign( minerals.begin(), minerals.end() ); // should probably check for NULL // pointer entries in minerals_ // succeeded return true; initFailed: // Initialization failed - object should not be used return false; }
static inline void Hessenberg( MatrixView<T> A, VectorView<T> Ubeta) { TMVAssert(A.colsize() == A.rowsize()); TMVAssert(Ubeta.size() == A.rowsize()-1); TMVAssert(A.isrm() || A.iscm()); TMVAssert(A.ct()==NonConj); TMVAssert(Ubeta.step() == 1); if (A.rowsize() > 0) { #ifdef LAP if (A.iscm()) LapHessenberg(A,Ubeta); else #endif NonLapHessenberg(A,Ubeta); } }
void DRSM::increment_expected_gradient( VectorView gradient, int t, const ConstVectorView &state_error_mean, const ConstSubMatrix &state_error_variance) { if (gradient.size() != xdim_ || state_error_mean.size() != xdim_ || state_error_variance.nrow() != xdim_ || state_error_variance.ncol() != xdim_) { report_error( "Wrong size arguments passed to " "DynamicRegressionStateModel::increment_expected_gradient."); } for (int i = 0; i < xdim_; ++i) { double mean = state_error_mean[i]; double var = state_error_variance(i, i); double sigsq = DynamicRegressionStateModel::sigsq(i); ; double tmp = (var + mean * mean) / (sigsq * sigsq) - 1.0 / sigsq; gradient[i] += .5 * tmp; } }
void MultMV( const T alpha, const GenDiagMatrix<Ta>& A, const GenVector<Tx>& x, VectorView<T> y) // y (+)= alpha * A * x // yi (+)= alpha * Ai * xi { TMVAssert(A.size() == x.size()); TMVAssert(A.size() == y.size()); #ifdef XDEBUG //cout<<"MultMV: \n"; //cout<<"alpha = "<<alpha<<endl; //cout<<"A = "<<TMV_Text(A)<<" "<<A<<endl; //cout<<"x = "<<TMV_Text(x)<<" "<<x<<endl; //cout<<"y = "<<TMV_Text(y)<<" "<<y<<endl; Vector<T> y0 = y; Vector<Tx> x0 = x; Matrix<Ta> A0 = A; Vector<T> y2 = alpha*A0*x0; if (add) y2 += y0; #endif ElemMultVV<add>(alpha,A.diag(),x,y); #ifdef XDEBUG if (!(Norm(y-y2) <= 0.001*(TMV_ABS(alpha)*Norm(A0)*Norm(x0)+ (add?Norm(y0):TMV_RealType(T)(0))))) { cerr<<"MultMV: alpha = "<<alpha<<endl; cerr<<"add = "<<add<<endl; cerr<<"A = "<<TMV_Text(A)<<" step "<<A.diag().step()<<" "<<A0<<endl; cerr<<"x = "<<TMV_Text(x)<<" step "<<x.step()<<" "<<x0<<endl; cerr<<"y = "<<TMV_Text(y)<<" step "<<y.step()<<" "<<y0<<endl; cerr<<"-> y = "<<y<<endl; cerr<<"y2 = "<<y2<<endl; abort(); } #endif }
/**************************************************************************** * * Construct LoadBasedScreen1 object as specified by specific arguments * * * * ScreenIntialize( Sizing, nRockType, ParamVec ) * * Initialize the screen model local variables to match the screen * specified by: * * Sizing - Vector of sieve sizes coarsest to finest for * the size distributions in the feed stream to the model * * nRockType - The number of mineral types in the feed stream (columns) * * THIS NEEDS UPDATING DAVE 13 params and different order * ParamVec - Screen configuration vector (10 elements). Contains: * * ParamVec[0] : Screen apperture in mm * ParamVec[1] : Screen total effective area m^2 * ParamVec[2] : Open fraction of effective area * ParamVec[3] : Bulk density of the screen feed t/m^3 * ParamVec[4] : Wet screening flag: * 0 - normal screening * 1 - wet screening * ParamVec[5] : Screen opening type * 1 - Round * 2 - Square * 3 - Slot 2/1 * 4 - Slot 3/1 * 5 - Slot 4/1 * 6 - Slot 5/1 * 7 - Grizzly * ParamVec[6] : Screen Material Type * 1 - Steel Wire * 2 - Steel Plate * 3 - Rubber * 4 - Polyurethane * ParamVec[7] : Deck location * 1 - Top Deck or Grizzly * 2 - Second Deck * etc * ParamVec[8] : Feed Type (Gravel Factor) * 1 - Rock * 2 - Gravel * ParamVec[9] : Custom area factor = 1.0 for no change * * ParamVec[10]: Water Recovery of Undersize * ParamVec[11]: Water Recovery of Undersize * ParamVec[12]: Water Recovery of Undersize * ****************************************************************************/ bool LoadBasedScreen1::Initialize( PStreamInfo1 Config, VectorView& ParamVec ) { // get count of material types from MatInfo nType = Config->nType(); // determine number of sizes from SizInfo nSize = Config->nSize(); // determine number of paramaters int nParam = ParamVec.size(); // ensure at least one type and two sizes if( nType<1 || nSize <2 ) goto initFailed; // ensure parameter vector has 11 elements //if( nParam != 11 ) // goto initFailed; // ensure parameter vector has 13 elements if( nParam != 13 ) goto initFailed; // set local vector/matrix to correct dimension Sizes.resize( nSize ); PartitionCurve.resize( nSize ); CombRetSizing.resize( nSize ); PartitionCurve.resize( nSize ); CombOS.resize( nSize ); CombUS.resize( nSize ); ModelOutput.resize( 23 ); // set screen product streams to correct dimension Oversize->SetConfig( Config ); Undersize->SetConfig( Config ); // extract sieve sizes Sizes = Config->GetSizes(); // unpack parameters from ParamVec Apperture = ParamVec[ 0]; Length = ParamVec[ 1]; Width = ParamVec[ 2]; Angle = ParamVec[ 3]; OpenFraction = ParamVec[ 4]; BulkDensity = ParamVec[ 5]; WetScreening = (int) ParamVec[ 6]; AppertureShape = (int) ParamVec[ 7]; MediaType = (int) ParamVec[ 8]; DeckLocation = (int) ParamVec[ 9]; GravelCorrection = (int) ParamVec[10]; CustomAreaFactor = ParamVec[11]; WaterSplitToUS = ParamVec[12]; S = Apperture; AF = Length * Width; OA = OpenFraction; F = BulkDensity; WS = WetScreening; OT = AppertureShape; ST = MediaType; DL = DeckLocation; FT = GravelCorrection; CF = CustomAreaFactor; WR = WaterSplitToUS; // indicate success return true; initFailed: // initialization failed - set default values nSize = 0; nType = 0; // etc // indicate failure return false; }
Matrix::Matrix(const VectorView &elements, long int nrow) : Matrix(elements.cbegin(), elements.cend(), nrow, elements.size() / nrow) { }
//====================================================================== void ArStateModel::simulate_state_error(RNG &rng, VectorView eta, int t) const { assert(eta.size() == state_dimension()); eta = 0; eta[0] = rnorm_mt(rng) * sigma(); }
static void BlockHessenberg( MatrixView<T> A, VectorView<T> Ubeta) { // Much like the block version of Bidiagonalize, we try to maintain // the operation of several successive Householder matrices in // a block form, where the net Block Householder is I - YZYt. // // But as with the bidiagonlization algorithm (and unlike a simple // block QR decomposition), we update the matrix from both the left // and the right, so we also need to keep track of the product // ZYtm in addition. // // The block update at the end of the block loop is // m' = (I-YZYt) m (I-YZtYt) // // The Y matrix is stored in the first K columns of m, // and the Hessenberg portion of these columns is updated as we go. // For the right-hand-side update, m -= mYZtYt, the m on the right // needs to be the full original matrix m, including the original // versions of these K columns. Therefore, we can't wait until // the end for this calculation. // // Instead, we keep track of mYZt as we progress, so the final update // is: // // m' = (I-YZYt) (m - mYZt Y) // // We also need to do this same calculation for each column as we // progress through the block. // const ptrdiff_t N = A.rowsize(); #ifdef XDEBUG Matrix<T> A0(A); #endif TMVAssert(A.rowsize() == A.colsize()); TMVAssert(N > 0); TMVAssert(Ubeta.size() == N-1); TMVAssert(!Ubeta.isconj()); TMVAssert(Ubeta.step()==1); ptrdiff_t ncolmax = MIN(HESS_BLOCKSIZE,N-1); Matrix<T,RowMajor> mYZt_full(N,ncolmax); UpperTriMatrix<T,NonUnitDiag|ColMajor> Z_full(ncolmax); T det(0); // Ignore Householder Determinant calculations T* Uj = Ubeta.ptr(); for(ptrdiff_t j1=0;j1<N-1;) { ptrdiff_t j2 = MIN(N-1,j1+HESS_BLOCKSIZE); ptrdiff_t ncols = j2-j1; MatrixView<T> mYZt = mYZt_full.subMatrix(0,N-j1,0,ncols); UpperTriMatrixView<T> Z = Z_full.subTriMatrix(0,ncols); for(ptrdiff_t j=j1,jj=0;j<j2;++j,++jj,++Uj) { // jj = j-j1 // Update current column of A // // m' = (I - YZYt) (m - mYZt Yt) // A(0:N,j)' = A(0:N,j) - mYZt(0:N,0:j) Y(j,0:j)t A.col(j,j1+1,N) -= mYZt.Cols(0,j) * A.row(j,0,j).Conjugate(); // // A(0:N,j)'' = A(0:N,j) - Y Z Yt A(0:N,j)' // // Let Y = (L) where L is unit-diagonal, lower-triangular, // (M) and M is rectangular // LowerTriMatrixView<T> L = LowerTriMatrixViewOf(A.subMatrix(j1+1,j+1,j1,j),UnitDiag); MatrixView<T> M = A.subMatrix(j+1,N,j1,j); // Use the last column of Z as temporary storage for Yt A(0:N,j)' VectorView<T> YtAj = Z.col(jj,0,jj); YtAj = L.adjoint() * A.col(j,j1+1,j+1); YtAj += M.adjoint() * A.col(j,j+1,N); YtAj = Z.subTriMatrix(0,jj) * YtAj; A.col(j,j1+1,j+1) -= L * YtAj; A.col(j,j+1,N) -= M * YtAj; // Do the Householder reflection VectorView<T> u = A.col(j,j+1,N); T bu = Householder_Reflect(u,det); #ifdef TMVFLDEBUG TMVAssert(Uj >= Ubeta._first); TMVAssert(Uj < Ubeta._last); #endif *Uj = bu; // Save the top of the u vector, which isn't actually part of u T& Atemp = *u.cptr(); TMVAssert(IMAG(Atemp) == RealType(T)(0)); RealType(T) Aorig = REAL(Atemp); Atemp = RealType(T)(1); // Update Z VectorView<T> Zj = Z.col(jj,0,jj); Zj = -bu * M.adjoint() * u; Zj = Z * Zj; Z(jj,jj) = -bu; // Update mYtZt: // // mYZt(0:N,j) = m(0:N,0:N) Y(0:N,0:j) Zt(0:j,j) // = m(0:N,j+1:N) Y(j+1:N,j) Zt(j,j) // = bu* m(0:N,j+1:N) u // mYZt.col(jj) = CONJ(bu) * A.subMatrix(j1,N,j+1,N) * u; // Restore Aorig, which is actually part of the Hessenberg matrix. Atemp = Aorig; } // Update the rest of the matrix: // A(j2,j2-1) needs to be temporarily changed to 1 for use in Y T& Atemp = *(A.ptr() + j2*A.stepi() + (j2-1)*A.stepj()); TMVAssert(IMAG(Atemp) == RealType(T)(0)); RealType(T) Aorig = Atemp; Atemp = RealType(T)(1); // m' = (I-YZYt) (m - mYZt Y) MatrixView<T> m = A.subMatrix(j1,N,j2,N); ConstMatrixView<T> Y = A.subMatrix(j2+1,N,j1,j2); m -= mYZt * Y.adjoint(); BlockHouseholder_LMult(Y,Z,m); // Restore A(j2,j2-1) Atemp = Aorig; j1 = j2; } #ifdef XDEBUG Matrix<T> U(N,N,T(0)); U.subMatrix(1,N,1,N) = A.subMatrix(1,N,0,N-1); U.upperTri().setZero(); U(0,0) = T(1); Vector<T> Ubeta2(N); Ubeta2.subVector(1,N) = Ubeta; Ubeta2(0) = T(0); GetQFromQR(U.view(),Ubeta2); Matrix<T> H = A; if (N>2) LowerTriMatrixViewOf(H).offDiag(2).setZero(); Matrix<T> AA = U*H*U.adjoint(); if (Norm(A0-AA) > 0.001*Norm(A0)) { cerr<<"NonBlock Hessenberg: A = "<<Type(A)<<" "<<A0<<endl; cerr<<"A = "<<A<<endl; cerr<<"Ubeta = "<<Ubeta<<endl; cerr<<"U = "<<U<<endl; cerr<<"H = "<<H<<endl; cerr<<"UHUt = "<<AA<<endl; Matrix<T,ColMajor> A2 = A0; Vector<T> Ub2(Ubeta.size()); NonBlockHessenberg(A2.view(),Ub2.view()); cerr<<"cf NonBlock: A -> "<<A2<<endl; cerr<<"Ubeta = "<<Ub2<<endl; abort(); } #endif }
bool CubicSpline::SetSpline( VectorView& X, VectorView& Y, bool logX, bool logY ) { int i,k; double p,sig; // determine element count N_ = X.size(); // test that X and Y same size if( N_ < 2 || N_ > 100 || N_ != Y.size() ) goto initFailed; // dimension structures for N elements X_.resize( N_ ); Y_.resize( N_ ); Y2_.resize( N_ ); // put values into local X_ and Y_ vectors if( X[N_-1] < X[0] ) { // Case 1: X_ values descending X_ = X.reverse(); Y_ = Y.reverse(); } else { // Caes 2: X_ values ascending X_ = X; Y_ = Y; } // convert X axis to its log if required if( logX ) { logX_ = true; if( !X_.setLog() ) goto initFailed; } // convert Y axis to its log if required if( logY ) { logY_ = true; if( !Y_.setLog() ) goto initFailed; } // use natural spline at boundaries Y2_[0] = u[0] = 0; Y2_[N_-1] = u[N_-1] = 0; // decomposition loop - tri-diagonal algorithm for( i=1; i<(N_-1); i++ ) { sig = ( X_[i] - X_[i-1] ) / ( X_[i+1] - X_[i-1] ); p = sig * Y2_[i-1] + 2.0; Y2_[i] = ( sig - 1.0 ) / p; u[i] = ( Y_[i+1] - Y_[i] ) / ( X_[i+1] - X_[i] ) - ( Y_[i] - Y_[i-1] ) / ( X_[i] - X_[i-1] ); u[i] = ( ( 6.0 * u[i] ) / ( X_[i+1] - X_[i-1] ) - sig * u[i-1] ) / p; } // backsubstitition loop - tri-diagonal algorithm for( k = N_-2; k >= 0; k -- ) { Y2_[k] = Y2_[k] * Y2_[k+1] + u[k]; } // SetSpline succeeded return true; initFailed: // Set empty state SetEmpty( ); // SetSpline failed return false; }
void DRSM::simulate_state_error(RNG &rng, VectorView eta, int t) const { check_size(eta.size()); for (int i = 0; i < eta.size(); ++i) { eta[i] = rnorm_mt(rng, 0, coefficient_transition_model_[i]->sigma()); } }
/**************************************************************************** * * WhitenCrusher1::Intialize( ) * * Configure WhitenCrusher1 model. * ****************************************************************************/ bool WhitenCrusher1::Initialize ( PStreamInfo1 Config, const VectorView& ParamVec ) { // Test object arguments if( Config==0 ) goto initFailed; // Test size of parameter vector if( ParamVec.size() < 26 ) goto initFailed; // Set parameters config_ = Config; CSS = ParamVec[ 0]; LLen = ParamVec[ 1]; ET = ParamVec[ 2]; LHr = ParamVec[ 3]; MotorPower = ParamVec[ 4]; NoLoadPower = ParamVec[ 5]; a0 = ParamVec[ 6]; a1 = ParamVec[ 7]; a2 = ParamVec[ 8]; a3 = ParamVec[ 9]; a4 = ParamVec[10]; b0 = ParamVec[11]; b1 = ParamVec[12]; b2 = ParamVec[13]; b3 = ParamVec[14]; b4 = ParamVec[15]; b5 = ParamVec[16]; c0 = ParamVec[17]; d0 = ParamVec[18]; d1 = ParamVec[19]; d2 = ParamVec[20]; e0 = ParamVec[21]; e1 = ParamVec[22]; f0 = ParamVec[23]; f1 = ParamVec[24]; f2 = ParamVec[25]; // Retrieve stream model dimensions nSize_ = config_->nSize(); nType_ = config_->nType(); // Test that product stream is valid if( Discharge==0 ) goto initFailed; // Configure Discharge stream if( !Discharge->SetConfig(config_) ) goto initFailed; // Resize internal vectors C_.resize( nSize_ ); T10.resize( nType_ ); nomSize_.resize( nSize_ ); Content_.resize( nSize_ ); BreakFeed_.resize( nSize_ ); BreakProd_.resize( nSize_ ); ModelOutput.resize( 11 ); return true; initFailed: return false; }
void DynamicRegressionStateModel::simulate_state_error(VectorView eta, int t)const{ check_size(eta.size()); for (int i = 0; i < eta.size(); ++i) { eta[i] = rnorm(0, coefficient_transition_model_[i]->sigma()); } }
SpdMatrix outer(const VectorView &v){ SpdMatrix ans(v.size(), 0.0); ans.add_outer(v); return ans; }