test/vectorwise_norm.cpp - mirror - Git at Google


            
            // SPDX-FileCopyrightText: The Eigen Authors

            
            // SPDX-License-Identifier: MPL-2.0


            #define EIGEN_RUNTIME_NO_MALLOC

            
            #define TEST_ENABLE_TEMPORARY_TRACKING

            
            #include "main.h"

            
            #include <Eigen/Core>

            
            #include "CustomComplex.h"


            template <typename Derived>

            
            void check_vectorwise_norms(const DenseBase<Derived>& input) {

            
              using Real = typename Derived::RealScalar;

            
              const Derived& matrix = input.derived();

            
              const Index rows = matrix.rows();

            
              const Index cols = matrix.cols();

            
              Matrix<Real, 1, Dynamic> columnSquares(cols), columnNorms(cols);

            
              Matrix<Real, Dynamic, 1> rowSquares(rows), rowNorms(rows);


              using ColumnNorm = decltype(matrix.colwise().squaredNorm());

            
              using RowNorm = decltype(matrix.rowwise().squaredNorm());

            
              STATIC_CHECK(ColumnNorm::RowsAtCompileTime == 1);

            
              STATIC_CHECK(int(ColumnNorm::ColsAtCompileTime) == int(Derived::ColsAtCompileTime));

            
              STATIC_CHECK(int(RowNorm::RowsAtCompileTime) == int(Derived::RowsAtCompileTime));

            
              STATIC_CHECK(RowNorm::ColsAtCompileTime == 1);

            
              STATIC_CHECK((internal::is_same<typename internal::traits<ColumnNorm>::XprKind,

            
                                              typename internal::traits<Derived>::XprKind>::value));


              internal::set_is_malloc_allowed(false);

            
              columnSquares = matrix.colwise().squaredNorm();

            
              rowSquares = matrix.rowwise().squaredNorm();

            
              columnNorms = matrix.colwise().norm();

            
              rowNorms = matrix.rowwise().norm();

            
              internal::set_is_malloc_allowed(true);


              for (int direction = 0; direction < 2; ++direction) {

            
                const Index count = direction == 0 ? cols : rows;

            
                const Index length = direction == 0 ? rows : cols;

            
                for (Index k = 0; k < count; ++k) {

            
                  long double reference = 0;

            
                  for (Index i = 0; i < length; ++i) {

            
                    const auto value = direction == 0 ? matrix.coeff(i, k) : matrix.coeff(k, i);

            
                    const long double real = static_cast<long double>(numext::real(value));

            
                    const long double imag = static_cast<long double>(numext::imag(value));

            
                    reference += real * real + imag * imag;

            
                  }

            
                  const Real square = direction == 0 ? columnSquares(k) : rowSquares(k);

            
                  const Real norm = direction == 0 ? columnNorms(k) : rowNorms(k);

            
                  // FMA contraction can round coefficient access and vector reductions differently.

            
                  const Real coefficientSquare =

            
                      direction == 0 ? matrix.colwise().squaredNorm()(k) : matrix.rowwise().squaredNorm()(k);

            
                  const Real vectorSquare =

            
                      direction == 0 ? matrix.col(k).matrix().squaredNorm() : matrix.row(k).matrix().squaredNorm();

            
                  // Two squares and at most two additions per complex coefficient, plus sqrt rounding.

            
                  const long double relativeBound = (4 * length + 4) * static_cast<long double>(NumTraits<Real>::epsilon());

            
                  VERIFY(numext::abs(static_cast<long double>(square) - reference) <= relativeBound * reference);

            
                  VERIFY(numext::abs(static_cast<long double>(coefficientSquare) - reference) <= relativeBound * reference);

            
                  VERIFY(numext::abs(static_cast<long double>(vectorSquare) - reference) <= relativeBound * reference);

            
                  VERIFY(numext::abs(static_cast<long double>(norm) - numext::sqrt(reference)) <=

            
                         relativeBound * numext::sqrt(reference));

            
                }

            
              }

            
            }


            template <typename Derived>

            
            void check_vectorwise_norm_evaluations(const DenseBase<Derived>& input) {

            
              using Scalar = typename Derived::Scalar;

            
              using Real = typename Derived::RealScalar;

            
              Index calls = 0;

            
              const auto expression = input.derived().unaryExpr([&calls](const Scalar& value) {

            
                ++calls;

            
                return value;

            
              });

            
              using Expression = internal::remove_all_t<decltype(expression)>;

            
              STATIC_CHECK((int(internal::evaluator<Expression>::Flags) & (DirectAccessBit | PacketAccessBit)) == 0);

            
              Matrix<Real, 1, Dynamic> columns(input.cols());

            
              Matrix<Real, Dynamic, 1> rows(input.rows());

            
              const Matrix<Real, 1, Dynamic> columnSquares = input.colwise().squaredNorm();

            
              const Matrix<Real, 1, Dynamic> columnNorms = input.colwise().norm();

            
              const Matrix<Real, Dynamic, 1> rowSquares = input.rowwise().squaredNorm();

            
              const Matrix<Real, Dynamic, 1> rowNorms = input.rowwise().norm();

            
              const auto check = [&](const auto& actual, const auto& expected) {

            
                VERIFY_IS_EQUAL(calls, input.size());

            
                VERIFY_IS_APPROX(actual, expected);

            
                calls = 0;

            
              };

            
              internal::set_is_malloc_allowed(false);

            
              columns = expression.colwise().squaredNorm();

            
              check(columns, columnSquares);

            
              columns = expression.colwise().norm();

            
              check(columns, columnNorms);

            
              rows = expression.rowwise().squaredNorm();

            
              check(rows, rowSquares);

            
              rows = expression.rowwise().norm();

            
              check(rows, rowNorms);

            
              internal::set_is_malloc_allowed(true);

            
            }


            template <typename Scalar, int Order>

            
            void vectorwise_norm_layout() {

            
              using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Order>;

            
              using Real = typename NumTraits<Scalar>::Real;

            
              // Only complex scalars with array-oriented access use the shared squaredNorm kernel.

            
              constexpr bool useVectorNorm = NumTraits<Scalar>::IsComplex && internal::complex_array_access<Scalar>::value;

            
              using InnerReduction =

            
                  typename VectorwiseOp<const MatrixType, Order == RowMajor ? Horizontal : Vertical>::SquaredNormReturnType;

            
              using InnerInput = internal::remove_all_t<decltype(std::declval<InnerReduction>().nestedExpression())>;

            
              using InnerScalar = std::conditional_t<useVectorNorm, Scalar, Real>;

            
              STATIC_CHECK((internal::is_same<typename InnerInput::Scalar, InnerScalar>::value));

            
              using OuterReduction =

            
                  typename VectorwiseOp<const MatrixType, Order == RowMajor ? Vertical : Horizontal>::SquaredNormReturnType;

            
              if (!NumTraits<Scalar>::IsComplex) {

            
                VERIFY(bool(internal::evaluator<OuterReduction>::Flags & PacketAccessBit) ==

            
                       bool(internal::evaluator<MatrixType>::Flags & PacketAccessBit));

            
              }


              for (Index rows : {0, 1, 2, 7, 8, 9, 17}) {

            
                for (Index cols : {0, 1, 3, 7, 8, 9, 19}) {

            
                  MatrixType matrix = MatrixType::Random(rows, cols);

            
                  check_vectorwise_norms(matrix);

            
                  check_vectorwise_norms(matrix.array());

            
                  check_vectorwise_norms(matrix.transpose());

            
                  check_vectorwise_norms(matrix + matrix);

            
                }

            
              }


              Matrix<Scalar, 3, 5, Order> fixed = Matrix<Scalar, 3, 5, Order>::Random();

            
              check_vectorwise_norms(fixed);

            
              Matrix<Scalar, Dynamic, Dynamic, Order, 9, 13> bounded(7, 11);

            
              bounded.setRandom();

            
              check_vectorwise_norms(bounded);


              MatrixType storage = MatrixType::Random(23, 29);

            
              check_vectorwise_norms(storage.block(1, 2, 17, 19));

            
              check_vectorwise_norm_evaluations(storage);

            
              check_vectorwise_norm_evaluations(storage.array());

            
              for (Index innerStride : {1, 2, 3}) {

            
                const Index innerSize = Order == RowMajor ? 19 : 17;

            
                const Index outerSize = Order == RowMajor ? 17 : 19;

            
                const Index outerStride = innerSize * innerStride + 5;

            
                Matrix<Scalar, Dynamic, 1> buffer = Matrix<Scalar, Dynamic, 1>::Random(outerSize * outerStride + 1);

            
                Map<const MatrixType, Unaligned, Stride<Dynamic, Dynamic>> strided(

            
                    buffer.data() + 1, 17, 19, Stride<Dynamic, Dynamic>(outerStride, innerStride));

            
                check_vectorwise_norms(strided);

            
              }


              MatrixType matrix = MatrixType::Random(17, 19);

            
              const auto delayed = (matrix + matrix).colwise().squaredNorm();

            
              Matrix<Real, 1, Dynamic> actual = delayed;

            
              VERIFY_IS_APPROX(actual, (matrix + matrix).eval().colwise().squaredNorm());

            
              MatrixType product = matrix.adjoint() * matrix;

            
              Matrix<Real, 1, Dynamic> productNorms(19);

            
              // The abs2 path materializes the product and its squared coefficients.

            
              const int expectedTemporaries = useVectorNorm ? 1 : 2;

            
              VERIFY_EVALUATION_COUNT(productNorms = (matrix.adjoint() * matrix).colwise().squaredNorm(), expectedTemporaries);

            
              VERIFY_IS_APPROX(productNorms, product.colwise().squaredNorm());


              matrix.setZero();

            
              for (Index i = 0; i < matrix.size(); ++i) {

            
                matrix.data()[i] = Scalar(-Real(0));

            
              }

            
              const Matrix<Real, 1, Dynamic> zeros = matrix.colwise().squaredNorm();

            
              for (Index i = 0; i < zeros.size(); ++i) {

            
                VERIFY_IS_EQUAL(zeros(i), Real(0));

            
                VERIFY(!numext::signbit(zeros(i)));

            
              }

            
              matrix(3, 5) = Scalar(NumTraits<Real>::infinity());

            
              VERIFY((numext::isinf)(matrix.colwise().norm()(5)));

            
              VERIFY((numext::isinf)(matrix.rowwise().squaredNorm()(3)));

            
              matrix(3, 5) = Scalar(NumTraits<Real>::quiet_NaN());

            
              VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(5)));

            
              VERIFY((numext::isnan)(matrix.rowwise().norm()(3)));

            
            }


            template <typename Real, int Order>

            
            void vectorwise_norm_mixed_special_values() {

            
              using Scalar = std::complex<Real>;

            
              Matrix<Scalar, Dynamic, Dynamic, Order> matrix = Matrix<Scalar, Dynamic, Dynamic, Order>::Zero(17, 19);

            
              matrix(0, 0) = Scalar(NumTraits<Real>::infinity(), Real(0));

            
              matrix(1, 0) = matrix(0, 1) = Scalar(Real(0), NumTraits<Real>::quiet_NaN());

            
              VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(0)));

            
              VERIFY((numext::isnan)(matrix.colwise().norm()(0)));

            
              VERIFY((numext::isnan)(matrix.rowwise().squaredNorm()(0)));

            
              VERIFY((numext::isnan)(matrix.rowwise().norm()(0)));

            
            }


            EIGEN_DECLARE_TEST(vectorwise_norm) {

            
              for (int i = 0; i < g_repeat; ++i) {

            
                CALL_SUBTEST_1((vectorwise_norm_layout<float, ColMajor>()));

            
                CALL_SUBTEST_2((vectorwise_norm_layout<float, RowMajor>()));

            
                CALL_SUBTEST_3((vectorwise_norm_layout<double, ColMajor>()));

            
                CALL_SUBTEST_4((vectorwise_norm_layout<double, RowMajor>()));

            
                CALL_SUBTEST_5((vectorwise_norm_layout<std::complex<float>, ColMajor>()));

            
                CALL_SUBTEST_6((vectorwise_norm_layout<std::complex<float>, RowMajor>()));

            
                CALL_SUBTEST_7((vectorwise_norm_layout<std::complex<double>, ColMajor>()));

            
                CALL_SUBTEST_8((vectorwise_norm_layout<std::complex<double>, RowMajor>()));

            
                CALL_SUBTEST_5((vectorwise_norm_mixed_special_values<float, ColMajor>()));

            
                CALL_SUBTEST_6((vectorwise_norm_mixed_special_values<float, RowMajor>()));

            
                CALL_SUBTEST_7((vectorwise_norm_mixed_special_values<double, ColMajor>()));

            
                CALL_SUBTEST_8((vectorwise_norm_mixed_special_values<double, RowMajor>()));

            
                CALL_SUBTEST_10((vectorwise_norm_layout<CustomComplex<float>, ColMajor>()));

            
                CALL_SUBTEST_11((vectorwise_norm_layout<CustomComplex<float>, RowMajor>()));

            
                CALL_SUBTEST_12((vectorwise_norm_layout<CustomComplex<double>, ColMajor>()));

            
                CALL_SUBTEST_13((vectorwise_norm_layout<CustomComplex<double>, RowMajor>()));

            
                CALL_SUBTEST_9(([] {

            
                  Matrix<int, 2, 2> integers;

            
                  integers << 3, 0, 4, 5;

            
                  VERIFY_IS_EQUAL(integers.colwise().squaredNorm().eval(), RowVector2i(25, 25));

            
                  VERIFY_IS_EQUAL(integers.transpose().rowwise().squaredNorm().eval(), Vector2i(25, 25));

            
                  Array<bool, 2, 2> flags;

            
                  flags << false, true, true, false;

            
                  VERIFY(flags.colwise().squaredNorm().all());

            
                  VERIFY(flags.rowwise().squaredNorm().all());

            
                  flags.setZero();

            
                  VERIFY(!flags.colwise().squaredNorm().any());

            
                  VERIFY(!flags.rowwise().squaredNorm().any());

            
                }()));

            
              }

            
            }
	// SPDX-FileCopyrightText: The Eigen Authors
	// SPDX-License-Identifier: MPL-2.0

	#define EIGEN_RUNTIME_NO_MALLOC
	#define TEST_ENABLE_TEMPORARY_TRACKING
	#include "main.h"
	#include <Eigen/Core>
	#include "CustomComplex.h"

	template <typename Derived>
	void check_vectorwise_norms(const DenseBase<Derived>& input) {
	using Real = typename Derived::RealScalar;
	const Derived& matrix = input.derived();
	const Index rows = matrix.rows();
	const Index cols = matrix.cols();
	Matrix<Real, 1, Dynamic> columnSquares(cols), columnNorms(cols);
	Matrix<Real, Dynamic, 1> rowSquares(rows), rowNorms(rows);

	using ColumnNorm = decltype(matrix.colwise().squaredNorm());
	using RowNorm = decltype(matrix.rowwise().squaredNorm());
	STATIC_CHECK(ColumnNorm::RowsAtCompileTime == 1);
	STATIC_CHECK(int(ColumnNorm::ColsAtCompileTime) == int(Derived::ColsAtCompileTime));
	STATIC_CHECK(int(RowNorm::RowsAtCompileTime) == int(Derived::RowsAtCompileTime));
	STATIC_CHECK(RowNorm::ColsAtCompileTime == 1);
	STATIC_CHECK((internal::is_same<typename internal::traits<ColumnNorm>::XprKind,
	typename internal::traits<Derived>::XprKind>::value));

	internal::set_is_malloc_allowed(false);
	columnSquares = matrix.colwise().squaredNorm();
	rowSquares = matrix.rowwise().squaredNorm();
	columnNorms = matrix.colwise().norm();
	rowNorms = matrix.rowwise().norm();
	internal::set_is_malloc_allowed(true);

	for (int direction = 0; direction < 2; ++direction) {
	const Index count = direction == 0 ? cols : rows;
	const Index length = direction == 0 ? rows : cols;
	for (Index k = 0; k < count; ++k) {
	long double reference = 0;
	for (Index i = 0; i < length; ++i) {
	const auto value = direction == 0 ? matrix.coeff(i, k) : matrix.coeff(k, i);
	const long double real = static_cast<long double>(numext::real(value));
	const long double imag = static_cast<long double>(numext::imag(value));
	reference += real * real + imag * imag;
	}
	const Real square = direction == 0 ? columnSquares(k) : rowSquares(k);
	const Real norm = direction == 0 ? columnNorms(k) : rowNorms(k);
	// FMA contraction can round coefficient access and vector reductions differently.
	const Real coefficientSquare =
	direction == 0 ? matrix.colwise().squaredNorm()(k) : matrix.rowwise().squaredNorm()(k);
	const Real vectorSquare =
	direction == 0 ? matrix.col(k).matrix().squaredNorm() : matrix.row(k).matrix().squaredNorm();
	// Two squares and at most two additions per complex coefficient, plus sqrt rounding.
	const long double relativeBound = (4 * length + 4) * static_cast<long double>(NumTraits<Real>::epsilon());
	VERIFY(numext::abs(static_cast<long double>(square) - reference) <= relativeBound * reference);
	VERIFY(numext::abs(static_cast<long double>(coefficientSquare) - reference) <= relativeBound * reference);
	VERIFY(numext::abs(static_cast<long double>(vectorSquare) - reference) <= relativeBound * reference);
	VERIFY(numext::abs(static_cast<long double>(norm) - numext::sqrt(reference)) <=
	relativeBound * numext::sqrt(reference));
	}
	}
	}

	template <typename Derived>
	void check_vectorwise_norm_evaluations(const DenseBase<Derived>& input) {
	using Scalar = typename Derived::Scalar;
	using Real = typename Derived::RealScalar;
	Index calls = 0;
	const auto expression = input.derived().unaryExpr([&calls](const Scalar& value) {
	++calls;
	return value;
	});
	using Expression = internal::remove_all_t<decltype(expression)>;
	STATIC_CHECK((int(internal::evaluator<Expression>::Flags) & (DirectAccessBit \| PacketAccessBit)) == 0);
	Matrix<Real, 1, Dynamic> columns(input.cols());
	Matrix<Real, Dynamic, 1> rows(input.rows());
	const Matrix<Real, 1, Dynamic> columnSquares = input.colwise().squaredNorm();
	const Matrix<Real, 1, Dynamic> columnNorms = input.colwise().norm();
	const Matrix<Real, Dynamic, 1> rowSquares = input.rowwise().squaredNorm();
	const Matrix<Real, Dynamic, 1> rowNorms = input.rowwise().norm();
	const auto check = [&](const auto& actual, const auto& expected) {
	VERIFY_IS_EQUAL(calls, input.size());
	VERIFY_IS_APPROX(actual, expected);
	calls = 0;
	};
	internal::set_is_malloc_allowed(false);
	columns = expression.colwise().squaredNorm();
	check(columns, columnSquares);
	columns = expression.colwise().norm();
	check(columns, columnNorms);
	rows = expression.rowwise().squaredNorm();
	check(rows, rowSquares);
	rows = expression.rowwise().norm();
	check(rows, rowNorms);
	internal::set_is_malloc_allowed(true);
	}

	template <typename Scalar, int Order>
	void vectorwise_norm_layout() {
	using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Order>;
	using Real = typename NumTraits<Scalar>::Real;
	// Only complex scalars with array-oriented access use the shared squaredNorm kernel.
	constexpr bool useVectorNorm = NumTraits<Scalar>::IsComplex && internal::complex_array_access<Scalar>::value;
	using InnerReduction =
	typename VectorwiseOp<const MatrixType, Order == RowMajor ? Horizontal : Vertical>::SquaredNormReturnType;
	using InnerInput = internal::remove_all_t<decltype(std::declval<InnerReduction>().nestedExpression())>;
	using InnerScalar = std::conditional_t<useVectorNorm, Scalar, Real>;
	STATIC_CHECK((internal::is_same<typename InnerInput::Scalar, InnerScalar>::value));
	using OuterReduction =
	typename VectorwiseOp<const MatrixType, Order == RowMajor ? Vertical : Horizontal>::SquaredNormReturnType;
	if (!NumTraits<Scalar>::IsComplex) {
	VERIFY(bool(internal::evaluator<OuterReduction>::Flags & PacketAccessBit) ==
	bool(internal::evaluator<MatrixType>::Flags & PacketAccessBit));
	}

	for (Index rows : {0, 1, 2, 7, 8, 9, 17}) {
	for (Index cols : {0, 1, 3, 7, 8, 9, 19}) {
	MatrixType matrix = MatrixType::Random(rows, cols);
	check_vectorwise_norms(matrix);
	check_vectorwise_norms(matrix.array());
	check_vectorwise_norms(matrix.transpose());
	check_vectorwise_norms(matrix + matrix);
	}
	}

	Matrix<Scalar, 3, 5, Order> fixed = Matrix<Scalar, 3, 5, Order>::Random();
	check_vectorwise_norms(fixed);
	Matrix<Scalar, Dynamic, Dynamic, Order, 9, 13> bounded(7, 11);
	bounded.setRandom();
	check_vectorwise_norms(bounded);

	MatrixType storage = MatrixType::Random(23, 29);
	check_vectorwise_norms(storage.block(1, 2, 17, 19));
	check_vectorwise_norm_evaluations(storage);
	check_vectorwise_norm_evaluations(storage.array());
	for (Index innerStride : {1, 2, 3}) {
	const Index innerSize = Order == RowMajor ? 19 : 17;
	const Index outerSize = Order == RowMajor ? 17 : 19;
	const Index outerStride = innerSize * innerStride + 5;
	Matrix<Scalar, Dynamic, 1> buffer = Matrix<Scalar, Dynamic, 1>::Random(outerSize * outerStride + 1);
	Map<const MatrixType, Unaligned, Stride<Dynamic, Dynamic>> strided(
	buffer.data() + 1, 17, 19, Stride<Dynamic, Dynamic>(outerStride, innerStride));
	check_vectorwise_norms(strided);
	}

	MatrixType matrix = MatrixType::Random(17, 19);
	const auto delayed = (matrix + matrix).colwise().squaredNorm();
	Matrix<Real, 1, Dynamic> actual = delayed;
	VERIFY_IS_APPROX(actual, (matrix + matrix).eval().colwise().squaredNorm());
	MatrixType product = matrix.adjoint() * matrix;
	Matrix<Real, 1, Dynamic> productNorms(19);
	// The abs2 path materializes the product and its squared coefficients.
	const int expectedTemporaries = useVectorNorm ? 1 : 2;
	VERIFY_EVALUATION_COUNT(productNorms = (matrix.adjoint() * matrix).colwise().squaredNorm(), expectedTemporaries);
	VERIFY_IS_APPROX(productNorms, product.colwise().squaredNorm());

	matrix.setZero();
	for (Index i = 0; i < matrix.size(); ++i) {
	matrix.data()[i] = Scalar(-Real(0));
	}
	const Matrix<Real, 1, Dynamic> zeros = matrix.colwise().squaredNorm();
	for (Index i = 0; i < zeros.size(); ++i) {
	VERIFY_IS_EQUAL(zeros(i), Real(0));
	VERIFY(!numext::signbit(zeros(i)));
	}
	matrix(3, 5) = Scalar(NumTraits<Real>::infinity());
	VERIFY((numext::isinf)(matrix.colwise().norm()(5)));
	VERIFY((numext::isinf)(matrix.rowwise().squaredNorm()(3)));
	matrix(3, 5) = Scalar(NumTraits<Real>::quiet_NaN());
	VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(5)));
	VERIFY((numext::isnan)(matrix.rowwise().norm()(3)));
	}

	template <typename Real, int Order>
	void vectorwise_norm_mixed_special_values() {
	using Scalar = std::complex<Real>;
	Matrix<Scalar, Dynamic, Dynamic, Order> matrix = Matrix<Scalar, Dynamic, Dynamic, Order>::Zero(17, 19);
	matrix(0, 0) = Scalar(NumTraits<Real>::infinity(), Real(0));
	matrix(1, 0) = matrix(0, 1) = Scalar(Real(0), NumTraits<Real>::quiet_NaN());
	VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(0)));
	VERIFY((numext::isnan)(matrix.colwise().norm()(0)));
	VERIFY((numext::isnan)(matrix.rowwise().squaredNorm()(0)));
	VERIFY((numext::isnan)(matrix.rowwise().norm()(0)));
	}

	EIGEN_DECLARE_TEST(vectorwise_norm) {
	for (int i = 0; i < g_repeat; ++i) {
	CALL_SUBTEST_1((vectorwise_norm_layout<float, ColMajor>()));
	CALL_SUBTEST_2((vectorwise_norm_layout<float, RowMajor>()));
	CALL_SUBTEST_3((vectorwise_norm_layout<double, ColMajor>()));
	CALL_SUBTEST_4((vectorwise_norm_layout<double, RowMajor>()));
	CALL_SUBTEST_5((vectorwise_norm_layout<std::complex<float>, ColMajor>()));
	CALL_SUBTEST_6((vectorwise_norm_layout<std::complex<float>, RowMajor>()));
	CALL_SUBTEST_7((vectorwise_norm_layout<std::complex<double>, ColMajor>()));
	CALL_SUBTEST_8((vectorwise_norm_layout<std::complex<double>, RowMajor>()));
	CALL_SUBTEST_5((vectorwise_norm_mixed_special_values<float, ColMajor>()));
	CALL_SUBTEST_6((vectorwise_norm_mixed_special_values<float, RowMajor>()));
	CALL_SUBTEST_7((vectorwise_norm_mixed_special_values<double, ColMajor>()));
	CALL_SUBTEST_8((vectorwise_norm_mixed_special_values<double, RowMajor>()));
	CALL_SUBTEST_10((vectorwise_norm_layout<CustomComplex<float>, ColMajor>()));
	CALL_SUBTEST_11((vectorwise_norm_layout<CustomComplex<float>, RowMajor>()));
	CALL_SUBTEST_12((vectorwise_norm_layout<CustomComplex<double>, ColMajor>()));
	CALL_SUBTEST_13((vectorwise_norm_layout<CustomComplex<double>, RowMajor>()));
	CALL_SUBTEST_9(([] {
	Matrix<int, 2, 2> integers;
	integers << 3, 0, 4, 5;
	VERIFY_IS_EQUAL(integers.colwise().squaredNorm().eval(), RowVector2i(25, 25));
	VERIFY_IS_EQUAL(integers.transpose().rowwise().squaredNorm().eval(), Vector2i(25, 25));
	Array<bool, 2, 2> flags;
	flags << false, true, true, false;
	VERIFY(flags.colwise().squaredNorm().all());
	VERIFY(flags.rowwise().squaredNorm().all());
	flags.setZero();
	VERIFY(!flags.colwise().squaredNorm().any());
	VERIFY(!flags.rowwise().squaredNorm().any());
	}()));
	}
	}