tuple<Matrix, typename make_triangular_matrix<Matrix, boost::numeric::ublas::upper>::type>
QR_decomposition(Matrix Q, InnerProduct inner_prod)
{
assert(Q.size1() == Q.size2());
typename make_triangular_matrix<Matrix, boost::numeric::ublas::upper>::type
R(Q.size1(), Q.size2());
for(size_t i = 0; i != Q.size2(); ++ i)
{
auto qi = column(Q, i);
for(size_t j = 0; j != i; ++ j)
{
auto qj = column(Q, j);
R(j, i) = inner_prod(qi, qj);
qi -= R(j, i) * qj;
}
R(i, i) = norm_2(qi);
assert(R(i, i) != 0);
qi /= R(i, i);
}
return std::make_tuple(std::move(Q), std::move(R));
}
TEST_F(DataFixture,Matrix_Log)
{
Matrix m(3,3);
Matrix n(3,3);
for (unsigned i = 0; i < m.size1(); ++i){
for (unsigned j = 0; j < m.size2(); ++j){
m(i,j) = std::pow(10.0, (double)(i+j));
n(i,j) = std::exp((double)(i+j));
}
}
Matrix logM = openstudio::log(m, 10.0);
Matrix logN = openstudio::log(n);
ASSERT_EQ(m.size1(), logM.size1());
ASSERT_EQ(m.size2(), logM.size2());
ASSERT_EQ(n.size1(), logN.size1());
ASSERT_EQ(n.size2(), logN.size2());
for (unsigned i = 0; i < m.size1(); ++i){
for (unsigned j = 0; j < m.size2(); ++j){
EXPECT_DOUBLE_EQ((double)(i+j), logM(i,j));
EXPECT_DOUBLE_EQ((double)(i+j), logN(i,j));
}
}
}
Matrix Matdiff(const Matrix& mat, int dim)
{
Matrix out = ZMatrix(mat.size1(), mat.size2());
if(dim == 1)
{
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
out(i, j) = mat((i + 1) % mat.size1(), j) - mat(i, j);
}
}
}
else if(dim == 2)
{
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
out(i, j) = mat(i, (j + 1) % mat.size2()) - mat(i, j);
}
}
}
return out;
}
/// Compute the exponential of a matrix from a reversible markov chain
Matrix exp(const EigenValues& eigensystem,const vector<double>& D,const double t) {
const int n = D.size();
// Compute D^-a * E * D^a
std::vector<double> DP(n);
std::vector<double> DN(n);
for(int i=0; i<D.size(); i++) {
DP[i] = sqrt(D[i]);
DN[i] = 1.0/DP[i];
}
// compute E = exp(S2)
Matrix E = exp(eigensystem,t);
// Compute D^-a * E * D^a
for(int i=0; i<E.size1(); i++)
for(int j=0; j<E.size2(); j++)
E(i,j) *= DN[i]*DP[j];
for(int i=0; i<E.size1(); i++)
for(int j=0; j<E.size2(); j++) {
assert(E(i,j) >= -1.0e-13);
if (E(i,j)<0)
E(i,j)=0;
}
return E;
}
Matrix gamma_exp(const SMatrix& S,const vector<double>& D,double alpha,double beta) {
const int n = S.size1();
std::vector<double> DP(n);
std::vector<double> DN(n);
for(int i=0; i<D.size(); i++) {
DP[i] = sqrt(D[i]);
DN[i] = 1.0/DP[i];
}
SMatrix S2 = S;
for(int i=0; i<S2.size1(); i++)
for(int j=0; j<=i; j++)
S2(i,j) *= DP[i]*DP[j];
Matrix E = gamma_exp(S2,alpha,beta);
// E = prod(DN,prod<Matrix>(E,DP));
for(int i=0; i<E.size1(); i++)
for(int j=0; j<E.size2(); j++)
E(i,j) *= DN[i]*DP[j];
for(int i=0; i<E.size1(); i++)
for(int j=0; j<E.size2(); j++) {
assert(E(i,j) >= -1.0e-13);
if (E(i,j)<0)
E(i,j)=0;
}
return E;
}
Matrix2 fft2_1D(const Matrix& mat)
{
fftw_complex* data_in;
fftw_complex* fft;
fftw_plan plan_f;
data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * mat.size1() *
mat.size2());
fft = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * mat.size1() *
mat.size2());
plan_f = fftw_plan_dft_1d(mat.size1(), data_in, fft, FFTW_FORWARD,
FFTW_ESTIMATE);
for(int i = 0, k = 0; i < mat.size1(); ++i)
{
data_in[k][0] = mat(i, 0);
data_in[k][1] = 0.0;
k++;
}
/* perform FFT */
fftw_execute(plan_f);
Matrix2 out(mat.size1(), mat.size2());
for(int i = 0, k = 0; i < mat.size1(); ++i)
{
out.real(i, 0) = fft[k][0];
out.imge(i, 0) = fft[k][1];
k++;
}
fftw_destroy_plan(plan_f);
fftw_free(data_in);
fftw_free(fft);
return out;
}
MatrixFloodPlotData::MatrixFloodPlotData(const Matrix& matrix)
: m_xVector(linspace(0, matrix.size1()-1, matrix.size1())),
m_yVector(linspace(0, matrix.size2()-1, matrix.size2())),
m_matrix(matrix),
m_interpMethod(NearestInterp)
{
init();
}
MatrixFloodPlotData::MatrixFloodPlotData(const Matrix& matrix, QwtDoubleInterval colorMapRange)
: m_xVector(linspace(0, matrix.size1()-1, matrix.size1())),
m_yVector(linspace(0, matrix.size2()-1, matrix.size2())),
m_matrix(matrix),
m_interpMethod(NearestInterp)
{
init();
m_colorMapRange = colorMapRange;
}
inline void element_prod_assign(Matrix& M1,const Matrix& M2)
{
assert(M1.size1() == M2.size1());
assert(M1.size2() == M2.size2());
const int size = M1.data().size();
double * __restrict__ m1 = M1.data().begin();
const double * __restrict__ m2 = M2.data().begin();
for(int i=0;i<size;i++)
m1[i] *= m2[i];
}
Matrix padarray(Matrix& pad, Matrix& outSize)
{
Matrix out = ZMatrix(pad.size1() + outSize(0, 0), pad.size2() + outSize(0, 1));
for(int i = 0; i < pad.size1(); ++i)
{
for(int j = 0; j < pad.size2(); ++j)
{
out(i, j) = pad(i, j);
}
}
return out;
}
Matrix Matfloor(const Matrix& mat)
{
Matrix out(mat.size1(), mat.size2());
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
out(i, j) = floor(mat(i, j));
}
}
return out;
}
/// maximum
double maximum(const Matrix& matrix)
{
double max = 0;
if ((matrix.size1() > 0) && (matrix.size2() > 0)) {
max = matrix(0,0);
for (unsigned i = 0; i < matrix.size1(); ++i) {
for (unsigned j = 0; j < matrix.size2(); ++j) {
max = std::max(max, matrix(i,j));
}
}
}
return max;
}
/// minimum
double minimum(const Matrix& matrix)
{
double min = 0;
if ((matrix.size1() > 0) && (matrix.size2() > 0)) {
min = matrix(0,0);
for (unsigned i = 0; i < matrix.size1(); ++i) {
for (unsigned j = 0; j < matrix.size2(); ++j) {
min = std::min(min, matrix(i,j));
}
}
}
return min;
}
Matrix MatPow2(Matrix& mat)
{
Matrix out(mat.size1(), mat.size2());
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
double tmp = mat(i, j);
out(i, j) = tmp * tmp;
}
}
return out;
}
Matrix2 operator/(const Matrix& rhs) const
{
Matrix2 tmp(rhs.size1(), rhs.size2());
for(int i = 0; i < rhs.size1(); ++i)
{
for(int j = 0; j < rhs.size2(); ++j)
{
tmp.imge(i, j) = imge(i, j) / rhs(i, j);
tmp.real(i, j) = real(i, j) / rhs(i, j);
}
}
return tmp;
}
bool isSymmetric (const Matrix &M)
/* Check a Symmetric Matrix really is Square and Symmetric
* The later may be implied by the SymMatrix type
* Implicitly also checks matrix is without IEC 559 NaN values as they are always !=
* Return:
* true iff M is Square and Symmetric and without NaN
*/
{
// Check Square
if (M.size1() != M.size2() ) {
return false;
}
// Check equality of upper and lower
bool bSym = true;
std::size_t size = M.size1();
for (std::size_t r = 0; r < size; ++r) {
for (std::size_t c = 0; c <= r; ++c) {
if( M(r,c) != M(c,r) ) {
bSym = false;
}
}
}
return bSym;
}
void orthonormalize( Matrix& S, Matrix& u ) {
if (S.size1() == 0 || S.size2() == 0) return;
int i, j, k;
int n = S.size1();
Vector eval( n );
Matrix evec( n, n );
u.reset( n, n );
u.set(0);
// diagonalize S, and then calculate 1/sqrt(S).
diagonalize( S, evec, eval);
for(i=0; i<n; i++)
eval[i] = 1.0/sqrt(eval[i]);
double sum;
for(i=0; i<n; i++)
for(j=0; j<n; j++) {
sum = 0;
for(k=0; k<n; k++)
sum += evec(j,k)*eval[k]*evec(i,k);
u(i,j) = sum;
}
}
void zero(Matrix &A) {
for (uint j = 0; j < A.size2(); ++j) {
for (uint i = 0; i < A.size1(); ++i) {
A(i,j) = typename Matrix::value_type(0);
}
}
}
Matrix DruckerPrager::InverseC(Matrix& InvC) {
if (InvC.size1() != 6 || InvC.size2() != 6)
InvC.resize(6, 6);
noalias(InvC) = ZeroMatrix(6, 6);
double lambda = mNU * mE / ((1
+ mNU) * (1 - 2 * mNU));
double mu = mE / (2 * (1 + mNU));
double a = (4 * mu * mu + 4 * mu * lambda) / (8 * mu * mu * mu + 12 * mu
* mu * lambda);
double b = -(2 * mu * lambda) / (8 * mu * mu * mu + 12 * mu * mu * lambda);
InvC(0, 0) = a;
InvC(0, 1) = b;
InvC(0, 2) = b;
InvC(1, 0) = b;
InvC(1, 1) = a;
InvC(1, 2) = b;
InvC(2, 0) = b;
InvC(2, 1) = b;
InvC(2, 2) = a;
InvC(3, 3) = 1 / (2 * mu);
InvC(4, 4) = 1 / (2 * mu);
InvC(5, 5) = 1 / (2 * mu);
return InvC;
}
LUDecomposition::Matrix LUDecomposition::solve (const Matrix& B) const {
BOOST_UBLAS_CHECK((int)B.size1() == m, bad_size("Matrix row dimensions must agree."));
BOOST_UBLAS_CHECK(isNonsingular(), singular("Matrix is singular."));
// Copy right hand side with pivoting
int nx = B.size2();
Matrix X(m,nx);
for (int i = 0; i < m; i++) {
row(X,i) = row(B, piv(i));
}
// Solve L*Y = B(piv,:)
for (int k = 0; k < n; k++) {
for (int i = k+1; i < n; i++) {
for (int j = 0; j < nx; j++) {
X(i,j) -= X(k,j)*LU(i,k);
}
}
}
// Solve U*X = Y;
for (int k = n-1; k >= 0; k--) {
for (int j = 0; j < nx; j++) {
X(k,j) /= LU(k,k);
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < nx; j++) {
X(i,j) -= X(k,j)*LU(i,k);
}
}
}
return X;
}
double FrobeniusNorm(const Matrix& A) {
double norm = 0.;
for(int i = 0; i < (int)A.size1(); i++)
for(int j = 0; j < (int)A.size2(); j++)
norm += pow(A(i, j), 2);
return sqrt(norm);
}
void forceSymmetric (Matrix &M, bool bUpperToLower)
/* Force Matrix Symmetry
* Normally Copies lower triangle to upper or
* upper to lower triangle if specified
*/
{
// Check Square
if (M.size1() != M.size2() ) {
using namespace Bayesian_filter;
Bayes_base::error (Logic_exception ("Matrix is not square"));
}
std::size_t size = M.size1();
if (bUpperToLower)
{
// Copy Lower to Upper
for (std::size_t r = 1; r < size; ++r) {
for (std::size_t c = 0; c < r; ++c) {
M(c,r) = M(r,c);
}
}
}
else
{
// Copy Upper to Lower
for (std::size_t r = 1; r < size; ++r) {
for (std::size_t c = 0; c < r; ++c) {
M(r,c) = M(c,r);
}
}
}
}
TEST_F(DataFixture,Matrix_Prod)
{
Matrix A(3,2);
Matrix B(2,2);
Vector x(2,1);
A(0,0) = 1.0; A(0,1) = 1.0;
A(1,0) = -1.0; A(1,1) = 0.0;
A(2,0) = 0.0; A(2,1) = 2.0;
B(0,0) = 0.0; B(0,1) = 1.0;
B(1,0) = -2.0; B(1,1) = 1.0;
x(0) = 1.0;
x(1) = 0.5;
Matrix C = prod(A,B);
Vector y = prod(B,x);
ASSERT_EQ(A.size1(),C.size1());
ASSERT_EQ(B.size2(),C.size2());
EXPECT_DOUBLE_EQ(-2.0,C(0,0)); EXPECT_DOUBLE_EQ(2.0,C(0,1));
EXPECT_DOUBLE_EQ(0.0,C(1,0)); EXPECT_DOUBLE_EQ(-1.0,C(1,1));
EXPECT_DOUBLE_EQ(-4.0,C(2,0)); EXPECT_DOUBLE_EQ(2.0,C(2,1));
ASSERT_EQ(B.size1(),y.size());
EXPECT_DOUBLE_EQ(0.5,y(0));
EXPECT_DOUBLE_EQ(-1.5,y(1));
}
void PlaneStress::CalculateMaterialResponse( const Vector& StrainVector,
const Matrix& DeformationGradient,
Vector& StressVector,
Matrix& AlgorithmicTangent,
const ProcessInfo& CurrentProcessInfo,
const Properties& props,
const GeometryType& geom,
const Vector& ShapeFunctionsValues,
bool CalculateStresses,
int CalculateTangent,
bool SaveInternalVariables )
{
if(CalculateStresses == true)
{
if(StressVector.size() != 3)
StressVector.resize(3, false);
CalculateStress(StrainVector, StressVector);
}
if(CalculateTangent == 1)
{
if(AlgorithmicTangent.size1() != 3 || AlgorithmicTangent.size2() != 3)
AlgorithmicTangent.resize(3, 3, false);
CalculateConstitutiveMatrix(StrainVector, AlgorithmicTangent);
}
}
bool operator==(const Matrix& lhs, const Matrix& rhs)
{
bool result = false;
if (lhs.size1() == rhs.size1()) {
if (lhs.size2() == rhs.size2()) {
result = true;
for (unsigned i = 0; i < lhs.size1(); ++i) {
for (unsigned j = 0; j < lhs.size2(); ++j) {
if (lhs(i,j) != rhs(i,j)) {
return false;
}
}
}
}
}
return result;
}
void symmeterize(Matrix &A) {
for (uint j = 0; j < A.size2(); ++j) {
for (uint i = j+1; i < A.size1(); ++i) {
A(i,j) += A(j,i);
A(j,i) = A(i,j);
}
}
}
Vector diag(const Matrix& A) {
int N = A.size1();
assert(N == (int)A.size2());
Vector b(N);
for(int i = 0; i < N; i++)
b(i) = A(i, i);
return b;
}
Matrix Matdiffinv(const Matrix& mat, int dim)
{
Matrix out = ZMatrix(mat.size1(), mat.size2());
// if (dim == 1)
// {
// for (int i = 0; i < mat.size1(); ++i)
// {
// for (int j = 0; j < mat.size2(); ++j)
// {
// out(i, j) = mat(i, j) - mat((i + 1) % mat.size1(), j);
// }
// }
// }
// else if (dim == 2)
// {
// for (int i = 0; i < mat.size1(); ++i)
// {
// for (int j = 0; j < mat.size2(); ++j)
// {
// out(i, j) = mat(i, j) - mat(i, (j + 1) % mat.size2());
// }
// }
// }
if(dim == 1)
{
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
out(i, j) = mat((i - 1 + mat.size1()) % mat.size1(), j) - mat(i, j);
}
}
}
else if(dim == 2)
{
for(int i = 0; i < mat.size1(); ++i)
{
for(int j = 0; j < mat.size2(); ++j)
{
out(i, j) = mat(i, (j - 1 + mat.size2()) % mat.size2()) - mat(i, j);
}
}
}
return out;
}
Matrix<double> Matrix<double>::
pinv(const Matrix<double>& A, const string& lsolver,
const Dict& dict) {
if (A.size1()>=A.size2()) {
return solve(mtimes(A.T(), A), A.T(), lsolver, dict);
} else {
return solve(mtimes(A, A.T()), A, lsolver, dict).T();
}
}
Matrix<double> Matrix<double>::
solve(const Matrix<double>& A, const Matrix<double>& b,
const string& lsolver, const Dict& dict) {
Function mysolver = linsol("tmp", lsolver, A.sparsity(), b.size2(), dict);
vector<DM> arg(LINSOL_NUM_IN);
arg.at(LINSOL_A) = A;
arg.at(LINSOL_B) = b;
return mysolver(arg).at(LINSOL_X);
}
