WebSVN – gelsvn – Diff – /branches/cpp11-devel/src/CGLA/ArithVec.h


/* ----------------------------------------------------------------------- *
 * This file is part of GEL, http://www.imm.dtu.dk/GEL
 * Copyright (C) the authors and DTU Informatics
 * For license and list of authors, see ../../doc/intro.pdf
 * @brief Abstract vector class
 * ----------------------------------------------------------------------- */
 
/** @file ArithVec.h
 * @brief Abstract vector class
 */
 
#ifndef __CGLA_ARITHVEC_H__
#define __CGLA_ARITHVEC_H__
 
#include <array>
#include <algorithm>
#include <iostream>
#include "CGLA.h"
 
#include <numeric>
 
namespace CGLA
{
    
    /** \brief Template representing generic arithmetic vectors.
     
     The three parameters to the template are
     
     T - the scalar type (i.e. float, int, double etc.)
     
     V - the name of the vector type. This template is always (and
     only) used as ancestor of concrete types, and the name of the
     class _inheriting_ _from_ this class is used as the V argument.
     
     N - The final argument is the dimension N. For instance, N=3 for a
     3D vector.
     
     This class template contains all functions that are assumed to be
     the same for any arithmetic vector - regardless of dimension or
     the type of scalars used for coordinates.
     
     The template contains no virtual functions which is important
     since they add overhead.
     */
    
    template <class T, class V, unsigned int N>
    class ArithVec
    {
        
    protected:
        
        /// The actual contents of the vector.
        std::array<T,N> data;
        
    protected:
        
        //----------------------------------------------------------------------
        // Constructors
        //----------------------------------------------------------------------
        
        /// Construct uninitialized vector
        ArithVec() {}
        
        /// Construct a vector where all coordinates are identical
        explicit ArithVec(T _a)
        {
            std::fill_n(data, N, _a);
        }
        
        /// Construct a 2D vector
        ArithVec(T _a, T _b): data({_a,_b}) {assert(N==2);}
        
        /// Construct a 2D vector
        ArithVec(T _a, T _b, T _c): data({_a,_b,_c}) {assert(N==3);}
        
        /// Construct a 2D vector
        ArithVec(T _a, T _b, T _c, T _d): data({_a,_b,_c,_d}) {assert(N==4);}
        
    public:
        
        /// For convenience we define a more meaningful name for the scalar type
        typedef T ScalarType;
        
        /// A more meaningful name for vector type
        typedef V VectorType;
        
        /// Return dimension of vector
        static unsigned int get_dim() {return N;}
        
        /// Set all coordinates of a 2D vector.
        void set(T _a, T _b)
        {
            assert(N==2);
            data = {_a,_b};
        }
        
        /// Set all coordinates of a 3D vector.
        void set(T _a, T _b, T _c)
        {
            assert(N==3);
            data = {_a,_b,_c};
        }
        
        /// Set all coordinates of a 4D vector.
        void set(T _a, T _b, T _c, T _d)
        {
            assert(N==4);
            data = {_a,_b,_c,_d};
        }
        
        /// Const index operator
        const T& operator [] ( unsigned int i ) const
        {
            assert(i<N);
            return data[i];
        }
        
        /// Non-const index operator
        T& operator [] ( unsigned int i )
        {
            assert(i<N);
            return data[i];
        }
        
        /// Const index operator
        const T& operator () ( unsigned int i ) const
        {
            assert(i<N);
            return data[i];
        }
        
        /// Non-const index operator
        T& operator () ( unsigned int i )
        {
            assert(i<N);
            return data[i];
        }
        
        typedef typename std::array<T,N>::iterator iterator;
        typedef typename std::array<T,N>::const_iterator const_iterator;
        
        
        /** Get a pointer to first element in data array.
         This function may be useful when interfacing with some other API
         such as OpenGL (TM) */
        iterator begin() {return data.begin();}
        iterator end() {return data.end();}
        T* get() {return data.data();}
        
