vector.h

Go to the documentation of this file.

#pragma once

#ifndef VECTOR_H
#define VECTOR_H


/**
    \file
    \brief Contains Vector class.

    In addition to the Vector class itself, this file also defines a large
    number of operators and functions acting on vectors.
*/




#include "helpers.h"

#include <iostream>
#include <algorithm>
#include <cmath>
#include <type_traits>

#include <assert.h>




/*==============================================================================
    RESULT_TYPE macro
==============================================================================*/

/// \brief Finds the type of \p ee, and removes reference, const and volatile.
#define RESULT_TYPE( ee ) typename std::decay< decltype( ee ) >::type




/*==============================================================================
    Vector class
==============================================================================*/


/// \brief Generates code for the assignment operator \p op (=,+=,*=,etc) taking a Vector argument.
#define VECTOR_VECTOR_ASSIGNMENT_OPERATOR( op ) \
    template< typename t_OtherType > \
    inline Vector const& operator op ( Vector< t_OtherType, t_Size > const& other ) { \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            data[ ii ] op other.data[ ii ]; \
        return *this; \
    }

/// \brief Generates code for the assignment operator \p op (=,+=,*=,etc) taking a scalar argument.
#define VECTOR_SCALAR_ASSIGNMENT_OPERATOR( op ) \
    template< typename t_OtherType > \
    inline Vector const& operator op ( t_OtherType const& other ) { \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            data[ ii ] op other; \
        return *this; \
    }


/**
    \brief Vector class.

    \param t_Type  Type of elements.
    \param t_Size  Number of elements.

    This class is an awful lot like \c std::array, with the main difference
    being that, for Vectors, a large number of operators and functions are also
    defined. Like \c std::array, it supports aggregate initialization, meaning
    that you can initialize a Vector as:

        Vector< float, 3 > vector = { { 1, 0, -1 } };

    Every C++ operator is overloaded, including the bitwise operators, *except*
    for the pre/post increment/decrement operators \c ++ and \c \-\-.
    Comparisons are lexicographic, like \c std::array, which enables instances
    of this class to be used in standard containers (although one could make a
    case for vector comparisons returning vector results, with the comparison
    being performed element-by-element). Also, many standard math functions
    have Vector overloads, including everything relevant in the cmath header,
    \c std::min and \c std::max, and the \c Square and \c Cube functions found
    in helpers.h. Adding new function overloads is pretty simple: see
    VECTOR_FUNCTION() and the related macros.

    The operators and functions which work on this class try to follow the same
    automatic casting rules as the underlying operations. For example, if you
    add a <tt>Vector< float, 3 ></tt> to a <tt>Vector< int, 3 ></tt>, the
    result will be a <tt>Vector< float, 3 ></tt>, with the result type being
    determined from that of *scalar* addition of a float and an int (using \c
    decltype).
*/
template< typename t_Type, size_t t_Size >
struct Vector {

    typedef t_Type value_type;


    inline t_Type& operator[]( size_t const index );
    inline t_Type const& operator[]( size_t const index ) const;


    inline Vector const& operator=( Vector const& other );


