#ifndef VECTOR6_H
#define VECTOR6_H

// Vector6 -- length 6 vector
// $Id: Vector6.h,v 1.11 2002/10/22 17:07:58 sachs Exp $
// David Sachs - Fermilab - April 2002
//
// Vector6 - array of 6 doubles

#include <iostream>
#include <iomanip>

namespace CovMatrices
{
  class CovMatrix6;
  class BiVector6;

  class Vector6
  {
    friend class CovMatrix6;
    friend class BiVector6;
  
    private:
    double E[6];
  
    public:
  
    // Constructors
  
    // Default Constructor - Constructs zeroed Vector6
    inline Vector6();
  
    // Construct Vector6 from 6 elements
    inline Vector6( double e0, double e1, double e2, double e3, double e4, double e5);
  
    // Construct Vector6 from array of 6 doubles - KNOWN TO BE DANGEROUS
    explicit inline Vector6(const double* p);
  
    // Assign Vector6 from  array of 6 doubles - KNOWN TO BE DANGEROUS
    inline Vector6& operator=(const double* p);
  
    // Dump Vector6 to array of 6 doubles - KNOWN TO BE DANGEROUS
    inline void dump(double* p) const;
  
    // Access elements by subscripting - No check for subscript range
    inline double& operator [] (int i);
    inline const double& operator [] (int i) const;
  
    // Vector Arithmetic
    inline Vector6& operator+=(const Vector6& v);
  
    inline Vector6& operator-=(const Vector6& v);
  
    inline Vector6& operator*=(const double d);
  
    inline Vector6 operator+(const Vector6& v) const;
  
    inline Vector6 operator-(const Vector6& v) const;
  
    friend inline Vector6 operator*(double d, const Vector6& v); // Scalar * Vector
    friend inline Vector6 operator*(const Vector6& v, double d);
  
    inline double operator* (const Vector6 &v) const; // Dot product
  
    // CovMatrix6 non-member friend functions
    friend Vector6 operator* ( const CovMatrix6& A, const Vector6& v );  // Matrix * Vector
    friend Vector6 operator* ( const Vector6& v, const CovMatrix6& A );
    friend BiVector6 operator* ( const CovMatrix6& m, const BiVector6& b );
    friend BiVector6 operator* ( const BiVector6& b, const CovMatrix6& m );
  
    // Print contents of a Vector6;
    friend std::ostream& operator<< (std::ostream&, const Vector6&);
    inline void put(std::ostream& o) const;
  
  };
  
  // Implementation  of Vector6 inline functions
  inline Vector6::Vector6()
  {
    E[0] = 0.;	// Cannot assume FP 0. == binary zeroes
    E[1] = 0.;
    E[2] = 0.;
    E[3] = 0.;
    E[4] = 0.;
    E[5] = 0.;
  }
  
  inline Vector6::Vector6( double e0, double e1, double e2, double e3, double e4, double e5)
  {
    E[0] = e0;
    E[1] = e1;
    E[2] = e2;
    E[3] = e3;
    E[4] = e4;
    E[5] = e5;
  }
  
  inline Vector6::Vector6(const double* p)
  {
    memcpy( &E, p, sizeof(E));
  }
  
  inline Vector6& Vector6::operator= (const double* p)
  {
    memcpy( &E, p, sizeof(E));
    return *this;
  }
  
  inline void Vector6::dump(double* p) const
  {
    memcpy(p, &E, sizeof(E));
  }
  
  inline double& Vector6::operator [] (int i) { return E[i]; }
  
  inline const double& Vector6::operator [] (int i) const { return E[i]; }
  
  inline Vector6& Vector6::operator+=(const Vector6& v)
  {
    E[0]+=v.E[0];
    E[1]+=v.E[1];
    E[2]+=v.E[2];
    E[3]+=v.E[3];
    E[4]+=v.E[4];
    E[5]+=v.E[5];
    return *this;
  }
  
  inline Vector6& Vector6::operator-=(const Vector6& v)
  {
    E[0]-=v.E[0];
    E[1]-=v.E[1];
    E[2]-=v.E[2];
    E[3]-=v.E[3];
    E[4]-=v.E[4];
    E[5]-=v.E[5];
    return *this;
  }
  
  inline Vector6& Vector6::operator*=(const double d)
  {
    E[0] *= d;
    E[1] *= d;
    E[2] *= d;
    E[3] *= d;
    E[4] *= d;
    E[5] *= d;
    return *this;
  }
  
  inline Vector6 Vector6::operator+(const Vector6& v) const
  {
    return Vector6 (	E[0] + v.E[0],
   	 		E[1] + v.E[1],
  		 	E[2] + v.E[2],
  			E[3] + v.E[3],
  			E[4] + v.E[4],
  	 		E[5] + v.E[5]);
  }
  
  inline Vector6 Vector6::operator-(const Vector6& v) const
  {
    return Vector6 (	E[0] - v.E[0],
  			E[1] - v.E[1],
  			E[2] - v.E[2],
  			E[3] - v.E[3],
  			E[4] - v.E[4],
  			E[5] - v.E[5]);
  }
  
  inline Vector6 operator*(double d, const Vector6& v)
  {
    return Vector6 (d*v.E[0], d*v.E[1], d*v.E[2], d*v.E[3], d*v.E[4], d*v.E[5]);
  }
  
  inline Vector6 operator*(const Vector6& v, double d)
  {
    return Vector6 (d*v.E[0], d*v.E[1], d*v.E[2], d*v.E[3], d*v.E[4], d*v.E[5]);
  }
  
  inline double Vector6::operator* (const Vector6 &v) const // Dot product
  {
    return(	 E[0] * v.E[0] +
   		 E[1] * v.E[1] +
  		 E[2] * v.E[2] +
  		 E[3] * v.E[3] +
  		 E[4] * v.E[4] +
  		 E[5] * v.E[5]);
  }
  
  inline std::ostream& operator<<( std::ostream& o, const Vector6& v)
  {
    v.put(o);
    return o;
  }
  
  inline void Vector6::put( std::ostream& o) const
  {
    // Define precision and width to use for now
    enum { W = 18, P = 10 };  // should have W = P + 8
  
    std::ios::fmtflags oldf = o.setf(std::ios::scientific|std::ios::showpos);
    int oldp = o.precision(P);
  
    // Print leading brace
    o << "{";
  
    // print each elment with proper width
    o << std::setw(W) << E[0];
    o << std::setw(W) << E[1];
    o << std::setw(W) << E[2];
    o << std::setw(W) << E[3];
    o << std::setw(W) << E[4];
    o << std::setw(W) << E[5];
  
    // Print trailing brace
    o << " }";
  
    // restore previous file parameters
    o.flags(oldf);
    o.precision(oldp);
  }
}
#endif