begin process at 2012 05 27 17:34:24
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > 

Code

 > 

Maths & Algorithmes

 > OP4 UN INTERPRÉTEUR POUR ENTIERS DE TRÈS GRANDE TAILLE

OP4 UN INTERPRÉTEUR POUR ENTIERS DE TRÈS GRANDE TAILLE


 Information sur la source

Note :
Aucune note
Catégorie :Maths & Algorithmes Classé sous :entiers, grande taille, liste chainée, langage interprété, librairies Niveau :Débutant Date de création :13/12/2010 Date de mise à jour :25/12/2010 08:19:27 Vu / téléchargé :2 352 / 75
Auteur : pgl10

Ecrire un message privé
Site perso
Commentaire sur cette source (9)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
OP4 est un logiciel pour effectuer des calculs arithmétiques avec des entiers de très grandes tailles. Il est organisé en trois parties : la librairie pour gérer les entiers de très grande taille, la librairie pour gérer l'archivage des variables ayant été calculées pendant l'utilisation et l'interpréteur des instructions du langage OP4 qui permet le mode conversationnel et le mode fichier de commandes avec ou sans un fichier memo qui enregistre les commandes reçues et les résultats obtenus. Les quatre opérations : addition, soustraction, multiplication et division sont opérationnelles. Des librairies spécialisées comme GMP ou NTL sont disponibles et optimisées pour faire de tels calculs. Mais ici, on a préféré développer une librairie personnelle ce qui doit très sûrement diminuer les performances tout en assurant plus d'autonomie. Les erreurs internes graves pouvant intervenir pendant l'exécution et qui sont détectées et signalées ont pour effet de stopper l'exécution. Dans ce cas le fichier fi_err_bi.txt conserve ce signalement. C'est un choix modifiable. Mais, avec le fichier memo et le fichier de commandes on a l'utilitaire histo.exe qui permet de rejouer l'historique de la session interrompue avec ou sans modification. A titre d'exemple, une erreur facile à provoquer est la division par zéro ! La programmation fait un usage intense des tableaux et des pointeurs. L'une des particularités de ce développement est la gestion d'une liste chainée, ou pile, dont les éléments sont de taille variable. La commande entrée au clavier ou par un fichier est actuellement limitée à 20000 caractères. Les entiers qui peuvent y être définis sont donc limités aussi, mais en pratique cette limite est peu contraignante et facile à modifier. Le temps de calcul est une autre limitation, il faudrait utiliser GMP pour aller plus vite. Enfin, il faut noter qu'un fichier de commandes peut en appeler un autre et qu'il est possible d'y effectuer des débranchements conditionnels et des boucles. Le manuel précise les instructions du langage OP4. Un octet peut avoir 256 valeurs différentes. Il n'y a que 10 chiffres décimaux différents. Si j'avais rangé un chiffre dans un octet, j'aurais occupé tout simplement deux fois plus de mémoire pour les grands entiers.

