TRUSTVect.h

/****************************************************************************
* Copyright (c) 2026, CEA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
 
#ifndef TRUSTVect_included
#define TRUSTVect_included
 
#include <type_traits>
#include <MD_Vector_tools.h>
#include <MD_Vector_base.h>
#include <TRUSTArray.h>
#include <limits.h>
#include <math.h>
 
#include <MD_Vector.h>
#ifndef LATATOOLS   // Lata tools does not use parallelism
#include <DescStructure.h>
#include <communications.h>
#endif
 
template<typename _TYPE_, typename _SIZE_>
class TRUSTVect : public TRUSTArray<_TYPE_,_SIZE_>
{
protected:
  inline unsigned taille_memoire() const override { throw; }
 
  inline int duplique() const override
  {
    TRUSTVect* xxx = new  TRUSTVect(*this);
    if(!xxx) Process::exit("Not enough memory ");
    return xxx->numero();
  }
 
  Sortie& printOn(Sortie& os) const override
  {
#ifndef LATATOOLS
    if (TRUSTArray<_TYPE_,_SIZE_>::nproc() > 1 && md_vector_)
      Process::exit("Error in TRUSTVect::printOn: try to print a parallel vector");
    TRUSTArray<_TYPE_,_SIZE_>::printOn(os);
#endif
    return os;
  }
 
  /*! @brief Reads a sequential vector (like an ArrOfDouble). Invalid call if the vector has a non-null MD_Vector.
   *
   * (For parallel vectors, use a save/restore method instead)
   *
   */
  Entree& readOn(Entree& is) override
  {
#ifndef LATATOOLS
    // Reading into a vector that already has a parallel structure is not allowed:
    if (md_vector_)
      Process::exit("Error in TRUSTVect::readOn: vector has a parallel structure");
    TRUSTArray<_TYPE_,_SIZE_>::readOn(is);
    size_reelle_ = TRUSTArray<_TYPE_,_SIZE_>::size_array();
    line_size_ = 1;
#endif
    return is;
  }
 
