vector.hh

//-*- c++ -*-
//
// Copyright (C) 2009 Tom Drummond (twd20@cam.ac.uk),
// Ed Rosten (er258@cam.ac.uk)

//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//2. Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
//
//THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
//LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE.



namespace TooN {


template<int Size=Dynamic, typename Precision=DefaultPrecision, typename Base=Internal::VBase>
struct Vector : public Base::template VLayout<Size, Precision> {
protected:
public:
    
    static const int SizeParameter = Size;

    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(){}

    Vector(Vector&&) = default;
    Vector(const Vector&) = default;

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

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

    template<typename X=Precision>
    inline  Vector(std::initializer_list<Precision> init, typename std::enable_if<sizeof(X)&&(Size <0)>::type* = 0)
    :Base::template VLayout<Size, Precision> (init) 
    {}


    template<typename Precision2, int Size2>
    inline  Vector(const Precision2(&init)[Size2])
    :Base::template VLayout<Size, Precision> (init) 
    {}

    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;
    using Base::template VLayout<Size, Precision>::try_destructive_resize;

    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) const {
        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) const {
        SizeMismatch<Size,Size2>::test(size(),rhs.size());
        for(int i=0; i<size(); i++)
          if((*this)[i]!=rhs[i])
            return 1;
        return 0;
    }
    
    
    template<class Op>
    bool operator!=(const Operator<Op>& op)
    {
        return op.notequal(*this);
    }       
    


    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

};

}