Esempio n. 1
0
NT2_TEST_CASE_TPL ( seladd_real__2_0,  NT2_REAL_TYPES)
{
  using nt2::seladd;
  using nt2::tag::seladd_;
  using nt2::logical;

  typedef std::complex<T> cT;
  NT2_TEST_TYPE_IS( typename nt2::meta::call<seladd_(logical<T>, cT, cT)>::type
                  , cT
                  );

  // specific values tests
  NT2_TEST_EQUAL(seladd(nt2::False< logical<T> >(), cT(1), cT(0, 1)), cT(1));
  NT2_TEST_EQUAL(seladd(nt2::True< logical<T> >(),cT(1),cT(0, 1)), cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Inf<cT>(), cT(1),cT(0, 1)), cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Minf<cT>(), cT(1),cT(0, 1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Nan<cT>(), cT(1),cT(0, 1)) ,  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Zero<cT>(), cT(1),cT(0, 1)),  cT(1));

  NT2_TEST_EQUAL(seladd(nt2::False< logical<T> >(), T(1), cT(0, 1)), cT(1));
  NT2_TEST_EQUAL(seladd(nt2::True< logical<T> >(),T(1),cT(0, 1)), cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Inf<cT>(), T(1),cT(0, 1)), cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Minf<cT>(), T(1),cT(0, 1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Nan<cT>(), T(1),cT(0, 1)) ,  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Zero<cT>(), T(1),cT(0, 1)),  cT(1));

  NT2_TEST_EQUAL(seladd(nt2::False< logical<T> >(),cT(0, 1),  T(1)),  cT(0, 1));
  NT2_TEST_EQUAL(seladd(nt2::True< logical<T> >(), cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Inf<cT>(),            cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Minf<cT>(),           cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Nan<cT>(),            cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Zero<cT>(),           cT(0, 1),  T(1)),  cT(0, 1));

  NT2_TEST_EQUAL(seladd(nt2::Inf<T>(),             cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Minf<T>(),            cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Nan<T>(),             cT(0, 1),  T(1)),  cT(1, 1));
  NT2_TEST_EQUAL(seladd(nt2::Zero<T>(),            cT(0, 1),  T(1)),  cT(0, 1));


} // end of test for floating_
Esempio n. 2
0
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
  typedef native<T,ext_t>                        n_t;
  typedef n_t                                     vT;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef native<iT,ext_t>                       ivT;
  typedef typename nt2::meta::call<firstbitset_(vT)>::type r_t;
  typedef typename nt2::meta::call<firstbitset_(T)>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_EQUAL(firstbitset(nt2::Inf<vT>())[0], 8388608u);
  NT2_TEST_EQUAL(firstbitset(nt2::Minf<vT>())[0], 8388608u);
  NT2_TEST_EQUAL(firstbitset(nt2::Nan<vT>())[0], nt2::One<sr_t>());
  NT2_TEST_EQUAL(firstbitset(nt2::Signmask<vT>())[0], nt2::One<sr_t>()+nt2::Valmax<sr_t>()/2);
  NT2_TEST_EQUAL(firstbitset(nt2::Zero<vT>())[0], nt2::Zero<sr_t>());
} // end of test for float

