DLL pour le calcul sur les grands entiers

' **********************************************************************
' Demonstration de la bibliotheque BIGINT
' **********************************************************************

dll_on "bigint.dll"

' ----------------------------------------------------------------------
' Variables globales utilisees par les sous-programmes
' ----------------------------------------------------------------------

dim bi_result% : ' Resultat d'un calcul
dim bi_num$    : ' valeur d'un nombre sous forme de chaine de caracteres
dim bi_temp$  : ' Variable temporaire

' ----------------------------------------------------------------------
' Initialisation de la bibliotheque
' ----------------------------------------------------------------------

dim nInt%

nInt% = 1000

BigInit(nInt%)

print "Nous pouvons utiliser ", nInt%, " nombres de ", bi_result%, " chiffres chacun"
print "Ces nombres ont les indices de 0 a ", nInt% - 1

' ----------------------------------------------------------------------
' Affectation de valeurs aux nombres entiers d'indices 0, 1, 2
' ----------------------------------------------------------------------

' Affectation par un nombre entier (32 bits)
SetNum(0, 123456789)

 ' Affectation par une chaine de caracteres
SetStr(1, "1267650600228229401496703205376")  : ' 2^100

' Affectation par un entier aleatoire de n bits
' Intervalle [2^(n - 1) .. 2^n - 1]
SetRnd(2, 128)                                : ' 128 bits

' ----------------------------------------------------------------------
' Lecture de la valeur d'un nombre dans une chaine de caracteres,
' ainsi que du nombre de chiffres
' ----------------------------------------------------------------------

dim i%

for i% = 0 to 2
  GetStr(i%)
  print
  print "Le nombre d'indice ", i%, " vaut ", bi_num$, " (", bi_result%, " chiffres)"
next i%

' ----------------------------------------------------------------------
' Operations arithmetiques
' ----------------------------------------------------------------------

SetRnd(0, 128)
SetRnd(1, 64)

BigDiv(0, 1, 2, 3)

print : print "Division entiere :"

GetStr(0) : print "      ", bi_num$, " \ "
GetStr(1) : print "      ", bi_num$, " = "
GetStr(2) : print "      ", bi_num$
GetStr(3) : print "reste ", bi_num$

print : print "Verification :"

GetStr(1) : print "      ", bi_num$, " * "
GetStr(2) : print "      ", bi_num$, " + "
GetStr(3) : print "      ", bi_num$, " = "

BigMul(1, 2, 0)
BigAdd(0, 3, 1)

GetStr(1) : print "      ", bi_num$

end

' ----------------------------------------------------------------------
' Sous-programmes
' ----------------------------------------------------------------------

sub BigInit(n%)
  bi_result% = dll_call1("BigInit", n%)
  bi_temp$ = string$(bi_result%, " ")
end_sub

sub SetNum(i%, n%)
  bi_result% = dll_call2("SetNum", i%, n%)
end_sub

sub SetStr(i%, a$)
  bi_result% = dll_call2("SetStr", i%, adr(a$))
end_sub

sub SetRnd(i%, nbits%)
  bi_result% = dll_call2("SetRnd", i%, nbits%)
end_sub

sub GetStr(i%)
  bi_result% = dll_call2("GetStr", i%, adr(bi_temp$))
  bi_num$ = left$(bi_temp$, bi_result%)
end_sub

sub BigDup(i%, j%)
  bi_result% = dll_call2("BigDup", i%, j%)
end_sub

sub BigAdd(i%, j%, k%)
  bi_result% = dll_call3("BigAdd", i%, j%, k%)
end_sub

sub BigSub(i%, j%, k%)
  bi_result% = dll_call3("BigSub", i%, j%, k%)
end_sub

sub BigMul(i%, j%, k%)
  bi_result% = dll_call3("BigMul", i%, j%, k%)
end_sub

sub BigDiv(i%, j%, k%, m%)
  bi_result% = dll_call4("BigDiv", i%, j%, k%, m%)
end_sub

Bibliothèque BigInt : calcul sur les grands entiers
===================================================

Introduction
------------

La DLL BigInt (basée sur la bibliothèque LargeInt de S. J. Schaper)
permet de réaliser des calculs sur de grands nombres entiers.

Les appels aux fonctions de la DLL sont inclus dans des sous-programmes
Panoramic. L'utilisateur appelle donc directement ces sous-programmes.


Variables globales
------------------

