bvector.h

Go to the documentation of this file.

//-------------------------------------------------------------
// Attila Michael Bilgic, 1/97
// last update  10/04/97 AMB
//              12/14/97 KG
// $Id: bvector.h,v 1.36.2.51 2010/08/16 13:58:36 garloff Exp $
//-------------------------------------------------------------


#ifndef TBCI_BVECTOR_H
#define TBCI_BVECTOR_H  

#include "basics.h"
#include "vector_sig.h"

// Avoid -fguiding-decls
#if !defined(NO_GD) && !defined(AUTO_DECL)
# include "bvector_gd.h"
#endif

NAMESPACE_TBCI

#ifdef EXCEPT
// except.h is included by basics.h

class VecErr : public NumErr
{
    public:
        VecErr() 
        : NumErr("Error in Vector library")  {}
        VecErr(const char* t, const long i = 0) 
        : NumErr(t, i) {}
        VecErr(const VecErr& ve)
        : NumErr(ve) {}
        virtual ~VecErr() throw() {}
};
#endif

#ifdef PRAGMA_I
# pragma interface "bvector.h"
#endif

template <typename T> class   TMatrix;
template <typename T> class    Matrix;
template <typename T> class F_TMatrix;
template <typename T> class  F_Matrix;
template <typename T> class   TVector;
template <typename T> class  TSVector;
template <typename T> class    Vector;

//template <typename T> class CTensor; 
//template <typename T> class Tensor; 


template <typename T>
class BVector : public BVector_Sig<T>
{
 protected:
  typedef T value_type;
  typedef T element_type;
  typedef T aligned_value_type TALIGN(MIN_ALIGN2);
  T* vec;
  unsigned long dim;
  bool keep;  // whether to destroy or not

 public:
  friend class   TMatrix<T>;
  friend class F_TMatrix<T>;
  friend class  F_Matrix<T>;
#ifdef HAVE_BCXX_INHER_BREAKS_FRIEND_BUG
  friend class   TVector<T>;
  friend class    Vector<T>;
  //friend class CTensor<T>;
#endif

  // constructor, destructor
  explicit BVector (const unsigned long = 0);
  BVector (const T&, const unsigned long);
  BVector (const BVector<T>&) HOT;              
#ifndef NO_POD
  // variable argument number 
  BVector(const vararg va, ...);
#endif
  inline void destroy ();
  ~BVector ();

  // basics
  BVector<T>& init_0 ()
        { if (UNLIKELY(dim)) TBCICLEAR (vec, T, dim); return *this; }
  BVector<T>& fill (const T&) HOT;
  // 2.97 was clever enough to detect this bug!
  //BVector<T>& fill (const Matrix<T>& m);
  friend NOINST /*inline*/ BVector<T>& FRIEND_TBCI2__ bvfillm FGD (BVector<T>&, const Matrix<T>& m);
        
  BVector<T>& resize (const BVector<T>&);
  BVector<T>& resize (const unsigned long);
  BVector<T>& resize (const T&, const unsigned long);
  BVector<T>& cheapdownsize (const unsigned long);
  // BVector<T>& free () { return this->resize (0); }
  BVector<T>& clear ()  { return this->fill((T)0); };
  BVector<T>& append (const T&);
  BVector<T>& push_back (const T& value) { append(value); return *this; }
  BVector<T>& append (const BVector<T>&);
  BVector<T>& remove (const unsigned long);
  BVector<T>& revert ();
  BVector<T>& bubble_sort ();

  BVector<T>& swap (BVector<T>& v);

  // Member access
  T& operator () (const unsigned long) HOT;
  typename tbci_traits<T>::const_refval_type
     operator () (const unsigned long) const HOT;
  const T& getcref (const unsigned long) const;

  // valarray compatibility
  T& operator [] (const unsigned long i) { return this->operator() (i); }
  typename tbci_traits<T>::const_refval_type
     operator [] (const unsigned long i) const { return this->operator() (i); }

  inline unsigned long size () const HOT { return dim; }

  // Needed for emul et al.
  T* const & vecptr () const  { return vec; }

  typedef T* iterator;
  iterator begin () { return vec; }
  iterator   end () { return vec+dim; }
  typedef const T* const_iterator;
  const_iterator begin () const { return vec; }
  const_iterator   end () const { return vec+dim; }

  // You'd better know, what you are doing!
  BVector<T>& setptr (T* pointer)  { vec = pointer; return *this; }
  BVector<T>& setsize (const unsigned long size)  { dim = size; return *this; }
  // access to data pointer for e.g. fortran libs
  T* const & get_fortran_vector () const  { return vecptr (); }
  void set_fortran_vector (T* pointer)  { setptr (pointer); }
  
