-- |
-- Module      :  Phonetic.Languages.Simplified.DataG
-- Copyright   :  (c) OleksandrZhabenko 2020
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  olexandr543@yahoo.com
--
-- Simplified version of the @phonetic-languages-common@ and @phonetic-languages-general@ packages.


{-# LANGUAGE BangPatterns, FlexibleContexts #-}

module Phonetic.Languages.Simplified.DataG where

import qualified Data.Foldable as F
import Data.Monoid
import Data.SubG
import Data.MinMax.Preconditions

data Result t a b c = R {Result t a b c -> t a
line :: !(t a), Result t a b c -> b
metrices :: !b,  Result t a b c -> c
transMetrices :: !c} deriving Result t a b c -> Result t a b c -> Bool
(Result t a b c -> Result t a b c -> Bool)
-> (Result t a b c -> Result t a b c -> Bool)
-> Eq (Result t a b c)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (t :: * -> *) a b c.
(Eq b, Eq c, Eq (t a)) =>
Result t a b c -> Result t a b c -> Bool
/= :: Result t a b c -> Result t a b c -> Bool
$c/= :: forall (t :: * -> *) a b c.
(Eq b, Eq c, Eq (t a)) =>
Result t a b c -> Result t a b c -> Bool
== :: Result t a b c -> Result t a b c -> Bool
$c== :: forall (t :: * -> *) a b c.
(Eq b, Eq c, Eq (t a)) =>
Result t a b c -> Result t a b c -> Bool
Eq

instance (Ord (t a), Ord b, Ord c) => Ord (Result t a b c) where
  compare :: Result t a b c -> Result t a b c -> Ordering
compare Result t a b c
x Result t a b c
y
    = case c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
x) (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
y) of
       Ordering
EQ -> case b -> b -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> b
forall (t :: * -> *) a b c. Result t a b c -> b
metrices Result t a b c
x) (Result t a b c -> b
forall (t :: * -> *) a b c. Result t a b c -> b
metrices Result t a b c
y) of
              Ordering
EQ -> t a -> t a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> t a
forall (t :: * -> *) a b c. Result t a b c -> t a
line Result t a b c
x) (Result t a b c -> t a
forall (t :: * -> *) a b c. Result t a b c -> t a
line Result t a b c
y)
              Ordering
z -> Ordering
z
       Ordering
z0 -> Ordering
z0

data FuncRep2 a b c = D (a -> b) (b -> c)

getAC :: FuncRep2 a b c -> (a -> c)
getAC :: FuncRep2 a b c -> a -> c
getAC (D a -> b
f b -> c
g) = b -> c
g (b -> c) -> (a -> b) -> a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f

getAB :: FuncRep2 a b c -> (a -> b)
getAB :: FuncRep2 a b c -> a -> b
getAB (D a -> b
f b -> c
_) = a -> b
f

getBC :: FuncRep2 a b c -> (b -> c)
getBC :: FuncRep2 a b c -> b -> c
getBC (D a -> b
_ b -> c
g) = b -> c
g

maximumEl
  :: (Foldable t2, Ord c) => FuncRep2 (t a) b c
  -> t2 (t a)
  -> Result t a b c
maximumEl :: FuncRep2 (t a) b c -> t2 (t a) -> Result t a b c
maximumEl FuncRep2 (t a) b c
frep2 t2 (t a)
data0 =
  let l :: t a
l = (t a -> t a -> Ordering) -> t2 (t a) -> t a
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
F.maximumBy (\t a
x t a
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
x) (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
y)) t2 (t a)
data0
      m :: b
m = FuncRep2 (t a) b c -> t a -> b
forall a b c. FuncRep2 a b c -> a -> b
getAB FuncRep2 (t a) b c
frep2 t a
l
      tm :: c
tm = FuncRep2 (t a) b c -> b -> c
forall a b c. FuncRep2 a b c -> b -> c
getBC FuncRep2 (t a) b c
frep2 b
m in R :: forall (t :: * -> *) a b c. t a -> b -> c -> Result t a b c
R {line :: t a
line = t a
l, metrices :: b
metrices = b
m, transMetrices :: c
transMetrices = c
tm}

