-- | 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