-----------------------------------------------------------------------------
-- |
-- Module      :  Polynomial.Maclaurin
-- Copyright   :  (c) Matthew Donadio 2003
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Simple module for generating Maclaurin series representation of a few
-- functions:
--
-- @f(x) = sum [ a_i * x^i | i \<- [0..] ]@
--
-- The @Int@ parameter for all functions is the /order/ of the polynomial,
-- eg:
--
-- @[ a_i | i \<- [0..N] ]@
--
-- and not the number of non-zero terms
--
-----------------------------------------------------------------------------

module Polynomial.Maclaurin (polyexp, polyln1,
			     polycos, polysin, polyatan,
			     polycosh, polysinh, polyatanh) where

-- A few utility lists

ifacs :: [Double]
ifacs :: [Double]
ifacs = forall a b. (a -> b) -> [a] -> [b]
map (Double
1forall a. Fractional a => a -> a -> a
/) forall a b. (a -> b) -> a -> b
$ forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl forall a. Num a => a -> a -> a
(*) Double
1 [Double
1..]

inverses :: [Double]
inverses :: [Double]
inverses = forall a b. (a -> b) -> [a] -> [b]
map (Double
1forall a. Fractional a => a -> a -> a
/) forall a b. (a -> b) -> a -> b
$ Double
1forall a. a -> [a] -> [a]
:[Double
1..]

-- Exponential and logarithm

-- | e^x

polyexp :: Int -> [Double]
polyexp :: Int -> [Double]
polyexp Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) [Double]
ifacs

-- | ln (1+x), 0 \<= x \<= 1

polyln1 :: Int -> [Double]
polyln1 :: Int -> [Double]
polyln1 Int
n = Double
0 forall a. a -> [a] -> [a]
: (forall a. Int -> [a] -> [a]
take Int
n forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (Double
1forall a. Fractional a => a -> a -> a
/) [Double
1..])
    where i :: [Double]
i = [ Double
1, -Double
1 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- Trig functions

-- | cos x

polycos :: Int -> [Double]
polycos :: Int -> [Double]
polycos Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
ifacs
    where i :: [Double]
i = [ Double
1, Double
0, -Double
1, Double
0 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- | sin x

polysin :: Int -> [Double]
polysin :: Int -> [Double]
polysin Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
ifacs
    where i :: [Double]
i = [ Double
0, Double
1, Double
0, -Double
1 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- | atan x, -1 \< x \< 1

polyatan :: Int -> [Double]
polyatan :: Int -> [Double]
polyatan Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
inverses
    where i :: [Double]
i = [ Double
0, Double
1, Double
0, -Double
1 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- Hyperbolic functions

-- | cosh x

polycosh :: Int -> [Double]
polycosh :: Int -> [Double]
polycosh Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
ifacs
    where i :: [Double]
i = [ Double
1, Double
0 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- | sinh x

polysinh :: Int -> [Double]
polysinh :: Int -> [Double]
polysinh Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
ifacs
    where i :: [Double]
i = [ Double
0, Double
1 ] forall a. [a] -> [a] -> [a]
++ [Double]
i

-- | atanh x

polyatanh :: Int -> [Double]
polyatanh :: Int -> [Double]
polyatanh Int
n = forall a. Int -> [a] -> [a]
take (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(*) [Double]
i [Double]
inverses
    where i :: [Double]
i = [ Double
0, Double
1 ] forall a. [a] -> [a] -> [a]
++ [Double]
i