Précision des calculs et stockage de grands nombres

Bonjour,

Je rencontre quelques petits probl=E8mes techniques et je n'arrive pas =E0
m'en sortir.
Dans le code ci dessous, je ne peux pas rentrer de nombre plus grand
dans un int que dans un double ?! A partir de 11 digits le double ( le
int aussi mais l=E0 c'est normal ) ne veut rien savoir, le programme
plante alors que selon la MSDN, on peut aller jusqu'=E0 1,7E308.

De plus, j'ai quelque soucis avec la pr=E9cision des calculs. En effet,
quand je calcul le nombre de digits d'un nombre par exemple 1E9,
l'ex=E9cution du code me retourne 9 au lieu de 10 ! car quand il calcul
le log il trouve 8.9999 une fois la partie enti=E8re prise, on a 8 + 1
donne 9 contre 9+1 en th=E9orie.

Voici le code. Peut =EAtre ai-je fais une erreur mais je ne la trouve
pas.

MAIN

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "./BIBLIOTHEQUE.h"

int main()
{

int DIGITS=3DNOMBRE_DE_DIGITS(1000000000,10);

double ENTIER =3D 1;
double *TABLEAU =3D NULL;
int *TAILLE =3D malloc(sizeof(int));
ENTIER_DANS_TABLEAU(ENTIER, &TABLEAU, TAILLE);

double VALEUR =3D 10;
double EXPOSANT =3D 10;
double RESULTAT =3D PUISSANCE(VALEUR, EXPOSANT);

int V_BASE =3D 11111111;
int BASE =3D 2;
double DECIMAL=3DVERS_LA_BASE_DECIMALE(V_BASE, BASE);

printf("\n\nDIGIT =3D %d", DIGITS);

printf("\n\nEN DECIMAL =3D %.0f", DECIMAL);

printf("\n\nPUISSANCE =3D %.0f", RESULTAT);

printf("\n\nENTIER DANS TABLEAU : ");

int i;
for ( i=3D(*TAILLE-1) ; i>=3D0 ; i-- )
{
printf("%.0f", TABLEAU[i]);
}

getchar();
}


HEADER

//
PROTOTYPES/////////////////////////////////////////////////////////////////=
///
int NOMBRE_DE_DIGITS( double VALEUR, int BASE );
double PUISSANCE( double VALEUR, double EXPOSANT );
void ENTIER_DANS_TABLEAU( double VALEUR, double **TABLEAU, int
*TAILLE_TABLEAU );
double VERS_LA_BASE_DECIMALE( double VALEUR, int BASE );
///////////////////////////////////////////////////////////////////////////=
/////



//
FONCTIONS//////////////////////////////////////////////////////////////////=
///

///////////////////////////////////////////////////////////////////////////=
/////
// NOMBRE_DE_DIGITS : Calcul le nombre de digits du nombre d=E9cimal
dans la base consid=E9r=E9e
///////////////////////////////////////////////////////////////////////////=
/////
// Entr=E9e :
// VALEUR : double
// BASE : int
//
// Pr=E9-Conditions :
// BASE>1
//
// Sortie :
// RESULTAT : int
//
// Post-Condition :
// ...
///////////////////////////////////////////////////////////////////////////=
/////

int NOMBRE_DE_DIGITS( double VALEUR, int BASE )
{
if ( BASE <=3D 1 )
{
printf("\nERREUR DANS LA FONCTION NOMBRE_DE_DIGITS\n -
LA BASE NE PEUT ETRE INFERIEURE OU EGALE A 1\n");
}

if ( VALEUR =3D=3D 0 || VALEUR =3D=3D 1)
{
return 1;
}

if ( BASE > 1 )
{
return (floor( log(abs(VALEUR))/log(BASE) ) +1);
}
}

///////////////////////////////////////////////////////////////////////////=
/////
// PUISSANCE : Calcul la puissance d'un nombre
///////////////////////////////////////////////////////////////////////////=
/////
// Entr=E9e :
// VALEUR : double
// EXPOSANT : double
//
// Pr=E9-Conditions :
// VALEUR !=3D0
//
// Sortie :
// RESULTAT : double
//
// Post-Condition :
// RESULTAT=3DVALEUR^EXPOSANT
///////////////////////////////////////////////////////////////////////////=
/////

double PUISSANCE( double VALEUR, double EXPOSANT )
{
double RESULTAT=3D1;
int I=3D0;

if ( EXPOSANT !=3D floor(EXPOSANT) || VALEUR =3D=3D 0 )
{
printf("\nERREUR DANS LA FONCTION PUISSANCE\n -
VERIFIER QUE VOTRE EXPOSANT N'EST PAS UN REEL\n - VERIFIER QUE VOUS
NE CALCULEZ PAS LA PUISSANCE DE 0\n");
}

else {
if ( EXPOSANT=3D=3D0 || VALEUR=3D=3D1 )
{
return RESULTAT;
}

if ( EXPOSANT >=3D 1 )
{
while ( I !=3D EXPOSANT )
{
RESULTAT=3DRESULTAT*VALEUR;
I++;
}

return RESULTAT;
}

if ( EXPOSANT < 0 )
{
while ( I !=3D -EXPOSANT )
{
RESULTAT=3DRESULTAT*VALEUR;
I++;
}

return 1/RESULTAT;
}
}
}


///////////////////////////////////////////////////////////////////////////=
/////
// ENTIER_DANS_TABLEAU : D=E9composer un entier dans un tableau
///////////////////////////////////////////////////////////////////////////=
/////
// Entr=E9e :
// VALEUR : double
// TABLEAU : un double pointeur sur un entier
// TAILLE_TABLEAU : un pointeur sur un entier
//
// Pr=E9-Conditions :
// VALEUR >=3D 0
//
// Sortie :
// TABLEAU : un double pointeur sur un entier
// TAILLE_TABLEAU : un pointeur sur un entier
//
// Post-Conditions :
// ...
///////////////////////////////////////////////////////////////////////////=
/////
void ENTIER_DANS_TABLEAU( double VALEUR, double *(*TABLEAU), int
*TAILLE_TABLEAU )
{
// On v=E9rifie que VALEUR est une partie enti=E8re
if( VALEUR !=3D floor(VALEUR) || TAILLE_TABLEAU=3D=3DNULL)
{
printf("\nERREUR DANS LA FONCTION ENTIER_DANS_TABLEAU\n -
LA VALEUR QUE VOUS AVEZ ENTRE N'EST PAS UNE PARTIE ENTIERE\n -LE
POITEUR SUR TAILLE_TABLEAU N'EST PAS CORRECTEMENT REFERENCE\n");
}

else {

if( VALEUR < 0 )
{
VALEUR=3D-VALEUR;
}

if( VALEUR >=3D 0 )
{
*TAILLE_TABLEAU=3DNOMBRE_DE_DIGITS(VALEUR, 10);

(*TABLEAU) =3D malloc((*TAILLE_TABLEAU)*sizeof
(double));

if( TABLEAU=3D=3DNULL )
{
printf("\nERREUR SUR LE POINTEUR TABLEAU
\n");
}

int J;
for ( J=3D((*TAILLE_TABLEAU)-1) ; J>=3D0 ; J-- )
{
(*TABLEAU)[J] =3D floor(VALEUR/PUISSANCE
(10, J));
VALEUR -=3D ((*TABLEAU)[J])*PUISSANCE
(10, J) ;
}
}


else printf("\nERREUR INCONNUE DANS L'UTILISATION DE LA
FONCTION ENTIER_DANS_TABLEAU\n");
}
}


///////////////////////////////////////////////////////////////////////////=
/////
// CONVERTIR VERS LA BASE : Donne la valeur du chiffre dans sa
nouvelle base
///////////////////////////////////////////////////////////////////////////=
/////
// Entr=E9e :
// VALEUR : entier
// BASE : entier
//
// Pr=E9-Conditions :
// VALEUR >=3D 0
//
// Sortie :
// RESULTAT : entier
//
// Post-Conditions :
// ...
///////////////////////////////////////////////////////////////////////////=
/////
double VERS_LA_BASE_DECIMALE( double VALEUR, int BASE )
{
VALEUR=3Dfloor(VALEUR);

int *TAILLE_TABLEAU=3Dmalloc(sizeof(int));
double *TABLEAU=3DNULL;

ENTIER_DANS_TABLEAU( VALEUR, &TABLEAU, TAILLE_TABLEAU );

double RESULTAT=3D0;

int I;
for ( I=3D0 ; I<(*TAILLE_TABLEAU) ; I++ )
{
double R=3DRESULTAT;
RESULTAT =3D RESULTAT + (TABLEAU[I])*PUISSANCE( BASE, I );
double P=3DPUISSANCE(BASE, I);
}

return RESULTAT;
}