include/vec.hh

Go to the documentation of this file.

#ifndef ZSIG_VEC_HH
#define ZSIG_VEC_HH

//== INCLUDES =================================================================

#include <cmath>
#include <iostream>

//== NAMESPACES ===============================================================

namespace zsig {

//== CLASS DEFINITION =========================================================

template< unsigned D, class T >
class vec {

public:

        typedef vec< D, T > vec_type; 

        vec() { this->clear(); }

        vec( const vec_type& _v ) { *this = _v; }

        vec( const T& _s ) { *this = _s; }

        ~vec() { }

        void clear( void ) { *this = T(); }

        T x( void ) const { if( D>0 ) return this->coord[0]; }

        T y( void ) const { if( D>1 ) return this->coord[1]; }

        T z( void ) const { if( D>2 ) return this->coord[2]; }

        T w( void ) const { if( D>3 ) return this->coord[3]; }

        T sqrl( void ) const { return (*this) ^ (*this); }

        T length( void ) const { return sqrt( this->sqrl() ); }

        T angle( const vec_type& _v ) const { return acos( ( (*this) ^ _v ) / ( this->length() * _v.length() ) ); }

        vec_type normal( void ) const { return *this / length(); }

        vec_type normalize( void ) { return *this = this->normal(); }

        vec_type normalize( const T& _l ) { return *this /= _l; }

        vec_type& operator = ( const vec_type& _v ) {
                for (unsigned i=0; i<D; i++) this->coord[i] = _v[i];
                return *this;
        }

        vec_type& operator = ( const T& _s ) {
                for (unsigned i=0; i<D; i++) this->coord[i] = _s;
                return *this;
        }

        vec_type operator - ( void ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = -this->coord[i];
                return u;
        }

        vec_type operator + ( const T& _s ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] + _s;
                return u;
        }

        vec_type operator + ( const vec_type& _v ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] + _v[i];
                return u;
        }

        vec_type& operator += ( const vec_type& _v ) {
                for (unsigned i=0; i<D; i++) this->coord[i] += _v[i];
                return *this;
        }

        vec_type operator - ( const T& _s ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] - _s;
                return u;
        }

        vec_type operator - ( const vec_type& _v ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] - _v[i];
                return u;
        }

        vec_type& operator -= ( const vec_type& _v ) {
                for (unsigned i=0; i<D; i++) this->coord[i] -= _v[i];
                return *this;
        }

        vec_type operator * ( const T& _s ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] * _s;
                return u;
        }

        vec_type operator * ( const vec_type& _v ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] * _v[i];
                return u;
        }

        vec_type& operator *= ( const T& _s ) {
                for (unsigned i=0; i<D; i++) this->coord[i] *= _s;
                return *this;
        }

        vec_type& operator *= ( const vec_type& _v ) {
                for (unsigned i=0; i<D; i++) this->coord[i] *= _v[i];
                return *this;
        }

        friend vec_type operator * ( const T& _s,
                                     const vec_type& _v ) {
                return _v * _s;
        }

        vec_type operator / ( const T& _s ) const {
                if( _s == (T)0 ) return *this; // lazy error handling
                vec_type u;
                for (unsigned i=0; i<D; i++) u[i] = this->coord[i] / _s;
                return u;
        }

        vec_type operator / ( const vec_type& _v ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++)
                        if( _v[i] != (T)0 ) // lazy error handling
                                u[i] = this->coord[i] / _v[i];
                return u;
        }

        vec_type& operator /= ( const T& _s ) {
                if( _s == (T)0 ) return *this; // lazy error handling
                for (unsigned i=0; i<D; i++) this->coord[i] /= _s;
                return *this;
        }

        vec_type& operator /= ( const vec_type& _v ) {
                for (unsigned i=0; i<D; i++)
                        if( _v[i] != (T)0 ) // lazy error handling
                                this->coord[i] /= _v[i];
                return *this;
        }

        T operator ^ ( const vec_type& _v ) const {
                T s = (T)0;
                for (unsigned i=0; i<D; i++) s += this->coord[i] * _v[i];
                return s;
        }

        vec_type operator % ( const vec_type& _v ) const {
                vec_type u;
                for (unsigned i=0; i<D; i++)
                        for (unsigned j=0; j<D-1; j++)
                                u[i] += ((j%2)==0?+1:-1) * this->coord[(((i+1)%D)+1*j)%D] * _v[(((i+2)%D)+2*j)%D];
                return u;
        }

        friend bool operator == ( const vec_type& _v1, const vec_type& _v2 ) {
                bool b = true;
                for (unsigned i=0; i<D; ++i) b &= (_v1[i] == _v2[i]);
                return b;
        }

        friend bool operator == ( const vec_type& _v1,
                                  T& _s2 ) {
                bool b = true;
                for (unsigned i=0; i<D; ++i) b &= (_v1[i] == _s2);
                return b;
        }

        friend bool operator != ( const vec_type& _v1,
                                  const vec_type& _v2 ) {
                bool b = true;
                for (unsigned i=0; i<D; ++i) b |= (_v1[i] != _v2[i]);
                return b;
        }

        friend bool operator != ( const vec_type& _v1,
                                  T& _s2 ) {
                bool b = true;
                for (unsigned i=0; i<D; ++i) b |= (_v1[i] != _s2);
                return b;
        }

        friend std::ostream& operator << ( std::ostream& out,
                                           const vec_type& _v ) {
                if( D==0 ) return out;
                out << _v.coord[0];
                for (unsigned i=1; i<D; ++i)
                        out << " " << _v.coord[i];
                return out;
        }

        friend std::istream& operator >> ( std::istream& in,
                                           vec_type& _v ) {
                for (unsigned i=0; i<D; ++i)
                        in >> _v.coord[i];
                return in;
        }

        T& operator [] ( const unsigned& _i ) { return this->coord[_i]; }

        const T& operator [] ( const unsigned& _i ) const { return this->coord[_i]; }

        const T* operator &( void ) const { return this->coord; }

protected:

        T coord[D]; 

};

//=== IMPLEMENTATION ==========================================================

template< unsigned D, class T >
void project_vertex( vec< D, T >& _v, const vec< D, T >& _n, const vec< D, T >& _p ) {
        T t = _n ^ ( _v - _p );
        _v -= t * _n;
}

//=============================================================================
} // namespace zsig
//=============================================================================
#endif // ZSIG_VEC_HH
//=============================================================================