-- |
-- Module      :  DobutokO.Sound.Effects.MCompand
-- Copyright   :  (c) OleksandrZhabenko 2020
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  olexandr543@yahoo.com
--
-- Helps to create experimental music. 
-- Can be used for applying the SoX \"compand\" and \"mcompand\" effects. 
-- 

{-# OPTIONS_GHC -threaded #-}
{-# LANGUAGE CPP, FlexibleInstances #-}

module DobutokO.Sound.Effects.MCompand where

#ifdef __GLASGOW_HASKELL__
#if __GLASGOW_HASKELL__>=710
/* code that applies only to GHC 7.10.* and higher versions */
import GHC.Base (mconcat)
#endif
#endif
import Numeric (showFFloat)
import Data.List (intersperse)
import DobutokO.Sound.One

#ifdef __GLASGOW_HASKELL__
#if __GLASGOW_HASKELL__==708
/* code that applies only to GHC 7.8.* */
mconcat = concat
#endif
#endif

data FloatE a = InfP | InfM | Float1 a deriving FloatE a -> FloatE a -> Bool
(FloatE a -> FloatE a -> Bool)
-> (FloatE a -> FloatE a -> Bool) -> Eq (FloatE a)
forall a. Eq a => FloatE a -> FloatE a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FloatE a -> FloatE a -> Bool
$c/= :: forall a. Eq a => FloatE a -> FloatE a -> Bool
== :: FloatE a -> FloatE a -> Bool
$c== :: forall a. Eq a => FloatE a -> FloatE a -> Bool
Eq

instance Show (FloatE Float) where
  show :: FloatE Float -> String
show FloatE Float
InfP = String
"inf "
  show FloatE Float
InfM = String
"-inf "
  show (Float1 Float
x) = Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
x String
" "

type Float3 = FloatE Float

floatE1 :: FloatE a -> Maybe a
floatE1 :: FloatE a -> Maybe a
floatE1 (Float1 a
x) = a -> Maybe a
forall a. a -> Maybe a
Just a
x
floatE1 FloatE a
_ = Maybe a
forall a. Maybe a
Nothing

floatESet1 :: a -> FloatE a
floatESet1 :: a -> FloatE a
floatESet1 = a -> FloatE a
forall a. a -> FloatE a
Float1 

isInfS :: FloatE a -> Bool
isInfS :: FloatE a -> Bool
isInfS (Float1 a
_)  = Bool
False
isInfS FloatE a
_ = Bool
True

isInfP :: FloatE a -> Bool
isInfP :: FloatE a -> Bool
isInfP FloatE a
InfP = Bool
True
isInfP FloatE a
_ = Bool
False

isInfM :: FloatE a -> Bool
isInfM :: FloatE a -> Bool
isInfM FloatE a
InfM = Bool
True
isInfM FloatE a
_ = Bool
False

isFloatE1 :: FloatE a -> Bool
isFloatE1 :: FloatE a -> Bool
isFloatE1 (Float1 a
_) = Bool
True
isFloatE1 FloatE a
_ = Bool
False

absEP :: Float3 -> Float3
absEP :: FloatE Float -> FloatE Float
absEP (Float1 Float
x) = Float -> FloatE Float
forall a. a -> FloatE a
Float1 (Float -> Float
forall a. Num a => a -> a
abs Float
x)
absEP FloatE Float
_ = FloatE Float
forall a. FloatE a
InfP

absEN :: Float3 -> Float3
absEN :: FloatE Float -> FloatE Float
absEN (Float1 Float
x) = Float -> FloatE Float
forall a. a -> FloatE a
Float1 (-Float -> Float
forall a. Num a => a -> a
abs Float
x)
absEN FloatE Float
_ = FloatE Float
forall a. FloatE a
InfM

data CompandTail a b = N | CT1 a | CT2 a a | CT3 a a b deriving CompandTail a b -> CompandTail a b -> Bool
(CompandTail a b -> CompandTail a b -> Bool)
-> (CompandTail a b -> CompandTail a b -> Bool)
-> Eq (CompandTail a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
(Eq a, Eq b) =>
CompandTail a b -> CompandTail a b -> Bool
/= :: CompandTail a b -> CompandTail a b -> Bool
$c/= :: forall a b.
(Eq a, Eq b) =>
CompandTail a b -> CompandTail a b -> Bool
== :: CompandTail a b -> CompandTail a b -> Bool
$c== :: forall a b.
(Eq a, Eq b) =>
CompandTail a b -> CompandTail a b -> Bool
Eq

instance Show (CompandTail Float3 Float) where
  show :: CompandTail (FloatE Float) Float -> String
show CompandTail (FloatE Float) Float
N = String
" "
  show (CT1 FloatE Float
x) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [FloatE Float -> String
forall a. Show a => a -> String
show FloatE Float
x, String
" "]
  show (CT2 FloatE Float
x FloatE Float
y) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [FloatE Float -> String
forall a. Show a => a -> String
show FloatE Float
x, String
" ", FloatE Float -> String
forall a. Show a => a -> String
show (FloatE Float -> FloatE Float
absEN FloatE Float
y), String
" "]
  show (CT3 FloatE Float
x FloatE Float
y Float
z) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [FloatE Float -> String
forall a. Show a => a -> String
show FloatE Float
x, String
" ", FloatE Float -> String
forall a. Show a => a -> String
show (FloatE Float -> FloatE Float
absEN FloatE Float
y), String
" ",  Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (Float -> Float
forall a. Num a => a -> a
abs Float
z) String
" "]

type CompTail = CompandTail Float3 Float

compandTail1 :: CompandTail a b -> Maybe (One2 a)
compandTail1 :: CompandTail a b -> Maybe (One2 a)
compandTail1 (CT1 a
x) = One2 a -> Maybe (One2 a)
forall a. a -> Maybe a
Just (a -> One2 a
forall a. a -> One2 a
O21 a
x)
compandTail1 (CT2 a
x a
y) = One2 a -> Maybe (One2 a)
forall a. a -> Maybe a
Just (a -> a -> One2 a
forall a. a -> a -> One2 a
O22 a
x a
y)
compandTail1 (CT3 a
x a
y b
_) = One2 a -> Maybe (One2 a)
forall a. a -> Maybe a
Just (a -> a -> One2 a
forall a. a -> a -> One2 a
O22 a
x a
y)
compandTail1 CompandTail a b
_ = Maybe (One2 a)
forall a. Maybe a
Nothing

compandTail2 :: CompandTail a b -> Maybe b
compandTail2 :: CompandTail a b -> Maybe b
compandTail2 (CT3 a
_ a
_ b
y) = b -> Maybe b
forall a. a -> Maybe a
Just b
y
compandTail2 CompandTail a b
_ = Maybe b
forall a. Maybe a
Nothing

compandTailSet1 :: One2 a -> CompandTail a b -> CompandTail a b
compandTailSet1 :: One2 a -> CompandTail a b -> CompandTail a b
compandTailSet1 (O21 a
x) (CT2 a
_ a
y) = a -> a -> CompandTail a b
forall a b. a -> a -> CompandTail a b
CT2 a
x a
y
compandTailSet1 (O21 a
x) (CT3 a
_ a
y b
z) = a -> a -> b -> CompandTail a b
forall a b. a -> a -> b -> CompandTail a b
CT3 a
x a
y b
z
compandTailSet1 (O22 a
x a
y) (CT2 a
_ a
_) = a -> a -> CompandTail a b
forall a b. a -> a -> CompandTail a b
CT2 a
x a
y
compandTailSet1 (O22 a
x a
y) (CT3 a
_ a
_ b
z) = a -> a -> b -> CompandTail a b
forall a b. a -> a -> b -> CompandTail a b
CT3 a
x a
y b
z
compandTailSet1 (O21 a
x) CompandTail a b
_ = a -> CompandTail a b
forall a b. a -> CompandTail a b
CT1 a
x
compandTailSet1 (O22 a
x a
y) CompandTail a b
_ = a -> a -> CompandTail a b
forall a b. a -> a -> CompandTail a b
CT2 a
x a
y

compandTailSet2 :: b -> CompandTail a b -> Maybe (CompandTail a b)
compandTailSet2 :: b -> CompandTail a b -> Maybe (CompandTail a b)
compandTailSet2 b
z (CT2 a
x a
y) = CompandTail a b -> Maybe (CompandTail a b)
forall a. a -> Maybe a
Just (a -> a -> b -> CompandTail a b
forall a b. a -> a -> b -> CompandTail a b
CT3 a
x a
y b
z)
compandTailSet2 b
z (CT3 a
x a
y b
_) = CompandTail a b -> Maybe (CompandTail a b)
forall a. a -> Maybe a
Just (a -> a -> b -> CompandTail a b
forall a b. a -> a -> b -> CompandTail a b
CT3 a
x a
y b
z)
compandTailSet2 b
_ CompandTail a b
_ = Maybe (CompandTail a b)
forall a. Maybe a
Nothing

showCTQ :: CompTail -> [String]
showCTQ :: CompandTail (FloatE Float) Float -> [String]
showCTQ = String -> [String]
words (String -> [String])
-> (CompandTail (FloatE Float) Float -> String)
-> CompandTail (FloatE Float) Float
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompandTail (FloatE Float) Float -> String
forall a. Show a => a -> String
show

data Pair a = AD a a deriving Pair a -> Pair a -> Bool
(Pair a -> Pair a -> Bool)
-> (Pair a -> Pair a -> Bool) -> Eq (Pair a)
forall a. Eq a => Pair a -> Pair a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pair a -> Pair a -> Bool
$c/= :: forall a. Eq a => Pair a -> Pair a -> Bool
== :: Pair a -> Pair a -> Bool
$c== :: forall a. Eq a => Pair a -> Pair a -> Bool
Eq

instance Show (Pair Float) where
  show :: Pair Float -> String
show (AD Float
x Float
y) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (Float -> Float
forall a. Num a => a -> a
abs Float
x) String
",",Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (Float -> Float
forall a. Num a => a -> a
abs Float
y) String
""]

type Pr = Pair Float  

pair1 :: Pair a -> a
pair1 :: Pair a -> a
pair1 (AD a
x a
_) = a
x

pair2 :: Pair a -> a
pair2 :: Pair a -> a
pair2 (AD a
_ a
y) = a
y

pairSet1 :: a -> Pair a -> Pair a
pairSet1 :: a -> Pair a -> Pair a
pairSet1 a
x (AD a
_ a
y) = a -> a -> Pair a
forall a. a -> a -> Pair a
AD a
x a
y

pairSet2 :: a -> Pair a -> Pair a
pairSet2 :: a -> Pair a -> Pair a
pairSet2 a
y (AD a
x a
_) = a -> a -> Pair a
forall a. a -> a -> Pair a
AD a
x a
y

data AtDe a = ADM a [a] deriving AtDe a -> AtDe a -> Bool
(AtDe a -> AtDe a -> Bool)
-> (AtDe a -> AtDe a -> Bool) -> Eq (AtDe a)
forall a. Eq a => AtDe a -> AtDe a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AtDe a -> AtDe a -> Bool
$c/= :: forall a. Eq a => AtDe a -> AtDe a -> Bool
== :: AtDe a -> AtDe a -> Bool
$c== :: forall a. Eq a => AtDe a -> AtDe a -> Bool
Eq

instance Show (AtDe Pr) where
  show :: AtDe (Pair Float) -> String
show (ADM (AD Float
x Float
y) [Pair Float]
zs) 
    | [Pair Float] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Pair Float]
zs = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Pair Float -> String
forall a. Show a => a -> String
show (Float -> Float -> Pair Float
forall a. a -> a -> Pair a
AD Float
x Float
y), String
" "]
    | Bool
