Perché Groovy esegue l'aritmetica in virgola mobile in questo modo?

Question

Provare aritmetica in virgola mobile in Groovy. Non hai idea del perché/come/che groovy sta facendo dietro le quinte per provocare questi diversi tipi di comportamenti?

double point2 = 0.2 
double point1 = 0.1 
double point3 = 0.3 

assert point2 + point1 == point3 // false, as expected 
    |  | |  | | 
    0.2 | 0.1 | 0.3 
      |  false 
      0.30000000000000004  

float point2 = 0.2 
float point1 = 0.1 
float point3 = 0.3 

assert point2 + point1 == point3 // false, as expected 
    |  | |  | | 
    0.2 | 0.1 | 0.3 
      |  false 
      0.30000000447034836 

def point2 = 0.2 
def point1 = 0.1 
def point3 = 0.3 

assert point2 + point1 == point3 // this returns true 
assert 0.2 + 0.1 == 0.3 // this returns true 

Ho pensato che avesse a che fare con BigDecimal ma poi ho provato questo.

BigDecimal point2 = 0.2 
BigDecimal point1 = 0.1 
BigDecimal point3 = 0.3 

float point4 = 0.4 

assert point1 + point3 == point4 
    |  | |  | | 
    0.1 | 0.3 | 0.4 
      0.4  false 

Che cosa sta causando questo comportamento?

Answer 1

tua def: s ci sono BigDecimals

groovy:000> p1 = 0.1 
===> 0.1 
groovy:000> p1.getClass() 
===> class java.math.BigDecimal 

E equals fallisce per comparsion tra BigDecimal e il galleggiante nativo/doppia

groovy:000> p1.equals(0.1f) 
===> false 
groovy:000> p1.equals(0.1) 
===> true 
groovy:000> p1==0.1f 
===> false 
groovy:000> p1==0.1 
===> true 

Non lo so ancora, perché == lavori per [gg] ouble .

groovy:000> p1.equals(0.1d) 
===> false 
groovy:000> p1==0.1d 
===> true 

La mia ipotesi è, che è sepolto in DefaultTypeTransformation.compareToWithEqualityCheck. Poiché entrambi i lati sono numeri: s.