        /** Get a const pointer to first element in data array.
         This function may be useful when interfacing with some other API
         such as OpenGL (TM). */
        const_iterator begin() const {return data.begin();}
        const_iterator end() const {return data.end();}
        const T* get() const {return data.data();}
        
        //----------------------------------------------------------------------
        // Comparison operators
        //----------------------------------------------------------------------
        
        /// Equality operator
        bool operator==(const V& v) const
        {
            return std::equal(begin(),end(), v.begin());
        }
        
        /// Equality wrt scalar. True if all coords are equal to scalar
        bool operator==(T k) const
        {
            return std::count(begin(),end(), k)==N;
        }
        
        /// Inequality operator
        bool operator!=(const V& v) const
        {
            return !(*this==v);
        }
        
        /// Inequality wrt scalar. True if any coord not equal to scalar
        bool operator!=(T k) const
        {
            return !(*this==k);
        }
        
        
        //----------------------------------------------------------------------
        // Comparison functions ... of geometric significance
        //----------------------------------------------------------------------
        
        /** Compare all coordinates against other vector. ( < )
         Similar to testing whether we are on one side of three planes. */
        bool  all_l  (const V& v) const
        {
            return std::inner_product(begin(), end(), v.begin(), true,
                                      std::logical_and<bool>(), std::less<T>());
        }
        
        /** Compare all coordinates against other vector. ( <= )
         Similar to testing whether we are on one side of three planes. */
        bool  all_le (const V& v) const
        {
            return std::inner_product(begin(), end(), v.begin(), true,
                                      std::logical_and<bool>(), std::less_equal<T>());
        }
        
        /** Compare all coordinates against other vector. ( > )
         Similar to testing whether we are on one side of three planes. */
        bool  all_g  (const V& v) const
        {
            return std::inner_product(begin(), end(), v.begin(), true,
                                      std::logical_and<bool>(), std::greater<T>());
        }
        
        /** Compare all coordinates against other vector. ( >= )
         Similar to testing whether we are on one side of three planes. */
        bool  all_ge (const V& v) const
        {
            return std::inner_product(begin(), end(), v.begin(), true,
                                      std::logical_and<bool>(), std::greater_equal<T>());
        }
        
        
        //----------------------------------------------------------------------
        // Assignment operators
        //----------------------------------------------------------------------
        
        /// Assignment multiplication with scalar.
        const V& operator *=(T k)
        {
            for(auto& x : data) {x*=k;}
            return static_cast<const V&>(*this);
        }
        
        /// Assignment division with scalar.
        const V& operator /=(T k)
        {
            for(auto& x : data) {x/=k;}
            return static_cast<const V&>(*this);
        }
        
        /// Assignment addition with scalar. Adds scalar to each coordinate.
        const V& operator +=(T k)
        {
            for(auto& x : data) {x+=k;}
            return  static_cast<const V&>(*this);
        }
        
        /// Assignment subtraction with scalar. Subtracts scalar from each coord.
        const V& operator -=(T k)
        {
            for(auto& x : data) {x-=k;}
            return  static_cast<const V&>(*this);
        }
        
        /** Assignment multiplication with vector.
         Multiply each coord independently. */
        const V& operator *=(const V& v)
        {
            std::transform(begin(), end(), v.begin(), begin(), std::multiplies<T>());
            return  static_cast<const V&>(*this);
        }
        
        /// Assigment division with vector. Each coord divided independently.
        const V& operator /=(const V& v)
        {
            std::transform(begin(), end(),  v.begin(), begin(), std::divides<T>());
            return  static_cast<const V&>(*this);
        }
        
        /// Assignmment addition with vector.
        const V& operator +=(const V& v)
        {
            std::transform(begin(), end(), v.begin(), begin(), std::plus<T>());
            return  static_cast<const V&>(*this);
        }
		
        /// Assignment subtraction with vector.
        const V& operator -=(const V& v)
        {
            std::transform(begin(), end(), v.begin(), begin(), std::minus<T>());
            return  static_cast<const V&>(*this);
        }
        
        
        //----------------------------------------------------------------------
        // Unary operators on vectors
        //----------------------------------------------------------------------
        
