// TrackVector.cpp

#include "TrackVector.h"

using trf::TrfVector;
using trf::TrfMatrix;
using trf::TrfSMatrix;
using trf::TrackVector;
using trf::TrackError;
using trf::TrackDerivative;

//**********************************************************************
// TrackVector
//**********************************************************************

// constructor

TrackVector::TrackVector( )
: TrfVector(5) {
  fill(0.0);
}

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

// constructor from base

TrackVector::TrackVector(const TrfVector& vec) : TrfVector(vec) { }

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

// destructor

TrackVector::~TrackVector( ) { }

//**********************************************************************
// TrackError
//**********************************************************************

// constructor

TrackError::TrackError( ) : TrfSMatrix(5) {
  fill(0.0);
}

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

// constructor from base

TrackError::TrackError(const TrfSMatrix& sma) : TrfSMatrix(sma) { }

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

// destructor

TrackError::~TrackError( ) { }

//**********************************************************************
// TrackDerivative
//**********************************************************************

// constructor

TrackDerivative::TrackDerivative( ) : TrfMatrix(5,5) {
  fill(0.0);
}

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

// constructor from base

TrackDerivative::TrackDerivative(const TrfMatrix& mtx)
: TrfMatrix(mtx) { }

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

// destructor

TrackDerivative::~TrackDerivative( ) { }

//**********************************************************************
// Friends.
//**********************************************************************

// vector addition
TrackVector
  operator+(const TrackVector& rhs1, const TrackVector& rhs2) {
  TrackVector lhs(rhs1);
  lhs += rhs2;
  return lhs;
}

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

// vector subtraction
TrackVector
  operator-(const TrackVector& rhs1, const TrackVector& rhs2) {
  TrackVector lhs(rhs1);
  lhs -= rhs2;
  return lhs;
}

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

// vector equality
bool operator==(const TrackVector& lhs, const TrackVector& rhs) {
  const TrfVector& rlhs = lhs;
  const TrfVector& rrhs = rhs;
  return rlhs == rrhs;
}

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

// vector inequality
bool operator!=(const TrackVector& lhs, const TrackVector& rhs) {
  return ! (lhs == rhs);
}

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

// vector equality with tolerance
bool is_equal(const TrackVector& lhs, const TrackVector& rhs) {
  const TrfVector& rlhs = lhs;
  const TrfVector& rrhs = rhs;
  return is_equal(rlhs,rrhs);
}

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

// error addition
TrackError operator+(const TrackError& rhs1, const TrackError& rhs2) {
  TrackError lhs(rhs1);
  lhs += rhs2;
  return lhs;
}

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

// error subtraction
TrackError operator-(const TrackError& rhs1, const TrackError& rhs2) {
  TrackError lhs(rhs1);
  lhs -= rhs2;
  return lhs;
}

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

// error equality
bool operator==(const TrackError& lhs, const TrackError& rhs) {
  const TrfSMatrix& rlhs = lhs;
  const TrfSMatrix& rrhs = rhs;
  return rlhs == rrhs;
}

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

// error inequality
bool operator!=(const TrackError& lhs, const TrackError& rhs) {
  return ! (lhs == rhs);
}

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

// error equality with tolerance
bool is_equal(const TrackError& lhs, const TrackError& rhs) {
  const TrfSMatrix& rlhs = lhs;
  const TrfSMatrix& rrhs = rhs;
  return is_equal(rlhs,rrhs);
}

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

// derivative addition
TrackDerivative
  operator+(const TrackDerivative& rhs1, const TrackDerivative& rhs2) {
  TrackDerivative lhs(rhs1);
  lhs += rhs2;
  return lhs;
}

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

// derivative subtraction
TrackDerivative
  operator-(const TrackDerivative& rhs1, const TrackDerivative& rhs2) {
  TrackDerivative lhs(rhs1);
  lhs -= rhs2;
  return lhs;
}

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

// derivative equality
bool operator==(const TrackDerivative& lhs, const TrackDerivative& rhs) {
  const TrfMatrix& rlhs = lhs;
  const TrfMatrix& rrhs = rhs;
  return rlhs == rrhs;
}

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

// derivative inequality
bool operator!=(const TrackDerivative& lhs, const TrackDerivative& rhs) {
  return ! (lhs == rhs);
}

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

// derivative equality with tolerance
bool is_equal(const TrackDerivative& lhs, const TrackDerivative& rhs) {
  const TrfMatrix& rlhs = lhs;
  const TrfMatrix& rrhs = rhs;
  return is_equal(rlhs,rrhs);
}

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