multiplicar un complejo doble con un doble en Haskell

Question

yo estaba un poco sorprendido cuando el siguiente código no se compilará:

-- Code 1 
import Complex 
type Velocity = Complex Double 
type Force = Complex Double 
type FrictionCoeff = Double 

frictionForce :: FrictionCoeff -> Velocity -> Force 
frictionForce mu vel = mu * vel 

dice El error

Couldn't match expected type `Complex Double' 
      with actual type `Double' 
Expected type: Force 
Actual type: FrictionCoeff 
In the first argument of `(*)', namely `mu' 
In the expression: mu * vel 

Así que, en resumen

-- Code 2 
let z = 1 :+ 2 
z * 3  -- Goes fine. 
z * 2.5 -- Goes fine. 
z * (2.5 :: Double) -- Explodes. 

Complex define (*) como

instance (RealFloat a) => Num (Complex a) where 
    (x:+y) * (x':+y') = (x*x'-y*y') :+ (x*y'+y*x') 

¿Por qué 3 (Num a => a) y 2.5 (Fraccional a => a) se comparan con patrones (x: + y), pero un doble no?

Answer 1

En primer lugar, el tipo de operador de multiplicación es

(*) :: Num a => a -> a -> a 

lo que significa que sólo se puede multiplicar números del mismo tipo, que es la razón por la multiplicación de una Complex Double por un Double no va a funcionar.

Entonces, ¿por qué la multiplicación de un número complejo con un literal decimal funciona?

Funciona porque los literales numéricos son polimórficos en Haskell, por lo que cuando escribe un entero literal como 42, realmente significa fromInteger 42. Del mismo modo, literales decimales como 2.3 se convierte en fromRational (23 % 10). Si examina los tipos de esas funciones,

fromInteger :: Num a => Integer -> a 
fromRational :: Fractional a => Rational -> a 

Esto significa que literales enteros pueden ser de cualquier tipo numérico, mientras que los literales decimales pueden ser cualquier tipo fraccional. Los números complejos son ambos, por lo que funcionan tanto z * 3 como z * 2.5.

Cuando no se trata de literales, debe convertir.Por ejemplo, su función original puede ser fijado por la escritura:

frictionForce :: FrictionCoeff -> Velocity -> Force 
frictionForce mu vel = (mu :+ 0) * vel 

Encontrar la función de conversión adecuada es muy fácil usando Hoogle, ya que se puede buscar por tipo de funciones. En este caso, la búsqueda de Double -> Complex Double da como resultado superior (:+).

Answer 2

No se puede multiplicar un número real con un número complejo, incluso en "matemática real"; cuando desee tomar 2 * (2 + 3i), lo que realmente calcule es (2 + 0i) * (2 + 3i). Del mismo modo, en Haskell, cuando dice:

let z = 1 :+ 2 
z * 3 

... luego 3 se convierte en un Complex Double así, por lo que la parte imaginaria cero. Esto solo ocurre con los números literales (2, 3.141, etc.) debido a la funcionalidad literal sobrecargada de Haskell; dado que los literales no tienen un tipo predeterminado (pueden representar valores de cualquier tipo de número), Haskell puede decir que el 3 tiene el tipo Complex Double en este contexto, y las funciones de conversión apropiadas se llaman automáticamente.

Si desea hacer esta conversión manualmente, es decir, hacer un número complejo de un número real que sea una variable o que ya tenga un tipo fijo diferente, debe usar la función realToFrac, que convierte cualquier real número en cualquier número fraccionario (y un Complex cuenta como un número fraccionario en este caso).

z * realToFrac (2.5 :: Double) 

Por supuesto, puede también añadir manualmente :+ 0 si que se ve más ordenado para usted.