Overflow en C : comment les gerer simplement ? - Page 1

BUT:
Calculer pour x (unsigned long),

y = (unsignedLong ) ((double)(x-0.5)*0.38) ?

CONTRAINTE:
Calcul exact. Pas d'overflow.
Pas de double (La prec d'un double est plate-forme dependante).

Ma solution:
(x / 50) * 19 + ((x%50) * 19 - 25 + 50 ) / 50 - 1

D'autres solutions plus simples ?

Arrondi au plus proche ? (flemme de lire ta solution)

Flemme de lire l'enonce aussi.

Ou alors la virgule de la première ligne est mal placée.

Arrondi au plus proche de (x*0.38) - 1

Euh ça n'a absolument rien à voir avec ce que tu as écrit, alors... (tu veux la partie entière de x*0.38-0.5, d'après ./5) Et ton énoncé ne précisait même pas le type de ce que tu voulais

Corrige. Satisfait ?

Ben non, (x-0.5)*0.38 != x*0.38-0.5

D'autant plus que tu as un pb de priorité : tu voulais probablement dire (ulong)((x-0.5)*0.38) et pas (ulong)(x-0.5)*0.38 (qui veut dire ((ulong)(x-0.5))*0.38)

Recorrige. Ca m'avance beaucoup ce que tu dis la.

Euh attends tu lis mes posts en entier là ?

Pollux :
Euh ça n'a absolument rien à voir avec ce que tu as écrit, alors... (tu veux la partie entière de x*0.38-0.5, d'après ./5)

Pollux :
Ben non, (x-0.5)*0.38 != x*0.38-0.5

Donc je répéte au cas où l'intersection de ce post et de ce que tu liras serait non vide : ./5 parle de floor(sub(mul(x,0.38),0.5)) alors que ./1 parle de floor(mul(sub(x,0.5),0.38)) (je prend une représentation non-ambiguë avec des arbres, comme ça pas d'excuse), ce qui n'est manifestement pas la même chose.

Je parle bien de floor(mul(sub(x,0.5),0.38)) . tu me cherches la?
./5 est une connerie.

Ben il suffisait de le dire... Ca te prenait 5 secondes et ça évitait que je te repose la question 50 fois


Bon j'ai fait le calcul indépendamment et je trouve q = x/50*19 + (19*(x%50)+40)/50 - 1, ce qui m'a l'air de revenir sensiblement à la même chose que toi (sauf qu'on a pas la même chose pour la constante à ajouter à x%50*19, l'un de nous deux a dû se planter, ou tu t'es plus probablement emmêlé les pinceaux entre ./1 et ./5 ) Je pense pas qu'on puisse vraiment faire plus simple, on sera de toute façon plus ou moins obligé de calculer à la fois x%50 et x/50, et le reste vient de lui-même après.

Ok je me suis trompe, mais c'est pas plutot:

q = x/100*38 + (38*(x%100)+100-19)/100 - 1

?

Les deux sont équivalents.

y = (unsigned long) (((unsigned long long)x<<1-1ull)*19ull/100ull)
Mais ça ne garantit le non-overflow que pour des nombres qui tiennent dans la taille minimum d'un unsigned long (32 bits). Avec un long 64 bits, il peut y avoir des débordements. Mais tu peux t'arranger avec __int128 si tu as GCC 3.4 64 bits (ou M$VC 64 bits).

je suis pas sûr que ça soit le genre de solution que veut PpHd, parce que je pense qu'il serait assez grand pour y penser tout seul et le jour où il voudra faire ça avec des nbs 128 bits, il devra faire sa lib de calcul 256 bits ?

Precision: ca doit fonctionner en C K&R. Moi je fais des trucs portables

En plus, je pense que si les long long sont émulés en software, la solution 32 bits est bien plus efficace (un div-mod, une multiplication, une lookup table à 50 entrées et une addition)

M'en fous un peu que ca soit rapide. C'est pour donner en parametre a une fonction qui prend pres de 100000 cycles sur un Athlon. Alors, je suis pas a 100 cycles pres pour calculer l'entree.

PpHd
: M'en fous un peu que ca soit rapide. C'est pour donner en parametre a une fonction qui prend pres de 100000 cycles sur un Athlon. Alors, je suis pas a 100 cycles pres pour calculer l'entree.

Ca fais plusieurs topic que je lis te concernant, et a chaque fois, la meme question me reviens.

Tu cherche a faire quoi, pour avoir des fonctions aussi lourdes?

Des fonctions de calcul flottantes + d'autres trucs que je fais en bonus.

ok.