  // assignment operators
  BVector<T>& operator = (const T& a)  { return fill (a); }
  BVector<T>& operator = (const BVector<T>&) HOT;
  BVector<T>& alias (const BVector<T>& bv)
     { destroy (); vec = bv.vec; dim = bv.dim; keep = true; return *this; }
  BVector<T>& copy (const BVector<T>& bv);
  
  // basic comparison  
  bool operator == (const BVector<T>&) const HOT;
  bool operator != (const BVector<T>& bv) const  { return !(*this == bv); }
  bool operator <= (const BVector<T>& bv) const;
  bool operator >= (const BVector<T>& bv) const;
  bool operator <  (const BVector<T>& bv) const  { return !((*this) >= bv); }
  bool operator >  (const BVector<T>& bv) const  { return !((*this) <= bv); }
   
  // val in vector 
  bool contains (const T&, unsigned long * = 0) const;
   
  // io-streams
  friend STD__ ostream& operator << FGD (STD__ ostream&, const BVector<T>&);
  friend STD__ istream& operator >> FGD (STD__ istream&, BVector<T>&);

  // for Index class
  //for friend BVector<T> concat FGD (const BVector<T>&, const BVector<T>&);
  BVector<T> concat (const BVector<T>&) const;

  /*virtual*/ static const char* vec_info()  { return "BVector"; }
  
#ifndef HAVE_PROMOTION_BUG
# ifndef HAVE_GCC295_TMPLFRNDCLS_BUG
  // Promotion (only explicit)
  template <typename U> friend class BVector;
  template <typename U> explicit BVector (const BVector<U>& bv) 
    : dim (bv.dim), keep (bv.keep)
    { 
      if (LIKELY(dim)) vec = NEW (T, dim); else vec = 0;
      if (UNLIKELY(!vec)) dim = 0;
      for (unsigned long i = 0; i < dim; i++) vec[i] = bv.vec[i];
    }
# else
  template <typename U> explicit BVector (const BVector<U>& bv) 
    : keep (false)
    { 
      dim = bv.size(); //keep = bv.keep;
      if (LIKELY(dim)) vec = NEW (T, dim); else vec = 0;
      if (UNLIKELY(!vec)) dim = 0;
      for (unsigned long i = 0; i < dim; i++) vec[i] = bv(i);
    }
# endif
#endif  

#ifdef HAVE_BCXX_INHER_BREAKS_FRIEND_BUG
    /* Speed mat-vec-mul */
   friend NOINST void FRIEND_TBCI2__ do_mat_vec_mult FGD (const unsigned start, const unsigned end, \
                        TVector<T> * res, const Matrix<T> * mat, const Vector<T> * vec);
   friend NOINST void FRIEND_TBCI2__ do_mat_vec_transmult FGD (const unsigned start, const unsigned end, \
                        TVector<T> * res, const Matrix<T> * mat, const Vector<T> * vec);
#endif
 
};


//definitions


template <typename T>
INLINE BVector<T>::BVector (const unsigned long c)
  : vec ((T*)0), dim (c), keep (false)
{
        if (UNLIKELY(c)) {
                vec = NEW (T, c);
                if (UNLIKELY(!vec))
                        dim = 0;
        }
}

#ifndef NO_POD
template <typename T>
INLINE BVector<T>::BVector (const vararg va, ...)
  : vec ((T*)0), dim (va), keep (false)
{         
        if (LIKELY(dim))
                vec = NEW (T, dim);
        if (UNLIKELY(!vec))
                dim = 0;
        va_list vl;  
        va_start (vl, va);
        for (unsigned long i=0; i < dim; ++i)
                vec[i] = va_arg (vl, T);
        va_end (vl);
}
#endif

template <typename T>
inline void BVector<T>::destroy ()
{
        if (LIKELY(dim)) 
                TBCIDELETE(T, vec, dim);
}

template <typename T>
INLINE BVector<T>::~BVector ()
{
        if (UNLIKELY(!keep))
                destroy ();
}

template <typename T>
INLINE BVector<T>::BVector (const BVector<T>& v) 
        : vec ((T*)0), dim(0), keep (false)
{
        if (LIKELY(v.dim)) {
                vec = NEW (T, v.dim);
                if (LIKELY(vec)) {
                        dim = v.dim;
                        TBCICOPY(vec, v.vec, T, dim);
                }
        }
}


template <typename T>
INLINE BVector<T>::BVector (const T& value, const unsigned long c)
  : vec ((T*)0), dim (c), keep (false)
{
        if (LIKELY(dim))
                vec = NEW (T, dim);
        if (LIKELY(vec)) 
                TBCIFILL (vec, value, T, dim);
        else 
                dim = 0;
}

