операций с плавающей точкой в

Вот пример кода в go:

package main

import "fmt"

func mult32(a, b float32) float32 { return a*b }
func mult64(a, b float64) float64 { return a*b }


func main() {
    fmt.Println(3*4.3)                  // A1, 12.9
    fmt.Println(mult32(3, 4.3))         // B1, 12.900001
    fmt.Println(mult64(3, 4.3))         // C1, 12.899999999999999

    fmt.Println(12.9 - 3*4.3)           // A2, 1.8033161362862765e-130
    fmt.Println(12.9 - mult32(3, 4.3))  // B2, -9.536743e-07
    fmt.Println(12.9 - mult64(3, 4.3))  // C2, 1.7763568394002505e-15

    fmt.Println(12.9 - 3*4.3)                               // A4, 1.8033161362862765e-130
    fmt.Println(float32(12.9) - float32(3)*float32(4.3))    // B4, -9.536743e-07
    fmt.Println(float64(12.9) - float64(3)*float64(4.3))    // C4, 1.7763568394002505e-15

}

Результаты различия между линиями A1, B1 и C1 понятны. Однако, начиная с А2 до С2, приходит магия. В результате ни Б2, ни С2 соответствует результату от линии А2. То же самое верно и для линий x2 (x = A, B или C) - но выходы x2 и x4 одинаковы.

Просто для уверенности давайте напечатаем результаты в двоичном виде.

    fmt.Printf("%bn", 3*4.3)                   // A11, 7262054399134925p-49
    fmt.Printf("%bn", mult32(3, 4.3))          // B11, 13526631p-20
    fmt.Printf("%bn", mult64(3, 4.3))          // C11, 7262054399134924p-49

    fmt.Printf("%bn", 12.9 - 3*4.3)            // A12, 4503599627370496p-483
    fmt.Printf("%bn", 12.9 - mult32(3, 4.3))   // B12, -8388608p-43
    fmt.Printf("%bn", 12.9 - mult64(3, 4.3))   // C12, 4503599627370496p-101

    fmt.Printf("%bn", 12.9 - 3*4.3)                                // A14, 4503599627370496p-483
    fmt.Printf("%bn", float32(12.9) - float32(3)*float32(4.3))     // B14, -8388608p-43
    fmt.Printf("%bn", float64(12.9) - float64(3)*float64(4.3))     // C14, 4503599627370496p-101

Некоторые факты из приведенного выше кода (один в форме бин):

1. есть разница между строками А11 и С11 (последняя цифра-непосредственно перед показателем степени).
2. линии A12 и C12 почти одинаковы (за исключением экспоненты!!!), то же самое можно наблюдать между линиями А14 и С14.

И тут возникают вопросы:

1. как выполняются вычисления голых (naked :)) чисел? (вычисления в каждой строке Axx)
2. выполняются ли они компилятором / чем угодно?
3. если да, то почему они отличаются? Оптимизация?
4. являются ли они вычисляется в некоторой системе, которая отличается от IEE-754?
5. если да, то почему?
Оправдывает ли такой подход достижение более точной точности?

Код был протестирован на 64-битном linux под обоими "go run" и "go build" (go1.0.3), а также на этом сайте: http://tour.golang.org/