-- |
-- Module      :  Composition.Sound.Functional
-- Copyright   :  (c) OleksandrZhabenko 2020-2021
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  olexandr543@yahoo.com
--
-- Helps to create experimental music from a file (or its part) and a Ukrainian text. 
-- It can also generate a timbre for the notes. Uses SoX inside.

{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -threaded #-}

module Composition.Sound.Functional (
  -- * Use additional function as a parameter
  overSoXSynth2FDN
  , overSoXSynth2FDN_B
  -- ** Just simple function application
  -- *** With additional filtering
  -- * Use additional function and Ukrainian texts and generates melody
  , overSoXSynthGen2FDN
  , overSoXSynthGen2FDN_B
  -- * 1G generalized functions with dB volume overtones adjustments
  , overSoXSynth2FDN1G
  , overSoXSynth2FDN_B1G
  , overSoXSynth2FDN_S1G
  , overSoXSynth2FDN_Sf1G
  , overSoXSynth2FDN_Sf31G
  -- * 2G generalized functions with additional sound quality specifying
  , overSoXSynth2FDN2G
  , overSoXSynth2FDN_B2G
  , overSoXSynth2FDN_S2G
  , overSoXSynth2FDN_Sf2G
  , overSoXSynth2FDN_Sf32G
  -- ** 2G generalized functions for melody producing
  , overSoXSynthGen2FDN_SG2G
  , overSoXSynthGen2FDN_Sf3G2G
  -- * Generalized functions with several functional parameters
  , overSoXSynthGen2FDN_SG
  , overSoXSynthGen2FDN_Sf3G
  -- ** 1G generalized function with db volume overtones adjustments and several functional parameters
  , soundGenF31G
  -- * New functions for the version 0.36.0.0
  , overSoXSynthGen2FDN4G
  , overSoXSynthGen2FDN_SG4G
  , overSoXSynthGen2FDN_SG4GS
  -- * New generalized 5G functions that works with Intervals
  , overSoXSynth2FDN5G
  , overSoXSynth2FDN_B5G
  , overSoXSynth2FDN_S5G
  , overSoXSynth2FDN_Sf35G
  -- * New generalized 6G functions that works with Strengths
  , overSoXSynth2FDN6G
  , overSoXSynth2FDN6GS
  , overSoXSynth2FDN_B6G
  , overSoXSynth2FDN_B6GS
  , overSoXSynth2FDN_S6G
  , overSoXSynth2FDN_S6GS
  , overSoXSynth2FDN_Sf36G
  , overSoXSynth2FDN_Sf36GS
  , overSoXSynthGen2FDN_SG6G
  , overSoXSynthGen2FDN_SG6GS
  , overSoXSynthGen2FDN_SG6GSu
  -- * Auxiliar functions
  , help11
  , help12
  , help13
) where

import Numeric
import Data.List (nubBy)
import Data.Maybe (isNothing,fromJust,fromMaybe,maybe)
import GHC.Arr
import qualified Data.Foldable as F
import System.Process
import EndOfExe
import System.Directory
import Melodics.ByteString.Ukrainian.Arr (convertToProperUkrainianS)
import Composition.Sound.IntermediateF
import Composition.Sound.Functional.Basics
import Composition.Sound.Functional.Params
import Composition.Sound.DIS5G6G (intervalsFromStringG,str2Durations,str2Vol1,str2Volume)

-- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Float -> [(Float, Float)]@ with
-- somewhat sophisticated mechanism to normalize the resulting list elements @(Float, Float)@. The last one is an experimental feature, so
-- it is your responsibility to provide a function so that it does not lead to clipping. In such a case, the result of application of the
-- 'convertToProperUkrainianS' to the 'String' parameter must not be []. 'Int' argument is an index of the element to be taken from 
-- the 'intervalsFromString' applied to the 'String' argument. To obtain compatible with versions prior to 0.20.0.0 behaviour, use for the 'Int' 0.
--
-- Be aware that the result can be rather unpredictable (the program can even obtain segmentation fault) for not very suitable function.
-- But for a lot of functions this works well.
-- 
-- It is recommended to fully simplify the computation for \"f\" function before using it in the 'overSoXSynth2FDN'.
overSoXSynth2FDN :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs = (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN1G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs ((\[Float]
rs -> (Int, Int) -> [Float] -> Array Int Float
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0, Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Float]
rs) ([Float] -> Array Int Float)
-> (Float -> [Float]) -> Float -> Array Int Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Float -> [Float]
forall a. Int -> a -> [a]
replicate Int
l (Float -> Array Int Float) -> Float -> Array Int Float
forall a b. (a -> b) -> a -> b
$ Float
0.0)
     where !l :: Int
l = OvertonesO -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (OvertonesO -> Int) -> (Float -> OvertonesO) -> Float -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
f (Float -> OvertonesO) -> (Float -> Float) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Float
closestNote (Float -> Int) -> Float -> Int
forall a b. (a -> b) -> a -> b
$ if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0
{-# INLINE overSoXSynth2FDN #-}

-- | 'Array' 'Int' of 'Float' is a vector of dB volume adjustments for the corresponding harmonices (overtones).
overSoXSynth2FDN1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN1G :: (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN1G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB = (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN2G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB []
{-# INLINE overSoXSynth2FDN1G #-}
 
-- | Similar to 'overSoXSynth2FDN1G', but additionally allows to specify by the second 'String' argument a quality changes to the generated files
-- (please, see 'soxBasicParams'). Since version 0.36.0.0 the function supports generation of the pauses.
overSoXSynth2FDN2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> String -> IO ()
overSoXSynth2FDN2G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN2G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB String
ys
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
zs = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0 = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
zs
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt (String -> Array Int Int
intervalsFromString String
zs) (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help11 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0

-- | Similar to 'overSoXSynth2FDN2G', but additionally allows to specify by the 'Intervals' argument to specify your own intervals. For more information, 
-- please, refer to 'intervalsFromStringG'.
overSoXSynth2FDN5G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> Array Int Float -> String -> IO ()
overSoXSynth2FDN5G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN5G Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 Array Int Float
vdB String
ys
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0 = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help11 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0

help11 :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Array Int Float -> String -> Int -> Maybe Float -> Float -> IO ()
help11 :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help11 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0 = do
  let g0 :: Float -> OvertonesO
g0    = ((Float, Float) -> (Float, Float) -> Bool)
-> OvertonesO -> OvertonesO
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\(!Float
x1,Float
_) (!Float
x2,Float
_) -> Float
x1 Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
== Float
x2) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Float, Float) -> (Float, Float)) -> OvertonesO -> OvertonesO
forall a b. (a -> b) -> [a] -> [b]
map (\(Float
noteX, !Float
amplX) ->
           if Float
noteX Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Float
0.0 then (Float
2 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
note0, Float -> Float
forall a. Num a => a -> a
abs (Float
amplX Float -> Float -> Float
forall a. Num a => a -> a -> a
- (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Float) -> (Float -> Integer) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
amplX))) else (Float -> Float
closestNote Float
noteX,
             Float -> Float
forall a. Num a => a -> a
abs (Float
amplX Float -> Float -> Float
forall a. Num a => a -> a -> a
- (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Float) -> (Float -> Integer) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
amplX)))) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
f
      g :: Float -> OvertonesO
g Float
k   = ((Float, Float) -> Bool) -> OvertonesO -> OvertonesO
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\(!Float
w,!Float
z) -> Float
w Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
107 Bool -> Bool -> Bool
&& Float -> Float
forall a. Num a => a -> a
abs Float
z Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.001) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                   ((Integer, (Float, Float)) -> (Float, Float))
-> [(Integer, (Float, Float))] -> OvertonesO
forall a b. (a -> b) -> [a] -> [b]
map (\(Integer
i, (Float
_,!Float
z0)) -> (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1) Float -> Float -> Float
forall a. Num a => a -> a -> a
* ((Float, Float) -> Float
forall a b. (a, b) -> a
fst ((Float, Float) -> Float)
-> (Float -> (Float, Float)) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OvertonesO -> (Float, Float)
forall a. [a] -> a
head (OvertonesO -> (Float, Float))
-> (Float -> OvertonesO) -> Float -> (Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
g0 (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
k), Float
z0)) ([(Integer, (Float, Float))] -> OvertonesO)
-> (Float -> [(Integer, (Float, Float))]) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> OvertonesO -> [(Integer, (Float, Float))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..] (OvertonesO -> [(Integer, (Float, Float))])
-> (Float -> OvertonesO) -> Float -> [(Integer, (Float, Float))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
g0 (Float -> OvertonesO) -> Float -> OvertonesO
forall a b. (a -> b) -> a -> b
$ Float
k 
      v0 :: OvertonesO
v0    = Float -> OvertonesO
g Float
note0
      v1 :: OvertonesO
v1    = OvertonesO -> (Float -> OvertonesO) -> Maybe Float -> OvertonesO
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Float -> OvertonesO
g Maybe Float
note1
      ts :: String
ts = Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4) (Float -> Float
forall a. Num a => a -> a
abs Float
y) String
"" 
      overSoXSynthHelp :: OvertonesO -> IO ()
overSoXSynthHelp = ((Integer, (Float, Float)) -> IO (ExitCode, String, String))
-> [(Integer, (Float, Float))] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Integer
i, (Float
noteN, !Float
amplN)) -> String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox"))
          ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"test0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
2) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav", String
"synth", String
ts,String
"sine", 
              Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
noteN String
"", String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
amplN String
"" else String
"0"]) String
"") ([(Integer, (Float, Float))] -> IO ())
-> (OvertonesO -> [(Integer, (Float, Float))])
-> OvertonesO
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> OvertonesO -> [(Integer, (Float, Float))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..]
      overSoXSynthHelp2 :: [(a, a)] -> Array i Float -> IO ()
overSoXSynthHelp2 [(a, a)]
vec Array i Float
vdB = ((Int, (a, a)) -> IO (ExitCode, String, String))
-> [(Int, (a, a))] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
i, (a
noteN, !a
amplN)) -> String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox"))
          ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) ([String] -> Float -> [String]
adjust_dbVol [String
"-r22050", String
"-n", String
"test1" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav", String
"synth", String
ts,String
"sine", 
            Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing a
noteN String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing a
amplN String
"" else String
"0"] (Array i Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array i Float
vdB Int
i))) String
"") ([(Int, (a, a))] -> IO ())
-> ([(a, a)] -> [(Int, (a, a))]) -> [(a, a)] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [(a, a)] -> [(Int, (a, a))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([(a, a)] -> IO ()) -> [(a, a)] -> IO ()
forall a b. (a -> b) -> a -> b
$ [(a, a)]
vec
  (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testA.wav", String
"synth", String
ts, 
       String
"sine", Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
note0 String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
  if Maybe Float -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Float
note1 then OvertonesO -> IO ()
overSoXSynthHelp OvertonesO
v0
  else do 
    (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testB.wav", String
"synth", String
ts, 
       String
"sine",  Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing (Maybe Float -> Float
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Float
note1) String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
    OvertonesO -> IO ()
overSoXSynthHelp OvertonesO
v0
    OvertonesO -> Array Int Float -> IO ()
forall a a i.
(RealFloat a, RealFloat a) =>
[(a, a)] -> Array i Float -> IO ()
overSoXSynthHelp2 OvertonesO
v1 Array Int Float
vdB
  if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then IO ()
mixTest else String -> IO ()
mixTest2G String
ys
{-# INLINE help11 #-}  

-- | Generalized variant of the 'overSoXSynth2FDN5G' with afterwards 'apply6Gf' usage. 
overSoXSynth2FDN6G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> Array Int Float -> String -> Float -> IO ()
overSoXSynth2FDN6G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN6G Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 Array Int Float
vdB String
ys Float
vol
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0     = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help11 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0
    if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Float -> String -> IO ()
apply6Gf Float
vol (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") else String -> IO ()
putStr String
""

-- | A variant of the 'overSoXSynth2FDN6G' where volume adjustment is obtained from a Ukrainian text.
overSoXSynth2FDN6GS :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> String -> Array Int Float -> String -> String -> IO ()
overSoXSynth2FDN6GS :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> String
-> Array Int Float
-> String
-> String
-> IO ()
overSoXSynth2FDN6GS Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 String
xs Array Int Float
vdB String
ys String
xxs 
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xxs = String -> IO ()
putStrLn String
"Composition.Sound.Functional.overSoXSynth2FDN6GS: You provided no information to obtain volume adjustment! "
 | Bool
otherwise = (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN6G Float -> OvertonesO
f (Float
x, Float
y) Int
j (Array Int Int -> String -> Array Int Int
intervalsFromStringG Array Int Int
v5 String
xs) Array Int Float
vdB String
ys (String -> Float
str2Vol1 String
xxs)
{-# INLINE overSoXSynth2FDN6GS #-} 
 
-- | Uses additional 'Int' parameters. The first one is a number of enka (see 'nkyT'). The second one defines, to which n-th elements set
-- (see 'nkyT') belongs the obtained higher notes in the intervals. To obtain reasonable results, please, use for the first one 2, 3, 4, 6, 9, or 12.
-- The first 'String' parameter is used to produce durations of the notes. The second one is used to define intervals. A 'Float' parameter is a
-- basic sound duration, it defines tempo of the melody in general.
overSoXSynthGen2FDN :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> IO ()
overSoXSynthGen2FDN :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> IO ()
overSoXSynthGen2FDN String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN
{-# INLINE overSoXSynthGen2FDN #-}

-- | Generalized variant of the 'overSoXSynthGen2FDN' with your own specified 'Durations' for the sounds and pauses. 
-- Instead of using a Ukrainian text to specify a durations for the sounds (and a rhythm 
-- respectively) you provide your own rhythm as 'Durations'. Positive values correspond to durations of the sounds generated 
-- and negative values -- to durations of the pauses respectively. 
overSoXSynthGen2FDN4G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> IO ()
overSoXSynthGen2FDN4G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> IO ()
overSoXSynthGen2FDN4G String
file Int
m Int
ku Float -> OvertonesO
f Array Int Float
v2 String
wws = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG4G String
file Int
m Int
ku Float -> OvertonesO
f Array Int Float
v2 String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN
{-# INLINE overSoXSynthGen2FDN4G #-}

-- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Float -> [(Float, Float)]@ with
-- somewhat sophisticated mechanism to normalize the resulting list elements @(Float, Float)@. The last one is experimental feature, so
-- it is your responsibility to provide a function so that it does not lead to clipping. In such a case, the result of application of the
-- 'convertToProperUkrainianS' to the 'String' parameter must not be []. The function also tries to perform filtering to avoid possible beating.
-- The third 'Float' parameter in the tuple is used as a limit for frequencies difference in Hz to be filtered out from the resulting sound. It is
-- considered to be from the range @[0.1..10.0]@. An 'Int' parameter is used to define the needed interval. To obtain compatible with versions prior
-- to 0.20.0.0 behaviour, use for the 'Int' 0.
--
-- Be aware that the result can be rather unpredictable (the program can even obtain segmentation fault) for not very suitable function.
-- But for a lot of functions this works well.
-- 
-- It is recommended to fully simplify the computation for \"f\" function before using it in the 'overSoXSynth2FDN_B'.
overSoXSynth2FDN_B :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN_B :: (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN_B Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j String
zs = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> IO ()
overSoXSynth2FDN_B1G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j String
zs ((\[Float]
rs -> (Int, Int) -> [Float] -> Array Int Float
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Float]
rs) ([Float] -> Array Int Float)
-> (Float -> [Float]) -> Float -> Array Int Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Float -> [Float]
forall a. Int -> a -> [a]
replicate Int
l (Float -> Array Int Float) -> Float -> Array Int Float
forall a b. (a -> b) -> a -> b
$ Float
0.0)
  where !l :: Int
l = OvertonesO -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (OvertonesO -> Int) -> (Float -> OvertonesO) -> Float -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
f (Float -> OvertonesO) -> (Float -> Float) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Float
closestNote (Float -> Int) -> Float -> Int
forall a b. (a -> b) -> a -> b
$ if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0
{-# INLINE overSoXSynth2FDN_B #-}  

-- | 'Array' 'Int' of 'Float' is a vector of dB volume adjustments for the corresponding harmonices (overtones).
overSoXSynth2FDN_B1G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_B1G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> IO ()
overSoXSynth2FDN_B1G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j String
zs Array Int Float
vdB = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_B2G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j String
zs Array Int Float
vdB []
{-# INLINE overSoXSynth2FDN_B1G #-}

-- | Generalized version of the 'overSoXSynth2FDN_B1G' with a possibility to specify sound quality parameters using additional second 'String'
-- argument. For more information, please, refer to 'soxBasicParams'. 
overSoXSynth2FDN_B2G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_B2G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_B2G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j String
zs Array Int Float
vdB String
ys
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
zs = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let l0 :: Int
l0    = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
zs
        note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt (String -> Array Int Int
intervalsFromString String
zs) (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help12 Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0

-- | Generalized version of the 'overSoXSynth2FDN_B2G' with a possibility to specify your own 'Intervals'. For more information, please, 
-- refer to 'intervalsFromStringG'.
overSoXSynth2FDN_B5G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_B5G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_B5G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Int
v5 Array Int Float
vdB String
ys
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let l0 :: Int
l0    = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help12 Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0
    
help12 :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Array Int Float -> String -> Int -> Maybe Float -> Float -> IO ()
help12 :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help12 Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0 = do
    let limA0 :: Float
limA0 = Float -> Float
forall a. Num a => a -> a
abs ((Float
limB Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
10) Float -> Float -> Float
forall a. Num a => a -> a -> a
- (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Float) -> (Float -> Integer) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ (Float
limB Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
10))) Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
10
        limA :: Float
limA  = if Float
limA0 Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
< Float
0.1 then Float
0.1 else Float
limA0
        g0 :: Float -> OvertonesO
g0    = ((Float, Float) -> (Float, Float) -> Bool)
-> OvertonesO -> OvertonesO
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\(!Float
x1,Float
_) (!Float
x2,Float
_) -> Float -> Float
forall a. Num a => a -> a
abs (Float
x1 Float -> Float -> Float
forall a. Num a => a -> a -> a
- Float
x2) Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
< Float
limA) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Float, Float) -> (Float, Float)) -> OvertonesO -> OvertonesO
forall a b. (a -> b) -> [a] -> [b]
map (\(Float
noteX, !Float
amplX) ->
           if Float
noteX Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Float
0.0 then (Float
2 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
note0, Float -> Float
forall a. Num a => a -> a
abs (Float
amplX Float -> Float -> Float
forall a. Num a => a -> a -> a
- (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Float) -> (Float -> Integer) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
amplX))) else (Float -> Float
closestNote Float
noteX,
             Float -> Float
forall a. Num a => a -> a
abs (Float
amplX Float -> Float -> Float
forall a. Num a => a -> a -> a
- (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Float) -> (Float -> Integer) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
amplX)))) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
f
        v0 :: OvertonesO
v0    = ((Float, Float) -> Bool) -> OvertonesO -> OvertonesO
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\(!Float
w,!Float
z) -> Float
w Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
107 Bool -> Bool -> Bool
&& Float -> Float
forall a. Num a => a -> a
abs Float
z Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.001) (OvertonesO -> OvertonesO)
-> (Float -> OvertonesO) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                   ((Integer, (Float, Float)) -> (Float, Float))
-> [(Integer, (Float, Float))] -> OvertonesO
forall a b. (a -> b) -> [a] -> [b]
map (\(Integer
i, (Float
_,!Float
z0)) -> (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1) Float -> Float -> Float
forall a. Num a => a -> a -> a
* ((Float, Float) -> Float
forall a b. (a, b) -> a
fst ((Float, Float) -> Float)
-> (Float -> (Float, Float)) -> Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OvertonesO -> (Float, Float)
forall a. [a] -> a
head (OvertonesO -> (Float, Float))
-> (Float -> OvertonesO) -> Float -> (Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
g0 (Float -> Float) -> Float -> Float
forall a b. (a -> b) -> a -> b
$ Float
note0), Float
z0)) ([(Integer, (Float, Float))] -> OvertonesO)
-> (Float -> [(Integer, (Float, Float))]) -> Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> OvertonesO -> [(Integer, (Float, Float))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..] (OvertonesO -> [(Integer, (Float, Float))])
-> (Float -> OvertonesO) -> Float -> [(Integer, (Float, Float))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
g0 (Float -> OvertonesO) -> Float -> OvertonesO
forall a b. (a -> b) -> a -> b
$ Float
note0 
        v1 :: OvertonesO
v1    = if Maybe Float -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Float
note1 then []
                else ((Float, Float) -> Bool) -> OvertonesO -> OvertonesO
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\(!Float
w,!Float
z) -> Float
w Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
107 Bool -> Bool -> Bool
&& Float -> Float
forall a. Num a => a -> a
abs Float
z Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.001) (OvertonesO -> OvertonesO)
-> (Maybe Float -> OvertonesO) -> Maybe Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                   ((Integer, (Float, Float)) -> (Float, Float))
-> [(Integer, (Float, Float))] -> OvertonesO
forall a b. (a -> b) -> [a] -> [b]
map (\(Integer
i, (Float
_,!Float
z0)) -> (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1) Float -> Float -> Float
forall a. Num a => a -> a -> a
* ((Float, Float) -> Float
forall a b. (a, b) -> a
fst ((Float, Float) -> Float)
-> (Maybe Float -> (Float, Float)) -> Maybe Float -> Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OvertonesO -> (Float, Float)
forall a. [a] -> a
head (OvertonesO -> (Float, Float))
-> (Maybe Float -> OvertonesO) -> Maybe Float -> (Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OvertonesO
g0 (Float -> OvertonesO)
-> (Maybe Float -> Float) -> Maybe Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Float -> Float
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Float -> Float) -> Maybe Float -> Float
forall a b. (a -> b) -> a -> b
$ Maybe Float
note1), Float
z0)) ([(Integer, (Float, Float))] -> OvertonesO)
-> (Maybe Float -> [(Integer, (Float, Float))])
-> Maybe Float
-> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> OvertonesO -> [(Integer, (Float, Float))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..] (OvertonesO -> [(Integer, (Float, Float))])
-> (Maybe Float -> OvertonesO)
-> Maybe Float
-> [(Integer, (Float, Float))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                     Float -> OvertonesO
g0 (Float -> OvertonesO)
-> (Maybe Float -> Float) -> Maybe Float -> OvertonesO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Float -> Float
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Float -> OvertonesO) -> Maybe Float -> OvertonesO
forall a b. (a -> b) -> a -> b
$ Maybe Float
note1
        ts :: String
ts = Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4) (Float -> Float
forall a. Num a => a -> a
abs Float
y) String
"" 
        overSoXSynthHelp :: OvertonesO -> IO ()
overSoXSynthHelp = ((Integer, (Float, Float)) -> IO (ExitCode, String, String))
-> [(Integer, (Float, Float))] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Integer
i, (Float
noteN, !Float
amplN)) -> String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox"))
            ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"test0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
2) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav", String
"synth", String
ts,String
"sine", 
              Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
noteN String
"", String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
amplN String
"" else String
"0"]) String
"") ([(Integer, (Float, Float))] -> IO ())
-> (OvertonesO -> [(Integer, (Float, Float))])
-> OvertonesO
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> OvertonesO -> [(Integer, (Float, Float))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..]
        overSoXSynthHelp2 :: [(a, a)] -> Array i Float -> IO ()
