Trace.h

Go to the documentation of this file.

#ifndef _utl_Trace_h_
#define _utl_Trace_h_

#include <algorithm>
#include <complex>
#include <iostream>
#include <string>
#include <vector>
#include <utl/ErrorLogger.h>
#include <utl/SVector.h>
#include <utl/ShadowPtr_fwd.h>
#include <utl/IteratorRange.h>


//#define TRACE_CHECKED_ACCESS

namespace utl {

  // threevector of doubles, e.g., for time-series e-field data
  typedef utl::SVector<3, double> Vector3D;

  // threevector of complex, e.g., for frequency-spectrum e-field data
  typedef utl::SVector<3, std::complex<double>> Vector3C;


  template<typename T>
  class Trace {

  public:
    typedef T ValueType;
    typedef typename std::vector<T>::size_type SizeType;
    typedef typename std::vector<T>::iterator Iterator;
    typedef typename std::vector<T>::const_iterator ConstIterator;

    Trace() = default;

    Trace(const SizeType size, const double binning, const T& init = T())
      : fArray(size, init), fBinning(binning), fStop(size) { }

    Trace(const SizeType size, const T* const cArray, const double binning)
      : fArray(cArray, cArray + size), fBinning(binning), fStop(size) { }

    Trace(const std::vector<T>& trace, const double binning,
          const SizeType start, const SizeType stop)
      : fArray(trace), fBinning(binning), fStart(start), fStop(stop) { }

    Iterator Begin() { return fArray.begin(); }
    Iterator End() { return fArray.end(); }
    ConstIterator Begin() const { return fArray.begin(); }
    ConstIterator End() const { return fArray.end(); }
    OFFLINE_MAKE_BOTH_FRIEND_RANGES(Iterator, ConstIterator, Trace)

    
    template<typename T2>
    void
    Adopt(const T2* const cArray, const SizeType size)
    {
      fArray.resize(size);
      copy(cArray, cArray + size, fArray.begin());
      fStart = 0;
      fStop = size;
    }

    template<typename T2>
    void
    Assign(const T2& begin, const T2& end)
    {
      fArray.assign(begin, end);
      fStart = 0;
      fStop = fArray.size();
    }

    template<typename T2>
    void
    Append(const T2& begin, const T2& end)
    {
      fArray.append(fArray.end(), begin, end);
      fStart = 0;
      fStop = fArray.size();
    }

    void
    PushBack(const T& value)
    {
      // increase fStop if it points to the end of the trace
      if (fStop == (GetSize() - 1))
        ++fStop;
      fArray.push_back(value);
    }

    void
    PopBack()
    {
      // decrease fStop if it points to the end of the trace
      if (fStop == (GetSize() - 1))
        --fStop;
      fArray.pop_back();
    }

    double GetBinning() const { return fBinning; }
    void SetBinning(const double binning) { fBinning = binning; }

    SizeType GetStart() const { return fStart; }

    void SetStart(const SizeType start) { fStart = start; }

    SizeType GetStop() const { return fStop; }

    void SetStop(const SizeType stop) { fStop = stop; }

    double GetScale() const { return fScale; }
    void SetScale(const double s) { fScale = s; }

    SizeType GetSize() const { return fArray.size(); }

    void Clear() { fArray.clear(); }

    void ResetAll(const T& value = T()) { std::fill(fArray.begin(), fArray.end(), value); }

    Trace<T>
    operator-()
      const
    {
      Trace<T> result(GetSize(), fBinning);
      transform(fArray.begin(), fArray.end(), result.Begin(), std::negate<T>());
      result.fStart = fStart;
      result.fStop = fStop;
      result.fScale = fScale;
      return result;
    }

    Trace<T> operator+(const Trace<T>& trace) const;
    Trace<T> operator-(const Trace<T>& trace) const;
    Trace<T> operator*(const Trace<T>& trace) const;

