exp_complex_test_impl< Scalar, Packet, HasExp > Struct Template Reference

Public Types
typedef Scalar::value_type	RealScalar

Static Public Member Functions
static Scalar	pexp1 (const Scalar &x)
static Scalar	cis (const RealScalar &x)
static bool	is_exactly_equal (RealScalar a, RealScalar b)
static bool	is_exactly_equal (const Scalar &a, const Scalar &b)
static bool	is_sign_exp_unspecified (const Scalar &z)
static void	run (Scalar *data1, Scalar *data2, Scalar *ref, int size)

Member Typedef Documentation

RealScalar

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

typedef Scalar::value_type exp_complex_test_impl< Scalar, Packet, HasExp >::RealScalar

Member Function Documentation

cis()

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static Scalar exp_complex_test_impl< Scalar, Packet, HasExp >::cis ( const RealScalar &  x )

inlinestatic

{ return Scalar(numext::cos(x), numext::sin(x)); }

References cos(), sin(), and plotDoE::x.

is_exactly_equal() [1/2]

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static bool exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal ( const Scalar &  a, const Scalar &  b  )

inlinestatic

                                                                 {
    bool result = is_exactly_equal(numext::real_ref(a), numext::real_ref(b)) &&
                  is_exactly_equal(numext::imag_ref(a), numext::imag_ref(b));
    if (!result) {
      std::cout << a << " != " << b << std::endl;
    }
    return result;
  }

References a, b, Eigen::numext::imag_ref(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), and Eigen::numext::real_ref().

is_exactly_equal() [2/2]

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static bool exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal ( RealScalar  a, RealScalar  b  )

inlinestatic

                                                           {
    // NaNs are always unsigned, and always compare not equal directly.
    if ((numext::isnan)(a)) {
      return (numext::isnan)(b);
    }
 
    RealScalar zero(0);
#ifdef EIGEN_ARCH_ARM
    // ARM automatically flushes denormals to zero.
    // Preserve sign by multiplying by +0.
    if (numext::abs(a) < (std::numeric_limits<RealScalar>::min)()) {
      a = a * zero;
    }
    if (numext::abs(b) < (std::numeric_limits<RealScalar>::min)()) {
      b = b * zero;
    }
#endif
 
    // Signed zero.
    if (a == zero) {
      // Signs are either 0 or NaN, so verify that their comparisons to zero are equal.
      return (a == b) && ((numext::signbit(a) == zero) == (numext::signbit(b) == zero));
    }
    // Allow _some_ tolerance.
    return verifyIsApprox(a, b);
  }

References a, abs(), b, isnan, min, Eigen::numext::signbit(), Eigen::verifyIsApprox(), and zero().

Referenced by exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), and exp_complex_test_impl< Scalar, Packet, HasExp >::run().

is_sign_exp_unspecified()

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static bool exp_complex_test_impl< Scalar, Packet, HasExp >::is_sign_exp_unspecified ( const Scalar &  z )

inlinestatic

                                                       {
    const RealScalar inf = std::numeric_limits<RealScalar>::infinity();
    // If z is (-∞,±∞), the result is (±0,±0) (signs are unspecified)
    if (numext::real_ref(z) == -inf && (numext::isinf)(numext::imag_ref(z))) {
      return true;
    }
    // If z is (+∞,±∞), the result is (±∞,NaN) and FE_INVALID is raised (the sign of the real part is unspecified)
    if (numext::real_ref(z) == +inf && (numext::isinf)(numext::imag_ref(z))) {
      return true;
    }
    // If z is (-∞,NaN), the result is (±0,±0) (signs are unspecified)
    if (numext::real_ref(z) == -inf && (numext::isnan)(numext::imag_ref(z))) {
      return true;
    }
    // If z is (+∞,NaN), the result is (±∞,NaN) (the sign of the real part is unspecified)
    if (numext::real_ref(z) == +inf && (numext::isnan)(numext::imag_ref(z))) {
      return true;
    }
    return false;
  }

References Eigen::numext::imag_ref(), constants::inf, isinf, isnan, and Eigen::numext::real_ref().

Referenced by exp_complex_test_impl< Scalar, Packet, HasExp >::run().

pexp1()

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static Scalar exp_complex_test_impl< Scalar, Packet, HasExp >::pexp1 ( const Scalar &  x )

inlinestatic

                                       {
    Packet px = internal::pset1<Packet>(x);
    Packet py = internal::pexp(px);
    return internal::pfirst(py);
  }

References Eigen::internal::pexp(), Eigen::internal::pfirst(), px, py, and plotDoE::x.

Referenced by exp_complex_test_impl< Scalar, Packet, HasExp >::run().

run()

template<typename Scalar , typename Packet , bool HasExp = internal::packet_traits<Scalar>::HasExp>

static void exp_complex_test_impl< Scalar, Packet, HasExp >::run ( Scalar *  data1, Scalar *  data2, Scalar *  ref, int  size  )

inlinestatic

                                                                       {
    const int PacketSize = internal::unpacket_traits<Packet>::size;
 
    for (int i = 0; i < size; ++i) {
      data1[i] = Scalar(internal::random<RealScalar>(), internal::random<RealScalar>());
    }
    CHECK_CWISE1_N(std::exp, internal::pexp, size);
 
    // Test all corner cases (and more).
    const RealScalar edges[] = {RealScalar(0),
                                RealScalar(1),
                                RealScalar(2),
                                RealScalar(EIGEN_PI / 2),
                                RealScalar(EIGEN_PI),
                                RealScalar(3 * EIGEN_PI / 2),
                                RealScalar(2 * EIGEN_PI),
                                numext::log(NumTraits<RealScalar>::highest()) - 1,
                                NumTraits<RealScalar>::highest(),
                                std::numeric_limits<RealScalar>::infinity(),
                                std::numeric_limits<RealScalar>::quiet_NaN(),
                                -RealScalar(0),
                                -RealScalar(1),
                                -RealScalar(2),
                                -RealScalar(EIGEN_PI / 2),
                                -RealScalar(EIGEN_PI),
                                -RealScalar(3 * EIGEN_PI / 2),
                                -RealScalar(2 * EIGEN_PI),
                                -numext::log(NumTraits<RealScalar>::highest()) + 1,
                                -NumTraits<RealScalar>::highest(),
                                -std::numeric_limits<RealScalar>::infinity(),
                                -std::numeric_limits<RealScalar>::quiet_NaN()};
 
    for (RealScalar x : edges) {
      for (RealScalar y : edges) {
        Scalar z = Scalar(x, y);
        Scalar w = pexp1(z);
        if (is_sign_exp_unspecified(z)) {
          Scalar abs_w = Scalar(numext::abs(numext::real_ref(w)), numext::abs(numext::imag_ref(w)));
          Scalar expected = numext::exp(z);
          Scalar abs_expected =
              Scalar(numext::abs(numext::real_ref(expected)), numext::abs(numext::imag_ref(expected)));
          VERIFY(is_exactly_equal(abs_w, abs_expected));
        } else {
          VERIFY(is_exactly_equal(w, numext::exp(z)));
        }
      }
    }
  }

References abs(), CHECK_CWISE1_N, EIGEN_PI, Eigen::bfloat16_impl::exp(), i, Eigen::numext::imag_ref(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_sign_exp_unspecified(), Eigen::bfloat16_impl::log(), Eigen::internal::pexp(), exp_complex_test_impl< Scalar, Packet, HasExp >::pexp1(), Eigen::numext::real_ref(), size, VERIFY, w, plotDoE::x, and y.

Referenced by exp_complex_test().

---

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

• packetmath.cpp