Numeric.RootFinding

Haskell functions for finding the roots of real functions of real arguments. These algorithms are iterative so we provide both function returning root (or failure to find root) and list of iterations.

Data types

data Root a

The result of searching for a root of a mathematical function.

Constructors

NotBracketed

The function does not have opposite signs when evaluated at the lower and upper bounds of the search.

SearchFailed

The search failed to converge to within the given error tolerance after the given number of iterations.

Root !a

A root was successfully found.

Instances

Monad Root

Defined in Numeric.RootFinding

Methods

(>>=) :: Root a -> (a -> Root b) -> Root b

(>>) :: Root a -> Root b -> Root b

return :: a -> Root a

fail :: String -> Root a

Functor Root

Defined in Numeric.RootFinding

Methods

fmap :: (a -> b) -> Root a -> Root b

(<$) :: a -> Root b -> Root a

Applicative Root

Defined in Numeric.RootFinding

Methods

pure :: a -> Root a

(<*>) :: Root (a -> b) -> Root a -> Root b

liftA2 :: (a -> b -> c) -> Root a -> Root b -> Root c

(*>) :: Root a -> Root b -> Root b

(<*) :: Root a -> Root b -> Root a

Foldable Root

Defined in Numeric.RootFinding

Methods

fold :: Monoid m => Root m -> m

foldMap :: Monoid m => (a -> m) -> Root a -> m

foldr :: (a -> b -> b) -> b -> Root a -> b

foldr' :: (a -> b -> b) -> b -> Root a -> b

foldl :: (b -> a -> b) -> b -> Root a -> b

foldl' :: (b -> a -> b) -> b -> Root a -> b

foldr1 :: (a -> a -> a) -> Root a -> a

foldl1 :: (a -> a -> a) -> Root a -> a

toList :: Root a -> [a]

null :: Root a -> Bool

length :: Root a -> Int

elem :: Eq a => a -> Root a -> Bool

maximum :: Ord a => Root a -> a

minimum :: Ord a => Root a -> a

sum :: Num a => Root a -> a

product :: Num a => Root a -> a

Traversable Root

Defined in Numeric.RootFinding

Methods

traverse :: Applicative f => (a -> f b) -> Root a -> f (Root b)

sequenceA :: Applicative f => Root (f a) -> f (Root a)

mapM :: Monad m => (a -> m b) -> Root a -> m (Root b)

sequence :: Monad m => Root (m a) -> m (Root a)

Alternative Root

Defined in Numeric.RootFinding

Methods

empty :: Root a

(<|>) :: Root a -> Root a -> Root a

some :: Root a -> Root [a]

many :: Root a -> Root [a]

MonadPlus Root

Defined in Numeric.RootFinding

Methods

mzero :: Root a

mplus :: Root a -> Root a -> Root a

Eq a => Eq (Root a)

Defined in Numeric.RootFinding

Methods

(==) :: Root a -> Root a -> Bool

(/=) :: Root a -> Root a -> Bool

Data a => Data (Root a)

Defined in Numeric.RootFinding

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Root a -> c (Root a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Root a)

toConstr :: Root a -> Constr

dataTypeOf :: Root a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Root a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Root a))

gmapT :: (forall b. Data b => b -> b) -> Root a -> Root a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Root a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Root a -> r

gmapQ :: (forall d. Data d => d -> u) -> Root a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Root a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Root a -> m (Root a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Root a -> m (Root a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Root a -> m (Root a)

Read a => Read (Root a)

Defined in Numeric.RootFinding

Methods

readsPrec :: Int -> ReadS (Root a)

readList :: ReadS [Root a]

readPrec :: ReadPrec (Root a)

readListPrec :: ReadPrec [Root a]

Show a => Show (Root a)

Defined in Numeric.RootFinding

Methods

showsPrec :: Int -> Root a -> ShowS

show :: Root a -> String

showList :: [Root a] -> ShowS

Generic (Root a)

Defined in Numeric.RootFinding

Associated Types

type Rep (Root a) :: * -> *

Methods

from :: Root a -> Rep (Root a) x

to :: Rep (Root a) x -> Root a

NFData a => NFData (Root a)

Defined in Numeric.RootFinding

Methods

rnf :: Root a -> ()

type Rep (Root a)

Defined in Numeric.RootFinding

type Rep (Root a) = D1 (MetaData "Root" "Numeric.RootFinding" "math-functions-0.3.0.2-1coklhaHwLc6eKe8umtGcV" False) (C1 (MetaCons "NotBracketed" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "SearchFailed" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "Root" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))

fromRoot

Arguments

:: a

Default value.

-> Root a

Result of search for a root.

-> a

Returns either the result of a search for a root, or the default value if the search failed.

data Tolerance

Error tolerance for finding root. It describes when root finding algorithm should stop trying to improve approximation.

Constructors

RelTol !Double

Relative error tolerance. Given RelTol ε two values are considered approximately equal if \[ \frac{|a - b|}{|\operatorname{max}(a,b)} < \varepsilon \]

AbsTol !Double

Absolute error tolerance. Given AbsTol δ two values are considered approximately equal if \[ |a - b| < \delta \]. Note that AbsTol 0 could be used to require to find approximation within machine precision.

Instances

Eq Tolerance

Defined in Numeric.RootFinding

Methods

(==) :: Tolerance -> Tolerance -> Bool

(/=) :: Tolerance -> Tolerance -> Bool

Data Tolerance

Defined in Numeric.RootFinding

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tolerance -> c Tolerance

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tolerance

toConstr :: Tolerance -> Constr

dataTypeOf :: Tolerance -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tolerance)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tolerance)