otherwise = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Pair Float -> String
forall a. Show a => a -> String
show (Float -> Float -> Pair Float
forall a. a -> a -> Pair a
AD Float
x Float
y), String
",", [String] -> String
forall a. Monoid a => [a] -> a
mconcat ([String] -> String)
-> ([Pair Float] -> [String]) -> [Pair Float] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> [String]
forall a. a -> [a] -> [a]
intersperse String
"," ([String] -> [String])
-> ([Pair Float] -> [String]) -> [Pair Float] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Pair Float -> String) -> [Pair Float] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Pair Float -> String
forall a. Show a => a -> String
show ([Pair Float] -> String) -> [Pair Float] -> String
forall a b. (a -> b) -> a -> b
$ [Pair Float]
zs, String
" "]

type AtD2 = AtDe Pr

atDe1 :: AtDe a -> a
atDe1 :: AtDe a -> a
atDe1 (ADM a
x [a]
_) = a
x

atDe2 :: AtDe a -> [a]
atDe2 :: AtDe a -> [a]
atDe2 (ADM a
_ [a]
xs) = [a]
xs

atDeSet1 :: a -> AtDe a -> AtDe a
atDeSet1 :: a -> AtDe a -> AtDe a
atDeSet1 a
x (ADM a
_ [a]
xs) = a -> [a] -> AtDe a
forall a. a -> [a] -> AtDe a
ADM a
x [a]
xs

