Conversion des flottants en leur fraction la plus proche (caractère UTF-8)

Question

Je souhaite prendre un nombre réel et renvoyer le nombre le plus proche, avec la fraction la plus proche disponible dans le jeu de caractères UTF-8, appropriée.

0/4 = 0.00 = # < .125 
1/4 = 0.25 = ¼ # > .125 & < .375 
2/4 = 0.50 = ½ # > .375 & < .625 
3/4 = 0.75 = ¾ # > .625 & < .875 
4/4 = 1.00 = # > .875 

J'ai fait cette fonction pour faire cette tâche:

function displayFraction($realNumber) 
{ 
    if (!is_float($realNumber)) 
    { 
     return $realNumber; 
    } 
    list($number, $decimal) = explode('.', $realNumber); 
    $decimal = '.' . $decimal; 
    switch($decimal) 
    { 
     case $decimal < 0.125: 
      return $number; 
     case $decimal > 0.125 && $decimal < 0.375: 
      return $number . '¼'; # 188 ¼ &#188; 
     case $decimal > 0.375 && $decimal < 0.625: 
      return $number . '½'; # 189 ½ &#189; 
     case $decimal > 0.625 && $decimal < 0.875: 
      return $number . '¾'; # 190 ¾ &#190; 
     case $decimal < 0.875: 
      return ++$number; 
    } 
} 

Quelles sont les mieux/façon de faire diffrent cela?

echo displayFraction(3.1) . PHP_EOL;  # Outputs: 3 
echo displayFraction(3.141593) . PHP_EOL; # Outputs: 3¼ 
echo displayFraction(3.267432) . PHP_EOL; # Outputs: 3¼ 
echo displayFraction(3.38) . PHP_EOL;  # Outputs: 3½ 

Élargir mon esprit!

Answer 1

Vous ne devez pas compter sur la présence d'une partie décimale:

# Will generate a STRICT warning if $realNumber does not contain a full stop: 
list($number, $decimal) = explode('.', $realNumber); 

Essayez ceci:

$integerPart = floor($realNumber); 
$decimalPart = $realPart - $integerPart; 

Vous ne devriez pas utiliser un interrupteur, mais plutôt si les déclarations (elle semblera fonctionner mais donnera des résultats inattendus si vous entrez 0, par exemple, puisque vous comparez $decimal au résultat de l'expression $decimal < 0.125):

if ($decimalPart <= 0.25) { 
    # ... 
} else if ($decimalPart <= 0.5) { 
    # ... 
} else if ... 

Answer 2

Vous avez implémenté un algorithme de recherche compilé statiquement pour choisir les fractions. Tant que le nombre de fractions unicode ne change pas beaucoup (ce qui ne sera pas le cas), alors ce que vous avez est bien. Passez.

Si vous viviez dans un monde où les fractions unicode changeaient souvent. Ensuite, vous devez faire passer votre recherche de codée en dur à pilotée par les données. Juste avoir une table de valeurs de fraction et leur équivalent unicode. Recherchez dans la table la fraction la plus proche, puis utilisez le char unicode associé.

Answer 3

On pourrait être "intelligent" et prendre (188 + (décimal-0,125) * 4) pour le cas où la décimale est entre 0,125 et 0,875, mais ce serait plus obfusant que malin, IMO. Cela dit, vous voulez probablement que votre dernier cas soit> 0,875 et non < 0,875.