test/product_mmtr.cpp

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2010-2017 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

#include "main.h"

#define CHECK_MMTR(DEST, TRI, OP)                                              \
  {                                                                            \
    ref3 = DEST;                                                               \
    ref2 = ref1 = DEST;                                                        \
    DEST.template triangularView<TRI>() OP;                                    \
    ref1 OP;                                                                   \
    ref2.template triangularView<TRI>() = ref1.template triangularView<TRI>(); \
    VERIFY_IS_APPROX(DEST, ref2);                                              \
                                                                               \
    DEST = ref3;                                                               \
    ref3 = ref2;                                                               \
    ref3.diagonal() = DEST.diagonal();                                         \
    DEST.template triangularView<TRI | ZeroDiag>() OP;                         \
    VERIFY_IS_APPROX(DEST, ref3);                                              \
  }

template <typename Scalar>
void mmtr(int size) {
  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> MatrixColMaj;
  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> MatrixRowMaj;

  DenseIndex othersize = internal::random<DenseIndex>(1, 200);

  MatrixColMaj matc = MatrixColMaj::Zero(size, size);
  MatrixRowMaj matr = MatrixRowMaj::Zero(size, size);
  MatrixColMaj ref1(size, size), ref2(size, size), ref3(size, size);

  MatrixColMaj soc(size, othersize);
  soc.setRandom();
  MatrixColMaj osc(othersize, size);
  osc.setRandom();
  MatrixRowMaj sor(size, othersize);
  sor.setRandom();
  MatrixRowMaj osr(othersize, size);
  osr.setRandom();
  MatrixColMaj sqc(size, size);
  sqc.setRandom();
  MatrixRowMaj sqr(size, size);
  sqr.setRandom();

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

  CHECK_MMTR(matc, Lower, = s * soc * sor.adjoint());
  CHECK_MMTR(matc, Upper, = s * (soc * soc.adjoint()));
  CHECK_MMTR(matr, Lower, = s * soc * soc.adjoint());
  CHECK_MMTR(matr, Upper, = soc * (s * sor.adjoint()));

  CHECK_MMTR(matc, Lower, += s * soc * soc.adjoint());
  CHECK_MMTR(matc, Upper, += s * (soc * sor.transpose()));
  CHECK_MMTR(matr, Lower, += s * sor * soc.adjoint());
  CHECK_MMTR(matr, Upper, += soc * (s * soc.adjoint()));

  CHECK_MMTR(matc, Lower, -= s * soc * soc.adjoint());
  CHECK_MMTR(matc, Upper, -= s * (osc.transpose() * osc.conjugate()));
  CHECK_MMTR(matr, Lower, -= s * soc * soc.adjoint());
  CHECK_MMTR(matr, Upper, -= soc * (s * soc.adjoint()));

  CHECK_MMTR(matc, Lower, -= s * sqr * sqc.template triangularView<Upper>());
  CHECK_MMTR(matc, Upper, = s * sqc * sqr.template triangularView<Upper>());
  CHECK_MMTR(matc, Lower, += s * sqr * sqc.template triangularView<Lower>());
  CHECK_MMTR(matc, Upper, = s * sqc * sqc.template triangularView<Lower>());

  CHECK_MMTR(matc, Lower, = (s * sqr).template triangularView<Upper>() * sqc);
  CHECK_MMTR(matc, Upper, -= (s * sqc).template triangularView<Upper>() * sqc);
  CHECK_MMTR(matc, Lower, = (s * sqr).template triangularView<Lower>() * sqc);
  CHECK_MMTR(matc, Upper, += (s * sqc).template triangularView<Lower>() * sqc);

  // check aliasing
  ref2 = ref1 = matc;
  ref1 = sqc.adjoint() * matc * sqc;
  ref2.template triangularView<Upper>() = ref1.template triangularView<Upper>();
  matc.template triangularView<Upper>() = sqc.adjoint() * matc * sqc;
  VERIFY_IS_APPROX(matc, ref2);

  ref2 = ref1 = matc;
  ref1 = sqc * matc * sqc.adjoint();
  ref2.template triangularView<Lower>() = ref1.template triangularView<Lower>();
  matc.template triangularView<Lower>() = sqc * matc * sqc.adjoint();
  VERIFY_IS_APPROX(matc, ref2);

  // destination with a non-default inner-stride
  // see bug 1741
  {
    typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
    MatrixX buffer(2 * size, 2 * size);
    Map<MatrixColMaj, 0, Stride<Dynamic, Dynamic> > map1(buffer.data(), size, size,
                                                         Stride<Dynamic, Dynamic>(2 * size, 2));
    buffer.setZero();
    CHECK_MMTR(map1, Lower, = s * soc * sor.adjoint());
  }
}

template <typename MatrixType>
void mmtr_empty_product(Index size) {
  typedef typename MatrixType::Scalar Scalar;
  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> LhsType;
  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RhsType;

  LhsType lhs(size, 0);
  RhsType rhs(0, size);

  MatrixType dst = MatrixType::Random(size, size);
  MatrixType ref = dst;

  dst.template triangularView<Lower>() += lhs * rhs;
  VERIFY_IS_APPROX(dst, ref);

  dst.template triangularView<Upper>() -= lhs * rhs;
  VERIFY_IS_APPROX(dst, ref);

  dst.template triangularView<Lower>() = lhs * rhs;
  ref.template triangularView<Lower>().setZero();
  VERIFY_IS_APPROX(dst, ref);

  dst = MatrixType::Random(size, size);
  ref = dst;
  dst.template selfadjointView<Lower>() = lhs * rhs;
  ref.template triangularView<Lower>().setZero();
  VERIFY_IS_APPROX(dst, ref);
}

EIGEN_DECLARE_TEST(product_mmtr) {
  for (int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1((mmtr<float>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
    CALL_SUBTEST_2((mmtr<double>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
    CALL_SUBTEST_3((mmtr<std::complex<float> >(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
    CALL_SUBTEST_4((mmtr<std::complex<double> >(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));

    CALL_SUBTEST_5((mmtr_empty_product<MatrixXd>(48)));
    CALL_SUBTEST_6((mmtr_empty_product<Matrix<double, Dynamic, Dynamic, RowMajor> >(48)));
  }
}