pkoi !? - Page 1

voila une ptite partie de code:

unsigned short y;
unsigned long Val;
char ss[100];

Val = 0;
for (y=0; y<=100; y++)
{
sprintf(ss,"%u", y);
DrawStrXY(0,5,ss, A_REPLACE);
sprintf(ss,"%lu", Val);
DrawStrXY(0,20,ss, A_REPLACE);
Val *= 2;
}

ceci est sencé incrementé une valeur en la doublant a chaque fois, mais je ne comprend pas, quand 'y' arrive vers 50 environ, 'Val' s'arrete de s'incrementer, alors qu'il n'atteind meme pas la valeur maximale d'un unsigned long !.
il est ou le pb ?

"...n'atteind meme pas la valeur maximale d'un unsigned long !."

C'est drôle, moi je lis "unsigned short" dans la déclaration de y

Au fait, je pense que tu veux que ta boucle soit répétée 100 fois, dans ce code elle l'est 101 fois (tu pars de 0 jusqu'à 100)


Topic clos

0*2=0, donc c'est normal que Val ne s'incrémente pas.

Oups j'ai pas bien compris la source

"Unsigned short" ca va pas de 0 à 65535 ?

Le problème c'est que Val est doublée 100 fois (ou 101 peu importe) et cela fais 2^100 soit environ 10^30 ou 100 bits;

Mais Val vaut 0 au départ et Val*=2 vaudra toujours zéros...

<< "Unsigned short" ca va pas de 0 à 65535 ? >>
Nan nan, c'est moi qui ai dit une bêtise, l'US est le compteur de la boucle ([0;100] qui tient sans pb dans [0;2^16-1]), donc rien à voir avec Val (0->2^32-1).

mé non ! vous avez rien compris !

déja, c vrai j'avais oublié, il fo commencer à Val = 1

pour 'y' qui va a 101 je m'en fou, j'ai simplifié une partie de mon code pour le mettre sur le forum

mais c pas 'y' qui double tt le temps, c Val ! qui est en unsigned long !

donc ça me prend la tete ce truc !

y ne va pas à 101. C'est ta boucle qui se répète 101 fois !

Le pb doit être comme le dit the_beast, que à y==63, Val dépasse la capactité d'un unsigned long.
Car à y==62, Val a été multipliée 63 fois par 2, donc est égal à 2^63. La prochaine multiplication par 2 fait une de ces trois choses :
- si TIGCC optimise la multiplication par 2 avec add.l dn,dn on obtient 0
- le dépassement de capacité avec mulu rend 0 (je ne sais pas)
- le dépassement de capacité avec mulu rend 2^64-1 (...)

en basic j'arrivait pourtant a stocker des valeurs 100 fois superieur a celle ci ds une variable !
comment cela se fait il !

et alors comment modifier ma grande valeur en un chiffre a puissance (donc un peu moins precis mais ça ne me gene pas) ???

>en basic j'arrivait pourtant a stocker des valeurs 100 fois superieur a celle ci ds une variable ! comment cela se fait il !

En basic c'est l'OS qui fait les calculs, et comme c'est un systeme formel les entiers sont à précision arbitraire. En C c'est le processeur directement, c'est infiniment plus rapide mais on doit se limiter à la structure du processeur (qui est 16-/32-bit).

Le Basic, pour ses calculs, fait appel aux fonctions de l'AMS ("Advanced Mathematic Software"). Le C, pour une question de rapidité, calcule en "bas niveau" en faisant les opérations avec le jeu d'instructions arithmétiques du MC68k. Et contrairement aux fonctions de l'AMS qui "émule" en quelque sorte un proc de 64 bits (ou plus je n'en sait rien), le processeur a une capacité de 32 bits.

>Nitro: les entiers sont à précision arbitraire

Non, les entiers d'AMS sont limités à 2^2040-1 (essaye 2^2039-1+2^2039, puis 2^2040), c'est-à-dire environ 10^614.

>Thibaut:
>Le pb doit être comme le dit the_beast, que à y==63, Val dépasse la capactité d'un unsigned long.

Non, unsigned long va jusqu'à 2^32-1 seulement.
Pour aller jusqu'à 2^64-1, il faut un unsigned long long. Après, il n'y a plus rien à faire avec les types de GCC. Ce qu'on peut faire, c'est:

typedef struct INT128 {
unsigned long long msll;
unsigned long long lsll;
} int128;

int128 duplicate(int128 x)
{
if (x.lsll && 0x8000000000000000)
return (int128){x.msll+x.msll+1,x.lsll+x.lsll}
else
return (int128){x.msll+x.msll,x.lsll+x.lsll};
}

int128 Val={0,1};

puis remplacer Val*=2 par Val=duplicate(Val);.

Ça, ça devrait marcher pour ton code (ça va jusqu'à 2^128-1), mais il faut une routine d'affichage personnalisée, donc des divisions par 10, ce qui est très compliqué avec ce type de structures. Aussi, évidemment, il faut initialiser Val à autre chose qu'à 0 (dans mon exemple, je l'initialise à 1).

>obza_Fazer:
>et alors comment modifier ma grande valeur en un chiffre a puissance (donc un peu moins precis mais ça ne me gene pas) ???

float Val=1.;

Il faut aussi changer le format du sprintf.
[edit]Edité par Kevin Kofler le 29-09-2001 à 21:15:56[/edit]

Nitro, désolé pour ma re-explication : on a posté simultanément.

merci kevin pour ton astuce, tu dechires tout

menfin çe ne me suffit pas , j'ai besoin d'incrementer ma variale jusqu'à 2^500 voir 2^1000 !!!
ce qu'en basic est tt a fait possible

je ne peux pas diviser ma valeur en plusieurs valeur car mon algo ne serait plus aussi performant
j'ai donc essayé ma multiplication par 2 en faisant appel au basic, mais rien que ça mon algo a sa vitesse divisée par 200 ! donc autant rester au basic c t pas plus rapide.
la je crois que je peux abandonner mon truc