TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, LexographicLess ) {
success = true;
// Build sorted index set of dimension d and order p
typedef Stokhos::TotalOrderIndexSet<ordinal_type> index_set_type;
typedef index_set_type::multiindex_type multiindex_type;
typedef Stokhos::LexographicLess<multiindex_type> less_type;
typedef std::set<multiindex_type, less_type> multiindex_set;
typedef multiindex_set::iterator iterator;
index_set_type indexSet(setup.d, 0, setup.p);
multiindex_set sortedIndexSet(indexSet.begin(), indexSet.end());
// Print sorted index set
std::ostream_iterator<multiindex_type> out_iterator(out, "\n");
out << std::endl << "Sorted lexicographic index set (dimension = "
<< setup.d << ", order = " << setup.p << "):" << std::endl;
std::copy(sortedIndexSet.begin(), sortedIndexSet.end(), out_iterator);
// Ensure orders of each index are increasing
iterator prev = sortedIndexSet.begin();
iterator curr = prev; ++curr;
while (curr != sortedIndexSet.end()) {
ordinal_type i = 0;
while (i < setup.d && (*prev)[i] == (*curr)[i]) ++i;
if (i == setup.d || (*prev)[i] >= (*curr)[i]) {
out << "previous index " << *prev << " and current index "
<< *curr << " are out of order" << std::endl;
success = false;
}
prev = curr;
++curr;
}
}
TEUCHOS_UNIT_TEST( Coefficients, Anisotropic ) {
success = true;
// Build anisotropic total order basis of dimension d
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(setup.d);
for (ordinal_type i=0; i<setup.d; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(i+1, true));
Teuchos::RCP<const Stokhos::TotalOrderBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::TotalOrderBasis<ordinal_type,value_type>(bases));
// Compute expected size
// Need to figure out how to do this
ordinal_type sz = basis->size();
// Check sizes
TEUCHOS_TEST_EQUALITY(sz, basis->size(), out, success);
std::ostream_iterator<ordinal_type> out_iterator(out, " ");
for (ordinal_type i=0; i<sz; i++) {
const Stokhos::MultiIndex<ordinal_type>& term = basis->term(i);
// Verify terms match
out << "term " << term << " <= " << setup.p << " : ";
bool is_less = true;
for (ordinal_type j=0; j<setup.d; j++)
is_less = is_less && term[j] <= j+1;
if (is_less)
out << "passed" << std::endl;
else {
out << "failed" << std::endl;
success = false;
}
}
}
TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, TotalOrderBasis ) {
success = true;
// Build index set of dimension d and order p
typedef Stokhos::TotalOrderIndexSet<ordinal_type> index_set_type;
typedef index_set_type::multiindex_type multiindex_type;
typedef index_set_type::iterator iterator;
index_set_type indexSet(setup.d, 0, setup.p);
// Build total-order basis from index set
typedef Stokhos::TensorProductElement<ordinal_type,ordinal_type> coeff_type;
typedef Stokhos::TotalOrderLess<coeff_type> less_type;
typedef std::map<coeff_type, ordinal_type, less_type> basis_set_type;
typedef basis_set_type::iterator basis_set_iterator;
typedef Teuchos::Array<coeff_type> basis_map_type;
basis_set_type basis_set;
basis_map_type basis_map;
Stokhos::ProductBasisUtils::buildProductBasis(
indexSet, basis_set, basis_map);
// Build total-order basis directly
ordinal_type sz;
Teuchos::Array< Stokhos::MultiIndex<ordinal_type> > terms;
Teuchos::Array<ordinal_type> num_terms;
Stokhos::CompletePolynomialBasisUtils<ordinal_type,value_type>::
compute_terms(setup.p, setup.d, sz, terms, num_terms);
// Check sizes
TEUCHOS_TEST_EQUALITY(static_cast<ordinal_type>(basis_set.size()),
static_cast<ordinal_type>(basis_map.size()),
out, success);
TEUCHOS_TEST_EQUALITY(static_cast<ordinal_type>(basis_set.size()),
static_cast<ordinal_type>(terms.size()),
out, success);
TEUCHOS_TEST_EQUALITY(sz, static_cast<ordinal_type>(terms.size()),
out, success);
std::ostream_iterator<ordinal_type> out_iterator(out, " ");
for (ordinal_type i=0; i<sz; i++) {
// Verify terms match
out << "term " << basis_map[i] << " == " << terms[i] << " : ";
bool is_equal = true;
for (ordinal_type j=0; j<setup.d; j++)
is_equal = is_equal && terms[i][j] == basis_map[i][j];
if (is_equal)
out << "passed" << std::endl;
else {
out << "failed" << std::endl;
success = false;
}
// Verify global index mapping matches
TEUCHOS_TEST_EQUALITY(basis_set[basis_map[i]], i, out, success);
}
}
void BinaryWriter::flushBuffer()
{
if(usedBitsInLastByte_ > 0)
++currentByte_;
std::ostream_iterator<uint8_t> out_iterator(ofs_);
std::copy(buffer_.begin(), buffer_.begin()+currentByte_, out_iterator);
std::fill(buffer_.begin(), buffer_.end(), 0);
currentByte_ = 0;
usedBitsInLastByte_ = 0;
}
TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, TensorProductBasis ) {
success = true;
// Build index set of dimension d and order p
typedef Stokhos::TensorProductIndexSet<ordinal_type> index_set_type;
typedef index_set_type::multiindex_type multiindex_type;
typedef index_set_type::iterator iterator;
index_set_type indexSet(setup.d, 0, setup.p);
// Build total-order basis from index set
typedef Stokhos::TensorProductElement<ordinal_type,ordinal_type> coeff_type;
typedef Stokhos::TotalOrderLess<coeff_type> less_type;
typedef std::map<coeff_type, ordinal_type, less_type> basis_set_type;
typedef basis_set_type::iterator basis_set_iterator;
typedef Teuchos::Array<coeff_type> basis_map_type;
basis_set_type basis_set;
basis_map_type basis_map;
Stokhos::ProductBasisUtils::buildProductBasis(
indexSet, basis_set, basis_map);
// Compute expected size
ordinal_type sz = 1;
for (ordinal_type i=0; i<setup.d; ++i)
sz *= setup.p+1;
// Check sizes
TEUCHOS_TEST_EQUALITY(static_cast<ordinal_type>(basis_set.size()),
static_cast<ordinal_type>(basis_map.size()),
out, success);
TEUCHOS_TEST_EQUALITY(sz, static_cast<ordinal_type>(basis_set.size()),
out, success);
std::ostream_iterator<ordinal_type> out_iterator(out, " ");
for (ordinal_type i=0; i<sz; i++) {
// Verify terms match
out << "term " << basis_map[i] << " <= " << setup.p << " : ";
bool is_less = true;
for (ordinal_type j=0; j<setup.d; j++)
is_less = is_less && basis_map[i][j] <= setup.p;
if (is_less)
out << "passed" << std::endl;
else {
out << "failed" << std::endl;
success = false;
}
// Verify global index mapping matches
TEUCHOS_TEST_EQUALITY(basis_set[basis_map[i]], i, out, success);
}
}
TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils,
AnisotropicTotalOrderIndexSet ) {
success = true;
// Build index set of dimension d and order p
typedef Stokhos::AnisotropicTotalOrderIndexSet<ordinal_type> index_set_type;
typedef index_set_type::multiindex_type multiindex_type;
typedef index_set_type::iterator iterator;
multiindex_type upper(setup.d);
for (ordinal_type i=0; i<setup.d; ++i)
upper[i] = i+1;
index_set_type indexSet(setup.p, upper);
// Print index set
out << std::endl << "Anisotropic total order index set (dimension = "
<< setup.d << ", order = " << setup.p << ", and component orders = "
<< upper << "):" << std::endl;
std::ostream_iterator<multiindex_type> out_iterator(out, "\n");
std::copy(indexSet.begin(), indexSet.end(), out_iterator);
// Verify each index lies appropriatly in the set
for (iterator i=indexSet.begin(); i!=indexSet.end(); ++i) {
if (i->order() < 0 || i->order() > setup.p || !i->termWiseLEQ(upper)) {
out << "index " << *i << " does not lie in total order set! "
<< std::endl;
success = false;
}
}
// Need to figure out how to compute the size of such an index set
/*
// Put indices in sorted container -- this will ensure there are no
// duplicates, if we get the right size
typedef Stokhos::TotalOrderLess<multiindex_type> less_type;
typedef std::set<multiindex_type, less_type> multiindex_set;
multiindex_set sortedIndexSet(indexSet.begin(), indexSet.end());
out << "sorted index set size = " << sortedIndexSet.size() << std::endl;
out << "expected index set size = "
<< Stokhos::n_choose_k(setup.p+setup.d,setup.d) << std::endl;
if (static_cast<ordinal_type>(sortedIndexSet.size()) !=
Stokhos::n_choose_k(setup.p+setup.d,setup.d))
success = false;
*/
}
