vector.hpp

一个gps小工具包

#pragma ident "$Id: Vector.hpp 166 2006-09-30 08:33:51Z architest $"



/**
 * @file Vector.hpp
 * Classes for Vector, both constant and modifiable
 */

#ifndef GPSTK_VECTOR_HPP
#define GPSTK_VECTOR_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#include "VectorBase.hpp"

namespace gpstk
{
 /** @addtogroup VectorGroup */
   //@{

// forward declaration
   template <class T> class VectorSlice;

/**
 * This class pretty much duplicates std::valarray<T> except it's fully
 * STL container compliant.  Remember that operators +=, -=, *= and /=
 * are provided by RefVectorBase.
 * 
 * @sa matvectest.cpp for examples
 */
   template <class T>
   class Vector : public RefVectorBase<T, Vector<T> >
   {
   public:
         /// STL value type
      typedef T value_type;
         /// STL reference type
      typedef T& reference;
         /// STL const reference type
      typedef const T& const_reference;
         /// STL iterator type
      typedef T* iterator;
         /// STL const iterator type
      typedef const T* const_iterator;

         /// Default constructor
      Vector() : v(NULL), s(0) {}
         /// Constructor given an initial size.
      Vector(size_t siz) : s(siz)
            //: v(new T[siz]), s(siz)
         {
            v = new T[siz];
            if(!v) {
               VectorException e("Vector(size_t) failed to allocate");
               GPSTK_THROW(e);
            }
         }
         /**
          * Constructor given an initial size and default value for all elements.
          */
      Vector(size_t siz, const T defaultValue) : s(siz)
            //: v(new T[siz]), s(siz)
         {
            v = new T[siz];
            if(!v) {
               VectorException e("Vector<T>(size_t, const T) failed to allocate");
               GPSTK_THROW(e);
            }
            assignFrom(defaultValue);
         }
         /**
          * Copy constructor from a ConstVectorBase type.
          */
      template <class E>
      Vector(const ConstVectorBase<T, E>& r) : s(r.size())
            //: v(new T[r.size()]), s(r.size())
         {
            v = new T[r.size()];
            if(!v) {
               VectorException e("Vector<T>(ConstVectorBase) failed to allocate");
               GPSTK_THROW(e);
            }
            assignFrom(r);
         }
         /**
          * Copy constructor.
          */
      Vector(const Vector& r) : s(r.s)
            //: v(new T[r.s]), s(r.s)
         {
            v = new T[r.s];
            if(!v) {
               VectorException e("Vector(Vector) failed to allocate");
               GPSTK_THROW(e);
            }
            assignFrom(r);
         }
         /**
          * Valarray constructor
          */
      Vector(const std::valarray<T>& r) : s(r.size())
            //: v(new T[r.size()]), s(r.size())
         {
            v = new T[r.size()];
            if(!v) {
               VectorException e("Vector(valarray) failed to allocate");
               GPSTK_THROW(e);
            }
            assignFrom(r);
         }

         /// subvector constructor
      template <class E>
      Vector(const ConstVectorBase<T, E>& vec,
             size_t top,
             size_t num) : v(size_t(0)),s(0)
         {
               // sanity checks...
            if ( top >= vec.size() || 
                 top + num > vec.size())
            {
               VectorException e("Invalid dimensions or size for Vector(VectorBase)");
               GPSTK_THROW(e);
            }
         
            v = new T[num];
            if(!v) {
               VectorException e("Vector(subvector) failed to allocate");
               GPSTK_THROW(e);
            }
            size_t i;
            for(i = 0; i < num; i++)
               v[i] = vec(top+i);
            s = num;
         }
   
         /// Destructor
      ~Vector()
         { if (v) delete [] v; }

