Why are these 2 big Float values not equal?

During the past 2 weeks I have been studying the behaviour and functionalities of floating points and specifically big Floats in GO . I encountered numerous behaviours and found answers by myself. But still, there is one answer I couldn't find myself.

https://play.golang.org/p/-y0oeb2Jisv

value1 := big.NewFloat(137216723432.8234782347)
value2 := big.NewFloat(71371.92602458)
for i := 0; i < 300; i++ {
	value1.Sub(value1, value2)
}

value3 := big.NewFloat(137216723432.8234782347)
value4 := big.NewFloat(71371.92602458)
for i := 0; i < 300; i++ {
	result := big.NewFloat(0).Sub(value3,value4)
	value3.Set(result)
}

encodedValue1, _ := value1.GobEncode()
encodedValue3, _ := value3.GobEncode()

if value1 == value3 {
	fmt.Println("values are equal" , value1 , value3)
} else {
	fmt.Println("values are not equal", value1 ,value3)
}

fmt.Println("difference is here:\n", encodedValue1,"\n", encodedValue3)

Why is the result of these 2 operations not equal? From my understanding it is something that has to do with precision/accuracy/rounding mode.

Thank you!

value1 and value3 are pointers, so value1 == value3 compares those pointers, not the pointed values. It may be possible 2 pointed objects are equal yet their addresses are not.

To compare big.Float values (or *big.Float), use the Float.Cmp() method. It returns 0 if the 2 values (the numbers they represent) are equal.

if value1.Cmp(value3) == 0 {
	fmt.Println("values are equal", value1, value3)
} else {
	fmt.Println("values are not equal", value1, value3)
}

With this change output will be (try it on the Go Playground):

values are equal 1.3719531185501585e+11 1.3719531185501585e+11
difference is here:
 [1 2 0 0 0 53 0 0 0 37 255 139 210 151 120 32 120 0] 
 [1 10 0 0 0 53 0 0 0 37 255 139 210 151 120 32 120 0]

So the represented numbers are equal.

The serialized binary form returned by Float.GobEncode() is not the same, but that doesn't mean the represented numbers are not equal. As its documentation states:

> GobEncode implements the gob.GobEncoder interface. The Float value and all its attributes (precision, rounding mode, accuracy) are marshaled.

The output is different because internals of big.Float are not the same (in this case the Accuracy). In this case even if you could compare the pointed objects, those would not be the same, but the represented numbers are. Again, always use the provided methods to compare complex objects, and certainly not the addresses.

The difference in this example comes from the stored accuracy field:

fmt.Println(value1.Acc())
fmt.Println(value3.Acc())

Which outputs (try it on the Go Playground):

Below
Exact

The accuracy returned by Float.Acc() is the "accuracy of x produced by the most recent operation". Since the last operation performed on value1 and value3 are not the same (value1.Sub() and value3.Set()), the accuracy field is not necessarily the same (and in this example they do differ). And since the accuracy property is also included in the Gob serialized form, that's why their serialized forms are different.