CepsArray.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
#include <array>
#include <ostream>
 
#include "common/core/Precision.hpp"
 
template <class _Type, CepsSize _N>
std::ostream&
operator<<(std::ostream& os, const CepsArray<_Type, _N>& a)
{
  for (CepsUInt i=0; i<_N-1; ++i)
    os << a[i] << ", " << std::flush;
  os << a[_N-1] << std::flush;
  return os;
}
 
template <class _Type, CepsSize _N>
CepsBool
areSameArray(const CepsArray<_Type, _N>& a, const CepsArray<_Type, _N>& b, const CepsReal error=1.)
{
 
  CepsReal amax  = std::abs(std::min(a[0],b[0]));
  for (CepsUInt i=1; i<_N; ++i)
    amax = std::max(amax,std::abs(std::min(a[i],b[i])));
 
  CepsReal errN = std::numeric_limits<CepsReal>::epsilon()*error*amax;
 
  for (CepsUInt i=0; i<_N; ++i)
    if (not (std::fabs(a[i]-b[i]) <= errN))
      return false;
  return true;
}
 
template <class _Factor, class _Type, CepsSize _N>
CepsArray<_Type, _N>
operator*(_Factor f, const CepsArray<_Type, _N>& a)
{
  CepsArray<_Type, _N> res(a);
  for (CepsUInt i = 0U; i < _N; i++)
    res[i] *= f;
  return res;
}
 
template <class _Factor, class _Type, CepsSize _N>
CepsArray<_Type, _N>
operator*(const CepsArray<_Type, _N>& a, _Factor f)
{
  return f * a;
}
 
template <class _Type, CepsSize _N>
CepsArray<_Type, _N>&
operator+=(CepsArray<_Type, _N>& a, const CepsArray<_Type, _N>& b)
{
  for (CepsUInt i=0U; i<_N; i++)
    a[i] += b[i];
  return a;
}
 
template <class _Type, CepsSize _N>
CepsArray<_Type, _N>
operator+(const CepsArray<_Type, _N>& a, const CepsArray<_Type, _N>& b)
{
  CepsArray<_Type, _N> res(a);
  res += b;
  return res;
}
 
template <class _Type, CepsSize _N>
CepsArray<_Type, _N>&
operator-=(CepsArray<_Type, _N>& a, const CepsArray<_Type, _N>& b)
{
  for (CepsUInt i=0U; i<_N; i++)
    a[i] -= b[i];
  return a;
}
 
template <class _Type, CepsSize _N>
CepsArray<_Type, _N>
operator-(const CepsArray<_Type, _N>& a, const CepsArray<_Type, _N>& b)
{
  CepsArray<_Type, _N> res(a);
  res -= b;
  return res;
}
 
template <class _Type, CepsSize _N>
CepsArray<_Type, _N>
operator-(const CepsArray<_Type, _N>& a)
{
  return -1*a;
}