//		vektor.cc
#include <iostream.h>
#include <fstream.h>       // ifstream
#include <math.h>
#include <assert.h>
#include "vektor.hh"

//--------------------------------------------------------------------
Vektor :: Vektor(const unsigned int n)
{
 unsigned int i;

 n_ = n;
 if (n_>0)
  {
    v_ = new double [n_];
  }
 else
  {
    v_ = 0;
  }

 for (i=0; i<n_; i++)	// Daten initialisieren
  {
   v_[i] = 0.0;
  }
}

//--------------------------------------------------------------------

Vektor :: Vektor(const Vektor &orig)
{
 unsigned int i;

 n_ = orig.n_;
 if (n_>0)
  {
    v_ = new double [n_];
  }
 else
  {
    v_ = 0;
  }

 for (i=0; i<n_; i++)	// Daten initialisieren
  {
   v_[i] = orig.v_[i];
  }

}

//--------------------------------------------------------------------

Vektor :: Vektor(const char filename[])
{
 unsigned int i;
     ifstream infile(filename);
//			No check whether file exists ==> more to do
 infile >> n_;
 if (n_>0)
  {
    v_ = new double [n_];
  }
 else
  {
    v_ = 0;
  }

 for (i=0; i<n_; i++)	// Daten initialisieren
  {
   infile >> v_[i];
  }
}
//--------------------------------------------------------------------

Vektor :: ~Vektor()
{
 if ( v_ != 0 )  delete [] v_;
}

//--------------------------------------------------------------------

Vektor & Vektor :: operator = (const Vektor &orig)
{
 unsigned int i;

 if ( &orig != this )
  {
    if ( v_ != 0 )  delete [] v_;

    n_ = orig.n_;
    if (n_>0)
    {
      v_ = new double [n_];
    }
    else
    {
      v_ = 0;
    }

    for (i=0; i<n_; i++)	// Daten initialisieren
    {
      v_[i] = orig.v_[i];
    }
  }

  return *this;
}

//--------------------------------------------------------------------

void Vektor :: daxpy(const double &alpha, const Vektor &x, const Vektor &y)
{
  unsigned int i;

  for (i=0; i<n_; i++)
  {
    v_[i] = alpha * x.v_[i] + y.v_[i];
  }
}

//--------------------------------------------------------------------
//	friend

double InnerProd(const Vektor &a, const Vektor &b)
{
  unsigned int i;
        double sum= 0.0;

  assert( a.n_ == b.n_ );	// compare vector lengths
  for (i=0; i<a.n_; i++)
  {
    sum += a.v_[i] * b.v_[i];
  }

  return sum;
}

//--------------------------------------------------------------------

double Vektor :: Norm() const
{
  unsigned int i;
        double sum= 0.0;

  for (i=0; i<n_; i++)
  {
    sum += v_[i] * v_[i];
  }

  return sqrt(sum);
}


//--------------------------------------------------------------------

ostream & operator<<(ostream  & s, const Vektor & orig)
{
 unsigned int i;
 for (i=0; i<orig.n_; i++)
  {
    s << "  " << orig.v_[i];
  }
 return s;
}

//--------------------------------------------------------------------

Vektor Vektor :: operator * (const double &scal) const
{
 unsigned int i;
 Vektor tmp(*this);

 for (i=0; i<tmp.n_; i++)
  {
    tmp.v_[i] *= scal;
  }

 return tmp;
}

//--------------------------------------------------------------------

Vektor Vektor :: operator + (const Vektor &b) const
{
 unsigned int i;
 Vektor tmp(*this);

 for (i=0; i<tmp.n_; i++)
  {
    tmp.v_[i] += b.v_[i];
  }

 return tmp;
}


//--------------------------------------------------------------------

//--------------------------------------------------------------------



//--------------------------------------------------------------------