-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | piecewise linear and cubic Hermite interpolation
--   
--   Represent real functions by linear or cubic polynomial segments. The
--   package provides both data structures for efficient lookup of
--   interpolation intervals, and computation of basis functions.
--   
--   There are two examples that can be built with
--   
--   <pre>
--   cabal install -fbuildExamples
--   </pre>
--   
--   <ul>
--   <li><tt>example/Plot.hs</tt>: Interpolate a sinus curve using
--   piecewise linear interpolation and piecewise Hermite cubic
--   interpolation. For the latter one we provide the derivatives of the
--   sinus function at the interpolation nodes.</li>
--   <li><tt>example/Fit.hs</tt>: Demonstrates how to use the basis
--   functions for fitting an interpolation function to a given function
--   using a linear least squares solver like <tt><a></a></tt> from
--   <tt>lapack</tt>. We use a distorted sinus as target.</li>
--   </ul>
--   
--   The package needs only Haskell 98. Most of the package dependencies
--   are only needed for the examples and are only installed if you enable
--   to build them.
@package interpolation
@version 0.1.1.2

module Numeric.Interpolation.NodeList
data T x y
Interval :: T x y
Node :: (x, y) -> T x y -> T x y -> T x y

-- | list must be sorted with respect to first element
fromList :: [(x, y)] -> T x y

-- | <pre>
--   \xs -&gt; xs == Nodes.toList (Nodes.fromList (xs::[(Integer,Char)]))
--   </pre>
toList :: T x y -> [(x, y)]

-- | <pre>
--   \x y -&gt; Nodes.singleton x y == Nodes.fromList [(x,y)::(Integer,Char)]
--   </pre>
singleton :: x -> y -> T x y

-- | <pre>
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2::Int,'b')])) (-1)
--   (Nothing,Just (0,'a'))
--   
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2::Int,'b')])) 0
--   (Just (0,'a'),Just (2,'b'))
--   
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2::Int,'b')])) 1
--   (Just (0,'a'),Just (2,'b'))
--   
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2::Int,'b')])) 2
--   (Just (2,'b'),Nothing)
--   
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2::Int,'b')])) 3
--   (Just (2,'b'),Nothing)
--   
--   &gt;&gt;&gt; Nodes.lookup (Nodes.fromList ([(0,'a'),(2,'b'),(5::Int,'c')])) 3
--   (Just (2,'b'),Just (5,'c'))
--   </pre>
lookup :: Ord x => T x y -> x -> (Maybe (x, y), Maybe (x, y))
instance (GHC.Show.Show x, GHC.Show.Show y) => GHC.Show.Show (Numeric.Interpolation.NodeList.T x y)
instance (GHC.Classes.Ord x, GHC.Classes.Ord y) => GHC.Classes.Ord (Numeric.Interpolation.NodeList.T x y)
instance (GHC.Classes.Eq x, GHC.Classes.Eq y) => GHC.Classes.Eq (Numeric.Interpolation.NodeList.T x y)
instance GHC.Base.Functor (Numeric.Interpolation.NodeList.T x)
instance Data.Foldable.Foldable (Numeric.Interpolation.NodeList.T x)
instance Data.Traversable.Traversable (Numeric.Interpolation.NodeList.T x)


-- | Interpolation basis functions using all given nodes. The represented
--   functions are equivalent to the ones from
--   <a>Numeric.Interpolation.Basis.Compact</a> but less efficient for
--   evaluation.
module Numeric.Interpolation.Basis.Full
linear :: Num b => [a] -> [T a b]
hermite1 :: Num b => [a] -> [T a (b, b)]


-- | Interpolation basis functions represented with a minimum of required
--   nodes.
module Numeric.Interpolation.Basis.Compact
linear :: Num b => [a] -> [T a b]
hermite1 :: Num b => [a] -> [T a (b, b)]

-- | Cubic interpolation where the derivative at a node is set to the slope
--   of the two adjacent nodes.
cubicLinear :: Fractional a => [a] -> [T a (a, a)]

-- | Cubic interpolation where the derivative at a node is set to the slope
--   of the parabola through the current and the two adjacent nodes.
cubicParabola :: Fractional a => [a] -> [T a (a, a)]


-- | Generate lists of basis functions with respect to interpolation nodes
--   and generate functions from coefficients with respect to these bases.
--   
--   A basis function is one where all but one features are zero. E.g. in a
--   linear basis a basis function is one at one node, and zero at all the
--   other interpolation nodes.
--   
--   You need the basis functions for setting up the matrix for a linear
--   least-squares solver for curve fitting. The solver computes some
--   coefficients and in a second step you convert these coefficients to
--   the piecewise interpolation function.
module Numeric.Interpolation.Basis
linear :: Num b => [a] -> [T a b]
hermite1 :: Num b => [a] -> [T a (b, b)]

-- | Cubic interpolation where the derivative at a node is set to the slope
--   of the two adjacent nodes.
cubicLinear :: Fractional a => [a] -> [T a (a, a)]

-- | Cubic interpolation where the derivative at a node is set to the slope
--   of the parabola through the current and the two adjacent nodes.
cubicParabola :: Fractional a => [a] -> [T a (a, a)]

-- | <tt>coefficientsToLinear nodes coefficients</tt> creates an
--   interpolation function for <tt>nodes</tt>, where the
--   <tt>coefficients</tt> correspond to the basis functions constructed
--   with <tt>Basis.linear nodes</tt>.
coefficientsToLinear :: [a] -> [b] -> T a b

-- | Cf. <a>coefficientsToLinear</a>
coefficientsToHermite1 :: [a] -> [b] -> T a (b, b)

