stl_helpers.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_STL_HELPERS_HPP
#define GNSSTK_STL_HELPERS_HPP
 
#include <cmath>
#include <algorithm>
#include <list>
#include <vector>
 
namespace gnsstk
{
 
   template<class For> For max(const std::list<For>& lst)
   {
      return *max_element(lst.begin(), lst.end());
   }
 
   template<class For> For min(const std::list<For>& lst)
   {
      return *min_element(lst.begin(), lst.end());
   }
 
   template<class bt>
   struct ListStats
   {
      unsigned n;
      bt mean, sigma, min, max;
      ListStats():n(0),mean(0),sigma(0),min(0),max(0){};
   };
 
   template<class bt> ListStats<bt> stats(const std::list<bt>& lst)
   {
      ListStats<bt> s;
      bt sum=0, sumsq=0;
 
      s.n = lst.size();
      if (s.n<1)
         return s;
 
      typename std::list<bt>::const_iterator li;
      li=lst.begin();
      s.min = s.max = *li;
      for(; li!=lst.end(); li++)
      {
         s.min = std::min(s.min, *li);
         s.max = std::max(s.max, *li);
         sum += *li;
      }
      s.mean = sum/s.n;
 
      if (s.n<2)
         return s;
 
      for(li=lst.begin(); li!=lst.end(); li++)
      {
         bt z=*li-s.mean;
         sumsq += z*z;
      }
 
      s.sigma = std::sqrt( (double)(sumsq/(s.n-1)) );
 
      return s;
   }
 
   template <class T> int vectorindex(const std::vector<T>& vec, const T& value)
   {
      typename std::vector<T>::const_iterator it;
      it = std::find(vec.begin(), vec.end(), value);
      if(it == vec.end()) return -1;
      return int(it - vec.begin());
   }
 
   template <class T> std::vector<T> vec_intersect(
                           const std::vector<T>& v1, const std::vector<T>& v2)
   {
      std::vector<T> vinter;
      typename std::vector<T>::const_iterator it;
      for(it=v1.begin(); it!=v1.end(); ++it) {
         if(std::find(v2.begin(), v2.end(), *it) != v2.end())
            vinter.push_back(*it);
      }
      return vinter;
   }
 
   template <class T> std::vector<T> vec_notintersect(
                           const std::vector<T>& v1, const std::vector<T>& v2)
   {
      std::vector<T> vinter;
      typename std::vector<T>::const_iterator it;
      for(it=v1.begin(); it!=v1.end(); ++it) {
         if(std::find(v2.begin(), v2.end(), *it) == v2.end())
            vinter.push_back(*it);
      }
      for(it=v2.begin(); it!=v2.end(); ++it) {
         if(std::find(v1.begin(), v1.end(), *it) == v1.end())
            vinter.push_back(*it);
      }
      return vinter;
   }
 
 
} // namespace
 
#endif