    Trace<T>& operator+=(const Trace<T>& trace);
    Trace<T>& operator-=(const Trace<T>& trace);
    Trace<T>& operator*=(const Trace<T>& trace);

    Trace<T>& operator+=(const T value);
    Trace<T>& operator-=(const T value);
    Trace<T>& operator*=(const T value);
    Trace<T>& operator/=(const T value);

    bool IsSameTypeAs(const Trace<T>& t) const
    { return fArray.size() == t.fArray.size() && fBinning == t.fBinning && fScale == t.fScale; }

    bool operator==(const Trace<T>& t) const
    { return IsSameTypeAs(t) && fArray == t.fArray && fStart == t.fStart && fStop == t.fStop; }

    bool operator!=(const Trace<T>& trace) const
    { return !operator==(trace); }

#ifdef TRACE_CHECKED_ACCESS
    T& operator[](const SizeType i) { return At(i); }
    const T& operator[](const SizeType i) const { return At(i); }
#else
    T& operator[](const SizeType i) { return fArray[i]; }
    const T& operator[](const SizeType i) const { return fArray[i]; }
#endif

    T& At(const SizeType i) { return fArray.at(i); }

    const T& At(const SizeType i) const { return fArray.at(i); }

    void
    Swap(Trace<T>& t)
    {
      std::swap(fArray, t.fArray);
      std::swap(fBinning, t.fBinning);
      std::swap(fStart, t.fStart);
      std::swap(fStop, t.fStop);
      std::swap(fScale, t.fScale);
    }

  protected:
    std::vector<T> fArray;

    double fBinning = 0;
    SizeType fStart = 0;
    SizeType fStop = 0;
    double fScale = 1;

    friend class ShadowPtr<Trace<T>>;

  };

  // To keep the forward declarations consistent
  // modify Trace-fwd when changing/adding below
  typedef Trace<unsigned short int>   TraceUSI;
  typedef Trace<short int>            TraceSI;
  typedef Trace<unsigned int>         TraceUI;
  typedef Trace<int>                  TraceI;
  typedef Trace<float>                TraceF;
  typedef Trace<double>               TraceD;
  typedef Trace<char>                 TraceB;
  typedef Trace<std::complex<double>> TraceC;
  typedef Trace<Vector3D>             TraceV3D;
  typedef Trace<Vector3C>             TraceV3C;


  // Trace<T> + - * Trace<T>
  #define INNER_ARITHMETIC_BINARY_OPERATOR(_op_)                \
  template<typename T>                                                         \
  Trace<T>                                                                     \
  Trace<T>::operator _op_(const Trace<T>& trace)                               \
    const                                                                      \
  {                                                                            \
    const SizeType size = GetSize();                                           \
    if (IsSameTypeAs(trace)) {                                                 \
      Trace<T> result(size, fBinning);                                         \
      transform(fArray.begin(), fArray.end(), trace.Begin(), result.Begin(),   \
                [](const auto& l, const auto& r) { return l _op_ r;} );        \
      result.fStart = fStart;                                                  \
      result.fStop = fStop;                                                    \
      result.fScale = fScale;                                                  \
      return result;                                                           \
    } else {                                                                   \
      ERROR("Attempting to operate on two traces of different type");          \
      Trace<T> foo;                                                            \
      return foo;                                                              \
    }                                                                          \
  }

  INNER_ARITHMETIC_BINARY_OPERATOR(+)
  INNER_ARITHMETIC_BINARY_OPERATOR(-)
  INNER_ARITHMETIC_BINARY_OPERATOR(*)

  #undef INNER_ARITHMETIC_BINARY_OPERATOR


  // Trace<T> += -= *= Trace<T>
  #define INNER_AUGMENTED_ARITHMETIC_OPERATOR(_op_)                            \
  template<typename T>                                                         \
  Trace<T>&                                                                    \
  Trace<T>::operator _op_##=(const Trace<T>& trace)                            \
  {                                                                            \
    if (IsSameTypeAs(trace)) {                                                 \
      transform(fArray.begin(), fArray.end(), trace.Begin(), fArray.begin(),   \
                [](const auto& l, const auto& r) { return l _op_ r;} );        \
    } else                                                                     \
      ERROR("Attempting to operate on two traces of different types");         \
    return *this;                                                              \
  }

