Discussion :

[panthere noire]

Bonjour,

Je cherche a comprendre et à faire les choses suivantes.

Un simple 2 puissance *128 ou plus avec des opération qui vont bien avec du numérique.
Un moyen de l'afficher ( j'ai penser faire un template)

j'ai ben tester avec plusieurs façon de faire, évidement bloquer à partir de 63 .

Après pas mal de recherche : int64_t ne suffi pas, donc comment on si prend quand cela dépasse ce qui à été prévu.
A par balancer une erreur de capacité , pour le moment dans la libraire standard rien ne semble gérer des chiffre qui
aujourd'hui sont vraiment très petit.

long long int , int64_t etc. est trop petit. Le c++ est il inadapté pour ce genre de calcule ?

j'imagine que des libraires on pris le relai pour corriger cela, cela risque de nuire a la lisibilité et a la portabilité.

voici le code que j'ai fait pour le moment,

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
 
#ifndef PUISSANCE_H
#define PUISSANCE_H
 
#include <iostream>
#include <string>
 
    class Math
    {
    public:
        //constructeur
        Math(int64_t, int64_t);
        uint64_t Result();
    private:
 
        int64_t calcule();
        int64_t numerique   =0;
        int64_t puissance   =0;
    };
#endif

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
37
38
39
40
41
42
43
44
45
46
47
 
#include <iostream>
#include "puissance.h"
template <typename T>
	std::string tostring(const T& t)
	{
		std::ostringstream ss;
		ss << t;
		return ss.str();
 
		/*
		* a tester 
		usage :
			uint64_t data = 123;
			std::string mystring = tostring(data);
		*/
	}
 
	Math::Math(int64_t A, int64_t P) {
		numerique = A;
		puissance = P;
	}
 
	int64_t Math::calcule() {
		uint64_t _cb = 1;
		for (int i = 1; i <= puissance; ++i)
		{
			_cb = numerique * _cb;
			if ( _cb < 1) {
				std::cout << "Erreur depassment de capaciter: " << i <<  " : " << _cb << std::endl;
				return -1;
			}
			else
			{
				std::cout << "DB: " << i << " : " << _cb << std::endl;
			}
 
		}
 
		return _cb;
	}
	uint64_t Math::Result() {
 
		if ((puissance <= 0) || (numerique <= 0)) { return 0; }
 
		return calcule();
	}

Code :

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

1
2
3
4
5
6
7
8
9
10
 
//dans le main
#include <iostream>
#include "puissance.h"
 
    Math _cp1(2,128);
 
    int64_t _count1 = 0;
    _count1 = _cp1.Result();
    std::cout << "Count : " << _count1 << "\n";

Merci d'avance,

[Kannagi]

j'ai ben tester avec plusieurs façon de faire, évidement bloquer à partir de 63 .

Après pas mal de recherche : int64_t ne suffi pas, donc comment on si prend quand cela dépasse ce qui à été prévu.
A par balancer une erreur de capacité , pour le moment dans la libraire standard rien ne semble gérer des chiffre qui
aujourd'hui sont vraiment très petit.

long long int , int64_t etc. est trop petit. Le c++ est il inadapté pour ce genre de calcule ?

Alors cela n'a rien n'a voir avec le C++ , mais avec le processeur qui ne peut pas faire des opérations avec des tailles infinis , actuellement le max est de 64 bits pour les entiers ,et ça risque d’être le cas pendant longtemps.

Si tu veux plus , tu peux utiliser des libs qui sont faite pour celà.

[panthere noire]

Donc rien dans la lib standard, pas moyen de contourner le problème, je vais voir ce que j'arrive a trouver.
je vais laisser le post ouvert car des processeur il en sort assez souvent, quand on vois ce que fait une carte graphique,
je doute quand même que cela ne finisse pas par augmenter. évidement c' est sans rapport.

Merci pour ta réponse.

[foetus]

Le truc c'est que le processeur ne supporte que 64 bits ... parce qu'il est 64 bits

