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]);
}
}