         /// STL iterator begin
      iterator begin() { return v; }
         /// STL const iterator begin
      const_iterator begin() const { return v; }
         /// STL iterator end
      iterator end() { return v + s; }
         /// STL const iterator end
      const_iterator end() const { return v + s; }
         /// STL front
      value_type front() { return v[s-1]; }
         /// STL const front
      const_reference front() const { return v[s-1];}
         /// STL empty
      bool empty() const { return size == 0; }
         /// STL size
      size_t size() const {return s; }
         /// STL max_size
      size_t max_size() const { return std::numeric_limits<size_t>().max(); }

         /// Non-const operator []
      T& operator[] (size_t i) 
         { return v[i]; }
         /// Const operator []
      T operator[] (size_t i) const
         { return v[i]; }
         /// Non-const operator ()
      T& operator() (size_t i) 
         { return v[i]; }
         /// Const operator ()
      T operator() (size_t i) const
         { return v[i]; }

         /// Like valarray, lets you do vec[slice] to get a VectorSlice.
      VectorSlice<T> operator[] (const std::slice& sli)
         { return VectorSlice<T>(*this, sli); }

         /// *this will be resized if it isn't as large as x.
      Vector& operator=(const Vector& x)
         { resize(x.s); return assignFrom(x); }

         /// *this will be resized if it isn't as large as x.
      template <class E>
      Vector& operator=(const ConstVectorBase<T, E>& x)
         { resize(x.size()); return assignFrom(x); }

         /// *this will be resized if it isn't as large as x.
      Vector& operator=(const std::valarray<T>& x)
         { resize(x.size()); return assignFrom(x); }
         /// Only (*this).size() elements will be assigned.
      Vector& operator=(const T x)
         { return assignFrom(x); }
         /// Only (*this).size() elements will be assigned.
      Vector& operator=(const T* x)
         { return assignFrom(x); }

      /// *this will be cleared and resized as necessary
      inline Vector& operator=(const std::vector<T>& x)
      {
          size_t i;
          size_t vs = x.size();
          (*this).resize(vs);

          for (i = 0; i < vs; i++) 
              (*this)[i] = x[i];

          return (*this); 
      }

         /// Resizes the vector.  if index > size, the vector will be
         /// erased and the contents destroyed.
      Vector& resize(const size_t index)
         { 
            if (index > s)
            {
               if (v)
                  delete [] v;
               v = new T[index];
               if(!v) {
                  VectorException e("Vector.resize(size_t) failed to allocate");
                  GPSTK_THROW(e);
               }
            }
            s = index;
            return *this;
         }

         /// resize with new default value
      Vector& resize(const size_t index, const T defaultValue)
         {
            resize(index);
            size_t i;
            for(i = 0; i < s; i++)
               v[i] = defaultValue;
            return *this;
         }

    /// Returns the concatenation of this Vector and Vector b
    inline Vector operator&&(const Vector &b) 
    {
        size_t i;
        size_t vs = this->size();
        size_t bs = b.size();
        size_t rows = vs + bs;
        Vector<T> toReturn(rows);

        for (i = 0; i < vs; i++)
            toReturn[i] = (*this)[i];

        for (i = 0; i < bs; i++)
            toReturn[i+vs] = b[i];

        return toReturn;
    }

    /// Returns the concatenation of this Vector and a scalar of type T
    inline Vector operator&&(const T &b) 
    {
        size_t i;
        size_t vs = this->size();
        size_t rows = vs + 1;
        Vector<T> toReturn(rows);

        for (i = 0; i < vs; i++)
            toReturn[i] = (*this)[i];

        toReturn[rows - 1] = b;

        return toReturn;
    }

   private:

         // a good optimizer will remove this function call
         // if RANGECHECK isn't defined.  remember that
         // range checking affects EVERY operation
      inline bool rangeCheck(const size_t index) const
         {
#ifdef RANGECHECK
            return (index < s);
#else
            return true;
#endif
         }
   
