
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*                                                                           */
/*                                                                           */
/*                   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 "mvconfig.h"
#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;
}
