Discussion :

[Rekin85]

Bonjour,

Je vous propose un nouvel élément à utiliser : Bibliothèques de routines de calculs pour les nombres entiers géants

NewGInt et NewGCent sont deux bibliothèques sous forme d'unités .pas s'intégrant parfaitement à vos programmes Delphi compilés en 32 bits. Elles permettent toutes manipulations calculatoires sur des nombres entiers géants sans limite de taille (sauf capacité matérielle), l'une en base 256 et l'autre en base 100.



Les deux fichiers .pas sont accompagnés dans le zip par une notice pour en saisir toute la philosophie et s'en approprier les nombreuses procédures et fonctions qu'elles contiennent.

Qu'en pensez-vous ?

[Gilbert Geyer]

Bonjour,

Rekin85 : Qu'en pensez-vous ?

Le ZIP est vide ... Sinon le sujet est intéressant.

A+.

[tourlourou]

Bonjour Gilbert,

Certes vide, mais René a dû recevoir un message à ce sujet pour le téléverser à nouveau. Et pê ajouter un titre au bouton de téléchargement !

Bon code,
Yves.

[Rekin85]

Effectivement Gilbert, le Zip est vide !... Et je ne parviens pas à le déposer à nouveau : je ne trouve aucune possibilité pour revenir dessus... Désolé...

En attendant, je place le fameux Zip ici en pièce jointe.

NewUnits.zip

Bonjour Yves,

Effectivement, je veux bien faire ce que Alcatiz et toi m'ont suggéré, mais comment ? Faut-il redéposer une nouvelle mouture complète ? Et alors, comment supprimer l'ancienne ? Je ne parviens pas à trouver une voie pour parvenir à modifier ce qui est déposé.

[Alcatîz]

L'archive est de nouveau téléchargeable.

Ne vois-tu pas le bouton d'édition tel qu'à gauche sur cette image ?

[Rekin85]

Bonjour Alcatiz,

Effectivement les icônes d'édition et suppression sont bien présentes et même les popups explicatifs de chacun. Je ne sais que dire ou faire pour obtenir des excuses : mea culpa ! Il faut dire qu'innocemment je voulais trouver un bouton explicite avec la mention "Editer" ou "Mettre à jour". A ma décharge, je reconnais ne pas être un habitué de la rubrique.

Les unités sont maintenant téléchargeables et je souhaite à tous les amateurs éventuels de bien coder avec et d'en tirer toutes satisfactions.

J'en profite pour signaler que le dossier contient dans un zip aussi un exécutable dénommé "Calculator". C'est une calculette créée pour illustrer quelques possibilités offertes par l'unité NewGInt sans plus.

[Alcatîz]

Je ne sais que dire ou faire pour obtenir des excuses : mea culpa !

Non, surtout pas, c'est plutôt à nous de te remercier de proposer des ressources de qualité !

[Roland Chastain]

Bonjour !

Pour ceux qui (comme moi) ne connaissent pas l'assembleur, le code est impossible à étudier, d'autant qu'il est plutôt volumineux (presque 4000 lignes pour la seule unité NewGint) mais il a l'air très efficace. Félicitations !

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
program Fibonacci;
{$APPTYPE CONSOLE}
 
uses
  NewGInt;
 
const
  N = 10000;
 
var
  a: array[0..N]of GInt;
  i: integer;
 
begin
  a[0] := FStrToGInt('0');
  a[1] := FStrToGInt('1');
 
  for i := 2 to N do
    a[i] := FAddGInt(a[i - 1], a[i - 2]);
 
  WriteLn(FGIntToStr(a[N]));
  ReadLn;
end.

Testé avec Delphi 7 sous Windows 8.1.

[Rekin85]

Bonjour Roland,

Bien vu le calcul du N^ième de la suite de Fibonacci. Merci pour le test.

Mais je me dois de faire une petite remarque : la capacité mémoire de la machine ! Avec les GInt et encore plus avec les GCent, dans les processus itératifs, on ne se rend pas toujours bien compte des kyrielles d'octets que les routines doivent manipuler et garder. Ainsi dans ton exemple, tu utilises un array qui, si on pousse les demandes de résultats va vite crier grâce...

Je reviens à ce que je préconise dans la notice d'accompagnement : la simplicité du code. Ainsi pour ton exemple, ne garder que les deux derniers GInt pour toute la suite des calculs. Moi, voici ce que j'ai cogité :

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
function Fibonacci(N: longword): GInt;
var
  Nb1,Nb2,Nb3: GInt;
  i: integer;
begin
  Nb3:=FGIntNul;
  Nb1:=FGIntNul;
  Nb2:=FIntToGInt(1);
  for i:=1 to N do begin
      Nb3:=FAddGInt(Nb2,Nb1);
      Nb1:=FCopyGInt(Nb2);
      Nb2:=FCopyGInt(Nb3);
  end;
  Result:=Nb3;
end;
 
 
procedure TForm1.Button1Click(Sender: TObject);
var Nb: GInt;
begin
   Nb:=Fibonacci(100000);
   Showmessage(FGIntToStr(Nb));
end;

En l'occurence, ici le 100 000 ^ième de Fibonacci est un GInt de plus de 8000 octets. Certes, les recopies bouffent du temps, mais garantissent le processus.

Oui, l'ASM... C'est le lot des routines basiques si on veut qu'elles soient suffisamment efficientes...

[Roland Chastain]

Merci pour les explications et l'exemple.

[Gilbert Geyer]

Bonjour,

Rekin85 : Mais je me dois de faire une petite remarque : la capacité mémoire de la machine ! Avec les GInt et encore plus avec les GCent, dans les processus itératifs, on ne se rend pas toujours bien compte des kyrielles d'octets que les routines doivent manipuler et garder. Ainsi dans ton exemple, tu utilises un array qui, si on pousse les demandes de résultats va vite crier grâce...

Absolument d'accord René, mais comme Roland Chastain s'intéresse peut-être également aux GCent j'en profite pour signaler un avantage qui distingue les GCent des GInt :
Comme les GCent sont des string codées en base 100 on peut à tout moment savoir (via le Result de la function IsDiv10GCent(Nv: GCent; var P10: boolean): longword) le nombre de 0 terminaux de la string lorsque la var P10 Renvoie true quand Nv=10^N ce qui permet de créer un troisième type de variables comme par exemple :

Code :

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

1
2
3
4
5
type tMonType = record
              Signe : Char;    //< si besoin est
              Nv     : GCent;  //< chaîne numérique représentée en base 100 expurgée des puissances de 10 
              Expo  : Int64;   //< accumulateur des puissances de 10, qui permet en plus de déterminer la position de la virgule si on veut utiliser les GCent pour des calculs avec des Grands Réels ou des Réels lilliputiens.
              end;

et avec des variables de ce type dès que le GCent Nv contient des zéros terminaux on peut illico raccourcir la longueur du GCent et reporter les puissances de 10 dans Expo d'où gains de vitesse + gains de Ram disponible.

Exemple pour Factorielle(1234567) = 621590586471231550926149008331891933156379855913769E6984170
en plus un tel résultat s'affiche sur une seule et unique ligne alors qu'en affichant le même nombre non expurgé des puissances de 10, celui-ci avec ses 6984170 zéros occupe ou déborde tout l'écran car le problème avec les calculs sur des Grands nombres c'est que pour en connaître leur résultat il faut bien en afficher le résultat quelque part ...

A+.