anonymous_namespace{skew_symmetric_matrix3.cpp} Namespace Reference

Functions
template<typename Scalar >
void	constructors ()
template<typename Scalar >
void	assignments ()
template<typename Scalar >
void	plusMinus ()
template<typename Scalar >
void	multiplyScale ()
template<typename Matrix >
void	skewSymmetricMultiplication (const Matrix &m)
template<typename Scalar >
void	traceAndDet ()
template<typename Scalar >
void	transpose ()
template<typename Scalar >
void	exponentialIdentity ()
template<typename Scalar >
void	exponentialOrthogonality ()
template<typename Scalar >
void	exponentialRotation ()

Function Documentation

assignments()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::assignments

(

)

                   {
  typedef Matrix<Scalar, 3, 1> Vector;
  typedef Matrix<Scalar, 3, 3> SquareMatrix;
 
  const Vector v = Vector::Random();
 
  // assign to square matrix
  SquareMatrix sq;
  sq = v.asSkewSymmetric();
  VERIFY(sq.isSkewSymmetric());
 
  // assign to skew symmetric matrix
  SkewSymmetricMatrix3<Scalar> sk;
  sk = v.asSkewSymmetric();
  VERIFY_IS_APPROX(v, sk.vector());
}

References v, Eigen::SkewSymmetricMatrix3< Scalar_ >::vector(), VERIFY, and VERIFY_IS_APPROX.

Referenced by ProblemParameters::edge_sign_setup(), TestProblem::edge_sign_setup(), and Global_Physical_Variables::edge_sign_setup().

constructors()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::constructors

(

)

                    {
  typedef Matrix<Scalar, 3, 1> Vector;
  const Vector v = Vector::Random();
  // l-value
  const SkewSymmetricMatrix3<Scalar> s1(v);
  const Vector& v1 = s1.vector();
  VERIFY_IS_APPROX(v1, v);
  VERIFY(s1.cols() == 3);
  VERIFY(s1.rows() == 3);
 
  // r-value
  const SkewSymmetricMatrix3<Scalar> s2(std::move(v));
  VERIFY_IS_APPROX(v1, s2.vector());
  VERIFY_IS_APPROX(s1.toDenseMatrix(), s2.toDenseMatrix());
 
  // from scalars
  SkewSymmetricMatrix3<Scalar> s4(v1(0), v1(1), v1(2));
  VERIFY_IS_APPROX(v1, s4.vector());
 
  // constructors with four vectors do not compile
  // Matrix<Scalar, 4, 1> vector4 = Matrix<Scalar, 4, 1>::Random();
  // SkewSymmetricMatrix3<Scalar> s5(vector4);
}

References Eigen::SkewSymmetricBase< Derived >::cols(), Eigen::SkewSymmetricBase< Derived >::rows(), Eigen::SkewSymmetricBase< Derived >::toDenseMatrix(), v, v1(), Eigen::SkewSymmetricMatrix3< Scalar_ >::vector(), VERIFY, and VERIFY_IS_APPROX.

exponentialIdentity()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::exponentialIdentity

(

)

                           {
  typedef Matrix<Scalar, 3, 1> Vector;
  const Vector v1 = Vector::Zero();
  VERIFY(v1.asSkewSymmetric().exponential().isIdentity());
 
  Vector v2 = Vector::Random();
  v2.normalize();
  VERIFY((2 * EIGEN_PI * v2).asSkewSymmetric().exponential().isIdentity());
 
  Vector v3;
  const auto precision = static_cast<Scalar>(1.1) * NumTraits<Scalar>::dummy_precision();
  v3 << 0, 0, precision;
  VERIFY(v3.asSkewSymmetric().exponential().isIdentity(precision));
}

References EIGEN_PI, v1(), v2(), VERIFY, and oomph::PseudoSolidHelper::Zero.

exponentialOrthogonality()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::exponentialOrthogonality

(

)

                                {
  typedef Matrix<Scalar, 3, 1> Vector;
  typedef Matrix<Scalar, 3, 3> SquareMatrix;
  const Vector v = Vector::Random();
  SquareMatrix sq = v.asSkewSymmetric().exponential();
  VERIFY(sq.isUnitary());
}

