    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE DeriveTraversable #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Data.Complex
    -- Copyright   :  (c) The University of Glasgow 2001
    -- License     :  BSD-style (see the file libraries/base/LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  provisional
    -- Portability :  portable
    --
    -- Complex numbers.
    --
    -----------------------------------------------------------------------------

    module Data.Complex
            (
            -- * Rectangular form
              Complex((:+))

            , realPart
            , imagPart
            -- * Polar form
            , mkPolar
            , cis
            , polar
            , magnitude
            , phase
            -- * Conjugate
            , conjugate

            )  where

    import GHC.Base (Applicative (..))
    import GHC.Generics (Generic, Generic1)
    import GHC.Float (Floating(..))
    import Data.Data (Data)
    import Foreign (Storable, castPtr, peek, poke, pokeElemOff, peekElemOff, sizeOf,
                    alignment)
    import Control.Monad.Fix (MonadFix(..))
    import Control.Monad.Zip (MonadZip(..))

    infix  6  :+

    -- -----------------------------------------------------------------------------
    -- The Complex type

    -- | Complex numbers are an algebraic type.
    --
    -- For a complex number @z@, @'abs' z@ is a number with the magnitude of @z@,
    -- but oriented in the positive real direction, whereas @'signum' z@
    -- has the phase of @z@, but unit magnitude.
    --
    -- The 'Foldable' and 'Traversable' instances traverse the real part first.
    --
    -- Note that `Complex`'s instances inherit the deficiencies from the type
    -- parameter's. For example, @Complex Float@'s 'Ord' instance has similar
    -- problems to `Float`'s.
    data Complex a
      = !a :+ !a    -- ^ forms a complex number from its real and imaginary
                    -- rectangular components.
            deriving ( Complex a -> Complex a -> Bool
    forall a. Eq a => Complex a -> Complex a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Complex a -> Complex a -> Bool
    $c/= :: forall a. Eq a => Complex a -> Complex a -> Bool
    == :: Complex a -> Complex a -> Bool
    $c== :: forall a. Eq a => Complex a -> Complex a -> Bool
    Eq          -- ^ @since 2.01
                     , Int -> Complex a -> ShowS
    forall a. Show a => Int -> Complex a -> ShowS
    forall a. Show a => [Complex a] -> ShowS
    forall a. Show a => Complex a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Complex a] -> ShowS
    $cshowList :: forall a. Show a => [Complex a] -> ShowS
    show :: Complex a -> String
    $cshow :: forall a. Show a => Complex a -> String
    showsPrec :: Int -> Complex a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> Complex a -> ShowS
    Show        -- ^ @since 2.01
                     , ReadPrec [Complex a]
    ReadPrec (Complex a)
    ReadS [Complex a]
    forall a. Read a => ReadPrec [Complex a]
    forall a. Read a => ReadPrec (Complex a)
    forall a. Read a => Int -> ReadS (Complex a)
    forall a. Read a => ReadS [Complex a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Complex a]
    $creadListPrec :: forall a. Read a => ReadPrec [Complex a]
    readPrec :: ReadPrec (Complex a)
    $creadPrec :: forall a. Read a => ReadPrec (Complex a)
    readList :: ReadS [Complex a]
    $creadList :: forall a. Read a => ReadS [Complex a]
    readsPrec :: Int -> ReadS (Complex a)
    $creadsPrec :: forall a. Read a => Int -> ReadS (Complex a)
    Read        -- ^ @since 2.01
                     , Complex a -> Constr
    Complex a -> DataType
    forall {a}. Data a => Typeable (Complex a)
    forall a. Data a => Complex a -> Constr
    forall a. Data a => Complex a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Complex a -> Complex a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Complex a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Complex a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Complex a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Complex a -> c (Complex a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Complex a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Complex a))
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Complex a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Complex a -> c (Complex a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Complex a))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Complex a -> u
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Complex a -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Complex a -> [u]
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Complex a -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Complex a -> r
    gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Complex a -> Complex a
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Complex a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Complex a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Complex a))
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Complex a))
    dataTypeOf :: Complex a -> DataType
    $cdataTypeOf :: forall a. Data a => Complex a -> DataType
    toConstr :: Complex a -> Constr
    $ctoConstr :: forall a. Data a => Complex a -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Complex a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Complex a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Complex a -> c (Complex a)
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Complex a -> c (Complex a)
    Data        -- ^ @since 2.01
                     , forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Complex a) x -> Complex a
    forall a x. Complex a -> Rep (Complex a) x
    $cto :: forall a x. Rep (Complex a) x -> Complex a
    $cfrom :: forall a x. Complex a -> Rep (Complex a) x
    Generic     -- ^ @since 4.9.0.0
                     , forall a. Rep1 Complex a -> Complex a
    forall a. Complex a -> Rep1 Complex a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cto1 :: forall a. Rep1 Complex a -> Complex a
    $cfrom1 :: forall a. Complex a -> Rep1 Complex a
    Generic1    -- ^ @since 4.9.0.0
                     , forall a b. a -> Complex b -> Complex a
    forall a b. (a -> b) -> Complex a -> Complex b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Complex b -> Complex a
    $c<$ :: forall a b. a -> Complex b -> Complex a
    fmap :: forall a b. (a -> b) -> Complex a -> Complex b
    $cfmap :: forall a b. (a -> b) -> Complex a -> Complex b
    Functor     -- ^ @since 4.9.0.0
                     , forall a. Eq a => a -> Complex a -> Bool
    forall a. Num a => Complex a -> a
    forall a. Ord a => Complex a -> a
    forall m. Monoid m => Complex m -> m
    forall a. Complex a -> Bool
    forall a. Complex a -> Int
    forall a. Complex a -> [a]
    forall a. (a -> a -> a) -> Complex a -> a
    forall m a. Monoid m => (a -> m) -> Complex a -> m
    forall b a. (b -> a -> b) -> b -> Complex a -> b
    forall a b. (a -> b -> b) -> b -> Complex a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Complex a -> a
    $cproduct :: forall a. Num a => Complex a -> a
    sum :: forall a. Num a => Complex a -> a
    $csum :: forall a. Num a => Complex a -> a
    minimum :: forall a. Ord a => Complex a -> a
    $cminimum :: forall a. Ord a => Complex a -> a
    maximum :: forall a. Ord a => Complex a -> a
    $cmaximum :: forall a. Ord a => Complex a -> a
    elem :: forall a. Eq a => a -> Complex a -> Bool
    $celem :: forall a. Eq a => a -> Complex a -> Bool
    length :: forall a. Complex a -> Int
    $clength :: forall a. Complex a -> Int
    null :: forall a. Complex a -> Bool
    $cnull :: forall a. Complex a -> Bool
    toList :: forall a. Complex a -> [a]
    $ctoList :: forall a. Complex a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Complex a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Complex a -> a
    foldr1 :: forall a. (a -> a -> a) -> Complex a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Complex a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Complex a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Complex a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Complex a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Complex a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Complex a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Complex a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Complex a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Complex a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Complex a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Complex a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Complex a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Complex a -> m
    fold :: forall m. Monoid m => Complex m -> m
    $cfold :: forall m. Monoid m => Complex m -> m
    Foldable    -- ^ @since 4.9.0.0
                     , Functor Complex
    Foldable Complex
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Complex (m a) -> m (Complex a)
    forall (f :: * -> *) a.
    Applicative f =>
    Complex (f a) -> f (Complex a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Complex a -> m (Complex b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Complex a -> f (Complex b)
    sequence :: forall (m :: * -> *) a. Monad m => Complex (m a) -> m (Complex a)
    $csequence :: forall (m :: * -> *) a. Monad m => Complex (m a) -> m (Complex a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Complex a -> m (Complex b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Complex a -> m (Complex b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Complex (f a) -> f (Complex a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Complex (f a) -> f (Complex a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Complex a -> f (Complex b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Complex a -> f (Complex b)
    Traversable -- ^ @since 4.9.0.0
                     )

    -- -----------------------------------------------------------------------------
    -- Functions over Complex

    -- | Extracts the real part of a complex number.
    realPart :: Complex a -> a
    realPart :: forall a. Complex a -> a
    realPart (a
    x :+ a
    _) =  a
    x

    -- | Extracts the imaginary part of a complex number.
    imagPart :: Complex a -> a
    imagPart :: forall a. Complex a -> a
    imagPart (a
    _ :+ a
    y) =  a
    y

    -- | The conjugate of a complex number.
    {-# SPECIALISE conjugate :: Complex Double -> Complex Double #-}
    conjugate        :: Num a => Complex a -> Complex a
    conjugate :: forall a. Num a => Complex a -> Complex a
    conjugate (a
    x:+a
    y) =  a
    x forall a. a -> a -> Complex a
    :+ (-a
    y)

    -- | Form a complex number from polar components of magnitude and phase.
    {-# SPECIALISE mkPolar :: Double -> Double -> Complex Double #-}
    mkPolar          :: Floating a => a -> a -> Complex a
    mkPolar :: forall a. Floating a => a -> a -> Complex a
    mkPolar a
    r a
    theta  =  a
    r forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cos a
    theta forall a. a -> a -> Complex a
    :+ a
    r forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sin a
    theta

    -- | @'cis' t@ is a complex value with magnitude @1@
    -- and phase @t@ (modulo @2*'pi'@).
    {-# SPECIALISE cis :: Double -> Complex Double #-}
    cis              :: Floating a => a -> Complex a
    cis :: forall a. Floating a => a -> Complex a
    cis a
    theta        =  forall a. Floating a => a -> a
    cos a
    theta forall a. a -> a -> Complex a
    :+ forall a. Floating a => a -> a
    sin a
    theta

    -- | The function 'polar' takes a complex number and
    -- returns a (magnitude, phase) pair in canonical form:
    -- the magnitude is nonnegative, and the phase in the range @(-'pi', 'pi']@;
    -- if the magnitude is zero, then so is the phase.
    {-# SPECIALISE polar :: Complex Double -> (Double,Double) #-}
    polar            :: (RealFloat a) => Complex a -> (a,a)
    polar :: forall a. RealFloat a => Complex a -> (a, a)
    polar Complex a
    z          =  (forall a. RealFloat a => Complex a -> a
    magnitude Complex a
    z, forall a. RealFloat a => Complex a -> a
    phase Complex a
    z)

    -- | The nonnegative magnitude of a complex number.
    {-# SPECIALISE magnitude :: Complex Double -> Double #-}
    magnitude :: (RealFloat a) => Complex a -> a
    magnitude :: forall a. RealFloat a => Complex a -> a
    magnitude (a
    x:+a
    y) =  forall a. RealFloat a => Int -> a -> a
    scaleFloat Int
    k
                         (forall a. Floating a => a -> a
    sqrt (forall {a}. Num a => a -> a
    sqr (forall a. RealFloat a => Int -> a -> a
    scaleFloat Int
    mk a
    x) forall a. Num a => a -> a -> a
    + forall {a}. Num a => a -> a
    sqr (forall a. RealFloat a => Int -> a -> a
    scaleFloat Int
    mk a
    y)))
                        where k :: Int
    k  = forall a. Ord a => a -> a -> a
    max (forall a. RealFloat a => a -> Int
    exponent a
    x) (forall a. RealFloat a => a -> Int
    exponent a
    y)
                              mk :: Int
    mk = - Int
    k
                              sqr :: a -> a
    sqr a
    z = a
    z forall a. Num a => a -> a -> a
    * a
    z

    -- | The phase of a complex number, in the range @(-'pi', 'pi']@.
    -- If the magnitude is zero, then so is the phase.
    {-# SPECIALISE phase :: Complex Double -> Double #-}
    phase :: (RealFloat a) => Complex a -> a
    phase :: forall a. RealFloat a => Complex a -> a
    phase (a
    0 :+ a
    0)   = a
    0            -- SLPJ July 97 from John Peterson
    phase (a
    x:+a
    y)     = forall a. RealFloat a => a -> a -> a
    atan2 a
    y a
    x

    -- -----------------------------------------------------------------------------
    -- Instances of Complex

    -- | @since 2.01
    instance  (RealFloat a) => Num (Complex a)  where
        {-# SPECIALISE instance Num (Complex Float) #-}
        {-# SPECIALISE instance Num (Complex Double) #-}
        (a
    x:+a
    y) + :: Complex a -> Complex a -> Complex a
    + (a
    x':+a
    y')   =  (a
    xforall a. Num a => a -> a -> a
    +a
    x') forall a. a -> a -> Complex a
    :+ (a
    yforall a. Num a => a -> a -> a
    +a
    y')
        (a
    x:+a
    y) - :: Complex a -> Complex a -> Complex a
    - (a
    x':+a
    y')   =  (a
    xforall a. Num a => a -> a -> a
    -a
    x') forall a. a -> a -> Complex a
    :+ (a
    yforall a. Num a => a -> a -> a
    -a
    y')
        (a
    x:+a
    y) * :: Complex a -> Complex a -> Complex a
    * (a
    x':+a
    y')   =  (a
    xforall a. Num a => a -> a -> a
    *a
    x'forall a. Num a => a -> a -> a
    -a
    yforall a. Num a => a -> a -> a
    *a
    y') forall a. a -> a -> Complex a
    :+ (a
    xforall a. Num a => a -> a -> a
    *a
    y'forall a. Num a => a -> a -> a
    +a
    yforall a. Num a => a -> a -> a
    *a
    x')
        negate :: Complex a -> Complex a
    negate (a
    x:+a
    y)       =  forall {a}. Num a => a -> a
    negate a
    x forall a. a -> a -> Complex a
    :+ forall {a}. Num a => a -> a
    negate a
    y
        abs :: Complex a -> Complex a
    abs Complex a
    z               =  forall a. RealFloat a => Complex a -> a
    magnitude Complex a
    z forall a. a -> a -> Complex a
    :+ a
    0
        signum :: Complex a -> Complex a
    signum (a
    0:+a
    0)       =  Complex a
    0
        signum z :: Complex a
    z@(a
    x:+a
    y)     =  a
    xforall a. Fractional a => a -> a -> a
    /a
    r forall a. a -> a -> Complex a
    :+ a
    yforall a. Fractional a => a -> a -> a
    /a
    r  where r :: a
    r = forall a. RealFloat a => Complex a -> a
    magnitude Complex a
    z
        fromInteger :: Integer -> Complex a
    fromInteger Integer
    n       =  forall a. Num a => Integer -> a
    fromInteger Integer
    n forall a. a -> a -> Complex a
    :+ a
    0

    -- | @since 2.01
    instance  (RealFloat a) => Fractional (Complex a)  where
        {-# SPECIALISE instance Fractional (Complex Float) #-}
        {-# SPECIALISE instance Fractional (Complex Double) #-}
        (a
    x:+a
    y) / :: Complex a -> Complex a -> Complex a
    / (a
    x':+a
    y')   =  (a
    xforall a. Num a => a -> a -> a
    *a
    x''forall a. Num a => a -> a -> a
    +a
    yforall a. Num a => a -> a -> a
    *a
    y'') forall a. Fractional a => a -> a -> a
    / a
    d forall a. a -> a -> Complex a
    :+ (a
    yforall a. Num a => a -> a -> a
    *a
    x''forall a. Num a => a -> a -> a
    -a
    xforall a. Num a => a -> a -> a
    *a
    y'') forall a. Fractional a => a -> a -> a
    / a
    d
                               where x'' :: a
    x'' = forall a. RealFloat a => Int -> a -> a
    scaleFloat Int
    k a
    x'
                                     y'' :: a
    y'' = forall a. RealFloat a => Int -> a -> a
    scaleFloat Int
    k a
    y'
                                     k :: Int
    k   = - forall a. Ord a => a -> a -> a
    max (forall a. RealFloat a => a -> Int
    exponent a
    x') (forall a. RealFloat a => a -> Int
    exponent a
    y')
                                     d :: a
    d   = a
    x'forall a. Num a => a -> a -> a
    *a
    x'' forall a. Num a => a -> a -> a
    + a
    y'forall a. Num a => a -> a -> a
    *a
    y''

        fromRational :: Rational -> Complex a
    fromRational Rational
    a      =  forall a. Fractional a => Rational -> a
    fromRational Rational
    a forall a. a -> a -> Complex a
    :+ a
    0

    -- | @since 2.01
    instance  (RealFloat a) => Floating (Complex a) where
        {-# SPECIALISE instance Floating (Complex Float) #-}
        {-# SPECIALISE instance Floating (Complex Double) #-}
        pi :: Complex a
    pi             =  forall a. Floating a => a
    pi forall a. a -> a -> Complex a
    :+ a
    0
        exp :: Complex a -> Complex a
    exp (a
    x:+a
    y)     =  a
    expx forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cos a
    y forall a. a -> a -> Complex a
    :+ a
    expx forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sin a
    y
                          where expx :: a
    expx = forall a. Floating a => a -> a
    exp a
    x
        log :: Complex a -> Complex a
    log Complex a
    z          =  forall a. Floating a => a -> a
    log (forall a. RealFloat a => Complex a -> a
    magnitude Complex a
    z) forall a. a -> a -> Complex a
    :+ forall a. RealFloat a => Complex a -> a
    phase Complex a
    z

        Complex a
    x ** :: Complex a -> Complex a -> Complex a
    ** Complex a
    y = case (Complex a
    x,Complex a
    y) of
          (Complex a
    _ , (a
    0:+a
    0))  -> a
    1 forall a. a -> a -> Complex a
    :+ a
    0
          ((a
    0:+a
    0), (a
    exp_re:+a
    _)) -> case forall a. Ord a => a -> a -> Ordering
    compare a
    exp_re a
    0 of
                     Ordering
    GT -> a
    0 forall a. a -> a -> Complex a
    :+ a
    0
                     Ordering
    LT -> a
    inf forall a. a -> a -> Complex a
    :+ a
    0
                     Ordering
    EQ -> a
    nan forall a. a -> a -> Complex a
    :+ a
    nan
          ((a
    re:+a
    im), (a
    exp_re:+a
    _))
            | (forall a. RealFloat a => a -> Bool
    isInfinite a
    re Bool -> Bool -> Bool
    || forall a. RealFloat a => a -> Bool
    isInfinite a
    im) -> case forall a. Ord a => a -> a -> Ordering
    compare a
    exp_re a
    0 of
                     Ordering
    GT -> a
    inf forall a. a -> a -> Complex a
    :+ a
    0
                     Ordering
    LT -> a
    0 forall a. a -> a -> Complex a
    :+ a
    0
                     Ordering
    EQ -> a
    nan forall a. a -> a -> Complex a
    :+ a
    nan
            | Bool
    otherwise -> forall a. Floating a => a -> a
    exp (forall a. Floating a => a -> a
    log Complex a
    x forall a. Num a => a -> a -> a
    * Complex a
    y)
          where
            inf :: a
    inf = a
    1forall a. Fractional a => a -> a -> a
    /a
    0
            nan :: a
    nan = a
    0forall a. Fractional a => a -> a -> a
    /a
    0

        sqrt :: Complex a -> Complex a
    sqrt (a
    0:+a
    0)    =  Complex a
    0
        sqrt z :: Complex a
    z@(a
    x:+a
    y)  =  a
    u forall a. a -> a -> Complex a
    :+ (if a
    y forall a. Ord a => a -> a -> Bool
    < a
    0 then -a
    v else a
    v)
                          where (a
    u,a
    v) = if a
    x forall a. Ord a => a -> a -> Bool
    < a
    0 then (a
    v',a
    u') else (a
    u',a
    v')
                                v' :: a
    v'    = forall {a}. Num a => a -> a
    abs a
    y forall a. Fractional a => a -> a -> a
    / (a
    u'forall a. Num a => a -> a -> a
    *a
    2)
                                u' :: a
    u'    = forall a. Floating a => a -> a
    sqrt ((forall a. RealFloat a => Complex a -> a
    magnitude Complex a
    z forall a. Num a => a -> a -> a
    + forall {a}. Num a => a -> a
    abs a
    x) forall a. Fractional a => a -> a -> a
    / a
    2)

        sin :: Complex a -> Complex a
    sin (a
    x:+a
    y)     =  forall a. Floating a => a -> a
    sin a
    x forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cosh a
    y forall a. a -> a -> Complex a
    :+ forall a. Floating a => a -> a
    cos a
    x forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sinh a
    y
        cos :: Complex a -> Complex a
    cos (a
    x:+a
    y)     =  forall a. Floating a => a -> a
    cos a
    x forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cosh a
    y forall a. a -> a -> Complex a
    :+ (- forall a. Floating a => a -> a
    sin a
    x forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sinh a
    y)
        tan :: Complex a -> Complex a
    tan (a
    x:+a
    y)     =  (a
    sinxforall a. Num a => a -> a -> a
    *a
    coshyforall a. a -> a -> Complex a
    :+a
    cosxforall a. Num a => a -> a -> a
    *a
    sinhy)forall a. Fractional a => a -> a -> a
    /(a
    cosxforall a. Num a => a -> a -> a
    *a
    coshyforall a. a -> a -> Complex a
    :+(-a
    sinxforall a. Num a => a -> a -> a
    *a
    sinhy))
                          where sinx :: a
    sinx  = forall a. Floating a => a -> a
    sin a
    x
                                cosx :: a
    cosx  = forall a. Floating a => a -> a
    cos a
    x
                                sinhy :: a
    sinhy = forall a. Floating a => a -> a
    sinh a
    y
                                coshy :: a
    coshy = forall a. Floating a => a -> a
    cosh a
    y

        sinh :: Complex a -> Complex a
    sinh (a
    x:+a
    y)    =  forall a. Floating a => a -> a
    cos a
    y forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sinh a
    x forall a. a -> a -> Complex a
    :+ forall a. Floating a => a -> a
    sin  a
    y forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cosh a
    x
        cosh :: Complex a -> Complex a
    cosh (a
    x:+a
    y)    =  forall a. Floating a => a -> a
    cos a
    y forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    cosh a
    x forall a. a -> a -> Complex a
    :+ forall a. Floating a => a -> a
    sin a
    y forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    sinh a
    x
        tanh :: Complex a -> Complex a
    tanh (a
    x:+a
    y)    =  (a
    cosyforall a. Num a => a -> a -> a
    *a
    sinhxforall a. a -> a -> Complex a
    :+a
    sinyforall a. Num a => a -> a -> a
    *a
    coshx)forall a. Fractional a => a -> a -> a
    /(a
    cosyforall a. Num a => a -> a -> a
    *a
    coshxforall a. a -> a -> Complex a
    :+a
    sinyforall a. Num a => a -> a -> a
    *a
    sinhx)
                          where siny :: a
    siny  = forall a. Floating a => a -> a
    sin a
    y
                                cosy :: a
    cosy  = forall a. Floating a => a -> a
    cos a
    y
                                sinhx :: a
    sinhx = forall a. Floating a => a -> a
    sinh a
    x
                                coshx :: a
    coshx = forall a. Floating a => a -> a
    cosh a
    x

        asin :: Complex a -> Complex a
    asin z :: Complex a
    z@(a
    x:+a
    y)  =  a
    y'forall a. a -> a -> Complex a
    :+(-a
    x')
                          where  (a
    x':+a
    y') = forall a. Floating a => a -> a
    log (((-a
    y)forall a. a -> a -> Complex a
    :+a
    x) forall a. Num a => a -> a -> a
    + forall a. Floating a => a -> a
    sqrt (Complex a
    1 forall a. Num a => a -> a -> a
    - Complex a
    zforall a. Num a => a -> a -> a
    *Complex a
    z))
        acos :: Complex a -> Complex a
    acos Complex a
    z         =  a
    y''forall a. a -> a -> Complex a
    :+(-a
    x'')
                          where (a
    x'':+a
    y'') = forall a. Floating a => a -> a
    log (Complex a
    z forall a. Num a => a -> a -> a
    + ((-a
    y')forall a. a -> a -> Complex a
    :+a
    x'))
                                (a
    x':+a
    y')   = forall a. Floating a => a -> a
    sqrt (Complex a
    1 forall a. Num a => a -> a -> a
    - Complex a
    zforall a. Num a => a -> a -> a
    *Complex a
    z)
        atan :: Complex a -> Complex a
    atan z :: Complex a
    z@(a
    x:+a
    y)  =  a
    y'forall a. a -> a -> Complex a
    :+(-a
    x')
                          where (a
    x':+a
    y') = forall a. Floating a => a -> a
    log (((a
    1forall a. Num a => a -> a -> a
    -a
    y)forall a. a -> a -> Complex a
    :+a
    x) forall a. Fractional a => a -> a -> a
    / forall a. Floating a => a -> a
    sqrt (Complex a
    1forall a. Num a => a -> a -> a
    +Complex a
    zforall a. Num a => a -> a -> a
    *Complex a
    z))

        asinh :: Complex a -> Complex a
    asinh Complex a
    z        =  forall a. Floating a => a -> a
    log (Complex a
    z forall a. Num a => a -> a -> a
    + forall a. Floating a => a -> a
    sqrt (Complex a
    1forall a. Num a => a -> a -> a
    +Complex a
    zforall a. Num a => a -> a -> a
    *Complex a
    z))
        -- Take care to allow (-1)::Complex, fixing #8532
        acosh :: Complex a -> Complex a
    acosh Complex a
    z        =  forall a. Floating a => a -> a
    log (Complex a
    z forall a. Num a => a -> a -> a
    + (forall a. Floating a => a -> a
    sqrt forall a b. (a -> b) -> a -> b
    $ Complex a
    zforall a. Num a => a -> a -> a
    +Complex a
    1) forall a. Num a => a -> a -> a
    * (forall a. Floating a => a -> a
    sqrt forall a b. (a -> b) -> a -> b
    $ Complex a
    zforall a. Num a => a -> a -> a
    -Complex a
    1))
        atanh :: Complex a -> Complex a
    atanh Complex a
    z        =  Complex a
    0.5 forall a. Num a => a -> a -> a
    * forall a. Floating a => a -> a
    log ((Complex a
    1.0forall a. Num a => a -> a -> a
    +Complex a
    z) forall a. Fractional a => a -> a -> a
    / (Complex a
    1.0forall a. Num a => a -> a -> a
    -Complex a
    z))

        log1p :: Complex a -> Complex a
    log1p x :: Complex a
    x@(a
    a :+ a
    b)
          | forall {a}. Num a => a -> a
    abs a
    a forall a. Ord a => a -> a -> Bool
    < a
    0.5 Bool -> Bool -> Bool
    && forall {a}. Num a => a -> a
    abs a
    b forall a. Ord a => a -> a -> Bool
    < a
    0.5
          , a
    u <- a
    2forall a. Num a => a -> a -> a
    *a
    a forall a. Num a => a -> a -> a
    + a
    aforall a. Num a => a -> a -> a
    *a
    a forall a. Num a => a -> a -> a
    + a
    bforall a. Num a => a -> a -> a
    *a
    b = forall a. Floating a => a -> a
    log1p (a
    uforall a. Fractional a => a -> a -> a
    /(a
    1 forall a. Num a => a -> a -> a
    + forall a. Floating a => a -> a
    sqrt(a
    uforall a. Num a => a -> a -> a
    +a
    1))) forall a. a -> a -> Complex a
    :+ forall a. RealFloat a => a -> a -> a
    atan2 (a
    1 forall a. Num a => a -> a -> a
    + a
    a) a
    b
          | Bool
    otherwise = forall a. Floating a => a -> a
    log (Complex a
    1 forall a. Num a => a -> a -> a
    + Complex a
    x)
        {-# INLINE log1p #-}

        expm1 :: Complex a -> Complex a
    expm1 x :: Complex a
    x@(a
    a :+ a
    b)
          | a
    aforall a. Num a => a -> a -> a
    *a
    a forall a. Num a => a -> a -> a
    + a
    bforall a. Num a => a -> a -> a
    *a
    b forall a. Ord a => a -> a -> Bool
    < a
    1
          , a
    u <- forall a. Floating a => a -> a
    expm1 a
    a
          , a
    v <- forall a. Floating a => a -> a
    sin (a
    bforall a. Fractional a => a -> a -> a
    /a
    2)
          , a
    w <- -a
    2forall a. Num a => a -> a -> a
    *a
    vforall a. Num a => a -> a -> a
    *a
    v = (a
    uforall a. Num a => a -> a -> a
    *a
    w forall a. Num a => a -> a -> a
    + a
    u forall a. Num a => a -> a -> a
    + a
    w) forall a. a -> a -> Complex a
    :+ (a
    uforall a. Num a => a -> a -> a
    +a
    1)forall a. Num a => a -> a -> a
    *forall a. Floating a => a -> a
    sin a
    b
          | Bool
    otherwise = forall a. Floating a => a -> a
    exp Complex a
    x forall a. Num a => a -> a -> a
    - Complex a
    1
        {-# INLINE expm1 #-}

    -- | @since 4.8.0.0
    instance Storable a => Storable (Complex a) where
        sizeOf :: Complex a -> Int
    sizeOf Complex a
    a       = Int
    2 forall a. Num a => a -> a -> a
    * forall a. Storable a => a -> Int
    sizeOf (forall a. Complex a -> a
    realPart Complex a
    a)
        alignment :: Complex a -> Int
    alignment Complex a
    a    = forall a. Storable a => a -> Int
    alignment (forall a. Complex a -> a
    realPart Complex a
    a)
        peek :: Ptr (Complex a) -> IO (Complex a)
    peek Ptr (Complex a)
    p           = do
                            Ptr a
    q <- forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $ forall a b. Ptr a -> Ptr b
    castPtr Ptr (Complex a)
    p
                            a
    r <- forall a. Storable a => Ptr a -> IO a
    peek Ptr a
    q
                            a
    i <- forall a. Storable a => Ptr a -> Int -> IO a
    peekElemOff Ptr a
    q Int
    1
                            forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    r forall a. a -> a -> Complex a
    :+ a
    i)
        poke :: Ptr (Complex a) -> Complex a -> IO ()
    poke Ptr (Complex a)
    p (a
    r :+ a
    i)  = do
                            Ptr a
    q <-forall (m :: * -> *) a. Monad m => a -> m a
    return forall a b. (a -> b) -> a -> b
    $  (forall a b. Ptr a -> Ptr b
    castPtr Ptr (Complex a)
    p)
                            forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr a
    q a
    r
                            forall a. Storable a => Ptr a -> Int -> a -> IO ()
    pokeElemOff Ptr a
    q Int
    1 a
    i

    -- | @since 4.9.0.0
    instance Applicative Complex where
      pure :: forall a. a -> Complex a
    pure a
    a = a
    a forall a. a -> a -> Complex a
    :+ a
    a
      a -> b
    f :+ a -> b
    g <*> :: forall a b. Complex (a -> b) -> Complex a -> Complex b
    <*> a
    a :+ a
    b = a -> b
    f a
    a forall a. a -> a -> Complex a
    :+ a -> b
    g a
    b
      liftA2 :: forall a b c. (a -> b -> c) -> Complex a -> Complex b -> Complex c
    liftA2 a -> b -> c
    f (a
    x :+ a
    y) (b
    a :+ b
    b) = a -> b -> c
    f a
    x b
    a forall a. a -> a -> Complex a
    :+ a -> b -> c
    f a
    y b
    b

    -- | @since 4.9.0.0
    instance Monad Complex where
      a
    a :+ a
    b >>= :: forall a b. Complex a -> (a -> Complex b) -> Complex b
    >>= a -> Complex b
    f = forall a. Complex a -> a
    realPart (a -> Complex b
    f a
    a) forall a. a -> a -> Complex a
    :+ forall a. Complex a -> a
    imagPart (a -> Complex b
    f a
    b)

    -- | @since 4.15.0.0
    instance MonadZip Complex where
      mzipWith :: forall a b c. (a -> b -> c) -> Complex a -> Complex b -> Complex c
    mzipWith = forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2

    -- | @since 4.15.0.0
    instance MonadFix Complex where
      mfix :: forall a. (a -> Complex a) -> Complex a
    mfix a -> Complex a
    f = (let a
    a :+ a
    _ = a -> Complex a
    f a
    a in a
    a) forall a. a -> a -> Complex a
    :+ (let a
    _ :+ a
    a = a -> Complex a
    f a
    a in a
    a)

    -- -----------------------------------------------------------------------------
    -- Rules on Complex

    {-# RULES

    "realToFrac/a->Complex Double"
      realToFrac = \x -> realToFrac x :+ (0 :: Double)

    "realToFrac/a->Complex Float"
      realToFrac = \x -> realToFrac x :+ (0 :: Float)

      #-}