Uso excesivo deIntegral en Haskell

Question

Cada vez que escribo una función usando dobles y enteros, encuentro este problema donde constantemente tengo que usar 'fromIntegral' en todas partes en mi función. Por ejemplo:

import Data.List 

roundDouble 
    :: Double 
    -> Int 
    -> Double 
roundDouble x acc = fromIntegral (round $ x * 10 ** fromIntegral acc)/10 ** fromIntegral acc 

¿Hay alguna manera más fácil de escribir esto? (Sé que puede haber formas más fáciles de redondeo un número y si hay por favor hágamelo saber! Sin embargo, estoy interesado principalmente en la forma de evitar el uso de tantos 'fromIntegrals'.)

Gracias, Ash

Answer 1

veces encuentro una función auxiliar útil:

roundDouble x acc = (round $ x * 10^acc) /. (10^acc) 
    where 
    x /. y = fromIntegral x/fromIntegral y 

Esa función auxiliar también se puede escribir:

(/.) = (/) `on` fromIntegral 

Dónde on es de Data.Function.

Answer 2

Usted puede usar ^ en lugar de **. ^ toma Integral como su segundo argumento, por lo que no necesita llamar al fromIntegral en el segundo operando. Por lo que su código se convierte en:

roundDouble x acc = fromIntegral ($ redonda x 10^* acc)/10^acc

que sólo tiene un fromIntegral. Y ese que no puede deshacerse como round, naturalmente, devuelve un Integral y no puede realizar una división no entera en un Integral.

Answer 3

Tengo un problema similar con el código de cálculo de referencias, donde fromIntegral se usa para convertir CInt a Int. Normalmente defino fI = fromIntegral para hacerlo más fácil. También puede necesitar darle una firma de tipo explícita o usar -XNoMonomorphismRestriction.

Si está haciendo un montón de matemáticas, es posible que desee mirar el Numeric Prelude, que parece tener relaciones mucho más sensatas entre los diferentes tipos numéricos.

Answer 4

Otra idea, similar a luqui's. La mayoría de mis problemas con fromIntegral están relacionados con la necesidad de dividir Int por Double o Double por Int. Por lo que este (/.) permite dividir cualquier par de Real tipos, no necesariamente el mismo, un no necesariamente Integral tipos, como en la solución de Luqui:

(/.) :: (Real a, Real b, Fractional c) => a -> b -> c 
(/.) x y = fromRational $ (toRational x)/(toRational y) 

Ejemplo:

ghci> let (a,b,c) = (2::Int, 3::Double, 5::Int) 
ghci> (b/.a, c/.a, a/.c) 
(1.5,2.5,0.4) 

Funciona para cualquier par de Real s, pero sospecho que la división racional y la conversión a/desde Rational no son muy efectivas.

Ahora su ejemplo se convierte en:

roundDouble :: Double -> Int -> Double 
roundDouble x acc = (round $ x * 10^acc) /. (10^acc)