atDeSet2 :: [a] -> AtDe a -> AtDe a
atDeSet2 :: [a] -> AtDe a -> AtDe a
atDeSet2 [a]
xs (ADM a
x [a]
_) = a -> [a] -> AtDe a
forall a. a -> [a] -> AtDe a
ADM a
x [a]
xs

showADQ :: AtD2 -> [String]
showADQ :: AtDe (Pair Float) -> [String]
showADQ = String -> [String]
words (String -> [String])
-> (AtDe (Pair Float) -> String) -> AtDe (Pair Float) -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AtDe (Pair Float) -> String
forall a. Show a => a -> String
show 

data Neg a = NG a deriving Neg a -> Neg a -> Bool
(Neg a -> Neg a -> Bool) -> (Neg a -> Neg a -> Bool) -> Eq (Neg a)
forall a. Eq a => Neg a -> Neg a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Neg a -> Neg a -> Bool
$c/= :: forall a. Eq a => Neg a -> Neg a -> Bool
== :: Neg a -> Neg a -> Bool
$c== :: forall a. Eq a => Neg a -> Neg a -> Bool
Eq

instance Show (Neg Float) where
  show :: Neg Float -> String
show (NG Float
x) = Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (-Float -> Float
forall a. Num a => a -> a
abs Float
x) String
" "