        /// Negate vector.
        const V operator - () const
        {
            V v_new;
            std::transform(begin(), end(), v_new.begin(), std::negate<T>());
            return v_new;
        }
        
        //----------------------------------------------------------------------
        // Binary operators on vectors
        //----------------------------------------------------------------------
        
        /** Multiply vector with vector. Each coord multiplied independently
         Do not confuse this operation with dot product. */
        const V operator * (const V& v1) const
        {
            V v_new;
            std::transform(begin(), end(), v1.begin(), v_new.begin(), std::multiplies<T>());
            return v_new;
        }
        
        /// Add two vectors
        const V operator + (const V& v1) const
        {
            V v_new;
            std::transform(begin(), end(), v1.begin(), v_new.begin(), std::plus<T>());
            return v_new;
        }
        
        /// Subtract two vectors.
        const V operator - (const V& v1) const
        {
            V v_new;
            std::transform(begin(), end(), v1.begin(), v_new.begin(), std::minus<T>());
            return v_new;
        }
        
        /// Divide two vectors. Each coord separately
        const V operator / (const V& v1) const
        {
            V v_new;
            std::transform(begin(), end(), v1.begin(), v_new.begin(), std::divides<T>());
            return v_new;
        }
        
        //----------------------------------------------------------------------
        // Binary operators on vector and scalar
        //----------------------------------------------------------------------
        
        /// Multiply scalar onto vector.
        const V operator * (T k) const
        {
            V v_new;
            std::transform(begin(), end(), v_new.begin(), [k](T x){return x*k;});
            return v_new;
        }
        
        
        /// Divide vector by scalar.
        const V operator / (T k) const
        {
            V v_new;
            std::transform(begin(), end(), v_new.begin(), [k](T x){return x/k;});
            return v_new;
        }
        
        
        /// Return the smallest coordinate of the vector
        const T min_coord() const
        {
            return *std::min_element(begin(), end());
        }
        
        /// Return the largest coordinate of the vector
        const T max_coord() const
        {
            return *std::max_element(begin(), end());
        }
        
    };
    
    template <class T, class V, unsigned int N>
    inline std::ostream& operator<<(std::ostream&os, const ArithVec<T,V,N>& v)
    {
        os << "[ ";
        for(const T& x : v) os << x << " ";
        os << "]";
        return os;
        }
        
