complex_test.cpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

      
      result = boost::math::asinh(ct(-infinity, -infinity));
      BOOST_CHECK(result.real() == -infinity);
      BOOST_CHECK_CLOSE(result.imag(), -quarter_pi, eps*200);
      
      result = boost::math::asinh(ct(-infinity, infinity));
      BOOST_CHECK(result.real() == -infinity);
      BOOST_CHECK_CLOSE(result.imag(), quarter_pi, eps*200);
   }

   if(test_nan)
   {
      result = boost::math::asinh(ct(infinity, nan));
      BOOST_CHECK(result.real() == infinity);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(-infinity, nan));
      BOOST_CHECK(result.real() == -infinity);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(nan, zero));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(result.imag() == 0);

      result = boost::math::asinh(ct(nan,  mzero));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(result.imag() == 0);

      result = boost::math::asinh(ct(nan, one));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(nan,  -one));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(nan,  nan));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(nan, infinity));
      BOOST_CHECK(std::fabs(result.real()) == infinity);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::asinh(ct(nan,  -infinity));
      BOOST_CHECK(std::fabs(result.real()) == infinity);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));
   }
   
   //
   // C99 special cases for atanh:
   //
   result = boost::math::atanh(ct(zero, zero));
   BOOST_CHECK(result.real() == zero);
   BOOST_CHECK(result.imag() == zero);

   result = boost::math::atanh(ct(mzero, zero));
   BOOST_CHECK(result.real() == zero);
   BOOST_CHECK(result.imag() == zero);

   result = boost::math::atanh(ct(zero, mzero));
   BOOST_CHECK(result.real() == zero);
   BOOST_CHECK(result.imag() == zero);

   result = boost::math::atanh(ct(mzero, mzero));
   BOOST_CHECK(result.real() == zero);
   BOOST_CHECK(result.imag() == zero);

   if(test_nan)
   {
      result = boost::math::atanh(ct(zero, nan));
      BOOST_CHECK(result.real() == zero);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(-zero, nan));
      BOOST_CHECK(result.real() == zero);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));
   }

   if(test_infinity)
   {
      result = boost::math::atanh(ct(one, zero));
      BOOST_CHECK_EQUAL(result.real(), infinity);
      BOOST_CHECK_EQUAL(result.imag(), zero);

      result = boost::math::atanh(ct(-one, zero));
      BOOST_CHECK_EQUAL(result.real(), -infinity);
      BOOST_CHECK_EQUAL(result.imag(), zero);

      result = boost::math::atanh(ct(-one, -zero));
      BOOST_CHECK_EQUAL(result.real(), -infinity);
      BOOST_CHECK_EQUAL(result.imag(), zero);

      result = boost::math::atanh(ct(one, -zero));
      BOOST_CHECK_EQUAL(result.real(), infinity);
      BOOST_CHECK_EQUAL(result.imag(), zero);

      result = boost::math::atanh(ct(pi, infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);

      result = boost::math::atanh(ct(pi, -infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-pi, -infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-pi, infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);
   }
   if(test_nan)
   {
      result = boost::math::atanh(ct(pi, nan));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(-pi, nan));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));
   }

   if(test_infinity)
   {
      result = boost::math::atanh(ct(infinity, pi));
      BOOST_CHECK(result.real() == zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);

      result = boost::math::atanh(ct(infinity, -pi));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-infinity, -pi));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-infinity, pi));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);

      result = boost::math::atanh(ct(infinity, infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);

      result = boost::math::atanh(ct(infinity, -infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-infinity, -infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(-infinity, infinity));
      BOOST_CHECK_EQUAL(result.real(), zero);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);
   }

   if(test_nan)
   {
      result = boost::math::atanh(ct(infinity, nan));
      BOOST_CHECK(result.real() == 0);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(-infinity, nan));
      BOOST_CHECK(result.real() == 0);
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(nan, pi));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(nan, -pi));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

      result = boost::math::atanh(ct(nan, infinity));
      BOOST_CHECK(result.real() == 0);
      BOOST_CHECK_CLOSE(result.imag(), half_pi, eps*200);

      result = boost::math::atanh(ct(nan, -infinity));
      BOOST_CHECK(result.real() == 0);
      BOOST_CHECK_CLOSE(result.imag(), -half_pi, eps*200);

      result = boost::math::atanh(ct(nan, nan));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.real()));
      BOOST_CHECK(boost::math::detail::test_is_nan(result.imag()));

   }
}

