Classe implémentant un réel Haute Précision. Plus de détails...

#include <arcane/utils/HPReal.h>

Graphe de collaboration de Arcane::HPReal:

Fonctions membres publiques
	HPReal ()
	Constructeur par défaut sans initialisation.

	HPReal (double avalue)
	Créé un réel HP avec la valeur value et la correction correction.

	HPReal (double avalue, double acorrection)
	Créé un réel HP avec la valeur value et la correction correction.

Real	value () const
	Valeur interne. En général, il faut utiliser toReal()

Real	correction () const
	Correction interne.

void	operator+= (Real v)
	Ajoute un Real en conservant l'erreur.

void	operator+= (HPReal v)
	Ajoute un HPReal v en conservant l'erreur (réduction)

Real	toReal () const
	Converti l'instance en un Real.

HPReal	reduce (HPReal b) const
	Ajoute un HPReal v en conservant l'erreur (réduction)

void	operator*= (Real v)
	multiplie un Real en conservant l'erreur.

void	operator*= (HPReal v)
	multiplie un HPReal v en conservant l'erreur (réduction)

void	operator/= (Real v)
	multiplie un Real en conservant l'erreur.

void	operator/= (HPReal v)
	multiplie un HPReal v en conservant l'erreur (réduction)

std::istream &	assign (std::istream &i)
	Lit un HPReal sur le flot i. Le couple est lu sous la forme de deux valeurs de type #Real.

std::ostream &	print (std::ostream &o) const
	Ecrit l'instance sur le flot o lisible par un assign()

std::ostream &	printPretty (std::ostream &o) const
	Ecrit l'instance sur le flot 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 réel 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 (operator+=()), la réduction (reduce()) et la conversion vers un Real (toReal()). Il n'est pas possible de faire d'autres opérations telles que les divisions où les multiplications.

Pour se conformer au type 'Real' classique, le constructeur par défaut de cette classe ne fait aucune initialisation.

La méthode toReal() permet de convertir le HPReal en un Réel classique. Le fonctionnement typique est le suivant:

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();

Evolution 12/18/18 :

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

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

est devenu (en accord avec la Ref 1)

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

Correction erreur de static HPReal _doQuickTwoSum(Real a,Real b)

il faut tester si a>b et inverser a et b si cela n'est pas le cas (voir Ref 2,3,4)

Modification de Accumulate et de Reduce, Accumulate et de Reduce etaient basées sur la Ref 1 qui a pour base la Ref 4

Ajout des produits comme proposés dans la ref 2 (en accord avec la Ref 5) de HPReal*Real ou HPreal*HPreal (on prend la meme valeur de p pour la fonction SPLIT() que la Ref 2,4,5)

Attention le produit Real*Real de la Ref 4 (p.4) n'est pas ecrit de la meme facon que celui de la Ref 2 (p.2), 5 (p.3)

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

Globalement les algo de reductions ou les erreurs sont cumulées uniquement avec une addition sont moins bons

L'algo 6 de DD_TWOSUM [Ref 2] est aussi 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 comme négatives ont été effectués pour l'additon,la multiplication et la division dans des ordres différents.

Je n'ai pas réussi à faire apparaitre dans un cas simple une différence de resultat entre l'algo proposée pour la somme et celui code initialement.

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 160 du fichier HPReal.h.

Documentation des constructeurs et destructeur

◆ HPReal() [1/3]

Arcane::HPReal::HPReal ( )

inline

Constructeur par défaut sans initialisation.

Définition à la ligne 166 du fichier HPReal.h.

◆ HPReal() [2/3]

Arcane::HPReal::HPReal ( double avalue )

inlineexplicit

Créé un réel HP avec la valeur value et la correction correction.

Définition à la ligne 169 du fichier HPReal.h.

◆ HPReal() [3/3]

Arcane::HPReal::HPReal	(	double	avalue,
		double	acorrection
	)

inline

Créé un réel HP avec la valeur value et la correction correction.

Définition à la ligne 175 du fichier HPReal.h.

Documentation des fonctions membres

◆ accumulate()

static HPReal Arcane::HPReal::accumulate	(	Real	a,
		HPReal	b
	)

inlinestatic

Définition à la ligne 249 du fichier HPReal.h.

◆ assign()

std::istream & Arcane::HPReal::assign ( std::istream & i )

Lit un HPReal sur le flot i. Le couple est lu sous la forme de deux valeurs de type #Real.