NT2_TEST_CASE_TPL ( firstbitset_double_1_0,  (double))
{
  using nt2::firstbitset;
  using nt2::tag::firstbitset_;
  using nt2::load; 
  using boost::simd::native;
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
Esempio n. 3
0
NT2_TEST_CASE_TPL ( fast_sincosd_unsigned_int__1_0,  NT2_UNSIGNED_TYPES)
{
  
  using nt2::fast_sincosd;
  using nt2::tag::fast_sincosd_;
  typedef typename boost::result_of<nt2::meta::floating(T)>::type ftype;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<fast_sincosd_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef boost::fusion::tuple<ftype,ftype> wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
  {
    r_t res = fast_sincosd(nt2::Zero<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Zero<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::One<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincosd(nt2::_45<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }

  // specific values tests
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
  {
    r_t res = fast_sincosd(nt2::Zero<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Zero<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::One<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincosd(nt2::_45<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }

  // specific values tests
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
  {
    r_t res = fast_sincosd(nt2::Zero<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Zero<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::One<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincosd(nt2::_45<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }

  // specific values tests
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
  {
    r_t res = fast_sincosd(nt2::Zero<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Zero<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::One<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincosd(nt2::_45<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }
} // end of test for unsigned_int_
Esempio n. 4
0
NT2_TEST_CASE_TPL ( cscpi_real__1_0,  NT2_REAL_TYPES)
{

  using nt2::cscpi;
  using nt2::tag::cscpi_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<cscpi_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename boost::dispatch::meta::as_floating<T>::type wished_r_t;


  // return type conformity test
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl;
  // specific values tests
  NT2_TEST_ULP_EQUAL(cscpi(-nt2::Quarter<T>()), -nt2::Sqrt_2<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(-nt2::Zero<T>()), nt2::Minf<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Half<T>()), nt2::One<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Inf<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Mhalf<T>()), nt2::Mone<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Minf<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Mone<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Nan<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::One<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Quarter<T>()), nt2::Sqrt_2<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscpi(nt2::Zero<T>()), nt2::Inf<r_t>(), 0.5);
} // end of test for floating_
Esempio n. 5
0
                    , (T)
                    );
}

NT2_TEST_CASE_TPL( ind2sub, (double)(float)(int) )
{
  using nt2::table;
  using nt2::ind2sub;
  using nt2::of_size;
  using nt2::tie;
  using nt2::cons;
  using nt2::ones;

  table<T> inds,x,y,z,w;

  table<T> rx = cons(T(1),T(2),T(1),T(2),T(1),T(2),T(1),T(2));
  table<T> ry = cons(T(1),T(1),T(2),T(2),T(3),T(3),T(4),T(4));
  table<T> rz = cons(T(1),T(1),T(1),T(1),T(2),T(2),T(2),T(2));

  inds = cons(T(1),T(2),T(3),T(4),T(5),T(6),T(7),T(8));

  x = ind2sub(of_size(2,2,2), inds);
  NT2_TEST_EQUAL(x, inds);
  NT2_TEST_EQUAL(x.extent(), inds.extent());

  nt2::tie(x,y) = ind2sub(of_size(2,4), inds);
  NT2_TEST_EQUAL(x, rx);
  NT2_TEST_EQUAL(x.extent(), inds.extent());
  NT2_TEST_EQUAL(y, ry);
  NT2_TEST_EQUAL(y.extent(), inds.extent());
Esempio n. 6
0
NT2_TEST_CASE_TPL ( iround_real__1_0,  NT2_REAL_TYPES)
{
    using nt2::iround;
    using nt2::tag::iround_;
    using nt2::load;
    using nt2::simd::native;
    using nt2::meta::cardinal_of;
    typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
    typedef typename nt2::meta::upgrade<T>::type   u_t;
    typedef native<T,ext_t>                        n_t;
    typedef n_t                                     vT;
    typedef typename nt2::meta::as_integer<T>::type iT;
    typedef native<iT,ext_t>                       ivT;
    typedef typename nt2::meta::call<iround_(vT)>::type r_t;
    typedef typename nt2::meta::call<iround_(T)>::type sr_t;
    typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
    double ulpd;
    ulpd=0.0;


    // specific values tests
    NT2_TEST_ULP_EQUAL(iround(nt2::splat<vT>(1.4))[0], 1, 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::splat<vT>(1.5))[0], 2, 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::splat<vT>(1.6))[0], 2, 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::splat<vT>(2.5))[0], 2, 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Half<vT>())[0], nt2::Zero<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Inf<vT>())[0], nt2::Inf<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Mhalf<vT>())[0], nt2::Zero<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Minf<vT>())[0], nt2::Minf<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Mone<vT>())[0], nt2::Mone<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Nan<vT>())[0], nt2::Zero<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::One<vT>())[0], nt2::One<sr_t>(), 0);
    NT2_TEST_ULP_EQUAL(iround(nt2::Zero<vT>())[0], nt2::Zero<sr_t>(), 0);
} // end of test for real_
Esempio n. 7
0
NT2_TEST_CASE_TPL ( lcm_real__2_0,  NT2_REAL_TYPES)
{
  
  using nt2::lcm;
  using nt2::tag::lcm_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<lcm_(T,T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename boost::result_of<nt2::meta::arithmetic(T)>::type wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_ULP_EQUAL(lcm(T(120),T(80)), T(240), 0);
  NT2_TEST_ULP_EQUAL(lcm(T(3),T(15)), T(15), 0);
  NT2_TEST_ULP_EQUAL(lcm(T(3),T(5)), T(15), 0);
  NT2_TEST_ULP_EQUAL(lcm(T(6),T(15)), T(30), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Inf<T>(), nt2::Inf<T>()), nt2::Nan<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Inf<T>(),T(5)), nt2::Nan<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Minf<T>(), nt2::Minf<T>()), nt2::Nan<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Mone<T>(), nt2::Mone<T>()), nt2::One<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Nan<T>(), nt2::Nan<T>()), nt2::Nan<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::One<T>(), nt2::One<T>()), nt2::One<T>(), 0);
  NT2_TEST_ULP_EQUAL(lcm(nt2::Zero<T>(), nt2::Zero<T>()), nt2::Nan<T>(), 0);
} // end of test for floating_
Esempio n. 8
0
NT2_TEST_CASE_TPL ( is_negative_real__1_0,  NT2_REAL_TYPES)
{

  using nt2::is_negative;
  using nt2::tag::is_negative_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<is_negative_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename nt2::meta::as_logical<T>::type wished_r_t;


  // return type conformity test
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl;

  // specific values tests
  NT2_TEST_EQUAL(is_negative((-nt2::Zero<T>())), nt2::True<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Half<T>()), nt2::False<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Inf<T>()), nt2::False<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Minf<T>()), nt2::True<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Mone<T>()), nt2::True<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Mzero<T>()), nt2::True<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Nan<T>()), nt2::True<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::One<T>()), nt2::False<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Quarter<T>()), nt2::False<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Two<T>()), nt2::False<r_t>());
  NT2_TEST_EQUAL(is_negative(nt2::Zero<T>()), nt2::False<r_t>());
} // end of test for floating_
Esempio n. 9
0
NT2_TEST_CASE_TPL( cumtrapz_mat, NT2_REAL_TYPES )
{
  using nt2::table;
  using nt2::of_size;
  using nt2::cumtrapz;
  using nt2::reshape;
  using nt2::trans;
  using nt2::cons;
  using nt2::_;
  using nt2::_2D;
  using nt2::meta::as_;
  table<T> y = reshape(_(T(1), T(15)), 3, 5); // test fails if y is _2D
  table<T, _2D> r1= trans(reshape(cons(
                                    T(0  ),  T(0  ),  T(0  ), T(0   ),T( 0  ),
                                    T(1.5),  T(4.5),  T(7.5), T(10.5),T( 13.5),
                                    T(4.0),  T(10.),  T(16.0),T(22.0),T( 28.0)
                                    ), 5, 3));

  table<T, _2D> r2= trans(reshape(cons(
                                    T(0),  T(2.5), T( 8.0), T(16.5), T(28.0),
                                    T(0),  T(3.5), T(10.0), T(19.5), T(32.0),
                                    T(0),  T(4.5), T(12.0), T(22.5), T(36.0)
                                    ), 5, 3));
  table<T, _2D> r3 =  nt2::zeros(3, 5, as_<T>());

  table<T, _2D> v1 =  cumtrapz(y, 1);
  NT2_TEST_EQUAL(v1, r1);
  table<T, _2D> v2 =  cumtrapz(y, 2);
  NT2_TEST_EQUAL(v2, r2);
  table<T, _2D> v3 =  cumtrapz(y, 3);
  NT2_TEST_EQUAL(v3, r3);
}
Esempio n. 10
0
NT2_TEST_CASE_TPL ( oneplus_real__1_0,  BOOST_SIMD_REAL_TYPES)
{
  
  using nt2::oneplus;
  using nt2::tag::oneplus_;
  typedef typename boost::dispatch::meta::as_integer<T>::type iT;
  typedef typename boost::dispatch::meta::call<oneplus_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename boost::dispatch::meta::upgrade<T>::type u_t;
  typedef typename boost::common_type<T>::type wished_r_t;
  typedef typename std::complex<T> cT;
  typedef typename nt2::meta::as_imaginary<T>::type ciT;
  typedef typename nt2::meta::as_dry<T>::type dT;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_EQUAL(oneplus(cT(nt2::Inf<T>(), nt2::Inf<T>() ))  , cT(nt2::Inf<cT>(),nt2::Inf<T>()));
  NT2_TEST_EQUAL(oneplus(cT(nt2::Minf<T>(),nt2::Minf<T>()))  , cT(nt2::Minf<cT>(),nt2::Minf<T>()));
  NT2_TEST_EQUAL(oneplus(cT(nt2::Mone<T>(),nt2::Mone<T>()))  , cT(nt2::Zero<cT>(),nt2::Mone<T>()));
  NT2_TEST_EQUAL(oneplus(cT(nt2::Nan<T>() ,nt2::Nan<T>() ))  , cT(nt2::Nan<cT>(),nt2::Nan<T>()));
  NT2_TEST_EQUAL(oneplus(cT(nt2::One<T>() ,nt2::One<T>() ))  , cT(nt2::Two<cT>(),nt2::One<T>()));
  NT2_TEST_EQUAL(oneplus(cT(nt2::Zero<T>(),nt2::Zero<T>()))  , cT(nt2::One<cT>(),nt2::Zero<T>()));
  NT2_TEST_EQUAL(oneplus(nt2::Inf<cT>()),  nt2::Inf<cT>());
  NT2_TEST_EQUAL(oneplus(nt2::Minf<cT>()), nt2::Minf<cT>());
  NT2_TEST_EQUAL(oneplus(nt2::Mone<cT>()), nt2::Zero<cT>());
  NT2_TEST_EQUAL(oneplus(nt2::Nan<cT>()),  nt2::Nan<cT>());
  NT2_TEST_EQUAL(oneplus(nt2::One<cT>()),  nt2::Two<cT>());
  NT2_TEST_EQUAL(oneplus(nt2::Zero<cT>()), nt2::One<cT>());
} // end of test for floating_
Esempio n. 11
0
File: norm.cpp Progetto: atyuwen/nt2
NT2_TEST_CASE_TPL(norm, NT2_REAL_TYPES)
{
  typedef typename nt2::meta::as_complex<T>::type  cT;
  using nt2::norm;
  using nt2::tag::norm_;
  nt2::table<cT> n = nt2::ones(10, 1, nt2::meta::as_<cT>());
  NT2_TEST_ULP_EQUAL(norm(n, 1), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(n, 2), nt2::sqrt(nt2::Ten<T>()), 0);
  NT2_TEST_ULP_EQUAL(norm(n)   , nt2::sqrt(nt2::Ten<T>()), 0);
  NT2_TEST_ULP_EQUAL(norm(n, 3), nt2::pow(nt2::Ten<T>(), 1/T(3)), 0);
  NT2_TEST_ULP_EQUAL(norm(n, nt2::Inf<T>()), nt2::One<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(n, nt2::Minf<T>()), nt2::One<T>(), 0);

  nt2::table<cT> a = nt2::ones(10, 10, nt2::meta::as_<cT>());
  NT2_TEST_ULP_EQUAL(norm(a, 1), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, 2), norm(a), 0);
  NT2_TEST_ULP_EQUAL(norm(a, nt2::Inf<T>()), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, 'I'), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, '1'), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, 'f'), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, "fro"), nt2::Ten<T>(), 0);

  NT2_TEST_ULP_EQUAL(norm(a+a, 1), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, 2), norm(a+a), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, nt2::Inf<T>()), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, 'I'), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, '1'), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, 'f'), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, "fro"), 2*nt2::Ten<T>(), 0);

}
Esempio n. 12
0
NT2_TEST_CASE_TPL ( round_real__1_0,  NT2_REAL_TYPES)
{

  using nt2::round;
  using nt2::tag::round_;
  typedef typename nt2::meta::call<round_(T)>::type r_t;
  typedef T wished_r_t;

  // return type conformity test
  NT2_TEST_TYPE_IS( r_t, wished_r_t );

  // specific values tests
  NT2_TEST_ULP_EQUAL(round(T(1.4)), r_t(1), 0);
  NT2_TEST_ULP_EQUAL(round(T(1.5)), r_t(2), 0);
  NT2_TEST_ULP_EQUAL(round(T(1.6)), r_t(2), 0);
  NT2_TEST_ULP_EQUAL(round(T(2.5)), r_t(3), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Half<T>()), nt2::One<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Inf<T>()), nt2::Inf<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Mhalf<T>()), nt2::Mone<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Minf<T>()), nt2::Minf<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Mone<T>()), nt2::Mone<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Nan<T>()), nt2::Nan<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::One<T>()), nt2::One<r_t>(), 0);
  NT2_TEST_ULP_EQUAL(round(nt2::Zero<T>()), nt2::Zero<r_t>(), 0);
} // end of test for floating_
Esempio n. 13
0
#include <nt2/sdk/functor/meta/call.hpp>
#include <nt2/sdk/meta/as_unsigned.hpp>
#include <boost/type_traits/is_same.hpp>
#include <nt2/toolbox/arithmetic/include/dist.hpp>
#include <nt2/sdk/unit/tests.hpp>
#include <nt2/sdk/unit/module.hpp>