type Ng1 = Neg Float

neg1 :: Neg a -> a
neg1 :: Neg a -> a
neg1 (NG a
x) = a
x

negSet1 :: a -> Neg a
negSet1 :: a -> Neg a
negSet1 = a -> Neg a
forall a. a -> Neg a
NG

type AtDeNF = AtDe (Neg Float)

instance Show AtDeNF where
  show :: AtDeNF -> String
show (ADM (NG Float
x) [Neg Float]
zs) 
    | [Neg Float] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Neg Float]
zs = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Neg Float -> String
forall a. Show a => a -> String
show (Float -> Neg Float
forall a. a -> Neg a
NG Float
x), String
" "]
    | Bool
otherwise = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Neg Float -> String
forall a. Show a => a -> String
show (Float -> Neg Float
forall a. a -> Neg a
NG Float
x), String
",", [String] -> String
forall a. Monoid a => [a] -> a
mconcat ([String] -> String)
-> ([Neg Float] -> [String]) -> [Neg Float] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> [String]
forall a. a -> [a] -> [a]
intersperse String
"," ([String] -> [String])
-> ([Neg Float] -> [String]) -> [Neg Float] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Neg Float -> String) -> [Neg Float] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Neg Float -> String
forall a. Show a => a -> String
show ([Neg Float] -> String) -> [Neg Float] -> String
forall a b. (a -> b) -> a -> b
$ [Neg Float]
zs, String
" "]

