{-# LANGUAGE DeriveDataTypeable, GeneralizedNewtypeDeriving #-}
{- |
Module      :  Numeric.VariablePrecision.Complex
Copyright   :  (c) Claude Heiland-Allen 2012
License     :  BSD3

Maintainer  :  claudiusmaximus@goto10.org
Stability   :  provisional
Portability :  DeriveDataTypeable, GeneralizedNewtypeDeriving

Newtype wrapper around 'Data.Complex'.  When both of 'Data.Complex' and
this module need to be imported, use qualified imports.

-}
module Numeric.VariablePrecision.Complex
  ( VComplex(..)
  , (.+)
  , fromComplex
  , withComplex
  , realPart
  , imagPart
  , conjugate
  , magnitude
  , magnitude2
  , phase
  , polar
  , cis
  , mkPolar
  , module Numeric.VariablePrecision.Float
  ) where

import Data.Data (Data())
import Data.Typeable (Typeable())
import qualified Data.Complex as X

import Numeric.VariablePrecision.Float

-- | Newtype wrapper around 'X.Complex' so that instances can be written
--   for 'HasPrecision' and 'VariablePrecision'.  
newtype VComplex p = C{ toComplex :: X.Complex (VFloat p) }
  deriving (Eq, Num, Fractional, Floating, Data, Typeable)

-- | Alike to 'X.:+', constructs a complex number from a real part and
--   an imaginary part.
(.+) :: VFloat p -> VFloat p -> VComplex p
x .+ y = C (x X.:+ y)
infix 6 .+

instance HasPrecision VComplex
instance VariablePrecision VComplex where
  adjustPrecision (C (x X.:+ y)) = C (adjustPrecision x X.:+ adjustPrecision y)

-- | Convert 'X.Complex' to 'VComplex'.
fromComplex :: X.Complex (VFloat p) -> VComplex p
fromComplex = C

-- | Lift an operation on 'X.Complex' to one on 'VComplex'.
withComplex :: (X.Complex (VFloat p) -> X.Complex (VFloat q)) -> (VComplex p -> VComplex q)
withComplex f = fromComplex . f . toComplex

instance NaturalNumber p => Show (VComplex p) where
  showsPrec p (C c) = showsPrec p c

instance NaturalNumber p => Read (VComplex p) where
  readsPrec p = map (first C) . readsPrec p
    where first f (a, b) = (f a, b)

-- | Unit at phase.
cis :: NaturalNumber p => VFloat p -> VComplex p
cis = fromComplex . X.cis

-- | From polar form.
mkPolar :: NaturalNumber p => VFloat p -> VFloat p -> VComplex p
mkPolar r t = fromComplex (X.mkPolar r t)

-- | Conjugate.
conjugate :: NaturalNumber p => VComplex p -> VComplex p
conjugate = withComplex X.conjugate

-- | Imaginary part.
imagPart :: NaturalNumber p => VComplex p -> VFloat p
imagPart = X.imagPart . toComplex

-- | Real part.
realPart :: NaturalNumber p => VComplex p -> VFloat p
realPart = X.realPart . toComplex

-- | Phase.
phase :: NaturalNumber p => VComplex p -> VFloat p
phase = X.phase . toComplex

-- | Polar form.
polar :: NaturalNumber p => VComplex p -> (VFloat p, VFloat p)
polar = X.polar . toComplex

-- | Magnitude.
magnitude :: NaturalNumber p => VComplex p -> VFloat p
magnitude = X.magnitude . toComplex

-- | Magnitude squared.
magnitude2 :: NaturalNumber p => VComplex p -> VFloat p
magnitude2 = magnitude2' . toComplex

magnitude2' :: Num r => X.Complex r -> r
magnitude2' (x X.:+ y) = x * x + y * y