///Calculate Exp[I*m]
LaGenMatComplex snake::math::expm2(LaGenMatDouble &m)
{
//std::cout<<m<<std::endl;
int dim = m.size(0);
LaGenMatComplex r(dim,dim);
LaGenMatDouble eigvec(dim,dim);
LaGenMatComplex eigvecC(dim,dim);
LaVectorDouble eigval(dim);
LaVectorComplex eigvalim(dim);
eigvec = m;
snake::math::SSMED(eigvec.addr(),dim,eigval.addr());
for(int i = 0;i<dim;i++)
eigvalim(i) = LaComplex(cos(eigval(i)),sin(eigval(i)));
LaGenMatComplex temp(dim,dim);
temp = LaComplex(0,0);
for(int i = 0;i<dim;i++)
temp(i,i) = eigvalim(i);
chop(temp,1e-15);
//std::cout<<temp<<std::endl;
eigvecC = eigvec.to_LaGenMatComplex();
LaGenMatComplex tempx(dim,dim);
Blas_Mat_Mat_Trans_Mult(temp,eigvecC,tempx);
Blas_Mat_Mat_Mult(eigvecC,tempx,r);
chop(r,1e-15);
return r;
}
void ClassicalScaling::run( PointWiseMapping* mymap ){
// Retrieve the distances from the dimensionality reduction object
double half=(-0.5); Matrix<double> distances( half*mymap->modifyDmat() );
// Apply centering transtion
unsigned n=distances.nrows(); double sum;
// First HM
for(unsigned i=0;i<n;++i){
sum=0; for(unsigned j=0;j<n;++j) sum+=distances(i,j);
for(unsigned j=0;j<n;++j) distances(i,j) -= sum/n;
}
// Now (HM)H
for(unsigned i=0;i<n;++i){
sum=0; for(unsigned j=0;j<n;++j) sum+=distances(j,i);
for(unsigned j=0;j<n;++j) distances(j,i) -= sum/n;
}
// Diagonalize matrix
std::vector<double> eigval(n); Matrix<double> eigvec(n,n);
diagMat( distances, eigval, eigvec );
// Pass final projections to map object
for(unsigned i=0;i<n;++i){
for(unsigned j=0;j<mymap->getNumberOfProperties();++j) mymap->setProjectionCoordinate( i, j, sqrt(eigval[n-1-j])*eigvec(n-1-j,i) );
}
}
int main(int argc, char *argv[]) {
std::string library_routine(rokko::serial_dense_solver::default_solver());
std::string library, routine;
unsigned int dim = 10;
if (argc >= 2) library_routine = argv[1];
if (argc >= 3) dim = boost::lexical_cast<int>(argv[2]);
rokko::split_solver_name(library_routine, library, routine);
std::cout.precision(5);
std::cout << "Eigenvalue decomposition of Frank matrix" << std::endl
<< "library:routine = " << library_routine << std::endl
<< "library = " << library << std::endl
<< "routine = " << routine << std::endl
<< "dimension = " << dim << std::endl;
rokko::serial_dense_solver solver(library);
solver.initialize(argc, argv);
rokko::localized_matrix<double, matrix_major> mat(dim, dim);
rokko::frank_matrix::generate(mat);
std::cout << "Frank matrix:\n" << mat << std::endl;
rokko::localized_vector<double> eigval(dim);
rokko::localized_matrix<double, matrix_major> eigvec(dim, dim);
rokko::parameters params;
params.set("upper_value", 1.2);
params.set("lower_value", 0.1);
//params.set("upper_index", 5);
//params.set("lower_index", 3);
params.set("uplow", 'L');
//params.set("uplow", 'lower');
params.set("verbose", true);
try {
default_diagonalize(mat, eigval, eigvec, params);
//default_diagonalize(mat, eigval, params);
}
catch (const char *e) {
std::cout << "Exception : " << e << std::endl;
exit(22);
}
rokko::frank_matrix::generate(mat);
bool sorted = true;
for (unsigned int i = 1; i < dim; ++i) sorted &= (eigval(i-1) <= eigval(i));
if (!sorted) std::cout << "Warning: eigenvalues are not sorted in ascending order!\n";
std::cout << "eigenvalues:\n" << eigval.transpose() << std::endl
<< "eigvectors:\n" << eigvec << std::endl;
std::cout << "orthogonality of eigenvectors:" << std::endl
<< eigvec.transpose() * eigvec << std::endl;
std::cout << "residual of the smallest eigenvalue/vector (A x - lambda x):" << std::endl
<< (mat * eigvec.col(0) - eigval(0) * eigvec.col(0)).transpose() << std::endl;
solver.finalize();
}
int main () {
// Define symmetric matrix
PLMD::Matrix<double> mat1(3,3); PLMD::OFile out; out.open("output");
mat1(0,0)=1.0; mat1(0,1)=0.2; mat1(0,2)=0.3;
mat1(1,0)=0.2; mat1(1,1)=0.2; mat1(1,2)=0.6;
mat1(2,0)=0.3; mat1(2,1)=0.6; mat1(2,2)=0.4;
// Test diagonalize
std::vector<double> eigval(3); PLMD::Matrix<double> eigvec(3,3);
diagMat( mat1, eigval, eigvec );
out<<"Eigenvalues "<<eigval[0]<<" "<<eigval[1]<<" "<<eigval[2]<<"\n";
out<<"Eigenvectors : \n";
for(unsigned i=0;i<3;++i){
out<<eigvec(i,0)<<" "<<eigvec(i,1)<<" "<<eigvec(i,2)<<"\n";
}
// Test inverse
out<<"Inverse : \n";
PLMD::Matrix<double> inverse(3,3); Invert( mat1, inverse );
for(unsigned i=0;i<3;++i){
for(unsigned j=0;j<3;++j) out<<inverse(i,j)<<" ";
out<<"\n";
}
// Test pseudoinverse
out<<"Pseudoinverse : \n";
PLMD::Matrix<double> mat(3,2);
mat(0,0)=0.1; mat(0,1)=0.2;
mat(1,0)=0.3; mat(1,1)=0.5;
mat(2,0)=0.4; mat(2,1)=0.6;
PLMD::Matrix<double> pseu(2,3);
pseudoInvert( mat, pseu );
for(unsigned i=0;i<pseu.nrows();++i){
for(unsigned j=0;j<pseu.ncols();++j) out<<" "<<pseu(i,j);
out<<"\n";
}
out.close();
return 0;
}
arma::rowvec rmvnormx(arma::mat R, arma::rowvec Z){
Rcpp::RNGScope scope;
int m = R.n_rows;
arma::vec eigval(m);
arma::mat eigvec(m, m);
arma::mat temp(m, m);
arma::eig_sym(eigval, eigvec, R);
arma::rowvec ans(m);
temp = ( eigvec * arma::diagmat( arma::sqrt( eigval ) ) * arma::inv( eigvec ) );
ans = Z * temp;
return ans;
}
void SqMat<dcmplx>::diagonalize(size_t il, size_t ir, SqMat<dcmplx> &sqmat, Vector<dreal> &eigval)
{
assert(il <= ir);
assert(ir < sqmat.size());
size_t m = ir - il + 1;
eigval.resize(m);
SqMat<dcmplx> eigvec(sqmat.size(), m);
lapack::zheevr(sqmat.size(), 0, 0, il+1, ir+1, sqmat.data(), eigval.data(), eigvec.data());
for(size_t i = il; i <= ir; ++i)
for(size_t j = 0; j < sqmat.size(); ++j)
sqmat.at(j, i) = eigvec.at(j, i);
}
int main(int argc, char *argv[]) {
std::string solver_name(rokko::serial_dense_solver::default_solver());
std::string lattice_file("xyz.dat");
if (argc >= 2) solver_name = argv[1];
if (argc >= 3) lattice_file = argv[2];
std::cout.precision(5);
int num_sites;
std::vector<std::pair<int, int> > lattice;
std::vector<boost::tuple<double, double, double> > coupling;
rokko::read_lattice_file(lattice_file, num_sites, lattice, coupling);
int dim = 1 << num_sites;
rokko::serial_dense_solver solver(solver_name);
solver.initialize(argc, argv);
std::cout << "Eigenvalue decomposition of XYZ model" << std::endl
<< "solver = " << solver_name << std::endl
<< "lattice file = " << lattice_file << std::endl
<< "number of sites = " << num_sites << std::endl
<< "number of bonds = " << lattice.size() << std::endl
<< "matrix dimension = " << dim << std::endl;
rokko::localized_matrix<double, matrix_major> mat(dim, dim);
rokko::xyz_hamiltonian::generate(num_sites, lattice, coupling, mat);
rokko::localized_vector<double> eigval(dim);
rokko::localized_matrix<double, matrix_major> eigvec(dim, dim);
try {
solver.diagonalize(mat, eigval, eigvec);
}
catch (const char *e) {
std::cout << "Exception : " << e << std::endl;
exit(22);
}
rokko::xyz_hamiltonian::generate(num_sites, lattice, coupling, mat);
std::cout << "smallest eigenvalues:";
for (int i = 0; i < std::min(dim, 10); ++i) std::cout << ' ' << eigval(i);
std::cout << std::endl;
std::cout << "residual of the smallest eigenvalue/vector: |x A x - lambda| = "
<< std::abs(eigvec.col(0).transpose() * mat * eigvec.col(0) - eigval(0))
<< std::endl;
solver.finalize();
}
///Calculate square matrix exponent
LaGenMatDouble snake::math::expm(LaGenMatDouble &m)
{
//std::cout<<m<<std::endl;
int dim = m.size(0);
LaGenMatDouble r(dim,dim);
LaGenMatDouble eigvec(dim,dim);
LaVectorDouble eigval(dim);
eigvec = m;
snake::math::SSMED(eigvec.addr(),dim,eigval.addr());
for(int i = 0;i<dim;i++)
eigval(i) = exp(eigval(i));
LaGenMatDouble temp(dim,dim);
temp = temp.from_diag(eigval);
//std::cout<<temp<<std::endl;
Blas_Mat_Mat_Trans_Mult(temp,eigvec,m);
Blas_Mat_Mat_Mult(eigvec,m,r);
chop(r,1e-15);
return r;
}
void pca::solve() {
assert_num_vars_();
printf("%i", num_records_);
if (num_records_ < 2)
throw std::logic_error("Number of records smaller than two.");
data_.resize(num_records_, num_vars_);
mean_ = utils::compute_column_means(data_);
//mean_ = utils::compute_column_means(data_, w_);
utils::remove_column_means(data_, mean_);
mean_.print();
sigma_ = utils::compute_column_rms(data_);
if (do_normalize_) utils::normalize_by_column(data_, sigma_);
arma::Col<double> eigval(num_vars_);
arma::Mat<double> eigvec(num_vars_, num_vars_);
arma::Mat<double> cov_mat = utils::make_covariance_matrix(data_);
arma::eig_sym(eigval, eigvec, cov_mat, solver_.c_str());
arma::uvec indices = arma::sort_index(eigval, 1);
for (long i=0; i<num_vars_; ++i) {
eigval_(i) = eigval(indices(i));
eigvec_.col(i) = eigvec.col(indices(i));
}
utils::enforce_positive_sign_by_column(eigvec_);
proj_eigvec_ = eigvec_;
proj_eigvec_.print();
princomp_ = data_ * eigvec_;
energy_(0) = arma::sum(eigval_);
eigval_ *= 1./energy_(0);
if (do_bootstrap_) bootstrap_eigenvalues_();
}
int main(int argc, char *argv[]) {
int provided;
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm comm = MPI_COMM_WORLD;
std::string solver_name(rokko::parallel_dense_solver::default_solver());
int L = 8;
if (argc >= 2) solver_name = argv[1];
if (argc >= 3) L = boost::lexical_cast<int>(argv[2]);
rokko::grid g(comm);
int myrank = g.get_myrank();
std::cout.precision(5);
int dim = 1 << L;
std::vector<std::pair<int, int> > lattice;
for (int i = 0; i < L; ++i) {
lattice.push_back(std::make_pair(i, (i+1) % L));
}
rokko::parallel_dense_solver solver(solver_name);
solver.initialize(argc, argv);
if (myrank == 0)
std::cout << "Eigenvalue decomposition of antiferromagnetic Heisenberg chain" << std::endl
<< "num_procs = " << g.get_nprocs() << std::endl
#ifdef _OPENMP
<< "num_threads per process = " << omp_get_max_threads() << std::endl
#endif
<< "solver = " << solver_name << std::endl
<< "L = " << L << std::endl
<< "dimension = " << dim << std::endl;
rokko::distributed_matrix<double, matrix_major> mat(dim, dim, g, solver);
rokko::heisenberg_hamiltonian::generate(L, lattice, mat);
rokko::localized_matrix<double, matrix_major> mat_loc(dim, dim);
rokko::gather(mat, mat_loc, 0);
rokko::localized_vector<double> eigval(dim);
rokko::distributed_matrix<double, matrix_major> eigvec(dim, dim, g, solver);
try {
solver.diagonalize(mat, eigval, eigvec);
}
catch (const char *e) {
if (myrank == 0) std::cout << "Exception : " << e << std::endl;
MPI_Abort(MPI_COMM_WORLD, 22);
}
rokko::localized_matrix<double, matrix_major> eigvec_loc(dim, dim);
rokko::gather(eigvec, eigvec_loc, 0);
if (myrank == 0) {
std::cout << "smallest eigenvalues:";
for (int i = 0; i < std::min(dim, 10); ++i) std::cout << ' ' << eigval(i);
std::cout << std::endl;
std::cout << "residual of the smallest eigenvalue/vector: |x A x - lambda| = "
<< std::abs(eigvec_loc.col(0).transpose() * mat_loc * eigvec_loc.col(0) - eigval(0))
<< std::endl;
}
solver.finalize();
MPI_Finalize();
}
void
ComputeSmearedCrackingStress::computeCrackStrainAndOrientation(
RealVectorValue & strain_in_crack_dir)
{
// The rotation tensor is ordered such that directions for pre-existing cracks appear first
// in the list of columns. For example, if there is one existing crack, its direction is in the
// first column in the rotation tensor.
const unsigned int num_known_dirs = getNumKnownCrackDirs();
if (num_known_dirs == 0)
{
std::vector<Real> eigval(3, 0.0);
RankTwoTensor eigvec;
_elastic_strain[_qp].symmetricEigenvaluesEigenvectors(eigval, eigvec);
// If the elastic strain is beyond the cracking strain, save the eigen vectors as
// the rotation tensor. Reverse their order so that the third principal strain
// (most tensile) will correspond to the first crack.
_crack_rotation[_qp].fillColumn(0, eigvec.column(2));
_crack_rotation[_qp].fillColumn(1, eigvec.column(1));
_crack_rotation[_qp].fillColumn(2, eigvec.column(0));
strain_in_crack_dir(0) = eigval[2];
strain_in_crack_dir(1) = eigval[1];
strain_in_crack_dir(2) = eigval[0];
}
else if (num_known_dirs == 1)
{
// This is easily the most complicated case.
// 1. Rotate the elastic strain to the orientation associated with the known
// crack.
// 2. Extract the lower 2x2 block into a separate tensor.
// 3. Run the eigen solver on the result.
// 4. Update the rotation tensor to reflect the effect of the 2 eigenvectors.
// 1.
const RankTwoTensor & R = _crack_rotation[_qp];
RankTwoTensor ePrime(_elastic_strain[_qp]);
ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
// 2.
ColumnMajorMatrix e2x2(2, 2);
e2x2(0, 0) = ePrime(1, 1);
e2x2(1, 0) = ePrime(2, 1);
e2x2(0, 1) = ePrime(1, 2);
e2x2(1, 1) = ePrime(2, 2);
// 3.
ColumnMajorMatrix e_val2x1(2, 1);
ColumnMajorMatrix e_vec2x2(2, 2);
e2x2.eigen(e_val2x1, e_vec2x2);
// 4.
RankTwoTensor eigvec(
1.0, 0.0, 0.0, 0.0, e_vec2x2(0, 1), e_vec2x2(1, 1), 0.0, e_vec2x2(0, 0), e_vec2x2(1, 0));
_crack_rotation[_qp] = _crack_rotation_old[_qp] * eigvec; // Roe implementation
strain_in_crack_dir(0) = ePrime(0, 0);
strain_in_crack_dir(1) = e_val2x1(1, 0);
strain_in_crack_dir(2) = e_val2x1(0, 0);
}
else if (num_known_dirs == 2 || num_known_dirs == 3)
{
// Rotate to cracked orientation and pick off the strains in the rotated
// coordinate directions.
const RankTwoTensor & R = _crack_rotation[_qp];
RankTwoTensor ePrime(_elastic_strain[_qp]);
ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
strain_in_crack_dir(0) = ePrime(0, 0);
strain_in_crack_dir(1) = ePrime(1, 1);
strain_in_crack_dir(2) = ePrime(2, 2);
}
else
mooseError("Invalid number of known crack directions");
}