Source

  • // BigInteger.h
  • #ifndef BIG_INTEGER_H
  • #define BIG_INTEGER_H
  • #include <iostream>
  • #include <fstream>
  • #include <string>
  • typedef struct {
  • // sur Intel x86 le unsigned short va de 0 à 65535
  • // ici les composants nels[] du BigInteger sont des unsigned short
  • // compris entre 0 et 9999 du moins significatif au plus significatif,
  • // par exemple pour 1234567890 : unsigned short nels[] = {7890, 3456, 12}
  • int size; // nombre de nels ( size = 0 pour 0 )
  • int sign; // signe ( -1 si < 0 et 0 sinon )
  • unsigned short *nels;
  • } BigInteger;
  • void errbi(char* s);
  • BigInteger biun();
  • BigInteger binul();
  • void annulebi(BigInteger* N);
  • void nouvbi(BigInteger* N, BigInteger M);
  • BigInteger bibi(BigInteger M);
  • BigInteger opbi(BigInteger M);
  • int taillebi(BigInteger M);
  • void verifbi(BigInteger* M);
  • void printbi(BigInteger N);
  • void printnbi(BigInteger N);
  • void printxbi(BigInteger X);
  • void fprintbi(FILE *fp, BigInteger N);
  • void fprintnbi(FILE *fp, BigInteger N);
  • BigInteger charstobi(char* s);
  • BigInteger strtobi(std::string s);
  • BigInteger ushorttobi(unsigned short d);
  • BigInteger shorttobi(short d);
  • BigInteger uinttobi(unsigned int n);
  • BigInteger inttobi(int n);
  • int cmpubi(BigInteger M, BigInteger N);
  • int cmpbi(BigInteger M, BigInteger N);
  • bool isnulbi(BigInteger* M);
  • bool isposbi(BigInteger* M);
  • bool ispairbi(BigInteger* M);
  • BigInteger addubi(BigInteger M, BigInteger N);
  • BigInteger sububi(BigInteger M, BigInteger N);
  • BigInteger addbi(BigInteger M, BigInteger N);
  • BigInteger subbi(BigInteger M, BigInteger N);
  • BigInteger mulbinel(BigInteger X, unsigned short n);
  • void muldibi(BigInteger* X);
  • BigInteger mulbi(BigInteger M, BigInteger N);
  • BigInteger* divbi(BigInteger M, BigInteger N);
  • #endif // BIG_INTEGER_H
  • Voir tout le source dans le zip 
// BigInteger.h 
#ifndef BIG_INTEGER_H
#define BIG_INTEGER_H
#include <iostream>
#include <fstream>
#include <string>
typedef struct {
    // sur Intel x86 le unsigned short va de 0 à 65535 
    // ici les composants nels[] du BigInteger sont des unsigned short 
    // compris entre 0 et 9999 du moins significatif au plus significatif, 
    // par exemple pour 1234567890 : unsigned short nels[] = {7890, 3456, 12}
    int size; // nombre de nels ( size = 0 pour 0 )
    int sign; // signe ( -1 si < 0 et 0 sinon )
    unsigned short *nels;
} BigInteger;
void errbi(char* s);
BigInteger biun();
BigInteger binul();
void annulebi(BigInteger* N);
void nouvbi(BigInteger* N, BigInteger M);
BigInteger bibi(BigInteger M);
BigInteger opbi(BigInteger M);
int taillebi(BigInteger M);
void verifbi(BigInteger* M);
void printbi(BigInteger N);
void printnbi(BigInteger N);
void printxbi(BigInteger X);
void fprintbi(FILE *fp, BigInteger N);
void fprintnbi(FILE *fp, BigInteger N);
BigInteger charstobi(char* s);
BigInteger strtobi(std::string s);
BigInteger ushorttobi(unsigned short d);
BigInteger shorttobi(short d);
BigInteger uinttobi(unsigned int n);
BigInteger inttobi(int n);
int cmpubi(BigInteger M, BigInteger N);
int cmpbi(BigInteger M, BigInteger N);
bool isnulbi(BigInteger* M);
bool isposbi(BigInteger* M);
bool ispairbi(BigInteger* M);
BigInteger addubi(BigInteger M, BigInteger N);
BigInteger sububi(BigInteger M, BigInteger N);
BigInteger addbi(BigInteger M, BigInteger N);
BigInteger subbi(BigInteger M, BigInteger N);
BigInteger mulbinel(BigInteger X, unsigned short n);
void muldibi(BigInteger* X);
BigInteger mulbi(BigInteger M, BigInteger N);
BigInteger* divbi(BigInteger M, BigInteger N);
#endif // BIG_INTEGER_H
    
Voir tout le source dans le zip

 Conclusion

Lancez OP4 et faites : aide. Ce programme est portable. Malgré les vérifications, il y a peut-être encore des bugs et malgré les précautions, des fuites de mémoire résiduelles sont possibles. Mais on peut encore développer divers compléments dont le plus simple est l'opérateur d'exponentiation. Vos remarques, observations, conseils et perfectionnements sont les bienvenus. Merci. Voici un exemple immédiat obtenu avec exp-exe.txt :
1234^100 = 1353679866791074518495392800706065891
641320359475365620283140987273250709210139671420
418849015638387608432148201867030594727794711411
552301641030226812163007870887536846101248467081
224073515912126936724561040113002017405574429832
255154128305164646648619699441218220156803948576
381957284173320050030562955493376

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Historique

