ap_fixedTest.cxx File Reference

#include "CxxUtils/checker_macros.h"
#include "gtest/gtest.h"
#include "../ap_fixed.h"
#include <sstream>
#include <cmath>

Include dependency graph for ap_fixedTest.cxx:

Go to the source code of this file.

Functions
constexpr int	pow (int base, int exp) noexcept
template<int W, int P>
constexpr double	min ()
template<int W, int P>
constexpr double	max ()
	TEST (ap_fixedTester, minmax)
	TEST (ap_fixedTester, stablity)
	TEST (ap_fixedTester, specialValue)
	TEST (ap_fixedTester, overflow_h)
	TEST (ap_fixedTester, overflow_l)
	TEST (ap_fixedTester, addition)
	TEST (ap_fixedTester, addition1)
	TEST (ap_fixedTester, subtraction)
	TEST (ap_fixedTester, subtraction1)
	TEST (ap_fixedTester, multiplication)
	TEST (ap_fixedTester, multiplication1)
	TEST (ap_fixedTester, division)
	TEST (ap_fixedTester, division1)
	TEST (ap_fixedTester, negation)
	TEST (ap_fixedTester, doubleMult)

Variables
	ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Function Documentation

max()

template<int W, int P>

double max ( )

constexpr

Definition at line 33 of file ap_fixedTest.cxx.

                        {
  static_assert(W >= P);
  static_assert(P >= 0);
  return static_cast<double>(pow(2, W-1)-1)/static_cast<double>(pow(2, P));
}

min()

template<int W, int P>

double min ( )

constexpr

Definition at line 26 of file ap_fixedTest.cxx.

                       {
  static_assert(W >= P);
  static_assert(P >= 0);
  return -pow(2, W-1)/pow(2, P);
}

pow()

int pow ( int base, int exp )

constexprnoexcept

Definition at line 15 of file ap_fixedTest.cxx.

                                              {
  auto result{1};
 
  for(int i = 0; i < exp; ++i) {
    result *= base;
  }
 
  return result;
}

TEST() [1/15]

TEST	(	ap_fixedTester	,
		addition	)

Definition at line 114 of file ap_fixedTest.cxx.

                               {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_sum = ap(1) + ap(2);
  auto val = static_cast<double>(ap_sum);
  auto diff = std::abs(val - 3);
  
  EXPECT_EQ (3, val);
  EXPECT_LT (diff, eps);
 
  ap_sum = ap(1.5) + ap(2.5);
  val = static_cast<double>(ap_sum);
  diff = std::abs(val - 4);
  
  EXPECT_EQ (4, val);
  EXPECT_LT (diff, eps);
}

TEST() [2/15]

TEST	(	ap_fixedTester	,
		addition1	)

Definition at line 136 of file ap_fixedTest.cxx.

                                {
  
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_sum = ap(2) += 1;
  auto val = static_cast<double>(ap_sum);
  auto diff = std::abs(val - 3);
   
  EXPECT_EQ (3, val);
  EXPECT_LT (diff, eps);
 
  ap_sum = ap(1.5) += 2.5;
  val = static_cast<double>(ap_sum);
  diff = std::abs(val - 4);
  
  EXPECT_EQ (4, val);
  EXPECT_LT (diff, eps);
}

TEST() [3/15]

TEST	(	ap_fixedTester	,
		division	)

Definition at line 249 of file ap_fixedTest.cxx.

                               {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_div = ap(1)/ap(2);
  auto val = static_cast<double>(ap_div);
  auto diff = std::abs(val - 0.5);
 
  EXPECT_EQ (0.5, val);
  EXPECT_LT (diff, eps);
 
  ap_div = ap(-1.5)/ap(2);
  val = static_cast<double>(ap_div);
  diff = std::abs(val + 0.75);
 
  EXPECT_EQ (-0.75, val);
  EXPECT_LT (diff, eps);
}

TEST() [4/15]

TEST	(	ap_fixedTester	,
		division1	)

Definition at line 272 of file ap_fixedTest.cxx.

                                {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_div = ap(1)/=ap(2);
  auto val = static_cast<double>(ap_div);
  auto diff = std::abs(val - 0.5);
 
  EXPECT_EQ (0.5, val);
  EXPECT_LT (diff, eps);
 
  ap_div = ap(-1.5)/ap(2);
  val = static_cast<double>(ap_div);
  diff = std::abs(val + 0.75);
 
  EXPECT_EQ (-0.75, val);
  EXPECT_LT (diff, eps);
}

TEST() [5/15]

TEST	(	ap_fixedTester	,
		doubleMult	)

Definition at line 314 of file ap_fixedTest.cxx.

                                 {
 
  constexpr int width{10};
  constexpr int prec{5};
 
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
  ap ap_mul = 9.99 * ap(1);
 
  EXPECT_EQ (10, static_cast<double>(ap_mul));
}

TEST() [6/15]

TEST	(	ap_fixedTester	,
		minmax	)

Definition at line 39 of file ap_fixedTest.cxx.

                              {
 
  auto min_v = min<10, 5>();
  auto max_v = max<10, 5>();
  EXPECT_EQ(-16, min_v);
  EXPECT_EQ(15.96875, max_v);
}

TEST() [7/15]

TEST	(	ap_fixedTester	,
		multiplication	)

Definition at line 205 of file ap_fixedTest.cxx.

                                     {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_prod = ap(1) * ap(2);
  auto val = static_cast<double>(ap_prod);
  auto diff = std::abs(val - 2);
 
  EXPECT_EQ (2, val);
  EXPECT_LT (diff, eps);
 
  ap_prod = ap(-1.5)*ap(2);
  val = static_cast<double>(ap_prod);
  diff = std::abs(val +3);
 
  EXPECT_EQ (-3, val);
  EXPECT_LT (diff, eps);
}