minMaximumEls
  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord (t a), Ord c) => FuncRep2 (t a) b c
  -> t2 (t a)
  -> (Result t a b c,Result t a b c)
minMaximumEls :: FuncRep2 (t a) b c -> t2 (t a) -> (Result t a b c, Result t a b c)
minMaximumEls FuncRep2 (t a) b c
frep2 t2 (t a)
data0 =
  let (t a
ln,t a
lx) = (t a -> t a -> Ordering) -> t2 (t a) -> (t a, t a)
forall a (t :: * -> *).
(Ord a, InsertLeft t a, Monoid (t a)) =>
(a -> a -> Ordering) -> t a -> (a, a)
minMax11ByC (\t a
x t a
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
x) (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
y)) t2 (t a)
data0
      mn :: b
mn = FuncRep2 (t a) b c -> t a -> b
forall a b c. FuncRep2 a b c -> a -> b
getAB FuncRep2 (t a) b c
frep2 t a
ln
      mx :: b
mx = FuncRep2 (t a) b c -> t a -> b
forall a b c. FuncRep2 a b c -> a -> b
getAB FuncRep2 (t a) b c
frep2 t a
lx
      tmn :: c
tmn = FuncRep2 (t a) b c -> b -> c
forall a b c. FuncRep2 a b c -> b -> c
getBC FuncRep2 (t a) b c
frep2 b
mn
      tmx :: c
tmx = FuncRep2 (t a) b c -> b -> c
forall a b c. FuncRep2 a b c -> b -> c
getBC FuncRep2 (t a) b c
frep2 b
mx in (R :: forall (t :: * -> *) a b c. t a -> b -> c -> Result t a b c
R {line :: t a
line = t a
ln, metrices :: b
metrices = b
mn, transMetrices :: c
transMetrices = c
tmn}, R :: forall (t :: * -> *) a b c. t a -> b -> c -> Result t a b c
R {line :: t a
line = t a
lx, metrices :: b
metrices = b
mx, transMetrices :: c
transMetrices = c
tmx})

maximumElR
  :: (Foldable t2, Ord c) => t2 (Result t a b c)
  -> Result t a b c
maximumElR :: t2 (Result t a b c) -> Result t a b c
maximumElR = (Result t a b c -> Result t a b c -> Ordering)
-> t2 (Result t a b c) -> Result t a b c
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
F.maximumBy (\Result t a b c
x Result t a b c
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
x) (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
y))

minMaximumElRs
  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord (t a), Ord b, Ord c) => t2 (Result t a b c)
  -> (Result t a b c,Result t a b c)
minMaximumElRs :: t2 (Result t a b c) -> (Result t a b c, Result t a b c)
minMaximumElRs = (Result t a b c -> Result t a b c -> Ordering)
-> t2 (Result t a b c) -> (Result t a b c, Result t a b c)
forall a (t :: * -> *).
(Ord a, InsertLeft t a, Monoid (t a)) =>
(a -> a -> Ordering) -> t a -> (a, a)
minMax11ByC (\Result t a b c
x Result t a b c
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
x) (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
y))

-----------------------------------------------------------------------------------

innerPartitioning
  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c) => FuncRep2 (t a) b c
  -> t2 (t a)
  -> (t2 (t a), t2 (t a))
innerPartitioning :: FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
innerPartitioning FuncRep2 (t a) b c
frep2 t2 (t a)
data0 =
  let l :: c
l = FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 (t a -> c) -> (t2 (t a) -> t a) -> t2 (t a) -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t a -> t a -> Ordering) -> t2 (t a) -> t a
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
F.maximumBy (\t a
x t a
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
x) (FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2 t a
y)) (t2 (t a) -> c) -> t2 (t a) -> c
forall a b. (a -> b) -> a -> b
$ t2 (t a)
data0 in (t a -> Bool) -> t2 (t a) -> (t2 (t a), t2 (t a))
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> (t a, t a)
partitionG ((c -> c -> Bool
forall a. Eq a => a -> a -> Bool
== c
l) (c -> Bool) -> (t a -> c) -> t a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuncRep2 (t a) b c -> t a -> c
forall a b c. FuncRep2 a b c -> a -> c
getAC FuncRep2 (t a) b c
frep2) t2 (t a)
data0

