static type call(A0& a0, I const& indices) { Idx idx = nt2::function_index(indices, a0.extent(), meta::as_<typename A0::indexes_type>()); std::size_t b = nt2::run(idx, 0u, meta::as_<std::size_t>()); std::size_t e = nt2::run(idx, nt2::numel(idx.extent())-1u, meta::as_<std::size_t>())+1u; typename A0::value_type* p = const_cast<typename A0::value_type*>(a0.raw()); return type(expr::make(container_ref(boost::make_shared<container>(idx.extent(), nt2::share(p+b, p+e))))); }
BOOST_FORCEINLINE void combine_eigens(const T& wr, const T& wi, A0& w) { typedef typename A0::value_type type_t; int n = numel(wr); w.resize(of_size(n, 1)); nt2::container::table<type_t, nt2::shared_> sw(of_size(n, 1), share(w.data(), w.data()+n)); sw = tocomplex(wr, wi); }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1 const& a1) const { result_type that; nt2_la_int n = nt2::width(a0); nt2_la_int lda = a0.leading_size(); NT2_F77NAME(zpotrf) (&a1,&n,a0.raw(),&lda,&that); return that; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1 const a1) const { result_type that; nt2_la_int n = nt2::width(a0); nt2_la_int lda = a0.leading_size(); magma_zpotrf(a1,n,(cuDoubleComplex*)a0.raw(),lda,&that); return that; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1) const { result_type that; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); a1.resize( nt2::of_size(std::min(n, m), 1) ); magma_cgetrf(m, n, (cuFloatComplex*)a0.data(), ld, a1.data(), &that); return that; }
BOOST_FORCEINLINE result_type operator()( A0& a, A1& scale , A2& ilo, A3& ihi, C0 job) const { result_type info; nt2_la_int n = nt2::width(a); BOOST_ASSERT_MSG(n == nt2_la_int(nt2::height(a)), "input must be square"); nt2_la_int lda = nt2::max(a.leading_size(), One<size_t>()); NT2_F77NAME(cgebal) (&job, &n , a.raw(), &lda , &ilo, &ihi , scale.raw(), &info); return info; }
BOOST_FORCEINLINE static void conf_bounds(const A0& a0, A1& a1, const M2x2 pcov, const value_type& normz, Out0 & p) { typedef typename boost::proto::result_of::child_c<A1&,1>::type Out1; typedef typename boost::proto::result_of::child_c<A1&,2>::type Out2; // NT2_DISPLAY(a0.extent()); NT2_DISPLAY(a1.extent()); p.resize(a0.extent()); const In0& x = boost::proto::child_c<0>(a0); // NT2_DISPLAY(x); const In1& a = boost::proto::child_c<1>(a0); // NT2_DISPLAY(a); const In2& b = boost::proto::child_c<2>(a0); // NT2_DISPLAY(b); BOOST_AUTO_TPL(z, x/b); // NT2_DISPLAY(z); // NT2_DISPLAY(nt2::gammainc(z, a)); // NT2_DISPLAY(size(p)); p = nt2::exp(z); //nt2::gammainc(z, a); // NT2_DISPLAY(p); // Out0& p = boost::proto::child_c<0>(a1); // NT2_DISPLAY(p); BOOST_AUTO_TPL(itp, (p/nt2::oneminus(p))); // NT2_DISPLAY(itp); BOOST_AUTO_TPL(dp, nt2::rec(p*oneminus(p))); // derivative of logit(p) w.r.t. p // NT2_DISPLAY(dp); BOOST_AUTO_TPL(da, dgammainc(z,a)*dp); // dlogitp/da = dp/da * dlogitp/dp // NT2_DISPLAY(da); BOOST_AUTO_TPL(db, -nt2::exp(a*nt2::log(z)-z-nt2::gammaln(a)-nt2::log(b))* dp); // dlogitp/db = dp/db * dlogitp/dp // NT2_DISPLAY(db); BOOST_AUTO_TPL(varLogitp, pcov(1,1)*sqr(da) + (Two<value_type>()*pcov(1,2)*da + pcov(2,2)*db)*db); // NT2_DISPLAY(varLogitp); // NT2_DISPLAY(normz); BOOST_AUTO_TPL(exp_halfwidth, nt2::exp(normz*nt2::sqrt(varLogitp))); // NT2_DISPLAY(exp_halfwidth); Out1 & plo = boost::proto::child_c<1>(a1); Out2 & pup = boost::proto::child_c<2>(a1); plo.resize(a0.extent()); pup.resize(a0.extent()); // std::cout << "1" << std::endl; plo = itp*exp_halfwidth; // std::cout << "2" << std::endl; pup = itp/exp_halfwidth; // std::cout << "3" << std::endl; plo /= nt2::oneplus(plo); // std::cout << "4" << std::endl; pup /= nt2::oneplus(pup); // std::cout << "5" << std::endl; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1) const { result_type that; nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int ldb = a1.leading_size(); nt2_la_int nhrs = nt2::width(a1); char uplo = 'L'; NT2_F77NAME(zposv) ( &uplo, &n, &nhrs, a0.data(), &ld, a1.data(), &ldb , &that ); return that; }
BOOST_FORCEINLINE result_type operator()( A0& a0, A1& s, A2& u,A3 &vt, A4 const jobu , A5 const jobvt) const { result_type that; details::workspace<typename A0::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int ldu = u.leading_size() > 1 ? u.leading_size() : 1 ; nt2_la_int ldvt= vt.leading_size() > 1 ? vt.leading_size() : 1 ; nt2_la_int lwork_query = -1; char c = std::toupper(jobu); magma_vec_t magma_jobu = c == 'A' ? MagmaAllVec : c == 'S' ? MagmaSomeVec : c == 'O' ? MagmaOverwriteVec : c == 'N' ? MagmaNoVec : (magma_vec_t)0; c = std::toupper(jobvt); magma_vec_t magma_jobvt = c == 'A' ? MagmaAllVec : c == 'S' ? MagmaSomeVec : c == 'O' ? MagmaOverwriteVec : c == 'N' ? MagmaNoVec : (magma_vec_t)0; magma_sgesvd(magma_jobu,magma_jobvt,m, n, 0, ld, 0, 0, ldu , 0, ldvt, w.main() , lwork_query, &that ); w.prepare_main(); nt2::gesvd(a0,s,u,vt,jobu,jobvt,w); return that; }
//========================================================================== /// INTERNAL ONLY - X = LINSOLVE(A,B) -- symmetric shape BOOST_FORCEINLINE void eval ( A0 const& a0, A1 const& a1 , A2 const& a2 ,boost::mpl::long_<1> const , nt2::symmetric_ const&) const { type_t rcond; nt2::container::table<nt2_la_int> piv = nt2::zeros(a0.leading_size(), 1 , nt2::meta::as_<nt2_la_int>() ); boost::proto::child_c<0>(a2).resize(nt2::of_size(a0.leading_size(),1)); NT2_AS_TERMINAL_IN(desired_semantic1,a,a0); NT2_AS_TERMINAL_IN(desired_semantic,b,a1); nt2_la_int iter = nt2::sysvx( boost::proto::value(a),boost::proto::value(piv) , boost::proto::value(b) , boost::proto::value(boost::proto::child_c<0>(a2)) , rcond); boost::ignore_unused(iter); }
result_type operator()(A0& yi, A1& inputs) const { yi.resize(inputs.extent()); const child0 & x = boost::proto::child_c<0>(inputs); if (numel(x) <= 1) BOOST_ASSERT_MSG(numel(x) > 1, "Interpolation requires at least two sample points in each dimension."); else { BOOST_ASSERT_MSG(issorted(x, 'a'), "for 'nearest' interpolation x values must be sorted in ascending order"); const child1 & y = boost::proto::child_c<1>(inputs); BOOST_ASSERT_MSG(numel(x) == numel(y), "The grid vectors do not define a grid of points that match the given values."); const child2 & xi = boost::proto::child_c<2>(inputs); bool extrap = false; value_type extrapval = Nan<value_type>(); choices(inputs, extrap, extrapval, N1()); table<index_type> index = bsearch (x, xi); table<value_type> dx = xi-x(index); table<index_type> indexp1 = oneplus(index); yi = y(nt2::if_else(lt(nt2::abs(xi-x(index)), nt2::abs(xi-x(indexp1))), index, indexp1)); value_type b = value_type(x(begin_)); value_type e = value_type(x(end_)); if (!extrap) yi = nt2::if_else(nt2::logical_or(boost::simd::is_nge(xi, b), boost::simd::is_nle(xi, e)), extrapval, yi); } return yi; }
static type call(A0& a0, I const& indices) { return boost::proto::make_expr<tag::function_,container::domain> ( boost::reference_wrapper<A0>(a0) , function_index(indices, a0.extent(), meta::as_<typename A0::indexes_type>()) ); }
static type call(A0& a0, I const& indices) { Idx idx = nt2::function_index(indices, a0.extent(), meta::as_<typename A0::indexes_type>()); std::size_t b = nt2::run(idx, 0u, meta::as_<std::size_t>()); return nt2_expr(basic_expr::make(container_ref(boost::proto::value(a0), boost::proto::value(a0).begin()+b, idx.extent()))); }
BOOST_FORCEINLINE result_type operator()( A0& a, A1& b, A2& alpha, A3& beta, A4& vr, A5& vl) const { result_type info = 0; char jobvr = 'V'; char jobvl = 'V'; details::workspace<typename A0::value_type> wk; nt2_la_int n = nt2::width(a); BOOST_ASSERT_MSG( (n == nt2_la_int(nt2::height(a))) &&(n == nt2_la_int(nt2::height(b))) , "inputs must be square"); nt2_la_int lda = nt2::max(a.leading_size(), One<size_t>()); nt2_la_int ldb = nt2::max(b.leading_size(), One<size_t>()); nt2_la_int ldvl = n; nt2_la_int ldvr = n; NT2_F77NAME(zggev) ( &jobvl, &jobvr , &n , 0 /*a*/, &lda , 0 /*b*/, &ldb , 0/*alpha*/ , 0/*beta*/ , 0/*vl*/, &ldvl , 0/*vr*/, &ldvr , wk.main(), details::query() , wk.reals() , &info); info = nt2::ggev_wvrvl(a, b, alpha, beta, vr, vl, wk); return info; }
BOOST_FORCEINLINE result_type operator()(A0 const& a0, A1 ind, A2 dim) const { std::size_t along = dim-1; typename A0::extent_type ex1 = a0.extent(); ex1[along] = 1; return boost::proto::make_expr< nt2::tag::line_ , container::domain > ( boost::cref(a0) , along , as_index( a0.extent() , as_subscript(ex1, ind) ) , nt2::linesstride(a0, dim) ); }
result_type operator()(A0& out, const A1& in) const { size_t n = boost::proto::child_c<0>(in); out.resize(nt2::of_size(n, n)); nt2::table<value_type, _2D> l = nt2::abs(nt2::pascal(n, 1, nt2::meta::as_<value_type>())); nt2::table<value_type, _2D> u = nt2::fliplr(nt2::flipud(l)); nt2::table<value_type, _2D> d = nt2::from_diag(nt2::pow(value_type(-2), nt2::_(value_type(0), value_type(n-1)))); out = nt2::round2even(nt2::mtimes(l, nt2::mtimes(d, u))); return out; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1 a1, nt2::symmetric_ const&) const { result_type norm; char uplo = 'L'; nt2_la_int n = nt2::width(a0); nt2_la_int ld = n; if(a1 =='I'|| a1 =='1'|| a1 =='O') { nt2::memory::container<tag::table_, result_type, nt2::_2D> work(nt2::of_size(n,1)); norm = NT2_F77NAME(zlansy)( &a1, &uplo, &n, a0.raw(), &ld, work.raw()); } else { norm = NT2_F77NAME(zlansy)( &a1, &uplo, &n, a0.raw(), &ld, 0); } return norm; }
BOOST_FORCEINLINE void combine_vects(const T1& rv, const T2& wi, A0& v) { typedef typename A0::value_type type_t; int n = height(rv); v.resize(of_size(n, n)); nt2::container::table<type_t, nt2::shared_> sv(of_size(n, n), share(v.data(), v.data()+numel(v))); for(int j=1; j <= n; ++j) { if(wi(j)) { sv(nt2::_, j ) = tocomplex(rv(nt2::_, j), rv(nt2::_, j+1)); sv(nt2::_, j+1) = conj(sv(nt2::_, j)); ++j; } else sv(nt2::_, j) = rv(nt2::_, j); } }
void foo (int x) { // This should be a single variable declaration, but instead it is two seperate declarations. // this is OK here, but a bug when it is handled this way inside of a for loop initialization. // See test2012_106.C. // #if 1 // class A0 {public: int foo (int x) {return x;}} x2; // #else for (class A0 {public: int foo (int x) {return x;}} x2; x2.foo (0); x) {} // #endif }
result_type operator()(A0& out, const A1& in) const { BOOST_AUTO_TPL(x,boost::proto::child_c<0>(in)); _2D siz = boost::proto::value(boost::proto::child_c<1>(in)); size_t n = siz[0]; size_t m = siz[1]; tab_t rnd = nt2::rand(n*m, 1, nt2::meta::as_<value_t>()); value_t p = nt2::numel(x); out.resize(siz); out(nt2::_) = x(nt2::iceil(rnd*p)); return out; }
//========================================================================== /// INTERNAL ONLY - X = LINSOLVE(A,B) -- positive definite shape BOOST_FORCEINLINE void eval ( A0 const& a0, A1 const& a1 , A2 const& a2 ,boost::mpl::long_<1> const , nt2::positive_definite_ const&) const { type_t rcond; boost::proto::child_c<0>(a2).resize(nt2::of_size(a0.leading_size(),1)); NT2_AS_TERMINAL_IN(desired_semantic1,a,a0); NT2_AS_TERMINAL_IN(desired_semantic,b,a1); nt2_la_int iter = nt2::posvx( boost::proto::value(a), boost::proto::value(b) , boost::proto::value(boost::proto::child_c<0>(a2)) , rcond); boost::ignore_unused(iter); }
result_type operator()(A0& out, const A1& in) const { size_t n = boost::proto::child_c<0>(in); value_type fn = value_type(n); table<value_type> ns = nt2::cons(of_size(1, 3), fn, fn/12, fn/20); table<i_type> ee(nt2::of_size(1, 3)); table<value_type> ff(nt2::of_size(1, 3)); // nt2::frexp(ns, ff, ee); nt2::frexp(ns(1), ff(1), ee(1)); nt2::frexp(ns(2), ff(2), ee(2)); nt2::frexp(ns(3), ff(3), ee(3)); BOOST_AUTO_TPL(kk, nt2::find(nt2::logical_and(eq(ff, nt2::Half<value_type>()), is_gtz(ee)))); BOOST_ASSERT_MSG(!nt2::isempty(kk), "n must be of form 2^m or 12*2^m or 20*2^m"); size_t k = kk(1); i_type e = nt2::minusone(ee(k)); out.resize(nt2::of_size(n, n)); table<value_type> h; if (k == 1) // n = 1 * 2^e; { h = nt2::One<value_type>(); } else if ( k == 2) // N = 12 * 2^e; { h = nt2::vertcat(nt2::ones(1,12,meta::as_<value_type>()), nt2::horzcat(nt2::ones(11,1,meta::as_<value_type>()), nt2::toeplitz(cons<value_type>(of_size(1, 11), -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1), cons<value_type>(of_size(1, 11), -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1) ) ) ); } else if ( k == 3) // N = 20 * 2^e; { h = vertcat(nt2::ones(1,20,meta::as_<value_type>()), nt2::horzcat(nt2::ones(19,1,meta::as_<value_type>()), nt2::hankel(cons<value_type>(of_size(1, 19),-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1), cons<value_type>(of_size(1, 19),1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1) ) ) ); } // Kronecker product construction. for (i_type i = 1; i <= e; ++i) { table<value_type> h1 = nt2::vertcat(nt2::horzcat(h, h), nt2::horzcat(h, -h)); h = h1; //ALIASING } out = h; return out; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1, A2& a2) const { result_type that; nt2_la_int n = std::min(nt2::height(a0),nt2::width(a0)); nt2_la_int lda = n; nt2_la_int nhrs = nt2::width(a2); nt2_la_int ldb = a2.leading_size(); a1.resize(nt2::of_size(n,1)); magma_zgesv(n,nhrs,(cuDoubleComplex*)a0.data(),lda,a1.data() ,(cuDoubleComplex*)a2.data(),ldb,&that); return that; }
BOOST_FORCEINLINE result_type operator()(A0 const& a0, A1 const&a1, A2 const& a2) const { result_type rcond; nt2_la_int n = nt2::height(a0); nt2_la_int ld = n; nt2_la_int info; char uplo = 'L'; nt2::memory::container<tag::table_, v_t, nt2::_2D> work(nt2::of_size(2*n,1)); NT2_F77NAME(zsycon) ( &uplo, &n, a0.raw(), &ld, a1.raw(), &a2, &rcond , work.raw(), &info ); return rcond; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1, A2& a2) const { result_type that; details::workspace<typename A0::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int lwork_query = -1; magma_sgeqp3 (m, n, 0, ld, 0, 0, w.main() , lwork_query, &that ); w.prepare_main(); nt2::geqp3(a0,a1,a2,w); return that; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1, A2& a2) const { result_type that; details::workspace<typename A0::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); NT2_F77NAME(sgeqp3) (&m, &n, 0, &ld, 0, 0, w.main() , details::query(), &that ); w.prepare_main(); nt2::geqp3(a0,a1,a2,w); return that; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& a1,A2& a2) const { result_type that; details::workspace<typename A2::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int k = a1.leading_size(); char side = 'L'; char trans = 'N'; NT2_F77NAME(sormqr) (&side,&trans,&m, &m, &k, 0, &ld, 0, 0, &m, w.main() , details::query(), &that ); w.prepare_main(); nt2::mqr(a0,a1,a2,w); return that; }
result_type operator()(A0& out, const A1& in) const { size_t n = boost::proto::child_c<0>(in); BOOST_ASSERT_MSG(n!= 2, "There is no 2x2 magic matrix"); out.resize(nt2::of_size(n, n)); if(n%2 == 1) //Odd order { oddOrderMagicSquare(out,n); } else if(n%4 == 0) { evenx2(out,n); } else { evenx1(out,n); } return out; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& s, A2& u,A3 &vt, A4 jobu, A5 jobvt) const { result_type that; details::workspace<typename A0::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int ldu = u.leading_size() > 1 ? u.leading_size() : 1 ; nt2_la_int ldvt= vt.leading_size() > 1 ? vt.leading_size() : 1 ; NT2_F77NAME(sgesvd) (&jobu,&jobvt,&m, &n, 0, &ld, 0, 0, &ldu , 0, &ldvt, w.main() , details::query(), &that ); w.resize_main(5*nt2::max(m, n)); nt2::gesvd(a0,s,u,vt,jobu,jobvt,w); return that; }
BOOST_FORCEINLINE result_type operator()(A0& a0, A1& s) const { result_type info; details::workspace<typename A0::value_type> w; nt2_la_int m = nt2::height(a0); nt2_la_int n = nt2::width(a0); nt2_la_int ld = a0.leading_size(); nt2_la_int ldu = 1 ; nt2_la_int ldvt= 1 ; char job = 'N'; NT2_F77NAME(sgesvd) (&job, &job, &m, &n, 0, &ld, 0, 0, &ldu , 0, &ldvt, w.main() , details::query(), &info ); w.prepare_main(); w.resize_main(5*nt2::max(m, n)); nt2::gesvd_w(a0,s,w); return info; }