Lavorare con i float
********************
.[perex]
[api:Nette\Utils\Floats] è una classe statica che contiene utili funzioni per confrontare i numeri in virgola mobile.
Installazione:
```shell
composer require nette/utils
```
Tutti gli esempi presuppongono che sia definito questo alias di classe:
```php
use Nette\Utils\Floats;
```
Motivazione
===========
Vi state chiedendo perché serva una classe per confrontare i float? In fondo bastano gli operatori `<`, `>`, `===` e il gioco è fatto, no? Beh, non è del tutto vero. Cosa pensate che stampi questo codice?
```php
$a = 0.1 + 0.2;
$b = 0.3;
echo $a === $b ? 'same' : 'not same';
```
Se eseguite il codice, alcuni di voi resteranno sorpresi dal fatto che il programma stampa `not same`.
Le operazioni matematiche con i numeri in virgola mobile possono portare a errori di precisione, dovuti alla conversione tra la rappresentazione decimale e quella binaria. Per esempio `0.1 + 0.2` dà come risultato qualcosa come `0.300000000000000044…`. Confrontando i float dobbiamo quindi tollerare una piccola differenza, un epsilon.
Ed è esattamente ciò che fa la classe `Floats`. Il confronto seguente funzionerà ora come ci aspettiamo:
```php
echo Floats::areEqual($a, $b) ? 'same' : 'not same'; // same
```
Il tentativo di confrontare `NAN` solleva una `\LogicException`.
.[tip]
La classe `Floats` confronta con una precisione relativa di circa `1e-10`. Se avete bisogno di lavorare con una precisione maggiore, valutate di usare la libreria BCMath.
Confronto dei float
===================
areEqual(float $a, float $b): bool .[method]
--------------------------------------------
Restituisce `true` se `$a` = `$b`.
```php
Floats::areEqual(10, 10.0); // true
```
isLessThan(float $a, float $b): bool .[method]
----------------------------------------------
Restituisce `true` se `$a` < `$b`.
```php
Floats::isLessThan(9.5, 10.2); // true
Floats::isLessThan(INF, 10.2); // false
```
isLessThanOrEqualTo(float $a, float $b): bool .[method]
-------------------------------------------------------
Restituisce `true` se `$a` <= `$b`.
```php
Floats::isLessThanOrEqualTo(9.5, 10.2); // true
Floats::isLessThanOrEqualTo(10.25, 10.25); // true
```
isGreaterThan(float $a, float $b): bool .[method]
-------------------------------------------------
Restituisce `true` se `$a` > `$b`.
```php
Floats::isGreaterThan(9.5, -10.2); // true
Floats::isGreaterThan(9.5, 10.2); // false
```
isGreaterThanOrEqualTo(float $a, float $b): bool .[method]
----------------------------------------------------------
Restituisce `true` se `$a` >= `$b`.
```php
Floats::isGreaterThanOrEqualTo(9.5, 10.2); // false
Floats::isGreaterThanOrEqualTo(10.2, 10.2); // true
```
compare(float $a, float $b): int .[method]
------------------------------------------
Restituisce `-1` se `$a` < `$b`, `0` se sono uguali e `1` se `$a` > `$b`.
Si può usare per esempio con la funzione `usort()`.
```php
$arr = [1, 5, 2, -3.5];
usort($arr, [Floats::class, 'compare']);
// $arr ora è [-3.5, 1, 2, 5]
```
Funzioni di supporto
====================
isZero(float $value): bool .[method]
------------------------------------
Restituisce `true` se il valore è zero.
```php
Floats::isZero(0.0); // true
Floats::isZero(0); // true
```
isInteger(float $value): bool .[method]
---------------------------------------
Restituisce `true` se il valore è un intero.
```php
Floats::isInteger(0); // true
Floats::isInteger(0.0); // true
Floats::isInteger(-5.0); // true
Floats::isInteger(-5.1); // false
Floats::isInteger(INF); // false
Floats::isInteger(NAN); // false
```
Lavorare con i float
Nette\Utils\Floats è una classe statica
che contiene utili funzioni per confrontare i numeri in virgola mobile.
Installazione:
composer require nette/utils
Tutti gli esempi presuppongono che sia definito questo alias di classe:
use Nette\Utils\Floats;
Motivazione
Vi state chiedendo perché serva una classe per confrontare i float? In fondo bastano gli operatori <,
>, === e il gioco è fatto, no? Beh, non è del tutto vero. Cosa pensate che stampi questo
codice?
$a = 0.1 + 0.2;
$b = 0.3;
echo $a === $b ? 'same' : 'not same';
Se eseguite il codice, alcuni di voi resteranno sorpresi dal fatto che il programma stampa not same.
Le operazioni matematiche con i numeri in virgola mobile possono portare a errori di precisione, dovuti alla conversione tra la
rappresentazione decimale e quella binaria. Per esempio 0.1 + 0.2 dà come risultato qualcosa come
0.300000000000000044…. Confrontando i float dobbiamo quindi tollerare una piccola differenza, un epsilon.
Ed è esattamente ciò che fa la classe Floats. Il confronto seguente funzionerà ora come ci aspettiamo:
echo Floats::areEqual($a, $b) ? 'same' : 'not same'; // same
Il tentativo di confrontare NAN solleva una \LogicException.
La classe Floats confronta con una precisione relativa di circa 1e-10. Se avete bisogno
di lavorare con una precisione maggiore, valutate di usare la libreria BCMath.
Confronto dei float
areEqual (float $a, float $b): bool
Restituisce true se $a = $b.
Floats::areEqual(10, 10.0); // true
isLessThan (float $a, float $b): bool
Restituisce true se $a < $b.
Floats::isLessThan(9.5, 10.2); // true
Floats::isLessThan(INF, 10.2); // false
isLessThanOrEqualTo (float $a,
float $b): bool
Restituisce true se $a <= $b.
Floats::isLessThanOrEqualTo(9.5, 10.2); // true
Floats::isLessThanOrEqualTo(10.25, 10.25); // true
isGreaterThan (float $a, float
$b): bool
Restituisce true se $a > $b.
Floats::isGreaterThan(9.5, -10.2); // true
Floats::isGreaterThan(9.5, 10.2); // false
isGreaterThanOrEqualTo (float $a,
float $b): bool
Restituisce true se $a >= $b.
Floats::isGreaterThanOrEqualTo(9.5, 10.2); // false
Floats::isGreaterThanOrEqualTo(10.2, 10.2); // true
compare (float $a, float $b): int
Restituisce -1 se $a < $b, 0 se sono uguali e 1 se
$a > $b.
Si può usare per esempio con la funzione usort().
$arr = [1, 5, 2, -3.5];
usort($arr, [Floats::class, 'compare']);
// $arr ora è [-3.5, 1, 2, 5]
Funzioni di supporto
isZero (float $value): bool
Restituisce true se il valore è zero.
Floats::isZero(0.0); // true
Floats::isZero(0); // true
isInteger (float $value): bool
Restituisce true se il valore è un intero.
Floats::isInteger(0); // true
Floats::isInteger(0.0); // true
Floats::isInteger(-5.0); // true
Floats::isInteger(-5.1); // false
Floats::isInteger(INF); // false
Floats::isInteger(NAN); // false