14 décembre 2010 05:50:46 :
Par précaution : l'écriture physique du fichier memo est faite plus souvent
14 décembre 2010 09:13:36 :
Petite clarification
14 décembre 2010 11:20:52 :
Ajout d'une explication bien utile
14 décembre 2010 11:21:02 :
Ajout d'une explication bien utile
14 décembre 2010 20:14:56 :
Correction d'un bug de calcul intervenant rarement
19 décembre 2010 20:27:24 :
Nouveauté : les boucles multiples imbriquées
21 décembre 2010 22:01:10 :
Clarification nécessaire de la condition "pour a < b"
22 décembre 2010 20:13:00 :
L'addition de commentaires inclus améliore l'utilisation
25 décembre 2010 08:19:28 :
Encore une petite correction vraiment indispensable

 Sources du même auteur

Source avec Zip Source avec une capture UNE LISTE HÉTÉROGÈNE DOUBLEMENT CHAINÉE
Source avec Zip Source avec une capture POUR AFFICHER LES CARACTÈRES ACCENTUÉS SOUS WINDOWS EN MODE ...
Source avec Zip Source avec une capture CONVHTML : UN UTILITAIRE DE CONVERSION POUR FICHIERS HTML
Source avec Zip Source avec une capture AFFIMOFF : UNE VISIONNEUSE 3D AVEC PARAMÉTRISATION ET TEXTUR...
Source avec Zip Source avec une capture CRIBLE D'ERATOSTHÈNE OPTIMISÉ
Toutes les sources de pgl10

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel
Toutes les sources de la catégorie Maths & Algorithmes

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture UN INTERPRÉTEUR POUR RATIONNELS DE GRANDES TAILLES par pgl10
Source avec Zip Source avec une capture DÉCOMPOSITION EN FACTEURS PREMIERS AVEC GMP par pgl10
LES OPÉRATIONS DE LA LISTE CHAINÉE par smaili
Source avec une capture POWER MATH: TESTE DE VITESSE ENTIERS VS REELS , CLASS VS STR... par dedalusman
Source avec Zip Source avec une capture LISTE AVEC LES CLASSES C++ par alberd_m

Commentaires et avis

Commentaire de pgl10 le 14/12/2010 17:16:14

Mardi 14 décembre 2010 à 17h15 : je viens de trouver un cas où le calcul est faux. A plus tard, quand j'aurai une version corrigée. Désolé, pgl10

Commentaire de pgl10 le 14/12/2010 20:18:42

Mardi 14 décembre 2010 à 20h15 : j'ai trouvé la faute de calcul annoncée ci-dessus et intervenant rarement. La nouvelle version disponible corrige ce problème. Je suis désolé de ne pas l'avoir détecté plus tôt.

Commentaire de pgl10 le 19/12/2010 20:30:49

Avant la modification de ce jour les boucles simples sur un seul niveau étaient acceptées. Maintenant on peut faire des boucles multiples imbriquées. La documentation et les exemples sont à jour.

Commentaire de Rescassol le 20/12/2010 08:49:14

Je n'ai pas encore eu le temps de me plonger dans le source, mais ça a l'air très intéressant. Juste un commentaire à priori: ça m'a toujours énervé de voir des fichiers C s'appeler *.cpp , le C et le C++ ne sont pas le même langage. En C il y a des printf, en C++ il y a des cout etc...

Commentaire de Rescassol le 20/12/2010 09:42:42

Je n'aime pas les goto non plus.

Commentaire de pgl10 le 20/12/2010 10:49:35