-- | Cf. <a>coefficientsToLinear</a>
coefficientsToCubicLinear :: Fractional a => [a] -> [a] -> T a (a, a)

-- | Cf. <a>coefficientsToLinear</a>
coefficientsToCubicParabola :: Fractional a => [a] -> [a] -> T a (a, a)

module Numeric.Interpolation.Piece
type T x y ny = (x, ny) -> (x, ny) -> x -> y

-- | <pre>
--   forAllDistinctPoints $ \p1 p2 x -&gt; Piece.linear p1 p2 x == Piece.linear p2 p1 x
--   </pre>
linear :: Fractional a => T a a a

-- | Hermite interpolation with one derivative per node. That is, the
--   interpolating polynomial is cubic.
--   
--   <pre>
--   forAllDistinctPoints $ \p1 p2 x -&gt; Piece.hermite1 p1 p2 x == Piece.hermite1 p2 p1 x
--   </pre>
--   
--   <pre>
--   forAllDistinctPoints $ \p1@(x1,y1) p2@(x2,y2) x -&gt; Piece.linear p1 p2 x == let slope = (y2-y1)/(x2-x1) in Piece.hermite1 (x1, (y1,slope)) (x2, (y2,slope)) x
--   </pre>
--   
--   <pre>
--   forAllDistinctPoints $ \p1 p2 x -&gt; Piece.hermite1 p1 p2 x == PiecePriv.hermite1 p1 p2 x
--   </pre>
hermite1 :: Fractional a => T a a (a, a)

module Numeric.Interpolation.Sample
type T x y = [x] -> x -> [(Int, y)]
linear :: (Fractional a, Ord a) => T a a
hermite1 :: (Fractional a, Ord a) => T a a
cubicLinear :: (Fractional a, Ord a) => T a a
cubicParabola :: (Fractional a, Ord a) => T a a

module Numeric.Interpolation.Type
data T x y ny
Cons :: ([x] -> [y] -> String) -> T x y ny -> Int -> ([x] -> [T x ny]) -> ([x] -> x -> [(Int, y)]) -> ([x] -> [y] -> T x ny) -> (ny -> y) -> T x y ny
[ssvFromNodes] :: T x y ny -> [x] -> [y] -> String
[interpolatePiece] :: T x y ny -> T x y ny

-- | maximum difference of indices of basis functions that overlap plus one
[basisOverlap] :: T x y ny -> Int
[basisFunctions] :: T x y ny -> [x] -> [T x ny]
[sampleBasisFunctions] :: T x y ny -> [x] -> x -> [(Int, y)]
[coefficientsToInterpolator] :: T x y ny -> [x] -> [y] -> T x ny
[valueFromNode] :: T x y ny -> ny -> y

-- | <pre>
--   checkOverlap Type.linear
--   </pre>
linear :: (Fractional a, Ord a, Show a) => T a a a

-- | <pre>
--   checkOverlap Type.hermite1
--   </pre>
hermite1 :: (Fractional a, Ord a, Show a) => T a a (a, a)

-- | <pre>
--   checkOverlap Type.cubicLinear
--   </pre>
cubicLinear :: (Fractional a, Ord a, Show a) => T a a (a, a)

-- | <pre>
--   checkOverlap Type.cubicParabola
--   </pre>
cubicParabola :: (Fractional a, Ord a, Show a) => T a a (a, a)

module Numeric.Interpolation.Piecewise

-- | It is a checked error to interpolate outside of the range of nodes.
--   
--   <pre>
--   &gt;&gt;&gt; Piecewise.interpolate Type.linear (Nodes.fromList [(0,0),(3,6),(5,10::Rational)]) 2
--   4 % 1
--   
--   &gt;&gt;&gt; Piecewise.interpolate Type.hermite1 (Nodes.fromList [(0,(0,0)),(3,(9,6)),(5,(25,10::Rational))]) 2
--   4 % 1
--   
--   &gt;&gt;&gt; Piecewise.interpolate Type.hermite1 (Nodes.fromList [(0,(1,-2)),(3,(4,4)),(5,(16,8::Rational))]) 2
--   1 % 1
--   </pre>
interpolate :: Ord x => T x y ny -> T x ny -> x -> y

-- | Outside the range of nodes the interpolation function takes the value
--   of the respective border.
--   
--   <pre>
--   forAllSortedRatios $ checkEq Type.linear
--   </pre>
--   
--   <pre>
--   forAllSortedRatios $ checkEq Type.hermite1
--   </pre>
--   
--   <pre>
--   forAllSortedRatios $ \nodeXs x -&gt; lengthAtLeast 4 nodeXs ==&gt; checkEq Type.cubicLinear nodeXs x
--   </pre>
--   
--   <pre>
--   forAllSortedRatios $ \nodeXs x -&gt; lengthAtLeast 4 nodeXs ==&gt; checkEq Type.cubicParabola nodeXs x
--   </pre>
--   
--   Linear interpolation can be used to compute the median, a quartile or
--   any other quantile of a list of arbitrary numbers.
--   
--   <pre>
--   &gt;&gt;&gt; quantile [2,5,3::Rational] 0.5
--   3 % 1
--   
--   &gt;&gt;&gt; quantile [2,5,3,7::Rational] 0.5
--   4 % 1
--   
--   &gt;&gt;&gt; quantile [2,5,3,7::Rational] 0.25
--   11 % 4
--   </pre>
--   
--   <pre>
--   \(QC.NonEmpty xs) -&gt; quantile (xs::[Rational]) 0 == minimum xs
--   </pre>
--   
--   <pre>
--   \(QC.NonEmpty xs) -&gt; quantile (xs::[Rational]) 1 == maximum xs
--   </pre>
interpolateConstantExt :: Ord x => T x y ny -> T x ny -> x -> y