gmapT :: (forall b. Data b => b -> b) -> Tolerance -> Tolerance

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tolerance -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tolerance -> r

gmapQ :: (forall d. Data d => d -> u) -> Tolerance -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tolerance -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tolerance -> m Tolerance

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tolerance -> m Tolerance

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tolerance -> m Tolerance

Read Tolerance

Defined in Numeric.RootFinding

Methods

readsPrec :: Int -> ReadS Tolerance

readList :: ReadS [Tolerance]

readPrec :: ReadPrec Tolerance

readListPrec :: ReadPrec [Tolerance]

Show Tolerance

Defined in Numeric.RootFinding

Methods

showsPrec :: Int -> Tolerance -> ShowS

show :: Tolerance -> String

showList :: [Tolerance] -> ShowS

Generic Tolerance

Defined in Numeric.RootFinding

Associated Types

type Rep Tolerance :: * -> *

Methods

from :: Tolerance -> Rep Tolerance x

to :: Rep Tolerance x -> Tolerance

type Rep Tolerance

Defined in Numeric.RootFinding

type Rep Tolerance = D1 (MetaData "Tolerance" "Numeric.RootFinding" "math-functions-0.3.0.2-1coklhaHwLc6eKe8umtGcV" False) (C1 (MetaCons "RelTol" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Double)) :+: C1 (MetaCons "AbsTol" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Double)))

withinTolerance :: Tolerance -> Double -> Double -> Bool

Check that two values are approximately equal. In addition to specification values are considered equal if they're within 1ulp of precision. No further improvement could be done anyway.

class IterationStep a where

Type class for checking whether iteration converged already.

Minimal complete definition

matchRoot

Methods

matchRoot :: Tolerance -> a -> Maybe (Root Double)

Return Just root is current iteration converged within required error tolerance. Returns Nothing otherwise.

findRoot

Arguments

:: IterationStep a

=> Int

Maximum

-> Tolerance

Error tolerance

-> [a]

-> Root Double

Find root in lazy list of iterations.

Ridders algorithm

data RiddersParam

Parameters for ridders root finding

Constructors

RiddersParam

Fields

• riddersMaxIter :: !Int

  Maximum number of iterations.

• riddersTol :: !Tolerance

  Error tolerance for root approximation.

Instances

Eq RiddersParam

Defined in Numeric.RootFinding

Methods

(==) :: RiddersParam -> RiddersParam -> Bool

(/=) :: RiddersParam -> RiddersParam -> Bool

Data RiddersParam

Defined in Numeric.RootFinding

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RiddersParam -> c RiddersParam

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RiddersParam

toConstr :: RiddersParam -> Constr

dataTypeOf :: RiddersParam -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RiddersParam)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RiddersParam)

gmapT :: (forall b. Data b => b -> b) -> RiddersParam -> RiddersParam

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RiddersParam -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RiddersParam -> r

gmapQ :: (forall d. Data d => d -> u) -> RiddersParam -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RiddersParam -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RiddersParam -> m RiddersParam

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RiddersParam -> m RiddersParam

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RiddersParam -> m RiddersParam

Read RiddersParam

Defined in Numeric.RootFinding

Methods

readsPrec :: Int -> ReadS RiddersParam

readList :: ReadS [RiddersParam]

readPrec :: ReadPrec RiddersParam

readListPrec :: ReadPrec [RiddersParam]

Show RiddersParam

Defined in Numeric.RootFinding

Methods

showsPrec :: Int -> RiddersParam -> ShowS

show :: RiddersParam -> String

showList :: [RiddersParam] -> ShowS

Generic RiddersParam

Defined in Numeric.RootFinding

Associated Types

type Rep RiddersParam :: * -> *

Methods

from :: RiddersParam -> Rep RiddersParam x

to :: Rep RiddersParam x -> RiddersParam

Default RiddersParam

Defined in Numeric.RootFinding