data SoftKnee a = NK | SK a deriving SoftKnee a -> SoftKnee a -> Bool
(SoftKnee a -> SoftKnee a -> Bool)
-> (SoftKnee a -> SoftKnee a -> Bool) -> Eq (SoftKnee a)
forall a. Eq a => SoftKnee a -> SoftKnee a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SoftKnee a -> SoftKnee a -> Bool
$c/= :: forall a. Eq a => SoftKnee a -> SoftKnee a -> Bool
== :: SoftKnee a -> SoftKnee a -> Bool
$c== :: forall a. Eq a => SoftKnee a -> SoftKnee a -> Bool
Eq

instance Show (SoftKnee Float) where
  show :: SoftKnee Float -> String
show (SK Float
x) = Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
x String
":"
  show SoftKnee Float
_ = String
""

type SoftK1 = SoftKnee Float 

softKneeC :: SoftKnee a -> String
softKneeC :: SoftKnee a -> String
softKneeC SoftKnee a
NK = String
"NK"
softKneeC SoftKnee a
_ = String
"SK"

softKnee1 :: SoftKnee a -> Maybe a
softKnee1 :: SoftKnee a -> Maybe a
softKnee1 (SK a
x)   = a -> Maybe a
forall a. a -> Maybe a
Just a
x
softKnee1 SoftKnee a
_ = Maybe a
forall a. Maybe a
Nothing

softKneeSet1 :: a -> SoftKnee a
softKneeSet1 :: a -> SoftKnee a
softKneeSet1 = a -> SoftKnee a
forall a. a -> SoftKnee a
SK

data Compand a b c d = CP3 a b c | CP4 a b c d deriving Compand a b c d -> Compand a b c d -> Bool
(Compand a b c d -> Compand a b c d -> Bool)
-> (Compand a b c d -> Compand a b c d -> Bool)
-> Eq (Compand a b c d)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Compand a b c d -> Compand a b c d -> Bool
/= :: Compand a b c d -> Compand a b c d -> Bool
$c/= :: forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Compand a b c d -> Compand a b c d -> Bool
== :: Compand a b c d -> Compand a b c d -> Bool
$c== :: forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Compand a b c d -> Compand a b c d -> Bool
Eq

instance Show (Compand AtD2 SoftK1 AtDeNF CompTail) where
  show :: Compand
  (AtDe (Pair Float))
  (SoftKnee Float)
  AtDeNF
  (CompandTail (FloatE Float) Float)
-> String
show (CP3 AtDe (Pair Float)
x SoftKnee Float
y AtDeNF
z) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
"compand ", AtDe (Pair Float) -> String
forall a. Show a => a -> String
show AtDe (Pair Float)
x, SoftKnee Float -> String
forall a. Show a => a -> String
show SoftKnee Float
y, AtDeNF -> String
forall a. Show a => a -> String
show AtDeNF
z]
  show (CP4 AtDe (Pair Float)
x SoftKnee Float
y AtDeNF
z CompandTail (FloatE Float) Float
t) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
"compand ", AtDe (Pair Float) -> String
forall a. Show a => a -> String
show AtDe (Pair Float)
x, SoftKnee Float -> String
forall a. Show a => a -> String
show SoftKnee Float
y, AtDeNF -> String
forall a. Show a => a -> String
show AtDeNF
z, CompandTail (FloatE Float) Float -> String
forall a. Show a => a -> String
show CompandTail (FloatE Float) Float
t]

type Compand4 = Compand AtD2 SoftK1 AtDeNF CompTail

compand1 :: Compand a b c d -> a
compand1 :: Compand a b c d -> a
compand1 (CP3 a
x b
_ c
_) = a
x
compand1 (CP4 a
x b
_ c
_ d
_) = a
x

