コード例 #1
0
ファイル: pcoderegs.c プロジェクト: TronicLabs/sdcc
static void RemoveRegFromLRBlock(regs *reg)
{
  if(elementsInSet(reg->reglives.usedpCodes) == 2) {
    pCode *pc1;

      /* only continue if there are just 2 uses of the register,
       * in in the local *entry* block and one in the local *exit* block */
        
      /* search for entry block */
      pc1 = indexSet(reg->reglives.usedpCodes, 1);

      if(insideLRBlock( pc1 )) {
        fprintf(stderr, "usedpCodes[0] inside LR block\n");
        deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
        Remove1pcode(pc1, reg);
      }

      pc1 = indexSet(reg->reglives.usedpCodes, 0);
      if(insideLRBlock( pc1 )) {
        fprintf(stderr, "usedpCodes[1] inside LR block\n");
        deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
        Remove1pcode(pc1, reg);
      }
        
      /* remove r0x00 */
      reg->isFree = 1;
      reg->wasUsed = 0;
  }
}
コード例 #2
0
ファイル: CoinPackedVector.cpp プロジェクト: rafapaz/FlopCpp
void
CoinPackedVector::append(const CoinPackedVectorBase & caboose)
{
   const int cs = caboose.getNumElements();
   if (cs == 0) {
       return;
   }
   if (testForDuplicateIndex()) {
       // Just to initialize the index heap
       indexSet("append (1st call)", "CoinPackedVector");
   }
   const int s = nElements_;
   // Make sure there is enough room for the caboose
   if ( capacity_ < s + cs)
      reserve(CoinMax(s + cs, 2 * capacity_));

   const int * cind = caboose.getIndices();
   const double * celem = caboose.getElements();
   CoinDisjointCopyN(cind, cs, indices_ + s);
   CoinDisjointCopyN(celem, cs, elements_ + s);
   CoinIotaN(origIndices_ + s, cs, s);
   nElements_ += cs;
   if (testForDuplicateIndex()) {
      std::set<int>& is = *indexSet("append (2nd call)", "CoinPackedVector");
      for (int i = 0; i < cs; ++i) {
	 if (!is.insert(cind[i]).second)
	    throw CoinError("duplicate index", "append", "CoinPackedVector");
      }
   }
}
コード例 #3
0
  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;
    }
  }
コード例 #4
0
  TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, LexographicMapping ) {
    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());

    // Loop over each index set element and test if mapping 
    // computes proper global index
    iterator i = sortedIndexSet.begin(); 
    ordinal_type idx = 0;
    while (i != sortedIndexSet.end()) {
      ordinal_type idx_mapping = lexicographicMapping(*i,setup.p);
      out << *i << ":  index = " << idx << " mapped index = " << idx_mapping 
	  << ":  ";
      if (idx == idx_mapping)
	out << "passed";
      else {
	out << "failed";
	success = false;
      }
      out << std::endl;
      ++i;
      ++idx;
    }
  }
コード例 #5
0
void CoinPackedVectorBase::duplicateIndex(const char *methodName,
  const char *className) const
{
  if (testForDuplicateIndex())
    indexSet(methodName, className);
  testedDuplicateIndex_ = true;
}
コード例 #6
0
bool CoinPackedVectorBase::isExistingIndex(int i) const
{
  if (!testedDuplicateIndex_)
    duplicateIndex("indexExists", "CoinPackedVectorBase");

  const std::set< int > &sv = *indexSet("indexExists", "CoinPackedVectorBase");
  return sv.find(i) != sv.end();
}
コード例 #7
0
  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);
    }

  }
コード例 #8
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);
    }

  }