overSoXSynthHelp2 [(a, a)]
vec Array i Float
vdB = ((Int, (a, a)) -> IO (ExitCode, String, String))
-> [(Int, (a, a))] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
i, (a
noteN, !a
amplN)) -> String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox"))
            ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) ((if Array i Float -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array i Float
vdB then [String] -> [String]
forall a. a -> a
id else (\[String]
wwws -> [String] -> Float -> [String]
adjust_dbVol [String]
wwws (Array i Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array i Float
vdB Int
i))) 
              [String
"-r22050", String
"-n", String
"test1" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav", String
"synth", String
ts,String
"sine", Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing a
noteN String
"", String
"vol", 
                if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing a
amplN String
"" else String
"0"])) String
"") ([(Int, (a, a))] -> IO ())
-> ([(a, a)] -> [(Int, (a, a))]) -> [(a, a)] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [(a, a)] -> [(Int, (a, a))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([(a, a)] -> IO ()) -> [(a, a)] -> IO ()
forall a b. (a -> b) -> a -> b
$ [(a, a)]
vec
    (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testA.wav", String
"synth", String
ts,String
"sine",
       Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
note0 String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
    if Maybe Float -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Float
note1 then OvertonesO -> IO ()
overSoXSynthHelp OvertonesO
v0
    else do 
      (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testB.wav", String
"synth", String
ts,String
"sine",
         Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing (Maybe Float -> Float
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Float
note1) String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
      OvertonesO -> IO ()
overSoXSynthHelp OvertonesO
v0
      OvertonesO -> Array Int Float -> IO ()
forall a a i.
(RealFloat a, RealFloat a) =>
[(a, a)] -> Array i Float -> IO ()
overSoXSynthHelp2 OvertonesO
v1 Array Int Float
vdB
    if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then IO ()
mixTest else String -> IO ()
mixTest2G String
ys    
{-# INLINE help12 #-}

-- | Generalized variant of the 'overSoXSynth2FDN_B5G' with afterwards 'apply6G' usage. 
overSoXSynth2FDN_B6G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> Array Int Float -> String -> Float -> IO ()
overSoXSynth2FDN_B6G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_B6G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Int
v5 Array Int Float
vdB String
ys Float
vol 
  | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
  | Bool
otherwise = do
    let l0 :: Int
l0    = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help12 Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0
    if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Float -> String -> IO ()
apply6Gf Float
vol (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") else String -> IO ()
putStr String
"" -- The line which differs for this function and the 'overSoXSynth2FDN_B5G'.

-- | A variant of the 'overSoXSynth2FDN_B6G' where volume adjustment is obtained from a Ukrainian text.
overSoXSynth2FDN_B6GS :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> String -> Array Int Float -> String -> String -> IO ()
overSoXSynth2FDN_B6GS :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> String
-> Array Int Float
-> String
-> String
-> IO ()
overSoXSynth2FDN_B6GS Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j Array Int Int
v5 String
xs Array Int Float
vdB String
ys String
xxs
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xxs = String -> IO ()
putStrLn String
"Composition.Sound.Functional.overSoXSynth2FDN_B6GS: You provided no information to obtain volume adjustment! "
 | Bool
otherwise = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_B6G Float -> OvertonesO
f (Float
x, Float
y, Float
limB) Int
j (Array Int Int -> String -> Array Int Int
intervalsFromStringG Array Int Int
v5 String
xs) Array Int Float
vdB String
ys (String -> Float
str2Vol1 String
xxs)
{-# INLINE overSoXSynth2FDN_B6GS #-} 

-- | Uses additional 'Int' parameters. The first one is a number of enka (see 'nkyT'). The second one defines, to which n-th elements set
-- (see 'nkyT') belongs the obtained higher notes in the intervals. To obtain reasonable results, please, use for the first one 2, 3, 4, 6, 9, or 12.
-- The first 'String' parameter is used to produce durations of the notes. The second one is used to define intervals. The first 'Float' parameter is a
-- basic sound duration, it defines tempo of the melody in general. The second one is a limit for frequencies difference in Hz to be filtered out from the
-- resulting sound. It is considered to be from the range @[0.1..10.0]@.
overSoXSynthGen2FDN_B :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String -> IO ()
overSoXSynthGen2FDN_B :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> Float
-> String
-> String
-> IO ()
overSoXSynthGen2FDN_B String
file Int
m Int
ku Float -> OvertonesO
f Float
y Float
limB String
zs String
wws = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_Sf3G String
file Int
m Int
ku Float -> OvertonesO
f Float
y Float
limB String
zs String
wws (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> IO ()
overSoXSynth2FDN_B
{-# INLINE overSoXSynthGen2FDN_B #-}

-- | Similar to 'overSoXSynth2FDN'  with the additional volume adjustment in dB for overtones given by 'Array' 'Int' of 'Float', but it does not make any normalizing transformations. To be used properly, it is needed
-- that every second element in the tuple in the list argument must be in the range [-1.0..1.0] and every first element must be in between
-- 16.351597831287414 and 7902.132820097988 (Hz). An 'Int' parameter is used to define an interval. To obtain compatible with versions prior to
-- 0.20.0.0 behaviour, use for the 'Int' 0.
--
-- Be aware that the result can be rather unpredictable (the program can even obtain segmentation fault) for not very suitable function.
-- But for a lot of functions this works well.
-- 
-- It is recommended to fully simplify the computation for \"f\" function before using it in the 'overSoXSynth2FDN_S'.
overSoXSynth2FDN_S1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_S1G :: (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_S1G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB = (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_S2G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB []
{-# INLINE overSoXSynth2FDN_S1G #-}
 
-- | Generalized version of the 'overSoXSynth2FDN_S1G' with a possibility to specify sound quality parameters using the second 'String' argument.
-- For more information, please, refer to 'soxBasicParams'.
overSoXSynth2FDN_S2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_S2G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_S2G Float -> OvertonesO
f (Float
x, Float
y) Int
j String
zs Array Int Float
vdB String
ys
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
zs = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0    = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
zs
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt (String -> Array Int Int
intervalsFromString String
zs) (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help13 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0
    
help13 :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Array Int Float -> String -> Int -> Maybe Float -> Float -> IO ()
help13 :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help13 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0 = do
    let v0 :: OvertonesO
v0    = Float -> OvertonesO
f Float
note0
        v1 :: OvertonesO
v1    = OvertonesO -> (Float -> OvertonesO) -> Maybe Float -> OvertonesO
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Float -> OvertonesO
f Maybe Float
note1
        ts :: String
ts = Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4) (Float -> Float
forall a. Num a => a -> a
abs Float
y) String
""
    (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testA.wav", String
"synth", String
ts,String
"sine",
       Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing Float
note0 String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
    if Maybe Float -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Float
note1 then OvertonesO -> Int -> String -> Array Int Float -> String -> IO ()
partialTest_k2G OvertonesO
v0 Int
0 String
ts Array Int Float
vdB String
ys
    else do 
      (ExitCode, String, String)
_ <- String -> [String] -> String -> IO (ExitCode, String, String)
readProcessWithExitCode (Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (String -> Maybe String
showE String
"sox")) ((if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then [String] -> [String]
forall a. a -> a
id else String -> [String] -> [String]
soxBasicParams String
ys) [String
"-r22050", String
"-n", String
"testB.wav", String
"synth", String
ts,String
"sine",
         Maybe Int -> Float -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat Maybe Int
forall a. Maybe a
Nothing (Maybe Float -> Float
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Float
note1) String
"",String
"vol", if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then String
"1.0" else String
"0"]) String
""
      OvertonesO -> Int -> String -> Array Int Float -> String -> IO ()
partialTest_k2G OvertonesO
v0 Int
0 String
ts Array Int Float
vdB String
ys
      OvertonesO -> Int -> String -> Array Int Float -> String -> IO ()
partialTest_k2G OvertonesO
v1 Int
1 String
ts Array Int Float
vdB String
ys
    if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then IO ()
mixTest else String -> IO ()
mixTest2G String
ys   
        
-- | Generalized version of the 'overSoXSynth2FDN_S2G' where you specify your own 'Intervals'. For more information, please, refer 
-- to 'intervalsFromStringG'.
overSoXSynth2FDN_S5G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_S5G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_S5G Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 Array Int Float
vdB String
ys
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0    = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help13 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0   

-- | Generalized variant of the 'overSoXSynth2FDN_S5G' with afterwards 'apply6G' usage. Arguments for the latter is the three last function arguments.
overSoXSynth2FDN_S6G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> Array Int Float -> String -> Float -> IO ()
overSoXSynth2FDN_S6G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_S6G Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 Array Int Float
vdB String
ys Float
vol
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let note0 :: Float
note0 = Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
        l0 :: Int
l0    = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
        note1 :: Maybe Float
note1 = Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) Float
note0
    (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Float
-> String
-> Int
-> Maybe Float
-> Float
-> IO ()
help13 Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Float
vdB String
ys Int
l0 Maybe Float
note1 Float
note0
    if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Float -> String -> IO ()
apply6Gf Float
vol (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") else String -> IO ()
putStr String
""
  
-- | A variant of the 'overSoXSynth2FDN_S6G' where volume adjustment is obtained from a Ukrainian text.
overSoXSynth2FDN_S6GS :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> String -> Array Int Float -> String -> String -> IO ()
overSoXSynth2FDN_S6GS :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> String
-> Array Int Float
-> String
-> String
-> IO ()
overSoXSynth2FDN_S6GS Float -> OvertonesO
f (Float
x, Float
y) Int
j Array Int Int
v5 String
xs Array Int Float
vdB String
ys String
xxs
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xxs = String -> IO ()
putStrLn String
"Composition.Sound.Functional.overSoXSynth2FDN_S6GS: You provided no information to obtain volume adjustment! "
 | Bool
otherwise = (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_S6G Float -> OvertonesO
f (Float
x, Float
y) Int
j (Array Int Int -> String -> Array Int Int
intervalsFromStringG Array Int Int
v5 String
xs) Array Int Float
vdB String
ys (String -> Float
str2Vol1 String
xxs)
{-# INLINE overSoXSynth2FDN_S6GS #-}

-- | Similar to 'overSoXSynthGen2FDN', but instead of 'overSoXSynth2FDN' uses 'overSoXSynth2FDN_S' function. Note that the first 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_SG :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO ()
overSoXSynthGen2FDN_SG :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h = do
  Int
n <- String -> IO Int
duration1000 String
file
  String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG4G String
file Int
m Int
ku Float -> OvertonesO
f (Int -> String -> Float -> Array Int Float
str2DurationsDef Int
n String
zs Float
y) String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h
{-# INLINE overSoXSynthGen2FDN_SG #-}  

-- | Generalized version of the 'overSoXSynthGen2FDN_SG' where instead of using a Ukrainian text to specify a durations for the sounds (and a rhythm 
-- respectively) you provide your own rhythm as 'Durations'. Positive values correspond to durations of the sounds generated 
-- and negative values -- to durations of the pauses respectively. Please, use a function @h :: ((Float -> OvertonesO) -> (Float, Float) -> 
-- Int -> String -> IO ())@ such that it can create for the given values accorgingly sounds and pauses. Otherwise, please, check whether at 
-- least it can deal with such arguments without errors. Note that 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_SG4G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO ()
overSoXSynthGen2FDN_SG4G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG4G String
file Int
m Int
ku Float -> OvertonesO
f Array Int Float
v2 String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h = do
  Int
n <- String -> IO Int
duration1000 String
file
  [Int]
vecA <- String -> Int -> IO [Int]
freqsFromFile String
file Int
n
  let vecB :: [Float]
vecB = Int -> Int -> [Float] -> [Float]
liftInEnkuV Int
m Int
ku ([Float] -> [Float]) -> ([Int] -> [Float]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Float) -> [Int] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Float]) -> ([Int] -> [Int]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
11440::Int)) ([Int] -> [Float]) -> [Int] -> [Float]
forall a b. (a -> b) -> a -> b
$ [Int]
vecA
      zeroN :: Int
zeroN = [Float] -> Int
forall a. [a] -> Int
numVZeroesPre [Float]
vecB
      !l :: Int
l = Array Int Float -> Int
forall i e. Array i e -> Int
numElements Array Int Float
v2 in ((Int, Float) -> IO ()) -> [(Int, Float)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
j, Float
x) -> do
        (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h Float -> OvertonesO
f (Float
x, (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v2 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l))) Int
j String
wws
        String -> String -> IO ()
renameFile String
"result.wav" (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav") ([(Int, Float)] -> IO ())
-> ([Float] -> [(Int, Float)]) -> [Float] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [Float] -> [(Int, Float)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Float] -> IO ()) -> [Float] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Float]
vecB
  IO ()
endFromResult  

-- | A variant of the 'overSoXSynthGen2FDN_SG4G' where instead of providing your own durations as 'Durations' you use a Ukrainian text and 
-- a function treats each symbol in it as a duration parameter with its sign. Positive values correspond to durations of the sounds generated 
-- and negative values -- to durations of the pauses respectively. Please, use a function @h :: ((Float -> OvertonesO) -> (Float, Float) -> 
-- Int -> String -> IO ())@ such that it can create for the given values accorgingly sounds and pauses. Otherwise, please, check whether at 
-- least it can deal with such arguments without errors.
overSoXSynthGen2FDN_SG4GS :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO ()
overSoXSynthGen2FDN_SG4GS :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG4GS String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_SG4G String
file Int
m Int
ku Float -> OvertonesO
f (String -> Float -> Array Int Float
str2Durations String
zs Float
y)
{-# INLINE overSoXSynthGen2FDN_SG4GS #-}

-- | 6G generalized variant of the 'overSoXSynthGen2FDN_SG4G' with volume adjustments given by 'Strengths'. Note that 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_SG6G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Strengths -> Float -> IO ()
overSoXSynthGen2FDN_SG6G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> Array Int Float
-> Float
-> IO ()
overSoXSynthGen2FDN_SG6G String
file Int
m Int
ku Float -> OvertonesO
f Array Int Float
v2 String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h Array Int Float
v6 Float
limV
 | Array Int Float -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Float
v6 = String -> IO ()
putStrLn String
"Composition.Sound.Functional.overSoXSynthGen2FDN_SG6G: You did not provide a volume adjustments array! "
 | Bool
otherwise = do
    Int
n <- String -> IO Int
duration1000 String
file
    [Int]
vecA <- String -> Int -> IO [Int]
freqsFromFile String
file Int
n
    let vecB :: [Float]
vecB = Int -> Int -> [Float] -> [Float]
liftInEnkuV Int
m Int
ku ([Float] -> [Float]) -> ([Int] -> [Float]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Float) -> [Int] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Float]) -> ([Int] -> [Int]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
11440::Int)) ([Int] -> [Float]) -> [Int] -> [Float]
forall a b. (a -> b) -> a -> b
$ [Int]
vecA
        zeroN :: Int
zeroN = [Float] -> Int
forall a. [a] -> Int
numVZeroesPre [Float]
vecB
        !l2 :: Int
l2 = Array Int Float -> Int
forall i e. Array i e -> Int
numElements Array Int Float
v2
        !l6 :: Int
l6 = Array Int Float -> Int
forall i e. Array i e -> Int
numElements Array Int Float
v6 in ((Int, Float) -> IO ()) -> [(Int, Float)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
j, Float
x) -> do
          (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h Float -> OvertonesO
f (Float
x, (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v2 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l2))) Int
j String
wws
          String -> String -> IO ()
renameFile String
"result.wav" (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav"
          String -> Float -> Float -> IO ()
apply6GSilentFile (String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav") Float
limV (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v6 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l6))) ([(Int, Float)] -> IO ())
-> ([Float] -> [(Int, Float)]) -> [Float] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            [Int] -> [Float] -> [(Int, Float)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Float] -> IO ()) -> [Float] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Float]
vecB
    IO ()
endFromResult  

-- | A variant of the 'overSoXSynthGen2FDN_SG6G' where 'Strengths' are obtained from a Ukrainian text and 'str2Volume'.
overSoXSynthGen2FDN_SG6GS :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> String -> Float -> IO ()
overSoXSynthGen2FDN_SG6GS :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> String
-> Float
-> IO ()
overSoXSynthGen2FDN_SG6GS String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h String
zzs = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> Array Int Float
-> Float
-> IO ()
overSoXSynthGen2FDN_SG6G String
file Int
m Int
ku Float -> OvertonesO
f (String -> Float -> Array Int Float
str2Durations String
zs Float
y) String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h (String -> Array Int Float
str2Volume String
zzs)
{-# INLINE overSoXSynthGen2FDN_SG6GS #-}

-- | A variant of the 'overSoXSynthGen2FDN_SG6GS' where 'Strengths' are obtained from the same Ukrainian text as also 'Durations' so the last 
-- 'String' argument is omitted (it is equal to the first one). Helps to create a speech-like composition.
overSoXSynthGen2FDN_SG6GSu :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> 
  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Float -> IO ()
overSoXSynthGen2FDN_SG6GSu :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> Float
-> IO ()
overSoXSynthGen2FDN_SG6GSu String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h = String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Array Int Float
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> IO ())
-> Array Int Float
-> Float
-> IO ()
overSoXSynthGen2FDN_SG6G String
file Int
m Int
ku Float -> OvertonesO
f (String -> Float -> Array Int Float
str2Durations String
zs Float
y) String
wws (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()
h (String -> Array Int Float
str2Volume String
zs)
{-# INLINE overSoXSynthGen2FDN_SG6GSu #-}

-- | Generalized variant of the 'overSoXSynthGen2FDN_SG' with a possibility to specify with the third 'String' argument sound quality parameters.
-- Besides, the second from the end argument (a function) needs to be one more argument -- just also 'String'. 
-- For more information, please, refer to 'soxBasicParams'. Note that 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_SG2G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> ((Float -> OvertonesO) ->
  (Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO ()
overSoXSynthGen2FDN_SG2G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float) -> Int -> String -> String -> IO ())
-> String
-> IO ()
overSoXSynthGen2FDN_SG2G String
file Int
m Int
ku Float -> OvertonesO
f Float
y String
zs String
wws (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> String -> IO ()
h String
ys = do
  Int
n <- String -> IO Int
duration1000 String
file
  [Int]
vecA <- String -> Int -> IO [Int]
freqsFromFile String
file Int
n
  let vecB :: [Float]
vecB = Int -> Int -> [Float] -> [Float]
liftInEnkuV Int
m Int
ku ([Float] -> [Float]) -> ([Int] -> [Float]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Float) -> [Int] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Float]) -> ([Int] -> [Int]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
11440::Int)) ([Int] -> [Float]) -> [Int] -> [Float]
forall a b. (a -> b) -> a -> b
$ [Int]
vecA
      zeroN :: Int
zeroN = [Float] -> Int
forall a. [a] -> Int
numVZeroesPre [Float]
vecB
      v2 :: Array Int Float
v2    = Int -> String -> Float -> Array Int Float
str2DurationsDef Int
n String
zs Float
y
      !l2 :: Int
l2 = Int
n in ((Int, Float) -> IO ()) -> [(Int, Float)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
j, Float
x) -> do
        (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> String -> IO ()
h Float -> OvertonesO
f (Float
x, (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v2 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l2))) Int
j String
wws String
ys
        String -> String -> IO ()
renameFile (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++
          if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
".flac" else String
".wav") ([(Int, Float)] -> IO ())
-> ([Float] -> [(Int, Float)]) -> [Float] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [Float] -> [(Int, Float)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Float] -> IO ()) -> [Float] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Float]
vecB
  String -> IO ()
endFromResult2G String
ys  

-- | Generalized variant of the 'overSoXSynth2FDN_Sf' with a possibility to adjust volume using 'adjust_dbVol'. 'Array' 'Int' of 'Float' is
-- used to specify adjustments in dB. For more information, please, refer to 'adjust_dbVol'.
overSoXSynth2FDN_Sf1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_Sf1G :: (Float -> OvertonesO)
-> (Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_Sf1G Float -> OvertonesO
f (Float
x, Float
y) = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> IO ()
overSoXSynth2FDN_Sf31G Float -> OvertonesO
f (Float
x, Float
y, Float
0.001)
{-# INLINE overSoXSynth2FDN_Sf1G #-}

-- | Generalized variant of the 'overSoXSynth2FDN_Sf1G' with a possibility to specify sound quality using the second 'String' argument.
-- For more information, please, refer to 'soxBasicParams'.
overSoXSynth2FDN_Sf2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_Sf2G :: (Float -> OvertonesO)
-> (Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_Sf2G Float -> OvertonesO
f (Float
x, Float
y) = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_Sf32G Float -> OvertonesO
f (Float
x, Float
y, Float
0.001)
{-# INLINE overSoXSynth2FDN_Sf2G #-}

-- | Generalized variant of the 'overSoXSynth2FDN_Sf3' function with a possibility to adjust volume using 'adjust_dBVol'. 'Array' 'Int' of 'Float'
-- specifies the needed adjustments in dB.
overSoXSynth2FDN_Sf31G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> Array Int Float -> IO ()
overSoXSynth2FDN_Sf31G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> IO ()
overSoXSynth2FDN_Sf31G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j String
zs Array Int Float
vdB = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> String
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_Sf32G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j String
zs Array Int Float
vdB []
{-# INLINE overSoXSynth2FDN_Sf31G #-}

-- | Generalized variant of the 'overSoXSynth2FDN_Sf31G' with a possibility to specify sound quality using the second 'String' parameter.
-- For more information, please, refer to 'soxBasicParams'.
overSoXSynth2FDN_Sf35G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> Array Int Float -> String -> IO ()
overSoXSynth2FDN_Sf35G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_Sf35G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Int
v5 Array Int Float
vdB String
ys
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = do
    let !l0 :: Int
l0 = Array Int Int -> Int
forall i e. Array i e -> Int
numElements Array Int Int
v5
    [Float -> Float]
-> [Float]
-> [Int]
-> (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> IO ()
soundGenF32G ([\Float
x -> Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0),\Float
x -> Float -> Maybe Float -> Float
forall a. a -> Maybe a -> a
fromMaybe (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)
     (Int -> Float -> Maybe Float
dNote (Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))) (Float -> Float
closestNote (if Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
/= Float
0.0 then Float -> Float
forall a. Num a => a -> a
abs Float
x else Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
notes Int
0)))])
       (Int -> Float -> [Float]
forall a. Int -> a -> [a]
replicate Int
2 Float
x) ([Int
1,Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
v5 (Int -> Int
forall a. Num a => a -> a
abs (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l0))]) Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Float
vdB String
ys
    if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys then IO ()
mixTest else String -> IO ()
mixTest2G String
ys 

-- | Generalized variant of the 'overSoXSynth2FDN_Sf35G' with afterwards 'apply6G' usage.
overSoXSynth2FDN_Sf36G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> Array Int Float -> String -> Float -> IO ()
overSoXSynth2FDN_Sf36G :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_Sf36G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Int
v5 Array Int Float
vdB String
ys Float
vol
 | Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null Array Int Int
v5 = (Float -> OvertonesO) -> Float -> IO ()
overSoXSynthG Float -> OvertonesO
f Float
x
 | Bool
otherwise = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> IO ()
overSoXSynth2FDN_Sf35G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Int
v5 Array Int Float
vdB String
ys IO () -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    if Float
y Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0.0 then Float -> String -> IO ()
apply6Gf Float
vol (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") else String -> IO ()
putStr String
""

-- | A variant of the 'overSoXSynth2FDN_Sf36G' where volume adjustment is obtained from a Ukrainian text.
overSoXSynth2FDN_Sf36GS :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> String -> Array Int Float -> String -> String -> IO ()
overSoXSynth2FDN_Sf36GS :: (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> String
-> Array Int Float
-> String
-> String
-> IO ()
overSoXSynth2FDN_Sf36GS Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Int
v5 String
xs Array Int Float
vdB String
ys String
xxs
 | String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (String -> String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
convertToProperUkrainianS (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xxs = String -> IO ()
putStrLn String
"Composition.Sound.Functional.overSoXSynth2FDN_Sf36GS: You provided no information to obtain volume adjustment! "
 | Bool
otherwise = (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Int
-> Array Int Float
-> String
-> Float
-> IO ()
overSoXSynth2FDN_Sf36G Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j (Array Int Int -> String -> Array Int Int
intervalsFromStringG Array Int Int
v5 String
xs) Array Int Float
vdB String
ys (String -> Float
str2Vol1 String
xxs)
{-# INLINE overSoXSynth2FDN_Sf36GS #-} 

-- | Can generate multiple notes with their respective overtones that are played simultaneously (e. g. it can be just one note with overtones,
-- an interval with overtones, an accord with overtones etc.). This allows to get a rather complex or even complicated behaviour to obtain expressive
-- and rich sound. It uses volume adjustment in dB given by the second @[Float]@ for the overtones.
soundGenF31G :: [(Float -> Float)] -> [Float] -> [Int] -> (Float -> OvertonesO) -> (Float, Float, Float) -> Int ->
  Array Int Float -> IO ()
soundGenF31G :: [Float -> Float]
-> [Float]
-> [Int]
-> (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> IO ()
soundGenF31G [Float -> Float]
vf [Float]
vd [Int]
vi Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Float
vdB = [Float -> Float]
-> [Float]
-> [Int]
-> (Float -> OvertonesO)
-> (Float, Float, Float)
-> Int
-> Array Int Float
-> String
-> IO ()
soundGenF32G [Float -> Float]
vf [Float]
vd [Int]
vi Float -> OvertonesO
f (Float
x, Float
y, Float
t0) Int
j Array Int Float
vdB []
{-# INLINE soundGenF31G #-}

-- | Similar to 'overSoXSynthGen2FDN_S', but instead of 'overSoXSynth2FDN_S' uses 'overSoXSynth2FDN_Sf3' function. Note that 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_Sf3G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->
 ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO ()) -> IO ()
overSoXSynthGen2FDN_Sf3G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float, Float) -> Int -> String -> IO ())
-> IO ()
overSoXSynthGen2FDN_Sf3G String
file Int
m Int
ku Float -> OvertonesO
f Float
y Float
t0 String
zs String
wws (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> IO ()
h = do
  Int
n <- String -> IO Int
duration1000 String
file
  [Int]
vecA <- String -> Int -> IO [Int]
freqsFromFile String
file Int
n
  let vecB :: [Float]
vecB = Int -> Int -> [Float] -> [Float]
liftInEnkuV Int
m Int
ku ([Float] -> [Float]) -> ([Int] -> [Float]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Float) -> [Int] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Float]) -> ([Int] -> [Int]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
11440::Int)) ([Int] -> [Float]) -> [Int] -> [Float]
forall a b. (a -> b) -> a -> b
$ [Int]
vecA
      zeroN :: Int
zeroN = [Float] -> Int
forall a. [a] -> Int
numVZeroesPre [Float]
vecB
      v2 :: Array Int Float
v2    = Int -> String -> Float -> Array Int Float
str2DurationsDef Int
n String
zs Float
y
      !l2 :: Int
l2 = Array Int Float -> Int
forall i e. Array i e -> Int
numElements Array Int Float
v2 in ((Int, Float) -> IO ()) -> [(Int, Float)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
j, Float
x) -> do
        (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> IO ()
h Float -> OvertonesO
f (Float
x, (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v2 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l2)), Float
t0) Int
j String
wws
        String -> String -> IO ()
renameFile String
"result.wav" (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".wav") ([(Int, Float)] -> IO ())
-> ([Float] -> [(Int, Float)]) -> [Float] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [Float] -> [(Int, Float)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Float] -> IO ()) -> [Float] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Float]
vecB
  IO ()
endFromResult

-- | Generalized variant of the 'ovorSoXSynthGen2FDN_Sf3G' with a possibility to specify sound quality with the third 'String' argument.
-- Besides, the second from the end argument (a function) needs to be one more argument -- just also 'String'. 
-- For more information, please, refer to 'soxBasicParams'. Note that 'Int' arguments are used by 'liftInEnku' in that order so it 
-- returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). The second 'Int' parameter defines that @n@.
overSoXSynthGen2FDN_Sf3G2G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->
 ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO ()
overSoXSynthGen2FDN_Sf3G2G :: String
-> Int
-> Int
-> (Float -> OvertonesO)
-> Float
-> Float
-> String
-> String
-> ((Float -> OvertonesO)
    -> (Float, Float, Float) -> Int -> String -> String -> IO ())
-> String
-> IO ()
overSoXSynthGen2FDN_Sf3G2G String
file Int
m Int
ku Float -> OvertonesO
f Float
y Float
t0 String
zs String
wws (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> String -> IO ()
h String
ys = do
  Int
n <- String -> IO Int
duration1000 String
file
  [Int]
vecA <- String -> Int -> IO [Int]
freqsFromFile String
file Int
n
  let vecB :: [Float]
vecB = Int -> Int -> [Float] -> [Float]
liftInEnkuV Int
m Int
ku ([Float] -> [Float]) -> ([Int] -> [Float]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Float) -> [Int] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Float]) -> ([Int] -> [Int]) -> [Int] -> [Float]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
11440::Int)) ([Int] -> [Float]) -> [Int] -> [Float]
forall a b. (a -> b) -> a -> b
$ [Int]
vecA
      zeroN :: Int
zeroN = [Float] -> Int
forall a. [a] -> Int
numVZeroesPre [Float]
vecB
      v2 :: Array Int Float
v2    = Int -> String -> Float -> Array Int Float
str2DurationsDef Int
n String
zs Float
y
      !l2 :: Int
l2 = Array Int Float -> Int
forall i e. Array i e -> Int
numElements Array Int Float
v2 in ((Int, Float) -> IO ()) -> [(Int, Float)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
j, Float
x) -> do
        (Float -> OvertonesO)
-> (Float, Float, Float) -> Int -> String -> String -> IO ()
h Float -> OvertonesO
f (Float
x, (Array Int Float -> Int -> Float
forall i e. Array i e -> Int -> e
unsafeAt Array Int Float
v2 (Int
j Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
l2)), Float
t0) Int
j String
wws String
ys
        String -> String -> IO ()
renameFile (String
"result." String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f" then String
"flac" else String
"wav") (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"result0" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
prependZeroes Int
zeroN (Int -> String
forall a. Show a => a -> String
show (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
3 String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"f"
          then String
".flac" else String
".wav") ([(Int, Float)] -> IO ())
-> ([Float] -> [(Int, Float)]) -> [Float] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [Float] -> [(Int, Float)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Float] -> IO ()) -> [Float] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Float]
vecB
  String -> IO ()
endFromResult2G String
ys