Methods

def :: RiddersParam

type Rep RiddersParam

Defined in Numeric.RootFinding

type Rep RiddersParam = D1 (MetaData "RiddersParam" "Numeric.RootFinding" "math-functions-0.3.0.2-1coklhaHwLc6eKe8umtGcV" False) (C1 (MetaCons "RiddersParam" PrefixI True) (S1 (MetaSel (Just "riddersMaxIter") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int) :*: S1 (MetaSel (Just "riddersTol") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Tolerance)))

ridders

Arguments

:: RiddersParam

Parameters for algorithms. def provides reasonable defaults

-> (Double, Double)

Bracket for root

-> (Double -> Double)

Function to find roots

-> Root Double

Use the method of Ridders[Ridders1979] to compute a root of a function. It doesn't require derivative and provide quadratic convergence (number of significant digits grows quadratically with number of iterations).

The function must have opposite signs when evaluated at the lower and upper bounds of the search (i.e. the root must be bracketed). If there's more that one root in the bracket iteration will converge to some root in the bracket.

riddersIterations :: (Double, Double) -> (Double -> Double) -> [RiddersStep]

List of iterations for Ridders methods. See ridders for documentation of parameters

Newton-Raphson algorithm

data NewtonParam

Parameters for ridders root finding

Constructors

NewtonParam

Fields

• newtonMaxIter :: !Int

  Maximum number of iterations.

• newtonTol :: !Tolerance

  Error tolerance for root approximation.

Instances

Eq NewtonParam

Defined in Numeric.RootFinding

Methods

(==) :: NewtonParam -> NewtonParam -> Bool

(/=) :: NewtonParam -> NewtonParam -> Bool

Data NewtonParam

Defined in Numeric.RootFinding

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewtonParam -> c NewtonParam

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewtonParam

toConstr :: NewtonParam -> Constr

dataTypeOf :: NewtonParam -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewtonParam)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewtonParam)

gmapT :: (forall b. Data b => b -> b) -> NewtonParam -> NewtonParam

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewtonParam -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewtonParam -> r

gmapQ :: (forall d. Data d => d -> u) -> NewtonParam -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NewtonParam -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewtonParam -> m NewtonParam

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewtonParam -> m NewtonParam

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewtonParam -> m NewtonParam

Read NewtonParam

Defined in Numeric.RootFinding

Methods

readsPrec :: Int -> ReadS NewtonParam

readList :: ReadS [NewtonParam]

readPrec :: ReadPrec NewtonParam

readListPrec :: ReadPrec [NewtonParam]

Show NewtonParam

Defined in Numeric.RootFinding

Methods

showsPrec :: Int -> NewtonParam -> ShowS

show :: NewtonParam -> String

showList :: [NewtonParam] -> ShowS

Generic NewtonParam

Defined in Numeric.RootFinding

Associated Types

type Rep NewtonParam :: * -> *

Methods

from :: NewtonParam -> Rep NewtonParam x

to :: Rep NewtonParam x -> NewtonParam

Default NewtonParam

Defined in Numeric.RootFinding

Methods

def :: NewtonParam

type Rep NewtonParam

Defined in Numeric.RootFinding

type Rep NewtonParam = D1 (MetaData "NewtonParam" "Numeric.RootFinding" "math-functions-0.3.0.2-1coklhaHwLc6eKe8umtGcV" False) (C1 (MetaCons "NewtonParam" PrefixI True) (S1 (MetaSel (Just "newtonMaxIter") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int) :*: S1 (MetaSel (Just "newtonTol") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Tolerance)))

newtonRaphson

Arguments

:: NewtonParam

Parameters for algorithm. def provide reasonable defaults.

-> (Double, Double, Double)

Triple of (low bound, initial guess, upper bound). If initial guess if out of bracket middle of bracket is taken as approximation

-> (Double -> (Double, Double))

Function to find root of. It returns pair of function value and its first derivative

-> Root Double

Solve equation using Newton-Raphson iterations.

This method require both initial guess and bounds for root. If Newton step takes us out of bounds on root function reverts to bisection.

newtonRaphsonIterations :: (Double, Double, Double) -> (Double -> (Double, Double)) -> [NewtonStep]

List of iteration for Newton-Raphson algorithm. See documentation for newtonRaphson for meaning of parameters.

References

• Ridders, C.F.J. (1979) A new algorithm for computing a single root of a real continuous function. IEEE Transactions on Circuits and Systems 26:979–980.
• Press W.H.; Teukolsky S.A.; Vetterling W.T.; Flannery B.P. (2007). "Section 9.2.1. Ridders' Method". /Numerical Recipes: The Art of Scientific Computing (3rd ed.)./ New York: Cambridge University Press. ISBN 978-0-521-88068-8.