text: 
  /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  /*                                                                           */
  /*                                                                           */
  /*                   MV++ Numerical Matrix/Vector C++ Library                */
  /*                             MV++ Version 1.5                              */
  /*                                                                           */
  /*                                  R. Pozo                                  */
  /*               National Institute of Standards and Technology              */
  /*                                                                           */
  /*                                  NOTICE                                   */
  /*                                                                           */
  /* Permission to use, copy, modify, and distribute this software and         */
  /* its documentation for any purpose and without fee is hereby granted       */
  /* provided that this permission notice appear in all copies and             */
  /* supporting documentation.                                                 */
  /*                                                                           */
  /* Neither the Institution (National Institute of Standards and Technology)  */
  /* nor the author makes any representations about the suitability of this    */
  /* software for any purpose.  This software is provided ``as is''without     */
  /* expressed or implied warranty.                                            */
  /*                                                                           */
  /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  
  //
  //          Basic vector class (COMPLEX precision)
  //
  
  
  #include <iostream>                                 
  #include "mvv.h"
  
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX()  : p_(0), dim_(0) , ref_(0){}
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX( int n) : p_(new COMPLEX[n]), dim_(n), 
              ref_(0)
  {
      if (p_ == NULL)
      {
          std::cerr << "Error: NULL pointer in MV_Vector_COMPLEX(int) constructor " << "\n";
          std::cerr << "       Most likely out of memory... " << "\n";
          exit(1);
      }
  }
  
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX( int n, const COMPLEX& v) : 
          p_(new COMPLEX[n]), dim_(n), ref_(0)
  {
      if (p_ == NULL)
      {
          std::cerr << "Error: NULL pointer in MV_Vector_COMPLEX(int) constructor " << "\n";
          std::cerr << "       Most likely out of memory... " << "\n";
          exit(1);
      }
      for (int i=0; i<n; i++)
          p_[i] = v;
  }
  
  // operators and member functions
  //
  
  
  MV_Vector_COMPLEX& MV_Vector_COMPLEX::operator=(const COMPLEX & m) 
  {
  #ifdef TRACE_VEC
      cout << "> MV_Vector_COMPLEX::operator=(const COMPLEX & m)  " << "\n";
  #endif
  
      // unroll loops to depth of length 4
  
      int N = size();
  
      int Nminus4 = N-4;
      int i;
  
      for (i=0; i<Nminus4; )
      {
          p_[i++] = m;
          p_[i++] = m;
          p_[i++] = m;
          p_[i++] = m;
      }
  
      for (; i<N; p_[i++] = m);   // finish off last piece...
  
  #ifdef TRACE_VEC
      cout << "< MV_Vector_COMPLEX::operator=(const COMPLEX & m)  " << "\n";
  #endif
      return *this;
  }
  
  
  MV_Vector_COMPLEX& MV_Vector_COMPLEX::newsize( int n)
  {
  #ifdef TRACE_VEC
      cout << "> MV_Vector_COMPLEX::newsize( int n) " << "\n";
  #endif
      if (ref_ )                  // is this structure just a pointer?
      {
          {
              std::cerr << "MV_Vector::newsize can't operator on references.\n";
              exit(1);
          }
      }
      else
      if (dim_ != n )                     // only delete and new if
      {                                   // the size of memory is really
          if (p_) delete [] p_;           // changing, otherwise just
          p_ = new COMPLEX[n];              // copy in place.
          if (p_ == NULL)
          {
              std::cerr << "Error : NULL pointer in operator= " << "\n";
              exit(1);
          }
          dim_ = n;
      }
  
  #ifdef TRACE_VEC
      cout << "< MV_Vector_COMPLEX::newsize( int n) " << "\n";
  #endif
  
      return *this;
  }
  
  
      
  
  
  MV_Vector_COMPLEX& MV_Vector_COMPLEX::operator=(const MV_Vector_COMPLEX & m) 
  {
  
      int N = m.dim_;
      int i;
  
      if (ref_ )                  // is this structure just a pointer?
      {
          if (dim_ != m.dim_)     // check conformance,
          {
              std::cerr << "MV_VectorRef::operator=  non-conformant assignment.\n";
              exit(1);
          }
  
          // handle overlapping matrix references
          if ((m.p_ + m.dim_) >= p_)
          {
              // overlap case, copy backwards to avoid overwriting results
              for (i= N-1; i>=0; i--)
                  p_[i] = m.p_[i];
          }
          else
          {
              for (i=0; i<N; i++)
                  p_[i] = m.p_[i];
          }
                  
      }
      else
      {
          newsize(N);
  
          // no need to test for overlap, since this region is new
          for (i =0; i< N; i++)       // careful not to use bcopy()
              p_[i] = m.p_[i];        // here, but COMPLEX::operator= COMPLEX.
      }
      return *this;   
  }
  
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX(const MV_Vector_COMPLEX & m) : p_(new COMPLEX[m.dim_]), 
      dim_(m.dim_) , ref_(0)
  {
      if (p_ == NULL)
      {
          std::cerr << "Error:  Null pointer in MV_Vector_COMPLEX(const MV_Vector&); " << "\n";
          exit(1);
      }
  
      int N = m.dim_;
  
      for (int i=0; i<N; i++)
          p_[i] = m.p_[i];
  }
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX(COMPLEX* d,  int n) : p_(new COMPLEX[n]), 
        dim_(n) , ref_(0)
  {
      if (p_ == NULL)
      {
          std::cerr << "Error: Null pointer in MV_Vector_COMPLEX(COMPLEX*, int) " << "\n";
          exit(1);
      }
      for (int i=0; i<n; i++)
          p_[i] = d[i];
  
  }
  
  
  
  MV_Vector_COMPLEX::MV_Vector_COMPLEX(const COMPLEX* d,  int n) : p_(new COMPLEX[n]), 
        dim_(n) , ref_(0)
  {
      if (p_ == NULL)
      {
          std::cerr << "Error: Null pointer in MV_Vector_COMPLEX(COMPLEX*, int) " << "\n";
          exit(1);
      }
      for (int i=0; i<n; i++)
          p_[i] = d[i];
  
  }
  
  
  MV_Vector_COMPLEX MV_Vector_COMPLEX::operator()(void)
  {
      return MV_Vector_COMPLEX(p_, dim_, MV_Vector_::ref);
  }
  
  
  const MV_Vector_COMPLEX MV_Vector_COMPLEX::operator()(void) const
  {
      return MV_Vector_COMPLEX(p_, dim_, MV_Vector_::ref);
  }
  
  
  MV_Vector_COMPLEX MV_Vector_COMPLEX::operator()(const MV_VecIndex &I) 
  {
      // default parameters
      if (I.all())
          return MV_Vector_COMPLEX(p_, dim_, MV_Vector_::ref);
      else
      {
      // check that index is not out of bounds
      //
          if ( I.end() >= dim_)
          {
              std::cerr << "MV_VecIndex: (" << I.start() << ":" << I.end() << 
                  ") too big for matrix (0:" << dim_ - 1 << ") " << "\n";
              exit(1);
          }
          return MV_Vector_COMPLEX(p_+ I.start(), I.end() - I.start() + 1,
              MV_Vector_::ref);
      }
  }
  
  
  const MV_Vector_COMPLEX MV_Vector_COMPLEX::operator()(const MV_VecIndex &I) const
  {
      // check that index is not out of bounds
      //
      if (I.all())
          return MV_Vector_COMPLEX(p_, dim_, MV_Vector_::ref);
      else
      {
        if ( I.end() >= dim_)
        {
          std::cerr << "MV_VecIndex: (" << I.start() << ":" << I.end() << 
                  ") too big for matrix (0:" << dim_ - 1 << ") " << "\n";
          exit(1);
        }
        return MV_Vector_COMPLEX(p_+ I.start(), I.end() - I.start() + 1,
              MV_Vector_::ref);
      }
  }
  
  
  MV_Vector_COMPLEX::~MV_Vector_COMPLEX()
  {
          if (p_ && !ref_ ) delete [] p_;
  }
  
  
  std::ostream&   operator<<(std::ostream& s, const MV_Vector_COMPLEX& V)
  {
      int N = V.size();
  
      for (int i=0; i< N; i++)
          s << V(i) << "\n";
      
      return s;
  }
  
  
  