Définition à la ligne 26 du fichier HPReal.cc.

◆ correction()

Real Arcane::HPReal::correction ( ) const

inline

Correction interne.

Définition à la ligne 184 du fichier HPReal.h.

◆ div2() [1/2]

static HPReal Arcane::HPReal::div2	(	HPReal	a,
		HPReal	b
	)

inlinestatic

Définition à la ligne 283 du fichier HPReal.h.

◆ div2() [2/2]

static HPReal Arcane::HPReal::div2	(	Real	b,
		HPReal	a
	)

inlinestatic

Définition à la ligne 291 du fichier HPReal.h.

◆ operator*=() [1/2]

void Arcane::HPReal::operator*= ( HPReal v )

inline

multiplie un HPReal v en conservant l'erreur (réduction)

Définition à la ligne 217 du fichier HPReal.h.

◆ operator*=() [2/2]

void Arcane::HPReal::operator*= ( Real v )

inline

multiplie un Real en conservant l'erreur.

Définition à la ligne 211 du fichier HPReal.h.

◆ operator+=() [1/2]

void Arcane::HPReal::operator+= ( HPReal v )

inline

Ajoute un HPReal v en conservant l'erreur (réduction)

Définition à la ligne 193 du fichier HPReal.h.

◆ operator+=() [2/2]

void Arcane::HPReal::operator+= ( Real v )

inline

Ajoute un Real en conservant l'erreur.

Définition à la ligne 187 du fichier HPReal.h.

◆ operator/=() [1/2]

void Arcane::HPReal::operator/= ( HPReal v )

inline

multiplie un HPReal v en conservant l'erreur (réduction)

Définition à la ligne 229 du fichier HPReal.h.

◆ operator/=() [2/2]

void Arcane::HPReal::operator/= ( Real v )

inline

multiplie un Real en conservant l'erreur.

Définition à la ligne 223 du fichier HPReal.h.

◆ print()

std::ostream & Arcane::HPReal::print ( std::ostream & o ) const

Ecrit l'instance sur le flot o lisible par un assign()

Définition à la ligne 36 du fichier HPReal.cc.

◆ printPretty()

std::ostream & Arcane::HPReal::printPretty ( std::ostream & o ) const

Ecrit l'instance sur le flot o sous la forme (x,y)

Définition à la ligne 46 du fichier HPReal.cc.

◆ product() [1/2]

static HPReal Arcane::HPReal::product	(	HPReal	a,
		HPReal	b
	)

inlinestatic

Définition à la ligne 265 du fichier HPReal.h.

◆ product() [2/2]

static HPReal Arcane::HPReal::product	(	Real	a,
		HPReal	b
	)

inlinestatic

Définition à la ligne 272 du fichier HPReal.h.

◆ reduce() [1/2]

static HPReal Arcane::HPReal::reduce	(	HPReal	a,
		HPReal	b
	)

inlinestatic

Définition à la ligne 257 du fichier HPReal.h.

◆ reduce() [2/2]

HPReal Arcane::HPReal::reduce ( HPReal b ) const

inline

Ajoute un HPReal v en conservant l'erreur (réduction)

Définition à la ligne 205 du fichier HPReal.h.

◆ toReal()

Real Arcane::HPReal::toReal ( ) const

inline

Converti l'instance en un Real.

Définition à la ligne 199 du fichier HPReal.h.

◆ value()

Real Arcane::HPReal::value ( ) const

inline

Valeur interne. En général, il faut utiliser toReal()

Définition à la ligne 181 du fichier HPReal.h.

◆ zero()

static HPReal Arcane::HPReal::zero ( )

inlinestatic

Valeur zéro.

Définition à la ligne 246 du fichier HPReal.h.

La documentation de cette classe a été générée à partir des fichiers suivants :

Fonctions membres publiques

Fonctions membres publiques statiques

Description détaillée

Références

Documentation des constructeurs et destructeur

◆ HPReal() [1/3]

◆ HPReal() [2/3]

◆ HPReal() [3/3]

Documentation des fonctions membres

◆ accumulate()

◆ assign()

◆ correction()

◆ div2() [1/2]

◆ div2() [2/2]

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator/=() [1/2]

◆ operator/=() [2/2]

◆ print()

◆ printPretty()

◆ product() [1/2]

◆ product() [2/2]

◆ reduce() [1/2]

◆ reduce() [2/2]

◆ toReal()

◆ value()

◆ zero()