         /// The vector
      T* v;
         /// The size of the vector.
      size_t s;
   };
   // end class Vector<T>

/**
 * A slice of Vector<T> that can be modified.  
 * @warning Remember that (VectorSlice = VectorSlice) will
 * assign elements to the VectorSlice, not copy the VectorSlice internal data!
 */
   template <class T>
   class VectorSlice : public RefVectorSliceBase<T, VectorSlice<T> >
   {
   public:
         /// Default constructor
      VectorSlice()
            : v(NULL), s(std::slice(0,0,0))
         { }

         /// Makes a slice of the whole vector
      VectorSlice(Vector<T>& vv)
            : v(&vv), s(std::slice(0,vv.size(),1))
         { }
            
         /// Makes a slice of the vector with the given std::slice.
      VectorSlice(Vector<T>& vv, const std::slice& ss)
            : v(&vv), s(ss)
         { vecSliceCheck(vv.size()); }

         /// Assign the elements of this slice from another vector.
      template <class V>
      VectorSlice& operator=(const ConstVectorBase<T, V>& x)
         { return assignFrom(x); }

         /// Assign the elements of this slice from a valarray.
      VectorSlice& operator=(const std::valarray<T>& x)
         { return assignFrom(x); }

         /// Assign all the elements of this slice to x.
      VectorSlice& operator=(const T x)
         { return assignFrom(x); }

         /// Assign (*this).size() elements from x to (*this).
      VectorSlice& operator=(const T* x)
         { return assignFrom(x); }

         /// Returns the modifiable i'th element of the slice.
      T& operator[] (size_t i) 
         { return (*v)[start() + i * stride()]; }
         /// Returns the const i'th element of the slice.
      T operator[] (size_t i) const
         { return (*v)[start() + i * stride()]; }
         /// Returns the modifiable i'th element of the slice.
      T& operator() (size_t i) 
         { return (*v)[start() + i * stride()]; }
         /// Returns the const i'th element of the slice.
      T operator() (size_t i) const
         { return (*v)[start() + i * stride()]; }

         /// returns the number of elements in the slice
      inline size_t size() const { return s.size(); }
         /// returns the index in the vector of the first element.
      inline size_t start() const { return s.start(); }
         /// returns the number of elements to skip between (*this)[i] and 
         /// (*this)[i+1]
      inline size_t stride() const { return s.stride(); }
   private:
         /// the vector used as a source for the slice
      Vector<T>* v;
         /// the slice specification.
      std::slice s;
   };

/**
 * A Vector<T> slice that doesn't allow modification. 
 */
   template <class T>
   class ConstVectorSlice : public ConstVectorSliceBase<T, ConstVectorSlice<T> >
   {
   public:
         /// default constructor
      ConstVectorSlice()
            : v(NULL), s(std::slice(0,0,0))
         { }

         /// Makes a slice of the whole vector
      ConstVectorSlice(const Vector<T>& vv)
            : v(&vv), s(std::slice(0,vv.size(),1))
         { }
            
         /// Uses the given slice and vector.
      ConstVectorSlice(const Vector<T>& vv, const std::slice& ss)
            : v(&vv), s(ss)
         { vecSliceCheck(vv.size()); }

         /// Returns a const version of the i'th slice element.
      T operator[] (size_t i) const
         { return (*v)[start() + i * stride()]; }
         /// Returns a const version of the i'th slice element.
      T operator() (size_t i) const
         { return (*v)[start() + i * stride()]; }

         /// returns the number of elements in the slice
      inline size_t size() const { return s.size(); }
         /// returns the index in the vector of the first element.
      inline size_t start() const { return s.start(); }
         /// returns the number of elements to skip between (*this)[i] and 
         /// (*this)[i+1]
      inline size_t stride() const { return s.stride(); }

   private:
         /// Vectortor used as a source for this slice.
      const Vector<T>* v;
         /// the slice specification.
      std::slice s;
   };

   //@}

}  // namespace

#include "VectorOperators.hpp"

#endif