//////////////////////////////////////////////////////////////////////////////
// Test behavior of arithmetic components using NT2_TEST_CASE
//////////////////////////////////////////////////////////////////////////////


NT2_TEST_CASE_TPL ( dist,  (double)(nt2::uint64_t)(nt2::int64_t) 
                          (float)(nt2::uint32_t)(nt2::int32_t)  
                          (nt2::uint16_t)(nt2::int16_t)         
                          (nt2::uint8_t)(nt2::int8_t)
                  )
{
  using nt2::dist;
  using nt2::functors::dist_;

  NT2_TEST( (boost::is_same < typename nt2::meta::call<dist_(T, T)>::type
	     , typename boost::result_of<nt2::meta::arithmetic(T, T)>::type
              >::value)
           );
  NT2_TEST_EQUAL(  dist( T(42), T(12)), T(30) );
  NT2_TEST_EQUAL(  dist( T(12), T(42) ), T(30) );

}
          
Esempio n. 14
0
NT2_TEST_CASE_TPL ( cscd_real__1_0,  NT2_REAL_TYPES)
{
  
  using nt2::cscd;
  using nt2::tag::cscd_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<cscd_(T)>::type r_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename boost::result_of<nt2::meta::floating(T)>::type wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_ULP_EQUAL(cscd(-nt2::Zero<T>()), nt2::Minf<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_180<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_45<T>()), -nt2::Sqrt_2<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_90<T>()), nt2::Mone<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Inf<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Minf<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Nan<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Zero<T>()), nt2::Inf<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_180<T>()), nt2::Nan<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_45<T>()), nt2::Sqrt_2<r_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_90<T>()), nt2::One<r_t>(), 0.5);
  // random verifications
  static const uint32_t NR = NT2_NB_RANDOM_TEST;
  {
    NT2_CREATE_BUF(tab_a0,T, NR, T(-79), T(79));
    double ulp0, ulpd ; ulpd=ulp0=0.0;
    T a0;
    for (uint32_t j =0; j < NR; ++j )
      {
        std::cout << "for param "
                  << "  a0 = "<< u_t(a0 = tab_a0[j])
                  << std::endl;
        NT2_TEST_ULP_EQUAL( nt2::cscd(a0),1.0l/(::cephes_sinl(nt2::long_deginrad*(a0))),1.0);
        ulp0=nt2::max(ulpd,ulp0);
     }
     std::cout << "max ulp found is: " << ulp0 << std::endl;
   }
} // end of test for real_
Esempio n. 15
0
File: round.cpp Progetto: pyrtsa/nt2
NT2_TEST_CASE_TPL ( round_real__1_0,  NT2_REAL_TYPES)
{

    using nt2::round;
    using nt2::tag::round_;
    typedef typename nt2::meta::as_integer<T>::type iT;
    typedef typename nt2::meta::call<round_(T)>::type r_t;
    typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
    typedef typename nt2::meta::upgrade<T>::type u_t;
    typedef T wished_r_t;


    // return type conformity test
    NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
    std::cout << std::endl;
    double ulpd;
    ulpd=0.0;


    // specific values tests
    NT2_TEST_ULP_EQUAL(round(T(1.4)), 1, 0);
    NT2_TEST_ULP_EQUAL(round(T(1.5)), 2, 0);
    NT2_TEST_ULP_EQUAL(round(T(1.6)), 2, 0);
    NT2_TEST_ULP_EQUAL(round(T(2.5)), 2, 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Half<T>()), nt2::Zero<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Inf<T>()), nt2::Inf<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Mhalf<T>()), nt2::Zero<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Minf<T>()), nt2::Minf<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Mone<T>()), nt2::Mone<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Nan<T>()), nt2::Nan<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::One<T>()), nt2::One<r_t>(), 0);
    NT2_TEST_ULP_EQUAL(round(nt2::Zero<T>()), nt2::Zero<r_t>(), 0);
} // end of test for floating_
Esempio n. 16
0
File: rem.cpp Progetto: Mathieu-/nt2
#include <nt2/sdk/functor/meta/call.hpp>
#include <boost/type_traits/is_same.hpp>
#include <nt2/toolbox/arithmetic/include/rem.hpp>
#include <nt2/sdk/unit/tests.hpp>
#include <nt2/sdk/unit/module.hpp>

