Eigen::test Namespace Reference

Classes
struct	runall< Scalar, PacketType, false, false >
struct	runall< Scalar, PacketType, false, true >
struct	runall< Scalar, PacketType, true, false >
struct	packet_helper
struct	packet_helper< false, Packet >
struct	runall
struct	runner
struct	runner< Scalar, PacketType, true, true >
struct	runner< Scalar, PacketType, true, false >
struct	runner< Scalar, PacketType, false, false >

Functions
template<typename T , std::enable_if_t< NumTraits< T >::IsSigned, bool > = true>
T	negate (const T &x)
template<typename T >
Map< const Array< unsigned char, sizeof(T), 1 > >	bits (const T &x)
template<typename T >
bool	biteq (T a, T b)
template<typename Scalar >
EIGEN_DONT_INLINE bool	isApproxAbs (const Scalar &a, const Scalar &b, const typename NumTraits< Scalar >::Real &refvalue)
template<typename Scalar >
void	print_mismatch (const Scalar *ref, const Scalar *vec, int size)
template<typename Scalar >
bool	areApproxAbs (const Scalar *a, const Scalar *b, int size, const typename NumTraits< Scalar >::Real &refvalue)
template<typename Scalar >
bool	areApprox (const Scalar *a, const Scalar *b, int size)
template<typename Scalar >
bool	areEqual (const Scalar *a, const Scalar *b, int size)
template<typename Scalar >
bool	areApprox (const Scalar *a, const Scalar *b, int size, const typename NumTraits< Scalar >::Real &precision)

Function Documentation

areApprox() [1/2]

template<typename Scalar >

bool Eigen::test::areApprox	(	const Scalar *	a,
		const Scalar *	b,
		int	size
	)

                                                           {
  for (int i = 0; i < size; ++i) {
    if (numext::not_equal_strict(a[i], b[i]) && !internal::isApprox(a[i], b[i]) &&
        !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
      print_mismatch(a, b, size);
      std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                << std::endl;
      return false;
    }
  }
  return true;
}

References a, b, i, Eigen::internal::isApprox(), Eigen::numext::isnan(), Eigen::numext::not_equal_strict(), print_mismatch(), and size.

Referenced by packetmath(), packetmath_complex(), packetmath_notcomplex(), packetmath_real(), test_cast_helper< SrcPacket, TgtPacket, SrcCoeffRatio, TgtCoeffRatio, true >::run(), and test_conj_helper().

areApprox() [2/2]

template<typename Scalar >

bool Eigen::test::areApprox	(	const Scalar *	a,
		const Scalar *	b,
		int	size,
		const typename NumTraits< Scalar >::Real &	precision
	)

                                                                                                            {
  for (int i = 0; i < size; ++i) {
    if (numext::not_equal_strict(a[i], b[i]) && !internal::isApprox(a[i], b[i], precision) &&
        !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
      print_mismatch(a, b, size);
      std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                << std::endl;
      return false;
    }
  }
  return true;
}

References a, b, i, Eigen::internal::isApprox(), Eigen::numext::isnan(), Eigen::numext::not_equal_strict(), print_mismatch(), and size.

areApproxAbs()

template<typename Scalar >

bool Eigen::test::areApproxAbs	(	const Scalar *	a,
		const Scalar *	b,
		int	size,
		const typename NumTraits< Scalar >::Real &	refvalue
	)

                                                                                                              {
  for (int i = 0; i < size; ++i) {
    if (!isApproxAbs(a[i], b[i], refvalue)) {
      print_mismatch(a, b, size);
      std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                << std::endl;
      return false;
    }
  }
  return true;
}

References a, b, i, isApproxAbs(), print_mismatch(), and size.

areEqual()

template<typename Scalar >

bool Eigen::test::areEqual	(	const Scalar *	a,
		const Scalar *	b,
		int	size
	)

                                                          {
  for (int i = 0; i < size; ++i) {
    if (numext::not_equal_strict(a[i], b[i]) && !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
      print_mismatch(a, b, size);
      std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                << std::endl;
      return false;
    }
  }
  return true;
}

References a, b, i, Eigen::numext::isnan(), Eigen::numext::not_equal_strict(), print_mismatch(), and size.

biteq()

template<typename T >

bool Eigen::test::biteq	(	T	a,
		T	b
	)

                     {
  return (bits(a) == bits(b)).all();
}

References a, b, and bits().

Referenced by packetmath_real().

bits()

template<typename T >

Map<const Array<unsigned char, sizeof(T), 1> > Eigen::test::bits

(

const T &

x

)

                                                                {
  return Map<const Array<unsigned char, sizeof(T), 1> >(reinterpret_cast<const unsigned char*>(&x));
}

References plotDoE::x.

Referenced by biteq(), Eigen::internal::count_bits_impl< BitsType, EnableIf >::clz(), Eigen::internal::clz(), Eigen::internal::count_bits_impl< BitsType, EnableIf >::ctz(), Eigen::internal::ctz(), packetmath_real(), and saveAsBitmap().

isApproxAbs()

template<typename Scalar >

EIGEN_DONT_INLINE bool Eigen::test::isApproxAbs	(	const Scalar &	a,
		const Scalar &	b,
		const typename NumTraits< Scalar >::Real &	refvalue
	)

                                                                                                                     {
  return internal::isMuchSmallerThan(a - b, refvalue);
}

References a, b, and Eigen::internal::isMuchSmallerThan().

Referenced by areApproxAbs(), packetmath(), and packetmath_scatter_gather().

negate()

template<typename T , std::enable_if_t< NumTraits< T >::IsSigned, bool > = true>

T Eigen::test::negate

(

const T &

x

)

                     {
  return -x;
}

References plotDoE::x.

Referenced by check_abs(), check_negate(), Eigen::internal::scalar_opposite_op< Scalar >::operator()(), Eigen::internal::pnegate(), REF_NMSUB(), check_signbit_impl< T >::run(), and negate_test_impl< Scalar, Packet, HasNegate >::run_negate().

print_mismatch()

template<typename Scalar >

void Eigen::test::print_mismatch ( const Scalar *  ref, const Scalar *  vec, int  size  )

inline

                                                                           {
  std::cout << "ref: [" << Map<const Matrix<Scalar, 1, Dynamic> >(ref, size) << "]"
            << " != vec: [" << Map<const Matrix<Scalar, 1, Dynamic> >(vec, size) << "]\n";
}

References size.

Referenced by areApprox(), areApproxAbs(), and areEqual().