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_
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;
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_
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_
, (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());
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_
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_
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_
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); }
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_
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); }
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_
#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) ); }
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_
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_
#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 ); }
// 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) ); }
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;
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_
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_
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;
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 }
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)); }
#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::_;
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) ); }
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_
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_
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)); }
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_
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_