Discussion :

[Abstrus]

Bonjour,
J'ai arpenté les tutoriel et plusieurs pages de forum sans vraiment trouver de réponse à mon problème. N'hésitez pas à me rediriger si je suis simplement passé par dessus la réponse sans la voir !
Je m'adresse à vous ajourd'hui puisque mes professeurs sont plutôt légers sur les réponses (je suis le cours à distance, tout se fait par internet... pas facile pour la communication !), surtout si celles-ci creusent un peu plus profondément que le contenu explicite du cours. Je tiens à spécifier que je suis un apprenti programmeur, j'ai commencé en janvier en fait... Ma question concerne un travail qui est déjà remis, donc je ne cherche pas à vous faire faire mes devoirs .
Je programmais une "course" entre 6 méthodes pour calculer pi (Liebniz, Wallis, Brouncker...) pour déterminer laquelle arrivait à la précision voulue (16 décimales) avec le moins de tours de boucles (exemple, de fractions superposées (continues) dans le cas de l'algorithme de Brouncker). J'étais restreint aux bibliothèques stdio et math, je ne pouvais pas utiliser de tableau (donc de chaines de caractères...) et je dois travailler avec Visual Studio (2005, dans mon cas).
Je me suis rendu compte que j'avais besoin de stocker mes résultats dans un long double. Mes notes de cours sont explicites: double jusqu'à 64 bits (15 décimales significatives) et long double 80 bits (19 décimales).
Jamais aucun des 6 algorithmes n'a atteint la valeur de pi de référence. Je crois avoir trouvé la réponse sur MSDA où il est décrit que sous Visual Studio, le long double est égal au double (64 bits). Il me manquerait donc de la précision possible pour y faire tenir ma référence de 16 décimales. Même si mon travail est remis, je pense que c'est un bon défi à relever.. et je continue de chercher !

Mes questions (eh oui, pluriel...)
-Selon vous, ai-je bien cerné mon problème (grandeur de type) ?

-Officiellement, je ne peux pas me créer un type de variable personnalisé (contrainte du cours), surtout que je ne l'ai pas encore appris. Pour satisfaire ma curiosité, pouvez-vous me rediriger vers un tutoriel pour créer des types personnalisés sous VS2005 ?

-Si j'ai bien compris, une fois mon code compilé, si j'ai attribué 80 bits à une variable dans un compilateur qui le supporte, le programme devrais être portable, n'est-ce pas ?

-J'aurais besoin d'éclaircissements par rapport à la portabilité de programmes en C d'un SE à l'autre (différentes distributions Linux, différentes éditions Windows, Mac OSx...). Avez-vous un tutoriel pour ça ?

Si vous avez besoin d'un bout de code, ne vous gênez pas. Je peux aussi poster les liens vers MSDA. J'ai lu qu'on suggèrait minimiser les liens et le code, alors je me suis abstenu . Oh, si ça peut changer quelque chose, je suis sur un x86-64, mais mon Vista Home Basic est un système 32 bits.

Merci beaucoup d'avance !!

[Melem]

Mes notes de cours sont explicites: double jusqu'à 64 bits (15 décimales significatives) et long double 80 bits (19 décimales).

La norme du langage C n'impose pas du tout ces valeurs. Tes cours suppose certainement que tu utilises un compilateur particulier, je ne sais pas lequel.

Officiellement, je ne peux pas me créer un type de variable personnalisé (contrainte du cours), surtout que je ne l'ai pas encore appris. Pour satisfaire ma curiosité, pouvez-vous me rediriger vers un tutoriel pour créer des types personnalisés sous VS2005 ?

C'est d'un truc comme ceci que tu parles : Opération sur des grands nombres ?

Si j'ai bien compris, une fois mon code compilé, si j'ai attribué 80 bits à une variable dans un compilateur qui le supporte, le programme devrais être portable, n'est-ce pas ?

Un programme compilé est exécutable, donc normal qu'il s'exécutera . Le système s'en fiche complètement de savoir avec quel compilateur ce programme a été compilé ...

J'aurais besoin d'éclaircissements par rapport à la portabilité de programmes en C d'un SE à l'autre (différentes distributions Linux, différentes éditions Windows, Mac OSx...). Avez-vous un tutoriel pour ça ?

Le langage C lui-même est portable (ne possède aucune fonctionnalité spécifique à un matériel ou à un système d'exploitation particulier). Chaque implémenteur (constructeur de compilateur) peut toutefois ajouter d'ajouter des fonctionnalités que tu n'es forcément pas obligé de toujours utiliser. Tout compilateur C doit également être accompagnée d'une bibliothèque dite "standard" afin de permettre aux programmeurs de développer facilement des applications portables. Une application portable est une application dont le code source peut être compilé pour n'importe quelle système. Un programme, une fois compilé, n'est exécutable que sur le système pour lequel il a été compilé. Un .exe ne peut fonctionner sous Linux comme un ELF e peut fonctionner sous Windows, sauf par émulation ...

[Gui13]

Salut,

Une astuce qui pourrait t'aiguiller serait de mettre quelquepart dans ton code:

Code :

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

printf("Taille d'un long double: %d\n",sizeof(long double));

.

Il t'affichera la taille (en octets) du type "long double".

[Abstrus]

D'abord, merci pour ces réponses et bravo pour la rapidité !

La norme du langage C n'impose pas du tout ces valeurs. Tes cours suppose certainement que tu utilises un compilateur particulier, je ne sais pas lequel.

En effet ! Il est prix pour acquis que j'utilise Visual Studio (on me propose Vs 6, j'ai préféré 2005 qui était plus facile (à première vue du moins) à faire rouler sous Vista) Je n'ai pas l'obligation d'utiliser ce compilateur, je dois seulement être compatible ANSI.

C'est d'un truc comme ceci que tu parles : Opération sur des grands nombres ?

Non, pas exactement. Je commence les chaîne de caractère la semaine prochaine seulement dans mon cours... et l'allocation dynamique seulement à la prochaine session (probablement en mai). Je pensais plutôt à produire une bibliothèque contenant, exemple, le type "abusif long double" qui se représente en nombre à virgule flottante IEEE comme n'importe quel float, mais sur 160 bits (par exemple, je répète). À moins que ce soit par configuration directe dans les options du compilateurs ? Je comprends que ce n'est pas a priori utile de s'amuser à fabriquer de nouveau type, surtout s'il faut les expliquer à chaque personnes qui consulte le code ! C'était plutôt par curiosité...

Une application portable est une application dont le code source peut être compilé pour n'importe quelle système. Un programme, une fois compilé, n'est exécutable que sur le système pour lequel il a été compilé. Un .exe ne peut fonctionner sous Linux comme un ELF e peut fonctionner sous Windows, sauf par émulation ...

Voilà qui m'éclaire encore ! Je vais continuer à essayer d'installer gcc sous cygwin pour faire des tests, en attendant un éventuel dual boot windows/linux. Il me manque encore quelques notions, mais ce n'est pas l'endroit pour ce sujet.

Salut,

Une astuce qui pourrait t'aiguiller serait de mettre quelquepart dans ton code:
Code :

printf("Taille d'un long double: %d\n",sizeof(long double));

.

Il t'affichera la taille (en octets) du type "long double".

En effet, le long double mesure bien 8 octets que je l'avais craint sous Visual Studio...

Je me demande encore comment avoir un vrai long double de 10 octets ! Il me faudra un autre compilateur, si j'ai bien compris.

Encore un petit détail. Je me demande se qu'un double peut vraiment tenir. Je veux dire, prennez par exemple 1/3 en décimale ne se représentera jamais bien. Si je veux faire tenir pi (dans mon cas pour ce travail : 3.1415926535897932, 16 décimales) est-ce possible dans un double sur 8 octets ? Ma question vient du fait que, si je prends l'algorithme de John Wallis pour calculer pi, traduit comme suis (attention aux yeux...):

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
32
33
34
35
36
{
	int n;
	long double piA = 0;
	long double piB = 0;
	long double pi = 0;
 
	for (n = 1 ; n <= i ; n++)
	{
		if ((n % 2) == 1)
		{
			piA +=(( 1.0 / (2 * n - 1)) * ( 1.0 / pow(5, (2 * n - 1)) ));
		}
		else
		{
			piA -=(( 1.0 / (2 * n - 1)) * ( 1.0 / pow(5, (2 * n - 1)) ));
		}
	}
	piA *= 16;
 
	for (n = 1 ; n <= i ; n++)
	{
		if ((n % 2) == 1)
		{
			piB +=(( 1.0 / (2 * n - 1)) * ( 1.0 / pow(239, (2 * n - 1)) ));
		}
		else
		{
			piB -=(( 1.0 / (2 * n - 1)) * ( 1.0 / pow(239, (2 * n - 1)) ));
		}
	}
	piB *= 4;
 
	pi = piA - piB;
 
	return test(pi);
}

après la 11eme boucle, si je me souvient bien, la valeur ne change plus, reste à 3.141592653589794 (15 décimales). Je n'atteins jamais plus de précision. Serais-ce limité par le long double ? Remarquez que sous Visual Studio, long double ou double, c'est pareil...
Vous pouvez en profitez pour critiquer ma technique .

Merci infiniment !

[Médinoc]

Plutôt que gcc sous Cygwin, tu peux aussi prendre MinGW, qui mettra bien en évidence certains problèmes de long double:
En effet, il utilise des long double de 80 bits, mais les fonctions C de Visual Studio, ce qui rend impossible d'afficher un long double avec printf().

[Jean-Marc.Bourguet]

Les flottants sont generalement bases sur des puissances de 2. Voir par exemple http://www.bourguet.org/v2/clang/libc90/float.html. Beaucoup plus complet, mais en anglais: http://docs.sun.com/source/806-3568/ncg_goldberg.html