scnc
/
qmcpack
mirror of https://github.com/QMCPACK/qmcpack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

resolve -Wcomment

This commit is contained in:
Graham Lopez 2019-10-01 12:38:10 -04:00
parent dc6bc2503b
commit 62f5025fa8
2 changed files with 18 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/QMCWaveFunctions/tests/test_einset.cpp
View File

@ -112,9 +112,6 @@ TEST_CASE("Einspline SPO from HDF", "[wavefunction]")
</tmp> \
";
// monoO
//<determinantset type=\"einspline\" href=\"pwscf.pwscf.h5\" tilematrix=\"1 0 0 0 1 0 0 0 1\" twistnum=\"0\" source=\"ion\" meshfactor=\"1.0\" precision=\"float\" size=\"6\"/> \
Libxml2Document doc;
bool okay = doc.parseFromString(particles);
REQUIRE(okay);

105
src/formic/utils/matrix.h
View File

@ -27,13 +27,13 @@ namespace formic {
template<class S> class ColVec;
template<class S> class RowVec;
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## Row and Col Iterators ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief An iterator used for iterating over the elements of a matrix row.
@ -75,45 +75,13 @@ namespace formic {
bool operator==(const RowIterator & other) const { return m_x == other.m_x; }
};
// ///////////////////////////////////////////////////////////////////////////////////////////////////
// /// \brief An iterator used for iterating over the elements of a matrix column.
// ///
// ///////////////////////////////////////////////////////////////////////////////////////////////////
// template<class S> class ColConstIterator {
// private:
// const S * m_x;
// public:
// ColConstIterator(const S * x) : m_x(x) {}
// const S & operator*() const { return *m_x; }
// ColConstIterator & operator++() { m_x += 1; return *this; } // prefix ++
// ColConstIterator & operator--() { m_x -= 1; return *this; } // prefix --
// ColConstIterator operator++(int) { ColConstIterator it(*this); ++(*this); return it; } // postfix ++
// ColConstIterator operator--(int) { ColConstIterator it(*this); --(*this); return it; } // postfix --
// };
//
// ///////////////////////////////////////////////////////////////////////////////////////////////////
// /// \brief An iterator used for iterating over the elements of a matrix column.
// ///
// ///////////////////////////////////////////////////////////////////////////////////////////////////
// template<class S> class ColIterator {
// private:
// S * m_x;
// public:
// ColIterator(S * x) : m_x(x) {}
// S & operator*() const { return *m_x; }
// ColIterator & operator++() { m_x += 1; return *this; } // prefix ++
// ColIterator & operator--() { m_x -= 1; return *this; } // prefix --
// ColIterator operator++(int) { ColIterator it(*this); ++(*this); return it; } // postfix ++
// ColIterator operator--(int) { ColIterator it(*this); --(*this); return it; } // postfix --
// };
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## ConstMatrix class ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief The base class for matrices and vectors. ConstMatrix cannot change the values of
@ -601,13 +569,13 @@ namespace formic {
};
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## Matrix class ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief The base class for matrices and vectors that can modify their elements, which
@ -1105,29 +1073,15 @@ namespace formic {
formic::xaxpy(mat.rows(), a, mat.col_begin(k-j), 1, this->col_begin(k) + i, 1);
}
// !!!!! DEPRECATED! See inv function in ConstMatrix !!!!!!
///// \brief invert the matrix
//formic::Matrix<S> & invert() {
// if ( m_n != m_m )
// throw formic::Exception("cannot invert a non-square matrix");
// if ( this->size() > 0 ) {
// std::vector<int> iwork(2 * m_n);
// formic::Matrix<S> work = this->clone();
// S det;
// formic::matrix_inverse_lu(m_n, det, this->begin(), work->begin(), &iwork(0));
// }
// return *this;
//}
};
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## VectorBase class ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief A class that will be the base for column and row vectors.
@ -1310,13 +1264,13 @@ namespace formic {
};
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## ColVec class ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief A class for column vectors, which are n by 1 matrices that inherit most of their
@ -1504,13 +1458,13 @@ namespace formic {
};
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//############################## ########################################\\
//############################## RowVec class ########################################\\
//############################## ########################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
///////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief A class for column vectors, which are n by 1 matrices that inherit most of their
@ -1679,13 +1633,13 @@ namespace formic {
};
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//########################### ##############################\\
//########################### Some Functions on Matrices ##############################\\
//########################### ##############################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
/// \brief check that the two matrices' dimensions allow them to be used together in matrix matrix multiplication
template<class S> inline void check_dimensions_for_matrix_multiply(const formic::ConstMatrix<S> & m1, const formic::ConstMatrix<S> & m2) {
@ -1761,13 +1715,13 @@ namespace formic {
} // end of namespace formic
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//########################### ################################\\
//########################### Matrix Arithmetic Operators ################################\\
//########################### ################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
/// \brief the unary + operator returns a deep copy of the matrix
template<class S> formic::Matrix<S> formic::ConstMatrix<S>::operator+() const {
@ -1866,37 +1820,14 @@ template<> inline formic::Matrix<std::complex<double> > operator*(const formic::
return retval;
}
//template<class S> inline
//formic::Vector<S> operator*(const formic::ConstMatrix<S> & m1, const formic::Vector<S> & v) {
// if ( m1.cols() != v.size() )
// throw formic::Exception("cannot multiply: dimensions of (%i by %i) matrix and (%i by 1) vector do not match.")
// % m1.rows() % m1.cols() % v.size();
// if ( v.size() == 0 )
// throw formic::Exception("cannot multiply: vector is zero length");
// if ( m1.rows() == 0 )
// throw formic::Exception("cannot multiply: matrix has no rows");
// return formic::Vector<S>(m1.rows()) <<= &( m1 * formic::ConstMatrix<S>(v.size(), 1, &v.at(0)) ).at(0,0);
//}
//template<class S> inline
//formic::Matrix<S> operator*(const formic::Vector<S> & v, const formic::ConstMatrix<S> & m1) {
// if ( m1.rows() != v.size() )
// throw formic::Exception("cannot multiply: dimensions of (1 by %i) vector and (%i by %i) matrix do not match.")
// % v.size() % m1.rows() % m1.cols();
// if ( v.size() == 0 )
// throw formic::Exception("cannot multiply: vector is zero length");
// if ( m1.cols() == 0 )
// throw formic::Exception("cannot multiply: matrix has no columns");
// return formic::Vector<S>(m1.cols()) <<= &( formic::ConstMatrix<S>(1, v.size(), &v.at(0)) * m1 ).at(0,0);
//}
//###############################################################################################\\
/*###############################################################################################\\
//###############################################################################################\\
//########################### ################################\\
//########################### Member Function Definitions ################################\\
//########################### ################################\\
//###############################################################################################\\
//###############################################################################################\\
//###############################################################################################*/
/// \brief return a deep copy of the matrix
template<class S> formic::Matrix<S> formic::ConstMatrix<S>::clone() const {