template <typename T>
BVector<T>& BVector<T>::cheapdownsize (const unsigned long nd)
{
        BCHK (nd > dim, VecErr, cheapdownsize does not upsize, nd, *this);
        if (UNLIKELY(!nd))
                return this->resize (nd);
        dim = nd;
        return *this;
}

#ifndef LAPACK_INLINE
# define LAPACK_INLINE  
#endif
template <typename T>
LAPACK_INLINE BVector<T>& BVector<T>::resize (const unsigned long c)
{
        if (LIKELY(c == dim))
                return *this;
        if (UNLIKELY(c == 0)) {
                if (LIKELY(dim))
                        TBCIDELETE(T, vec, dim);
                dim = c; 
                return *this; 
        }
#if defined(BOUNDCHECK) && !defined(EXCEPT) && !defined(ABORT_ON_ERR)
        T* tmp = vec;
#endif
        if (LIKELY(dim == 0))
                vec = NEW (T, c);
        else 
                REALLOC(vec,dim,T,c);
        BCHK (!vec, VecErr, Realloc failed in resize, 0, (vec=tmp, *this));
        dim = c; 
        return *this;
}

template <typename T>
BVector<T>& BVector<T>::resize (const T& value, const unsigned long c)
{
        if (UNLIKELY(dim != c)) {
                if (LIKELY(dim))
                        TBCIDELETE(T, vec, dim);
                dim = c;
                if (UNLIKELY(c))
                        vec = NEW (T, c); 
                else 
                        vec = (T*)0;
        }
        if (UNLIKELY(dim && vec))
                return this->fill (value);
        else 
                dim = 0;
        return *this;
}

template <typename T>
BVector<T>& BVector<T>::resize (const BVector<T>& v) 
{
        if (UNLIKELY(dim))
                TBCIDELETE (T, vec, dim);
        dim = v.dim; 
        if (UNLIKELY(v.dim)) {
                vec = NEW (T, v.dim);
                if (LIKELY(vec))
                        TBCICOPY(vec, v.vec, T, dim);
                else 
                        dim = 0;
        } else
                vec = (T*)0;
        return *this;
}

template <typename T>
INLINE BVector<T>& BVector<T>::fill (const T& val)
{
        TBCIFILL(vec, val, T, dim);
        return *this;
}

template <typename T>
INLINE BVector<T>& BVector<T>::revert ()
{
        BVector<T> buf(dim);
        for (register unsigned long t = 0; t < dim; t++) 
                buf[t] = vec[dim-t-1];
        return *this = buf;
}

template <typename T>
BVector<T>& BVector<T>::bubble_sort ()
{
        T temp;
        if(dim > 1) {
                for (register unsigned long i = 0; i < dim-1; i++)
                        for (register unsigned long j = dim-1; i < j; j--) {
                                if ( vec[j] < vec[j-1] ) {
                                        temp = vec[j];
                                        vec[j] = vec[j-1];
                                        vec[j-1] = temp;
                                }
                        }
        }
        return *this;
}

//append one element to vector
template <typename T>
INLINE BVector<T>& BVector<T>::append (const T& val)
{
#if defined(BOUNDCHECK) && !defined(EXCEPT) && !defined(ABORT_ON_ERR)
        T* tmp = vec;
#endif
        REALLOC (vec,dim,T,dim+1);
        BCHK (!vec, VecErr, Realloc failed in append, 0, (vec=tmp, *this));
        vec[dim++] = val;
        return *this;
}

//append one vector to vector
template <typename T>
INLINE BVector<T>& BVector<T>::append (const BVector<T>& v)
{
#if defined(BOUNDCHECK) && !defined(EXCEPT) && !defined(ABORT_ON_ERR)
        T* tmp = vec;
#endif
        REALLOC (vec, dim, T, dim+v.dim);
        BCHK (!vec, VecErr, Realloc failed in append, 0, (vec=tmp, *this));
        TBCICOPY(vec+dim, v.vec, T, v.dim);
        dim += v.dim;
        return *this;
}

//remove one element
template <typename T>
BVector<T>& BVector<T>::remove (const unsigned long i)
{
        BCHK (i>=dim, VecErr, Remove idx out of range, i, *this);
        T* tmp = NEW (T, dim-1);
        BCHK (!tmp, VecErr, Memory allocation failed in remove, (dim-1)*sizeof(T), *this);
        if (UNLIKELY(i))
                TBCICOPY (tmp, vec, T, i);
        dim -= 1;
        if (UNLIKELY(dim-i))
                TBCICOPY (&tmp[i], &vec[i+1], T, (dim-i));
        TBCIDELETE(T, vec, dim+1);
        vec = tmp;
        return *this;
}

