Format d'affichage resultat division très petite

[Anthor]

C'est bien compliqué tout ça alors qu'il suffit de faire ça :

<?php



$a = 0.0000017682711283366;

echo sprintf('%.' . (strlen($a)+1) . 'f', $a);

Edit : c'est juste pour remettre Anthor à sa place lol

Et pour $a = 1.7682711283366E-26; ?

[srm]

Ca n'est pas sa demande, il dit qu'il ne veut pas de notation scientifique lorsqu'il fait le résultat d'une division très petite mais qu'il veut juste la valeur comme nous on l'écrirait. Et ma solution marche très bien pour ce cas.

<?php



$a = 1384237/38743289473297;



echo $a . "\n";

echo sprintf('%.' . (strlen($a)+1) . 'f', $a) . "\n";

3.5728432428384E-8
0.0000000357284324284

[Argorate]

en fait, j'avais pensais à cette solution (strlen), et je l'avais même testé, mais j'avais abandonné quand j'avais vu que le strlen() renvoi un peu n'importe quoi. Mais à la reflection, c'est peut etre lié a cette histoire de limite technique?

$a = 0.0000000176827115406046445640545416064283366;

echo strlen($a);

echo sprintf('%.' . (strlen($a)+1) . 'f', $a);

echo floatToString($a);

echo afficher_decimal($a);

echo floatalize($a);

echo $a;

resultat:

18 (44 en réalité, dans cette exemple ^^)

0.0000000176827115406

0.0000000176827115406046

0.00000001768271154060464

0.000000017682711540605

1.7682711540605E-8

Donc j'adore comment chaque fonction me renvoi un truc différent... XD

//Argorate se dirige contre un mur et se tape la tête dessus.

[Myrina]

une chose est sure, c'est que la fonction sprintf() se démarque des autres dans sa manière de voir les variables flottantes:

echo sprintf('%.44f', $a);

echo sprintf('%.100f', $a);

echo sprintf('%.9999f', $a);

les 3 renvoient:

0.0000000176827115406046444932704290184736

NB: pour strlen(), c'est normal que ce soit 18 car c'est la longueur de 1.7682711540605E-8.

[niahoo]

heu perso au dessus de 40 php fait la gueule.

ya une variable du php ini qui règle ça ?

[Anthor]

Ca n'est pas sa demande, il dit qu'il ne veut pas de notation scientifique lorsqu'il fait le résultat d'une division très petite mais qu'il veut juste la valeur comme nous on l'écrirait. Et ma solution marche très bien pour ce cas.

En quoi est-ce différent ?

$a = 125/12354874646520864284284624684;



echo $a . "\n"; // 1.0117464043652E-26

echo sprintf('%.' . (strlen($a)+1) . 'f', $a) . "\n"; // 0.00000000000000000000

echo floatToString($a) . "\n"; // 0.0000000000000000000000000101174640436518

echo afficher_decimal($a) . "\n"; // 0.00000000000000000000000001011746404365179

echo floatalize($a) . "\n"; // 0.000000000000000000000000010117464043652 

en fait, j'avais pensais à cette solution (strlen), et je l'avais même testé, mais j'avais abandonné quand j'avais vu que le strlen() renvoi un peu n'importe quoi. Mais à la reflection, c'est peut etre lié a cette histoire de limite technique?

Tu n'as toujours rien compris, elle renvoi parfaitement le bon résultat par rapport à la précision de php, soit 14 chiffres après la virgule dans un nombre (en général).
En gros la notation scientifique permet de garder une plus grande précision pour le même nombre de chiffres après la virgule.

Exemple :

$a = 0.0000000000000000000176827115406041111;

ini_set('precision', 14);

echo $a; // 1.7682711540604E-20

echo strlen($a); // 19

echo sprintf('%.' . (strlen($a)+1) . 'f', $a); // 0.00000000000000000002

echo floatalize($a) . "\n"; // 0.000000000000000000017682711540604



ini_set('precision', 20);

echo $a; // 1.7682711540604110611E-20

echo strlen($a); // 25

echo sprintf('%.' . (strlen($a)+1) . 'f', $a); // 0.00000000000000000001768271

echo floatalize($a) . "\n"; // 0.000000000000000000017682711540604110611 

[Argorate]

Oui, on est d'accord

Sinon effectivement j'avais pas pensé que le strlen compté sur la chaine transformer, ce qui explique mieux le résultat

Merci pour toutes ces précisions.