void test_redux()
{
// the max size cannot be too large, otherwise reduxion operations obviously generate large errors.
int maxsize = (std::min)(100,EIGEN_TEST_MAX_SIZE);
EIGEN_UNUSED_VARIABLE(maxsize);
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( matrixRedux(Matrix<float, 1, 1>()) );
CALL_SUBTEST_1( matrixRedux(Array<float, 1, 1>()) );
CALL_SUBTEST_2( matrixRedux(Matrix2f()) );
CALL_SUBTEST_2( matrixRedux(Array2f()) );
CALL_SUBTEST_3( matrixRedux(Matrix4d()) );
CALL_SUBTEST_3( matrixRedux(Array4d()) );
CALL_SUBTEST_4( matrixRedux(MatrixXcf(internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
CALL_SUBTEST_4( matrixRedux(ArrayXXcf(internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
CALL_SUBTEST_5( matrixRedux(MatrixXd (internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
CALL_SUBTEST_5( matrixRedux(ArrayXXd (internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
CALL_SUBTEST_6( matrixRedux(MatrixXi (internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
CALL_SUBTEST_6( matrixRedux(ArrayXXi (internal::random<int>(1,maxsize), internal::random<int>(1,maxsize))) );
}
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_7( vectorRedux(Vector4f()) );
CALL_SUBTEST_7( vectorRedux(Array4f()) );
CALL_SUBTEST_5( vectorRedux(VectorXd(internal::random<int>(1,maxsize))) );
CALL_SUBTEST_5( vectorRedux(ArrayXd(internal::random<int>(1,maxsize))) );
CALL_SUBTEST_8( vectorRedux(VectorXf(internal::random<int>(1,maxsize))) );
CALL_SUBTEST_8( vectorRedux(ArrayXf(internal::random<int>(1,maxsize))) );
}
}
std::vector<ArrayXd> GoSUM::CModelVariables::samples()
{
if ( mvs.size()<=0 ) throw "GoSUM::CModelVariables::samples error: no model variables";
if ( mvs[0].sampleSize()<=0 ) throw "GoSUM::CModelVariables::samples error: no samples";
int Ssize=mvs[0].sampleSize(),Vsize=mvs.size(),i,j;
std::vector<ArrayXd> S(Ssize,ArrayXd(Vsize));
for ( j=0; j<Ssize; j++ )
for ( i=0; i<Vsize; i++ )
S[j](i)=mvs[i].sampleValue(j);
return S;
}
bool qbd_compute_pi0(const MatrixXd & R,
const MatrixXd & B0,
const MatrixXd & A0,
RowVectorXd & pi0,
const qbd_parms & parms) throw (Exc) {
if(R.rows()!=R.cols())
EXC_PRINT("R had to be square");
if (!check_sizes(A0,R) || !check_sizes(A0,B0))
EXC_PRINT("A0, A1, A2 matrixes have to be square and equal size");
if ((R.minCoeff()<0)&&parms.verbose)
cerr<<"QBD_COMPUTE_PI0: Warning: R has negative coeeficients"<<endl;
SelfAdjointEigenSolver<MatrixXd> eigensolver(R);
if (eigensolver.info() != Success) {
if (parms.verbose)
cerr<<"QBD_COMPUTE_PI0: cannot compute eigenvalues of R"<<endl;
return false;
}
if ((ArrayXd(eigensolver.eigenvalues()).abs().maxCoeff()>1)&&parms.verbose)
cerr<<"QBD_COMPUTE_PI0: Warning: R has spectral radius greater than 1"<<endl;
int n = R.rows();
MatrixXd Id = MatrixXd::Identity(n,n);
VectorXd u(n);
u.setOnes();
MatrixXd M(n,n+1);
M.block(0,0,n,n)= B0+R*A0-Id;
M.block(0,n,n,1)= (Id-R).inverse()*u;
FullPivLU<MatrixXd> lu_decomp(M);
if(lu_decomp.rank()<n) {
if (parms.verbose)
cerr<<"QBD_COMPUTE_PI0: No unique solution"<<endl;
return false;
}
RowVectorXd work(n+1);
work.setZero();
work(n)=1;
MatrixXd W1;
pseudoInverse<MatrixXd>(M,W1);
pi0 = work*W1;
if ((pi0.minCoeff()<0)&&parms.verbose)
cerr<<"QBD_COMPUTE_PI0: Warning: x0 has negative elements"<<endl;
return true;
}
