Flutuante vs decimal no ActiveRecord

Às vezes, os tipos de dados do Activerecord me confundem. Erre, frequentemente. Uma das minhas eternas perguntas é, para um dado caso,

Devo usar :decimalou :float?

Eu sempre encontrei esse link, ActiveRecord:: decimal vs: float? , mas as respostas não são suficientemente claras para que eu tenha certeza:

Eu já vi muitos tópicos em que as pessoas recomendam flat out para nunca usar float e sempre usar decimal. Também vi sugestões de algumas pessoas para usar o float apenas para aplicações científicas.

Aqui estão alguns exemplos de casos:

• Geolocalização / latitude / longitude: -45.756688, 120.5777777, ...
• Rácio / porcentagem: 0.9, 1.25, 1.333, 1.4143, ...

Eu usei :decimalno passado, mas achei que lidar com BigDecimalobjetos em Ruby era desnecessariamente estranho em comparação com um flutuador. Também sei que posso usar :integerpara representar dinheiro / centavos, por exemplo, mas não se encaixa em outros casos, por exemplo, quando quantidades em que a precisão pode mudar com o tempo.

• Quais são as vantagens / desvantagens de usar cada um?
• Quais seriam algumas boas regras práticas para saber qual tipo usar?

Lembro-me de meu professor do CompSci dizendo para nunca usar carros alegóricos como moeda.

A razão para isso é como a especificação IEEE define flutuadores no formato binário. Basicamente, ele armazena sinal, fração e expoente para representar um flutuador. É como uma notação científica para binário (algo como +1.43*10^2). Por isso, é impossível armazenar exatamente frações e decimais no Float.

É por isso que existe um formato decimal. Se você fizer isto:

irb:001:0> "%.47f" % (1.0/10)
=> "0.10000000000000000555111512312578270211815834045" # not "0.1"!

enquanto que se você fizer

irb:002:0> (1.0/10).to_s
=> "0.1" # the interprer rounds the number for you

Portanto, se você estiver lidando com frações pequenas, como juros compostos ou talvez até geolocalização, eu recomendo o formato Decimal, pois no formato decimal 1.0/10é exatamente 0,1.

No entanto, deve-se notar que, apesar de serem menos precisos, os carros alegóricos são processados ​​mais rapidamente. Aqui está uma referência:

require "benchmark" 
require "bigdecimal" 

d = BigDecimal.new(3) 
f = Float(3)

time_decimal = Benchmark.measure{ (1..10000000).each { |i| d * d } } 
time_float = Benchmark.measure{ (1..10000000).each { |i| f * f } }

puts time_decimal 
#=> 6.770960 seconds 
puts time_float 
#=> 0.988070 seconds

Responda

Use float quando não se importa muito com precisão. Por exemplo, algumas simulações e cálculos científicos precisam apenas de 3 ou 4 dígitos significativos. Isso é útil na troca de precisão por velocidade. Como eles não precisam tanto de precisão quanto de velocidade, usariam float.

Use decimal se estiver lidando com números que precisam ser precisos e que resumam o número correto (como juros compostos e coisas relacionadas a dinheiro). Lembre-se: se você precisar de precisão, use sempre decimal.

No Rails 3.2.18,: decimal se transforma em: número inteiro ao usar o SQLServer, mas funciona bem no SQLite. Mudar para: float resolveu esse problema para nós.

A lição aprendida é "sempre use bancos de dados homogêneos de desenvolvimento e implantação!"

No Rails 4.1.0, eu enfrentei um problema ao salvar latitude e longitude no banco de dados MySql. Ele não pode salvar um número de fração grande com o tipo de dados flutuante. E mudo o tipo de dados para decimal e trabalhando para mim.

  mudança de definição
    change_column: cities,: latitude,: decimal,: precision => 15,: scale => 13
    change_column: cities,: longitude,: decimal,: precision => 15,: scale => 13
  fim