maximumGroupsClassification
  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, Integral d) => d
  -> FuncRep2 (t a) b c
  -> (t2 (t a), t2 (t a))
  -> (t2 (t a), t2 (t a))
maximumGroupsClassification :: d
-> FuncRep2 (t a) b c
-> (t2 (t a), t2 (t a))
-> (t2 (t a), t2 (t a))
maximumGroupsClassification d
nGroups FuncRep2 (t a) b c
frep2 (t2 (t a)
dataT,t2 (t a)
dataF)
 | d
nGroups d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
0 = (t2 (t a)
dataT,t2 (t a)
dataF)
 | Bool
otherwise = d
-> FuncRep2 (t a) b c
-> (t2 (t a), t2 (t a))
-> (t2 (t a), t2 (t a))
forall (t2 :: * -> *) (t :: * -> *) a c d b.
(InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, Integral d) =>
d
-> FuncRep2 (t a) b c
-> (t2 (t a), t2 (t a))
-> (t2 (t a), t2 (t a))
maximumGroupsClassification (d
nGroups d -> d -> d
forall a. Num a => a -> a -> a
- d
1) FuncRep2 (t a) b c
frep2 (t2 (t a)
dataT t2 (t a) -> t2 (t a) -> t2 (t a)
forall a. Monoid a => a -> a -> a
`mappend` t2 (t a)
partT,t2 (t a)
partF)
     where (t2 (t a)
partT,t2 (t a)
partF) = FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
forall (t2 :: * -> *) (t :: * -> *) a c b.
(InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c) =>
FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
innerPartitioning FuncRep2 (t a) b c
frep2 t2 (t a)
dataF

maximumGroupsClassification1
  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, Integral d) => d
  -> FuncRep2 (t a) b c
  -> t2 (t a)
  -> (t2 (t a), t2 (t a))
maximumGroupsClassification1 :: d -> FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
maximumGroupsClassification1 d
nGroups FuncRep2 (t a) b c
frep2 t2 (t a)
data0
 | d
nGroups d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
0 = FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
forall (t2 :: * -> *) (t :: * -> *) a c b.
(InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c) =>
FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
innerPartitioning FuncRep2 (t a) b c
frep2 t2 (t a)
data0
 | Bool
otherwise = d
-> FuncRep2 (t a) b c
-> (t2 (t a), t2 (t a))
-> (t2 (t a), t2 (t a))
forall (t2 :: * -> *) (t :: * -> *) a c d b.
(InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, Integral d) =>
d
-> FuncRep2 (t a) b c
-> (t2 (t a), t2 (t a))
-> (t2 (t a), t2 (t a))
maximumGroupsClassification (d
nGroups d -> d -> d
forall a. Num a => a -> a -> a
- d
1) FuncRep2 (t a) b c
frep2 ((t2 (t a), t2 (t a)) -> (t2 (t a), t2 (t a)))
-> (t2 (t a) -> (t2 (t a), t2 (t a)))
-> t2 (t a)
-> (t2 (t a), t2 (t a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
forall (t2 :: * -> *) (t :: * -> *) a c b.
(InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c) =>
FuncRep2 (t a) b c -> t2 (t a) -> (t2 (t a), t2 (t a))
innerPartitioning FuncRep2 (t a) b c
frep2 (t2 (t a) -> (t2 (t a), t2 (t a)))
-> t2 (t a) -> (t2 (t a), t2 (t a))
forall a b. (a -> b) -> a -> b
$ t2 (t a)
data0

maximumGroupsClassificationR
  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord c, Integral d) => d
  -> FuncRep2 (t a) b c
  -> t2 (Result t a b c)
  -> (t2 (Result t a b c), t2 (Result t a b c))
maximumGroupsClassificationR :: d
-> FuncRep2 (t a) b c
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
maximumGroupsClassificationR d
nGroups FuncRep2 (t a) b c
frep2 t2 (Result t a b c)
data0
 | d
nGroups d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
1 = (t2 (Result t a b c)
partT,t2 (Result t a b c)
partF)
 | Bool
otherwise = (t2 (Result t a b c)
partT t2 (Result t a b c) -> t2 (Result t a b c) -> t2 (Result t a b c)
forall a. Monoid a => a -> a -> a
`mappend` ((t2 (Result t a b c), t2 (Result t a b c)) -> t2 (Result t a b c)
forall a b. (a, b) -> a
fst ((t2 (Result t a b c), t2 (Result t a b c)) -> t2 (Result t a b c))
-> (t2 (Result t a b c)
    -> (t2 (Result t a b c), t2 (Result t a b c)))
-> t2 (Result t a b c)
-> t2 (Result t a b c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. d
-> FuncRep2 (t a) b c
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
forall (t2 :: * -> *) (t :: * -> *) a b c d.
(InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)),
 Ord c, Integral d) =>
d
-> FuncRep2 (t a) b c
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
maximumGroupsClassificationR (d
nGroups d -> d -> d
forall a. Num a => a -> a -> a
- d
1) FuncRep2 (t a) b c
frep2 (t2 (Result t a b c) -> t2 (Result t a b c))
-> t2 (Result t a b c) -> t2 (Result t a b c)
forall a b. (a -> b) -> a -> b
$ t2 (Result t a b c)
partF),(t2 (Result t a b c), t2 (Result t a b c)) -> t2 (Result t a b c)
forall a b. (a, b) -> b
snd ((t2 (Result t a b c), t2 (Result t a b c)) -> t2 (Result t a b c))
-> (t2 (Result t a b c)
    -> (t2 (Result t a b c), t2 (Result t a b c)))
-> t2 (Result t a b c)
-> t2 (Result t a b c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. d
-> FuncRep2 (t a) b c
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
forall (t2 :: * -> *) (t :: * -> *) a b c d.
(InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)),
 Ord c, Integral d) =>