コード例 #9
0
ファイル: concrete_grid.hpp プロジェクト: bempp/bempp
std::vector<int>
permuteInsertionDomainIndices(const std::vector<int> &domainIndices,
                              const Dune::GridFactory<DuneGrid> &factory,
                              const DuneGrid &grid) {

  std::vector<int> output(domainIndices.size());
  auto view = grid.leafGridView();
  const auto &indexSet = view.indexSet();
  for (auto it = grid.template leafbegin<0>(); it != grid.template leafend<0>();
       ++it) {
    const typename DuneGrid::template Codim<0>::Entity &element = *it;
    int insertionIndex = factory.insertionIndex(element);
    output[indexSet.index(element)] = domainIndices[insertionIndex];
  }

  return output;
}
コード例 #10
0
  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;
    */
  }
コード例 #11
0
ファイル: CoinPackedVector.cpp プロジェクト: rafapaz/FlopCpp
void
CoinPackedVector::insert( int index, double element )
{
   const int s = nElements_;
   if (testForDuplicateIndex()) {
      std::set<int>& is = *indexSet("insert", "CoinPackedVector");
      if (! is.insert(index).second)
	 throw CoinError("Index already exists", "insert", "CoinPackedVector");
   }

   if( capacity_ <= s ) {
      reserve( CoinMax(5, 2*capacity_) );
      assert( capacity_ > s );
   }
   indices_[s] = index;
   elements_[s] = element;
   origIndices_[s] = s;
   ++nElements_;
}
コード例 #12
0
double
  CoinPackedVectorBase::operator[](int i) const
{
  if (!testedDuplicateIndex_)
    duplicateIndex("operator[]", "CoinPackedVectorBase");

  // Get a reference to a map of full storage indices to
  // packed storage location.
  const std::set< int > &sv = *indexSet("operator[]", "CoinPackedVectorBase");
#if 1
  if (sv.find(i) == sv.end())
    return 0.0;
  return getElements()[findIndex(i)];
#else
  // LL: suggested change, somthing is wrong with this
  const size_t ind = std::distance(sv.begin(), sv.find(i));
  return (ind == sv.size()) ? 0.0 : getElements()[ind];
#endif
}
コード例 #13
0
ファイル: Test.cpp プロジェクト: ginging/cplusplus_testat3
void testRangeConstructor() {
	std::vector<int> myInts = {1, 2, 3, 4, 5};
	IndexableSet<int> indexSet(myInts.begin() , myInts.end());
	ASSERT_EQUAL(3, indexSet[2]);
}
コード例 #14
0
ファイル: icenode.cpp プロジェクト: oyaGG/aaOcean
SICALLBACK aaOcean_Evaluate( ICENodeContext& in_ctxt )
{
    aaOcean *pOcean = (aaOcean *)(CValue::siPtrType)in_ctxt.GetUserData();

    CIndexSet indexSet(in_ctxt, ID_IN_PointID );
    CDataArrayLong PointID(in_ctxt, ID_IN_PointID );
    CDataArrayBool bEnable(in_ctxt, ID_IN_ENABLE);
    CDataArrayFloat uCoord(in_ctxt, ID_IN_U);
    CDataArrayFloat vCoord(in_ctxt, ID_IN_V);
    CDataArrayBool enableFoam( in_ctxt, ID_IN_ENABLEFOAM);
    CDataArrayMatrix4f transform(in_ctxt, ID_IN_TRANSFORM);

    const int count = PointID.GetCount();

    float worldSpaceVec[3] = {0.0f, 0.0f, 0.0f};
    float localSpaceVec[3] = {0.0f, 0.0f, 0.0f};

    int transformArraySize = 0;
    bool transformSingleton = TRUE;

    if(transform.GetCount() > 1)
        transformSingleton = FALSE;

    ULONG out_portID = in_ctxt.GetEvaluatedOutputPortID( ); 
    switch( out_portID )
    {
        case ID_OUT_OCEAN:
        {
            CDataArrayVector3f outData( in_ctxt );
            if(bEnable[0])
            {
                #pragma omp parallel for private(worldSpaceVec, localSpaceVec)
                for(int i = 0; i<count; ++i)
                {
                    // get ocean displacement vector
                    worldSpaceVec[1] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eHEIGHTFIELD);
                    if(pOcean->isChoppy())
                    {
                        worldSpaceVec[0] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eCHOPX);
                        worldSpaceVec[2] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eCHOPZ);
                    }

                    // multiply displacement vector by input transform matrix
                    if(!transformSingleton)
                        transformArraySize = i;

                    multiplyMatrix(&worldSpaceVec[0], &localSpaceVec[0], transform, transformArraySize);

                    outData[i].PutX(localSpaceVec[0]);
                    outData[i].PutY(localSpaceVec[1]);
                    outData[i].PutZ(localSpaceVec[2]);

                    outData[i].PutX(worldSpaceVec[0]);
                    outData[i].PutY(worldSpaceVec[1]);
                    outData[i].PutZ(worldSpaceVec[2]);
                }
            }
            else
            {
                #pragma omp parallel for
                for(int i = 0; i<count; ++i)
                {
                    outData[i].PutX(0.f); 
                    outData[i].PutY(0.f); 
                    outData[i].PutZ(0.f);
                }
            }
        }
        break;

        case ID_OUT_FOAM:
        {
            if(pOcean->isChoppy() && bEnable[0] && enableFoam[0])
            {               
                CDataArrayFloat outData( in_ctxt );

                // output raw (unscaled) foam in ICE deformer
                #pragma omp parallel for
                for(int i = 0; i<count; ++i)
                    outData[i] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eFOAM);
            }
        }
        break;

        case ID_OUT_EIGEN_MINUS:
        {
            CDataArrayVector3f outData( in_ctxt );
            if(pOcean->isChoppy() && bEnable[0] && enableFoam[0])
            {
                #pragma omp parallel for private(worldSpaceVec, localSpaceVec)
                for(int i = 0; i<count; ++i)
                {
                    worldSpaceVec[0] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eEIGENMINUSX);
                    worldSpaceVec[2] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eEIGENMINUSZ);

                    multiplyMatrix(&worldSpaceVec[0], &localSpaceVec[0], transform, transformArraySize);

                    outData[i].PutX(localSpaceVec[0]);
                    outData[i].PutY(0.0f);
                    outData[i].PutZ(localSpaceVec[2]);
                }
            }
            else
            {
                #pragma omp parallel for
                for(int i = 0; i<count; ++i){
                    outData[i].PutX(0);outData[i].PutY(0);outData[i].PutZ(0);}
            }
        }
        break;

        case ID_OUT_EIGEN_PLUS:
        {
            CDataArrayVector3f outData( in_ctxt );
            if(pOcean->isChoppy() && bEnable[0] && enableFoam[0])
            {
                #pragma omp parallel for private(worldSpaceVec, localSpaceVec)
                for(int i = 0; i<count; ++i)
                {
                    worldSpaceVec[0] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eEIGENPLUSX);
                    worldSpaceVec[2] = pOcean->getOceanData(uCoord[i], vCoord[i], aaOcean::eEIGENPLUSZ);

                    multiplyMatrix(&worldSpaceVec[0], &localSpaceVec[0], transform, transformArraySize);

                    outData[i].PutX(localSpaceVec[0]);
                    outData[i].PutY(0.0f);
                    outData[i].PutZ(localSpaceVec[2]);
                }
            }
            else
            {
                #pragma omp parallel for
                for(int i = 0; i<count; ++i){
                    outData[i].PutX(0); outData[i].PutY(0); outData[i].PutZ(0);}
            }
        }
        break;
    }

    return CStatus::OK;
}
コード例 #15
0
  TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, LexographicMapping2 ) {
    success = true;

    // Build sorted index set of dimension d and order p
    ordinal_type d = setup.d;
    ordinal_type p = setup.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(d, 0, p);
    multiindex_set sortedIndexSet(indexSet.begin(), indexSet.end());

    // Loop over lexicographically sorted multi-indices, compute global index
    // using combinatorial number system, and test if it is correct
    multiindex_type index(d), num_terms(d), orders(d,p);
    bool stop = false;
    ordinal_type idx = 0;
    index[d-1] = -1;
    num_terms[d-1] = -1;
    while (!stop) {
      // Increment index to next lexicographic term
      ordinal_type dim = d-1;
      ++index[dim];
      while (dim > 0 && index[dim] > orders[dim]) {
	index[dim] = 0;
	--dim;
	++index[dim];
      }
      for (ordinal_type i=dim+1; i<d; ++i)
	orders[i] = orders[i-1] - index[i-1];

      if (index[dim] > orders[dim]) 
	stop = true;
      else {
	// Update num_terms:  num_terms[dim] = number of terms with 
	// order < index[dim] and dimension d-dim-1
	num_terms[dim] += Stokhos::n_choose_k(orders[dim]-index[dim]+d-dim,
					      d-dim-1);
	for (ordinal_type i=dim+1; i<d; ++i)
	  num_terms[i] = 0;

	// Compute global index
	ordinal_type I = num_terms.order();
	//ordinal_type I = lexicographicMapping(index, p);

	out << index << ":  index = " << idx << " mapped index = " << I
	    << ":  ";
	if (idx == I)
	  out << "passed";
	else {
	  out << "failed";
	  success = false;
	}
	out << std::endl;
      }

      ++idx;
    }
  }
