-----------------------------------------------------------------------------
-- |
-- Module      :  Polynomial.Roots
-- Copyright   :  (c) 1998 Numeric Quest Inc., All rights reserved
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Root finder using Laguerre's method
--
-----------------------------------------------------------------------------

-- This file was sucked out of the Wayback Machine at www.archive.org.
-- This was orginally a HTML files containing literate Haskell. It has
-- been modified to use the Polynomial library, and Haddock style comments
-- have been added.  As much as the original formatting has been retained
-- as possible. --mpd

-- Original comments are below

{-
	Literate Haskell module <i>Roots.lhs</i>

	Jan Skibinski, <a href="http://www.numeric-quest.com/news/">
	Numeric Quest Inc.</a>, Huntsville, Ontario, Canada

	1998.09.05, last modified 1998.09.24

	This module implements <i>Laguerre's</i> method for finding complex
	roots of polynomials. According to [1], it <i> is by far the most
	straightforward of these sure-fire methods. It does require that you
	perform complex arithmetic (even while converging to real roots), but
	it is guaranteed to converge to a root from any starting point. In
	some instances the complex arithmetic is no disadvantage, since the
	polynomial itself may have complex coefficients. </i>

	[1] Numerical Recipes in Pascal, W.H. Press, B.P. Flannery,
	S.A. Teukolsky, W.T. Vetterling, Cambridge University Press,
	ISBN 0-521-37516-9

	See also some other variations of the same book by the same authors:
	Numerical Recipes in C, Fortran, etc. I just happen to own [1], although
	I have never programmed in Pascal. :-)	

	Example

	To solve the equation

	x^2 - 3 x + 2 = 0

	form the list of coefficients [2, -3, 1] (notice the reverse
	order of coefficients) and execute

	roots 1.0e-6 300 [2,-3, 1]
	-- where
	--     1.0e-6 is a required accuracy
	--     300 is a count of permitted iterations
	--     (You set it to small number just in case you
	--	do not trust the algorithm. But if you do,
	--	then set it to something big, say 300)   

	The answer is [2.0 :+ 0.0, 1.0 :+ 0.0]; that is, both roots are
	real and equal to 2 and 1:

	x^2 - 3 x + 2 = (x - 2) (x - 1) = 0
-}

module Polynomial.Roots (roots) where         

import Data.Complex

import Polynomial.Basic

-- * Functions

-- | Root finder using Laguerre's method

roots :: RealFloat a => a           -- ^ epsilon
                     -> Int         -- ^ iteration limit
                     -> [Complex a] -- ^ the polynomial
                     -> [Complex a] -- ^ the roots
roots eps0 count0 as0 =
	--
	-- List of complex roots of a polynomial
	-- a0 + a1*x + a2*x^2...
	-- represented by the list as=[a0,a1,a2...]
	-- where
	--     eps is a desired accuracy
	--     count is a maximum count of iterations allowed
	-- Require: list 'as' must have at least two elements
	--     and the last element must not be zero 
	roots' eps0 count0 as0 []
	where
	    roots' eps count as xs 
	        | length as <= 2  = x:xs
	        | otherwise       = 
                 roots' eps count (deflate x bs [last as]) (x:xs)
	        where
	            x  = laguerre eps count as 0
	            bs = drop 1 (reverse (drop 1 as))
	            deflate z bs' cs
	                | bs' == []  = cs
		        | otherwise  = 
                         deflate z (tail bs') (((head bs')+z*(head cs)):cs)


laguerre :: RealFloat a => a -> Int -> [Complex a] -> Complex a -> Complex a
laguerre eps0 count as0 x0
	--
	-- One of the roots of the polynomial 'as',
	-- where
	--    eps is a desired accuracy
	--    count is a maximum count of iterations allowed
	--    x is initial guess of the root
	-- This method is due to Laguerre.
	--
	| count <= 0	              = x0
	| magnitude (x0 - x0') < eps0 = x0'
	| otherwise                   = laguerre eps0 (count - 1) as0 x0'
	where x0'    = laguerre2 eps0 as0 as0' as0'' x0
	      as0'   = polyderiv as0
	      as0''  = polyderiv as0'
	      laguerre2 eps as as' as'' x
	        -- One iteration step
	        | magnitude b < eps           = x
	        | magnitude gp < magnitude gm = 
		    if gm == 0 then x - 1 else x - n/gm
	        | otherwise                   = 
		    if gp == 0 then x - 1 else x - n/gp
	        where gp    = g + delta
		      gm    = g - delta
		      g     = d/b
		      delta = sqrt ((n-1)*(n*h - g2))
		      h     = g2 - f/b
		      b     = polyeval as x
		      d     = polyeval as' x
		      f     = polyeval as'' x
		      g2    = g^(2::Int)
		      n     = fromIntegral (length as)

-- Original Copyright Notice

-----------------------------------------------------------------------------
--
-- Copyright:
--
--	(C) 1998 Numeric Quest Inc., All rights reserved
--
-- Email:
--
--      jans@numeric-quest.com
--
-- License:
--
--	GNU General Public License, GPL
-- 
-----------------------------------------------------------------------------