TEST() [8/15]

TEST	(	ap_fixedTester	,
		multiplication1	)

Definition at line 227 of file ap_fixedTest.cxx.

                                      {
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_prod = ap(1) *= ap(2);
  auto val = static_cast<double>(ap_prod);
  auto diff = std::abs(val - 2);
 
  EXPECT_EQ (2, val);
  EXPECT_LT (diff, eps);
 
  ap_prod = ap(-1.5) *= ap(2.);
  val = static_cast<double>(ap_prod);
  diff = std::abs(val +3);
  
  EXPECT_EQ (-3, val);
  EXPECT_LT (diff, eps);
}

TEST() [9/15]

TEST	(	ap_fixedTester	,
		negation	)

Definition at line 295 of file ap_fixedTest.cxx.

                               {
 
  constexpr int width{10};
  constexpr int prec{5};
 
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  auto ap_p = ap(1);
  auto ap_n = -ap_p;
  auto ap_pp = -ap_n;
  
  auto val_p = static_cast<double>(ap_p);
  auto val_n = static_cast<double>(ap_n);
  auto val_pp = static_cast<double>(ap_pp);
 
  EXPECT_EQ (val_p, -val_n);
  EXPECT_EQ (val_p, val_pp);
}

TEST() [10/15]

TEST	(	ap_fixedTester	,
		overflow_h	)

EXPECT does not take templates, provide a new typename

Definition at line 90 of file ap_fixedTest.cxx.

                                 {
  constexpr int width{10};
  constexpr int prec{5};

  using ap = typename GlobalSim::ap_fixed<width, prec, GlobalSim::Round>; 
  // out of range by 0.5*prec
  double outOfRange = max<width, prec>() + pow(2, -prec-1);
 
  EXPECT_THROW ((ap(outOfRange)), std::out_of_range);
}

TEST() [11/15]

TEST	(	ap_fixedTester	,
		overflow_l	)

Definition at line 102 of file ap_fixedTest.cxx.

                                 {
  constexpr int width{10};
  constexpr int prec{5};
 
  // out of range by 0.5*prec
  double outOfRange = min<width, prec>() - pow(2, -prec-1);
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  EXPECT_THROW ((ap(outOfRange)), std::out_of_range);
}

TEST() [12/15]

TEST	(	ap_fixedTester	,
		specialValue	)

Definition at line 78 of file ap_fixedTest.cxx.

                                   {
 
  //Xylinx ap_fixed gets this wrong
  auto apf =  GlobalSim::ap_fixed<10, 5, GlobalSim::Round>(-0.327374935);
  EXPECT_EQ (-0.3125, static_cast<double>(apf));
  std::stringstream ss;
  ss << std::hex << apf.m_value;
  EXPECT_EQ ("fff6", ss.str());
}

TEST() [13/15]

TEST	(	ap_fixedTester	,
		stablity	)

Definition at line 47 of file ap_fixedTest.cxx.

                               {
 
 
  constexpr int width{10};
  constexpr int prec{5};
  double delta = pow(2, -prec-1); // step by a value less then precision
  
  double val = min<width, prec>();
  double max_val = max<width, prec>();
  double cval = -val;
 
  std::size_t i{0};
 
  while (cval <= max_val) {
    
    auto ap_gs0 = GlobalSim::ap_fixed<10, 5, GlobalSim::Round>(cval);
    double d0 = static_cast<double>(ap_gs0);
    auto ap_gs1 = GlobalSim::ap_fixed<10, 5>(d0);
    double d1 = static_cast<double>(ap_gs1);
    auto ap_gs2 = GlobalSim::ap_fixed<10, 5>(d1);
    double d2 = static_cast<double>(ap_gs2);
   
    EXPECT_EQ (d2, d0);
    EXPECT_EQ (ap_gs0.m_value, ap_gs2.m_value);
    EXPECT_LT (std::abs(d0 -cval), 1./(2*2*2*2*2));
   
 
    cval =  -val + ((++i) * delta);
  }
}

TEST() [14/15]

TEST	(	ap_fixedTester	,
		subtraction	)

Definition at line 159 of file ap_fixedTest.cxx.

                                  {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_diff = ap(1) - ap(2);
  auto val = static_cast<double>(ap_diff);
  auto diff = std::abs(val + 1); 
 
  EXPECT_EQ (-1, val);
  EXPECT_LT (diff, eps);
 
  ap_diff = ap(1.5) - ap(2.5);
  val = static_cast<double>(ap_diff);
  diff = std::abs(val + 1); 
 
  EXPECT_EQ (-1, val);
  EXPECT_LT (diff, eps);
}

TEST() [15/15]

TEST	(	ap_fixedTester	,
		subtraction1	)

Definition at line 181 of file ap_fixedTest.cxx.

                                   {
 
  constexpr int width{10};
  constexpr int prec{5};
  const double eps {std::pow(2.0, -prec)};
  using ap = GlobalSim::ap_fixed<width, prec, GlobalSim::Round>;
 
  ap ap_diff = ap(1) -= 2;
  auto val = static_cast<double>(ap_diff);
  auto diff = std::abs(val + 1);
 
  EXPECT_EQ (-1, val);
  EXPECT_LT (diff, eps);
 
  ap_diff = ap(1.5) -= 2.5;
  val = static_cast<double>(ap_diff);
  diff = std::abs(val + 1); 
 
  EXPECT_EQ (-1, val);
  EXPECT_LT (diff, eps);
}

Variable Documentation

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 6 of file ap_fixedTest.cxx.