index.h

Go to the documentation of this file.

/* 
 * AMB,
 * KG,  splitted from tensor.h, 99/05/31
 * $Id: index.h,v 1.4.2.16 2019/05/28 11:13:02 garloff Exp $
 */
 
#ifndef TBCI_INDEX_H
#define TBCI_INDEX_H
 
#include "tbci/vector.h"
 
// Avoid -fguiding-decls
#if !defined(NO_GD) && !defined(AUTO_DECL)
# include "index_gd.h"
#endif
 
NAMESPACE_TBCI
 
#ifndef TBCI_DISABLE_EXCEPT
class IdxErr : public NumErr
{
    public:
        IdxErr() 
        : NumErr("Error in Index class") {}
        IdxErr(const char* t, const long i = 0) 
        : NumErr(t, i) {}
        IdxErr(const IdxErr& ie)
        : NumErr(ie) {}
        virtual ~IdxErr() throw() {}    
};
#endif

 
#if defined(PRAGMA_I) && defined (PRAGMA_I_IDX) && ! defined(_NO_IDX_PRAGMA)
# pragma interface "index.h"
#endif

class Index : public Vector <unsigned>
{
  
protected:
  
public:
  Index () : Vector <unsigned> () {}
  Index (const unsigned dim) : Vector<unsigned> (dim) {}
  Index (const unsigned value, const unsigned dim) : Vector<unsigned> (value, dim) {}
  Index (const Index & idx) : Vector<unsigned> (idx) {}
  Index (const Vector <unsigned> & vec) : Vector<unsigned> (vec) {}
  Index (const TVector <unsigned> & tv) : Vector<unsigned> (tv) {}
  // variable argument number 
  Index (vararg va, ...) : Vector <unsigned> ((unsigned)va)
    {
      va_list vl;
      va_start (vl, va);
      for (unsigned i = 0; i < (unsigned)va; ++i)
        (*this) (i) = va_arg (vl, unsigned);
      va_end (vl);
    }
  
  void lin_read (vararg va, ...)
    {
      //unsigned num=this->size();
      va_list vl;
      va_start (vl, va);
      for (unsigned i = 0; i < (unsigned)va; ++i)
        (*this) (i) = va_arg (vl, unsigned);
      va_end (vl);
    }
  
  //Iterators (++,-- syntax can not be used, as we need to know max)
  //work by incr/decr the last index, and wrap around ...
  //caller has to check if Index(0) is within the valid range
  //Really essential as it allows to linearize data access 
  // without circumventing the () operator in CTensor<>
 
  Index next_idx (const Index& max)
    {
      BCHK (dim != max.dim, IdxErr, Indexes of iterators must have same dim, max.dim, *this);
      (*this)(dim-1)++;
      for (unsigned r = dim-1; r; r--)
        if ((*this)(r) >= max(r)) { (*this)(r-1)++; (*this)(r) = 0; }
      return *this;
    }
  Index prev_idx (const Index& max)
    {
      BCHK (dim != max.dim, IdxErr, Indices of iterators must have same dim, max.dim, *this);
      (*this)(dim-1)--;
      for (unsigned r = dim-1; r; r--)
        if ((signed)(*this)(r) < 0) { (*this)(r-1)--; (*this)(r) = max(r); }
      return *this;
    }
  
  // Now a couple of functions to modify Index objects
  //for friend TVector<unsigned> idx_fill_in1 FGD (const Index&, const unsigned, const unsigned);
  TVector<unsigned> idx_fill_in1 (const unsigned, const unsigned) const;
  //for friend TVector<unsigned> idx_fill_in2 FGD (const Index&, const unsigned, 
  //                            const unsigned, const unsigned, const unsigned);
  TVector<unsigned> idx_fill_in2 (const unsigned, const unsigned, 
                                  const unsigned, const unsigned) const;
 
  //for friend TVector<unsigned> idx_remove1 FGD (const Index&, const unsigned);
  TVector<unsigned> idx_remove1 (const unsigned) const;
  //for friend TVector<unsigned> idx_remove2 FGD (const Index&, const unsigned, const unsigned);
  TVector<unsigned> idx_remove2 (const unsigned, const unsigned) const;
  //for friend TVector<unsigned> idx_set1 FGD (const Index&, const unsigned, const unsigned);
  TVector<unsigned> idx_set1 (const unsigned, const unsigned) const;
};
 
