// vec6.h

#include <iostream>
#include <cstdlib>
using namespace std;

// Class declaration //
class vector {
// friends - friends have access to data members and member functions
   friend void show( vector ); 
   friend void show( char[], vector );
   friend void assign( vector &, double = 0.0, double = 0.0, double = 0.0 );
   friend vector plus( vector, vector );
   friend vector minus( vector, vector );
   friend double dot( vector, vector );

public:
       vector( double = 0.0, double = 0.0, double = 0.0 );  // Constructor
       vector( const vector & );   // Overloaded constructor
       vector( char[] );   // Another overloaded constructor
       
       void show( void );
       double entry( int );
       void assign( double = 0.0, double = 0.0, double = 0.0 );
       void assign( char, double = 0.0 );
       vector plus( vector );
       vector minus( vector );
       vector operator + ( const vector & );
       vector operator - ( const vector & );
       double& operator []( int i );
       
       ~vector();   // Destructor
       
private:
       double data[3];   // Private data
};

// Prototypes for non-member functions

// Friend implementations
void show( vector u ) 
{
   cout << "( " << u.data[0] << ", "
        << u.data[1] << ", " << u.data[2] << " )";
}

void show( char name[], vector u ) 
{
   cout << name << " = ";
   cout << "( " << u.data[0] << ", "
        << u.data[1] << ", " << u.data[2] << " )";
   cout << endl;
}

void assign( vector &x, double a, double b, double c )
{
   x.data[0] = a;
   x.data[1] = b;
   x.data[2] = c;
   return;
}

vector plus( vector u, vector v )
{
    return( vector( u.data[0] + v.data[0], u.data[1] + v.data[1],
                    u.data[2] + v.data[2] ) );
}

vector minus( vector u, vector v )
{
    return( vector( u.data[0] - v.data[0], u.data[1] - v.data[1],
                    u.data[2] - v.data[2] ) );
}

double dot( vector u, vector v )
{
    return( u.data[0]*v.data[0] + u.data[1]*v.data[1] + u.data[2]*v.data[2] );
}

// Member function definitions
vector::vector( double x, double y, double z )
{
   data[0] = x;
   data[1] = y;
   data[2] = z;
}

vector::vector( const vector &x )
{
   data[0] = x.data[0];
   data[1] = x.data[1];
   data[2] = x.data[2];
}

vector::vector( char str[] )
{
   double temp = atof( str );
   data[0] = temp;
   data[1] = temp;
   data[2] = temp;
}

void vector::show( void )
{
   cout << "( " << data[0] << ", "
        << data[1] << ", " << data[2] << " )";
   return;
}

double vector::entry( int i )
{
   if ( ( i < 1 ) || ( i > 3 ) ) {
      cout << "\n** Vector index out of bounds in entry **\n";
      exit( EXIT_FAILURE );
   }
   return( data[i-1] );
}

void vector::assign( double a, double b, double c )
{
   data[0] = a;
   data[1] = b;
   data[2] = c;
   return;
}

void vector::assign( char p, double a )
{
   switch ( p ) {
      case '1':
         data[0] = a;
	  break;
      case '2':
         data[1] = a;
	  break;
      case '3':
         data[2] = a;
	  break;
      default:
         cout << "\n** Vector index out of bounds in assign **\n";
         exit( EXIT_FAILURE );
   }
   return;
}

vector vector::plus( vector u )
{
   return( vector( data[0] + u.data[0], data[1] + u.data[1],
                  data[2] + u.data[2] ) );
}

vector vector::minus( vector u )
{
   return( vector( data[0] - u.data[0], data[1] - u.data[1],
                  data[2] - u.data[2] ) );
}

vector vector::operator + ( const vector &u )
{
   return( vector( data[0] + u.data[0], data[1] + u.data[1],
                  data[2] + u.data[2] ) );
}

vector vector::operator - ( const vector &u )
{
   return( vector( data[0] - u.data[0], data[1] - u.data[1],
                  data[2] - u.data[2] ) );
}

double &vector::operator[]( int i )
{
   if ( ( i < 1 ) || ( i > 3 ) ) {
      cout << "\n** Vector index out of bounds in entry **\n";
      exit( EXIT_FAILURE );
   }
   return( data[i-1] );
}

vector::~vector()
{
}

// Non-member functions