public:
 
  using Span_ = tcb::span<_TYPE_>;
 
  // One instanciation with given template parameter may see all other template versions (useful in ref_as_xxx())
  template<typename _TYPE2_, typename _SIZE2_> friend class TRUSTVect;
 
  virtual ~TRUSTVect() { }
 
  TRUSTVect() : size_reelle_(0), line_size_(1) { }
 
  /*! @brief Constructs a vector of size n.
   *
   * Elements are initialized to zero by default. To skip initialization, use: DoubleVect toto;
   *    toto.resize(n, RESIZE_OPTIONS::NOCOPY_NOINIT);
   *
   */
  TRUSTVect(_SIZE_ n) :   TRUSTArray<_TYPE_,_SIZE_>(n), size_reelle_(n), line_size_(1) { }
 
  /*! @brief Copy constructor.
   *
   * This is a deep copy; see ArrOfDouble::ArrOfDouble(const ArrOfDouble &). Note: there is no copy constructor from ArrOfDouble on purpose,
   *    to avoid large performance losses from implicit object creation that are hard to track down.
   *    (Example: calling toto(const IntVect &) with an ArrOfInt would silently copy the array!)
   *   Use copy() to copy an ArrOfDouble into a DoubleVect.
   *
   */
  TRUSTVect(const TRUSTVect& v) : TRUSTArray<_TYPE_,_SIZE_>(v), md_vector_(v.md_vector_), size_reelle_(v.size_reelle_), line_size_(v.line_size_) { }
 
  inline TRUSTVect& operator=(const TRUSTVect&);
  inline TRUSTVect& operator=(_TYPE_);
  inline _SIZE_ size() const;
  inline _SIZE_ size_totale() const;
  inline _SIZE_ size_reelle() const;
  inline _SIZE_ size_reelle_ok() const;
  inline int line_size() const;   // Even in 64b we suppose line_size_ is always sufficiently small to fit in an int.
  inline void resize(_SIZE_, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT);
  inline void copy(const TRUSTArray<_TYPE_,_SIZE_>&, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT);
  inline void copy(const TRUSTVect&, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT);
  inline void operator+=(const TRUSTVect& v) { operator_add(*this, v); }
  inline void operator+=(const _TYPE_ x) { operator_add(*this, x); }
  inline void operator-=(const TRUSTVect& v) { operator_sub(*this, v); }
  inline void operator-=(const _TYPE_ x) { operator_sub(*this, x); }
  inline void operator*=(const TRUSTVect& v) { operator_multiply(*this, v); }
  inline void operator*= (const _TYPE_ x) { operator_multiply(*this, x); }
 
  template<typename _T_ /* double ou float */>
  inline void operator/=(const TRUSTVect<_T_, _SIZE_>& v) { operator_divide(*this, v); }
  inline void operator/= (const _TYPE_ x) { operator_divide(*this, x); }
 
  inline virtual const MD_Vector& get_md_vector() const { return md_vector_; }
  inline void resize_tab(_SIZE_ n, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT) override;
 
  // See same methods as in TRUSTArray - CAREFUL, this is not an override because arg types are different (vect vs arr)
  inline void from_tid_to_int(TRUSTVect<int, int>& out) const;
  inline void ref_as_big(TRUSTVect<_TYPE_, trustIdType>& out) const;
  inline void ref_as_small(TRUSTVect<_TYPE_, int>& out) const;
 
  // Default options chosen for compatibility with the previous version. Note: there was an echange_espace_virtuel call before, which is not strictly equivalent.
  inline void abs(Mp_vect_options opt=VECT_ALL_ITEMS) { operator_abs(*this, opt); }
  inline void carre(Mp_vect_options opt=VECT_ALL_ITEMS) { carre_(*this, opt); }
  inline void racine_carree(Mp_vect_options opt=VECT_ALL_ITEMS) { racine_carree_(*this, opt); }
 
  template<typename _SCALAR_TYPE_>
  inline void ajoute(_SCALAR_TYPE_ alpha, const TRUSTVect& y, Mp_vect_options opt=VECT_ALL_ITEMS);
 
  template<typename _SCALAR_TYPE_>
  inline void ajoute_sans_ech_esp_virt(_SCALAR_TYPE_ alpha, const TRUSTVect& y, Mp_vect_options opt=VECT_REAL_ITEMS);
 
  template<typename _SCALAR_TYPE_>
  inline void ajoute_produit_scalaire(_SCALAR_TYPE_ alpha, const TRUSTVect& x, const TRUSTVect& y, Mp_vect_options opt=VECT_ALL_ITEMS);
 
  template<typename _SCALAR_TYPE_>
  inline void ajoute_carre(_SCALAR_TYPE_ alpha, const TRUSTVect& y, Mp_vect_options opt=VECT_ALL_ITEMS);
 
#ifndef LATATOOLS
  //
  //    All the methods below involve parallelism or are not used in lata_tools
  //
 
  // Default: min and max over real items (compat. 1.5.6):
  inline _TYPE_ local_max_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return local_max_vect_(*this, opt); }
  inline _TYPE_ local_min_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return local_min_vect_(*this, opt); }
  inline _TYPE_ local_max_abs_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return local_max_abs_vect_(*this, opt); }
  inline _TYPE_ local_min_abs_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return local_min_abs_vect_(*this, opt); }
  inline _TYPE_ mp_max_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return mp_max_vect_(*this, opt); }
  inline _TYPE_ mp_min_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return mp_min_vect_(*this, opt); }
  inline _TYPE_ mp_max_abs_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return mp_max_abs_vect_(*this, opt); }
  inline _TYPE_ mp_min_abs_vect(Mp_vect_options opt=VECT_REAL_ITEMS) const { return mp_min_abs_vect_(*this, opt); }
  inline _TYPE_ mp_norme_vect() const { return mp_norme_vect_(*this); }
