// TrackVector.h

#ifndef TrackVector_H
#define TrackVector_H

// Class TrackVector is a 5-vector containing the parameters
// describing a track in a magnetic field.

// Class TrackError is the corresponding symmetric 5x5 error matrix.

// Class TrackDerivative is the derivative of one track vector with
// repect to another; i.e. a non-symmetric 5x5 matrix.

// TrackVector tv, TrackError te and TrackDerivative td should 
// support the following operations:
// construct: tv(), te(), td() (should fill with zeros)
// copy: tv2(tv1), te2(te1), td2(td1)
// assignment: tv2 = tv2, te2 = te1, td2 = td1
// indexing: tv(i), te(i,j), td(i,j)
// minimum element: tv.min(), te.min(), td.min()
// maximum element: tv.max(), te.max(), td.max()
// absolute minimum element: tv.amin(), te.amin(), td.amin()
// absolute maximum element: tv.amax(), te.amax(), td.amax()
// addition: tv2 += tv1, tv3 = tv1 + tv2,
//           te2 += te1, te3 = tv1 + te2,
//           td2 += td1, td3 = td1 + td2,
// subtraction: tv2 -= tv1, tv3 = tv1 - tv2,
//              te2 -= te1, te3 = tv1 - te2,
//              td2 -= td1, td3 = td1 - td2,
// inversion: int stat = invert( TrackError& te1 ) (0 for success)
// output stream: cout << tv << te << td
// equality: tv1==tv2, te1==te2, td1==td2
// inequality: tv!=tv2, te1!=te2, td1!=td2
// chisquare difference: chisq_diff(tv,te) = tv_T * te * tv
// (tv is the difference between two vectors and te is the inverse
// of the error matrix.)
// transpose: td.transpose()
// transform: te.xform(td)

#include "TrfVector.h"

namespace trf {

//**********************************************************************

class TrackVector : public TrfVector {

public:

  // constructor
  TrackVector( );

  // construct from base class
  TrackVector(const TrfVector& vec);

  // destructor
  virtual ~TrackVector( );

  // return the underlying vector.
  const TrfVector& get_vector() const { return *this; }

};

//**********************************************************************

class TrackDerivative : public TrfMatrix {

public:

  // constructor
  TrackDerivative();

  // construct from base class
  TrackDerivative(const TrfMatrix& mtx);

  // destructor
  virtual ~TrackDerivative();

  // transpose
  TrackDerivative& transpose() {
    *this = TrfMatrix::transpose();
    return *this;
  }

  // return the underlying matrix
  const TrfMatrix& get_matrix() const { return *this; }

};

//**********************************************************************

class TrackError : public TrfSMatrix {

public:

  // constructor
  TrackError( );

  // construct from base class
  TrackError(const TrfSMatrix& sma);

  // destructor
  virtual ~TrackError( );

  // Xform  E --> D * E * DT
  TrackError& Xform(const TrackDerivative& deriv) {
    *this = TrfSMatrix::xform(deriv);
    return *this;
  }

  // return the underlying matrix
  const TrfSMatrix& get_matrix() const { return *this; }

};

//**********************************************************************

}  // end namespace trf

// tv + tv
trf::TrackVector
operator+(const trf::TrackVector& lhs, const trf::TrackVector& rhs);

// tv - tv
trf::TrackVector
operator-(const trf::TrackVector& lhs, const trf::TrackVector& rhs);

// te + te
trf::TrackError
operator+(const trf::TrackError& lhs, const trf::TrackError& rhs);

// te - te
trf::TrackError
operator-(const trf::TrackError& lhs, const trf::TrackError& rhs);

// td + td
trf::TrackDerivative
operator+(const trf::TrackDerivative& lhs, const trf::TrackDerivative& rhs);

// td - td
trf::TrackDerivative
operator-(const trf::TrackDerivative& lhs, const trf::TrackDerivative& rhs);

// equality
bool operator==(const trf::TrackVector& lhs, const trf::TrackVector& rhs);

// equality
bool operator==(const trf::TrackError& lhs, const trf::TrackError& rhs);

// equality
bool
operator==(const trf::TrackDerivative& lhs, const trf::TrackDerivative& rhs);

// inequality
bool operator!=(const trf::TrackVector& lhs, const trf::TrackVector& rhs);

// inequality
bool operator!=(const trf::TrackError& lhs, const trf::TrackError& rhs);

// inequality
bool
operator!=(const trf::TrackDerivative& lhs, const trf::TrackDerivative& rhs);

// equality with tolerance
bool is_equal(const trf::TrackVector& lhs, const trf::TrackVector& rhs);

// equality with tolerance
bool is_equal(const trf::TrackError& lhs, const trf::TrackError& rhs);

// equality with tolerance
bool
is_equal(const trf::TrackDerivative& lhs, const trf::TrackDerivative& rhs);

#endif