References v, and VERIFY.

exponentialRotation()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::exponentialRotation

(

)

                           {
  typedef Matrix<Scalar, 3, 1> Vector;
  typedef Matrix<Scalar, 3, 3> SquareMatrix;
 
  // rotation axis is invariant
  const Vector v1 = Vector::Random();
  const SquareMatrix r1 = v1.asSkewSymmetric().exponential();
  VERIFY_IS_APPROX(r1 * v1, v1);
 
  // rotate around z-axis
  Vector v2;
  v2 << 0, 0, Scalar(EIGEN_PI);
  const SquareMatrix r2 = v2.asSkewSymmetric().exponential();
  VERIFY_IS_APPROX(r2 * (Vector() << 1, 0, 0).finished(), (Vector() << -1, 0, 0).finished());
  VERIFY_IS_APPROX(r2 * (Vector() << 0, 1, 0).finished(), (Vector() << 0, -1, 0).finished());
}

References EIGEN_PI, MergeRestartFiles::finished, v1(), v2(), and VERIFY_IS_APPROX.

multiplyScale()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::multiplyScale

(

)

                     {
  typedef Matrix<Scalar, 3, 1> Vector;
  typedef Matrix<Scalar, 3, 3> SquareMatrix;
 
  const Vector v1 = Vector::Random();
  SquareMatrix sq1;
  sq1 = v1.asSkewSymmetric();
  SkewSymmetricMatrix3<Scalar> sk1;
  sk1 = v1.asSkewSymmetric();
 
  const Scalar s1 = internal::random<Scalar>();
  VERIFY_IS_APPROX(SkewSymmetricMatrix3<Scalar>(sk1 * s1).vector(), sk1.vector() * s1);
  VERIFY_IS_APPROX(SkewSymmetricMatrix3<Scalar>(s1 * sk1).vector(), s1 * sk1.vector());
  VERIFY_IS_APPROX(sq1 * (sk1 * s1), (sq1 * sk1) * s1);
 
  const Vector v2 = Vector::Random();
  SquareMatrix sq2;
  sq2 = v2.asSkewSymmetric();
  SkewSymmetricMatrix3<Scalar> sk2;
  sk2 = v2.asSkewSymmetric();
  VERIFY_IS_APPROX(sk1 * sk2, sq1 * sq2);
 
  // null space
  VERIFY((sk1 * v1).isZero());
  VERIFY((sk2 * v2).isZero());
}

References v1(), v2(), Eigen::SkewSymmetricMatrix3< Scalar_ >::vector(), VERIFY, and VERIFY_IS_APPROX.

plusMinus()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::plusMinus

(

)

                 {
  typedef Matrix<Scalar, 3, 1> Vector;
  typedef Matrix<Scalar, 3, 3> SquareMatrix;
 
  const Vector v1 = Vector::Random();
  const Vector v2 = Vector::Random();
 
  SquareMatrix sq1;
  sq1 = v1.asSkewSymmetric();
  SquareMatrix sq2;
  sq2 = v2.asSkewSymmetric();
 
  SkewSymmetricMatrix3<Scalar> sk1;
  sk1 = v1.asSkewSymmetric();
  SkewSymmetricMatrix3<Scalar> sk2;
  sk2 = v2.asSkewSymmetric();
 
  VERIFY_IS_APPROX((sk1 + sk2).toDenseMatrix(), sq1 + sq2);
  VERIFY_IS_APPROX((sk1 - sk2).toDenseMatrix(), sq1 - sq2);
 
  SquareMatrix sq3 = v1.asSkewSymmetric();
  VERIFY_IS_APPROX(sq3 = v1.asSkewSymmetric() + v2.asSkewSymmetric(), sq1 + sq2);
  VERIFY_IS_APPROX(sq3 = v1.asSkewSymmetric() - v2.asSkewSymmetric(), sq1 - sq2);
  VERIFY_IS_APPROX(sq3 = v1.asSkewSymmetric() - 2 * v2.asSkewSymmetric() + v1.asSkewSymmetric(), sq1 - 2 * sq2 + sq1);
 
  VERIFY_IS_APPROX((sk1 + sk1).vector(), 2 * v1);
  VERIFY((sk1 - sk1).vector().isZero());
  VERIFY((sk1 - sk1).toDenseMatrix().isZero());
}