compand2 :: Compand a b c d -> b
compand2 :: Compand a b c d -> b
compand2 (CP3 a
_ b
y c
_) = b
y
compand2 (CP4 a
_ b
y c
_ d
_) = b
y

compand3 :: Compand a b c d -> c
compand3 :: Compand a b c d -> c
compand3 (CP3 a
_ b
_ c
z) = c
z
compand3 (CP4 a
_ b
_ c
z d
_) = c
z

compand4 :: Compand a b c d -> Maybe d
compand4 :: Compand a b c d -> Maybe d
compand4 (CP4 a
_ b
_ c
_ d
t) = d -> Maybe d
forall a. a -> Maybe a
Just d
t
compand4 Compand a b c d
_ = Maybe d
forall a. Maybe a
Nothing

compandSet1 :: a -> Compand a b c d -> Compand a b c d
compandSet1 :: a -> Compand a b c d -> Compand a b c d
compandSet1 a
x (CP3 a
_ b
y c
z) = a -> b -> c -> Compand a b c d
forall a b c d. a -> b -> c -> Compand a b c d
CP3 a
x b
y c
z
compandSet1 a
x (CP4 a
_ b
y c
z d
t) = a -> b -> c -> d -> Compand a b c d
forall a b c d. a -> b -> c -> d -> Compand a b c d
CP4 a
x b
y c
z d
t

compandSet2 :: b -> Compand a b c d -> Compand a b c d
compandSet2 :: b -> Compand a b c d -> Compand a b c d
compandSet2 b
y (CP3 a
x b
_ c
z) = a -> b -> c -> Compand a b c d
forall a b c d. a -> b -> c -> Compand a b c d
CP3 a
x b
y c
z
compandSet2 b
y (CP4 a
x b
_ c
z d
t) = a -> b -> c -> d -> Compand a b c d
forall a b c d. a -> b -> c -> d -> Compand a b c d
CP4 a
x b
y c
z d
t

compandSet3 :: c -> Compand a b c d -> Compand a b c d
compandSet3 :: c -> Compand a b c d -> Compand a b c d
compandSet3 c
z (CP3 a
x b
y c
_) = a -> b -> c -> Compand a b c d
forall a b c d. a -> b -> c -> Compand a b c d
CP3 a
x b
y c
z
compandSet3 c
z (CP4 a
x b
y c
_ d
t) = a -> b -> c -> d -> Compand a b c d
forall a b c d. a -> b -> c -> d -> Compand a b c d
CP4 a
x b
y c
z d
t

compandSet4 :: d -> Compand a b c d -> Compand a b c d
compandSet4 :: d -> Compand a b c d -> Compand a b c d
compandSet4 d
t (CP3 a
x b
y c
z) = a -> b -> c -> d -> Compand a b c d
forall a b c d. a -> b -> c -> d -> Compand a b c d
CP4 a
x b
y c
z d
t
compandSet4 d
t (CP4 a
x b
y c
z d
_) = a -> b -> c -> d -> Compand a b c d
forall a b c d. a -> b -> c -> d -> Compand a b c d
CP4 a
x b
y c
z d
t

showCMPDQ :: Compand4 -> [String]
showCMPDQ :: Compand
  (AtDe (Pair Float))
  (SoftKnee Float)
  AtDeNF
  (CompandTail (FloatE Float) Float)
-> [String]
showCMPDQ = String -> [String]
words (String -> [String])
-> (Compand
      (AtDe (Pair Float))
      (SoftKnee Float)
      AtDeNF
      (CompandTail (FloatE Float) Float)
    -> String)
-> Compand
     (AtDe (Pair Float))
     (SoftKnee Float)
     AtDeNF
     (CompandTail (FloatE Float) Float)
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compand
  (AtDe (Pair Float))
  (SoftKnee Float)
  AtDeNF
  (CompandTail (FloatE Float) Float)
-> String
forall a. Show a => a -> String
show 

