double ls_error(double *xval, double *yval, int cnt, ls_err_t etype) { double slope; double intercept; ls_stat_t stat; int i; double num, denom; ls_stats(xval, yval, cnt, &stat); slope = (cnt * stat.sum_xy - stat.sum_x * stat.sum_y)/ (cnt * stat.sum_xx - stat.sum_x*stat.sum_x); intercept = (stat.sum_xx * stat.sum_y - stat.sum_xy * stat.sum_x)/ (cnt * stat.sum_xx - stat.sum_x*stat.sum_x); num = denom = 0; for (i = 0; i < cnt; i++) { double e = rel_err(xval[i], yval[i], slope, intercept); switch (etype) { case LS_AVG: num += e; denom++; break; case LS_MAX: if (num < e) num = e; denom = 1; break; default: fprintf(stderr, "Invalid error type: %d\n", etype); exit(1); break; } } return num/denom; }
int calculate(double *r, node *A) { int i, j; double *r_pre; double damp_const; damp_const = (1.0 - DAMPING_FACTOR) / n; int my_rank, comm_sz, local_n; double start = 0, end = 0; // for time MPI_Init(NULL, NULL); /* Get my process rank */ MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); /* Find out how many processes are being used */ MPI_Comm_size(MPI_COMM_WORLD, &comm_sz); r_pre = malloc(n * sizeof(double)); local_n = n / comm_sz; double still_err = 1; double *local_r = malloc(local_n * sizeof(double)); if (my_rank == 0) { GET_TIME(start); } while (still_err > EPSILON) { backup_vec(r, r_pre, n); for ( i = local_n * my_rank; i < local_n * (my_rank + 1); i++) { local_r[i - local_n * my_rank] = 0.0; for ( j = 0; j < A[i].size_Di; ++j) { local_r[i - local_n * my_rank] += r_pre[A[i].Di[j]] / A[A[i].Di[j]].li; } local_r[i - local_n * my_rank] *= DAMPING_FACTOR; local_r[i - local_n * my_rank] += damp_const; } MPI_Gather(local_r, local_n, MPI_DOUBLE, r, local_n, MPI_DOUBLE, 0, MPI_COMM_WORLD); if (my_rank == 0) { still_err = rel_err(r, r_pre, n); } MPI_Bcast(&still_err, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD); MPI_Bcast(r, n, MPI_DOUBLE, 0, MPI_COMM_WORLD); } if (my_rank == 0) { GET_TIME(end); printf("%f\n", end-start); Lab4_saveoutput(r, n, end-start); } free(r_pre); MPI_Finalize(); return 0; }
static int hu_moments_test( void ) { const double success_error_level = 1e-7; CvSize size = { 512, 512 }; int i; IplImage* img = atsCreateImage( size.width, size.height, 8, 1, 0 ); CvMoments moments; CvHuMoments a, b; AtsRandState rng_state; int seed = atsGetSeed(); double nu20, nu02, nu11, nu30, nu21, nu12, nu03; double err = 0; char buffer[100]; atsRandInit( &rng_state, 0, 255, seed ); atsbRand8u( &rng_state, (uchar*)(img->imageData), size.width * size.height ); cvMoments( img, &moments, 0 ); atsReleaseImage( img ); nu20 = cvGetNormalizedCentralMoment( &moments, 2, 0 ); nu11 = cvGetNormalizedCentralMoment( &moments, 1, 1 ); nu02 = cvGetNormalizedCentralMoment( &moments, 0, 2 ); nu30 = cvGetNormalizedCentralMoment( &moments, 3, 0 ); nu21 = cvGetNormalizedCentralMoment( &moments, 2, 1 ); nu12 = cvGetNormalizedCentralMoment( &moments, 1, 2 ); nu03 = cvGetNormalizedCentralMoment( &moments, 0, 3 ); cvGetHuMoments( &moments, &a ); b.hu1 = nu20 + nu02; b.hu2 = sqr(nu20 - nu02) + 4*sqr(nu11); b.hu3 = sqr(nu30 - 3*nu12) + sqr(3*nu21 - nu03); b.hu4 = sqr(nu30 + nu12) + sqr(nu21 + nu03); b.hu5 = (nu30 - 3*nu12)*(nu30 + nu12)*(sqr(nu30 + nu12) - 3*sqr(nu21 + nu03)) + (3*nu21 - nu03)*(nu21 + nu03)*(3*sqr(nu30 + nu12) - sqr(nu21 + nu03)); b.hu6 = (nu20 - nu02)*(sqr(nu30 + nu12) - sqr(nu21 + nu03)) + 4*nu11*(nu30 + nu12)*(nu21 + nu03); b.hu7 = (3*nu21 - nu03)*(nu30 + nu12)*(sqr(nu30 + nu12) - 3*sqr(nu21 + nu03)) + (3*nu12 - nu30)*(nu21 + nu03)*(3*sqr(nu30 + nu12) - sqr(nu21 + nu03)); for( i = 0; i < 7; i++ ) { double t = rel_err( ((double*)&b)[i], ((double*)&a)[i] ); if( t > err ) err = t; } sprintf( buffer, "Accuracy: %.4e", err ); return trsResult( err > success_error_level ? TRS_FAIL : TRS_OK, buffer ); }
/* ///////////////////// moments_test ///////////////////////// */ static int moments_test( void* arg ) { static double weight[] = { 1e6, 1e6, 1e6, /* m00, m10, m01 */ 1e6, 1e6, 1e6, 1, 1, 1, 1, /* m20 - m03 */ 1, 1e-4, 1, 1e-5, 1e-5, 1e-5, 1e-5, /* mu20 - mu03 */ 1, 1, 1, 1, 1, 1, 1 }; /* nu20 - nu03 */ const double success_error_level = 1e-4; int param = (int)arg; int binary = param >= 6; int depth = (param % 6)/2; int channels = (param & 1); int seed = atsGetSeed(); /* position where the maximum error occured */ int merr_w = 0, merr_h = 0, merr_iter = 0, merr_c = 0; /* test parameters */ int w = 0, h = 0, i = 0, c = 0; double max_err = 0.; //int code = TRS_OK; IplROI roi; IplImage *img; AtsRandState rng_state; atsRandInit( &rng_state, 0, 1, seed ); read_moments_params(); if( !(ATS_RANGE( binary, fn_l, fn_h+1 ) && ATS_RANGE( depth, dt_l, dt_h+1 ) && ATS_RANGE( channels, ch_l, ch_h+1 ))) return TRS_UNDEF; depth = depth == 2 ? IPL_DEPTH_32F : depth == 1 ? IPL_DEPTH_8S : IPL_DEPTH_8U; channels = channels*2 + 1; img = atsCreateImage( max_img_size, max_img_size, depth, channels, 0 ); roi.coi = 0; roi.xOffset = roi.yOffset = 0; img->roi = &roi; for( h = min_img_size; h <= max_img_size; ) { for( w = min_img_size; w <= max_img_size; ) { int denom = (w - min_img_size + 1)*(h - min_img_size + 1)*channels; int iters = (base_iters*2 + denom)/(2*denom); roi.width = w; roi.height = h; if( iters < 1 ) iters = 1; for( i = 0; i < iters; i++ ) { switch( depth ) { case IPL_DEPTH_8U: atsRandSetBounds( &rng_state, 0, img8u_range ); break; case IPL_DEPTH_8S: atsRandSetBounds( &rng_state, -img8s_range, img8s_range ); break; case IPL_DEPTH_32F: atsRandSetBounds( &rng_state, -img32f_range, img32f_range ); if( binary ) atsRandSetFloatBits( &rng_state, img32f_bits ); break; } roi.coi = 0; atsFillRandomImageEx( img, &rng_state ); /*iplSet( img, depth == IPL_DEPTH_8S ? 125 : 251 );*/ for( c = 1; c <= channels; c++ ) { double err0 = 0; AtsMomentState astate0, astate1; CvMoments istate; double* a0 = (double*)&astate0; double* a1 = (double*)&astate1; int j; roi.coi = c; /* etalon function */ atsCalcMoments( img, &astate0, binary ); /* cv function */ cvMoments( img, &istate, binary ); atsGetMoments( &istate, &astate1 ); /*iplMoments( img, lstate ); */ /*convert_ipl_to_ats( lstate, &astate1 ); */ for( j = 0; j < sizeof(astate0)/sizeof(double); j++ ) { double err = rel_err( a0[j], a1[j] )*weight[j]; err0 = MAX( err0, err ); } if( err0 > max_err ) { merr_w = w; merr_h = h; merr_iter = i; merr_c = c; max_err = err0; if( max_err > success_error_level ) goto test_exit; } } } ATS_INCREASE( w, img_size_delta_type, img_size_delta ); } /* end of the loop by w */ ATS_INCREASE( h, img_size_delta_type, img_size_delta ); } /* end of the loop by h */ test_exit: img->roi = 0; iplDeallocate( img, IPL_IMAGE_ALL ); //if( code == TRS_OK ) { trsWrite( ATS_LST, "Max err is %g at w = %d, h = %d, " "iter = %d, c = %d, seed = %08x", max_err, merr_w, merr_h, merr_iter, merr_c, seed ); return max_err <= success_error_level ? trsResult( TRS_OK, "No errors" ) : trsResult( TRS_FAIL, "Bad accuracy" ); } /*else { trsWrite( ATS_LST, "Fatal error at w = %d, h = %d, " "iter = %d, c = %d, seed = %08x", w, h, i, c, seed ); return trsResult( TRS_FAIL, "Function returns error code" ); }*/ }
int main(int argc, char **argv) { try { const unsigned int d = 2; const unsigned int pmin = 2; const unsigned int pmax = 10; const unsigned int np = pmax-pmin+1; bool use_pce_quad_points = false; bool normalize = true; bool sparse_grid = true; bool project_integrals = false; #ifndef HAVE_STOKHOS_DAKOTA sparse_grid = false; #endif Teuchos::Array<double> mean(np), mean_st(np), std_dev(np), std_dev_st(np); Teuchos::Array<double> pt(np), pt_st(np); Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d); Teuchos::Array<double> eval_pt(d, 0.5); double pt_true; // Loop over orders unsigned int n = 0; for (unsigned int p=pmin; p<=pmax; p++) { std::cout << "p = " << p << std::endl; // Create product basis for (unsigned int i=0; i<d; i++) bases[i] = Teuchos::rcp(new basis_type(p)); Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis = Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases)); // Create approximation Stokhos::OrthogPolyApprox<int,double> x(basis), u(basis), v(basis), w(basis), w2(basis); for (unsigned int i=0; i<d; i++) { x.term(i, 1) = 1.0; } double x_pt = x.evaluate(eval_pt); pt_true = std::exp(std::sin(x_pt)); // Quadrature Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad; #ifdef HAVE_STOKHOS_DAKOTA if (sparse_grid) quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(basis, p)); #endif if (!sparse_grid) quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis)); // Triple product tensor Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk = basis->computeTripleProductTensor(basis->size()); // Quadrature expansion Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk, quad); // Compute PCE via quadrature expansion quad_exp.sin(u,x); //quad_exp.times(u,u,10.0); quad_exp.exp(w,u); // Compute Stieltjes basis Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > st_bases(1); Teuchos::RCP<const Stokhos::LanczosProjPCEBasis<int,double> > st_1d_basis = Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<int,double>( p, Teuchos::rcp(&u,false), Cijk, normalize)); st_bases[0] = st_1d_basis; Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > st_basis = Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(st_bases)); //std::cout << *st_basis << std::endl; Stokhos::OrthogPolyApprox<int,double> u_st(st_basis), w_st(st_basis); u_st.term(0, 0) = st_1d_basis->getNewCoeffs(0); u_st.term(0, 1) = st_1d_basis->getNewCoeffs(1); // Triple product tensor Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk = st_basis->computeTripleProductTensor(st_basis->size()); // Tensor product quadrature Teuchos::RCP<const Stokhos::Quadrature<int,double> > st_quad; if (!use_pce_quad_points) { #ifdef HAVE_STOKHOS_DAKOTA if (sparse_grid) st_quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(st_basis, p)); #endif if (!sparse_grid) st_quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(st_basis)); } else { Teuchos::Array<double> st_points_0; Teuchos::Array<double> st_weights_0; Teuchos::Array< Teuchos::Array<double> > st_values_0; st_bases[0]->getQuadPoints(p+1, st_points_0, st_weights_0, st_values_0); Teuchos::Array<double> st_points_1; Teuchos::Array<double> st_weights_1; Teuchos::Array< Teuchos::Array<double> > st_values_1; st_bases[1]->getQuadPoints(p+1, st_points_1, st_weights_1, st_values_1); Teuchos::RCP< Teuchos::Array< Teuchos::Array<double> > > st_points = Teuchos::rcp(new Teuchos::Array< Teuchos::Array<double> >(st_points_0.size())); for (int i=0; i<st_points_0.size(); i++) { (*st_points)[i].resize(2); (*st_points)[i][0] = st_points_0[i]; (*st_points)[i][1] = st_points_1[i]; } Teuchos::RCP< Teuchos::Array<double> > st_weights = Teuchos::rcp(new Teuchos::Array<double>(st_weights_0)); Teuchos::RCP< const Stokhos::OrthogPolyBasis<int,double> > st_b = st_basis; st_quad = Teuchos::rcp(new Stokhos::UserDefinedQuadrature<int,double>(st_b, st_points, st_weights)); } // Quadrature expansion Stokhos::QuadOrthogPolyExpansion<int,double> st_quad_exp(st_basis, st_Cijk, st_quad); // Compute w_st = u_st*v_st in Stieltjes basis st_quad_exp.exp(w_st, u_st); // Project w_st back to original basis pce_quad_func st_func(w_st, *st_basis); quad_exp.unary_op(st_func, w2, u); // std::cout.precision(12); // std::cout << w; // std::cout << w2; // std::cout << w_st; mean[n] = w.mean(); mean_st[n] = w2.mean(); std_dev[n] = w.standard_deviation(); std_dev_st[n] = w2.standard_deviation(); pt[n] = w.evaluate(eval_pt); pt_st[n] = w2.evaluate(eval_pt); n++; } n = 0; int wi=10; std::cout << "Statistical error:" << std::endl; std::cout << "p " << std::setw(wi) << "mean" << " " << std::setw(wi) << "mean_st" << " " << std::setw(wi) << "std_dev" << " " << std::setw(wi) << "std_dev_st" << " " << std::setw(wi) << "point" << " " << std::setw(wi) << "point_st" << std::endl; for (unsigned int p=pmin; p<pmax; p++) { std::cout.precision(3); std::cout.setf(std::ios::scientific); std::cout << p << " " << std::setw(wi) << rel_err(mean[n], mean[np-1]) << " " << std::setw(wi) << rel_err(mean_st[n], mean[np-1]) << " " << std::setw(wi) << rel_err(std_dev[n], std_dev[np-1]) << " " << std::setw(wi) << rel_err(std_dev_st[n], std_dev[np-1]) << " " << std::setw(wi) << rel_err(pt[n], pt_true) << " " << std::setw(wi) << rel_err(pt_st[n], pt_true) << std::endl; n++; } } catch (std::exception& e) { std::cout << e.what() << std::endl; } }
double estimate_ml_t(log_like_function_t *log_like, const double* t, size_t n_pts, const double tolerance, bsm_t* model, bool* success, const double min_t, const double max_t) { *success = false; point_t *starting_pts = malloc(sizeof(point_t) * n_pts); evaluate_ll(log_like, t, n_pts, starting_pts); const size_t orig_n_pts = n_pts; point_t* points = select_points(log_like, starting_pts, &n_pts, DEFAULT_MAX_POINTS, min_t, max_t); free(starting_pts); if (points == NULL) { fprintf(stderr, "ERROR: select_points returned NULL\n"); *success = false; return NAN; } curve_type_t curvature = classify_curve(points, n_pts); if (!(curvature == CRV_ENC_MAXIMA || curvature == CRV_MONO_DEC)) { fprintf(stderr, "ERROR: " "points don't enclose a maximum and aren't decreasing\n"); free(points); *success = false; return NAN; } /* From here on, curvature is CRV_ENC_MAXIMA or CRV_MONO_DEC, and * thus ml_t is zero or positive (but not infinite). */ assert(n_pts >= orig_n_pts); if (n_pts > orig_n_pts) { /* Subset to top orig_n_pts */ subset_points(points, n_pts, orig_n_pts); n_pts = orig_n_pts; } assert(points[0].t >= min_t); assert(points[n_pts - 1].t <= max_t); #ifdef LCFIT_AUTO_VERBOSE fprintf(stderr, "starting iterative fit\n"); fprintf(stderr, "starting points: "); print_points(stderr, points, n_pts); fprintf(stderr, "\n"); #endif /* LCFIT_AUTO_VERBOSE */ /* Allocate an extra point for scratch */ points = realloc(points, sizeof(point_t) * (n_pts + 1)); size_t iter = 0; const point_t* max_pt = NULL; double ml_t = 0.0; double prev_t = 0.0; for (iter = 0; iter < MAX_ITERS; iter++) { max_pt = max_point(points, n_pts); /* Re-fit */ lcfit_bsm_rescale(max_pt->t, max_pt->ll, model); double* tbuf = malloc(sizeof(double) * n_pts); double* lbuf = malloc(sizeof(double) * n_pts); blit_points_to_arrays(points, n_pts, tbuf, lbuf); double* wbuf = malloc(sizeof(double) * n_pts); double alpha = (double) iter / (MAX_ITERS - 1); for (size_t i = 0; i < n_pts; ++i) { wbuf[i] = exp(alpha * (lbuf[i] - max_pt->ll)); } #ifdef LCFIT_AUTO_VERBOSE fprintf(stderr, "weights: "); for (size_t i = 0; i < n_pts; ++i) { fprintf(stderr, "%g ", wbuf[i]); } fprintf(stderr, "\n"); #endif /* LCFIT_AUTO_VERBOSE */ lcfit_fit_bsm_weight(n_pts, tbuf, lbuf, wbuf, model, 250); free(tbuf); free(lbuf); free(wbuf); ml_t = lcfit_bsm_ml_t(model); if (isnan(ml_t)) { fprintf(stderr, "ERROR: " "lcfit_bsm_ml_t returned NaN" ", model = { %.3f, %.3f, %.6f, %.6f }\n", model->c, model->m, model->r, model->b); *success = false; break; } if (curvature == CRV_ENC_MAXIMA) { /* Stop if the modeled maximum likelihood branch length is * within tolerance of the empirical maximum. */ if (rel_err(max_pt->t, ml_t) <= tolerance) { *success = true; break; } } double next_t = bound_point(ml_t, points, n_pts, min_t, max_t); /* Stop if the next sample point is within tolerance of the * previous sample point. */ if (rel_err(prev_t, next_t) <= tolerance) { *success = true; break; } points[n_pts].t = next_t; points[n_pts].ll = log_like->fn(next_t, log_like->args); prev_t = next_t; sort_by_t(points, n_pts + 1); curvature = classify_curve(points, n_pts + 1); if (!(curvature == CRV_ENC_MAXIMA || curvature == CRV_MONO_DEC)) { fprintf(stderr, "ERROR: " "after iteration points don't enclose a maximum " "and aren't decreasing\n"); *success = false; break; } ++n_pts; points = realloc(points, sizeof(point_t) * (n_pts + 1)); #ifdef LCFIT_AUTO_VERBOSE fprintf(stderr, "current points: "); print_points(stderr, points, n_pts); fprintf(stderr, "\n"); #endif /* LCFIT_AUTO_VERBOSE */ } if (iter == MAX_ITERS) { fprintf(stderr, "WARNING: maximum number of iterations reached\n"); } free(points); #ifdef LCFIT_AUTO_VERBOSE fprintf(stderr, "ending iterative fit after %zu iteration(s)\n", iter); #endif /* LCFIT_AUTO_VERBOSE */ if (ml_t < min_t) { ml_t = min_t; } else if (ml_t > max_t) { ml_t = max_t; } return ml_t; }
int main(int argc, char **argv) { try { const int d = 5; const int pmin = 1; const int pmax = 10; const int np = pmax-pmin+1; const double a = 1.5; bool use_pce_quad_points = false; bool normalize = false; bool project_integrals = false; bool lanczos = true; bool sparse_grid = true; #ifndef HAVE_STOKHOS_DAKOTA sparse_grid = false; #endif Teuchos::Array<double> mean(np), mean_st(np), std_dev(np), std_dev_st(np); Teuchos::Array<double> pt(np), pt_st(np); Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d); Teuchos::Array<double> eval_pt(d, 0.56789); double pt_true; // Loop over orders int n = 0; for (int p=pmin; p<=pmax; p++) { std::cout << "p = " << p << std::endl; // Create product basis for (int i=0; i<d; i++) bases[i] = Teuchos::rcp(new basis_type(p)); Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis = Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases)); // Create approximation Stokhos::OrthogPolyApprox<int,double> s(basis), t1(basis), t2(basis); Teuchos::Array< Stokhos::OrthogPolyApprox<int,double>* > xi(d); for (int i=0; i<d; i++) { xi[i] = new Stokhos::OrthogPolyApprox<int,double>(basis); xi[i]->term(i, 1) = 1.0; } // Quadrature Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad; #ifdef HAVE_STOKHOS_DAKOTA if (sparse_grid) quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(basis, p)); #endif if (!sparse_grid) quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis)); // Triple product tensor Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk = basis->computeTripleProductTensor(); // Quadrature expansion Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk, quad); // Compute PCE via quadrature expansion s_quad_func<d> s_func(a); const Stokhos::OrthogPolyApprox<int,double> **xip = new const Stokhos::OrthogPolyApprox<int,double>*[d]; for (int i=0; i<d; i++) xip[i] = xi[i]; quad_exp.nary_op(s_func,s,xip); quad_exp.divide(t1,1.0,s); delete [] xip; // compute true point Teuchos::Array<double> xx(d); for (int i=0; i<d; i++) xx[i] = xi[i]->evaluate(eval_pt); pt_true = s_func(&(xx[0])); pt_true = 1.0/pt_true; // Compute Stieltjes basis Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > st_bases(1); Teuchos::RCP< Stokhos::LanczosProjPCEBasis<int,double> > stp_basis_s; Teuchos::RCP< Stokhos::LanczosPCEBasis<int,double> > st_basis_s; if (lanczos) { if (project_integrals) { stp_basis_s = Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<int,double>( p, Teuchos::rcp(&s,false), Cijk, normalize, true)); st_bases[0] = stp_basis_s; } else { st_basis_s = Teuchos::rcp(new Stokhos::LanczosPCEBasis<int,double>( p, Teuchos::rcp(&s,false), quad, normalize, true)); st_bases[0] = st_basis_s; } } else { st_bases[0] = Teuchos::rcp(new Stokhos::StieltjesPCEBasis<int,double>( p, Teuchos::rcp(&s,false), quad, use_pce_quad_points, normalize, project_integrals, Cijk)); } Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > st_basis = Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(st_bases)); //std::cout << *st_basis << std::endl; Stokhos::OrthogPolyApprox<int,double> s_st(st_basis), t_st(st_basis); if (lanczos) { if (project_integrals) { s_st.term(0, 0) = stp_basis_s->getNewCoeffs(0); s_st.term(0, 1) = stp_basis_s->getNewCoeffs(1); } else { s_st.term(0, 0) = st_basis_s->getNewCoeffs(0); s_st.term(0, 1) = st_basis_s->getNewCoeffs(1); } } else { s_st.term(0, 0) = s.mean(); s_st.term(0, 1) = 1.0; } // Triple product tensor Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk = st_basis->computeTripleProductTensor(); // Tensor product quadrature Teuchos::RCP<const Stokhos::Quadrature<int,double> > st_quad; #ifdef HAVE_STOKHOS_DAKOTA if (sparse_grid) st_quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(st_basis, p)); #endif if (!sparse_grid) st_quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(st_basis)); // Quadrature expansion Stokhos::QuadOrthogPolyExpansion<int,double> st_quad_exp(st_basis, st_Cijk, st_quad); // Compute t_st = 1/s_st in Stieltjes basis st_quad_exp.divide(t_st, 1.0, s_st); // Project t_st back to original basis pce_quad_func st_func(t_st, *st_basis); quad_exp.unary_op(st_func, t2, s); // std::cout.precision(12); // std::cout << w; // std::cout << w2; // std::cout << w_st; mean[n] = t1.mean(); mean_st[n] = t2.mean(); std_dev[n] = t1.standard_deviation(); std_dev_st[n] = t2.standard_deviation(); pt[n] = t1.evaluate(eval_pt); pt_st[n] = t2.evaluate(eval_pt); n++; for (int i=0; i<d; i++) delete xi[i]; } n = 0; int wi=10; std::cout << "Statistical error:" << std::endl; std::cout << "p " << std::setw(wi) << "mean" << " " << std::setw(wi) << "mean_st" << " " << std::setw(wi) << "std_dev" << " " << std::setw(wi) << "std_dev_st" << " " << std::setw(wi) << "point" << " " << std::setw(wi) << "point_st" << std::endl; for (int p=pmin; p<pmax; p++) { std::cout.precision(3); std::cout.setf(std::ios::scientific); std::cout << p << " " << std::setw(wi) << rel_err(mean[n], mean[np-1]) << " " << std::setw(wi) << rel_err(mean_st[n], mean[np-1]) << " " << std::setw(wi) << rel_err(std_dev[n], std_dev[np-1]) << " " << std::setw(wi) << rel_err(std_dev_st[n], std_dev[np-1]) << " " << std::setw(wi) << rel_err(pt[n], pt_true) << " " << std::setw(wi) << rel_err(pt_st[n], pt_true) << std::endl; n++; } } catch (std::exception& e) { std::cout << e.what() << std::endl; } }