/* Implementation of Index modifying funcs */
// Notes (KG, 98/12/09): 
// - We give back a TVector<unsigned> instead of Index (optimization)
// - These functions should really be inlined. Otherwise the linker
//   will bite us because of multiple references, if we include this
//   header from more than one source file. (And it probably won't inline,
//   if we don't use optimization.) 
// Moving this class outside of a header would be an idea, as it's not
// templated.
 
inline TVector<unsigned>
Index::idx_fill_in1 (const unsigned where, const unsigned what) const
{
  TVector<unsigned> ix (size()+1);
  BCHK (where >= ix.size(), IdxErr, Index nr. out of range, where, *this);
  ix.set (what, where);
  unsigned i = 0;
  for (unsigned j = 0; j < size(); j++)
    {
      if (i == where) i++;
      ix.set ((*this)(j), i++);
    }
  return ix;
}
 
INST(class Index friend TVector<unsigned> idx_fill_in1 (const Index&, const unsigned, const unsigned);)
inline TVector<unsigned>
idx_fill_in1 (const Index& idx, const unsigned where, const unsigned what)
{ return idx.idx_fill_in1 (where, what); }
 
inline TVector<unsigned>
Index::idx_fill_in2 (const unsigned where1, const unsigned what1, 
                     const unsigned where2, const unsigned what2) const
{
  TVector<unsigned> ix (size()+2);
  BCHK (where1 >= ix.size(), IdxErr, Index nr. 1 out of range, where1, *this);
  BCHK (where2 >= ix.size(), IdxErr, Index nr. 2 out of range, where2, *this);
  ix.set (what1, where1); ix.set (what2, where2);
  unsigned i = 0;
  for (unsigned j = 0; j < size(); j++)
    {
      while (i == where1 || i == where2) i++;
      ix.set ((*this)(j), i++);
    }
  return ix;
}
 
INST(class Index friend TVector<unsigned> idx_fill_in2 (const Index&, const unsigned, const unsigned, const unsigned, const unsigned);)
inline TVector<unsigned>
idx_fill_in2 (const Index& idx, const unsigned where1, const unsigned what1, 
                                const unsigned where2, const unsigned what2)
{ return idx.idx_fill_in2 (where1, what1, where2, what2); }
 
 
inline TVector<unsigned>
Index::idx_remove1 (const unsigned which) const
{
  BCHK (which >= size(), IdxErr, Tried to remove non-existing index, which, *this);
  TVector<unsigned> ix (size()-1);
  unsigned i = 0;
  for (unsigned j = 0; j < size(); j++)
    if (which != j) ix.set ((*this)(j), i++);
  return ix;
}
 
INST(class Index friend TVector<unsigned> idx_remove1 (const Index&, const unsigned);)
inline TVector<unsigned>
idx_remove1 (const Index& idx, const unsigned which)
{ return idx.idx_remove1 (which); }
 
 
inline TVector<unsigned>
Index::idx_remove2 (const unsigned which1, const unsigned which2) const
{
  BCHK (size() < 2, IdxErr, Cannot remove two indices from a Index with just one or zero, size(), *this);
  BCHK (which1 >= size(), IdxErr, Tried to remove non-existing index1, which1, *this);
  BCHK (which2 >= size(), IdxErr, Tried to remove non-existing index2, which2, *this);
  TVector<unsigned> ix (size()-2);
  unsigned i = 0;
  for (unsigned j = 0; j < size(); j++)
    if (which1 != j && which2 != j) ix.set ((*this)(j), i++);
  return ix;
}
 
INST(class Index friend TVector<unsigned> idx_remove2 (const Index&, const unsigned, const unsigned);)
inline TVector<unsigned>
idx_remove2 (const Index& idx, const unsigned which1, const unsigned which2)
{ return idx.idx_remove2 (which1, which2); }
 
inline TVector<unsigned>
Index::idx_set1 (const unsigned which, const unsigned what) const
{
  BCHK (which >= size(), IdxErr, Cannot set index (out of range), which, *this);
  TVector<unsigned> ix (*this);
  ix.set (what, which);
  return ix;
}
 
INST(class Index friend TVector<unsigned> idx_set1 (const Index&, const unsigned, const unsigned);)
inline TVector<unsigned>
idx_set1 (const Index& idx, const unsigned which, const unsigned what)
{ return idx.idx_set1 (which, what); }
 
NAMESPACE_END
 
#endif /* TBCI_INDEX_H */