//////////////////////////////////////////////////////////////////////////////
// Test behavior of arithmetic components using NT2_TEST_CASE
//////////////////////////////////////////////////////////////////////////////


NT2_TEST_CASE_TPL ( rem,  (double)(nt2::uint64_t)(nt2::int64_t) 
                          (float)(nt2::uint32_t)(nt2::int32_t)  
                          (nt2::uint16_t)(nt2::int16_t)         
                          (nt2::uint8_t)(nt2::int8_t)
                  )
{
  using nt2::rem;
  using nt2::functors::rem_;

  NT2_TEST( (boost::is_same < typename nt2::meta::call<rem_(T, T)>::type
              , typename boost::result_of<nt2::meta::arithmetic(T, T)>::type
              >::value)
           );
  NT2_TEST_EQUAL(  rem( T(4), T(3)), 1 );
  NT2_TEST_EQUAL(  rem( T(5), T(3)), 2);
  NT2_TEST_EQUAL(  rem( T(6), T(3)), 0 );

}
          
Esempio n. 17
0
File: rol.cpp Progetto: Mathieu-/nt2
// Test behavior of bitwise components using NT2_TEST_CASE
//////////////////////////////////////////////////////////////////////////////
NT2_TEST_CASE_TPL ( rol,  (nt2::uint64_t)(nt2::int64_t) 
                          (nt2::uint32_t)(nt2::int32_t)  
                          (nt2::uint16_t)(nt2::int16_t)         
                          (nt2::uint8_t)(nt2::int8_t)
                  )
{
  using nt2::rol;
  using nt2::functors::rol_;

  NT2_TEST( (boost::is_same < typename nt2::meta::call<rol_(T, int)>::type
	     , T
              >::value)
           );
  NT2_TEST_EQUAL(  rol( T(1), 1), T(2) );
  NT2_TEST_EQUAL(  rol( ~T(0), 1), ~T(0) );
}
NT2_TEST_CASE_TPL ( real_rol,  (double)(float)
                  )
{
  using nt2::rol;
  using nt2::functors::rol_;

  NT2_TEST( (boost::is_same < typename nt2::meta::call<rol_(T, int)>::type
	     , T
              >::value)
           );

}
Esempio n. 18
0
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
  typedef native<T,ext_t>                        n_t;
  typedef n_t                                     vT;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef native<iT,ext_t>                       ivT;
  typedef typename nt2::meta::call<csc_(vT)>::type r_t;
  typedef typename nt2::meta::call<csc_(T)>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_ULP_EQUAL(csc(nt2::Zero<vT>())[0], nt2::Nan<sr_t>(), 0.5);
} // end of test for int_convert_