#endif  // LATATOOLS
 
  // Virtual methods
 
  inline virtual void ref(const TRUSTVect&);
  inline virtual void echange_espace_virtuel(IsExchangeBlocking exchange_type = IsExchangeBlocking::DefaultBlocking, const std::string kernel_name="noname");
  inline virtual void start_echange_espace_virtuel_async(const std::string kernel_name);
  inline virtual void finish_echange_espace_virtuel_async(const std::string kernel_name);
 
  inline virtual void set_md_vector(const MD_Vector&);
  inline virtual void jump(Entree&);
  inline virtual void lit(Entree&, bool resize_and_read=1);
  inline virtual void ecrit(Sortie&) const;
  inline virtual void detach_vect() { md_vector_.detach(); }
 
  inline void ref_data(_TYPE_* ptr, _SIZE_ new_size) override;
  inline void ref_array(TRUSTArray<_TYPE_,_SIZE_>&, _SIZE_ start = 0, _SIZE_ sz = -1) override;
 
  inline Span_ get_span() override { return Span_(TRUSTArray<_TYPE_,_SIZE_>::addr(),size_reelle()); }
  inline Span_ get_span_tot() override { return Span_(TRUSTArray<_TYPE_,_SIZE_>::addr(),TRUSTArray<_TYPE_,_SIZE_>::size_array()); }
  inline const Span_ get_span() const override { return Span_((_TYPE_*)TRUSTArray<_TYPE_,_SIZE_>::addr(), size_reelle()); }
  inline const Span_ get_span_tot() const override { return Span_((_TYPE_*)TRUSTArray<_TYPE_,_SIZE_>::addr(), TRUSTArray<_TYPE_,_SIZE_>::size_array()); }
 
  /*! @brief Resets the object to the state obtained by the default constructor.
   *
   */
  inline void reset() override
  {
    md_vector_.detach();
    line_size_ = 1;
    size_reelle_ = 0;
    TRUSTArray<_TYPE_,_SIZE_>::reset();
  }
 
protected:
  inline void set_line_size_(int n);   // Even in 64b we suppose line_size_ is always sufficiently small to fit in an int.
  inline void resize_vect_(_SIZE_ n, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT);
  inline void copy_(const TRUSTVect& v, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT);
 
  // A DoubleVect is an ArrOfDouble that optionally carries a distributed array structure. This pointer may be null.
  MD_Vector md_vector_;
 
  // The size_reelle property of the array (provided by scattered_vect_data). -1 => calls to size_reelle() and size() are invalid for this vector.
  _SIZE_ size_reelle_;
 
  // Multiplicative factor between md_vector_.nb_items_tot() and size_array(), and between md_vector_.nb_items_reels() and size_reelle_.
  // For a 2D array, this is typically the product of dimension(i) for i>1 (one array row per geometric item in the descriptor).
  // Warning: line_size_ may be zero for an array with zero columns, but not if a descriptor is attached.
  // Even in 64b we suppose line_size_ is always sufficiently small to fit in an int.
  int line_size_;
};
 
using DoubleVect = TRUSTVect<double, int>;
using FloatVect = TRUSTVect<float, int>;
using IntVect = TRUSTVect<int, int>;
using TIDVect = TRUSTVect<trustIdType, int>;
 
template <typename _TYPE_>
using BigTRUSTVect = TRUSTVect<_TYPE_, trustIdType>;
 
using BigDoubleVect = BigTRUSTVect<double>;
using BigIntVect = BigTRUSTVect<int>;
using BigTIDVect = BigTRUSTVect<trustIdType>;
 
/* ********************************** *
 * NON-MEMBER FUNCTIONS OF TRUSTVect  *
 * ********************************** */
 
#include <TRUSTVect_tools.tpp> // external templates function specializations ici ;)
 
/* ****************************** *
 * MEMBER FUNCTIONS OF TRUSTVect  *
 * ****************************** */
 
#include <TRUSTVect.tpp> // template specializations are here ;)
 
#endif /* TRUSTVect_included */