Merci Rescassol pour vos commentaires. Pour être bien précis à propos du C++ il faut rappeler que l'emploi du "using namespace std; " doit être limité et peut créer des confusions. Ce n'est donc pas "cout" qui est recommendable en C++ mais "std::cout". Quant aux "goto" ils sont quand même implicites dans les "for", "do .. while" et même dans les "if" du C++. C'est vrai, on peut éviter les "goto" en C++, mais est-ce toujours la meilleure solution ?

Commentaire de pgl10 le 21/12/2010 11:17:49

J'ai connu et pratiqué, il y a longtemps, la programmation structurée dans un grand projet : source de 1 000 000 de lignes, 12 programmeurs et durée 15 ans avec un langage où le "goto" était impossible. Cela facilite la clarté et la mise à jour du source pour de très grands projets. Mais, à mon avis, pour de petits projets personnels c'est seulement l'excès de "goto" qu'il faut éviter. Et progresser encore en C et C++ continue de m'intéresser.

Commentaire de pgl10 le 22/12/2010 20:20:18

Les commentaires inclus dans les fichiers de commandes facilitent leur utilisation. La documentation et les exemples sont à jour. Parmi les nouveautés qui peuvent être ajoutées, on peut citer : l'opérateur d'exponentiation, le modulo et le test de primalité, mais ce n'est pas prévu bientôt.

Commentaire de pgl10 le 08/02/2011 11:35:58

Le 8/2/2011. J'ai redéveloppé un autre programme sur une nouvelle base avec des suppléments : exponentiation, modulo, primalité, racine carrée, inverse modulaire, exponentiation modulaire, pgcd, ppcm, ... Je crains qu'il y ait encore des problèmes dans OP4 mais je ne lui prévois plus de mise à jour. Mais on peut quand même y récupérer des morceaux. pgl10

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Télécharger des librairies [ par Alain ] Où puis-je télécharger des librairies pour TC tel que TV.H, TCLASSH.LIB... et aussi beaucoup d'autre. Un grand merçi d'avance.Alain. Librairies [ par Panther ] Bonjour, je voudrais savoir comment on peut se procurer des librairies manquantes. Presentement je fais l'essaie de DEV si ca peut vous aiderMerci Où installer les librairies Open GL?? [ par Budweiser ] Il m'est impossible de compiler un seul programme avec les librairies d'Open GL car il ne trouve jamais le fichier à inclure.Ma question c'est où copi Librairies mathématiques VS matlab [ par devilinside ] Devant coder une interface graphique en visual C++ pour un logiciel de calcul, je suis fort dépourvu.Le code original du coeur de calcul tourne sous m Problème de compilation de librairie... [ par ditch ] je me retrouve face à un énorme problème, en fait je dois compiler les librairies de imageMagick pour implémenter les fonctions de celles-ci dans une Carte d'acquisition pcl-812 E/S [ par ludoo7 ] J'utilise une carte d'acquisition pcl-812 et elle utilise une fonction spécifique nécessitant l'utilisation de librairies. Je possède actuellement les Aruthmétique sur grands entiers ??? [ par Cygnus ] J'ai à effectuer des opérations (+,-,'/,*) sur des grands nombres entiers (positifs et négatifs), tout en utilisant les fonctions membre de la classe Division de deux tableaux d'entiers [ par BenHur ] Bonjour, j'ai deux tableaux d'entiers dont chaque indice contient un nombre de 0 à 9. Je dois faire des opérations mathématiques sur chacun de ces ind manipulaton de trés grands entiers [ par Orkblutt ] Salut,j'aimerai implementer une classe qui me permettrai de manipuler (+,-, /,*,%) des grands nombres (Nb&gt;32bits) mais je ne sais pas du tout comme Urgent...classe de manipulation de grands entiers [ par Orkblutt ] Salut,j'aimerai implementer une classe qui me permettrai de manipuler (+,-, /,*,%) des grands nombres (Nb&gt;32bits) mais je ne sais pas du tout comme


Nos sponsors


Sondage...

Comparez les prix


Archos 5 Internet Tablette 500 Go
Entre 396€ et 444€

Visiter le guide achat

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,764 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib (Android Market)