vector.hh

Go to the documentation of this file.

//-*- c++ -*-
//
// Copyright (C) 2009 Tom Drummond (twd20@cam.ac.uk),
// Ed Rosten (er258@cam.ac.uk)
//
// This file is part of the TooN Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.



namespace TooN {


template<int Size=Dynamic, typename Precision=DefaultPrecision, typename Base=Internal::VBase>
struct Vector : public Base::template VLayout<Size, Precision> {
protected:
public:
        typedef typename Base::template VLayout<Size, Precision>::PointerType PointerType;
  // sneaky hack: only one of these constructors will work with any given base
  // class but they don't generate errors unless the user tries to use one of them
  // although the error message may be less than helpful - maybe this can be changed?



        inline Vector(){}

        explicit inline Vector(int size_in) : Base::template VLayout<Size, Precision>(size_in) {}

        explicit inline Vector(PointerType data) : Base::template VLayout<Size, Precision> (data) {}


        inline Vector(PointerType data, int size_in) : Base::template VLayout<Size, Precision> (data, size_in) {}

        inline Vector(PointerType data_in, int size_in, int stride_in, Internal::Slicing)
  : Base::template VLayout<Size, Precision>(data_in, size_in, stride_in) {}
        
        using Base::template VLayout<Size, Precision>::size;

        template <class Op>
        inline Vector(const Operator<Op>& op)
                : Base::template VLayout<Size, Precision> (op)
        {
                op.eval(*this);
        }

        // Copy construction is a very special case. Copy construction goes all the
        // way down to the bottom. GenericVBase has no idea how to copy itself.
        // However, the underlying allocator objects do.  In the case of static sized
        // objects, C++ automatically copies the data.  For slice objects, C++ copies
        // all parts (pointer and size), which is correct.  For dynamically sized
        // non-slice objects the copying has to be done by hand.
        
        // inline Vector(const Vector&from);

        template<int Size2, typename Precision2, typename Base2>
        inline Vector(const Vector<Size2,Precision2,Base2>& from):
                Base::template VLayout<Size, Precision>(from.size()) {
                operator=(from);
        }


#ifdef DOXYGEN_INCLUDE_ONLY_FOR_DOCS


        Precision& operator[] (int i);

        const Precision& operator[] (int i) const;


#endif


        inline Vector& operator= (const Vector& from){
                try_destructive_resize(from.size());
                SizeMismatch<Size,Size>::test(size(), from.size());
                const int s=size();
                for(int i=0; i<s; i++){
                        (*this)[i]=from[i];
                }
                return *this;
        }

        template<int Size2, typename Precision2, typename Base2>
        Vector<Size,Precision,Base >& operator= (const Vector<Size2, Precision2, Base2>& from){
                try_destructive_resize(from.size());
                SizeMismatch<Size,Size2>::test(size(), from.size());
                const int s=size();
                for(int i=0; i<s; i++){
                        (*this)[i]=from[i];
                }
                return *this;
        }

        template <class Op>
        inline Vector & operator=(const Operator<Op>& op){
                try_destructive_resize(op);
                op.eval(*this);
                return *this;
        }


        Vector& operator/=(const Precision& rhs) {
                for(int i=0; i<size(); i++)
                        (*this)[i]/=rhs;
                return *this;
        }
        
        Vector& operator*=(const Precision& rhs) {
                for(int i=0; i<size(); i++)
                        (*this)[i]*=rhs;
                return *this;
        }
        
        template<int Size2, class Precision2, class Base2>
        Vector& operator+=(const Vector<Size2, Precision2, Base2>& rhs) {
                SizeMismatch<Size,Size2>::test(size(),rhs.size());
                for(int i=0; i<size(); i++)
                        (*this)[i]+=rhs[i];
                return *this;
        }
        
        template<class Op>
        Vector& operator+=(const Operator<Op>& op)
        {
                op.plusequals(*this);
                return *this;
        }               

        template<class Op>
        Vector& operator-=(const Operator<Op>& op)
        {
                op.minusequals(*this);
                return *this;
        }               

        template<int Size2, class Precision2, class Base2>
        Vector& operator-=(const Vector<Size2, Precision2, Base2>& rhs) {
                SizeMismatch<Size,Size2>::test(size(),rhs.size());
                for(int i=0; i<size(); i++)
                        (*this)[i]-=rhs[i];
                return *this;
        }



        template<int Size2, class Precision2, class Base2>
        bool operator==(const Vector<Size2, Precision2, Base2>& rhs) {
                SizeMismatch<Size,Size2>::test(size(),rhs.size());
                for(int i=0; i<size(); i++)
                  if((*this)[i]!=rhs[i])
                    return 0;
                return 1;
        }

        template<int Size2, class Precision2, class Base2>
        bool operator!=(const Vector<Size2, Precision2, Base2>& rhs) {
                SizeMismatch<Size,Size2>::test(size(),rhs.size());
                for(int i=0; i<size(); i++)
                  if((*this)[i]!=rhs[i])
                    return 1;
                return 0;
        }



        Vector& ref()
        {
                return *this;
        }

#ifdef DOXYGEN_INCLUDE_ONLY_FOR_DOCS

        int size() const;
        
        void resize(int s);

        Precision* get_data_ptr();






        Matrix<1, Size, Precision> as_row();
  
        Matrix<Size, 1, Precision> as_col();
  
        DiagonalMatrix<Size,Precision> as_diagonal();

        template<Start, Length>
        const Vector<Length,Precision>& slice() const;
  
        template<Start, Length>
        Vector<Length,Precision>& slice();
  
        template<Start, Length>
        const Vector<Length,Precision>& slice() const;
  
        template<Start, Length>
        Vector<Length,Precision>& slice();

#endif

};

}

---

libtoon
Author(s): Florian Weisshardt
autogenerated on Fri Jan 11 10:09:37 2013