VectorBase.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef GNSSTK_VECTOR_BASE_HPP
#define GNSSTK_VECTOR_BASE_HPP
 
#include <valarray>
#include "Exception.hpp"
 
#include "MathBase.hpp"
#include "gnsstk_export.h"
 
namespace gnsstk
{
 
   NEW_EXCEPTION_CLASS(VectorException, gnsstk::Exception);
 
 
 
      /*
       * There were two overriding philosophies to the vector and
       * matrix classes:
       *
       * The concept of "const" and "reference" (i.e. changable)
       * vector and matrix types both exist, so that any Const* type
       * could not be altered while Ref* types can.  This allowed one
       * to add the slice classes that let you use a subset of a
       * vector and modify (or not if it's const) the original vector.
       * Furthermore, it allowed slice and non-slice classes to
       * interoperate through the ConstVectorBase or ConstMatrixBase
       * classes, so, for example, operator* only needs to be written
       * in terms of ConstVectorBase to work correctly with Vector,
       * VectorSlice and ConstVectorSlice.
       *
       * Remember that a slice MUST refer to a vector or matrix; you
       * cannot have a slice independent of a base vector or matrix.
       *
       * In the future:
       *
       * - Change the math operators to template expressions.
       * - Add general slices and diagonal matrix slices.
       * - Make range checking more consistent.
       * - Make operator= and copy constructors consistent between const and
       *   non-const versions.
       * - Reevaluate the need for default slice constructors...?
       * - find a way for LUD and SVD to use the template type of the
       *   parameters rather than specified when the object is
       *   created.
       * - come up with a policy for when zeroize() will be used before results
       *   are returned.
       *
       * @warning MSVC cant deal with cmath header.
       * Changes to accomidate this may break complex!
       */
 
   template <class T, class BaseClass>
   class ConstVectorBase
   {
   public:
      explicit ConstVectorBase() {}
 
      size_t size() const
      { return static_cast<const BaseClass*>(this)->size(); }
      T operator[] (size_t i) const
      { return constVectorRef(i); }
      T operator() (size_t i) const
      { return constVectorRef(i); }
 
   protected:
      inline T constVectorRef(size_t i) const
      {
         const BaseClass& b = static_cast<const BaseClass&>(*this);
#ifdef RANGECHECK
         if (i >= b.size())
         {
            VectorException e("Invalid ConstVectorBase index");
            GNSSTK_THROW(e);
         }
#endif
         return b[i];
      }
   };
 
   class RefVectorBaseHelper
   {
   public:
      GNSSTK_EXPORT static double zeroTolerance;
   };
 
   template <class T, class BaseClass>
   class RefVectorBase : public ConstVectorBase<T, BaseClass>,
                         public RefVectorBaseHelper
   {
   public:
      explicit RefVectorBase() {}
      T& operator[] (size_t i)
      { return vecRef(i); }
      T& operator() (size_t i)
      { return vecRef(i); }
      BaseClass& zeroize()
      {
         BaseClass& me = static_cast<BaseClass&>(*this);
         size_t i;
         for (i = 0; i < me.size(); i++)
            if (ABS(me[i]) < zeroTolerance)
               me[i] = T(0);
         return me;
      }
 
#define VecBaseArrayAssignMacroDontCheckRange(func)     \
      BaseClass& me = static_cast<BaseClass&>(*this);   \
      size_t i; for (i=0; i < me.size(); i++) {         \
         me[i] func x[i];                               \
      }                                                 \
      return me;
 
#ifdef RANGECHECK
#define VecBaseArrayAssignMacro(func)                           \
      BaseClass& me = static_cast<BaseClass&>(*this);           \
      if (x.size() != me.size())                                \
      {                                                         \
         VectorException e("Unequal lengths for vectors");      \
         GNSSTK_THROW(e);                                        \
      }                                                         \
      size_t i; for (i=0; i < me.size(); i++) me[i] func x[i];  \
      return me;
#else
#define VecBaseArrayAssignMacro(func)                   \
      VecBaseArrayAssignMacroDontCheckRange(func)
#endif
 
#define VecBaseAtomicAssignMacro(func)                          \
      BaseClass& me = static_cast<BaseClass&>(*this);           \
      size_t i; for (i=0; i < me.size(); i++) me[i] func x;     \
      return me;
 
#define VecBaseNewAssignOperator(funcName, op)                          \
   \
      template <class E> BaseClass& funcName(const ConstVectorBase<T, E>& x) \
      { VecBaseArrayAssignMacro(op) }                                   \
   \
      BaseClass& funcName(const std::valarray<T>& x)                    \
      { VecBaseArrayAssignMacro(op) }                                   \
   \
      BaseClass& funcName(const T* x)                                   \
      { VecBaseArrayAssignMacroDontCheckRange(op) }                     \
   \
      BaseClass& funcName(T x)                                          \
      { VecBaseAtomicAssignMacro(op) }
 
      VecBaseNewAssignOperator(assignFrom, =);
      VecBaseNewAssignOperator(operator+=, +=);
      VecBaseNewAssignOperator(operator-=, -=);
      VecBaseNewAssignOperator(operator*=, *=);
      VecBaseNewAssignOperator(operator/=, /=);
 
         //   // unary minus: multiplies each element of this vector by -1.
         //BaseClass& operator-()
         //   {
         //      const T x=T(-1);
         //      VecBaseAtomicAssignMacro(*=);
         //   }
         // unary minus must not return an l-value
 
      const BaseClass operator-() const
      {
         const T x=T(-1);
         BaseClass me = static_cast<BaseClass>(*this);
         size_t i;
         for (i=0; i < me.size(); i++) me(i) *= x;
         return me;
      }
 
   protected:
      inline T& vecRef(size_t i)
      {
         BaseClass& b = static_cast<BaseClass&>(*this);
#ifdef RANGECHECK
         if (i >= b.size())
         {
            VectorException e("Invalid VectorBase index");
            GNSSTK_THROW(e);
         }
#endif
         return b[i];
      }
   };
 
   template <class BaseClass>
   class VectorSliceBase
   {
   public:
      explicit VectorSliceBase() {}
 
      size_t size() const
      { return static_cast<const BaseClass*>(this)->size(); }
      size_t start() const
      { return static_cast<const BaseClass*>(this)->start(); }
      size_t stride() const
      { return static_cast<const BaseClass*>(this)->stride(); }
 
   protected:
      inline void vecSliceCheck(size_t sourceSize) const
      {
#ifdef RANGECHECK
            // sanity checks...
         if ( (start() >= sourceSize) ||
              ((start() + (size() - 1) * stride()) >= sourceSize) )
         {
            VectorException e("Invalid range for slice");
            GNSSTK_THROW(e);
         }
#endif
      }
   };
 
   template <class T, class BaseClass>
   class ConstVectorSliceBase : public VectorSliceBase<BaseClass>,
                                public ConstVectorBase<T, BaseClass>
   {
   public:
      explicit ConstVectorSliceBase() {}
   };
 
   template <class T, class BaseClass>
   class RefVectorSliceBase : public VectorSliceBase<BaseClass>,
                              public RefVectorBase<T, BaseClass>
   {
   public:
      explicit RefVectorSliceBase() {}
   };
 
 
}  // namespace gnsstk
 
#include "VectorBaseOperators.hpp"
 
#endif //GNSSTK_VECTOR_BASE_HPP