    // **TODO: pre/post increment/decrement?

    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( = )

    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( +=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( -=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( *=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( /=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( %=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( &=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( |=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( ^=  )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( <<= )
    VECTOR_VECTOR_ASSIGNMENT_OPERATOR( >>= )

    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( +=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( -=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( *=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( /=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( %=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( &=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( |=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( ^=  )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( <<= )
    VECTOR_SCALAR_ASSIGNMENT_OPERATOR( >>= )


    inline t_Type Sum() const;        ///< Returns the sum of all elements.
    inline t_Type Product() const;    ///< Returns the product of all elements.
    inline t_Type Maximum() const;    ///< Returns the maximum element.
    inline t_Type Minimum() const;    ///< Returns the minimum element.

    /// Returns the sum of the squares of the elements.
    inline t_Type NormSquared() const;

    /// Returns the 2-norm of the vector (the square root of the sum of the squares of the elements).
    inline RESULT_TYPE( std::sqrt( *static_cast< t_Type const* >( NULL ) ) ) Norm() const;    // as of gcc 4.6.3, we can't put decltype( NormSquared() ) in a trailing return type (auto ... -> result) because it doesn't know about "this"


    t_Type data[ t_Size ];
};


#undef VECTOR_VECTOR_ASSIGNMENT_OPERATOR
#undef VECTOR_SCALAR_ASSIGNMENT_OPERATOR




/*==============================================================================
    Vector methods
==============================================================================*/


template< typename t_Type, size_t t_Size >
t_Type& Vector< t_Type, t_Size >::operator[]( size_t const index ) {

    assert( index < t_Size );
    return data[ index ];
}


template< typename t_Type, size_t t_Size >
t_Type const& Vector< t_Type, t_Size >::operator[]( size_t const index ) const {

    assert( index < t_Size );
    return data[ index ];
}


template< typename t_Type, size_t t_Size >
Vector< t_Type, t_Size > const& Vector< t_Type, t_Size >::operator=( Vector const& other ) {

    for ( size_t ii = 0; ii < t_Size; ++ii )
        data[ ii ] = other.data[ ii ];
    return *this;
}


template< typename t_Type, size_t t_Size >
t_Type Vector< t_Type, t_Size >::Sum() const {

    t_Type result = 0;
    for ( size_t ii = 0; ii < t_Size; ++ii )
        result += data[ ii ];
    return result;
}


template< typename t_Type, size_t t_Size >
t_Type Vector< t_Type, t_Size >::Product() const {

    t_Type result = 1;
    for ( size_t ii = 0; ii < t_Size; ++ii )
        result *= data[ ii ];
    return result;
}


template< typename t_Type, size_t t_Size >
t_Type Vector< t_Type, t_Size >::Maximum() const {

    static_assert( t_Size > 0, "cannot find Maximum of an empty vector!" );
    t_Type result = data[ 0 ];
    for ( size_t ii = 1; ii < t_Size; ++ii )
        if ( data[ ii ] > result )
            result = data[ ii ];
    return result;
}


template< typename t_Type, size_t t_Size >
t_Type Vector< t_Type, t_Size >::Minimum() const {

    static_assert( t_Size > 0, "cannot find Minimum of an empty vector!" );
    t_Type result = data[ 0 ];
    for ( size_t ii = 1; ii < t_Size; ++ii )
        if ( data[ ii ] < result )
            result = data[ ii ];
    return result;
}


template< typename t_Type, size_t t_Size >
t_Type Vector< t_Type, t_Size >::NormSquared() const {

    t_Type result = 0;
    for ( size_t ii = 0; ii < t_Size; ++ii )
        result += Square( data[ ii ] );
    return result;
}


template< typename t_Type, size_t t_Size >
RESULT_TYPE( std::sqrt( *static_cast< t_Type const* >( NULL ) ) ) Vector< t_Type, t_Size >::Norm() const {

    return std::sqrt( NormSquared() );
}




/*==============================================================================
    Vector functions
==============================================================================*/


/// Compares its arguments lexicographically, returning -1 if \p left is smaller than \p right, 1 if it is larger, and 0 if they are equal.
template< typename t_LeftType, typename t_RightType, size_t t_Size >
inline int Compare( Vector< t_LeftType, t_Size > const& left, Vector< t_RightType, t_Size > const& right ) {    // like std::array, comparisons are lexicographic

    int result = 0;
    for ( size_t ii = 0; ii < t_Size; ++ii ) {

        if ( left.data[ ii ] < right.data[ ii ] ) {

            result = -1;
            break;
        }
        else if ( left.data[ ii ] > right[ ii ] ) {

            result = 1;
            break;
        }
    }
    return result;
}


/// Returns the dot product of its arguments.
template< typename t_LeftType, typename t_RightType, size_t t_Size >
inline auto Dot( Vector< t_LeftType, t_Size > const& left, Vector< t_RightType, t_Size > const& right ) -> RESULT_TYPE( left.data[ 0 ] * right.data[ 0 ] ) {

    RESULT_TYPE( left.data[ 0 ] * right.data[ 0 ] ) result = 0;
    for ( size_t ii = 0; ii < t_Size; ++ii )
        result += left.data[ ii ] * right.data[ ii ];
    return result;
}


/// Returns the cross product of its (3D) arguments.
template< typename t_LeftType, typename t_RightType >
inline auto Cross( Vector< t_LeftType, 3 > const& left, Vector< t_RightType, 3 > const& right ) -> Vector< RESULT_TYPE( left.data[ 0 ] * right.data[ 0 ] ), 3 > {

    Vector< RESULT_TYPE( left.data[ 0 ] * right.data[ 0 ] ), 3 > result = { {
        left.data[ 1 ] * right.data[ 2 ] - left.data[ 2 ] * right.data[ 1 ],
        left.data[ 2 ] * right.data[ 0 ] - left.data[ 0 ] * right.data[ 2 ],
        left.data[ 0 ] * right.data[ 1 ] - left.data[ 1 ] * right.data[ 0 ]
    } };
    return result;
}


/// Outputs the vector contents (as text) to the given stream.
template< typename t_Type, size_t t_Size >
inline std::ostream& operator<<( std::ostream& out, Vector< t_Type, t_Size > const& vector ) {

    out << '[';
    if ( t_Size > 0 ) {

        out << vector.data[ 0 ];
        for ( size_t ii = 1; ii < t_Size; ++ii )
            out << ',' << vector.data[ ii ];
    }
    out << ']';

    return out;
}




/*==============================================================================
    Vector macro'ed operators
==============================================================================*/


/// \brief Generates code for the unary operator \p op (-,~).
#define VECTOR_OPERATOR( op ) \
    template< typename t_Type, size_t t_Size > \
    inline Vector< t_Type, t_Size > operator op ( Vector< t_Type, t_Size > const& vector ) { \
        Vector< t_Type, t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = ( op vector.data[ ii ] ); \
        return result; \
    }

/// \brief Generates code for the binary operator \p op (+,*,<<,etc) taking two Vector arguments.
#define VECTOR_VECTOR_OPERATOR( op ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto operator op ( Vector< t_LeftType, t_Size > const& left, Vector< t_RightType, t_Size > const& right ) -> Vector< RESULT_TYPE( left.data[ 0 ] op right.data[ 0 ] ), t_Size > { \
        Vector< RESULT_TYPE( left.data[ 0 ] op right.data[ 0 ] ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = ( left.data[ ii ] op right.data[ ii ] ); \
        return result; \
    }

/// \brief Generates code for the binary operator \p op (+,*,<<,etc) taking a Vector argument on the left, and scalar on the right.
#define VECTOR_SCALAR_OPERATOR( op ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto operator op ( Vector< t_LeftType, t_Size > const& left, t_RightType const& right ) -> Vector< RESULT_TYPE( left.data[ 0 ] op right ), t_Size > { \
        Vector< RESULT_TYPE( left.data[ 0 ] op right ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = ( left.data[ ii ] op right ); \
        return result; \
    }

/// \brief Generates code for the binary operator \p op (+,*,<<,etc) taking a scalar argument on the left, and Vector on the right.
#define SCALAR_VECTOR_OPERATOR( op ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto operator op ( t_LeftType const& left, Vector< t_RightType, t_Size > const& right ) -> Vector< RESULT_TYPE( left op right.data[ 0 ] ), t_Size > { \
        Vector< RESULT_TYPE( left op right.data[ 0 ] ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = ( left op right.data[ ii ] ); \
        return result; \
    }

/// \brief Generates code for the binary comparison operator \p op (==,<,etc) taking two Vector arguments. The resulting code simply calls the Compare() function, which orders lexicographically.
#define VECTOR_COMPARISON_OPERATOR( op ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline bool operator op ( Vector< t_LeftType, t_Size > const& left, Vector< t_RightType, t_Size > const& right ) { \
        return( Compare( left, right ) op 0 ); \
    }


VECTOR_OPERATOR( - )
VECTOR_OPERATOR( ~ )

VECTOR_VECTOR_OPERATOR( +  )
VECTOR_VECTOR_OPERATOR( -  )
VECTOR_VECTOR_OPERATOR( *  )
VECTOR_VECTOR_OPERATOR( /  )
VECTOR_VECTOR_OPERATOR( %  )
VECTOR_VECTOR_OPERATOR( &  )
VECTOR_VECTOR_OPERATOR( |  )
VECTOR_VECTOR_OPERATOR( ^  )
VECTOR_VECTOR_OPERATOR( << )
VECTOR_VECTOR_OPERATOR( >> )

VECTOR_SCALAR_OPERATOR( +  )
VECTOR_SCALAR_OPERATOR( -  )
VECTOR_SCALAR_OPERATOR( *  )
VECTOR_SCALAR_OPERATOR( /  )
VECTOR_SCALAR_OPERATOR( %  )
VECTOR_SCALAR_OPERATOR( &  )
VECTOR_SCALAR_OPERATOR( |  )
VECTOR_SCALAR_OPERATOR( ^  )
VECTOR_SCALAR_OPERATOR( << )
VECTOR_SCALAR_OPERATOR( >> )

SCALAR_VECTOR_OPERATOR( +  )
SCALAR_VECTOR_OPERATOR( -  )
SCALAR_VECTOR_OPERATOR( *  )
SCALAR_VECTOR_OPERATOR( /  )
SCALAR_VECTOR_OPERATOR( %  )
SCALAR_VECTOR_OPERATOR( &  )
SCALAR_VECTOR_OPERATOR( |  )
SCALAR_VECTOR_OPERATOR( ^  )
SCALAR_VECTOR_OPERATOR( << )
SCALAR_VECTOR_OPERATOR( >> )

VECTOR_COMPARISON_OPERATOR( == )
VECTOR_COMPARISON_OPERATOR( != )
VECTOR_COMPARISON_OPERATOR( <  )
VECTOR_COMPARISON_OPERATOR( >= )
VECTOR_COMPARISON_OPERATOR( >  )
VECTOR_COMPARISON_OPERATOR( <= )


#undef VECTOR_VECTOR_OPERATOR
#undef VECTOR_SCALAR_OPERATOR
#undef SCALAR_VECTOR_OPERATOR
#undef VECTOR_COMPARISON_OPERATOR




/*==============================================================================
    Vector macro'ed functions
==============================================================================*/


/// \brief Generates code for the unary function \p fun taking a Vector argument. The resulting code simply calls the scalar version of \p fun for each element.
#define VECTOR_FUNCTION( fun ) \
    template< typename t_Type, size_t t_Size > \
    inline auto fun( Vector< t_Type, t_Size > const& vector ) -> Vector< RESULT_TYPE( fun( vector.data[ 0 ] ) ), t_Size > { \
        Vector< RESULT_TYPE( fun( vector.data[ 0 ] ) ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = fun( vector.data[ ii ] ); \
        return result; \
    }

/// \brief Generates code for the binary function \p fun taking two Vector arguments. The resulting code simply calls the scalar version of \p fun for each element.
#define VECTOR_VECTOR_FUNCTION( fun ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto fun( Vector< t_LeftType, t_Size > const& left, Vector< t_RightType, t_Size > const& right ) -> Vector< RESULT_TYPE( fun( left.data[ 0 ], right.data[ 0 ] ) ), t_Size > { \
        Vector< RESULT_TYPE( fun( left.data[ 0 ], right.data[ 0 ] ) ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = fun( left.data[ ii ], right.data[ ii ] ); \
        return result; \
    }

/// \brief Generates code for the binary function \p fun taking a Vector argument on the left, and scalar on the right. The resulting code simply calls the scalar version of \p fun for each element.
#define VECTOR_SCALAR_FUNCTION( fun ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto fun( Vector< t_LeftType, t_Size > const& left, t_RightType const& right ) -> Vector< RESULT_TYPE( fun( left.data[ 0 ], right ) ), t_Size > { \
        Vector< RESULT_TYPE( fun( left.data[ 0 ], right ) ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = fun( left.data[ ii ], right ); \
        return result; \
    }

/// \brief Generates code for the binary function \p fun taking a scalar argument on the left, and Vector on the right. The resulting code simply calls the scalar version of \p fun for each element.
#define SCALAR_VECTOR_FUNCTION( fun ) \
    template< typename t_LeftType, typename t_RightType, size_t t_Size > \
    inline auto fun( t_LeftType const& left, Vector< t_RightType, t_Size > const& right ) -> Vector< RESULT_TYPE( fun( left, right.data[ 0 ] ) ), t_Size > { \
        Vector< RESULT_TYPE( fun( left, right.data[ 0 ] ) ), t_Size > result; \
        for ( size_t ii = 0; ii < t_Size; ++ii ) \
            result.data[ ii ] = fun( left, right.data[ ii ] ); \
        return result; \
    }


VECTOR_FUNCTION( Square )
VECTOR_FUNCTION( Cube   )

namespace std {

VECTOR_FUNCTION( abs   )
VECTOR_FUNCTION( acos  )
VECTOR_FUNCTION( asin  )
VECTOR_FUNCTION( atan  )
VECTOR_FUNCTION( ceil  )
VECTOR_FUNCTION( cos   )
VECTOR_FUNCTION( cosh  )
VECTOR_FUNCTION( exp   )
VECTOR_FUNCTION( fabs  )
VECTOR_FUNCTION( floor )
VECTOR_FUNCTION( log   )
VECTOR_FUNCTION( log10 )
VECTOR_FUNCTION( sin   )
VECTOR_FUNCTION( sinh  )
VECTOR_FUNCTION( sqrt  )
VECTOR_FUNCTION( tan   )
VECTOR_FUNCTION( tanh  )

VECTOR_VECTOR_FUNCTION( atan2 )
VECTOR_VECTOR_FUNCTION( fmod  )
VECTOR_VECTOR_FUNCTION( ldexp )
VECTOR_VECTOR_FUNCTION( max   )
VECTOR_VECTOR_FUNCTION( min   )
VECTOR_VECTOR_FUNCTION( pow   )

VECTOR_SCALAR_FUNCTION( atan2 )
VECTOR_SCALAR_FUNCTION( fmod  )
VECTOR_SCALAR_FUNCTION( ldexp )
VECTOR_SCALAR_FUNCTION( max   )
VECTOR_SCALAR_FUNCTION( min   )
VECTOR_SCALAR_FUNCTION( pow   )

SCALAR_VECTOR_FUNCTION( atan2 )
SCALAR_VECTOR_FUNCTION( fmod  )
SCALAR_VECTOR_FUNCTION( ldexp )
SCALAR_VECTOR_FUNCTION( max   )
SCALAR_VECTOR_FUNCTION( min   )
SCALAR_VECTOR_FUNCTION( pow   )

}    // namespace std


#undef VECTOR_FUNCTION
#undef VECTOR_VECTOR_FUNCTION
#undef VECTOR_SCALAR_FUNCTION
#undef SCALAR_VECTOR_FUNCTION




/*==============================================================================
    RESULT_TYPE macro
==============================================================================*/

#undef RESULT_TYPE




#endif    // VECTOR_H