template <typename T>
INLINE BVector<T>& BVector<T>::swap (BVector<T>& v)
{
        //BCHK(dim != v.dim, VecErr, swap with different size vecs, v.dim, *this);
        SWAP (v.dim, dim);
        SWAP (v.vec, vec);
        SWAP (v.keep, keep);
        return *this;
}

template <typename T>
  inline typename tbci_traits<T>::const_refval_type
  BVector<T>::operator () (const unsigned long i) const
{ 
        BCHK(i<0 || i>=dim, VecErr, Illegal index, i, vec[0]);
        return vec[i]; 
}

template <typename T>
inline T& BVector<T>::operator () (const unsigned long i)
{
        BCHK(i<0 || i>=dim, VecErr, Illegal index, i, vec[0]);
        return vec[i]; 
}

template <typename T>
inline const T& BVector<T>::getcref (const unsigned long i) const
{ 
        BCHK(i<0 || i>=dim, VecErr, Illegal index, i, vec[0]);
        return vec[i]; 
}


template <typename T>
INLINE BVector<T>& BVector<T>::operator = (const BVector<T>& a)
{
        BCHK(dim != a.dim, VecErr, Assignment from wrong dim vector, a.dim, *this);
        TBCICOPY (vec, a.vec, T, dim);
        return *this;
}

template <typename T>
inline BVector<T>& BVector<T>::copy (const BVector<T>& a)
{
        //BCHK(dim != a.dim, VecErr, Assignment from wrong dim vector, a.dim, *this);
        return this->resize (a);
        //TBCICOPY(vec, a.vec, T, dim);
        //return *this;
}

template <typename T>
/*inline*/ bool BVector<T>::operator == (const BVector<T>& bv) const
{
        if (LIKELY(dim != bv.dim))
                return false;
        if (LIKELY(vec == bv.vec || dim == 0))
                return true;
        if (TBCICOMP (vec, bv.vec, T, dim)) 
                return false;
        else 
                return true;
}


template<typename T>
bool BVector<T>::operator <= (const BVector<T>& bv) const
{ 
        BCHK(dim != bv.dim, VecErr, comparison between wrong dim vectors, bv.dim, false);
        for (unsigned long i=0; i<dim; i++) 
                if (UNLIKELY(vec[i] > bv.vec[i]))
                        return false;
        return true;
}


template<typename T>
bool BVector<T>::operator >= (const BVector<T>& bv) const
{ 
        BCHK(dim != bv.dim, VecErr, comparison between wrong dim vectors, bv.dim, false);
        for (unsigned long i=0; i<dim; i++) 
                if( UNLIKELY(vec[i] < bv.vec[i]) )
                        return false;
        return true;
}


template <typename T>
inline STD__ ostream& operator << (STD__ ostream& os, const BVector<T>& v)
{
#ifdef VEC_COL
        for (unsigned long i = 0; i < v.dim; i++) 
                os << v.vec[i] << "\n";
#else
        for (unsigned long i = 0; i < v.dim; i++) 
                os << v.vec[i] << " ";
#endif
        return os.flush();
}

#ifdef PTR
template <typename T>
STD__ istream& operator >> (STD__ istream& in, BVector<T>& v)
{
        STD__ cerr << "BVector (" << __FILE__ << ":" << __LINE__ 
                   <<") Input on pointers not possible!" << STD__ endl;
        abort();
        return in;
}
#else
template <typename T>
STD__ istream& operator >> (STD__ istream& in, BVector<T>& v)
{
        T r ALIGN(MIN_ALIGN) = 0;
        char s = ',';

/*
        if( !( in >> s ) )
                return in;
        if (s != '(') 
                in.putback(s);
*/
        if( !( in >> r ) )
                return in;
        v.vec[0] = r;
        for (unsigned long i = 1; i < v.dim; i++) {
                in >> s;
                if (s != ',') in.putback(s);
                if( !( in >> r ) )
                        return in;
                v.vec[i] = r;
        } 
        return in;
}
#endif

template <typename T>
inline bool BVector<T>::contains (const T& val, unsigned long *ind) const
{
        for (register unsigned long i = 0; i < dim; ++i)
                if (UNLIKELY(val == vec[i])) {
                        if (ind) 
                                *ind = i;
                        return true;
                }
        return false;
}


template <typename T>
BVector<T> BVector<T>::concat (const BVector<T>& b2) const
{
        BVector<T> c (dim + b2.dim);
        TBCICOPY(c.vec, vec, T, dim);
        TBCICOPY(c.vec+dim, b2.vec, T, dim);
        return c;
}

 
INST(template <typename T> class BVector friend BVector<T> concat (const BVector<T>&, const BVector<T>&);)
template <typename T>
inline BVector<T> concat (const BVector<T>& b1, const BVector<T>& b2)
{ return (b1.concat (b2)); }


NAMESPACE_END

#endif  /* TBCI_BVECTOR_H */

---