/**
* Compute the weighted 2-norm of 'step'.
*/
doublereal MultiNewton::norm2(const doublereal* x,
const doublereal* step, OneDim& r) const {
doublereal f, sum = 0.0;//, fmx = 0.0;
size_t nd = r.nDomains();
for (size_t n = 0; n < nd; n++) {
f = norm_square(x + r.start(n), step + r.start(n),
r.domain(n));
sum += f;
}
sum /= r.size();
return sqrt(sum);
}
TEST(FastUpdate, BlockMatrixAdd)
{
typedef double Scalar;
typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> matrix_t;
std::vector<size_t> N_list, M_list;
N_list.push_back(0);
N_list.push_back(10);
N_list.push_back(2);
M_list.push_back(10);
M_list.push_back(20);
M_list.push_back(4);
for (size_t n=0; n<N_list.size(); ++n) {
for (size_t m=0; m<M_list.size(); ++m) {
const size_t N = N_list[n];
const size_t M = M_list[m];
matrix_t A(N,N), B(N,M), C(M,N), D(M,M);
matrix_t E(N,N), F(N,M), G(M,N), H(M,M);
alps::ResizableMatrix<Scalar> invA(N,N), BigMatrix(N+M, N+M, 0);//, invBigMatrix2(N+M, N+M, 0);
randomize_matrix(A, 100);//100 is a seed
randomize_matrix(B, 200);
randomize_matrix(C, 300);
randomize_matrix(D, 400);
if (N>0) {
invA = A.inverse();
} else {
invA.destructive_resize(0,0);
}
copy_block(A,0,0,BigMatrix,0,0,N,N);
copy_block(B,0,0,BigMatrix,0,N,N,M);
copy_block(C,0,0,BigMatrix,N,0,M,N);
copy_block(D,0,0,BigMatrix,N,N,M,M);
const Scalar det_rat = compute_det_ratio_up<Scalar>(B, C, D, invA);
ASSERT_TRUE(std::abs(det_rat-determinant(BigMatrix)/A.determinant())<1E-8)
<< "N=" << N << " M=" << M << " " << std::abs(det_rat-determinant(BigMatrix)) << "/" << std::abs(det_rat)<<"="
<< std::abs(det_rat-determinant(BigMatrix)/A.determinant());
const Scalar det_rat2 = compute_inverse_matrix_up(B, C, D, invA);
ASSERT_TRUE(std::abs(det_rat-det_rat2)<1E-8) << "N=" << N << " M=" << M;
ASSERT_TRUE(norm_square(inverse(BigMatrix)-invA)<1E-8) << "N=" << N << " M=" << M;
}
}
}