Classe implémentant un nombre réel de haute précision. Plus de détails...

#include <arccore/base/HPReal.h>

Fonctions membres publiques
constexpr	HPReal ()
	Constructeur par défaut à 0.0.
constexpr	HPReal (NoInitTag)
	Constructeur SANS initialisation.
constexpr	HPReal (double avalue)
	Crée un HP real avec la valeur value et la correction correction.
constexpr	HPReal (double avalue, double acorrection)
	Crée un HP real avec la valeur value et la correction correction.
constexpr Real	value () const
	Valeur interne. Généralement, vous devez utiliser toReal().
constexpr Real	correction () const
	Correction interne.
constexpr void	operator+= (Real v)
	Ajoute un Real tout en préservant l'erreur.
constexpr void	operator+= (HPReal v)
	Ajoute un HPReal v tout en préservant l'erreur (réduction).
constexpr Real	toReal () const
	Convertit l'instance en un Real.
constexpr HPReal	reduce (HPReal b) const
	Ajoute un HPReal v tout en préservant l'erreur (réduction).
constexpr void	operator*= (Real v)
	Multiplie un Real tout en préservant l'erreur.
constexpr void	operator*= (HPReal v)
	Multiplie un HPReal v tout en préservant l'erreur (réduction).
constexpr void	operator/= (Real v)
	Divise un Real tout en préservant l'erreur.
constexpr void	operator/= (HPReal v)
	Divise un HPReal v tout en préservant l'erreur (réduction).
std::istream &	assign (std::istream &i)
	Lit un HPReal à partir du flux i. La paire est lue sous la forme de deux valeurs de type Real.
std::ostream &	print (std::ostream &o) const
	Écrit l'instance dans le flux o lisible par assign().
std::ostream &	printPretty (std::ostream &o) const
	Écrit l'instance dans le flux o sous la forme (x,y).

Fonctions membres publiques statiques
static constexpr HPReal	zero ()
	Valeur zéro.
static constexpr HPReal	accumulate (Real a, HPReal b)
static constexpr HPReal	reduce (HPReal a, HPReal b)
static constexpr HPReal	product (HPReal a, HPReal b)
static constexpr HPReal	product (Real a, HPReal b)
static constexpr HPReal	div2 (HPReal a, HPReal b)
static constexpr HPReal	div2 (Real b, HPReal a)

Amis
constexpr bool	operator< (const HPReal &a, const HPReal &b)
constexpr bool	operator> (const HPReal &a, const HPReal &b)
constexpr bool	operator== (const HPReal &a, const HPReal &b)
constexpr bool	operator!= (const HPReal &a, const HPReal &b)
constexpr HPReal	operator+ (const HPReal &a, const HPReal &b)
std::ostream &	operator<< (std::ostream &o, HPReal t)
std::istream &	operator>> (std::istream &i, HPReal &t)

Description détaillée

Classe implémentant un nombre réel de haute précision.

Cette classe est basée sur l'article :

Obtaining identical results with double precision global accuracy on different numbers of processors in parallel particle Monte Carlo simulations (Mathew A. Cleveland, Thomas A. Brunner, Nicholas A. Gentile, jeffrey A. Keasler) in Journal Of Computational Physics 251 (2013) 223-236.

Les opérations possibles sont l'accumulation (opérateur+=()), la réduction (reduce()) et la conversion en Real (toReal()). D'autres opérations telles que la division ou la multiplication ne sont pas possibles.

Pour être conforme au type 'Real' classique, le constructeur par défaut de cette classe n'effectue aucune initialisation.

La méthode toReal() permet de convertir le HPReal en un Real classique. L'utilisation typique est la suivante :

HPReal r(0.0);
ArrayView<Real> x = ...;
for( Integer i=0, n=x.size(); i<n; ++i ){
  // Accumule la valeur
  r += x[i];
}
Real final_r = r.toReal();

Évolution 12/18/18 :

Correction de l'erreur de l'algorithme de base pour HPReal statique _doTwoSum(Real a, Real b)

Real sum_error = (a - (value-approx_b) + (b-approx_b));

est devenu (conformément à la Ref 1)

Real sum_error = (a - (value-approx_b)) + (b-approx_b);

Correction de l'erreur dans HPReal statique _doQuickTwoSum(Real a,Real b)

il est nécessaire de tester si a>b et d'inverser a et b si ce n'est pas le cas (voir Ref 2, 3, 4)

Modification de Accumulate et Reduce, Accumulate et Reduce étaient basés sur la Ref 1, qui est basée sur la Ref 4

Ajout des produits tels que proposés dans la Ref 2 (conformément à la Ref 5) de HPReal*Real ou HPReal*HPReal (nous prenons la même valeur de p pour la fonction SPLIT() que dans la Ref 2, 4, 5)

Notez que le produit Real*Real dans la Ref 4 (p.4) n'est pas écrit de la même manière que ceux dans la Ref 2 (p.2) ou 5 (p.3)

+++++++++++++++++

Globalement, les algorithmes de réduction ou les erreurs accumulées uniquement par addition sont moins bons

L'algorithme 6 de DD_TWOSUM [Ref 2] est également moins bon :

static HPReal accumulate(Real a,MYHPReal b)
{
  HPReal x(_doTwoSum(a,b.value()));
  Real d= x.correction() + b.correction();
  HPReal u(_doQuickTwoSum(x.value(),d));
  return _doQuickTwoSum(u.value(),u.correction());
}

ou

HPReal  reduce(HPReal a,HPReal b)
{
  HPReal x(_doTwoSum(a.value(),b.value()));
  HPReal y(_doTwoSum(a.correction(),b.correction()));
  Real d= x.correction() + y.value();
  HPReal u(_doQuickTwoSum(x.value(),d));
  Real w=y.correction()+u.correction();
  return _doQuickTwoSum(u.value(),w);
}

Des tests sur des millions de valeurs positives ainsi que négatives ont été effectués pour l'addition, la multiplication et la division dans différents ordres.

Je n'ai pas réussi à montrer de différence de résultats dans un cas simple entre l'algorithme proposé pour la somme et celui initialement codé.

Références

Ref 1 Obtaining identical results with double precision global accuracy on different numbers of processors in parallel particle Monte Carlo simulations (Mathew A. Cleveland, Thomas A. Brunner, Nicholas A. Gentile, jeffrey A. Keasler) in Journal Of Computational Physics 251 (2013) 223-236.

Ref 2 Automatic Source-to-Source error compensation of floating-point programs L.Thevenoux, Ph langlois, Mathieu Martel HAL Id: hal-01158399

Ref 3 Numerical validation of compensated summation algorithms withs stochastic arithmetic S.Gaillat, F.Jézéquel , R.Picot Published in Electronic Notes in Theoritical Computer Science

ou

Numerical validation of compensated algorithms withs stochastic arithmetic S.Gaillat, F.Jézéquel , R.Picot Published in Applied Mathematics and Computation 329 (2018)339-363

Ref 4 Library for Double-Double and Quad-Double Arithmetic December 29, 2007 Yozo Hida Xiaoye Li D.H.Bailey

Ref 5 Accurate floating point Product and exponentation S.Graillat HAL ID: hal-00164607

Ref 6 A floating point technique for extending the avaible precision T.J.Dekker Numeri.Math 18, 224-242 (1971)

Définition à la ligne 157 du fichier arccore/src/base/arccore/base/HPReal.h.