adjoint_specific< false > Struct Reference

Static Public Member Functions
template<typename Vec , typename Mat , typename Scalar >
static void	run (const Vec &v1, const Vec &v2, Vec &v3, const Mat &square, Scalar s1, Scalar s2)

Member Function Documentation

run()

template<typename Vec , typename Mat , typename Scalar >

static void adjoint_specific< false >::run ( const Vec &  v1, const Vec &  v2, Vec &  v3, const Mat &  square, Scalar  s1, Scalar  s2  )

inlinestatic

                                                                                                  {
    typedef typename NumTraits<Scalar>::Real RealScalar;
    using std::abs;
 
    RealScalar ref = NumTraits<Scalar>::IsInteger ? RealScalar(0) : (std::max)((s1 * v1 + s2 * v2).norm(), v3.norm());
    VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3),
                                numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), ref));
    VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1 * v3.dot(v1) + s2 * v3.dot(v2), ref));
 
    VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm());
    // check normalized() and normalize()
    VERIFY_IS_APPROX(v1, v1.norm() * v1.normalized());
    v3 = v1;
    v3.normalize();
    VERIFY_IS_APPROX(v1, v1.norm() * v3);
    VERIFY_IS_APPROX(v3, v1.normalized());
    VERIFY_IS_APPROX(v3.norm(), RealScalar(1));
 
    // check null inputs
    VERIFY_IS_APPROX((v1 * 0).normalized(), (v1 * 0));
#if (!EIGEN_ARCH_i386) || defined(EIGEN_VECTORIZE)
    RealScalar very_small = (std::numeric_limits<RealScalar>::min)();
    VERIFY(numext::is_exactly_zero((v1 * very_small).norm()));
    VERIFY_IS_APPROX((v1 * very_small).normalized(), (v1 * very_small));
    v3 = v1 * very_small;
    v3.normalize();
    VERIFY_IS_APPROX(v3, (v1 * very_small));
#endif
 
    // check compatibility of dot and adjoint
    ref = NumTraits<Scalar>::IsInteger ? 0
                                       : (std::max)((std::max)(v1.norm(), v2.norm()),
                                                    (std::max)((square * v2).norm(), (square.adjoint() * v1).norm()));
    VERIFY(internal::isMuchSmallerThan(abs(v1.dot(square * v2) - (square.adjoint() * v1).dot(v2)), ref,
                                       test_precision<Scalar>()));
 
    // check that Random().normalized() works: tricky as the random xpr must be evaluated by
    // normalized() in order to produce a consistent result.
    VERIFY_IS_APPROX(Vec::Random(v1.size()).normalized().norm(), RealScalar(1));
  }

References abs(), conj(), dot(), Eigen::numext::is_exactly_zero(), Eigen::internal::isMuchSmallerThan(), max, min, Eigen::square(), Eigen::test_isApproxWithRef(), v1(), v2(), VERIFY, and VERIFY_IS_APPROX.

---

The documentation for this struct was generated from the following file:

• adjoint.cpp