Discussion :

[zvib4012]

Bonjour,
j'ai besoin d'utiliser une librarire qui permet des calculs en précision arbitraire et également de pouvoir calculer des exponentielles et logarithme de ces nombres.
J'ai trouvé ça: http://www.hvks.com/Numerical/arbitrary_precision.htm. Et j'ai voulu l'inclure dans mon code. Mais j'ai des problèmes de compilation, le compilateur se demande quel opérateur il doit utiliser. Voici les erreurs de compilation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
tables.cpp:431: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
/usr/include/c++/4.1.3/istream:201: note: candidat 1: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(double&) [with _CharT = char, _Traits = std::char_traits<char>]
iprecision.h:1366: note: candidat 2: int_precision operator>>(const _Ty&, const int_precision&) [with _Ty = std::ifstream]
tables.cpp: In member function «void TwoDRowVectorTable::save(std::ostream&, Str2IdMap&)":
tables.cpp:450: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
/usr/include/c++/4.1.3/bits/ostream.tcc:361: note: candidat 1: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
iprecision.h:1331: note: candidat 2: int_precision operator<<(const _Ty&, const int_precision&) [with _Ty = std::ofstream]

Les fonctions incriminées dans mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void TwoDRowVectorTable::load(istream& file, Str2IdMap& str2id)
{
  string name1, name2;
  double mean,sigma,weight;
  RowVector newVector =  RowVector(sizeDescSpace); 
  while (file>>name1>>name2>>weight) {
  int i = 1; 
  ifstream vectFile(name2.c_str());
 
  while (vectFile>>mean>>sigma) {
    newVector(i) = mean;
    i++;
  }
  add(str2id.getId(name1), str2id.getId(name2), newVector);
  }
}
 
void TwoDRowVectorTable::save(ostream& file, Str2IdMap& str2id)
{
  int k;
  for (TwoDRowVectorTable::iterator i = begin(); i!=end(); i++) {
    OneDRowVectorTable& vals = *i->second;
    for (OneDRowVectorTable::iterator it = vals.begin(); it!=vals.end(); it++) {
      string fileName = str2id.getStr(it->first)+".mean";
      ofstream vectFile(fileName.c_str());
      for(k = 1; k<= it->second.Ncols(); k++) {
	 vectFile << (double)exp(it->second(k)) << endl;
      }
  }
  }
}

et les fonctions de la bibliothèque:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
template <class _Ty> inline int_precision operator<<( int_precision& lhs, const _Ty& rhs )
   {
   return int_precision(lhs) <<= rhs; 
   }
 
template <class _Ty> inline int_precision operator<<(  const _Ty& lhs, const int_precision& rhs )
   {
   return int_precision(lhs) <<= rhs; 
   }
 
 
template <class _Ty> inline int_precision operator>>( int_precision& lhs, const _Ty& rhs )
   {
   return int_precision(lhs) >>= rhs; 
   }
 
template <class _Ty> inline int_precision operator>>( const _Ty& lhs, const int_precision& rhs )
   {
   return int_precision(lhs) >>= rhs; 
   }

Voila, si vous avez des explications quant au problème ou si vous connaissez d'autres lib qui permettent de faire ce que je veux (BigNum ne le permet pas)

Merci

[Feriaman]

Salut,

Hélas, je ne connais pas grand chose au calcul en précision arbitraire. Je ne peux en particulier pas te conseiller d'autres librairies.

Tout ce que je peux faire c'est expliquer l'erreur. Il s'agit d'un conflit entre deux définitions de l'opérateur ">>"

lorsque tu écris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
istream& file;
double weight;
file>>weight;

Le premier est définit par la stl, pour l'utilisation suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

une_istream >> un_double

La seconde est définit par ta librairie pour l'utilisation suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

n_importe_quoi >> un_int_precision

je soupçonne donc qu'il existe une forme quelconque de parenté entre "double" et "int_precision", mais je ne peux que conjecturer.

En admettant que ta librairie gère la lecture dans un istream, et que l'operateur >> serve à cela, tu as peut-être un moyen facile de résoudre ton problème, c'est de remplacer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

file>>name1>>name2>>weight

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int_precision(file>>name1>>name2)>>=weight

.

Si par contre ta librairie ne gère pas la lecture dans un istream, et bien tu es bon pour changer de librairie ou pour coder cette fonctionnalité.

Si ta librairie gère la lecture dans un istream mais pas avec l'opérateur >>, et bien tu n'as plus qu'à te renseigner sur l'api de ta librairie.

Bonne chance et tiens nous au courant

[zvib4012]

Merci de ta réponse, ma libraire gère la lecture de istream avec l'opérateur >>.