NT2_TEST_CASE_TPL ( csc_uint_convert__1_0,  (uint32_t)(uint64_t))
{
  using nt2::csc;
  using nt2::tag::csc_;
  using nt2::load; 
  using nt2::simd::native;
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
  typedef native<T,ext_t>                        n_t;
  typedef n_t                                     vT;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef native<iT,ext_t>                       ivT;
Esempio n. 19
0
NT2_TEST_CASE_TPL ( fast_cotd_real__1_0,  NT2_REAL_TYPES)
{
  
  using nt2::fast_cotd;
  using nt2::tag::fast_cotd_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<fast_cotd_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename boost::result_of<nt2::meta::floating(T)>::type wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_ULP_EQUAL(fast_cotd(-nt2::Zero<T>()), -nt2::Inf<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(-nt2::_180<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(-nt2::_45<T>()), nt2::Mone<r_t>(), 4.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(-nt2::_90<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::Inf<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::Minf<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::Nan<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::Zero<T>()), nt2::Inf<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::_180<T>()), nt2::Nan<r_t>(), 1.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::_45<T>()), nt2::One<r_t>(), 4.0);
  NT2_TEST_ULP_EQUAL(fast_cotd(nt2::_90<T>()), nt2::Nan<r_t>(), 1.0);
} // end of test for real_
Esempio n. 20
0
NT2_TEST_CASE_TPL ( caupdf_2,  NT2_REAL_TYPES)
{

  using nt2::caupdf;
  using nt2::tag::caupdf_;
  using nt2::_;


  // specific values tests
  NT2_TEST_ULP_EQUAL(caupdf(nt2::Nan<T>(), nt2::One<T>()), nt2::Nan<T>(), 0);
  NT2_TEST_ULP_EQUAL(caupdf(nt2::Zero<T>(), nt2::One<T>() ), nt2::Invpi<T>()/2, 0);
  NT2_TEST_ULP_EQUAL(caupdf(nt2::One<T>(), nt2::One<T>()), nt2::Invpi<T>(), 0);
  NT2_TEST_ULP_EQUAL(caupdf(nt2::Inf<T>(), nt2::One<T>()), nt2::Zero<T>(), 0);
  NT2_TEST_ULP_EQUAL(caupdf(nt2::Minf<T>(), nt2::One<T>()), nt2::Zero<T>(), 0);

  nt2::table<T> a = _(T(-5), T(1), T(5));
  NT2_DISPLAY(a);
  NT2_DISPLAY(caupdf(a, nt2::One<T>()));
  a = nt2::reshape(_(T(1), T(16)), 4, 4);
  NT2_DISPLAY(a);
  NT2_DISPLAY(caupdf(a, a));
  NT2_DISPLAY(caupdf(a, nt2::One<T>(), nt2::Two<T>()));
  NT2_DISPLAY(caupdf(a, a, nt2::Two<T>()));
  NT2_DISPLAY(caupdf(a, a, a));
} // end of test for floating_
Esempio n. 21
0
File: ffs.cpp Progetto: KWMalik/nt2
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<ffs_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef typename nt2::meta::as_integer<T, unsigned>::type wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_EQUAL(ffs(nt2::Inf<T>()), 24u);
  NT2_TEST_EQUAL(ffs(nt2::Minf<T>()), 24u);
  NT2_TEST_EQUAL(ffs(nt2::Nan<T>()), nt2::One<r_t>());
  NT2_TEST_EQUAL(ffs(nt2::Signmask<T>()), sizeof(T)*8);
  NT2_TEST_EQUAL(ffs(nt2::Zero<T>()), nt2::Zero<r_t>());
} // end of test for float

