NumericVectorWithOffset.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2005-06-03, Hammersmith Imanet Ltd
    Copyright (C) 2011-07-01 - 2012, Kris Thielemans
    Copyright (C) 2020, 2023 University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
 
#ifndef __NumericVectorWithOffset_H__
#define __NumericVectorWithOffset_H__
 
#include "stir/VectorWithOffset.h"
#include "stir/deprecated.h"
 
START_NAMESPACE_STIR
 
template <class T, class elemT>
class NumericVectorWithOffset : public VectorWithOffset<T>
{
#ifdef SWIG
public: // needs to be public for SWIG to be able to parse the "using" statement below
#endif
 
  typedef VectorWithOffset<T> base_type;
 
public:
  using base_type::base_type;

  inline NumericVectorWithOffset(const VectorWithOffset<T>& t);

  inline NumericVectorWithOffset(const NumericVectorWithOffset& t)
      : NumericVectorWithOffset(static_cast<const base_type&>(t))
  {}

  // implementation in .h because of templates/friends/whatever, see https://stackoverflow.com/a/61020224
  friend inline void swap(NumericVectorWithOffset& first, NumericVectorWithOffset& second) // nothrow
  {
    swap(static_cast<base_type&>(first), static_cast<base_type&>(second));
  }


  NumericVectorWithOffset(NumericVectorWithOffset&& other) noexcept;

  NumericVectorWithOffset& operator=(const NumericVectorWithOffset& other);
 
  // arithmetic operations with a vector, combining element by element

  inline NumericVectorWithOffset operator+(const NumericVectorWithOffset& v) const;

  inline NumericVectorWithOffset operator-(const NumericVectorWithOffset& v) const;

  inline NumericVectorWithOffset operator*(const NumericVectorWithOffset& v) const;

  inline NumericVectorWithOffset operator/(const NumericVectorWithOffset& v) const;
 
  // arithmetic operations with a elemT
  // TODO??? use member templates

  inline NumericVectorWithOffset operator+(const elemT& v) const;

  inline NumericVectorWithOffset operator-(const elemT& v) const;

  inline NumericVectorWithOffset operator*(const elemT& v) const;

  inline NumericVectorWithOffset operator/(const elemT& v) const;
 
  // corresponding assignment operators

  inline NumericVectorWithOffset& operator+=(const NumericVectorWithOffset& v);

  inline NumericVectorWithOffset& operator-=(const NumericVectorWithOffset& v);

  inline NumericVectorWithOffset& operator*=(const NumericVectorWithOffset& v);

  inline NumericVectorWithOffset& operator/=(const NumericVectorWithOffset& v);

  inline NumericVectorWithOffset& operator+=(const elemT& v);

  inline NumericVectorWithOffset& operator-=(const elemT& v);

  inline NumericVectorWithOffset& operator*=(const elemT& v);

  inline NumericVectorWithOffset& operator/=(const elemT& v);

  template <typename elemT2>
  STIR_DEPRECATED inline void
  axpby(const elemT2 a, const NumericVectorWithOffset& x, const elemT2 b, const NumericVectorWithOffset& y);

  inline void xapyb(const NumericVectorWithOffset& x, const elemT a, const NumericVectorWithOffset& y, const elemT b);

  inline void xapyb(const NumericVectorWithOffset& x,
                    const NumericVectorWithOffset& a,
                    const NumericVectorWithOffset& y,
                    const NumericVectorWithOffset& b);

  template <class T2>
  inline void sapyb(const T2& a, const NumericVectorWithOffset& y, const T2& b);
};
 
END_NAMESPACE_STIR
 
#include "stir/NumericVectorWithOffset.inl"
 
#endif // __NumericVectorWithOffset_H__