References v1(), v2(), VERIFY, and VERIFY_IS_APPROX.

Referenced by Eigen::EulerSystem< _AlphaAxis, _BetaAxis, _GammaAxis >::CalcEulerAngles_imp().

skewSymmetricMultiplication()

template<typename Matrix >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::skewSymmetricMultiplication

(

const Matrix &

m

)

                                                  {
  typedef Eigen::Matrix<typename Matrix::Scalar, 3, 1> Vector;
  const Vector v = Vector::Random();
  const Matrix m1 = Matrix::Random(m.rows(), m.cols());
  const SkewSymmetricMatrix3<typename Matrix::Scalar> sk = v.asSkewSymmetric();
  VERIFY_IS_APPROX(m1.transpose() * (sk * m1), (m1.transpose() * sk) * m1);
  VERIFY((m1.transpose() * (sk * m1)).isSkewSymmetric());
}

References m, m1, v, VERIFY, and VERIFY_IS_APPROX.

Referenced by EIGEN_DECLARE_TEST().

traceAndDet()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::traceAndDet

(

)

                   {
  typedef Matrix<Scalar, 3, 1> Vector;
  const Vector v = Vector::Random();
  // this does not work, values larger than 1.e-08 can be seen
  // VERIFY_IS_APPROX(sq.determinant(), static_cast<Scalar>(0));
  VERIFY_IS_APPROX(v.asSkewSymmetric().determinant(), static_cast<Scalar>(0));
  VERIFY_IS_APPROX(v.asSkewSymmetric().toDenseMatrix().trace(), static_cast<Scalar>(0));
}

References v, and VERIFY_IS_APPROX.

transpose()

template<typename Scalar >

void anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose

(

)

                 {
  typedef Matrix<Scalar, 3, 1> Vector;
  const Vector v = Vector::Random();
  // By definition of a skew symmetric matrix: A^T = -A
  VERIFY_IS_APPROX(v.asSkewSymmetric().toDenseMatrix().transpose(), v.asSkewSymmetric().transpose().toDenseMatrix());
  VERIFY_IS_APPROX(v.asSkewSymmetric().transpose().vector(), (-v).asSkewSymmetric().vector());
}

References v, and VERIFY_IS_APPROX.

Referenced by Eigen::CompleteOrthogonalDecomposition< MatrixType_, PermutationIndex_ >::_solve_impl_transposed(), Eigen::CompleteOrthogonalDecomposition< MatrixType_, PermutationIndex_ >::applyZOnTheLeftInPlace(), Eigen::internal::assign_sparse_to_sparse(), oomph::SuperLUSolver::backsub_serial(), oomph::SuperLUSolver::backsub_transpose_serial(), block(), check_indexed_view(), oomph::CRComplexMatrix::clean_up_memory(), oomph::CCComplexMatrix::clean_up_memory(), oomph::SuperLUSolver::clean_up_memory(), comparisons(), Eigen::RefBase< Derived >::construct(), Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::dhs_cblock(), Eigen::BDCSVD< MatrixType_, Options_ >::divide(), EIGEN_DECLARE_TEST(), oomph::SuperLUSolver::factorise_serial(), integer_type_tests(), Eigen::MatrixBase< Derived >::isSkewSymmetric(), oomph::CRComplexMatrix::lubksub(), oomph::CCComplexMatrix::lubksub(), oomph::CRComplexMatrix::ludecompose(), oomph::CCComplexMatrix::ludecompose(), product(), Eigen::internal::solve_assertion< Transpose< Derived > >::run(), run_nesting_ops_2(), selfadjointeigensolver_essential_check(), symm(), and trmm().