NT2_TEST_CASE_TPL ( ffs_double_1_0,  (double))
{
  
  using nt2::ffs;
  using nt2::tag::ffs_;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<ffs_(T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
Esempio n. 22
0
NT2_TEST_CASE_TPL(sinhcosh, NT2_SIMD_REAL_TYPES)
{
  using nt2::sinhcosh;
  using nt2::tag::sinhcosh_;
  using boost::simd::native;
  typedef native<T,BOOST_SIMD_DEFAULT_EXTENSION>            vT;
  vT a[] = {nt2::Zero<vT>(), nt2::Half<vT>(), nt2::One<vT>(), nt2::splat<vT>(-5), nt2::splat<vT>(5)};
  size_t N =  sizeof(a)/sizeof(vT);
  NT2_TEST_TYPE_IS( (typename boost::dispatch::meta::call<sinhcosh_(vT)>::type)
                  , (std::pair<vT,vT>)
                  );

  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      sinhcosh(a[i], s, c);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(a[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(a[i]), 1);
    }
  }

  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      s = sinhcosh(a[i], c);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(a[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(a[i]), 1);
    }
  }

  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      boost::fusion::vector_tie(s, c) = sinhcosh(a[i]);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(a[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(a[i]), 1);
    }
  }

  {
    for(size_t i=0; i < N; ++i)
    {
      std::pair<vT,vT> p = sinhcosh(a[i]);
      NT2_TEST_ULP_EQUAL(p.first,  nt2::sinh(a[i]), 1);
      NT2_TEST_ULP_EQUAL(p.second, nt2::cosh(a[i]), 1);
    }
  }

#ifndef BOOST_SIMD_NO_INVALIDS
  vT b[] = {nt2::splat<vT>(10), nt2::Inf<vT>(), nt2::Minf<vT>(), nt2::Nan<vT>()};
  N =  sizeof(b)/sizeof(vT);
  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      sinhcosh(b[i], s, c);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(b[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(b[i]), 1);
    }
  }

  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      s = sinhcosh(b[i], c);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(b[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(b[i]), 1);
    }
  }

  {
    vT s, c;
    for(size_t i=0; i < N; ++i)
    {
      boost::fusion::vector_tie(s, c) = sinhcosh(b[i]);
      NT2_TEST_ULP_EQUAL(s, nt2::sinh(b[i]), 1);
      NT2_TEST_ULP_EQUAL(c, nt2::cosh(b[i]), 1);
    }
  }

  {
    for(size_t i=0; i < N; ++i)
    {
      std::pair<vT,vT> p = sinhcosh(b[i]);
      NT2_TEST_ULP_EQUAL(p.first,  nt2::sinh(b[i]), 1);
      NT2_TEST_ULP_EQUAL(p.second, nt2::cosh(b[i]), 1);
    }
  }
#endif


}
Esempio n. 23
0
NT2_TEST_CASE_TPL ( is_nan_real__1_0,  BOOST_SIMD_REAL_TYPES)
{
  using nt2::is_nan;
  using nt2::tag::is_nan_;
  typedef std::complex<T> cT;
  typedef nt2::imaginary<T> ciT;
  typedef typename boost::dispatch::meta::call<is_nan_(cT)>::type r_t;

  // return type conformity test
  NT2_TEST_TYPE_IS( typename boost::dispatch::meta::call<is_nan_(cT)>::type, nt2::logical<T> );

  // specific values tests
  NT2_TEST_EQUAL(is_nan(cT(nt2::Inf<T>())),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Minf<T>())), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Nan<T>())),  r_t(true));
  NT2_TEST_EQUAL(is_nan(cT(nt2::One<T>())),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Zero<T>())), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Inf<T>(), T(0))),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Minf<T>(), T(0))), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Nan<T>(), T(0))),  r_t(true));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Nan<T>(), nt2::Inf<T>())),  r_t(true));
  NT2_TEST_EQUAL(is_nan(cT(nt2::One<T>(), T(0))),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Zero<T>(), T(0))), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(0, 0)), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(1, 0))    , r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(0, 2)), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(0, 1))   , r_t(false));
  NT2_TEST_EQUAL(is_nan(ciT(1))     , r_t(false));
  NT2_TEST_EQUAL(is_nan(ciT(0))     , r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(T(0), nt2::Inf<T>())),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(T(0), nt2::Minf<T>())), r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(T(0), nt2::Nan<T>())),  r_t(true));
  NT2_TEST_EQUAL(is_nan(cT(T(0), nt2::One<T>())),  r_t(false));
  NT2_TEST_EQUAL(is_nan(cT(nt2::Inf<T>(), nt2::Nan<T>())),  r_t(true));
  NT2_TEST_EQUAL(is_nan(cT(T(0), nt2::Zero<T>())), r_t(false));
}
Esempio n. 24
0
#include <nt2/sdk/unit/tests.hpp>
#include <nt2/sdk/unit/module.hpp>

#include <nt2/constant/constant.hpp>
#include <nt2/table.hpp>

NT2_TEST_CASE_TPL ( normcdf_1,  (float)(double))//NT2_REAL_TYPES)
{

  using nt2::normcdf;
  using nt2::tag::normcdf_;
  using nt2::_;


  // specific values tests
  NT2_TEST_ULP_EQUAL(normcdf(nt2::Nan<T>()), nt2::Nan<T>(), 0.5);
  NT2_TEST_ULP_EQUAL(normcdf(nt2::One<T>()), T(0.841344746068542948585232545632), 1.5);
  NT2_TEST_ULP_EQUAL(normcdf(nt2::Mone<T>()), T(0.158655253931457051414767454368), 6);
  NT2_TEST_ULP_EQUAL(normcdf(nt2::Zero<T>()), nt2::Half<T>(), 0.5);
  NT2_TEST_ULP_EQUAL(normcdf(nt2::Inf<T>()), nt2::One<T>(), 0.5);
  NT2_TEST_ULP_EQUAL(normcdf(nt2::Minf<T>()), nt2::Zero<T>(), 0.5);
} // end of test for floating_