        /// Get from operator for ArithVec descendants.
        template <class T,class V, unsigned int N>
        inline std::istream& operator>>(std::istream&is, ArithVec<T,V,N>& v)
        {
            is >> std::ws;
            if (is.peek() == '[')
                is.ignore();
            is >> std::ws;
            for (int c=0; c<N; ++c)
            {
                is >> v(c) >> std::ws;
            }
            if (is.peek() == ']')
                is.ignore();
            return is;
        }
        
        
        /** Dot product for two vectors. The `*' operator is
         reserved for coordinatewise	multiplication of vectors. */
        template <class T,class V, unsigned int N>
        inline T dot(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
        {
            return std::inner_product(v0.begin(), v0.end(), v1.begin(), T(0));
        }
        
        /** Compute the sqr length by taking dot product of vector with itself. */
        template <class T,class V, unsigned int N>
        inline T sqr_length(const ArithVec<T,V,N>& v)
        {
            return dot(v,v);
        }
        
        /** Multiply double onto vector. This operator handles the case
         where the vector is on the righ side of the `*'.
         
         \note It seems to be optimal to put the binary operators inside the
         ArithVec class template, but the operator functions whose
         left operand is _not_ a vector cannot be inside, hence they
         are here.
         We need three operators for scalar * vector although they are
         identical, because, if we use a separate template argument for
         the left operand, it will match any type. If we use just T as
         type for the left operand hoping that other built-in types will
         be automatically converted, we will be disappointed. It seems that
         a float * ArithVec<float,Vec3f,3> function is not found if the
         left operand is really a double.
         */
        
        template<class T, class V, unsigned int N>
        inline const V operator * (double k, const ArithVec<T,V,N>& v)
        {
            return v * k;
        }
        
        /** Multiply float onto vector. See the note in the documentation
         regarding multiplication of a double onto a vector. */
        template<class T, class V, unsigned int N>
        inline const V operator * (float k, const ArithVec<T,V,N>& v)
        {
            return v * k;
        }
        
        /** Multiply unsigned int onto vector. See the note in the documentation
         regarding multiplication of a double onto a vector. */
        template<class T, class V, unsigned int N>
        inline const V operator * (int k, const ArithVec<T,V,N>& v)
        {
            return v * k;
        }
        
        /** Returns the vector containing for each coordinate the smallest
         value from two vectors. */
        template <class T,class V, unsigned int N>
        inline V v_min(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
        {
            V v;
            std::transform(v0.begin(), v0.end(), v1.begin(), v.begin(),
                           [](T a, T b){return std::min(a,b);});
            return v;
        }
        
        /** Returns the vector containing for each coordinate the largest
         value from two vectors. */
        template <class T,class V, unsigned int N>
        inline V v_max(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
        {
            V v;
            std::transform(v0.begin(), v0.end(), v1.begin(), v.begin(),
                           [](T a, T b){return std::max(a,b);});
            return v;
        }
        
        
}
        
#endif
 

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/src/CGLA/ArithVec.h – Rev 632 → 633

Rev 632		Rev 633
1	`/* ----------------------------------------------------------------------- *`	1	`/* ----------------------------------------------------------------------- *`
2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`	2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`
3	`* Copyright (C) the authors and DTU Informatics`	3	`* Copyright (C) the authors and DTU Informatics`
4	`* For license and list of authors, see ../../doc/intro.pdf`	4	`* For license and list of authors, see ../../doc/intro.pdf`
5	`* @brief Abstract vector class`	5	`* @brief Abstract vector class`
6	`* ----------------------------------------------------------------------- */`	6	`* ----------------------------------------------------------------------- */`
7		7
8	`/** @file ArithVec.h`	8	`/** @file ArithVec.h`
9	`* @brief Abstract vector class`	9	`* @brief Abstract vector class`
10	`*/`	10	`*/`
11		11
12	`#ifndef __CGLA_ARITHVEC_H__`	12	`#ifndef __CGLA_ARITHVEC_H__`
13	`#define __CGLA_ARITHVEC_H__`	13	`#define __CGLA_ARITHVEC_H__`
14		14
15	`#include <array>`	15	`#include <array>`
16	`#include <algorithm>`	16	`#include <algorithm>`
17	`#include <iostream>`	17	`#include <iostream>`
18	`#include "CGLA.h"`	18	`#include "CGLA.h"`
19		19
20	`#include <numeric>`	20	`#include <numeric>`
21		21
22	`namespace CGLA`	22	`namespace CGLA`
23	`{`	23	`{`
24		24
25	`/** \brief Template representing generic arithmetic vectors.`	25	`/** \brief Template representing generic arithmetic vectors.`
26		26
27	`The three parameters to the template are`	27	`The three parameters to the template are`
28		28
29	`T - the scalar type (i.e. float, int, double etc.)`	29	`T - the scalar type (i.e. float, int, double etc.)`
30		30
31	`V - the name of the vector type. This template is always (and`	31	`V - the name of the vector type. This template is always (and`
32	`only) used as ancestor of concrete types, and the name of the`	32	`only) used as ancestor of concrete types, and the name of the`
33	`class _inheriting_ _from_ this class is used as the V argument.`	33	`class _inheriting_ _from_ this class is used as the V argument.`
34		34
35	`N - The final argument is the dimension N. For instance, N=3 for a`	35	`N - The final argument is the dimension N. For instance, N=3 for a`
36	`3D vector.`	36	`3D vector.`
37		37
38	`This class template contains all functions that are assumed to be`	38	`This class template contains all functions that are assumed to be`
39	`the same for any arithmetic vector - regardless of dimension or`	39	`the same for any arithmetic vector - regardless of dimension or`
40	`the type of scalars used for coordinates.`	40	`the type of scalars used for coordinates.`