test/shape_checks.cpp - mirror - Git at Google


            
            // SPDX-FileCopyrightText: The Eigen Authors

            
            // SPDX-License-Identifier: MPL-2.0


            #include "main.h"

            
            #include <Eigen/Dense>

            
            #include <contrib/Eigen/MatrixFunctions>


            struct MissingShape {};

            
            struct PartialShape {};

            
            template <int Rows, int Cols>

            
            struct ShapeProbe;

            
            namespace Eigen {

            
            namespace internal {

            
            template <int Rows, int Cols>

            
            struct traits<ShapeProbe<Rows, Cols>> : traits<Matrix<double, Rows, Cols>> {};

            
            template <>

            
            struct traits<PartialShape> {

            
              static constexpr int RowsAtCompileTime = 3;

            
            };

            
            }  // namespace internal

            
            }  // namespace Eigen


            template <int Rows, int Cols>

            
            struct ShapeProbe : MatrixBase<ShapeProbe<Rows, Cols>> {

            
              using Nested = const ShapeProbe&;

            
              mutable int row_reads = 0;

            
              mutable int col_reads = 0;

            
              Index rows() const {

            
                ++row_reads;

            
                return 2;

            
              }

            
              Index cols() const {

            
                ++col_reads;

            
                return 2;

            
              }

            
            };


            void rank_update_shape_checks() {

            
              Matrix2d b = Matrix2d::Constant(2);

            
              Matrix2d updated = Matrix2d::Zero();

            
              updated.selfadjointView<Lower>().rankUpdate(b);

            
              VERIFY_IS_EQUAL(Matrix2d(updated.selfadjointView<Lower>()), (b * b.transpose()).eval());

            
              MatrixXd wrong = MatrixXd::Ones(3, 2);

            
              VERIFY_RAISES_ASSERT(updated.selfadjointView<Lower>().rankUpdate(wrong));

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              Matrix<double, 3, 2> fixed_wrong = wrong;

            
              VERIFY_RAISES_ASSERT(updated.selfadjointView<Lower>().rankUpdate(fixed_wrong));

            
            #endif

            
            }


            void product_coefficient_shape_checks() {

            
              Matrix2d a = Matrix2d::Identity(), b = Matrix2d::Constant(2);

            
              VERIFY_IS_EQUAL(a.lazyProduct(b).coeff(0, 1), 2);

            
              Vector2d v = Vector2d::Ones();

            
              VERIFY_IS_EQUAL((v.transpose() * v).coeff(0, 0), 2);

            
              VERIFY_IS_EQUAL((v.transpose() * v).coeff(0), 2);

            
              MatrixXd dynamic_a = a, dynamic_b = b;

            
              VERIFY_RAISES_ASSERT((dynamic_a * dynamic_b).coeff(0, 0));

            
              VERIFY_RAISES_ASSERT((dynamic_a * dynamic_b).coeff(0));

            
              MatrixXd scalar = MatrixXd::Constant(1, 1, 3);

            
              VERIFY_IS_EQUAL((scalar * scalar).coeff(0), 9);

            
            }


            void transpose_shape_checks() {

            
              Matrix<double, 2, 3> rectangle;

            
              rectangle << 1, 2, 3, 4, 5, 6;

            
              MatrixXd resizable = rectangle;

            
              resizable.transposeInPlace();

            
              VERIFY_IS_EQUAL(resizable, rectangle.transpose());

            
              Matrix<double, 2, Dynamic> partial = Matrix2d::Identity();

            
              partial.transposeInPlace();

            
              VERIFY_IS_EQUAL(partial, Matrix2d::Identity());

            
              partial = rectangle;

            
              VERIFY_RAISES_ASSERT(partial.transposeInPlace());

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(rectangle.transposeInPlace());

            
            #endif

            
            }


            void product_shape_checks() {

            
              transpose_shape_checks();

            
              product_coefficient_shape_checks();

            
              rank_update_shape_checks();

            
              ShapeProbe<2, 2> a, b;

            
              const auto product = a * b;

            
              EIGEN_UNUSED_VARIABLE(product);

            
              VERIFY_IS_EQUAL(a.col_reads + b.row_reads, 0);

            
              const MatrixBase<ShapeProbe<2, 2>>& base_a = a;

            
              const MatrixBase<ShapeProbe<2, 2>>& base_b = b;

            
              EIGEN_INTERNAL_ASSERT_PRODUCT_SHAPE(base_a, base_b);

            
              VERIFY_IS_EQUAL(a.col_reads + b.row_reads, 0);

            
              Matrix2d fixed = Matrix2d::Identity();

            
              MatrixXd wrong(3, 2);

            
              VERIFY_RAISES_ASSERT((fixed * wrong));

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              Matrix<double, 3, 2> fixed_wrong;

            
              VERIFY_RAISES_ASSERT((Product<Matrix2d, decltype(fixed_wrong)>(fixed, fixed_wrong)));

            
            #endif

            
              Transpositions<2> swaps;

            
              swaps.setIdentity();

            
              VERIFY_IS_EQUAL((swaps * fixed).eval(), fixed);

            
              VERIFY_IS_EQUAL((fixed * swaps.transpose()).eval(), fixed);

            
            }


            template <int Size, int Order>

            
            void product_destination_shape_checks() {

            
              using MatrixType = Matrix<double, Size, Size, Order>;

            
              const MatrixType identity = MatrixType::Identity(3, 3);

            
              const MatrixType values = MatrixType::Constant(3, 3, 2);

            
              MatrixType result = MatrixType::Zero(3, 3);

            
              result.noalias() += identity * values;

            
              VERIFY_IS_EQUAL(result, values);

            
              result.noalias() -= identity * values;

            
              VERIFY(result.isZero());

            
              result.noalias() += identity.template selfadjointView<Lower>() * values;

            
              VERIFY_IS_EQUAL(result, values);

            
              result.noalias() -= identity.template triangularView<Upper>() * values;

            
              VERIFY(result.isZero());


              PermutationMatrix<Size> permutation(3);

            
              permutation.setIdentity();

            
              DiagonalMatrix<double, Size> diagonal(3);

            
              diagonal.diagonal().setConstant(2);

            
              result.noalias() = identity.template triangularView<Lower>() * diagonal;

            
              VERIFY_IS_EQUAL(result, 2 * identity);

            
              result.noalias() = diagonal * identity.template triangularView<Upper>();

            
              VERIFY_IS_EQUAL(result, 2 * identity);

            
              result.noalias() = identity.template selfadjointView<Lower>() * diagonal;

            
              VERIFY_IS_EQUAL(result, 2 * identity);

            
              result.setZero();

            
              const auto scaled = permutation * diagonal;

            
              result += scaled;

            
              VERIFY_IS_EQUAL(result, 2 * identity);

            
              result -= scaled;

            
              VERIFY(result.isZero());

            
              MatrixXd wrong_destination = MatrixXd::Zero(2, 3);

            
              VERIFY_RAISES_ASSERT(wrong_destination.noalias() += identity * values);

            
              VERIFY_RAISES_ASSERT(wrong_destination.noalias() -= identity * values);

            
              VERIFY_RAISES_ASSERT(wrong_destination += scaled);

            
              VERIFY_RAISES_ASSERT(wrong_destination -= scaled);

            
              result.noalias() += scaled * identity;

            
              VERIFY_IS_EQUAL(result, 2 * identity);

            
              result.noalias() -= scaled * identity;

            
              VERIFY(result.isZero());

            
              VERIFY_IS_EQUAL((scaled * permutation).toDenseMatrix(), 2 * identity);

            
              VERIFY_IS_EQUAL((permutation * scaled).toDenseMatrix(), 2 * identity);

            
              VERIFY_IS_EQUAL((permutation * permutation.inverse()).toDenseMatrix().template cast<double>(), identity);

            
              const ScaledPermutationMatrix<double, Size> from_coefficients(permutation.indices(), diagonal.diagonal());

            
              VERIFY_IS_EQUAL(from_coefficients.toDenseMatrix(), 2 * identity);

            
              DiagonalMatrix<double, Dynamic> wrong(2);

            
              VERIFY_RAISES_ASSERT(permutation * wrong);

            
            }


            EIGEN_DECLARE_TEST(shape_checks) {

            
              ShapeProbe<2, 2> fixed_a, fixed_b;

            
              const auto sum = fixed_a + fixed_b;

            
              EIGEN_UNUSED_VARIABLE(sum);

            
              internal::resize_if_allowed(fixed_a, fixed_b, internal::add_assign_op<double, double>());

            
              VERIFY_IS_EQUAL(fixed_a.row_reads + fixed_b.row_reads + fixed_a.col_reads + fixed_b.col_reads, 0);

            
              ShapeProbe<2, Dynamic> partial_a, partial_b;

            
              const auto partial_sum = partial_a + partial_b;

            
              EIGEN_UNUSED_VARIABLE(partial_sum);

            
              VERIFY_IS_EQUAL(partial_a.row_reads + partial_b.row_reads, 0);

            
            #ifndef EIGEN_NO_DEBUG

            
              VERIFY(partial_a.col_reads > 0 && partial_b.col_reads > 0);

            
            #endif

            
              Matrix2d matrix = Matrix2d::Identity();

            
              MatrixXd bad(3, 2);

            
              VERIFY_RAISES_ASSERT((matrix + bad));

            
              VERIFY_RAISES_ASSERT(matrix += bad);

            
              VERIFY_IS_EQUAL(hcat(matrix, matrix).cols(), 4);

            
              VERIFY_IS_EQUAL(vcat(matrix, matrix).rows(), 4);

            
              Matrix<double, 2, 3> concat_wide = Matrix<double, 2, 3>::Ones();

            
              VERIFY_IS_EQUAL(hcat(matrix, concat_wide).cols(), 5);

            
              VERIFY_IS_EQUAL(vcat(matrix, concat_wide.transpose()).rows(), 5);

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(hcat(matrix, concat_wide.transpose()));

            
              VERIFY_RAISES_ASSERT(vcat(matrix, concat_wide));

            
            #endif

            
              Matrix<double, 2, 3> wide = Matrix<double, 2, 3>::Ones();

            
              const DiagonalMatrix<double, 2> left_diagonal(Vector2d::Constant(2));

            
              const DiagonalMatrix<double, 3> right_diagonal(Vector3d::Constant(3));

            
              Matrix<double, 2, 3> triangular_product = left_diagonal * wide.triangularView<Upper>();

            
              VERIFY_IS_EQUAL(triangular_product, 2 * wide.triangularView<Upper>().toDenseMatrix());

            
              triangular_product = wide.triangularView<Upper>() * right_diagonal;

            
              VERIFY_IS_EQUAL(triangular_product, 3 * wide.triangularView<Upper>().toDenseMatrix());

            
              Vector3d vector = Vector3d::Ones();

            
              RowVector3d row = RowVector3d::Ones();

            
              VERIFY_IS_EQUAL(vector.dot(row), 3);

            
              VERIFY_IS_EQUAL(vector.reshaped(fix<1>, fix<3>).sum(), 3);

            
              VectorXd dynamic_reshape = vector;

            
              VERIFY_RAISES_ASSERT(dynamic_reshape.reshaped(fix<2>, fix<2>));

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(vector.reshaped(fix<2>, fix<2>));

            
              Vector4d mismatched_vector = Vector4d::Ones();

            
              VERIFY_RAISES_ASSERT(vector.dot(mismatched_vector));

            
            #endif

            
              VectorXd bad_vector(2);

            
              VERIFY_RAISES_ASSERT(vector.dot(bad_vector));

            
              VectorXd resized;

            
              resized.resizeLike(row);

            
              VERIFY_IS_EQUAL(resized.size(), 3);

            
              MatrixXd resize_source = matrix;

            
              VERIFY_RAISES_ASSERT(resized.resizeLike(resize_source));

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(resized.resizeLike(matrix));

            
            #endif

            
              Ref<VectorXd> ref(vector);

            
              Ref<Matrix2d> matrix_ref(matrix);

            
              VERIFY_IS_EQUAL(matrix_ref.rows(), 2);

            
              Matrix2d resized_matrix;

            
              resized_matrix.resizeLike(matrix);

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(EIGEN_INTERNAL_ASSERT_SCALAR(matrix));

            
            #endif

            
              VERIFY_IS_EQUAL(ref.size(), 3);

            
              MatrixXd dynamic_matrix = matrix;

            
              VERIFY_RAISES_ASSERT((Ref<VectorXd>(dynamic_matrix)));

            
              VERIFY_IS_EQUAL(matrix.determinant(), 1);

            
              VERIFY_IS_EQUAL(matrix.householderQr().absDeterminant(), 1);

            
              VERIFY_IS_EQUAL(matrix.fullPivLu().determinant(), 1);

            
              VERIFY_IS_EQUAL(matrix.fullPivLu().rcond(), 1);

            
              Matrix3d transpose_source = Matrix3d::Random();

            
              const Matrix3d transposed = transpose_source.transpose();

            
              transpose_source.transposeInPlace();

            
              VERIFY_IS_EQUAL(transpose_source, transposed);

            
              MatrixXd rectangular_transpose = MatrixXd::Random(2, 3);

            
              const MatrixXd rectangular_expected = rectangular_transpose.transpose();

            
              rectangular_transpose.transposeInPlace();

            
              VERIFY_IS_EQUAL(rectangular_transpose, rectangular_expected);

            
              VERIFY(matrix.llt().info() == Success);

            
              Vector2d rhs = Vector2d::Ones();

            
              const auto lu = matrix.fullPivLu();

            
              VERIFY_IS_EQUAL(lu.solve(rhs).eval(), rhs);

            
              VERIFY_IS_EQUAL(lu.transpose().solve(rhs).eval(), rhs);

            
              Matrix2d nonsymmetric;

            
              nonsymmetric << 2, 1, 0, 3;

            
              const auto partial_lu = nonsymmetric.partialPivLu();

            
              const Vector2d transpose_solution = partial_lu.transpose().solve(rhs);

            
              VERIFY_IS_APPROX(nonsymmetric.transpose() * transpose_solution, rhs);

            
              VERIFY_RAISES_ASSERT(partial_lu.transpose().solve(VectorXd::Ones(3)));

            
              VERIFY_RAISES_ASSERT(lu.solve(VectorXd::Ones(3)));

            
            #ifdef EIGEN_NO_STATIC_ASSERT

            
              VERIFY_RAISES_ASSERT(lu.solve(Vector3d::Ones()));

            
            #endif

            
              VERIFY_IS_APPROX(matrix.sqrt(), matrix);

            
              VERIFY(SelfAdjointEigenSolver<Matrix2d>(matrix).info() == Success);

            
              MatrixXd rectangle = MatrixXd::Ones(2, 3);

            
              VERIFY_RAISES_ASSERT(rectangle.determinant());

            
              VERIFY_RAISES_ASSERT(rectangle.householderQr().absDeterminant());

            
              VERIFY_RAISES_ASSERT(rectangle.fullPivLu().determinant());

            
              VERIFY_RAISES_ASSERT(rectangle.llt());

            
              VERIFY_RAISES_ASSERT(wide.fullPivLu().determinant());

            
              MatrixXd empty(0, 0);

            
              VERIFY_IS_EQUAL(empty.sum(), 0);

            
              const Matrix<double, 0, 0> fixed_empty;

            
              VERIFY_IS_EQUAL(fixed_empty.sum(), 0);

            
              VERIFY_IS_EQUAL(fixed_empty.prod(), 1);

            
              Matrix<double, 3, 0> empty_columns;

            
              Matrix<double, 0, 3> empty_rows;

            
              VERIFY_IS_EQUAL(empty_columns.colwise().maxCoeff().eval().size(), 0);

            
              VERIFY_IS_EQUAL(empty_rows.rowwise().minCoeff().eval().size(), 0);

            
              VERIFY_RAISES_ASSERT(fixed_empty.maxCoeff());

            
              VERIFY_RAISES_ASSERT(empty_columns.rowwise().maxCoeff());

            
              VERIFY_RAISES_ASSERT(empty_rows.colwise().minCoeff());

            
              VERIFY_RAISES_ASSERT(empty.maxCoeff());

            
              VERIFY_IS_EQUAL(matrix.maxCoeff(), 1);

            
              Index max_row, max_col;

            
              VERIFY_IS_EQUAL(matrix.maxCoeff(&max_row, &max_col), 1);

            
              CALL_SUBTEST(product_shape_checks());

            
              CALL_SUBTEST((product_destination_shape_checks<3, ColMajor>()));

            
              CALL_SUBTEST((product_destination_shape_checks<3, RowMajor>()));

            
              CALL_SUBTEST((product_destination_shape_checks<Dynamic, ColMajor>()));

            
              CALL_SUBTEST((product_destination_shape_checks<Dynamic, RowMajor>()));

            
              using namespace Eigen::internal;

            
              STATIC_CHECK((dimension_relation<3, 3>::Proven));

            
              STATIC_CHECK((!dimension_relation<3, 2>::Compatible));

            
              STATIC_CHECK((dimension_relation<Dynamic, 3>::Compatible));

            
              STATIC_CHECK((!dimension_relation<Dynamic, 3>::Known));

            
              STATIC_CHECK((compile_time_shape<MissingShape>::Rows == Dynamic));

            
              STATIC_CHECK((compile_time_shape<PartialShape>::Rows == 3));

            
              STATIC_CHECK((compile_time_shape<PartialShape>::Cols == Dynamic));

            
              STATIC_CHECK((compile_time_shape<Matrix<double, Dynamic, 1, 0, 3, 1>>::Size == Dynamic));

            
              STATIC_CHECK((matching_sizes<Matrix<double, 2, 3>, Matrix<double, 3, 2>>::Proven));

            
              STATIC_CHECK((matching_shapes<Matrix<double, 1, 0>, Matrix<double, 0, 1>>::Compatible));

            
              const Matrix<double, 1, 0> empty_row;

            
              const Matrix<double, 0, 1> empty_column;

            
              VERIFY_RAISES_ASSERT(empty_row + empty_column);

            
              VERIFY_RAISES_ASSERT(internal::resize_if_allowed(empty_row, empty_column, internal::add_assign_op<double, double>()));

            
              STATIC_CHECK((square_dimensions<const Matrix3d&>::Proven));

            
              int reads = 0;

            
              struct RuntimeDimensions {

            
                mutable int accesses = 0;

            
                Index rows() const {

            
                  ++accesses;

            
                  return 2;

            
                }

            
                Index cols() const {

            
                  ++accesses;

            
                  return 3;

            
                }

            
              } runtime_a, runtime_b;

            
              EIGEN_INTERNAL_ASSERT_SAME_ROWS(runtime_a, runtime_b);

            
              EIGEN_INTERNAL_ASSERT_SAME_COLS(runtime_a, runtime_b);

            
            #ifndef EIGEN_NO_DEBUG

            
              VERIFY_IS_EQUAL(runtime_a.accesses, 2);

            
              VERIFY_IS_EQUAL(runtime_b.accesses, 2);

            
            #endif

            
              EIGEN_INTERNAL_SHAPE_ASSERT((dimension_relation<3, 3>::Proven), ++reads == 1);  // NOLINT(bugprone-assert-side-effect)

            
              VERIFY_IS_EQUAL(reads, 0);

            
              EIGEN_INTERNAL_ASSERT_NONEMPTY_SIZE(fixed_a, ++reads);  // NOLINT(bugprone-assert-side-effect)

            
              VERIFY_IS_EQUAL(reads, 0);

            
            #ifndef EIGEN_NO_DEBUG

            
              // NOLINTBEGIN(bugprone-assert-side-effect)

            
              EIGEN_INTERNAL_SHAPE_ASSERT((dimension_relation<Dynamic, 3>::Proven), ++reads == 1);

            
              // NOLINTEND(bugprone-assert-side-effect)

            
              VERIFY_IS_EQUAL(reads, 1);

            
              VERIFY_RAISES_ASSERT([] { EIGEN_INTERNAL_SHAPE_ASSERT(false, false); }());

            
            #endif

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

	#include "main.h"
	#include <Eigen/Dense>
	#include <contrib/Eigen/MatrixFunctions>

	struct MissingShape {};
	struct PartialShape {};
	template <int Rows, int Cols>
	struct ShapeProbe;
	namespace Eigen {
	namespace internal {
	template <int Rows, int Cols>
	struct traits<ShapeProbe<Rows, Cols>> : traits<Matrix<double, Rows, Cols>> {};
	template <>
	struct traits<PartialShape> {
	static constexpr int RowsAtCompileTime = 3;
	};
	} // namespace internal
	} // namespace Eigen

	template <int Rows, int Cols>
	struct ShapeProbe : MatrixBase<ShapeProbe<Rows, Cols>> {
	using Nested = const ShapeProbe&;
	mutable int row_reads = 0;
	mutable int col_reads = 0;
	Index rows() const {
	++row_reads;
	return 2;
	}
	Index cols() const {
	++col_reads;
	return 2;
	}
	};

	void rank_update_shape_checks() {
	Matrix2d b = Matrix2d::Constant(2);
	Matrix2d updated = Matrix2d::Zero();
	updated.selfadjointView<Lower>().rankUpdate(b);
	VERIFY_IS_EQUAL(Matrix2d(updated.selfadjointView<Lower>()), (b * b.transpose()).eval());
	MatrixXd wrong = MatrixXd::Ones(3, 2);
	VERIFY_RAISES_ASSERT(updated.selfadjointView<Lower>().rankUpdate(wrong));
	#ifdef EIGEN_NO_STATIC_ASSERT
	Matrix<double, 3, 2> fixed_wrong = wrong;
	VERIFY_RAISES_ASSERT(updated.selfadjointView<Lower>().rankUpdate(fixed_wrong));
	#endif
	}

	void product_coefficient_shape_checks() {
	Matrix2d a = Matrix2d::Identity(), b = Matrix2d::Constant(2);
	VERIFY_IS_EQUAL(a.lazyProduct(b).coeff(0, 1), 2);
	Vector2d v = Vector2d::Ones();
	VERIFY_IS_EQUAL((v.transpose() * v).coeff(0, 0), 2);
	VERIFY_IS_EQUAL((v.transpose() * v).coeff(0), 2);
	MatrixXd dynamic_a = a, dynamic_b = b;
	VERIFY_RAISES_ASSERT((dynamic_a * dynamic_b).coeff(0, 0));
	VERIFY_RAISES_ASSERT((dynamic_a * dynamic_b).coeff(0));
	MatrixXd scalar = MatrixXd::Constant(1, 1, 3);
	VERIFY_IS_EQUAL((scalar * scalar).coeff(0), 9);
	}

	void transpose_shape_checks() {
	Matrix<double, 2, 3> rectangle;
	rectangle << 1, 2, 3, 4, 5, 6;
	MatrixXd resizable = rectangle;
	resizable.transposeInPlace();
	VERIFY_IS_EQUAL(resizable, rectangle.transpose());
	Matrix<double, 2, Dynamic> partial = Matrix2d::Identity();
	partial.transposeInPlace();
	VERIFY_IS_EQUAL(partial, Matrix2d::Identity());
	partial = rectangle;
	VERIFY_RAISES_ASSERT(partial.transposeInPlace());
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(rectangle.transposeInPlace());
	#endif
	}

	void product_shape_checks() {
	transpose_shape_checks();
	product_coefficient_shape_checks();
	rank_update_shape_checks();
	ShapeProbe<2, 2> a, b;
	const auto product = a * b;
	EIGEN_UNUSED_VARIABLE(product);
	VERIFY_IS_EQUAL(a.col_reads + b.row_reads, 0);
	const MatrixBase<ShapeProbe<2, 2>>& base_a = a;
	const MatrixBase<ShapeProbe<2, 2>>& base_b = b;
	EIGEN_INTERNAL_ASSERT_PRODUCT_SHAPE(base_a, base_b);
	VERIFY_IS_EQUAL(a.col_reads + b.row_reads, 0);
	Matrix2d fixed = Matrix2d::Identity();
	MatrixXd wrong(3, 2);
	VERIFY_RAISES_ASSERT((fixed * wrong));
	#ifdef EIGEN_NO_STATIC_ASSERT
	Matrix<double, 3, 2> fixed_wrong;
	VERIFY_RAISES_ASSERT((Product<Matrix2d, decltype(fixed_wrong)>(fixed, fixed_wrong)));
	#endif
	Transpositions<2> swaps;
	swaps.setIdentity();
	VERIFY_IS_EQUAL((swaps * fixed).eval(), fixed);
	VERIFY_IS_EQUAL((fixed * swaps.transpose()).eval(), fixed);
	}

	template <int Size, int Order>
	void product_destination_shape_checks() {
	using MatrixType = Matrix<double, Size, Size, Order>;
	const MatrixType identity = MatrixType::Identity(3, 3);
	const MatrixType values = MatrixType::Constant(3, 3, 2);
	MatrixType result = MatrixType::Zero(3, 3);
	result.noalias() += identity * values;
	VERIFY_IS_EQUAL(result, values);
	result.noalias() -= identity * values;
	VERIFY(result.isZero());
	result.noalias() += identity.template selfadjointView<Lower>() * values;
	VERIFY_IS_EQUAL(result, values);
	result.noalias() -= identity.template triangularView<Upper>() * values;
	VERIFY(result.isZero());

	PermutationMatrix<Size> permutation(3);
	permutation.setIdentity();
	DiagonalMatrix<double, Size> diagonal(3);
	diagonal.diagonal().setConstant(2);
	result.noalias() = identity.template triangularView<Lower>() * diagonal;
	VERIFY_IS_EQUAL(result, 2 * identity);
	result.noalias() = diagonal * identity.template triangularView<Upper>();
	VERIFY_IS_EQUAL(result, 2 * identity);
	result.noalias() = identity.template selfadjointView<Lower>() * diagonal;
	VERIFY_IS_EQUAL(result, 2 * identity);
	result.setZero();
	const auto scaled = permutation * diagonal;
	result += scaled;
	VERIFY_IS_EQUAL(result, 2 * identity);
	result -= scaled;
	VERIFY(result.isZero());
	MatrixXd wrong_destination = MatrixXd::Zero(2, 3);
	VERIFY_RAISES_ASSERT(wrong_destination.noalias() += identity * values);
	VERIFY_RAISES_ASSERT(wrong_destination.noalias() -= identity * values);
	VERIFY_RAISES_ASSERT(wrong_destination += scaled);
	VERIFY_RAISES_ASSERT(wrong_destination -= scaled);
	result.noalias() += scaled * identity;
	VERIFY_IS_EQUAL(result, 2 * identity);
	result.noalias() -= scaled * identity;
	VERIFY(result.isZero());
	VERIFY_IS_EQUAL((scaled * permutation).toDenseMatrix(), 2 * identity);
	VERIFY_IS_EQUAL((permutation * scaled).toDenseMatrix(), 2 * identity);
	VERIFY_IS_EQUAL((permutation * permutation.inverse()).toDenseMatrix().template cast<double>(), identity);
	const ScaledPermutationMatrix<double, Size> from_coefficients(permutation.indices(), diagonal.diagonal());
	VERIFY_IS_EQUAL(from_coefficients.toDenseMatrix(), 2 * identity);
	DiagonalMatrix<double, Dynamic> wrong(2);
	VERIFY_RAISES_ASSERT(permutation * wrong);
	}

	EIGEN_DECLARE_TEST(shape_checks) {
	ShapeProbe<2, 2> fixed_a, fixed_b;
	const auto sum = fixed_a + fixed_b;
	EIGEN_UNUSED_VARIABLE(sum);
	internal::resize_if_allowed(fixed_a, fixed_b, internal::add_assign_op<double, double>());
	VERIFY_IS_EQUAL(fixed_a.row_reads + fixed_b.row_reads + fixed_a.col_reads + fixed_b.col_reads, 0);
	ShapeProbe<2, Dynamic> partial_a, partial_b;
	const auto partial_sum = partial_a + partial_b;
	EIGEN_UNUSED_VARIABLE(partial_sum);
	VERIFY_IS_EQUAL(partial_a.row_reads + partial_b.row_reads, 0);
	#ifndef EIGEN_NO_DEBUG
	VERIFY(partial_a.col_reads > 0 && partial_b.col_reads > 0);
	#endif
	Matrix2d matrix = Matrix2d::Identity();
	MatrixXd bad(3, 2);
	VERIFY_RAISES_ASSERT((matrix + bad));
	VERIFY_RAISES_ASSERT(matrix += bad);
	VERIFY_IS_EQUAL(hcat(matrix, matrix).cols(), 4);
	VERIFY_IS_EQUAL(vcat(matrix, matrix).rows(), 4);
	Matrix<double, 2, 3> concat_wide = Matrix<double, 2, 3>::Ones();
	VERIFY_IS_EQUAL(hcat(matrix, concat_wide).cols(), 5);
	VERIFY_IS_EQUAL(vcat(matrix, concat_wide.transpose()).rows(), 5);
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(hcat(matrix, concat_wide.transpose()));
	VERIFY_RAISES_ASSERT(vcat(matrix, concat_wide));
	#endif
	Matrix<double, 2, 3> wide = Matrix<double, 2, 3>::Ones();
	const DiagonalMatrix<double, 2> left_diagonal(Vector2d::Constant(2));
	const DiagonalMatrix<double, 3> right_diagonal(Vector3d::Constant(3));
	Matrix<double, 2, 3> triangular_product = left_diagonal * wide.triangularView<Upper>();
	VERIFY_IS_EQUAL(triangular_product, 2 * wide.triangularView<Upper>().toDenseMatrix());
	triangular_product = wide.triangularView<Upper>() * right_diagonal;
	VERIFY_IS_EQUAL(triangular_product, 3 * wide.triangularView<Upper>().toDenseMatrix());
	Vector3d vector = Vector3d::Ones();
	RowVector3d row = RowVector3d::Ones();
	VERIFY_IS_EQUAL(vector.dot(row), 3);
	VERIFY_IS_EQUAL(vector.reshaped(fix<1>, fix<3>).sum(), 3);
	VectorXd dynamic_reshape = vector;
	VERIFY_RAISES_ASSERT(dynamic_reshape.reshaped(fix<2>, fix<2>));
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(vector.reshaped(fix<2>, fix<2>));
	Vector4d mismatched_vector = Vector4d::Ones();
	VERIFY_RAISES_ASSERT(vector.dot(mismatched_vector));
	#endif
	VectorXd bad_vector(2);
	VERIFY_RAISES_ASSERT(vector.dot(bad_vector));
	VectorXd resized;
	resized.resizeLike(row);
	VERIFY_IS_EQUAL(resized.size(), 3);
	MatrixXd resize_source = matrix;
	VERIFY_RAISES_ASSERT(resized.resizeLike(resize_source));
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(resized.resizeLike(matrix));
	#endif
	Ref<VectorXd> ref(vector);
	Ref<Matrix2d> matrix_ref(matrix);
	VERIFY_IS_EQUAL(matrix_ref.rows(), 2);
	Matrix2d resized_matrix;
	resized_matrix.resizeLike(matrix);
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(EIGEN_INTERNAL_ASSERT_SCALAR(matrix));
	#endif
	VERIFY_IS_EQUAL(ref.size(), 3);
	MatrixXd dynamic_matrix = matrix;
	VERIFY_RAISES_ASSERT((Ref<VectorXd>(dynamic_matrix)));
	VERIFY_IS_EQUAL(matrix.determinant(), 1);
	VERIFY_IS_EQUAL(matrix.householderQr().absDeterminant(), 1);
	VERIFY_IS_EQUAL(matrix.fullPivLu().determinant(), 1);
	VERIFY_IS_EQUAL(matrix.fullPivLu().rcond(), 1);
	Matrix3d transpose_source = Matrix3d::Random();
	const Matrix3d transposed = transpose_source.transpose();
	transpose_source.transposeInPlace();
	VERIFY_IS_EQUAL(transpose_source, transposed);
	MatrixXd rectangular_transpose = MatrixXd::Random(2, 3);
	const MatrixXd rectangular_expected = rectangular_transpose.transpose();
	rectangular_transpose.transposeInPlace();
	VERIFY_IS_EQUAL(rectangular_transpose, rectangular_expected);
	VERIFY(matrix.llt().info() == Success);
	Vector2d rhs = Vector2d::Ones();
	const auto lu = matrix.fullPivLu();
	VERIFY_IS_EQUAL(lu.solve(rhs).eval(), rhs);
	VERIFY_IS_EQUAL(lu.transpose().solve(rhs).eval(), rhs);
	Matrix2d nonsymmetric;
	nonsymmetric << 2, 1, 0, 3;
	const auto partial_lu = nonsymmetric.partialPivLu();
	const Vector2d transpose_solution = partial_lu.transpose().solve(rhs);
	VERIFY_IS_APPROX(nonsymmetric.transpose() * transpose_solution, rhs);
	VERIFY_RAISES_ASSERT(partial_lu.transpose().solve(VectorXd::Ones(3)));
	VERIFY_RAISES_ASSERT(lu.solve(VectorXd::Ones(3)));
	#ifdef EIGEN_NO_STATIC_ASSERT
	VERIFY_RAISES_ASSERT(lu.solve(Vector3d::Ones()));
	#endif
	VERIFY_IS_APPROX(matrix.sqrt(), matrix);
	VERIFY(SelfAdjointEigenSolver<Matrix2d>(matrix).info() == Success);
	MatrixXd rectangle = MatrixXd::Ones(2, 3);
	VERIFY_RAISES_ASSERT(rectangle.determinant());
	VERIFY_RAISES_ASSERT(rectangle.householderQr().absDeterminant());
	VERIFY_RAISES_ASSERT(rectangle.fullPivLu().determinant());
	VERIFY_RAISES_ASSERT(rectangle.llt());
	VERIFY_RAISES_ASSERT(wide.fullPivLu().determinant());
	MatrixXd empty(0, 0);
	VERIFY_IS_EQUAL(empty.sum(), 0);
	const Matrix<double, 0, 0> fixed_empty;
	VERIFY_IS_EQUAL(fixed_empty.sum(), 0);
	VERIFY_IS_EQUAL(fixed_empty.prod(), 1);
	Matrix<double, 3, 0> empty_columns;
	Matrix<double, 0, 3> empty_rows;
	VERIFY_IS_EQUAL(empty_columns.colwise().maxCoeff().eval().size(), 0);
	VERIFY_IS_EQUAL(empty_rows.rowwise().minCoeff().eval().size(), 0);
	VERIFY_RAISES_ASSERT(fixed_empty.maxCoeff());
	VERIFY_RAISES_ASSERT(empty_columns.rowwise().maxCoeff());
	VERIFY_RAISES_ASSERT(empty_rows.colwise().minCoeff());
	VERIFY_RAISES_ASSERT(empty.maxCoeff());
	VERIFY_IS_EQUAL(matrix.maxCoeff(), 1);
	Index max_row, max_col;
	VERIFY_IS_EQUAL(matrix.maxCoeff(&max_row, &max_col), 1);
	CALL_SUBTEST(product_shape_checks());
	CALL_SUBTEST((product_destination_shape_checks<3, ColMajor>()));
	CALL_SUBTEST((product_destination_shape_checks<3, RowMajor>()));
	CALL_SUBTEST((product_destination_shape_checks<Dynamic, ColMajor>()));
	CALL_SUBTEST((product_destination_shape_checks<Dynamic, RowMajor>()));
	using namespace Eigen::internal;
	STATIC_CHECK((dimension_relation<3, 3>::Proven));
	STATIC_CHECK((!dimension_relation<3, 2>::Compatible));
	STATIC_CHECK((dimension_relation<Dynamic, 3>::Compatible));
	STATIC_CHECK((!dimension_relation<Dynamic, 3>::Known));
	STATIC_CHECK((compile_time_shape<MissingShape>::Rows == Dynamic));
	STATIC_CHECK((compile_time_shape<PartialShape>::Rows == 3));
	STATIC_CHECK((compile_time_shape<PartialShape>::Cols == Dynamic));
	STATIC_CHECK((compile_time_shape<Matrix<double, Dynamic, 1, 0, 3, 1>>::Size == Dynamic));
	STATIC_CHECK((matching_sizes<Matrix<double, 2, 3>, Matrix<double, 3, 2>>::Proven));
	STATIC_CHECK((matching_shapes<Matrix<double, 1, 0>, Matrix<double, 0, 1>>::Compatible));
	const Matrix<double, 1, 0> empty_row;
	const Matrix<double, 0, 1> empty_column;
	VERIFY_RAISES_ASSERT(empty_row + empty_column);
	VERIFY_RAISES_ASSERT(internal::resize_if_allowed(empty_row, empty_column, internal::add_assign_op<double, double>()));
	STATIC_CHECK((square_dimensions<const Matrix3d&>::Proven));
	int reads = 0;
	struct RuntimeDimensions {
	mutable int accesses = 0;
	Index rows() const {
	++accesses;
	return 2;
	}
	Index cols() const {
	++accesses;
	return 3;
	}
	} runtime_a, runtime_b;
	EIGEN_INTERNAL_ASSERT_SAME_ROWS(runtime_a, runtime_b);
	EIGEN_INTERNAL_ASSERT_SAME_COLS(runtime_a, runtime_b);
	#ifndef EIGEN_NO_DEBUG
	VERIFY_IS_EQUAL(runtime_a.accesses, 2);
	VERIFY_IS_EQUAL(runtime_b.accesses, 2);
	#endif
	EIGEN_INTERNAL_SHAPE_ASSERT((dimension_relation<3, 3>::Proven), ++reads == 1); // NOLINT(bugprone-assert-side-effect)
	VERIFY_IS_EQUAL(reads, 0);
	EIGEN_INTERNAL_ASSERT_NONEMPTY_SIZE(fixed_a, ++reads); // NOLINT(bugprone-assert-side-effect)
	VERIFY_IS_EQUAL(reads, 0);
	#ifndef EIGEN_NO_DEBUG
	// NOLINTBEGIN(bugprone-assert-side-effect)
	EIGEN_INTERNAL_SHAPE_ASSERT((dimension_relation<Dynamic, 3>::Proven), ++reads == 1);
	// NOLINTEND(bugprone-assert-side-effect)
	VERIFY_IS_EQUAL(reads, 1);
	VERIFY_RAISES_ASSERT([] { EIGEN_INTERNAL_SHAPE_ASSERT(false, false); }());
	#endif
	}