data KFreq a = Fr a | KFr a deriving KFreq a -> KFreq a -> Bool
(KFreq a -> KFreq a -> Bool)
-> (KFreq a -> KFreq a -> Bool) -> Eq (KFreq a)
forall a. Eq a => KFreq a -> KFreq a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KFreq a -> KFreq a -> Bool
$c/= :: forall a. Eq a => KFreq a -> KFreq a -> Bool
== :: KFreq a -> KFreq a -> Bool
$c== :: forall a. Eq a => KFreq a -> KFreq a -> Bool
Eq

instance Show (KFreq Int) where
  show :: KFreq Int -> String
show (Fr Int
n) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Int -> String
forall a. Show a => a -> String
show (Int -> Int
forall a. Num a => a -> a
abs Int
n), String
" "]
  show (KFr Int
n) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Int -> String
forall a. Show a => a -> String
show (Int -> Int
forall a. Num a => a -> a
abs Int
n), String
"k "]

instance Show (KFreq Float) where
  show :: KFreq Float -> String
show (Fr Float
x) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (Float -> Float
forall a. Num a => a -> a
abs Float
x) String
" "]
  show (KFr Float
x) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [Maybe Int -> Float -> ShowS
forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
forall a. Maybe a
Nothing (Float -> Float
forall a. Num a => a -> a
abs Float
x) String
"k "]  

type KFQ = KFreq Int

kFreqC :: KFQ -> String
kFreqC :: KFreq Int -> String
kFreqC (Fr Int
_)   = String
"Fr"
kFreqC KFreq Int
_ = String
"KFr"

kFreq1 :: KFQ -> Int
kFreq1 :: KFreq Int -> Int
kFreq1 (Fr Int
n) = Int
n
kFreq1 (KFr Int
n) = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
1000 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n

