```{-|
Module      : Math.ExpPairs.Process
Copyright   : (c) Andrew Lelechenko, 2014-2020
Maintainer  : andrew.lelechenko@gmail.com

Sequences of \( A \)- and \( B \)-processes
of van der Corput's method of exponential sums.
A good reference can be found in
/Graham S. W., Kolesnik G. A./
Van Der Corput's Method of Exponential Sums,
Cambridge University Press, 1991,
especially Ch. 5.
-}

{-# LANGUAGE DeriveGeneric   #-}

module Math.ExpPairs.Process
( Process ()
, Path (Path)
, aPath
, baPath
, evalPath
, lengthPath
) where

import GHC.Generics             (Generic)
import Data.Text.Prettyprint.Doc hiding ((<>))

import Math.ExpPairs.ProcessMatrix
import Math.ExpPairs.PrettyProcess

-- | Holds a list of 'Process' and a matrix of projective
-- transformation, which they define.
data Path = Path !ProcessMatrix ![Process]
deriving (Eq, Show, Generic)

instance Semigroup Path where
Path m1 p1 <> Path m2 p2 = Path (m1 <> m2) (p1 <> p2)

instance Monoid Path where
mempty  = Path mempty mempty
mappend = (<>)

instance Pretty Path where
pretty (Path _ l) = pretty (prettify l)

reads' ('A':xs) = (aPath <> path, ys) where
reads' ('B':'A':xs) = (baPath <> path, ys) where

instance Ord Path where
compare (Path _ x) (Path _ y) = cmp x y where
cmp     []      []  = EQ
cmp ( A:u) ( A:v) = cmp u v
cmp (BA:u) (BA:v) = cmp v u
cmp ( A:_)     _  = LT
cmp (BA:_)     _  = GT
cmp     _  ( A:_) = GT
cmp     _  (BA:_) = LT

-- | Path consisting of a single process 'A'.
aPath :: Path
aPath  = Path aMatrix [ A]

-- | Path consisting of a single process 'BA'.
baPath :: Path
baPath = Path baMatrix [BA]

-- | Apply a projective transformation, defined by 'Path',
-- to a given point in two-dimensional projective space.
evalPath :: (Num t) => Path -> (t, t, t) -> (t, t, t)
evalPath (Path m _) = evalMatrix m

-- | Count processes in the 'Path'. Note that 'BA' counts
-- for a single process.
lengthPath :: Path -> Int
lengthPath (Path _ xs) = length xs
```