Vector4.h

#ifndef VECTOR4_H
#define VECTOR4_H

/*
** ---------------------------------------------------------------
** Includes:
*/
#include <iostream>
#include "defs.h"
#include "Vector3.h"

/*
** ---------------------------------------------------------------
** Definitions:
*/

using namespace std;

class Vector3;


class Vector4 {

public:


        Vector4 (void);
        Vector4 (Real x, Real y, Real z, Real w);
        Vector4(const Vector4 &vector); 
        Vector4(const Vector3 &vector,Real p = 1.0);    
        ~Vector4(void);
        
        Real &operator()(int comp);
        Real operator()(int comp) const;
        Vector4 &operator=(const Vector4 &u);           

private :

        Real x,y,z,w;
        friend class Vector3; // for row() and col()
};

inline Real operator*(const Vector4 &u, const Vector4 &v);

inline istream &operator>>(istream &is, Vector4 &vector);
inline ostream &operator<<(ostream &os, const Vector4 &vector);

inline
Vector4::Vector4(void)
{
        x = y = z = 0.0;
        w = 1.;
}

inline
Vector4::Vector4(const Vector4 &vector)
        : x(vector(0)),
          y(vector(1)),
          z(vector(2)),
          w(vector(3))
{
}

inline
Vector4::Vector4(const Vector3 &vector,Real p = 1.0)
        : x(vector(0)),
          y(vector(1)),
          z(vector(2)),
          w(p)
{
}

inline
Vector4::Vector4(Real x_, Real y_, Real z_, Real w_)
        : x(x_),
          y(y_),
          z(z_),
          w(w_)
{
}

inline Vector4 &
Vector4::operator=(const Vector4 &vector)
{
        x = vector(0);
        y = vector(1);
        z = vector(2);
        w = vector(3);
        return *this;
}

inline Real &
Vector4::operator()(int comp)
{
        return (comp == 0) ? x : (comp == 1) ? y : ( (comp == 2) ? z : w );
}

inline Real
Vector4::operator()(int comp) const
{
        return (comp == 0) ? x : (comp == 1) ? y : ( (comp == 2) ? z : w );
}

inline Real
operator*(const Vector4 &u, const Vector4 &v)
{
        return u(0)*v(0) + u(1)*v(1) + u(2)*v(2) + u(3)*v(3);
}

inline istream &
operator>>(istream &is, Vector4 &vector)
{
        is >> vector(0) >> vector(1) >> vector(2) >> vector(3);
        return is;
}

inline ostream &
operator<<(ostream &os, const Vector4 &vector)
{
        os << vector(0) << " " << vector(1) << " " << vector(2) << " " << vector(3);
        return os;
}
#endif //VECTOR4_H

---