kFreqSet1 :: Int -> KFQ -> KFreq Float
kFreqSet1 :: Int -> KFreq Int -> KFreq Float
kFreqSet1 Int
n (Fr Int
_) = Float -> KFreq Float
forall a. a -> KFreq a
Fr (Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
kFreqSet1 Int
n KFreq Int
_ = Float -> KFreq Float
forall a. a -> KFreq a
KFr (Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
1000.0)

data FreqComp a b = FrCmp a b deriving FreqComp a b -> FreqComp a b -> Bool
(FreqComp a b -> FreqComp a b -> Bool)
-> (FreqComp a b -> FreqComp a b -> Bool) -> Eq (FreqComp a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => FreqComp a b -> FreqComp a b -> Bool
/= :: FreqComp a b -> FreqComp a b -> Bool
$c/= :: forall a b. (Eq a, Eq b) => FreqComp a b -> FreqComp a b -> Bool
== :: FreqComp a b -> FreqComp a b -> Bool
$c== :: forall a b. (Eq a, Eq b) => FreqComp a b -> FreqComp a b -> Bool
Eq

instance Show (FreqComp KFQ String) where 
  show :: FreqComp (KFreq Int) String -> String
show (FrCmp KFreq Int
x String
ys) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [KFreq Int -> String
forall a. Show a => a -> String
show KFreq Int
x, ShowS
forall a. Show a => a -> String
show String
ys, String
" "]

type FrCmpnd2 = FreqComp KFQ String

freqComp1 :: FreqComp a b -> a
freqComp1 :: FreqComp a b -> a
freqComp1 (FrCmp a
x b
_) = a
x

freqComp2 :: FreqComp a b -> b
freqComp2 :: FreqComp a b -> b
freqComp2 (FrCmp a
_ b
y) = b
y

freqCompSet1 :: a -> FreqComp a b -> FreqComp a b
freqCompSet1 :: a -> FreqComp a b -> FreqComp a b
freqCompSet1 a
x (FrCmp a
_ b
y) = a -> b -> FreqComp a b
forall a b. a -> b -> FreqComp a b
FrCmp a
x b
y

freqCompSet2 :: b -> FreqComp a b -> FreqComp a b
freqCompSet2 :: b -> FreqComp a b -> FreqComp a b
freqCompSet2 b
y (FrCmp a
x b
_) = a -> b -> FreqComp a b
forall a b. a -> b -> FreqComp a b
FrCmp a
x b
y

showFC :: FrCmpnd2 -> [String]
showFC :: FreqComp (KFreq Int) String -> [String]
showFC = String -> [String]
words (String -> [String])
-> (FreqComp (KFreq Int) String -> String)
-> FreqComp (KFreq Int) String
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FreqComp (KFreq Int) String -> String
forall a. Show a => a -> String
show 

data MCompand a b = MCN1 a | MCNM a [b] deriving MCompand a b -> MCompand a b -> Bool
(MCompand a b -> MCompand a b -> Bool)
-> (MCompand a b -> MCompand a b -> Bool) -> Eq (MCompand a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => MCompand a b -> MCompand a b -> Bool
/= :: MCompand a b -> MCompand a b -> Bool
$c/= :: forall a b. (Eq a, Eq b) => MCompand a b -> MCompand a b -> Bool
== :: MCompand a b -> MCompand a b -> Bool
$c== :: forall a b. (Eq a, Eq b) => MCompand a b -> MCompand a b -> Bool
Eq

instance Show (MCompand String FrCmpnd2) where 
  show :: MCompand String (FreqComp (KFreq Int) String) -> String
show (MCN1 String
xs) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
"mcompand ", ShowS
forall a. Show a => a -> String
show String
xs, String
" "]
  show (MCNM String
xs [FreqComp (KFreq Int) String]
ys) = [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
"mcompand ", ShowS
forall a. Show a => a -> String
show String
xs, String
" ", [String] -> String
forall a. Monoid a => [a] -> a
mconcat ([String] -> String)
-> ([FreqComp (KFreq Int) String] -> [String])
-> [FreqComp (KFreq Int) String]
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FreqComp (KFreq Int) String -> String)
-> [FreqComp (KFreq Int) String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map FreqComp (KFreq Int) String -> String
forall a. Show a => a -> String
show ([FreqComp (KFreq Int) String] -> String)
-> [FreqComp (KFreq Int) String] -> String
forall a b. (a -> b) -> a -> b
$ [FreqComp (KFreq Int) String]
ys]

type MComPand2 = MCompand String FrCmpnd2

mCompandC :: MCompand a b -> String
mCompandC :: MCompand a b -> String
mCompandC (MCN1 a
_) = String
"MCN1"
mCompandC (MCNM a
_ [b]
_) = String
"MCNM"

mCompand1 :: MCompand a b -> a
mCompand1 :: MCompand a b -> a
mCompand1 (MCN1 a
x) = a
x
mCompand1 (MCNM a
x [b]
_) = a
x

mCompand2 :: MCompand a b -> Maybe [b]
mCompand2 :: MCompand a b -> Maybe [b]
mCompand2 (MCNM a
_ [b]
ys) = [b] -> Maybe [b]
forall a. a -> Maybe a
Just [b]
ys
mCompand2 MCompand a b
_ = Maybe [b]
forall a. Maybe a
Nothing

mCompandSet1 :: a -> MCompand a b -> MCompand a b
mCompandSet1 :: a -> MCompand a b -> MCompand a b
mCompandSet1 a
x (MCN1 a
_) = a -> MCompand a b
forall a b. a -> MCompand a b
MCN1 a
x
mCompandSet1 a
x (MCNM a
_ [b]
ys) = a -> [b] -> MCompand a b
forall a b. a -> [b] -> MCompand a b
MCNM a
x [b]
ys

mCompandSet2 :: [b] -> MCompand a b -> MCompand a b
mCompandSet2 :: [b] -> MCompand a b -> MCompand a b
mCompandSet2 [b]
ys (MCN1 a
x) = a -> [b] -> MCompand a b
forall a b. a -> [b] -> MCompand a b
MCNM a
x [b]
ys
mCompandSet2 [b]
ys (MCNM a
x [b]
_) = a -> [b] -> MCompand a b
forall a b. a -> [b] -> MCompand a b
MCNM a
x [b]
ys