NT2_TEST_CASE_TPL ( normcdf_2,  NT2_REAL_TYPES)
{

  using nt2::normcdf;
  using nt2::tag::normcdf_;
  using nt2::_;

Esempio n. 25
0
NT2_TEST_CASE_TPL( value_type, NT2_TYPES )
{
  using boost::mpl::_;
  using nt2::table;
  using nt2::of_size;
  using nt2::meta::value_type_;

  nt2::table<int> sz( of_size(1,4) );

  // IND is a scalar + all variants od size/base
  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(1,T(1)) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( of_size(2,2),T(1) ) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( sz, T(1) ) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(1,T(1), 0) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( of_size(2,2),T(1), 0) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( sz, T(1), 0 ) )
                    , (value_type_<_>)
                    , (T)
                    );

  // IND is a expr + all variants od size/base
  nt2::table<T> inds;

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(1,inds) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(of_size(2,2),inds) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( sz, inds ) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(1,inds,0) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub(of_size(2,2),inds,0) )
                    , (value_type_<_>)
                    , (T)
                    );

  NT2_TEST_EXPR_TYPE( ( nt2::ind2sub( sz, inds,0 ) )
                    , (value_type_<_>)
                    , (T)
                    );
}
Esempio n. 26
0
NT2_TEST_CASE_TPL ( cscd_real__1_0,  NT2_SIMD_REAL_TYPES)
{
  using nt2::cscd;
  using nt2::tag::cscd_;
  using boost::simd::native;
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
  typedef native<T,ext_t>                        n_t;
  typedef n_t                                     vT;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef native<iT,ext_t>                       ivT;
  typedef typename nt2::meta::call<cscd_(vT)>::type r_t;
  typedef typename nt2::meta::call<cscd_(T)>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;

  // specific values tests
  NT2_TEST_ULP_EQUAL(cscd(-nt2::Zero<vT>())[0], nt2::Minf<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_180<vT>())[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_45<vT>())[0], -nt2::Sqrt_2<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(-nt2::_90<vT>())[0], nt2::Mone<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Inf<vT>())[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Minf<vT>())[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Nan<vT>())[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::Zero<vT>())[0], nt2::Inf<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_180<vT>())[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_45<vT>())[0], nt2::Sqrt_2<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(cscd(nt2::_90<vT>())[0], nt2::One<sr_t>(), 0.5);
} // end of test for floating_
Esempio n. 27
0
NT2_TEST_CASE_TPL ( nthroot_real__2_0,  NT2_SIMD_REAL_TYPES)
{
  using nt2::nthroot;
  using nt2::tag::nthroot_;
  using nt2::load; 
  using boost::simd::native;
  using nt2::meta::cardinal_of;
  typedef NT2_SIMD_DEFAULT_EXTENSION  ext_t;
  typedef typename nt2::meta::upgrade<T>::type   u_t;
  typedef native<T,ext_t>                        n_t;
  typedef n_t                                     vT;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef native<iT,ext_t>                       ivT;
  typedef typename nt2::meta::call<nthroot_(vT,ivT)>::type r_t;
  typedef typename nt2::meta::call<nthroot_(T,iT)>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_ULP_EQUAL(nthroot(nt2::splat<vT>(-8),nt2::splat<ivT>(3))[0], sr_t(-2), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::splat<vT>(256),nt2::splat<ivT>(4))[0], sr_t(4), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::splat<vT>(8),nt2::splat<ivT>(3))[0], sr_t(2), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Inf<vT>(),nt2::splat<ivT>(3))[0], nt2::Inf<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Inf<vT>(),nt2::splat<ivT>(4))[0], nt2::Inf<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Minf<vT>(),nt2::splat<ivT>(3))[0], nt2::Minf<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Minf<vT>(),nt2::splat<ivT>(4))[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Mone<vT>(),nt2::splat<ivT>(3))[0], nt2::Mone<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Mone<vT>(),nt2::splat<ivT>(4))[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Nan<vT>(),nt2::splat<ivT>(3))[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Nan<vT>(),nt2::splat<ivT>(4))[0], nt2::Nan<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::One<vT>(),nt2::splat<ivT>(3))[0], nt2::One<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::One<vT>(),nt2::splat<ivT>(4))[0], nt2::One<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Zero<vT>(),nt2::splat<ivT>(3))[0], nt2::Zero<sr_t>(), 0.5);
  NT2_TEST_ULP_EQUAL(nthroot(nt2::Zero<vT>(),nt2::splat<ivT>(4))[0], nt2::Zero<sr_t>(), 0.5);
} // end of test for floating_
Esempio n. 28
0
NT2_TEST_CASE_TPL(norm, NT2_REAL_TYPES)
{
  using nt2::norm;
  using nt2::tag::norm_;
  nt2::table<T> n = nt2::ones(10, 1, nt2::meta::as_<T>());
  NT2_TEST_ULP_EQUAL(norm(n, 1), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(n, 2), nt2::sqrt(nt2::Ten<T>()), 0);
  NT2_TEST_ULP_EQUAL(norm(n)   , nt2::sqrt(nt2::Ten<T>()), 0);
  NT2_TEST_ULP_EQUAL(globalnorm(n, 3), nt2::pow(nt2::Ten<T>(), 1/T(3)), 0);
  NT2_TEST_ULP_EQUAL(norm(n, 3), nt2::pow(nt2::Ten<T>(), 1/T(3)), 0);
  NT2_TEST_ULP_EQUAL(norm(n, nt2::Inf<T>()), nt2::One<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(n, nt2::Minf<T>()), nt2::One<T>(), 0);

  nt2::table<T> a = nt2::ones(10, 10, nt2::meta::as_<T>());
  NT2_TEST_ULP_EQUAL(norm(a, 1), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, 2), norm(a), 0);
  NT2_TEST_ULP_EQUAL(norm(a, nt2::Inf<T>()), nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a, nt2::fro_), nt2::Ten<T>(), 0);
  NT2_TEST_ASSERT(norm(a, 3));

  NT2_TEST_ULP_EQUAL(norm(a+a, 1), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, 2), norm(a+a), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, nt2::Inf<T>()), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ULP_EQUAL(norm(a+a, nt2::fro_), 2*nt2::Ten<T>(), 0);
  NT2_TEST_ASSERT(norm(a+a, 3));
}
Esempio n. 29
0
NT2_TEST_CASE_TPL ( is_not_equal_real__2_0,  BOOST_SIMD_REAL_TYPES)
{

  using nt2::is_not_equal;
  using nt2::tag::is_not_equal_;
  typedef typename boost::dispatch::meta::as_integer<T>::type iT;
  typedef typename boost::dispatch::meta::call<is_not_equal_(T,T)>::type r_t;
  typedef typename nt2::meta::scalar_of<r_t>::type sr_t;
  typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
  typedef nt2::logical<T> wished_r_t;
  typedef std::complex<T> cT;
  typedef nt2::imaginary<T> ciT;

  // return type conformity test
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl;
  double ulpd;
  ulpd=0.0;


  // specific values tests
  NT2_TEST_EQUAL(is_not_equal(cT(nt2::Inf<T>()),  cT(nt2::Inf<T>())),  r_t(false));
  NT2_TEST_EQUAL(is_not_equal(cT(nt2::Minf<T>()), cT(nt2::Minf<T>())), r_t(false));
  NT2_TEST_EQUAL(is_not_equal(cT(nt2::Nan<T>()),  cT(nt2::Nan<T>())),  r_t(true));
  NT2_TEST_EQUAL(is_not_equal(cT(nt2::One<T>()),  cT(nt2::Zero<T>())), r_t(true));
  NT2_TEST_EQUAL(is_not_equal(cT(nt2::Zero<T>()), cT(nt2::Zero<T>())), r_t(false));
  NT2_TEST_EQUAL(is_not_equal(cT(0, 1), cT(0, 1)), r_t(false));
  NT2_TEST_EQUAL(is_not_equal(cT(1, 0), T(1))    , r_t(false));
  NT2_TEST_EQUAL(is_not_equal(cT(0, 2), cT(0, 1)), r_t(true));
  NT2_TEST_EQUAL(is_not_equal(cT(0, 1), ciT(1))   , r_t(false));
  NT2_TEST_EQUAL(is_not_equal(ciT(1), ciT(1))     , r_t(false));
  NT2_TEST_EQUAL(is_not_equal(ciT(0), ciT(1))     , r_t(true));
} // end of test for floating_
Esempio n. 30
0
NT2_TEST_CASE_TPL ( fast_sincospi_real__1_0,  NT2_REAL_TYPES)
{
  
  using nt2::fast_sincospi;
  using nt2::tag::fast_sincospi_;
  typedef typename boost::result_of<nt2::meta::floating(T)>::type ftype;
  typedef typename nt2::meta::as_integer<T>::type iT;
  typedef typename nt2::meta::call<fast_sincospi_(T)>::type r_t;
  typedef typename nt2::meta::upgrade<T>::type u_t;
  typedef boost::fusion::tuple<ftype,ftype> wished_r_t;


  // return type conformity test 
  NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
  std::cout << std::endl; 
  double ulpd;
  ulpd=0.0;


  // specific values tests
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
  typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
  {
    r_t res = fast_sincospi(-nt2::Quarter<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), -nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Half<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Nan<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Nan<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Inf<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Nan<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Nan<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Mhalf<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Nan<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Nan<r_t1>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Minf<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Nan<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Nan<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Nan<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Nan<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Nan<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Quarter<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::Sqrt_2o_2<r_t0>(), 0.75);
  }
  {
    r_t res = fast_sincospi(nt2::Zero<T>());
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<0>(res), nt2::Zero<r_t0>(), 0.75);
    NT2_TEST_TUPLE_ULP_EQUAL( boost::fusion::get<1>(res), nt2::One<r_t0>(), 0.75);
  }
  // random verifications
  static const uint32_t NR = NT2_NB_RANDOM_TEST;
  {
    typedef typename boost::result_of<nt2::meta::floating(T)>::type ftype;
    NT2_CREATE_BUF(tab_a0,T, NR, T(0.25), T(0.25));
    double ulp0, ulpd ; ulpd=ulp0=0.0;
    T a0;
    for (uint32_t j =0; j < NR; ++j )
      {
        std::cout << "for param "
                  << "  a0 = "<< u_t(a0 = tab_a0[j])
                  << std::endl;
        r_t r = nt2::fast_sincospi(a0);
        typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,0>::type>::type r_t0;
        typedef typename nt2::meta::strip<typename boost::fusion::result_of::at_c<r_t,1>::type>::type r_t1;
        r_t0 r0 = boost::fusion::get<0>(r);
        r_t1 r1 = boost::fusion::get<1>(r);
        NT2_TEST_TUPLE_ULP_EQUAL( r0, nt2::sin(nt2::Pi<T>()*a0), 0.5);
        NT2_TEST_TUPLE_ULP_EQUAL( r1, nt2::cos(nt2::Pi<T>()*a0), 0.5);
     }
     std::cout << "max ulp found is: " << ulp0 << std::endl;
   }
} // end of test for real_