void Stokhos::PecosOneDOrthogPolyBasis<ordinal_type,value_type>:: getQuadPoints(ordinal_type quad_order, Teuchos::Array<value_type>& quad_points, Teuchos::Array<value_type>& quad_weights, Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const { // This assumes Gaussian quadrature ordinal_type num_points = static_cast<ordinal_type>(std::ceil((quad_order+1)/2.0)); const Pecos::RealArray& gp = pecosPoly->collocation_points(num_points); const Pecos::RealArray& gw = pecosPoly->type1_collocation_weights(num_points); quad_points.resize(num_points); quad_weights.resize(num_points); for (ordinal_type i=0; i<num_points; i++) { quad_points[i] = gp[i]; quad_weights[i] = gw[i]; } // Evalute basis at gauss points quad_values.resize(num_points); for (ordinal_type i=0; i<num_points; i++) { quad_values[i].resize(p+1); evaluateBases(quad_points[i], quad_values[i]); } }
void Stokhos::RecurrenceBasis<ordinal_type,value_type>:: evaluateBasesAndDerivatives(const value_type& x, Teuchos::Array<value_type>& vals, Teuchos::Array<value_type>& derivs) const { evaluateBases(x, vals); derivs[0] = 0.0; if (p >= 1) derivs[1] = delta[0]/(gamma[0]*gamma[1]); for (ordinal_type i=2; i<=p; i++) derivs[i] = (delta[i-1]*vals[i-1] + (delta[i-1]*x-alpha[i-1])*derivs[i-1] - beta[i-1]*derivs[i-2])/gamma[i]; }
void Stokhos::MonoProjPCEBasis<ordinal_type, value_type>:: getQuadPoints(ordinal_type quad_order, Teuchos::Array<value_type>& quad_points, Teuchos::Array<value_type>& quad_weights, Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const { #ifdef STOKHOS_TEUCHOS_TIME_MONITOR TEUCHOS_FUNC_TIME_MONITOR("Stokhos::MonoProjPCEBasis -- compute Gauss points"); #endif // Call base class ordinal_type num_points = static_cast<ordinal_type>(std::ceil((quad_order+1)/2.0)); // We can't always reliably generate quadrature points of order > 2*p // when using sparse grids for the underlying quadrature if (limit_integration_order && quad_order > 2*this->p) quad_order = 2*this->p; Stokhos::RecurrenceBasis<ordinal_type,value_type>::getQuadPoints(quad_order, quad_points, quad_weights, quad_values); // Fill in the rest of the points with zero weight if (quad_weights.size() < num_points) { ordinal_type old_size = quad_weights.size(); quad_weights.resize(num_points); quad_points.resize(num_points); quad_values.resize(num_points); for (ordinal_type i=old_size; i<num_points; i++) { quad_weights[i] = value_type(0); quad_points[i] = quad_points[0]; quad_values[i].resize(this->p+1); evaluateBases(quad_points[i], quad_values[i]); } } }
void Stokhos::StieltjesPCEBasis<ordinal_type, value_type>:: getQuadPoints(ordinal_type quad_order, Teuchos::Array<value_type>& quad_points, Teuchos::Array<value_type>& quad_weights, Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const { TEUCHOS_FUNC_TIME_MONITOR("Stokhos::StieltjesPCEBasis -- compute Gauss points"); // Use underlying pce's quad points, weights, values if (use_pce_quad_points) { quad_points = pce_vals; quad_weights = pce_weights; quad_values = phi_vals; return; } // Call base class ordinal_type num_points = static_cast<ordinal_type>(std::ceil((quad_order+1)/2.0)); if (quad_order > 2*this->p) quad_order = 2*this->p; Stokhos::RecurrenceBasis<ordinal_type,value_type>::getQuadPoints(quad_order, quad_points, quad_weights, quad_values); if (quad_weights.size() < num_points) { ordinal_type old_size = quad_weights.size(); quad_weights.resize(num_points); quad_points.resize(num_points); quad_values.resize(num_points); for (ordinal_type i=old_size; i<num_points; i++) { quad_values[i].resize(this->p+1); evaluateBases(quad_points[i], quad_values[i]); } } }
void Stokhos::RecurrenceBasis<ordinal_type,value_type>:: getQuadPoints(ordinal_type quad_order, Teuchos::Array<value_type>& quad_points, Teuchos::Array<value_type>& quad_weights, Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const { //This is a transposition into C++ of Gautschi's code for taking the first // N recurrance coefficient and generating a N point quadrature rule. // The MATLAB version is available at // http://www.cs.purdue.edu/archives/2002/wxg/codes/gauss.m ordinal_type num_points = static_cast<ordinal_type>(std::ceil((quad_order+1)/2.0)); Teuchos::Array<value_type> a(num_points,0); Teuchos::Array<value_type> b(num_points,0); Teuchos::Array<value_type> c(num_points,0); Teuchos::Array<value_type> d(num_points,0); // If we don't have enough recurrance coefficients, get some more. if(num_points > p+1) { bool is_normalized = computeRecurrenceCoefficients(num_points, a, b, c, d); if (!is_normalized) normalizeRecurrenceCoefficients(a, b, c, d); } else { //else just take the ones we already have. for(ordinal_type n = 0; n<num_points; n++) { a[n] = alpha[n]; b[n] = beta[n]; c[n] = delta[n]; d[n] = gamma[n]; } if (!normalize) normalizeRecurrenceCoefficients(a, b, c, d); } // With normalized coefficients, A is symmetric and tri-diagonal, with // diagonal = a, and off-diagonal = b, starting at b[1] Teuchos::SerialDenseMatrix<ordinal_type,value_type> eig_vectors(num_points, num_points); Teuchos::Array<value_type> workspace(2*num_points); ordinal_type info_flag; Teuchos::LAPACK<ordinal_type,value_type> my_lapack; // compute the eigenvalues (stored in a) and right eigenvectors. if (num_points == 1) my_lapack.STEQR('I', num_points, &a[0], &b[0], eig_vectors.values(), num_points, &workspace[0], &info_flag); else my_lapack.STEQR('I', num_points, &a[0], &b[1], eig_vectors.values(), num_points, &workspace[0], &info_flag); // eigenvalues are sorted by STEQR quad_points.resize(num_points); quad_weights.resize(num_points); for (ordinal_type i=0; i<num_points; i++) { quad_points[i] = a[i]; if (std::abs(quad_points[i]) < quad_zero_tol) quad_points[i] = 0.0; quad_weights[i] = beta[0]*eig_vectors[i][0]*eig_vectors[i][0]; } // Evalute basis at gauss points quad_values.resize(num_points); for (ordinal_type i=0; i<num_points; i++) { quad_values[i].resize(p+1); evaluateBases(quad_points[i], quad_values[i]); } }