La bibliothèque utilise 3 variables globales qui doivent être déclarées
au début du programme Panoramic:

  bi_result% : Valeur de retour d'une fonction de la DLL
  bi_num$    : Valeur d'un nombre sous forme de chaine de caracteres
  bi_temp$  : Variable temporaire utilisée par les sous-programmes


Initialisation
--------------

Le sous-programme BigInit(n%) initialise la bibliothèque. Le paramètre
n% représente le nombre d'entiers que l'on veut utiliser. Le nombre de
chiffres maximum de chaque entier est retourné dans la variable bi_result%

P. ex. l'instruction :

  BigInit(100)

permet de réserver 100 entiers pouvant avoir jusqu'à 4176 chiffres chacun.

Les entiers sont stockés dans un tableau. On accède à chaque entier par
le biais de son indice. Les indices vont de 0 à (n% - 1)

Dans la suite, nous désignerons par (i%) l'entier d'indice i%

Note : la procédure BigInit crée un fichier PrimFlgs.bin de 0 octet qui
sera utilisé par les procédures concernant les nombres premiers (non
encore implémentées).


Affectation de valeurs
----------------------

Pour affecter une valeur à un grand entier on dispose de 3 procedures :

SetNum(i%, n%) : affecte à l'entier (i%) la valeur de n% (entier 32 bits)

                Exemple : SetNum(0, 123456789)

SetStr(i%, a$) : affecte à l'entier (i%) le nombre représenté par la
                chaîne de caractères a$. On peut utiliser un nombre
                hexadécimal à condition de le préfixer par "&H"
               
                Exemple : SetStr(1, "12345678901234567890")
                          SetStr(2, "&H123456789ABCDEF")
                         
SetRnd(i%, n%) : affecte à l'entier (i%) un nombre aléatoire de n% bits
                allant de 2^(n% - 1) à (2^n% - 1)
               
                Exemple : SetRnd(3, 128)
               

Lecture d'une valeur
--------------------

La procédure GetStr(i%) permet de lire la valeur décimale de l'entier
(i%) dans la chaîne de caractères bi_num$. Le nombre de chiffres est
retourné dans bi_result%


Opérations arithmétiques
------------------------

On dispose des procédures suivantes :

BigDup(i%, j%)        : Copie (i%) dans (j%)

BigAdd(i%, j%, k%)    : Somme (i%) + (j%). Résultat dans (k%)

BigSub(i%, j%, k%)    : Différence (i%) - (j%). Résultat dans (k%)

BigMul(i%, j%, k%)    : Produit (i%) * (j%). Résultat dans (k%)

BigDiv(i%, j%, k%, m%) : Division entière de (i%) par (j%). Place le
                        quotient dans (k%) et le reste dans (m%)
                       


               

' **********************************************************************
' Demonstration de la bibliotheque BIGINT
' **********************************************************************

dll_on "bigint.dll"

' ----------------------------------------------------------------------
' Definition des variables globales
' ----------------------------------------------------------------------

#include "bigvar.inc"

' ----------------------------------------------------------------------
' Initialisation de la bibliotheque
' ----------------------------------------------------------------------

dim nInt%

nInt% = 1000  : ' Adapter en fonction de la taille des nombres a calculer

BigInit(nInt%)

print "Nous pouvons utiliser ", nInt%, " nombres de ", bi_result%, " chiffres chacun"
print

' ----------------------------------------------------------------------
' Demonstration des procedures BigPow, BigSqr, BigSqrt, BigFact
' ----------------------------------------------------------------------

' Calcul de 2^100
SetNum(0, 2)
BigPow(0, 100, 1)
GetStr(1)
print "2^100 =", bi_num$
print

' Calcul de 2^200 par mise au carre du resultat precedent
BigSqr(1, 2)
GetStr(2)
print "2^200 =", bi_num$
print

' Racine carree du resultat redonne 2^100
BigSqrt(2, 3)
GetStr(3)
print "2^100 =", bi_num$
print

' Calcul de la factorielle de 50
BigFact(50, 4)
GetStr(4)
print "50!  =", bi_num$
print

' ----------------------------------------------------------------------
' Fin du programme principal
' ----------------------------------------------------------------------

end

' ----------------------------------------------------------------------
' Definition des sous-programmes
' ----------------------------------------------------------------------

#include "bigint.inc"

' ----------------------------------------------------------------------