-- | Integration of complex and real functions along straight lines
module Data.Complex.Integrate (

  integrate

) where

-- We will work with complex numbers
import Data.Complex

-- | Integration of complex function using Simpson's rule
integrate :: (Fractional v) => 
    (v -> v)   -- ^ Function to be integrated
    -> Integer -- ^ Number of discretization segments    
    -> v       -- ^ Lower limit of the integration, and it's complex number
    -> v       -- ^ Upper limit of the integration, and it's complex number, too
    -> v       -- ^ Integration result
integrate f n a b =
    (f a + (4 * f_o) + (2 * f_e) + f b) * h / 3
        where
           h = getQuantizer a b n
           f_o = sum $ map (f . (+ a) . (* h) . fromInteger) [nn | nn <- [1..(n-1)], odd nn]
           f_e = sum $ map (f . (+ a) . (* h) . fromInteger) [nn | nn <- [2..(n-2)], even nn]
-- Yes, I know that function and data in maps should be refactored out, but every time I'm doing this, I am became stunned, because the integrate itself is losing clarity.


-- | Get step between <a> and <b> given number <n> of steps
getQuantizer :: (Fractional a) => a -> a -> Integer -> a
getQuantizer a b n = (b - a) / fromInteger n