Mais depuis toujours, il y a des "coprocesseurs" pour l'aider : AVX/ AVX512, SSE, SIMD ... AltiVec (Apple PowerPc, Velocity Engine - Apple et VMX - IBM) ... et encore + vieux MMX, 3DNow!

Et côté bibliothèque, je pense qu'il faut utiliser principalement les bibliothèques "grand nombres" (bignum/ bignumber en anglais)

[Kannagi]

je vais laisser le post ouvert car des processeur il en sort assez souvent, quand on vois ce que fait une carte graphique,
je doute quand même que cela ne finisse pas par augmenter. évidement c' est sans rapport.

Ben ,je vois pas le rapport ,les processeurs graphique ne gère pas tous le 64 bits (ou alors de façon parcellaire quand celui ci n'est pas viré tout simplement) , franchement gérer des doubles sur une carte graphique est une vrai plaie
Donc tu peux très bien acheter une CG qui coûte 1000 euros et qui ne gère que du float 32 bits.

Pour les CPU , quel intérêt d'augmenter ça en 128 bits ou 256 bits d'entiers ?

Le soucis , c'est que tu augmente une sacré contrainte CPU de gérer plus grand :
Tu augmente la taille des registres , il y'a plus de 200 registres interne actuellement , et donc ça t'oblige à l'augmenter l'ensemble ,mais aussi que l’accès aux registres devient plus long.
Cela t'oblige à faire un ALU de 128 ou 256 bits , ce qui est assez contraignant (surtout pour le mul et le div ).
Tu as des contraintes qui augmente pour le LSU (load /store).
Le dernier point ,qui montre que tu connais peu les processeurs actuel et que cela casserai la compatibilité pour du x86-64 qui est lui même rétrocompatible avec un processeurs vieux de 40 ans , donc croit moi , le "progrès" dans les CPU actuel , c'est beaucoup de pipeau

Il faut savoir que quand tu crées un CPU , tu vas te baser sur le cas le plus courant ,et le cas rare ,ben faut mieux qu'il soit un peu plus long ,plutôt que cela te prend + 20/30% de die pour le gérer + la complexité qui va avec
D'ailleurs pour cela que en interne tu as certain CPU qui ont des ALU de 64bits et 32 bits, parce que le 32 bits est le cas le plus courant.

Donc oui je t'assure que cela ne risque vraiment pas d'augmenter , c'est de toute façon pas la priorité des constructeurs actuellement d'augmenter ce point là.
Surtout qu'on n'est pas passé en 64 bits pour gérer des nombres 64 bits , mais pour pouvoir gérer plus de 4 Go de RAM.
Et comme en 64 bits on peut gérer 18 milliards de Go , pas demain la veille qu'on va changer

Le truc c'est que le processeur ne supporte que 64 bits ... parce qu'il est 64 bits

Mais depuis toujours, il y a des "coprocesseurs" pour l'aider : AVX/ AVX512, SSE, SIMD ... AltiVec (Apple PowerPc, Velocity Engine - Apple et VMX - IBM) ... et encore + vieux MMX, 3DNow!

Alors à ma connaissance le AVX/SSE , c'est plus pour gérer des vector par exemple 32 bits x4 ou 64 bits x 4.
Après y'a peut être des instructions pour gérer des big entiers (a ma connaissance non , mais j'ai la flemme de vérifier les + 100/200 instructions ) , mais c'est assez rare d'avoir ça en SIMD.

[foetus]

Alors à ma connaissance le AVX/SSE , c'est plus pour gérer des vector par exemple 32 bits x4 ou 64 bits x 4.
Après y'a peut être des instructions pour gérer des big entiers (a ma connaissance non , mais j'ai la flemme de vérifier les + 100/200 instructions ) , mais c'est assez rare d'avoir ça en SIMD.

Ouais tu as raison : manque de retenu, pas d'addition/ soustraction en 128bits, pas de multiplication en 64x64
Mais apparemment, tu peux bidouiller 1 truc avec AVX512-IFMA ou en vectorisant avec l'algo Fast-Fourier Transforms ... comme quoi AVX-512 sert, n'en déplaise à L. Torvald

Can long integer routines benefit from SSE?, lien stackoverflow en anglais