test/selfadjoint.cpp

// This file is triangularView of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// SPDX-License-Identifier: MPL-2.0

#define TEST_CHECK_STATIC_ASSERTIONS
#include "main.h"

// This file tests the basic selfadjointView API,
// the related products and decompositions are tested in specific files.

template <typename MatrixType>
void selfadjoint(const MatrixType& m) {
  typedef typename MatrixType::Scalar Scalar;

  Index rows = m.rows();
  Index cols = m.cols();

  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols), m4(rows, cols);

  m1.diagonal() = m1.diagonal().real().template cast<Scalar>();

  // check selfadjoint to dense
  m3 = m1.template selfadjointView<Upper>();
  VERIFY_IS_APPROX(MatrixType(m3.template triangularView<Upper>()), MatrixType(m1.template triangularView<Upper>()));
  VERIFY_IS_APPROX(m3, m3.adjoint());

  m3 = m1.template selfadjointView<Lower>();
  VERIFY_IS_APPROX(MatrixType(m3.template triangularView<Lower>()), MatrixType(m1.template triangularView<Lower>()));
  VERIFY_IS_APPROX(m3, m3.adjoint());

  m3 = m1.template selfadjointView<Upper>();
  m4 = m2;
  m4 += m1.template selfadjointView<Upper>();
  VERIFY_IS_APPROX(m4, m2 + m3);

  m3 = m1.template selfadjointView<Lower>();
  m4 = m2;
  m4 -= m1.template selfadjointView<Lower>();
  VERIFY_IS_APPROX(m4, m2 - m3);

  Scalar s = internal::random<Scalar>();

  m4 = s * m1.template selfadjointView<Upper>();
  VERIFY_IS_APPROX(m4, MatrixType((s * m1).template selfadjointView<Upper>()));
  m4 = m1.template selfadjointView<Upper>() * s;
  VERIFY_IS_APPROX(m4, MatrixType((m1 * s).template selfadjointView<Upper>()));

  m4 = s * m1.template selfadjointView<Lower>();
  VERIFY_IS_APPROX(m4, MatrixType((s * m1).template selfadjointView<Lower>()));
  m4 = m1.template selfadjointView<Lower>() * s;
  VERIFY_IS_APPROX(m4, MatrixType((m1 * s).template selfadjointView<Lower>()));

  // l1Norm: reads only the stored triangle but must agree with the L1 norm of
  // the materialized full matrix. Upper and Lower views of the same (stored-
  // full) self-adjoint matrix must return the same value; complex scalars
  // behave identically since |conj(x)| = |x|.
  typedef typename NumTraits<Scalar>::Real RealScalar;
  m3 = m1.template selfadjointView<Upper>();  // m3 is now fully self-adjoint
  RealScalar ref_l1 = m3.cwiseAbs().colwise().sum().maxCoeff();
  VERIFY_IS_APPROX(m3.template selfadjointView<Upper>().l1Norm(), ref_l1);
  VERIFY_IS_APPROX(m3.template selfadjointView<Lower>().l1Norm(), ref_l1);
  // Either triangle alone still gives the correct L1 norm even if the other
  // half is zero (the view conjure it back via symmetry).
  MatrixType upperOnly = MatrixType::Zero(rows, cols);
  upperOnly.template triangularView<Upper>() = m3;
  VERIFY_IS_APPROX(upperOnly.template selfadjointView<Upper>().l1Norm(), ref_l1);
  MatrixType lowerOnly = MatrixType::Zero(rows, cols);
  lowerOnly.template triangularView<Lower>() = m3;
  VERIFY_IS_APPROX(lowerOnly.template selfadjointView<Lower>().l1Norm(), ref_l1);
}

// l1Norm accumulates the column sums a panel at a time, so sweep sizes across two panel
// boundaries: a mis-sized segment would otherwise hide between the random sizes above.
template <typename Scalar>
void selfadjoint_l1norm_sizes() {
  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  for (Index n : {Index(0), Index(1), Index(2), Index(63), Index(64), Index(65), Index(127), Index(128), Index(129)}) {
    MatrixType m = MatrixType::Random(n, n);
    MatrixType full = m.template selfadjointView<Lower>();
    RealScalar ref = n == 0 ? RealScalar(0) : full.cwiseAbs().colwise().sum().maxCoeff();
    VERIFY_IS_APPROX(m.template selfadjointView<Lower>().l1Norm(), ref);
    VERIFY_IS_APPROX(full.template selfadjointView<Upper>().l1Norm(), ref);
  }
}

void bug_159() {
  Matrix3d m = Matrix3d::Random().selfadjointView<Lower>();
  EIGEN_UNUSED_VARIABLE(m);
}

EIGEN_DECLARE_TEST(selfadjoint) {
  for (int i = 0; i < g_repeat; i++) {
    int s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);

    CALL_SUBTEST_1(selfadjoint(Matrix<float, 1, 1>()));
    CALL_SUBTEST_2(selfadjoint(Matrix<float, 2, 2>()));
    CALL_SUBTEST_3(selfadjoint(Matrix3cf()));
    CALL_SUBTEST_4(selfadjoint(MatrixXcd(s, s)));
    CALL_SUBTEST_5(selfadjoint(Matrix<float, Dynamic, Dynamic, RowMajor>(s, s)));

    TEST_SET_BUT_UNUSED_VARIABLE(s);
  }

  CALL_SUBTEST_1(bug_159());
  CALL_SUBTEST_4(selfadjoint_l1norm_sizes<double>());
  CALL_SUBTEST_4(selfadjoint_l1norm_sizes<std::complex<double> >());
}