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

#include <arccore/base/HPReal.h>

Fonctions membres publiques
	HPReal ()
	Constructeur par défaut sans initialisation.
	HPReal (double avalue)
	Crée un HP real avec la valeur value et la correction correction.
	HPReal (double avalue, double acorrection)
	Crée un HP real avec la valeur value et la correction correction.
Real	value () const
	Valeur interne. Généralement, vous devez utiliser toReal().
Real	correction () const
	Correction interne.
void	operator+= (Real v)
	Ajoute un Real tout en préservant l'erreur.
void	operator+= (HPReal v)
	Ajoute un HPReal v tout en préservant l'erreur (réduction).
Real	toReal () const
	Convertit l'instance en un Real.
HPReal	reduce (HPReal b) const
	Ajoute un HPReal v tout en préservant l'erreur (réduction).
void	operator*= (Real v)
	Multiplie un Real tout en préservant l'erreur.
void	operator*= (HPReal v)
	Multiplie un HPReal v tout en préservant l'erreur (réduction).
void	operator/= (Real v)
	Divise un Real tout en préservant l'erreur.
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 HPReal	zero ()
	Valeur zéro.
static HPReal	accumulate (Real a, HPReal b)
static HPReal	reduce (HPReal a, HPReal b)
static HPReal	product (HPReal a, HPReal b)
static HPReal	product (Real a, HPReal b)
static HPReal	div2 (HPReal a, HPReal b)
static HPReal	div2 (Real b, HPReal a)

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 158 du fichier arccore/src/base/arccore/base/HPReal.h.