d
-> FuncRep2 (t a) b c
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
maximumGroupsClassificationR (d
nGroups d -> d -> d
forall a. Num a => a -> a -> a
- d
1) FuncRep2 (t a) b c
frep2 (t2 (Result t a b c) -> t2 (Result t a b c))
-> t2 (Result t a b c) -> t2 (Result t a b c)
forall a b. (a -> b) -> a -> b
$ t2 (Result t a b c)
partF)
     where maxE0 :: c
maxE0 = Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices (Result t a b c -> c)
-> (t2 (Result t a b c) -> Result t a b c)
-> t2 (Result t a b c)
-> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Result t a b c -> Result t a b c -> Ordering)
-> t2 (Result t a b c) -> Result t a b c
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
F.maximumBy (\Result t a b c
x Result t a b c
y -> c -> c -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
x) (Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices Result t a b c
y)) (t2 (Result t a b c) -> c) -> t2 (Result t a b c) -> c
forall a b. (a -> b) -> a -> b
$ t2 (Result t a b c)
data0
           (t2 (Result t a b c)
partT,t2 (Result t a b c)
partF) = (Result t a b c -> Bool)
-> t2 (Result t a b c)
-> (t2 (Result t a b c), t2 (Result t a b c))
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> (t a, t a)
partitionG ((c -> c -> Bool
forall a. Eq a => a -> a -> Bool
== c
maxE0) (c -> Bool) -> (Result t a b c -> c) -> Result t a b c -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Result t a b c -> c
forall (t :: * -> *) a b c. Result t a b c -> c
transMetrices) t2 (Result t a b c)
data0

toResultR
  :: FuncRep2 (t a) b c
  -> t a
  -> Result t a b c
toResultR :: FuncRep2 (t a) b c -> t a -> Result t a b c
toResultR FuncRep2 (t a) b c
frep2 t a
ys = R :: forall (t :: * -> *) a b c. t a -> b -> c -> Result t a b c
R { line :: t a
line = t a
ys, metrices :: b
metrices = b
m, transMetrices :: c
transMetrices = c
tm}
  where m :: b
m = FuncRep2 (t a) b c -> t a -> b
forall a b c. FuncRep2 a b c -> a -> b
getAB FuncRep2 (t a) b c
frep2 t a
ys
        tm :: c
tm = FuncRep2 (t a) b c -> b -> c
forall a b c. FuncRep2 a b c -> b -> c
getBC FuncRep2 (t a) b c
frep2 b
m