Ce que je ne comprend pas c'est que les objets dans lesquels je mets ce que je lis sont de type double et je veux utiliser la lecture normale en double et pas en précision arbitraire a ce moment la du code.

Comment préciser que je veux que la lecture se fasse en double comme tu me l'as expliqué pour int_precision?

[zvib4012]

Bon j'ai réussi a regler quelques soucis. Si je mets dans mes fonctions des istream (resp. ostream) au lieu des ifstream (resp. ofstream) ca marche.
Mais maintenant j'ai un souci dans une autre librairie et cette fois avec les opérateurs+ - etc...
Pourquoi le compilateur s'intéresse aux opérateurs de mon type int_precision même si il n'y a aucun int_precision dans le code?...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
girl/girlDirection.inl: In function «girlDirection girlDirection_previous(girlDirection)":
girl/girl/girlDirection.inl:13: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
girl/girl/girlDirection.inl:13: note: candidat 1: operator+(int, int) <construit-interne>
iprecision.h:1043: note: candidat 2: int_precision operator+(const _Ty&, const int_precision&) [with _Ty = girlDirection]
girl/girl/girlDirection.inl:13: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
girl/girl/girlDirection.inl:13: note: candidat 1: operator+(int, int) <construit-interne>
iprecision.h:1043: note: candidat 2: int_precision operator+(const _Ty&, const int_precision&) [with _Ty = girlDirection]
girl/girl/girlDirection.inl: In function «girlDirection girlDirection_next(girlDirection)":
girl/girl/girlDirection.inl:20: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
girl/girl/girlDirection.inl:20: note: candidat 1: operator-(int, int) <construit-interne>
iprecision.h:1133: note: candidat 2: int_precision operator-(const _Ty&, const int_precision&) [with _Ty = girlDirection]
girl/girl/girlDirection.inl:20: erreur: ISO C++ indique qu'ils sont ambiguës même à travers la plus mauvaise conversion pour le premier que la plus mauvaise pour la seconde:
girl/girl/girlDirection.inl:20: note: candidat 1: operator-(int, int) <construit-interne>
iprecision.h:1133: note: candidat 2: int_precision operator-(const _Ty&, const int_precision&) [with _Ty = girlDirection]

[Feriaman]

Pourquoi le compilateur s'intéresse aux opérateurs de mon type int_precision même si il n'y a aucun int_precision dans le code?

je soupçonne donc qu'il existe une forme quelconque de parenté entre "double" et "int_precision", mais je ne peux que conjecturer.

Je ne connais pas cette lib, mais toi qui a les en-tête, tu dois pouvoir répondre à cette question.

Je subodore que quelque part se trouve un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class int_precision
{
	operator double (void)
	{
		...
	}
}

ou quelques chose de plus trash comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define double int_precision<double>

Il n'est pas impossible que tes problèmes viennent d'une mauvaise utilisation de la librairie. La doc de ta librairie ne contient-elle pas un chapitre "utilisation conjointe de précision arbitraire et de précision usuelles" ?

Puisque tu ne semble pas utiliser ta librairie partout, est-ce que tu ne peux pas isoler les inclusions des en-têtes de ta librairies afin qu'elles ne perturbent pas le reste de ton programme ?

[zvib4012]

Exact. Je trouve tout ça dans la librairie:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
// Implict conversion operators
      operator long() const;
      operator int() const;
      operator short() const;
      operator char() const;
      operator unsigned long() const;
      operator unsigned int() const;
      operator unsigned short() const;
      operator unsigned char() const;
      operator double() const; 
      operator float() const;

Pour la doc, elle consiste plus en un manuel d'utilisation que reellement une doc.
Pour les includes non plus, les calculs en precision arbitraire doivent se faire dans une classe qui contient plein d'autres fonctions. Et même si je passe tout en précision arbitraire il faudrait que je modifie d'autres librairies...

Maintenant le soucis, c'est la somme de deux entiers!

[Feriaman]

Et bien voilà, tu sais à quoi t'en tenir.

Quand tu utilises ta librairie, int_precision peut être casté implicitement en double, int etc.

Du coup, dès qu'il y a un doute sur un opérateur qui implique l'un de ces types et pour lequel les types ne sont pas exactement définis, ton compilo ne sait pas s'il doit utiliser un int_precision ou pas.

Soit tu fais très attention en codant, de ne lui donner que des choses qu'il saura résoudre, c'est à dire qu'à chaque fois tu comprends entre quoi et quoi il hésite et que tu lui dit ce que tu préfères qu'il utilise, ce qui peut éventuellement passer par la lecture approfondie d'une doc qui devrait exister pour la manipulation d'une lib si touchy, soit tu change de lib pour une qui sera, si ce n'est plus performante, au moins mieux documentée.

Bonne chance