Français
Français
Dans le développement de PHP, la fonction CEIL () est souvent utilisée pour rassembler, mais parfois nous constatons que son résultat n'est pas l'entier que nous attendons, ce qui est souvent déroutant. En fait, la raison fondamentale de cette situation est la représentation et l'erreur de fonctionnement des nombres de points flottants. Cet article analysera en détail les causes de ce problème et fournira des solutions efficaces.
La fonction de la fonction ceil () consiste à arrondir un nombre vers le haut et à renvoyer le plus petit entier pas moins que ce nombre. Par exemple:
<?php
echo ceil(3.2); // Sortir 4
echo ceil(7.0); // Sortir 7
?>
Dans des circonstances normales, cette fonction est simple et intuitive à utiliser.
Dans certains cas, la fonction ceil () aura des résultats anormaux, tels que:
<?php
$num = 1.9999999999999998;
echo ceil($num); // 结果Sortir 2，Répondre aux attentes
$num = 1.9999999999999996;
echo ceil($num); // 结果Sortir 1，De façon inattendue
?>
Pourquoi ce dernier a-t-il le résultat de 1 au lieu de 2 ? Cela est en fait dû à la limitation de précision des nombres de points flottants.
Les points flottants dans PHP sont des numéros de points flottants à double précision basés sur la norme IEEE 754. Cette représentation a ses limitations de précision inhérente, ce qui rend certaines décimales incapables d'être représentées avec précision. Par exemple:
<?php
var_dump(0.1 + 0.2);
// Sortir float(0.30000000000000004)
?>
Ces minuscules erreurs s'accumulent lorsque les opérations mathématiques, entraînant les valeurs numériques traitées par ceil () sont en fait légèrement plus petites ou légèrement plus grandes que ce à quoi nous nous attendions.
Considérez l'exemple suivant:
<?php
$num = 2.0000000000000004;
echo ceil($num); // Sortir 3
$num2 = 1.9999999999999996;
echo ceil($num2); // Sortir 2，Mais l'espoir réel est 2
?>
Bien que NUM2 ait moins de 2 , il est stocké comme un nombre légèrement inférieur à 2 en raison de la précision du point flottante, ce qui a fait en sorte que ceil ()) augmente jusqu'à 2 au lieu de 1 .
Ce type d'erreur peut entraîner de graves problèmes dans les calculs financiers, l'unité de conversion de mesure et d'autres scénarios.
Vous pouvez d'abord utiliser la fonction rond () pour limiter le nombre de décimales, puis utiliser ceil () pour traiter:
<?php
$num = 1.9999999999999996;
$num = round($num, 8); // réserve8Numéro décimal
echo ceil($num); // 结果Sortir 2，Répondre aux attentes
?>
Cette méthode réduit efficacement l'impact des erreurs de points flottants.
Si les exigences de précision sont extrêmement élevées, vous pouvez utiliser la fonction BCMATH de PHP:
<?php
$num = "1.9999999999999996";
$result = bcadd($num, '0', 0); // réserve0Numéro décimal，Cela équivaut à l'arrondir vers le bas
if (bccomp($num, $result, 10) > 0) {
$result = bcadd($result, '1', 0);
}
echo $result; // Sortir 2
?>
BCMATH utilise des chaînes pour représenter les nombres, en évitant les erreurs de points flottants.
Lorsque la plage numérique le permet, vous pouvez d'abord agrandir le numéro:
<?php
$num = 1.9999999999999996;
$scale = 8;
$num_scaled = (int)($num * pow(10, $scale));
$num_ceil = ceil($num_scaled / pow(10, $scale));
echo $num_ceil; // Sortir 2
?>
Cette méthode peut également atténuer le problème de l'erreur de précision des points flottants.
Les nombres de points flottants en PHP ont des erreurs de précision en raison de la représentation binaire sous-jacente;
La fonction CEIL () elle-même ne fera aucune erreur, mais l'erreur rend le paramètre d'entrée imprévu, entraînant une déviation dans le résultat;
Utilisez des techniques Round () , BCMath Extension ou Zoom-in pour éviter efficacement les problèmes.
Ce n'est qu'en comprenant la nature des nombres de points flottants et en prenant des mesures appropriées que cel () peut jouer un rôle précis et fiable dans les projets PHP.
