Division de grands entiers par un flottant

Bonjour,

Dans un programme je simule actuellement un entier composé de plusieurs entiers non signés de 64 bits.

Je souhaiterai calculer une valeur arrondit à l'unité prêt de la division d'un tel entier par un flottant.

Cependant je ne sais comment faire, j'ai déjà testé une manière de faire qui fonctionnait dans la théorie, mais dans la pratique les doubles et longs doubles ne semblent pas du tout apprécier... si vous le souhaitez je vous la détaille...

C'est pourquoi je viens faire appel à vous, car après quelques recherches je n'ai pas trouvé de travaux semblables. ( par exemple division d'un uint128_t par un flotant... ), et peut-être avez vous connaissance d'algorithmes ou de méthodes prévues pour. :)

Merci d'avance.

J'avais fait une chose similaire mais en divisant par un unsigned long long int[2]

Citation:

---

Diviseur : X
Dividende : Y
Pointeur unsigned long int x
Pointeur unsigned long long int y

En gros :
- Je fait : x = K + (unsigned long int *)&X; Afin d'obtenir le unsigned long int de X de poids le plus fort possible.
y = K' + (unsigned long int *)&Y; Idem
- Tant que X < Y :

- tant que (*x) < (*y)
- je fait : Y -= (*y/*x)*X
- fin tant que;

- y = (unsigned long long int *)(1 - (unsigned long int *)y) //on décale y
- fin tant que

---

C'est une solution que j'avais fait moi-même donc je doute que ce soit la meilleur solution.
Sinon, il me semble qu'il existe des bibliothèques mathématiques qui sont capable de tout faire elles-même.

Merci pour votre réponse,

Cependant je ne vois pas trop le rapport avec mon problème, je ne comprends pas trop comment fonctionne votre algorithme.
( combien valent K et K'? quand est ce que (x) < (y) est satisfait vu que x et y ne changent jamais ? "je fait : Y - (y/x)*X" vous placez le résultat où? )

Mais il divise des entiers par des entiers, mon problème traite d'un grand entier non signé divisé par un flottant.

Et si tu fais un truc du genre :

Code:

---

float resultat = (tonInt * 1.0) / tonFloat;

---

Ca ne marche pas ça? Me semble que j'ai deja fait un truc comme ça :?

J'ai corrigé quelques petites erreurs et il doit sûrement en avoir encore.

K et K' sont à choisir de sorte d'avoir le poids le plus fort possible qui sera pointé pour x et y.

J'aurais peut être dû commencer par cela :

Un flottant est un nombre décimal, il vaut donc :
X/D où X est un entier et D une puissance de 10.

On peut aussi décomposer Y pour faciliter la division :

Soit X = A*B et Y = C*D,
Y/X = (C*D)/(A*B) = C/(A*B) * D

On peut aussi avoir : Y = G + C*D + E*D*D + F*D*D*D
D'où Y/X = G/(A*B) + D*(C/(A*B) + D*(E/(A*B) + D*(F/(A*B))))

Les divisions sont déjà beaucoup plus simples.

@saymoneu : l'entier que le PO manipule sont beaucoup trop grand pour que le processeur sache faire la division en une seule instruction

Citation:

---

Envoyé par saymoneu

Et si tu fais un truc du genre :

Code:

---

float resultat = (tonInt * 1.0) / tonFloat;

---

Ca ne marche pas ça? Me semble que j'ai deja fait un truc comme ça :?

---

Citation:

---

Envoyé par ijatsu;

Dans un programme je simule actuellement un entier composé de plusieurs entiers non signés de 64 bits.

---

Je veux bien mais j'ai pas un entier, mais un "grand" entier, composé de plusieurs entiers de 64 bits.
Et la méthode que j'ai appliqué jusqu'ici a été de diviser seuls chaque entiers, et de répercuter les valeurs décimales de ceux de poids forts vers ceux de poids faibles, mais ça n'a pas marché au niveau des doubles car ils sont trop petits... :/

Citation:

---

Envoyé par Neckara

J'ai corrigé quelques petites erreurs et il doit sûrement en avoir encore.

K et K' sont à choisir de sorte d'avoir le poids le plus fort possible qui sera pointé pour x et y.

J'aurais peut être dû commencer par cela :

Un flottant est un nombre décimal, il vaut donc :
X/D où X est un entier et D une puissance de 10.

On peut aussi décomposer Y pour faciliter la division :

Soit X = A*B et Y = C*D,
Y/X = (C*D)/(A*B) = C/(A*B) * D

On peut aussi avoir : Y = G + C*D + E*D*D + F*D*D*D
D'où Y/X = G/(A*B) + D*(C/(A*B) + D*(E/(A*B) + D*(F/(A*B))))

Les divisions sont déjà beaucoup plus simples.

@saymoneu : l'entier que le PO manipule sont beaucoup trop grand pour que le processeur sache faire la division en une seule instruction

---

Si je comprends bien, vous me proposez de faire une division binaire normale en considérant mon flottant comme un entier, mais tôt ou tard il me faudra nécessaire diviser mon résultat final par la puissance de 10 que j'ai ignoré jusque là, et je retomberai à nouveau sur mon problème actuel. :(

Avec Y = 3,54645 il est possible de faire : Y = 3 54645 * 10^-5
Mais en informatique on préfèrera les puissances de 2
Donc Y = R * 10^-B

En faisant un :

Code:

---

1 2 3 4 5 6 7 8 9 10

int B = 0; float Fbis = F; int R = (int)Fbis; while(R != Fbis) { Fbis *= 2; R = (int)Fbis; B++; }

---

?

Et à la fin tu n'auras plus qu'un décalage de bit à faire.


Après, je suis sûr qu'il y a des bibliothèques qui savent déjà faire cela.

Citation:

---

Envoyé par Neckara

Avec Y = 3,54645 il est possible de faire : Y = 3 54645 * 10^-5
Mais en informatique on préfèrera les puissances de 2
Donc Y = R * 10^-B

En faisant un :

Code:

---

1 2 3 4 5 6 7 8 9 10

int B = 0; float Fbis = F; int R = (int)Fbis; while(R != Fbis) { Fbis *= 2; R = (int)Fbis; B++; }

---

?

Et à la fin tu n'auras plus qu'un décalage de bit à faire.


Après, je suis sûr qu'il y a des bibliothèques qui savent déjà faire cela.

---

Oui c'est la solution idéale et j'y avais déjà pensé mais le problème est que mon float n'arrive jamais à une valeur correcte en le multipliant par 2.

Je pense que si je ne trouve rien de concluant je vais me contenter d'une valeur rapprochée avec cette méthode. ^^

http://fr.wikipedia.org/wiki/IEEE_754

En multipliant par 2, on est obligé d'obtenir un entier au bout d'un moment.

Il faudrait voir s'il existe pas une fonction standard pour récupérer directement la mantisse, l'exposant et le signe séparément et directement, ceci sera beaucoup plus rapide.

Oui c'est vrai! j'avais complètement oublié que la mantisse donnait exactement ce qu'il fallait pour avoir un entier à partir d'un float :roll:, j'étais resté sur le fait que mon nombre d'or était par dans Q.

Il suffit pour un float de multiplier simplement par 2^23
de faire la division binaire
puis de diviser mon gros entier par 2^23 et donc 23 décalages :]

Je pense qu'il y a de quoi faire maintenant. :) merci bien pour votre patience et votre aide!