(Nota: acrescentarei 'b' para indicar números binários aqui. Todos os outros números são dados em decimal)
Uma maneira de pensar sobre as coisas é em termos de algo como notação científica. Estamos acostumados a ver números expressos em notação científica como 6.022141 * 10 ^ 23. Os números de ponto flutuante são armazenados internamente usando um formato semelhante - mantissa e expoente, mas usando potências de dois em vez de dez.
Seu 61.0 pode ser reescrito como 1.90625 * 2 ^ 5 ou 1.11101b * 2 ^ 101b com a mantissa e os expoentes. Para multiplicar por dez e (mover o ponto decimal), podemos fazer:
(1,90625 * 2 ^ 5) * (1,25 * 2 ^ 3) = (2,3828125 * 2 ^ 8) = (1,19140625 * 2 ^ 9)
ou com a mantissa e expoentes em binário:
(1.11101b * 2 ^ 101b) * (1.01b * 2 ^ 11b) = (10.0110001b * 2 ^ 1000b) = (1.00110001b * 2 ^ 1001b)
Observe o que fizemos lá para multiplicar os números. Nós multiplicamos as mantissas e adicionamos os expoentes. Então, como a mantissa terminou acima de dois, normalizamos o resultado batendo no expoente. É como quando ajustamos o expoente após fazer uma operação em números em notação científica decimal. Em cada caso, os valores com os quais trabalhamos tinham uma representação finita em binário e, portanto, os valores gerados pelas operações básicas de multiplicação e adição também produziam valores com uma representação finita.
Agora, considere como dividiríamos 61 por 10. Começaríamos dividindo as mantissas, 1,90625 e 1,25. Em decimal, isso dá 1,525, um bom número curto. Mas o que é isso se o convertermos em binário? Faremos isso da maneira usual - subtraindo a maior potência de duas sempre que possível, assim como converter decimais inteiros em binários, mas usaremos potências negativas de duas:
1,525 - 1 * 2 ^ 0 -> 1
0,525 - 1 * 2 ^ -1 -> 1
0,025 - 0 * 2 ^ -2 -> 0
0,025 - 0 * 2 ^ -3 -> 0
0,025 - 0 * 2 ^ -4 -> 0
0,025 - 0 * 2 ^ -5 -> 0
0,025 - 1 * 2 ^ -6 -> 1
0,009375 - 1 * 2 ^ -7 -> 1
0,0015625 - 0 * 2 ^ -8 -> 0
0,0015625 - 0 * 2 ^ -9 -> 0
0,0015625 - 1 * 2 ^ -10 -> 1
0,0005859375 - 1 * 2 ^ -11 -> 1
0,00009765625 ...
Ah, oh. Agora estamos com problemas. Acontece que 1.90625 / 1.25 = 1.525, é uma fração repetida quando expressa em binário: 1.11101b / 1.01b = 1.10000110011 ... b Nossas máquinas só têm tantos bits para manter essa mantissa e, portanto, arredondam a fração e assuma zeros além de um certo ponto. O erro que você vê ao dividir 61 por 10 é a diferença entre:
1.100001100110011001100110011001100110011 ... b * 2 ^ 10b
e, digamos:
1.100001100110011001100110b * 2 ^ 10b
É esse arredondamento da mantissa que leva à perda de precisão que associamos aos valores de ponto flutuante. Mesmo quando a mantissa pode ser expressa exatamente (por exemplo, ao adicionar apenas dois números), ainda podemos obter perdas numéricas se a mantissa precisar de muitos dígitos para ajustar após a normalização do expoente.
Na verdade, fazemos esse tipo de coisa o tempo todo quando arredondamos números decimais para um tamanho gerenciável e apenas fornecemos os primeiros dígitos. Como expressamos o resultado em decimal, parece natural. Mas se arredondássemos um decimal e depois o convertêssemos em uma base diferente, ficaria tão feio quanto os decimais que obtemos devido ao arredondamento do ponto flutuante.