Haskell LanguageAritmética


Introducción

En Haskell, todas las expresiones (que incluyen las constantes numéricas y las funciones que operan en ellas) tienen un tipo decidible. En el momento de la compilación, el comprobador de tipos infiere el tipo de una expresión de los tipos de funciones elementales que la componen. Dado que los datos son inmutables de manera predeterminada, no hay operaciones de "conversión de tipo", pero hay funciones que copian los datos y generalizan o especializan los tipos dentro de la razón.

Observaciones

La jerarquía de clases de tipo numérico.

Num encuentra en la raíz de la jerarquía de clases de tipo numérica. A continuación se muestran sus operaciones características y algunas instancias comunes (las cargadas de forma predeterminada con Prelude más las de Data.Complex ):

λ> :i Num
class Num a where
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  (*) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a
  {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
      -- Defined in ‘GHC.Num’
instance RealFloat a => Num (Complex a) -- Defined in ‘Data.Complex’
instance Num Word -- Defined in ‘GHC.Num’
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Int -- Defined in ‘GHC.Num’
instance Num Float -- Defined in ‘GHC.Float’
instance Num Double -- Defined in ‘GHC.Float’

Ya hemos visto la clase Fractional , que requiere Num e introduce las nociones de "división" (/) y recíproco de un número:

λ> :i Fractional
class Num a => Fractional a where
  (/) :: a -> a -> a
  recip :: a -> a
  fromRational :: Rational -> a
  {-# MINIMAL fromRational, (recip | (/)) #-}
      -- Defined in ‘GHC.Real’
instance RealFloat a => Fractional (Complex a) -- Defined in ‘Data.Complex’
instance Fractional Float -- Defined in ‘GHC.Float’
instance Fractional Double -- Defined in ‘GHC.Float’

La clase Real modela ... los números reales. Requiere Num y Ord , por lo tanto, modela un campo numérico ordenado. Como contraejemplo, los números complejos no son un campo ordenado (es decir, no poseen una relación de orden natural):

λ> :i Real
class (Num a, Ord a) => Real a where
  toRational :: a -> Rational
  {-# MINIMAL toRational #-}
      -- Defined in ‘GHC.Real’
instance Real Word -- Defined in ‘GHC.Real’
instance Real Integer -- Defined in ‘GHC.Real’
instance Real Int -- Defined in ‘GHC.Real’
instance Real Float -- Defined in ‘GHC.Float’
instance Real Double -- Defined in ‘GHC.Float’

RealFrac representa números que pueden ser redondeados

λ> :i RealFrac
class (Real a, Fractional a) => RealFrac a where
  properFraction :: Integral b => a -> (b, a)
  truncate :: Integral b => a -> b
  round :: Integral b => a -> b
  ceiling :: Integral b => a -> b
  floor :: Integral b => a -> b
  {-# MINIMAL properFraction #-}
      -- Defined in ‘GHC.Real’
instance RealFrac Float -- Defined in ‘GHC.Float’
instance RealFrac Double -- Defined in ‘GHC.Float’

Floating (lo que implica Fractional ) representa constantes y operaciones que pueden no tener una expansión decimal finita.

λ> :i Floating
class Fractional a => Floating a where
  pi :: a
  exp :: a -> a
  log :: a -> a
  sqrt :: a -> a
  (**) :: a -> a -> a
  logBase :: a -> a -> a
  sin :: a -> a
  cos :: a -> a
  tan :: a -> a
  asin :: a -> a
  acos :: a -> a
  atan :: a -> a
  sinh :: a -> a
  cosh :: a -> a
  tanh :: a -> a
  asinh :: a -> a
  acosh :: a -> a
  atanh :: a -> a
  GHC.Float.log1p :: a -> a
  GHC.Float.expm1 :: a -> a
  GHC.Float.log1pexp :: a -> a
  GHC.Float.log1mexp :: a -> a
  {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh,
              asinh, acosh, atanh #-}
      -- Defined in ‘GHC.Float’
instance RealFloat a => Floating (Complex a) -- Defined in ‘Data.Complex’
instance Floating Float -- Defined in ‘GHC.Float’
instance Floating Double -- Defined in ‘GHC.Float’

Precaución: mientras que expresiones como sqrt . negate :: Floating a => a -> a son perfectamente válidos, pueden devolver NaN ("no-a-number"), que puede no ser un comportamiento intencionado. En tales casos, podríamos querer trabajar sobre el campo Complejo (se muestra más adelante).

Aritmética Ejemplos relacionados