コード例 #16
0
  TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, TotalOrderSparse3TensorNew ) {
    success = true;
    // ordinal_type dim = setup.d;
    // ordinal_type order = setup.p;
    ordinal_type dim = 2;
    ordinal_type order = 3;

    // 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(dim, 0, order);

    // 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);

    // 1-D bases
    Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<ordinal_type,value_type> > > bases(dim);
    for (ordinal_type i=0; i<dim; i++)
      bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<ordinal_type,value_type>(order, true));

    // Build Cijk tensor
    typedef Stokhos::Sparse3Tensor<ordinal_type,value_type> Cijk_type;
    total_order_predicate<ordinal_type> pred(dim, order);
    //general_predicate<basis_set_type> pred(basis_set);
    Teuchos::RCP<Cijk_type> Cijk =
      Stokhos::ProductBasisUtils::computeTripleProductTensorNew<ordinal_type,value_type>(bases, basis_set, basis_map, pred, pred, false);

    // Build Cijk tensor using original approach
    Teuchos::RCP<const Stokhos::CompletePolynomialBasis<ordinal_type,value_type> > basis = Teuchos::rcp(new Stokhos::CompletePolynomialBasis<ordinal_type,value_type>(bases));
    Teuchos::RCP<Cijk_type> Cijk2 =
      basis->computeTripleProductTensor();
    
    // Check sizes
    TEUCHOS_TEST_EQUALITY(Cijk->num_k(), Cijk2->num_k(), out, success);
    TEUCHOS_TEST_EQUALITY(Cijk->num_entries(), Cijk2->num_entries(), out, success);
    
    // Check tensors match
    for (Cijk_type::k_iterator k_it=Cijk2->k_begin(); 
	 k_it!=Cijk2->k_end(); ++k_it) {
      int k = Stokhos::index(k_it);
      for (Cijk_type::kj_iterator j_it = Cijk2->j_begin(k_it); 
	   j_it != Cijk2->j_end(k_it); ++j_it) {
	int j = Stokhos::index(j_it);
	for (Cijk_type::kji_iterator i_it = Cijk2->i_begin(j_it);
	     i_it != Cijk2->i_end(j_it); ++i_it) {
	  int i = Stokhos::index(i_it);
	  double c = Cijk->getValue(i,j,k);
	  double c2 = Stokhos::value(i_it);
	  double tol = setup.atol + c2*setup.rtol;
	  double err = std::abs(c-c2);
	  bool s = err < tol;
	  if (!s) {
	    out << std::endl
		<< "Check: rel_err( C(" << i << "," << j << "," << k << ") )"
		<< " = " << "rel_err( " << c << ", " << c2 << " ) = " << err 
		<< " <= " << tol << " : ";
	    if (s) out << "Passed.";
	    else out << "Failed!";
	    out << std::endl;
	  }
	  success = success && s;
	}
      }
    }
  }