  INNER_AUGMENTED_ARITHMETIC_OPERATOR(+)
  INNER_AUGMENTED_ARITHMETIC_OPERATOR(-)
  INNER_AUGMENTED_ARITHMETIC_OPERATOR(*)

  #undef INNER_AUGMENTED_ARITHMETIC_OPERATOR


  // Trace<T> += -= *= /= T
  #define OUTER_AUGMENTED_ARITHMETIC_OPERATOR(_op_)                            \
  template<typename T>                                                         \
  Trace<T>&                                                                    \
  Trace<T>::operator _op_##=(const T value)                                    \
  {                                                                            \
    transform(fArray.begin(), fArray.end(), fArray.begin(),                    \
              [&value](const auto& elem) { return elem _op_ value; });         \
    return *this;                                                              \
  }

  OUTER_AUGMENTED_ARITHMETIC_OPERATOR(+)
  OUTER_AUGMENTED_ARITHMETIC_OPERATOR(-)
  OUTER_AUGMENTED_ARITHMETIC_OPERATOR(*)
  OUTER_AUGMENTED_ARITHMETIC_OPERATOR(/)

  #undef OUTER_AUGMENTED_ARITHMETIC_OPERATOR


  // left:  Trace<T1> + - * T2
  // right: T2 + - * Trace<T1>
  #define LEFT_OUTER_ARITHMETIC_OPERATOR(_op_)                                 \
  template <typename _T1_, typename _T2_>                                      \
  utl::Trace<_T2_>                                                             \
  operator _op_(const utl::Trace<_T1_>& trace, const _T2_ value)               \
  {                                                                            \
    utl::Trace<_T2_> result(trace.GetSize(), trace.GetBinning());              \
    transform(trace.Begin(), trace.End(), result.Begin(),                      \
              [&value](const auto& elem) { return elem _op_ value; });         \
    result.SetStart(trace.GetStart());                                         \
    result.SetStop(trace.GetStop());                                           \
    result.SetScale(trace.GetScale());                                         \
    return result;                                                             \
  }

  #define RIGHT_OUTER_ARITHMETIC_OPERATOR(_op_)                                \
  template <typename _T1_, typename _T2_>                                      \
  utl::Trace<_T2_>                                                             \
  operator _op_(const _T2_ value, const utl::Trace<_T1_>& trace)               \
  {                                                                            \
    utl::Trace<_T2_> result(trace.GetSize(), trace.GetBinning());              \
    transform(trace.Begin(), trace.End(), result.Begin(),                      \
              [&value](const auto& elem) { return value _op_ elem; });         \
    result.SetStart(trace.GetStart());                                         \
    result.SetStop(trace.GetStop());                                           \
    result.SetScale(trace.GetScale());                                         \
    return result;                                                             \
  }

  LEFT_OUTER_ARITHMETIC_OPERATOR(+)
  RIGHT_OUTER_ARITHMETIC_OPERATOR(+)
  LEFT_OUTER_ARITHMETIC_OPERATOR(-)
  RIGHT_OUTER_ARITHMETIC_OPERATOR(-)
  LEFT_OUTER_ARITHMETIC_OPERATOR(*)
  RIGHT_OUTER_ARITHMETIC_OPERATOR(*)
  LEFT_OUTER_ARITHMETIC_OPERATOR(/)

  #undef LEFT_OUTER_ARITHMETIC_OPERATOR
  #undef RIGHT_OUTER_ARITHMETIC_OPERATOR

} // utl


namespace std {

  template<typename T>
  inline void swap(utl::Trace<T>& t1, utl::Trace<T>& t2)
  { t1.Swap(t2); }

}


#undef TRACE_CHECKED_ACCESS


#endif