//
// test_boundaries:
// This is an accuracy test, sets the real and imaginary components
// of the input argument to various "boundary conditions" that exist
// inside the implementation.  Then computes the result at double precision
// and again at float precision.  The double precision result will be
// computed using the "regular" code, where as the float precision versions
// will calculate the result using the "exceptional value" handlers, so
// we end up comparing the values calculated by two different methods.
//
const float boundaries[] = {
   0,
   1,
   2,
   (std::numeric_limits<float>::max)(),
   (std::numeric_limits<float>::min)(),
   std::numeric_limits<float>::epsilon(),
   std::sqrt((std::numeric_limits<float>::max)()) / 8,
   static_cast<float>(4) * std::sqrt((std::numeric_limits<float>::min)()),
   0.6417F,
   1.5F,
   std::sqrt((std::numeric_limits<float>::max)()) / 2,
   std::sqrt((std::numeric_limits<float>::min)()),
   1.0F / 0.3F,
};

void do_test_boundaries(float x, float y)
{
   std::complex<float> r1 = boost::math::asin(std::complex<float>(x, y));
   std::complex<double> dr = boost::math::asin(std::complex<double>(x, y));
   std::complex<float> r2(static_cast<float>(dr.real()), static_cast<float>(dr.imag()));
   check_complex(r2, r1, 5);
   r1 = boost::math::acos(std::complex<float>(x, y));
   dr = boost::math::acos(std::complex<double>(x, y));
   r2 = std::complex<float>(std::complex<double>(dr.real(), dr.imag()));
   check_complex(r2, r1, 5);
   r1 = boost::math::atanh(std::complex<float>(x, y));
   dr = boost::math::atanh(std::complex<double>(x, y));
   r2 = std::complex<float>(std::complex<double>(dr.real(), dr.imag()));
   check_complex(r2, r1, 5);
}

void test_boundaries(float x, float y)
{
   do_test_boundaries(x, y);
   do_test_boundaries(-x, y); 
   do_test_boundaries(-x, -y);
   do_test_boundaries(x, -y);
}

void test_boundaries(float x)
{
   for(unsigned i = 0; i < sizeof(boundaries)/sizeof(float); ++i)
   {
      test_boundaries(x, boundaries[i]);
      test_boundaries(x, boundaries[i] + std::numeric_limits<float>::epsilon()*boundaries[i]);
      test_boundaries(x, boundaries[i] - std::numeric_limits<float>::epsilon()*boundaries[i]);
   }
}

void test_boundaries()
{
   for(unsigned i = 0; i < sizeof(boundaries)/sizeof(float); ++i)
   {
      test_boundaries(boundaries[i]);
      test_boundaries(boundaries[i] + std::numeric_limits<float>::epsilon()*boundaries[i]);
      test_boundaries(boundaries[i] - std::numeric_limits<float>::epsilon()*boundaries[i]);//here
   }
}


int test_main(int, char*[])
{
   std::cout << "Running complex trig sanity checks for type float." << std::endl;
   test_inverse_trig(float(0));
   std::cout << "Running complex trig sanity checks for type double." << std::endl;
   test_inverse_trig(double(0));
   //test_inverse_trig((long double)(0));

   std::cout << "Running complex trig spot checks for type float." << std::endl;
   check_spots(float(0));
   std::cout << "Running complex trig spot checks for type double." << std::endl;
   check_spots(double(0));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
   std::cout << "Running complex trig spot checks for type long double." << std::endl;
   check_spots((long double)(0));
#endif

   std::cout << "Running complex trig boundary and accuracy tests." << std::endl;
   test_boundaries();
   return 0;
}