//  Cartesian points and Distances classes
//  --------------------------------------

#ifndef DISTANCE
#define DISTANCE  const Distance
#define DISTANCE  const Distance
#define POINT     const Point
#include "Duration.hpp"
#include "Velocity.hpp"
#include <math.h>


//  These class templates support linear, plane, or spatial distances 
//  and Cartesian points.

//  (1).  Distance (extent) class template
//        --------------------------------

template<int DIM>              // 1, 2, or 3 (Higher dimensionality may work
                               // in some contexts, but has not been validated)
   class Distance {
     double value[DIM];       //  Centimeters



public:

//  Constants
//  ---------

static DISTANCE<DIM> ZERO;
static DISTANCE<DIM> ONE;


//  Constructors & accessors
//  ------------------------
     
     Distance ();
     Distance (DOUBLE x); 
     Distance (DOUBLE x, DOUBLE y);      
     Distance (DOUBLE x, DOUBLE y, DOUBLE z); 

//  The compiler will supply an acceptable copy constructor, destructor, and
//  assignment operator.

     double operator() (INT coord) const             //  General 
     {assert(coord <  DIM); return value[coord];}   //     accessor

     double x() const {return (*this)(0);}           //  Conventional
     double y() const {return (*this)(1);}           //    named
     double z() const {return (*this)(2);}           //      accessors
     
     double magnitude() const 
     {double result = value[0] * value[0];
      for (int ctr = 1; ctr < DIM; ++ctr)
           result += value[ctr] * value[ctr];
      return sqrt(result);
     }  

//  Arithmetic operators

#define Class Distance
#include "additive.hpp"

 Velocity<DIM> operator/ (DURATION t) {return value / t.value;}
   
   
};

template<int DIM>
inline Distance<DIM>& Distance<DIM>::operator+= (DISTANCE<DIM> rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  
             value[ctr] += rs.value[ctr];
         return *this;}

template<int DIM>
inline Distance<DIM>& Distance<DIM>::operator-= (DISTANCE<DIM> rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  
             value[ctr] -= rs.value[ctr];
         return *this;}

template<int DIM>
 inline Distance<DIM>& Distance<DIM>::operator*= (DOUBLE    rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  value[ctr] *= rs; return *this;}

template<int DIM> 
 inline Distance<DIM>& Distance<DIM>::operator/= (DOUBLE    rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  value[ctr] /= rs; return *this;}

template<int DIM>
 inline Distance<DIM>  Distance<DIM>::operator-() const 
        {Distance<DIM> result;
         for (int ctr = 0; ctr < DIM; ++ctr)  
            result.value[ctr] = -value[ctr]; 
         return result;}

//  Logical operator
//  ----------------

template<int DIM>
 inline bool operator==(DISTANCE<DIM> ls, DISTANCE<DIM> rs)
       {for (int ctr = 0; ctr < DIM; ++ctr)
            if (ls(ctr) != rs(ctr)) return false;
        return true;
       }  

template<int DIM>
 ostream& operator<< (ostream& ls, DISTANCE<DIM> rs)
        {ls << '(' << rs(0);
         for (int ctr = 1; ctr < DIM; ++ctr)
             ls << ',' << rs(ctr);
         return ls << ')';
         }

//      (2).  Point class
//      -----------------

template<int DIM> class Point {

     double value[DIM];

public:

//  Constructors & accessors
//  ------------------------

     Point (double x[DIM]) 
       {for (int ctr = 0; ctr < DIM; ++ctr)
           value[ctr] = x[ctr];
       }

     Point () 
       {for (int ctr = 0; ctr < DIM; ++ctr)
           value[ctr] = 0.0;
       }

#define  PointClass Point
#include "PointExt.hpp"    

 

}; 

template<int DIM>
inline Point<DIM>& Point<DIM>::operator+= (DISTANCE<DIM> rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  
             value[ctr] += rs.value[ctr];
         return *this;}

template<int DIM>
inline Point<DIM>& Point<DIM>::operator-= (DISTANCE<DIM> rs)
        {for (int ctr = 0; ctr < DIM; ++ctr)  
             value[ctr] -= rs.value[ctr];
         return *this;}
    
//  Logical operator
//  ----------------

template<int DIM>
 inline bool operator==(POINT<DIM> ls, POINT<DIM> rs)
       {for (int ctr = 0; ctr < DIM; ++ctr)
            if (ls.value[ctr] != rs.value[ctr]) return false;
        return true;
       }  


#undef Class
#endif