dobutokO2 0.41.0.0 → 0.42.0.0

raw patch · 16 files changed

+399/−389 lines, 16 filesdep ~mmsyn7ldep ~mmsyn7sdep ~mmsyn7ukrPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: mmsyn7l, mmsyn7s, mmsyn7ukr

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• DobutokO/Sound/DIS5G6G.hs +15/−15
• DobutokO/Sound/Decibel.hs +6/−6
• DobutokO/Sound/Executable.hs +13/−13
• DobutokO/Sound/FunctionF.hs +9/−9
• DobutokO/Sound/Functional.hs +66/−66
• DobutokO/Sound/Functional/Basics.hs +26/−26
• DobutokO/Sound/Functional/Elements.hs +41/−41
• DobutokO/Sound/Functional/Params.hs +47/−47
• DobutokO/Sound/Functional/Split.hs +4/−4
• DobutokO/Sound/Octaves.hs +5/−5
• DobutokO/Sound/Overtones.hs +70/−70
• DobutokO/Sound/Process.hs +4/−4
• DobutokO/Sound/Uniq.hs +77/−77
• README.markdown +7/−3
• dobutokO2.cabal +3/−3

@@ -386,3 +386,9 @@ different modules: DobutokO.Sound.Overtones, DobutokO.Sound.Uniq and DobutokO.Sound.Octaves. This was done to simplify compilation and to produce more  logical and semantic structure. The most complicated functions from DobutokO.Sound.Functional module are moved to a new package dobutokO3. Some code  improvements.++## 0.42.0.0 -- 2020-06-24++* Fourty-second version. Changed Double to Float in the modules where possible to reduce redundancy and to open access to new possibilities. The shift is inspired +by: https://www.youtube.com/watch?v=FYTZkE5BZ-0+Some minor code and documentation improvements.

@@ -64,29 +64,29 @@ ---------------------------------------------------------------------------------------------------------------------  -- | Arithmetic average for the 'V.Vector' is used as a weight for a duration. -doublesAveragedA :: V.Vector Double -> Double -> V.Vector Double+doublesAveragedA :: V.Vector Float -> Float -> V.Vector Float doublesAveragedA v4 y3    | V.null v4 || y3 == 0 = V.empty   | otherwise = let aver = V.sum v4 / fromIntegral (V.length v4) in if aver == 0.0 then doublesAveragedA (V.filter (/= 0.0) v4) y3        else V.map (\t4 -> t4 * y3 / aver) v4  -- | Geometric average for the 'V.Vector' is used as a weight for a strength. -doublesAveragedG :: V.Vector Double -> Double -> V.Vector Double+doublesAveragedG :: V.Vector Float -> Float -> V.Vector Float doublesAveragedG v4 y3    | V.null v4 || y3 == 0 = V.empty   | otherwise = let aver = V.product v4 ** (fromIntegral 1 / (fromIntegral (V.length v4))) in if aver == 0.0 then doublesAveragedG (V.filter (/= 0.0) v4) y3        else V.map (\t4 -> t4 * y3 / aver) v4        -- | 'Durations' accounting the desired average duration.-durationsAver :: Durations -> Double -> Durations+durationsAver :: Durations -> Float -> Durations durationsAver = doublesAveragedA  -- | 'Strengths' accounting the desired average strength.-strengthsAver :: Strengths -> Double -> Strengths+strengthsAver :: Strengths -> Float -> Strengths strengthsAver = doublesAveragedG  -- | 'StrengthsDb' accounting the desired average strength in dB.-strengthsDbAver :: StrengthsDb -> Double -> StrengthsDb+strengthsDbAver :: StrengthsDb -> Float -> StrengthsDb strengthsDbAver = doublesAveragedG  -- | Auxiliar function to make all vectors in a 'V.Vector' equal by length (the minimum one).@@ -94,13 +94,13 @@ equalize2Vec v = let min = V.minimum . V.map V.length $ v in V.map (V.unsafeSlice 0 min) v  -- | A full conversion to the 'Durations' from a Ukrainian text.-str2Durations :: String -> Double -> Durations+str2Durations :: String -> Float -> Durations str2Durations xs y   | compare y 0.0 == GT && not (null xs) = durationsAver (V.map str2Durat1 . convertToProperUkrainian $ xs) y  | otherwise = V.empty --- | A conversion to the 'Double' that is used inside 'str2Durations'.-str2Durat1 :: String -> Double+-- | A conversion to the 'Float' that is used inside 'str2Durations'.+str2Durat1 :: String -> Float str2Durat1 = getBFst' ((-0.153016), V.fromList [("-", (-0.101995)), ("0", (-0.051020)), ("1", (-0.153016)), ("а", 0.138231), ("б", 0.057143),    ("в", 0.082268), ("г", 0.076825), ("д", 0.072063), ("дж", 0.048934), ("дз", 0.055601), ("е", 0.093605), ("ж", 0.070658), ("з", 0.056054),      ("и", 0.099955), ("й", 0.057143), ("к", 0.045351), ("л", 0.064036), ("м", 0.077370), ("н", 0.074240), ("о", 0.116463), ("п", 0.134830), @@ -115,8 +115,8 @@       ("т", -0.304443), ("у", 0.718262), ("ф", (-0.374359)), ("х", (-0.251160)), ("ц", (-0.392365)), ("ць", 0.381348), ("ч", (-0.189240)),          ("ш", 0.251221), ("ь", 0.495483), ("і", (-0.682709)), ("ґ", 0.557098)])) . convertToProperUkrainian --- | A conversion to the 'Double' that is used inside 'str2Volume'.-str2Vol1 :: String -> Double+-- | A conversion to the 'Float' that is used inside 'str2Volume'.+str2Vol1 :: String -> Float str2Vol1 = getBFst' (0.0, V.fromList [("а", 0.890533), ("б", 0.211334), ("в", (-0.630859)), ("г", (-0.757599)), ("д", 0.884613), ("дж", 0.768127),    ("дз", (-0.731262)), ("е", (-0.742523)), ("ж", (-0.588959)), ("з", (-0.528870)), ("и", 0.770935), ("й", (-0.708008)), ("к", (-0.443085)),      ("л", 0.572632), ("м", (-0.782349)), ("н", (-0.797607)), ("о", (-0.579559)), ("п", 0.124908), ("р", 0.647369), ("с", 0.155640), ("сь", (-0.207764)), @@ -125,7 +125,7 @@  -- | For the given non-existing 'FilePath' for a sound file supported by SoX generates a silence of the specified duration and quality (see,  -- 'soxBasicParams').-silentSound2G :: FilePath -> Double -> String -> IO ()+silentSound2G :: FilePath -> Float -> String -> IO () silentSound2G file y4 ys = do   _ <- readProcessWithExitCode (fromJust (showE "sox"))       ((if null ys then id else soxBasicParams ys) ["-r22040","-n",file,"synth", showFFloat (Just 1) y4 "","sine","440.0","vol","0"]) ""@@ -146,9 +146,9 @@ apply6GS :: String -> String -> String -> IO () apply6GS xs = apply6G (str2Volume xs) --- | Variant of the 'apply6G' function which can be applied also to the silent files. Whether a file is silent is defined using the 'Double' argument --- so that if the maximum by absolute value amplitude is less by absolute value than the 'Double' argument then the file is not changed.-apply6G2 :: Strengths -> String -> String -> Double -> IO ()+-- | Variant of the 'apply6G' function which can be applied also to the silent files. Whether a file is silent is defined using the 'Float' argument +-- so that if the maximum by absolute value amplitude is less by absolute value than the 'Float' argument then the file is not changed.+apply6G2 :: Strengths -> String -> String -> Float -> IO () apply6G2 v6 ys zs limV  | V.null v6 = putStrLn "Nothing changed, because the vector of volume adjustments is empty! "  | otherwise = do@@ -157,6 +157,6 @@  -- | Variant of the 'apply6G2' where you use as a 'Strengths' parameter that one obtained from a Ukrainian text provided as the first 'String' argument.  -- It uses 'str2Volume' inside. -apply6GS2 :: String -> String -> String -> Double -> IO ()+apply6GS2 :: String -> String -> String -> Float -> IO () apply6GS2 xs = apply6G2 (str2Volume xs) 

@@ -26,21 +26,21 @@  -- | Is used to represent a set of volumes in the dB scale for SoX \"vol\" effect. Usually, the zero value corresponds to the sound with volume  -- level equal by absolute value to 1.0 (the extremum one). So for most cases, its elements are negative numbers not less than (-120).-type StrengthsDb = V.Vector Double+type StrengthsDb = V.Vector Float --- | Returns the frequency for which its ratio with the second 'Double' argument being under lg and being multiplied with 20 returns --- the first 'Double'  argument. For example, @dBOmegaRatio 6 440 ~ 880@ (actually, 877.9154185863069).-dBOmegaRatio :: Double -> Double -> Double+-- | Returns the frequency for which its ratio with the second 'Float' argument being under lg and being multiplied with 20 returns +-- the first 'Float'  argument. For example, @dBOmegaRatio 6 440 ~ 880@ (actually, 877.9154185863069).+dBOmegaRatio :: Float -> Float -> Float dBOmegaRatio dB omega0 = omega0 * 10 ** (dB / fromIntegral 20)   -- | Converts the absolute value of the argument to dB value compared to 1.0. Usually, is less than 0. The argument should not be equal to zero (0),  -- otherwise, it is equal to -'Infinity'.-strength2dB_Abs :: Double -> Double+strength2dB_Abs :: Float -> Float strength2dB_Abs vol = 20 * logBase 10 (abs vol)  -- | Converts the absolute value of the argument from dB value to amplitude with 0 equivalent to amplitude of 1.0 (or -1.0 for inverted sound).  -- Usually, is used for negative arguments (or at least not positive ones). -strengthdB2ampl :: Double -> Double+strengthdB2ampl :: Float -> Float strengthdB2ampl dB = 10 ** (dB / fromIntegral 20)  -- | Converts the 'V.Vector' of the absolute values of the argument to the 'V.Vector' of dB values compared to 1.0. 

@@ -60,18 +60,18 @@   let (octave1,ampL,time3) = fromJust . threeStr2Val $ [octave,ampLS,time2] in overSoXSynthNGen file octave1 ampL time3 args {-# INLINE dobutokO2H1 #-} -threeStr2Val :: [String] -> Maybe (Int,Double,Double)-threeStr2Val [xs,ys,zs] = Just (read xs::Int,read ys::Double,read zs::Double)+threeStr2Val :: [String] -> Maybe (Int,Float,Float)+threeStr2Val [xs,ys,zs] = Just (read xs::Int,read ys::Float,read zs::Float) threeStr2Val _ = Nothing {-# INLINE threeStr2Val #-} -fourStr2Val :: [String] -> Maybe (Int,Double,Double,Double)-fourStr2Val [xs,ys,zs,tws] = Just (read xs::Int,read ys::Double,read zs::Double,read tws::Double)+fourStr2Val :: [String] -> Maybe (Int,Float,Float,Float)+fourStr2Val [xs,ys,zs,tws] = Just (read xs::Int,read ys::Float,read zs::Float,read tws::Float) fourStr2Val _ = Nothing {-# INLINE fourStr2Val #-} -fiveStr2Val :: [String] -> Maybe ([Int],Double,Double,Double)-fiveStr2Val [xs,ys,zs,tws] = Just (map (\z -> read z::Int) . words $ xs,read ys::Double,read zs::Double,read tws::Double)+fiveStr2Val :: [String] -> Maybe ([Int],Float,Float,Float)+fiveStr2Val [xs,ys,zs,tws] = Just (map (\z -> read z::Int) . words $ xs,read ys::Float,read zs::Float,read tws::Float) fiveStr2Val _ = Nothing {-# INLINE fiveStr2Val #-} @@ -327,8 +327,8 @@     4 -> onException (do       let [octave0,ampLS0,time20,wws] = listTxt           octave1 = read (d3H octave0)::Int-          ampL = read (d4H ampLS0)::Double-          time3 = read (d5H time20)::Double+          ampL = read (d4H ampLS0)::Float+          time3 = read (d5H time20)::Float       uniqOverSoXSynthNGen file octave1 ampL time3 args wws) (do         putStrLn "--------------------------------------------------------------------------------------------------------------------"         putStrLn ""@@ -337,8 +337,8 @@     5 -> onException (do       let [octave0,ampLS0,time20,wws,tts0] = listTxt           octave1 = read (d3H octave0)::Int-          ampL = read (d4H ampLS0)::Double-          time3 = read (d5H time20)::Double+          ampL = read (d4H ampLS0)::Float+          time3 = read (d5H time20)::Float       uniqOverSoXSynthNGen3 file octave1 ampL time3 args wws (d7H tts0)) (do         putStrLn "--------------------------------------------------------------------------------------------------------------------"         putStrLn ""@@ -347,9 +347,9 @@     7 -> onException (do       let [octave0,ampLS0,time20,wws,tts0,dAmpl0,vs0] = listTxt           octave1 = read (d3H octave0)::Int-          ampL = read (d4H ampLS0)::Double-          time3 = read (d5H time20)::Double-          dAmpl = read (d8H dAmpl0)::Double+          ampL = read (d4H ampLS0)::Float+          time3 = read (d5H time20)::Float+          dAmpl = read (d8H dAmpl0)::Float       uniqOverSoXSynthNGen4 file octave1 ampL time3 dAmpl args wws (d7H tts0) (d9H vs0)) (do         putStrLn "--------------------------------------------------------------------------------------------------------------------"         putStrLn ""

@@ -23,8 +23,8 @@ import qualified Data.Vector as V import DobutokO.Sound.Functional.Basics --- | Gets a function @f::Double -> OvertonesO@ that can be used further. Has two variants with usage of 'closestNote' ('Int' argument is greater than 0)v---  and without it ('Int' argument is less than 0). For both cases 'String' must be in a form list of tuples of pairs of 'Double' to get somewhat+-- | Gets a function @f::Float -> OvertonesO@ that can be used further. Has two variants with usage of 'closestNote' ('Int' argument is greater than 0)v+--  and without it ('Int' argument is less than 0). For both cases 'String' must be in a form list of tuples of pairs of 'Float' to get somewhat -- reasonable result. The function @f@ can be shown using a special printing function 'showFFromStrVec'. It is a simplest multiplicative (somewhat -- acoustically and musically reasonable) form for the function that can provide such a result that fits into the given data. --@@ -36,26 +36,26 @@ -- >  -- > (3583.9783,[(25.368,0.2486356),(37.259,0.6464867),(486.153,0.374618646),(789.563,0.463486461)]) -- -maybeFFromStrVec :: Int -> Double -> String -> Maybe (Double,(Double -> V.Vector (Double,Double)))+maybeFFromStrVec :: Int -> Float -> String -> Maybe (Float,(Float -> V.Vector (Float,Float))) maybeFFromStrVec n x ys   | n == 0 || null ys = Nothing   | n > 0 =       let y = closestNote (if x /= 0.0 then abs x else V.unsafeIndex notes 0)-         v = readMaybe ys::Maybe (V.Vector (Double,Double))+         v = readMaybe ys::Maybe (V.Vector (Float,Float))          v2 = fromMaybe V.empty v          v3 = V.map (\(t,_) -> t / y) v2 in            if V.null v3 then Nothing            else Just (y,(\t1 -> V.imap (\i (_,ampl2) -> ((V.unsafeIndex v3 i) * t1,ampl2)) v2))   | otherwise =       let y = (if x /= 0.0 then abs x else V.unsafeIndex notes 0)-         v = readMaybe ys::Maybe (V.Vector (Double,Double))+         v = readMaybe ys::Maybe (V.Vector (Float,Float))          v2 = fromMaybe V.empty v          v3 = V.map (\(t,_) -> t / y) v2 in            if V.null v3 then Nothing            else Just (y,(\t1 -> V.imap (\i (_,ampl2) -> ((V.unsafeIndex v3 i) * t1,ampl2)) v2)) --- | Gets multiplication coefficients for @f::Double -> Vector (Double,Double)@ from the 'maybeFFromStrVec' with the same arguments.-fVecCoefs :: Int -> Double -> String -> V.Vector Double+-- | Gets multiplication coefficients for @f::Float -> Vector (Float,Float)@ from the 'maybeFFromStrVec' with the same arguments.+fVecCoefs :: Int -> Float -> String -> V.Vector Float fVecCoefs n x ys =   let rs = maybeFFromStrVec n x ys in     case rs of@@ -64,14 +64,14 @@         let (_,f1) = fromJust rs in           V.map fst (f1 1) --- | Experimental 'show' for @f::Double -> Vector (Double,Double)@ that is used only for visualisation. It is correct only with 'maybeFFromStrVec' or+-- | Experimental 'show' for @f::Float -> Vector (Float,Float)@ that is used only for visualisation. It is correct only with 'maybeFFromStrVec' or -- equivalent function. Because the shape of the @f@ is known the function can be defined. --  -- > showFFromStrVec (-1) 440 "[(25.358,0.3598),(489.35,0.4588962),(795.35,0.6853)]" -- >  -- > "(440.00,(\t -> <(0.05763181818181818 * t, 0.3598),(1.112159090909091 * t, 0.4588962),(1.8076136363636364 * t, 0.6853)>))" -- -showFFromStrVec :: Int -> Double -> String -> String+showFFromStrVec :: Int -> Float -> String -> String showFFromStrVec n x ys  | isNothing . maybeFFromStrVec n x $ ys = ""  | otherwise =

@@ -83,8 +83,8 @@ import DobutokO.Sound.Functional.Params import DobutokO.Sound.DIS5G6G (intervalsFromStringG,str2Durations,str2Vol1,str2Volume) --- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Double -> Vector (Double, Double)@ with--- somewhat sophisticated mechanism to normalize the resulting 'V.Vector' elements @(Double, Double)@. The last one is an experimental feature, so+-- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Float -> Vector (Float, Float)@ with+-- somewhat sophisticated mechanism to normalize the resulting 'V.Vector' 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 -- 'convertToProperUkrainian' to the 'String' parameter must not be 'V.empty'. '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.@@ -93,17 +93,17 @@ -- 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 :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()+overSoXSynth2FDN :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO () overSoXSynth2FDN f (x, y) j zs = overSoXSynth2FDN1G f (x, y) j zs (V.replicate (V.length . f . closestNote $ if x /= 0.0    then abs x else V.unsafeIndex notes 0) 0.0) --- | 'V.Vector' of 'Double' is a vector of dB volume adjustments for the corresponding harmonices (overtones).-overSoXSynth2FDN1G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> IO ()+-- | 'V.Vector' of 'Float' is a vector of dB volume adjustments for the corresponding harmonices (overtones).+overSoXSynth2FDN1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> IO () overSoXSynth2FDN1G f (x, y) j zs vdB = overSoXSynth2FDN2G f (x, y) j zs vdB []   -- | 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 :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> String -> IO () overSoXSynth2FDN2G f (x, y) j zs vdB ys  | V.null . convertToProperUkrainian $ zs = overSoXSynth x  | otherwise = do@@ -136,7 +136,7 @@  -- | 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 :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN5G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> IO () overSoXSynth2FDN5G f (x, y) j v5 vdB ys  | V.null v5 = overSoXSynth x  | otherwise = do@@ -168,7 +168,7 @@     if null ys then mixTest else mixTest2G ys         -- | Generalized variant of the 'overSoXSynth2FDN5G' with afterwards 'apply6Gf' usage. -overSoXSynth2FDN6G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> Double -> IO ()+overSoXSynth2FDN6G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> Float -> IO () overSoXSynth2FDN6G f (x, y) j v5 vdB ys vol  | V.null v5 = overSoXSynth x  | otherwise = do@@ -201,30 +201,30 @@     if compare y 0.0 == GT then apply6Gf vol ("result." ++ if drop 3 ys == "f" then "flac" else "wav") else putStr ""  -- | A variant of the 'overSoXSynth2FDN6G' where volume adjustment is obtained from a Ukrainian text.-overSoXSynth2FDN6GS :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> String -> V.Vector Double -> String -> String -> IO ()+overSoXSynth2FDN6GS :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> String -> V.Vector Float -> String -> String -> IO () overSoXSynth2FDN6GS f (x, y) j v5 xs vdB ys xxs   | V.null . convertToProperUkrainian $ xxs = putStrLn "You provided no information to obtain volume adjustment! "  | otherwise = overSoXSynth2FDN6G f (x, y) j (intervalsFromStringG v5 xs) vdB ys (str2Vol1 xxs)   -- | 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 'Double' parameter is a+-- 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 -> (Double -> OvertonesO) -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> IO () overSoXSynthGen2FDN file m ku f y zs wws = overSoXSynthGen2FDN_SG file m ku f y zs wws overSoXSynth2FDN  -- | 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 -> (Double -> OvertonesO) -> Durations -> String -> IO ()+overSoXSynthGen2FDN4G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> IO () overSoXSynthGen2FDN4G file m ku f v2 wws = overSoXSynthGen2FDN_SG4G file m ku f v2 wws overSoXSynth2FDN --- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Double -> Vector (Double, Double)@ with--- somewhat sophisticated mechanism to normalize the resulting 'V.Vector' elements @(Double, Double)@. The last one is experimental feature, so+-- | Similar to 'overSoXSynth2DN' but instead of 'overTones' function, it uses volatile function @f::Float -> Vector (Float, Float)@ with+-- somewhat sophisticated mechanism to normalize the resulting 'V.Vector' 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 -- 'convertToProperUkrainian' to the 'String' parameter must not be 'V.empty'. The function also tries to perform filtering to avoid possible beating.--- The third 'Double' parameter in the tuple is used as a limit for frequencies difference in Hz to be filtered out from the resulting sound. It is+-- 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. --@@ -232,16 +232,16 @@ -- 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 :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> IO ()+overSoXSynth2FDN_B :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO () overSoXSynth2FDN_B f (x, y, limB) j zs = overSoXSynth2FDN_B1G f (x, y, limB) j zs (V.replicate (V.length . f . closestNote $ if x /= 0.0 then abs x else V.unsafeIndex notes 0) 0.0) --- | 'V.Vector' of 'Double' is a vector of dB volume adjustments for the corresponding harmonices (overtones).-overSoXSynth2FDN_B1G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> V.Vector Double -> IO ()+-- | 'V.Vector' of 'Float' is a vector of dB volume adjustments for the corresponding harmonices (overtones).+overSoXSynth2FDN_B1G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> V.Vector Float -> IO () overSoXSynth2FDN_B1G f (x, y, limB) j zs vdB = overSoXSynth2FDN_B2G f (x, y, limB) j zs vdB []  -- | 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 :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_B2G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> V.Vector Float -> String -> IO () overSoXSynth2FDN_B2G f (x, y, limB) j zs vdB ys  | V.null . convertToProperUkrainian $ zs = overSoXSynth x  | otherwise = do@@ -278,7 +278,7 @@  -- | Generalized version of the 'overSoXSynth2FDN_B2G' with a possibility to specify your own 'Intervals'. For more information, please,  -- refer to 'intervalsFromStringG'.-overSoXSynth2FDN_B5G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_B5G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> IO () overSoXSynth2FDN_B5G f (x, y, limB) j v5 vdB ys  | V.null v5 = overSoXSynth x  | otherwise = do@@ -314,7 +314,7 @@     if null ys then mixTest else mixTest2G ys      -- | Generalized variant of the 'overSoXSynth2FDN_B5G' with afterwards 'apply6G' usage. -overSoXSynth2FDN_B6G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> Double -> IO ()+overSoXSynth2FDN_B6G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> Float -> IO () overSoXSynth2FDN_B6G f (x, y, limB) j v5 vdB ys vol    | V.null v5 = overSoXSynth x   | otherwise = do@@ -351,17 +351,17 @@     if compare y 0.0 == GT then apply6Gf vol ("result." ++ if drop 3 ys == "f" then "flac" else "wav") else putStr ""  -- | A variant of the 'overSoXSynth2FDN_B6G' where volume adjustment is obtained from a Ukrainian text.-overSoXSynth2FDN_B6GS :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> String -> V.Vector Double -> String -> String -> IO ()+overSoXSynth2FDN_B6GS :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> String -> V.Vector Float -> String -> String -> IO () overSoXSynth2FDN_B6GS f (x, y, limB) j v5 xs vdB ys xxs  | V.null . convertToProperUkrainian $ xxs = putStrLn "You provided no information to obtain volume adjustment! "  | otherwise = overSoXSynth2FDN_B6G f (x, y, limB) j (intervalsFromStringG v5 xs) vdB ys (str2Vol1 xxs)  -- | 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 'Double' parameter is a+-- 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 -> (Double -> OvertonesO) -> Double -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN_B :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String -> IO () overSoXSynthGen2FDN_B file m ku f y limB zs wws = overSoXSynthGen2FDN_Sf3G file m ku f y limB zs wws overSoXSynth2FDN_B  -- | Similar to 'overSoXSynth2FDN' but it does not make any normalizing transformations with the 'V.Vector' argument. To be used properly, it is needed@@ -373,16 +373,16 @@ -- 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_S :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()+overSoXSynth2FDN_S :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO () overSoXSynth2FDN_S f (x, y) j zs = overSoXSynth2FDN_S2G f (x, y) j zs V.empty [] --- | Generalized version of the 'overSoXSynth2FDN_S' with the additional volume adjustment in dB for overtones given by 'V.Vector' of 'Double'.-overSoXSynth2FDN_S1G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> IO ()+-- | Generalized version of the 'overSoXSynth2FDN_S' with the additional volume adjustment in dB for overtones given by 'V.Vector' of 'Float'.+overSoXSynth2FDN_S1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> IO () overSoXSynth2FDN_S1G f (x, y) j zs vdB = overSoXSynth2FDN_S2G f (x, y) j zs vdB []   -- | 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 :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_S2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> String -> IO () overSoXSynth2FDN_S2G f (x, y) j zs vdB ys  | V.null . convertToProperUkrainian $ zs = overSoXSynth x  | otherwise = do@@ -404,7 +404,7 @@          -- | Generalized version of the 'overSoXSynth2FDN_S2G' where you specify your own 'Intervals'. For more information, please, refer  -- to 'intervalsFromStringG'.-overSoXSynth2FDN_S5G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_S5G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> IO () overSoXSynth2FDN_S5G f (x, y) j v5 vdB ys  | V.null v5 = overSoXSynth x  | otherwise = do@@ -425,7 +425,7 @@     if null ys then mixTest else mixTest2G ys              -- | Generalized variant of the 'overSoXSynth2FDN_S5G' with afterwards 'apply6G' usage. Arguments for the latter is the three last function arguments.-overSoXSynth2FDN_S6G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> Double -> IO ()+overSoXSynth2FDN_S6G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> Float -> IO () overSoXSynth2FDN_S6G f (x, y) j v5 vdB ys vol  | V.null v5 = overSoXSynth x  | otherwise = do@@ -447,27 +447,27 @@     if compare y 0.0 == GT then apply6Gf vol ("result." ++ if drop 3 ys == "f" then "flac" else "wav") else putStr ""    -- | A variant of the 'overSoXSynth2FDN_S6G' where volume adjustment is obtained from a Ukrainian text.-overSoXSynth2FDN_S6GS :: (Double -> OvertonesO) -> (Double, Double) -> Int -> Intervals -> String -> V.Vector Double -> String -> String -> IO ()+overSoXSynth2FDN_S6GS :: (Float -> OvertonesO) -> (Float, Float) -> Int -> Intervals -> String -> V.Vector Float -> String -> String -> IO () overSoXSynth2FDN_S6GS f (x, y) j v5 xs vdB ys xxs  | V.null . convertToProperUkrainian $ xxs = putStrLn "You provided no information to obtain volume adjustment! "  | otherwise = overSoXSynth2FDN_S6G f (x, y) j (intervalsFromStringG v5 xs) vdB ys (str2Vol1 xxs)  -- | 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 -> (Double -> OvertonesO) -> Double -> String -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_SG :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_SG file m ku f y zs wws h = do   n <- duration1000 file   overSoXSynthGen2FDN_SG4G file m ku f (str2DurationsDef n zs y) wws h  -- | 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 :: ((Double -> OvertonesO) -> (Double, Double) -> +-- 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 -> (Double -> OvertonesO) -> Durations -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_SG4G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_SG4G file m ku f v2 wws h = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -479,17 +479,17 @@  -- | 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 :: ((Double -> OvertonesO) -> (Double, Double) -> +-- 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 -> (Double -> OvertonesO) -> Double -> String -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_SG4GS :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_SG4GS file m ku f y zs = overSoXSynthGen2FDN_SG4G file m ku f (str2Durations zs y)  -- | 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 -> (Double -> OvertonesO) -> Durations -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> Strengths -> Double -> IO ()+overSoXSynthGen2FDN_SG6G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Durations -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Strengths -> Float -> IO () overSoXSynthGen2FDN_SG6G file m ku f v2 wws h v6 limV  | V.null v6 = putStrLn "You did not provide a volume adjustments vector! "  | otherwise = do@@ -503,22 +503,22 @@     endFromResult    -- | A variant of the 'overSoXSynthGen2FDN_SG6G' where 'Strengths' are obtained from a Ukrainian text and 'str2Volume'.-overSoXSynthGen2FDN_SG6GS :: FilePath -> Int -> Int -> (Double -> OvertonesO) -> Double -> String -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> String -> Double -> IO ()+overSoXSynthGen2FDN_SG6GS :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> String -> Float -> IO () overSoXSynthGen2FDN_SG6GS file m ku f y zs wws h zzs = overSoXSynthGen2FDN_SG6G file m ku f (str2Durations zs y) wws h (str2Volume zzs)    -- | 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 -> (Double -> OvertonesO) -> Double -> String -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> Double -> IO ()+overSoXSynthGen2FDN_SG6GSu :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Float -> IO () overSoXSynthGen2FDN_SG6GSu file m ku f y zs wws h = overSoXSynthGen2FDN_SG6G file m ku f (str2Durations zs y) wws h (str2Volume zs)  -- | 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 -> (Double -> OvertonesO) -> Double -> String -> String -> ((Double -> OvertonesO) ->-  (Double, Double) -> Int -> String -> String -> IO ()) -> String -> IO ()+overSoXSynthGen2FDN_SG2G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> ((Float -> OvertonesO) ->+  (Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO () overSoXSynthGen2FDN_SG2G file m ku f y zs wws h ys = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -531,22 +531,22 @@   endFromResult2G ys    -- | Similar to 'overSoXSynthGen2FDN', but instead of 'overSoXSynth2FDN' uses 'overSoXSynth2FDN_S' function. -overSoXSynthGen2FDN_S :: FilePath -> Int -> Int -> (Double -> OvertonesO) -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN_S :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> IO () overSoXSynthGen2FDN_S file m ku f y zs wws = overSoXSynthGen2FDN_SG file m ku f y zs wws overSoXSynth2FDN_S --- | Generalized variant of the 'overSoXSynth2FDN_Sf' with a possibility to adjust volume using 'adjust_dbVol'. 'V.Vector' of 'Double' is+-- | Generalized variant of the 'overSoXSynth2FDN_Sf' with a possibility to adjust volume using 'adjust_dbVol'. 'V.Vector' of 'Float' is -- used to specify adjustments in dB. For more information, please, refer to 'adjust_dbVol'.-overSoXSynth2FDN_Sf1G :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> IO ()+overSoXSynth2FDN_Sf1G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> IO () overSoXSynth2FDN_Sf1G f (x, y) = overSoXSynth2FDN_Sf31G f (x, y, 0.001)  -- | 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 :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_Sf2G :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> V.Vector Float -> String -> IO () overSoXSynth2FDN_Sf2G f (x, y) = overSoXSynth2FDN_Sf32G f (x, y, 0.001)  -- | Similar to 'overSoXSynthGen2FDN_S', but instead of 'overSoXSynth2FDN_S' uses 'overSoXSynth2FDN_Sf' 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_Sf :: FilePath -> Int -> Int -> (Double -> OvertonesO) -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN_Sf :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> String -> String -> IO () overSoXSynthGen2FDN_Sf file m ku f y zs wws = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -557,14 +557,14 @@         renameFile "result.wav" $ "result0" ++ prependZeroes zeroN (show (j + 1)) ++ ".wav") vecB   endFromResult      --- | Generalized variant of the 'overSoXSynth2FDN_Sf3' function with a possibility to adjust volume using 'adjust_dBVol'. 'V.Vector' of 'Double'+-- | Generalized variant of the 'overSoXSynth2FDN_Sf3' function with a possibility to adjust volume using 'adjust_dBVol'. 'V.Vector' of 'Float' -- specifies the needed adjustments in dB.-overSoXSynth2FDN_Sf31G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> V.Vector Double -> IO ()+overSoXSynth2FDN_Sf31G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> V.Vector Float -> IO () overSoXSynth2FDN_Sf31G f (x, y, t0) j zs vdB = overSoXSynth2FDN_Sf32G f (x, y, t0) j zs vdB []  -- | 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 :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_Sf35G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> IO () overSoXSynth2FDN_Sf35G f (x, y, t0) j v5 vdB ys  | V.null v5 = overSoXSynth x  | otherwise = do@@ -575,7 +575,7 @@     if null ys then mixTest else mixTest2G ys   -- | Generalized variant of the 'overSoXSynth2FDN_Sf35G' with afterwards 'apply6G' usage.-overSoXSynth2FDN_Sf36G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> V.Vector Double -> String -> Double -> IO ()+overSoXSynth2FDN_Sf36G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> V.Vector Float -> String -> Float -> IO () overSoXSynth2FDN_Sf36G f (x, y, t0) j v5 vdB ys vol  | V.null v5 = overSoXSynth x  | otherwise = do@@ -587,7 +587,7 @@     if compare y 0.0 == GT then apply6Gf vol ("result." ++ if drop 3 ys == "f" then "flac" else "wav") else putStr ""  -- | A variant of the 'overSoXSynth2FDN_Sf36G' where volume adjustment is obtained from a Ukrainian text.-overSoXSynth2FDN_Sf36GS :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> Intervals -> String -> V.Vector Double -> String -> String -> IO ()+overSoXSynth2FDN_Sf36GS :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Intervals -> String -> V.Vector Float -> String -> String -> IO () overSoXSynth2FDN_Sf36GS f (x, y, t0) j v5 xs vdB ys xxs  | V.null . convertToProperUkrainian $ xxs = putStrLn "You provided no information to obtain volume adjustment! "  | otherwise = overSoXSynth2FDN_Sf36G f (x, y, t0) j (intervalsFromStringG v5 xs) vdB ys (str2Vol1 xxs)@@ -595,22 +595,22 @@ -- | 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.-soundGenF3 :: V.Vector (Double -> Double) -> V.Vector Double -> V.Vector Int -> (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> IO ()+soundGenF3 :: V.Vector (Float -> Float) -> V.Vector Float -> V.Vector Int -> (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> IO () soundGenF3 vf vd vi f (x, y, t0) j = soundGenF32G vf vd vi f (x, y, t0) j V.empty [] --- | Generalized variant of the 'soundGenF3' with volume adjustment in dB given by the second @Vector Double@ for the overtones.-soundGenF31G :: V.Vector (Double -> Double) -> V.Vector Double -> V.Vector Int -> (Double -> OvertonesO) -> (Double, Double, Double) -> Int ->-  V.Vector Double -> IO ()+-- | Generalized variant of the 'soundGenF3' with volume adjustment in dB given by the second @Vector Float@ for the overtones.+soundGenF31G :: V.Vector (Float -> Float) -> V.Vector Float -> V.Vector Int -> (Float -> OvertonesO) -> (Float, Float, Float) -> Int ->+  V.Vector Float -> IO () soundGenF31G vf vd vi f (x, y, t0) j vdB = soundGenF32G vf vd vi f (x, y, t0) j vdB []   -- | Similar to 'overSoXSynthGen2FDN_S', but instead of 'overSoXSynth2FDN_S' uses 'overSoXSynth2FDN_Sf3' function. -overSoXSynthGen2FDN_Sf3 :: FilePath -> Int -> Int -> (Double -> OvertonesO) -> Double -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN_Sf3 :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String -> IO () overSoXSynthGen2FDN_Sf3 file m ku f y t0 zs wws = overSoXSynthGen2FDN_Sf3G file m ku f y t0 zs wws overSoXSynth2FDN_Sf3  -- | 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 -> (Double -> OvertonesO) -> Double -> Double -> String -> String ->- ((Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_Sf3G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->+ ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_Sf3G file m ku f y t0 zs wws h = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -625,8 +625,8 @@ -- 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 -> (Double -> OvertonesO) -> Double -> Double -> String -> String ->- ((Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> String -> IO ()) -> String -> IO ()+overSoXSynthGen2FDN_Sf3G2G :: FilePath -> Int -> Int -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->+ ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO () overSoXSynthGen2FDN_Sf3G2G file m ku f y t0 zs wws h ys = do   n <- duration1000 file   vecA <- freqsFromFile file n

@@ -72,15 +72,15 @@ import System.Directory import DobutokO.Sound.IntermediateF --- | Is used to represent a sequence of intervals, each note being a 'Double' value (its frequency in Hz).-type SoundsO = V.Vector (Double, Double)+-- | Is used to represent a sequence of intervals, each note being a 'Float' value (its frequency in Hz).+type SoundsO = V.Vector (Float, Float) --- | Is used to represent a set of overtones for the single sound, the first 'Double' value is a frequency and the second one -- an amplitude.-type OvertonesO = V.Vector (Double, Double)+-- | Is used to represent a set of overtones for the single sound, the first 'Float' value is a frequency and the second one -- an amplitude.+type OvertonesO = V.Vector (Float, Float) --- | Is used to represent a set of pairs of notes for each element of which the 'Double' values (notes frequencies in Hz) are somewhat+-- | Is used to represent a set of pairs of notes for each element of which the 'Float' values (notes frequencies in Hz) are somewhat -- musically connected one with another..-type NotePairs = V.Vector (Double, Double)+type NotePairs = V.Vector (Float, Float)  -- | Gets 'V.Vector' of 'Int' frequencies from the given 'FilePath' using SoX. The frequencies are \"rough\" according to the SoX documentation and -- the duration is too small so they can be definitely other than expected ones. Is used as a source of variable numbers (somewhat close each to another@@ -169,13 +169,13 @@ partialTest_k :: OvertonesO -> Int -> String -> IO () partialTest_k vec k ts = partialTest_k2G vec k ts V.empty [] --- | Generalized version of the 'partialTest_k' with the additional volume adjustment in dB given by 'V.Vector' of 'Double'.-partialTest_k1G :: OvertonesO -> Int -> String -> V.Vector Double -> IO ()+-- | Generalized version of the 'partialTest_k' with the additional volume adjustment in dB given by 'V.Vector' of 'Float'.+partialTest_k1G :: OvertonesO -> Int -> String -> V.Vector Float -> IO () partialTest_k1G vec k ts vdB = partialTest_k2G vec k ts vdB []  -- | Generalized version of the 'partialTest_k1G' with a possibility to change sound quality parameters using the additional second 'String' argument. -- For more information, please, refer to 'soxBasicParams'.-partialTest_k2G :: OvertonesO -> Int -> String -> V.Vector Double -> String -> IO ()+partialTest_k2G :: OvertonesO -> Int -> String -> V.Vector Float -> String -> IO () partialTest_k2G vec k ts vdB ys =   let zeroN = numVZeroesPre vec in V.imapM_ (\i (noteN, !amplN) -> if i /= 0 && i `rem` 50 == 0     then do@@ -202,19 +202,19 @@  -- | Function to get from the number of semi-tones and a note a 'Maybe' note for the second lower note in the interval if any. If there is -- no need to obtain such a note, then the result is 'Nothing'.-dNote :: Int -> Double -> Maybe Double+dNote :: Int -> Float -> Maybe Float dNote n note   | n == 0 || compare note (V.unsafeIndex notes 0) == LT || compare note (V.unsafeIndex notes 107) == GT = Nothing   | otherwise = Just (note / 2 ** (fromIntegral n / 12))  -- | 'V.Vector' of musical notes in Hz.-notes :: V.Vector Double+notes :: V.Vector Float -- notes V.! 57 = 440.0   -- A4 in Hz notes = V.generate 108 (\t ->  440 * 2 ** (fromIntegral (t - 57) / 12))  -- | Function returns either the nearest two musical notes if frequency is higher than one for C0 and lower than one for B8 -- or the nearest note duplicated in a tuple.-neighbourNotes :: Double -> V.Vector Double -> (Double, Double)+neighbourNotes :: Float -> V.Vector Float -> (Float, Float) neighbourNotes x v   | compare x (V.unsafeIndex v 0) /= GT = (V.unsafeIndex v 0, V.unsafeIndex v 0)   | compare x (V.unsafeIndex v (V.length v - 1)) /= LT = (V.unsafeIndex v (V.length v - 1), V.unsafeIndex v (V.length v - 1))@@ -224,7 +224,7 @@   | otherwise = (V.unsafeIndex v 0, V.unsafeIndex v (V.length v - 1))  -- | Returns the closest note to the given frequency in Hz.  -closestNote :: Double -> Double+closestNote :: Float -> Float closestNote x  | compare x 0.0 == GT =     let (x0, x2) = neighbourNotes x notes@@ -253,14 +253,14 @@ numVZeroesPre v = fromMaybe (0 :: Int) (nOfZeroesLog . V.length $ v) {-# INLINE numVZeroesPre #-}       --- | Similarly to 'liftInOctaveV' returns a 'V.Vector' 'Double' (actually frequencies) for the n-th elements set of notes (see 'nkyT') instead of octaves.+-- | Similarly to 'liftInOctaveV' returns a 'V.Vector' 'Float' (actually frequencies) for the n-th elements set of notes (see 'nkyT') instead of octaves. -- A second 'Int' parameter defines that @n@. -liftInEnkuV :: Int -> Int -> V.Vector Double -> V.Vector Double+liftInEnkuV :: Int -> Int -> V.Vector Float -> V.Vector Float liftInEnkuV n ku = V.mapMaybe (liftInEnku n ku)  -- | Similarly to 'liftInOctave' returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). -- A second 'Int' parameter defines that @n@. Not all pairs return 'Just' @x@. -liftInEnku :: Int -> Int -> Double -> Maybe Double+liftInEnku :: Int -> Int -> Float -> Maybe Float liftInEnku n ku x   | compare n 0 == LT || compare n ((108 `quot` ku) - 1) == GT = Nothing   | getBFst' (False, V.fromList . zip [2,3,4,6,9,12] $ repeat True) ku && compare (closestNote x) 24.4996 == GT =@@ -280,7 +280,7 @@  -- | Similarly to 'whichOctave' returns a 'Maybe' number (actually frequency) for the n-th elements set of notes (see 'nkyT'). -- An 'Int' parameter defines that @n@.-whichEnka :: Int -> Double -> Maybe Int+whichEnka :: Int -> Float -> Maybe Int whichEnka n x   | getBFst' (False,V.fromList . zip [2,3,4,6,9,12] $ repeat True) n && compare (closestNote x) 24.4996 == GT = (\t ->      case isJust t of @@ -292,14 +292,14 @@   | otherwise = Nothing  -- | Returns an analogous note in the higher n-th elements set (its frequency in Hz) (see 'nkyT'). An 'Int' parameter defines this @n@.-enkuUp  :: Int -> Double -> Double+enkuUp  :: Int -> Float -> Float enkuUp n x   | getBFst' (False, V.fromList . zip [2..11] $ repeat True) n = 2 ** (fromIntegral n / 12) * x   | otherwise = 2 * x {-# INLINE enkuUp #-}    -- | Returns an analogous note in the lower n-th elements set (its frequency in Hz) (see 'nkyT'). An 'Int' parameter defines this @n@.-enkuDown  :: Int -> Double -> Double+enkuDown  :: Int -> Float -> Float enkuDown n x   | getBFst' (False, V.fromList . zip [2..11] $ repeat True) n = 2 ** (fromIntegral (-n) / 12) * x   | otherwise = x / 2@@ -322,7 +322,7 @@ -- | For the given frequency it generates a musical sound with a timbre. The main component of the sound includes the lower pure quint, -- which can be in the same octave or in the one with the number lower by one. Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten.-overSoXSynth :: Double -> IO ()+overSoXSynth :: Float -> IO () overSoXSynth x = do   let note0 = if x /= 0.0 then closestNote (abs x) else V.unsafeIndex notes 0       note1 = pureQuintNote note0@@ -338,12 +338,12 @@   mixTest   -- | Returns a pure quint lower than the given note.-pureQuintNote :: Double -> Double+pureQuintNote :: Float -> Float pureQuintNote x = x / 2 ** (7 / 12) {-# INLINE pureQuintNote #-}  -- | For the given frequency of the note it generates a 'V.Vector' of the tuples, each one of which contains the harmonics' frequency and amplitude.-overTones :: Double -> OvertonesO+overTones :: Float -> OvertonesO overTones note =   V.takeWhile (\(!w,!z) -> compare w (V.unsafeIndex notes 107) /= GT && compare (abs z) 0.001 == GT) . V.zip (V.generate 1024 (\i ->     note * fromIntegral (i + 2))) $ (V.generate 1024 (\i -> 1 / fromIntegral ((i + 1) * (i + 1))))@@ -351,7 +351,7 @@ -- | Function can be used to determine to which octave (in the American notation for the notes, this is a number in the note written form, -- e. g. for C4 this is 4) the frequency belongs (to be more exact, the closest note for the given frequency -- see 'closestNote' taking into account -- its lower pure quint, which can lay in the lower by 1 octave). If it is not practical to determine the number, then the function returns 'Nothing'.-whichOctave :: Double -> Maybe Int+whichOctave :: Float -> Maybe Int whichOctave x   | compare (closestNote x) 24.4996 == GT = (\t ->      case isJust t of @@ -363,7 +363,7 @@   | otherwise = Nothing  -- | Generalized version of the 'whichOctave'.-whichOctaveG :: Double -> Maybe Int+whichOctaveG :: Float -> Maybe Int whichOctaveG x    | compare (closestNote x) (V.unsafeIndex notes 0) == GT && compare x (V.unsafeIndex notes 107) /= GT = (\t ->      case isJust t of @@ -374,8 +374,8 @@        _    -> Just 8) . V.findIndex (\(t1, _) -> compare (closestNote x) t1 == LT) $ octavesT   | otherwise = Nothing --- | Is used internally in the 'readProcessWithExitCode' to adjust volume for the sound with additional dB value given by 'Double' argument.-adjust_dbVol :: [String] -> Double -> [String]+-- | Is used internally in the 'readProcessWithExitCode' to adjust volume for the sound with additional dB value given by 'Float' argument.+adjust_dbVol :: [String] -> Float -> [String] adjust_dbVol xss y  | y == 0.0 = xss  | otherwise = xss ++ ["vol",showFFloat Nothing y "dB"]

@@ -53,8 +53,8 @@       else V.map (\(x,y) -> (x, y / (snd . V.unsafeIndex v1 $ 0))) v1  -- | Renormalizes amplitudes for the frequencies so that the maximum one of them (if 'OvertonesO' is not 'V.empty') is equal by the absolute value--- to 'Double' argument and the mutual ratios of the amplitudes are preserved.-renormFD :: Double -> OvertonesO -> OvertonesO+-- to 'Float' argument and the mutual ratios of the amplitudes are preserved.+renormFD :: Float -> OvertonesO -> OvertonesO renormFD ampl0 v  | V.null v = V.empty  | otherwise =@@ -69,55 +69,55 @@  | otherwise = V.all (\(x,_) -> x == (fst . V.unsafeIndex v $ 0)) v  -- | Similar to 'sameOvertone', except that not the 'V.Vector' is checked but a corresponding list.-sameOvertoneL :: [(Double,Double)] -> Bool+sameOvertoneL :: [(Float,Float)] -> Bool sameOvertoneL xs@((x,_):_) = all (\(xn,_) -> xn == x) xs sameOvertoneL _ = False --- | @g :: (Double,Double) -> OvertonesO -> OvertonesO@ is a function that defines how the new element is added to the 'OvertonesO'. It depends--- only on the element being added and the actual 'OvertonesO'. It does not depend on the 'Double' argument for @f :: Double -> OvertonesO@--- so for different 'Double' for @f@ it gives the same result.-sameFreqF :: Double -> (Double,Double) -> (Double -> OvertonesO) -> ((Double,Double) -> OvertonesO -> OvertonesO) -> OvertonesO+-- | @g :: (Float,Float) -> OvertonesO -> OvertonesO@ is a function that defines how the new element is added to the 'OvertonesO'. It depends+-- only on the element being added and the actual 'OvertonesO'. It does not depend on the 'Float' argument for @f :: Float -> OvertonesO@+-- so for different 'Float' for @f@ it gives the same result.+sameFreqF :: Float -> (Float,Float) -> (Float -> OvertonesO) -> ((Float,Float) -> OvertonesO -> OvertonesO) -> OvertonesO sameFreqF freq (noteN0,amplN0) f g = g (noteN0,amplN0) (f freq) --- | @g :: (Double,Double) -> OvertonesO -> OvertonesO@ is a function that defines how the new element is added to the 'OvertonesO'.+-- | @g :: (Float,Float) -> OvertonesO -> OvertonesO@ is a function that defines how the new element is added to the 'OvertonesO'. -- Variant of 'sameFreqF' where g depends only on the elements of the 'OvertonesO', which first elements in the tuples equal to the first element--- in the @(Double,Double)@. It does not depend on the 'Double' argument for @f :: Double -> OvertonesO@--- so for different 'Double' for @f@ it gives the same result.-sameFreqFI :: Double -> (Double,Double) -> (Double -> OvertonesO) -> ((Double,Double) -> OvertonesO -> OvertonesO) -> OvertonesO+-- in the @(Float,Float)@. It does not depend on the 'Float' argument for @f :: Float -> OvertonesO@+-- so for different 'Float' for @f@ it gives the same result.+sameFreqFI :: Float -> (Float,Float) -> (Float -> OvertonesO) -> ((Float,Float) -> OvertonesO -> OvertonesO) -> OvertonesO sameFreqFI freq (noteN0,amplN0) f g = g (noteN0,amplN0) . V.filter (\(x,_) -> x == noteN0) $ f freq --- | @gAdd :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO@ is a function that defines how the element is added+-- | @gAdd :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO@ is a function that defines how the element is added -- to the 'OvertonesO'. 'fAddFElem' is  -- actually a higher-order function, it changes the function @f@ and returns a new one. It can be an interesting task  -- (in general) to look at such a function through a prism of notion of operator (mathematical, for example similar to that ones that  -- are used for quantum mechanics and quantum field theory).  -- @gAdd@ allows not only to insert an element if missing, but to change all the 'OvertonesO' system. So depending on the complexity, -- it can produce rather complex behaviour.-fAddFElem :: (Double, Double) -> (Double -> OvertonesO) -> ((Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO) ->-  (Double -> OvertonesO)+fAddFElem :: (Float, Float) -> (Float -> OvertonesO) -> ((Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO) ->+  (Float -> OvertonesO) fAddFElem (noteN, amplN) f gAdd t = gAdd (noteN, amplN) t f --- | @gRem:: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO@ is a function that defines how the element is removed+-- | @gRem:: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO@ is a function that defines how the element is removed -- from the 'OvertonesO'. 'fRemoveFElem' is -- actually a higher-order function, it changes the function @f@ and returns a new one. It can be an interesting task  -- (in general) to look at such a function through a prism of notion of operator (mathematical, for example that ones that are used  -- for quantum mechanics and quantum field theory).  -- @gRem@ allows not only to delete an element if existing, but to change all the 'OvertonesO' system. So depending on the complexity, -- it can produce rather complex behaviour.-fRemoveFElem :: (Double, Double) -> (Double -> OvertonesO) -> ((Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO) -> -  (Double -> OvertonesO)+fRemoveFElem :: (Float, Float) -> (Float -> OvertonesO) -> ((Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO) -> +  (Float -> OvertonesO) fRemoveFElem (noteN, amplN) f gRem t = gRem (noteN, amplN) t f  -- | Changes elements of the 'OvertonesO' using two functions. It is a generalization of the 'fAddFElem' and 'fRemoveFElem' functions. For example, if the first  -- of the two inner functional arguments acts as 'gAdd01' or similar, then it adds element to the 'OvertonesO', if it acts as 'gRem01', then it removes the element. --- Its behaviour is defined by the 'Double' parameter (meaning frequency, probably), so you can change elements depending on what point it is applied.-fChangeFElem :: (Double, Double) -> Double -> (Double -> ((Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO)) -> (Double -> OvertonesO) -> -  (Double -> OvertonesO)+-- Its behaviour is defined by the 'Float' parameter (meaning frequency, probably), so you can change elements depending on what point it is applied.+fChangeFElem :: (Float, Float) -> Float -> (Float -> ((Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO)) -> (Float -> OvertonesO) -> +  (Float -> OvertonesO) fChangeFElem (noteN, amplN) freq h f t = (h freq) (noteN, amplN) t f  -- | Example of the function gAdd for the 'fAddFElem'. If the frequency is already in the 'OvertonesO' then the corresponding amplitude is divided--- equally between all the elements with the repeated given frequency from @(Double, Double)@. Otherwise, it is just concatenated to the 'OvertonesO'.-gAdd01 :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+-- equally between all the elements with the repeated given frequency from @(Float, Float)@. Otherwise, it is just concatenated to the 'OvertonesO'.+gAdd01 :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gAdd01 (note,ampl) freq f   | V.null . f $ freq = V.singleton (note,ampl)  | otherwise =@@ -128,14 +128,14 @@  -- | Can be used to produce an example of the function @gAdd@ for the 'fAddFElem'. Similar to 'gAdd01', but uses its first argument -- to renorm the result of the 'gAdd01' so that its maximum by absolute value amplitude equals to the first argument.-gAdd02 :: Double -> (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+gAdd02 :: Float -> (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gAdd02 amplMax (note,ampl) freq = renormFD amplMax . gAdd01 (note,ampl) freq  -- | Example of the function @gAdd@. for the 'fAddFElem'. If the frequency is not already in the 'OvertonesO' then the corresponding element is added and -- the 'OvertonesO' are renormed with 'renormF'. Otherwise, the element is tried to be inserted with a new frequency between the greatest by an absolute -- values notes as an intermediate value with the respective amplitude, or if there is only one element, to produce two elements in -- the resulting 'V.Vector' with two consequent harmonics.-gAdd03 :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+gAdd03 :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gAdd03 (note,ampl) freq f   | V.null . f $ freq = V.singleton (note,ampl)  | otherwise =@@ -152,7 +152,7 @@ -- | Example of the function gRem for the 'fRemoveFElem'. If the element is already in the 'OvertonesO' then it is removed (if there are more than 5 -- elements already) and 'OvertonesO' are renormalized. Otherwise, all the same for the element already existing elements become less in an amlitude -- for a numbers that in sum equal to amplitude of the removed element.-gRem01 :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+gRem01 :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gRem01 (note,ampl) freq f   | V.null . f $ freq = V.empty   | otherwise =@@ -165,23 +165,23 @@  -- | Can be used to produce an example of the function @gRem@ for the 'fRemoveFElem'. Similar to 'gRem01', but uses its first argument -- to renorm the result of the 'gRem01' so that its maximum by absolute value amplitude equals to the first argument.-gRem02 :: Double -> (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+gRem02 :: Float -> (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gRem02 amplMax (note,ampl) freq = renormFD amplMax . gAdd01 (note,ampl) freq --- | Similar to 'fAddFElem', but instead of one element @(Double,Double)@ it deals with a 'V.Vector' of such elements that is 'OvertonesO'. -fAddFElems :: OvertonesO -> (Double -> OvertonesO) -> (OvertonesO -> Double -> (Double -> OvertonesO) -> OvertonesO) ->-  (Double -> OvertonesO)+-- | Similar to 'fAddFElem', but instead of one element @(Float,Float)@ it deals with a 'V.Vector' of such elements that is 'OvertonesO'. +fAddFElems :: OvertonesO -> (Float -> OvertonesO) -> (OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO) ->+  (Float -> OvertonesO) fAddFElems v f gAdds t = gAdds v t f --- | Similar to 'fRemoveFElem', but instead of one element @(Double,Double)@ it deals with a 'V.Vector' of such elements that is 'OvertonesO'. -fRemoveFElems :: OvertonesO -> (Double -> OvertonesO) -> (OvertonesO -> Double -> (Double -> OvertonesO) -> OvertonesO) -> -  (Double -> OvertonesO)+-- | Similar to 'fRemoveFElem', but instead of one element @(Float,Float)@ it deals with a 'V.Vector' of such elements that is 'OvertonesO'. +fRemoveFElems :: OvertonesO -> (Float -> OvertonesO) -> (OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO) -> +  (Float -> OvertonesO) fRemoveFElems v f gRems t = gRems v t f  -- | Similar to 'fChangeFElem', but use another form of the changing function, so it can deal with not only single element of the 'OvertonesO',  -- but also with several ones.-fChangeFElems :: OvertonesO -> Double -> (Double -> (OvertonesO -> Double -> (Double -> OvertonesO) -> OvertonesO)) -> (Double -> OvertonesO) -> -  (Double -> OvertonesO)+fChangeFElems :: OvertonesO -> Float -> (Float -> (OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO)) -> (Float -> OvertonesO) -> +  (Float -> OvertonesO) fChangeFElems v freq h f t = (h freq) v t f  -- | Binary predicate to check whether two given 'OvertonesO' both have the elements with the same first element in the tuples. If 'True' then@@ -207,7 +207,7 @@               [l1,l2]  = map V.length [v13,v23] in compare (V.length . V.uniq . V.fromList . sort . V.toList . V.concat $ [v13,v23]) (l1 + l2) == LT  -- | Example of the function @gAdds@ for the 'fAddFElems'. -gAdds01 :: OvertonesO -> Double -> (Double -> OvertonesO) -> OvertonesO+gAdds01 :: OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO gAdds01 v0 freq f   | V.null . f $ freq = v0  | freqsOverlapOvers v0 (f freq) =@@ -224,11 +224,11 @@  -- | Can be used to produce an example of the function @gAdds@ for the 'fAddFElems'. Similar to 'gAdds01', but uses its first argument -- to renorm the result of the 'gAdds01' so that its maximum by absolute value amplitude equals to the first argument.-gAdds02 :: Double -> OvertonesO -> Double -> (Double -> OvertonesO) -> OvertonesO+gAdds02 :: Float -> OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO gAdds02 amplMax v0 freq = renormFD amplMax . gAdds01 v0 freq --- | Example of the function @gAdd@. for the 'fAddFElem'. It tries to insert the given ('Double','Double') into the less dense frequency region.-gAdd04 :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+-- | Example of the function @gAdd@. for the 'fAddFElem'. It tries to insert the given ('Float','Float') into the less dense frequency region.+gAdd04 :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gAdd04 (note,ampl) freq f   | V.null . f $ freq = V.singleton (note,ampl)  | otherwise =@@ -238,9 +238,9 @@         newFreq = (fst (V.unsafeIndex v1 (idxMax + 1)) + fst (V.unsafeIndex v1 idxMax)) / 2 in (newFreq,ampl) `V.cons` v1  -- | Example of the function @gRem@ for the 'fRemFElem'. It tries not to remove elements from the less than 6 elements 'OvertonesO' and to remove--- all the elements in the given range with the width of the twice as many as the second 'Double' in the first argument tuple and the centre--- in the first 'Double' in the tuple. Similar to somewhat bandreject filter but with more complex behaviour for the sound to be more complex.-gRem03 :: (Double,Double) -> Double -> (Double -> OvertonesO) -> OvertonesO+-- all the elements in the given range with the width of the twice as many as the second 'Float' in the first argument tuple and the centre+-- in the first 'Float' in the tuple. Similar to somewhat bandreject filter but with more complex behaviour for the sound to be more complex.+gRem03 :: (Float,Float) -> Float -> (Float -> OvertonesO) -> OvertonesO gRem03 (note,halfwidth) freq f =  let v1 = V.filter (\(x,_) -> compare (abs (x - note)) halfwidth /= GT) . f $ freq in    if compare (V.length v1) 5 /= GT then renormF . V.generate 5 $ (\i -> (fromIntegral (i + 1) * note, halfwidth / fromIntegral (i + 3))) 

@@ -56,7 +56,7 @@   , soundGenF32G   , helpF0   , helpF1-  , doubleVecFromVecOfDouble+  , doubleVecFromVecOfFloat ) where  import CaseBi (getBFst')@@ -83,10 +83,10 @@  -- | Is used to represent a set of durations parameters of the sounds and pauses. The positive value corresponds to the sound  -- and the negative one -- to the pause.-type Durations = V.Vector Double+type Durations = V.Vector Float  -- | Is used to represent a set of volumes in the amplitude scale for SoX \"vol\" effect.-type Strengths = V.Vector Double+type Strengths = V.Vector Float  -- | Is used to represent a set of intervals for notes (each element is a number of semi-tones between parts of interval).  -- Positive values corresponds to lower notes and negative to higher ones.@@ -108,8 +108,8 @@   -- | Generalized version of the 'overSoXSynthGen2FDN_SG4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_SG4GPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> Durations -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_SG4GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Durations -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_SG4GPar file params f y v2 wws h = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -121,8 +121,8 @@     -- | Generalized version of the 'overSoXSynthGen2FDN_SG6G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_SG6GPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> Durations -> String -> -  ((Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()) -> Strengths -> Double -> IO ()+overSoXSynthGen2FDN_SG6GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Durations -> String -> +  ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Strengths -> Float -> IO () overSoXSynthGen2FDN_SG6GPar file params f y v2 wws h v6 limV  | V.null v6 = putStrLn "You did not provide a volume adjustments vector! "  | otherwise = do@@ -137,8 +137,8 @@  -- | Generalized version of the 'overSoXSynthGen2FDN_SG2G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_SG2GPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> String -> String -> ((Double -> OvertonesO) ->-  (Double, Double) -> Int -> String -> String -> IO ()) -> String -> IO ()+overSoXSynthGen2FDN_SG2GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> String -> String -> ((Float -> OvertonesO) ->+  (Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO () overSoXSynthGen2FDN_SG2GPar file params f y zs wws h ys = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -152,7 +152,7 @@  -- | Generalized version of the 'overSoXSynthGen2FDN_Sf' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_SfPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> String -> String -> IO ()+overSoXSynthGen2FDN_SfPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> String -> String -> IO () overSoXSynthGen2FDN_SfPar file params f y zs wws = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -165,8 +165,8 @@      -- | Generalized version of the 'overSoXSynthGen2FDN_Sf3G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_Sf3GPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> Double -> String -> String ->- ((Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> IO ()) -> IO ()+overSoXSynthGen2FDN_Sf3GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->+ ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO ()) -> IO () overSoXSynthGen2FDN_Sf3GPar file params f y t0 zs wws h = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -179,8 +179,8 @@  -- | Generalized version of the 'overSoXSynthGen2FDN_Sf3G2G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthGen2FDN_Sf3G2GPar :: FilePath -> Params -> (Double -> OvertonesO) -> Double -> Double -> String -> String ->- ((Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> String -> IO ()) -> String -> IO ()+overSoXSynthGen2FDN_Sf3G2GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Float -> String -> String ->+ ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO () overSoXSynthGen2FDN_Sf3G2GPar file params f y t0 zs wws h ys = do   n <- duration1000 file   vecA <- freqsFromFile file n@@ -192,7 +192,7 @@           then ".flac" else ".wav") vecB   endFromResult2G ys     --- | A way to get from a 'Params' a corresponding 'V.Vector' of 'Double' (if any) and so to work with them further. May contain some issues +-- | A way to get from a 'Params' a corresponding 'V.Vector' of 'Float' (if any) and so to work with them further. May contain some issues  -- so please, before production usage check thoroughly.  -- For information there were used the following:  -- @@ -210,7 +210,7 @@ -- Смаглій Г., Маловик Л. Теорія музики : Підруч. для навч. закл. освіти, культури і мистецтв / Г.А. Смаглій. -- Х. : Вид-во \"Ранок\", 2013. -- 392 с.  -- ISBN 978-617-09-1294-7 -- -filterInParams :: Params -> Maybe (V.Vector Double)+filterInParams :: Params -> Maybe (V.Vector Float) filterInParams (P3lf n2 nL zs) -- generalized sound series, e. g. the chromatic ones etc.  | all (\n -> compare n 0 /= LT) ([nL,107 - nL - n2,n2 - 2] ++ zs) =      if V.null . V.ifilter (\i _ -> getBFst' (False,V.fromList . zip (sortNoDup . filter (< n2) $ zs) $ replicate n2 True) i) $ @@ -222,13 +222,13 @@ filterInParams (P32sf nT n2 nL xs ys) -- dur and moll in various their modifications  | all (\n -> compare n 0 /= LT) [107 - nL - n2,nT,nL,nT - nL,nL + n2 - nT,n2 - 12] =      case xs of -      "dur" -> getBFst' (Nothing,V.fromList . zip ["DoubleH","H","Full","Full moll","M","N"] $ fmap Just +      "dur" -> getBFst' (Nothing,V.fromList . zip ["FloatH","H","Full","Full moll","M","N"] $ fmap Just          [V.ifilter (\i _ -> toneD i nL nT [2,3,6,8,10]) (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> toneD i nL nT [1,3,5,9,10])            (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> ((nL + i - nT + (((nT - nL) `quot` 12) + 1) * 12) `rem` 12) `notElem` [1,3,5])              (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> ((nL + i - nT + (((nT - nL) `quot` 12) + 1) * 12) `rem` 12) `notElem` [1,6])                (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> toneD i nL nT [1,3,5,9,11]) (V.unsafeSlice nL n2 notes),                  V.ifilter (\i _ -> toneD i nL nT [1,3,5,8,10]) (V.unsafeSlice nL n2 notes)]) ys-      "moll" -> getBFst' (Nothing,V.fromList . zip ["DoubleH1","H","Full","Full dur","M","N"] $ fmap Just +      "moll" -> getBFst' (Nothing,V.fromList . zip ["FloatH1","H","Full","Full dur","M","N"] $ fmap Just          [V.ifilter (\i _ -> toneD i nL nT [1,4,5,9,10]) (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> toneD i nL nT [1,4,6,9,10])            (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> ((nL + i - nT + (((nT - nL) `quot` 12) + 1) * 12) `rem` 12) `notElem` [1,4,6])              (V.unsafeSlice nL n2 notes), V.ifilter (\i _ -> ((nL + i - nT + (((nT - nL) `quot` 12) + 1) * 12) `rem` 12) `notElem` [1,6]) @@ -315,7 +315,7 @@         [2,4,7,9,11], [1,3,5,8,10], [1,3,6,8,11], [2,4,6,9,11]]) xs  | otherwise = Nothing -h3 :: Int -> Int -> Int -> [Int] -> Maybe (V.Vector Double)+h3 :: Int -> Int -> Int -> [Int] -> Maybe (V.Vector Float) h3 nT n2 nL zs   | nT == nL = Just (V.ifilter (\i _ -> toneD i nL nT zs) (V.unsafeSlice nL n2 notes))  | otherwise = Nothing@@ -344,7 +344,7 @@  -- | Analogous to 'liftInEnku' lifts a frequency into a tonality (or something that can be treated alike one) specified by 'Params'. If not  -- reasonably one exists then the result is 11440 (Hz).-liftInParams :: Double -> Params -> Double+liftInParams :: Float -> Params -> Float liftInParams x params   | lengthP params == 0 || (isNothing . whichOctaveG $ x) = 11440.0   | otherwise = @@ -352,20 +352,20 @@       (\i -> V.unsafeIndex notes (12 * fromJust (whichOctaveG x)) * 2 ** (fromIntegral i / fromIntegral (lengthP params))))  -- | Application of the 'liftInParams' to a 'V.Vector'. -liftInParamsV :: Params -> V.Vector Double -> V.Vector Double+liftInParamsV :: Params -> V.Vector Float -> V.Vector Float liftInParamsV params = V.filter (/= 11440.0) . V.map (\x -> liftInParams x params) --- | Gets a length of the 'V.Vector' of 'Double' being represented as 'Params'. This is a number of the notes contained in the 'Params'.+-- | Gets a length of the 'V.Vector' of 'Float' being represented as 'Params'. This is a number of the notes contained in the 'Params'. lengthP :: Params -> Int lengthP = fromMaybe 0 . fmap V.length . filterInParams --- | Check whether a given 'Double' value (frequency of a note) is in the vector of Doubles that corresponds to the given 'Params'.-elemP :: Double -> Params -> Bool+-- | Check whether a given 'Float' value (frequency of a note) is in the vector of Floats that corresponds to the given 'Params'.+elemP :: Float -> Params -> Bool elemP note = fromMaybe False . fmap (note `V.elem`) . filterInParams --- | Check whether a given 'Double' value (frequency of the closest note to the given frequency) is in the vector of Doubles that +-- | Check whether a given 'Float' value (frequency of the closest note to the given frequency) is in the vector of Floats that  -- corresponds to the given 'Params'.-elemCloseP :: Double -> Params -> Bool+elemCloseP :: Float -> Params -> Bool elemCloseP note = fromMaybe False . fmap (closestNote note `V.elem`) . filterInParams  -- | A way to show not the (somewhat algebraic) structure of the 'Params' (as the usual 'show' does), but the contained frequencies in it. @@ -388,18 +388,18 @@ isListParams xs (P3lf x y zs) = if isJust (filterInParams (P3lf x y zs)) then xs == zs else False isListParams _ _ = False --- | Generates melody for the given parameters. The idea is that every application of the function @f :: Double -> OvertonesO@ to its argument --- possibly can produce multiple overtones being represented as 'V.Vector' of tuples of pairs of 'Double'. We can use the first element in the --- tuple to obtain a new sound parameters and the second one -- to obtain its new duration in the melody. Additional function @g :: Double -> Double@ +-- | Generates melody for the given parameters. The idea is that every application of the function @f :: Float -> OvertonesO@ to its argument +-- possibly can produce multiple overtones being represented as 'V.Vector' of tuples of pairs of 'Float'. We can use the first element in the +-- tuple to obtain a new sound parameters and the second one -- to obtain its new duration in the melody. Additional function @g :: Float -> Float@  -- is used to avoid the effect of becoming less and less -- closer to the zero for the higher overtones so the durations will become also less.  -- Besides it allows to rescale the durations in a much more convenient way.  -- --- The first 'Double' parameter is a multiplication coefficient to increase or to decrease the durations (values with an absolute values greater than +-- The first 'Float' parameter is a multiplication coefficient to increase or to decrease the durations (values with an absolute values greater than  -- one correspond to increasing inside the @g@. function applied afterwards with function composition and the values with an absolute values less  -- than one and not equal to zero correspond to decreasing inside the @g@ function. --- The second 'Double' parameter is a usual frequency which is used instead of the 11440.0 (Hz) value. --- The third 'Double' parameter is a main argument -- the frequency for which the 'OvertonesO' are generated as a first step of the computation. -overMeloPar :: (Double -> OvertonesO) -> (Double -> Double) -> Params -> Double -> Double -> Double -> IO ()+-- The second 'Float' parameter is a usual frequency which is used instead of the 11440.0 (Hz) value. +-- The third 'Float' parameter is a main argument -- the frequency for which the 'OvertonesO' are generated as a first step of the computation. +overMeloPar :: (Float -> OvertonesO) -> (Float -> Float) -> Params -> Float -> Float -> Float -> IO () overMeloPar f g params coeff freq0 freq = do    let v = f freq       vFreqs = V.map ((\z -> if z == 11440.0 then freq0 else z) . flip liftInParams params . fst) v@@ -423,19 +423,19 @@ -- | A default way to get 'Durations' for the sounds up to 0.35.2.0 version of the package including. It is based on the number of Ukrainian  -- sounds representations (see, 'convertToProperUkrainian') in a Ukrainian syllables or somewhat generated by the same rules as they.  -- The rhythm using the function is very often not binary but its ratios are almost always a ratios of the small natural numbers (1, 2, 3, 4, 5, 6, 7 etc.).-str2DurationsDef :: Int -> String -> Double -> Durations+str2DurationsDef :: Int -> String -> Float -> Durations str2DurationsDef n zs y =    let (t, ws) = splitAt 1 . syllableStr n $ zs in V.map (\yy -> y * fromIntegral (yy * length ws) / fromIntegral (head t)) . V.fromList $ ws    -apply6GSilentFile :: FilePath -> Double -> Double -> IO ()+apply6GSilentFile :: FilePath -> Float -> Float -> IO () apply6GSilentFile file limV vol = do   upp <- upperBnd file-  ampL2 <- fmap ((\zz -> read zz::Double) . fst) (selMaxAbs file (0,upp))+  ampL2 <- fmap ((\zz -> read zz::Float) . fst) (selMaxAbs file (0,upp))   if compare (abs ampL2) (abs limV) /= GT then putStr ""   else apply6Gf vol file  -- | Apply volume adjustment to the sound file. It must not be silent. Otherwise, it leads to likely noise sounding or errors.-apply6Gf :: Double -> FilePath -> IO ()+apply6Gf :: Float -> FilePath -> IO () apply6Gf vol file = soxE file ["norm","vol", showFFloat (Just 4) vol ""]    -- | Function is used to generate a rhythm of the resulting file \'end.wav\' from the Ukrainian text and a number of sounds either in the syllables or in the words without vowels.@@ -455,23 +455,23 @@ -- 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_Sf'.-overSoXSynth2FDN_Sf :: (Double -> OvertonesO) -> (Double, Double) -> Int -> String -> IO ()+overSoXSynth2FDN_Sf :: (Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO () overSoXSynth2FDN_Sf f (x, y) = overSoXSynth2FDN_Sf3 f (x, y, 0.001)  -- | Similar to 'overSoXSynth2FDN_S' but additionally the program filters out from the resulting 'V.Vector' after \"f\" application values that are smaller--- than the third 'Double' parameter by an absolute value in the triple of @Double@'s. An 'Int' parameter is used to define an interval. To obtain compatible+-- than the third 'Float' parameter by an absolute value in the triple of @Float@'s. 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_Sf3'.-overSoXSynth2FDN_Sf3 :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> IO ()+overSoXSynth2FDN_Sf3 :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO () overSoXSynth2FDN_Sf3 f (x, y, t0) j zs = overSoXSynth2FDN_Sf32G f (x, y, t0) j zs V.empty []  -- | 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_Sf32G :: (Double -> OvertonesO) -> (Double, Double, Double) -> Int -> String -> V.Vector Double -> String -> IO ()+overSoXSynth2FDN_Sf32G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> V.Vector Float -> String -> IO () overSoXSynth2FDN_Sf32G f (x, y, t0) j zs vdB ys  | V.null . convertToProperUkrainian $ zs = overSoXSynth x  | otherwise = do@@ -503,12 +503,12 @@  -- | Generalized variant of the 'soundGenF31G' with a possibility to specify sound quality using the 'String' argument. For more information, -- please, refer to 'soxBasicParams'.-soundGenF32G :: V.Vector (Double -> Double) -> V.Vector Double -> V.Vector Int -> (Double -> OvertonesO) -> (Double, Double, Double) -> Int ->-  V.Vector Double -> String -> IO ()+soundGenF32G :: V.Vector (Float -> Float) -> V.Vector Float -> V.Vector Int -> (Float -> OvertonesO) -> (Float, Float, Float) -> Int ->+  V.Vector Float -> String -> IO () soundGenF32G vf vd vi f (x, y, t0) j vdB ys = do   let vD = helpF1 vf vd vi   -- Vector of notes played simultaneously (e. g. just one, interval, accord etc.)       vDz = V.mapMaybe id vD -- The previous one without Nothings and Justs-      vNotes = doubleVecFromVecOfDouble f t0 (V.map Just vDz) -- Vector of vectors of pairs (freq,ampl) -- notes and their absence (V.empty) with overtones+      vNotes = doubleVecFromVecOfFloat f t0 (V.map Just vDz) -- Vector of vectors of pairs (freq,ampl) -- notes and their absence (V.empty) with overtones       ts = showFFloat (Just 4) (abs y) "" -- duration of the sound to be generated   V.imapM_ (\i _ -> do     _ <- readProcessWithExitCode (fromJust (showE "sox")) ((if null ys then id else soxBasicParams ys) ((if V.null vdB @@ -521,7 +521,7 @@   getBFst' ("ZZ0",V.fromList . zip [0..] $ (map (:[]) "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ++ concatMap (\z -> map ((z:) . (:[])) "ABCDEFGHIJKLMNOPQRSTUVWXYZ")      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))  -helpF1 :: V.Vector (Double -> Double) -> V.Vector Double -> V.Vector Int -> V.Vector (Maybe Double)+helpF1 :: V.Vector (Float -> Float) -> V.Vector Float -> V.Vector Int -> V.Vector (Maybe Float) helpF1 vf vd =   V.map (\(f1,x,i2) ->     case i2 of@@ -529,6 +529,6 @@       _ -> Just $ f1 x) . V.zip3 vf vd  -- | Generates a 'V.Vector' of 'OvertonesO' that represents the sound. -doubleVecFromVecOfDouble :: (Double -> OvertonesO) -> Double -> V.Vector (Maybe Double) -> V.Vector OvertonesO-doubleVecFromVecOfDouble f t0 =+doubleVecFromVecOfFloat :: (Float -> OvertonesO) -> Float -> V.Vector (Maybe Float) -> V.Vector OvertonesO+doubleVecFromVecOfFloat f t0 =   V.map (\note1 -> if isNothing note1 then V.empty else V.filter (\(_,!z) -> compare (abs z) t0 == GT) . f . fromJust $ note1)          

@@ -35,8 +35,8 @@  -- | Splits (with addition of the new overtones) a given 'OvertonesO' into a number @n@ (specified by the first 'Int' argument) of 'OvertonesO'  -- (represented finally as a 'V.Vector' of them respectively) so that all except the first @n@ greatest by the absolute value of the amplitude --- tuples of Doubles are considered overtones for the greatest by the absolute value one in the given 'OvertonesO' and all the next @n - 1@ --- are treated as the greatest by the absolute value and each of them produces the similar by the @f :: Double -> OvertonesO@ function overtones.+-- tuples of Floats are considered overtones for the greatest by the absolute value one in the given 'OvertonesO' and all the next @n - 1@ +-- are treated as the greatest by the absolute value and each of them produces the similar by the @f :: Float -> OvertonesO@ function overtones. --  -- It is expected to obtain by such a conversion a splitted one sound into several simultaneous similar ones with different heights.  -- To provide a rich result, the given first argument must be strictly less than the length of the given 'OvertonesO' minus one.@@ -87,7 +87,7 @@  | otherwise = V.singleton v0  -- | Auxiliary function that is used inside 'splitOG1'.-splitHelp1 :: Int -> Int -> Int -> Int -> OvertonesO -> (Double,Double) -> V.Vector OvertonesO+splitHelp1 :: Int -> Int -> Int -> Int -> OvertonesO -> (Float,Float) -> V.Vector OvertonesO splitHelp1 x1 x2 x3 x4 v00 (y5,y6) =    let v2 = V.unsafeSlice x1 x2 v00       v31 = V.map (\t -> (fst t) / y5) v2@@ -97,7 +97,7 @@         in V.map f1Tup (V.unsafeSlice x3 x4 v00)  -- | Auxiliary function that is used inside 'splitOG2'.-splitHelp2 :: (OvertonesO -> OvertonesO) -> Int -> Int -> Int -> Int -> OvertonesO -> (Double,Double) -> V.Vector OvertonesO+splitHelp2 :: (OvertonesO -> OvertonesO) -> Int -> Int -> Int -> Int -> OvertonesO -> (Float,Float) -> V.Vector OvertonesO splitHelp2 h1 x1 x2 x3 x4 v00 (y5,y6) =    let v2 = V.unsafeSlice x1 x2 v00       v31 = V.map (\t -> (fst t) / y5) v2

@@ -23,19 +23,19 @@ import DobutokO.Sound.Functional.Basics  -- | Returns an analogous note in the higher octave (its frequency in Hz).-octaveUp :: Double -> Double+octaveUp :: Float -> Float octaveUp x = 2 * x {-# INLINE octaveUp #-}  -- | Returns an analogous note in the lower octave (its frequency in Hz).-octaveDown :: Double -> Double+octaveDown :: Float -> Float octaveDown x = x / 2 {-# INLINE octaveDown #-}  -- | Function lifts the given frequency to the given number of the octave (in American notation, from 0 to 8). This number is an 'Int' parameter. -- The function also takes into account the lower pure quint for the closest note. -- If it is not practical to determine the number, then the function returns 'Nothing'.-liftInOctave :: Int -> Double -> Maybe Double+liftInOctave :: Int -> Float -> Maybe Float liftInOctave n x   | compare n 0 == LT || compare n 8 == GT = Nothing   | compare (closestNote x) 24.4996 == GT =@@ -53,10 +53,10 @@                      else Just (V.unsafeLast . V.iterateN (fromIntegral z1 + 1) octaveDown $ closestNote x)   | otherwise = Nothing --- | Function lifts the 'V.Vector' of 'Double' representing frequencies to the given octave with the 'Int' number. Better to use numbers in the range [1..8].+-- | Function lifts the 'V.Vector' of 'Float' representing frequencies to the given octave with the 'Int' number. Better to use numbers in the range [1..8]. -- The function also takes into account the lower pure quint for the obtained note behaviour. If it is not practical to determine the octave, the resulting -- frequency is omitted from the resulting 'V.Vector'.-liftInOctaveV :: Int -> V.Vector Double -> V.Vector Double+liftInOctaveV :: Int -> V.Vector Float -> V.Vector Float liftInOctaveV n = V.mapMaybe (liftInOctave n)  --------------------------------------------------------------------------------------------------------------------------------

@@ -88,7 +88,7 @@  -- | For the given frequency of the note and a Ukrainian text it generates a 'V.Vector' of the tuples, each one of which contains -- the harmonics' frequency and amplitude. The 'String' is used to produce the signs for harmonics coefficients.-overTones2 :: Double -> String -> OvertonesO+overTones2 :: Float -> String -> OvertonesO overTones2 note ts =   V.takeWhile (\(!w,!z) -> compare w (V.unsafeIndex notes 107) /= GT && compare (abs z) 0.001 == GT) . V.filter (\(_, t4) -> t4 /= 0.0) .     V.zip (V.generate 1024 (\i -> note * fromIntegral (i + 2))) $ (V.generate 1024 (\i -> fromIntegral (V.unsafeIndex (signsFromString 1024 ts)@@ -97,12 +97,12 @@ -- | Similar to 'overSoXSynth' except that takes not necessarily pure lower quint note as the second one, but the one specified by the 'String' parameter -- as an argument to 'dNote'. If you begin the 'String' with space characters, or \"сь\", or \"ць\", or dash, or apostrophe, or soft sign, than there will -- be no interval and the sound will be solely one with its 'OvertonesO'.-overSoXSynthDN :: Double -> String -> IO ()+overSoXSynthDN :: Float -> String -> IO () overSoXSynthDN x = overSoXSynth2DN x 0.5 --- | Similar to 'overSoXSynthDN' except that the resulting duration is specified by the second 'Double' parameter in seconds. For 'overSoXSynthDN'+-- | Similar to 'overSoXSynthDN' except that the resulting duration is specified by the second 'Float' parameter in seconds. For 'overSoXSynthDN' -- it is equal to 0.5.-overSoXSynth2DN :: Double -> Double -> String -> IO ()+overSoXSynth2DN :: Float -> Float -> String -> IO () overSoXSynth2DN x y zs  | V.null . convertToProperUkrainian $ zs = overSoXSynth x  | otherwise = do@@ -130,7 +130,7 @@ -- which can be in the same octave or in the one with the number lower by one. Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten. -- The 'String' argument is used to define signs of the harmonics coefficients for Overtones.-overSoXSynth2 :: Double -> String -> IO ()+overSoXSynth2 :: Float -> String -> IO () overSoXSynth2 x tts = do   let note0 = closestNote x       note1 = pureQuintNote note0@@ -149,15 +149,15 @@   mixTest   -- | Function to create a melody for the given arguments. 'String' is used to provide a rhythm. The main component of the sound includes the lower pure quint, which--- can be in the same octave or in the one with the number lower by one. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude+-- can be in the same octave or in the one with the number lower by one. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude -- for Overtones. If it is set to 1.0 the overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results--- in their becoming more silent ones. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- in their becoming more silent ones. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten.-overSoXSynthN :: Int -> Double -> Double -> String -> V.Vector Double -> IO ()+overSoXSynthN :: Int -> Float -> Float -> String -> V.Vector Float -> IO () overSoXSynthN n ampL time3 zs = overSoXSynthN4G n ampL (str2DurationsDef n zs time3)  -- | Function to create a melody for the given arguments. 'Durations' is used to provide a rhythm. -overSoXSynthN4G :: Int -> Double -> Durations -> V.Vector Double -> IO ()+overSoXSynthN4G :: Int -> Float -> Durations -> V.Vector Float -> IO () overSoXSynthN4G n ampL v2 vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT = @@ -188,19 +188,19 @@  -- | Variant of the 'overSoXSynthN4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-overSoXSynthN4GS :: Int -> Double -> Double -> String -> V.Vector Double -> IO ()+overSoXSynthN4GS :: Int -> Float -> Float -> String -> V.Vector Float -> IO () overSoXSynthN4GS n ampL time3 zs = overSoXSynthN4G n ampL (str2Durations zs time3)  -- | Function to create a melody for the given arguments. 'String' is used to provide a rhythm. The main component of the sound includes the lower pure quint, which--- can be in the same octave or in the one with the number lower by one. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude+-- can be in the same octave or in the one with the number lower by one. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude -- for Overtones. If it is set to 1.0 the overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results--- in their becoming more silent ones. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- in their becoming more silent ones. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten.-overSoXSynthN2 :: Int -> Double -> Double -> String -> String -> V.Vector Double -> IO ()+overSoXSynthN2 :: Int -> Float -> Float -> String -> String -> V.Vector Float -> IO () overSoXSynthN2 n ampL time3 zs = overSoXSynthN24G n ampL (str2DurationsDef n zs time3)   -- | Function to create a melody for the given arguments. 'Durations' is used to provide a rhythm. -overSoXSynthN24G :: Int -> Double -> Durations -> String -> V.Vector Double -> IO ()+overSoXSynthN24G :: Int -> Float -> Durations -> String -> V.Vector Float -> IO () overSoXSynthN24G n ampL v2 tts vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT = @@ -231,23 +231,23 @@  -- | Variant of the 'overSoXSynthN24G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-overSoXSynthN24GS :: Int -> Double -> Double -> String -> String -> V.Vector Double -> IO ()+overSoXSynthN24GS :: Int -> Float -> Float -> String -> String -> V.Vector Float -> IO () overSoXSynthN24GS n ampL time3 zs = overSoXSynthN24G n ampL (str2Durations zs time3)  -- | Function to create a melody for the given arguments. 'String' is used to provide a rhythm. The main component of the sound includes the lower pure quint, which--- can be in the same octave or in the one with the number lower by one. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude+-- can be in the same octave or in the one with the number lower by one. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude -- for Overtones. If it is set to 1.0 the overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results--- in their becoming more silent ones. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- in their becoming more silent ones. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten. -- The third 'String' argument is used to define the intervals for the notes if any.--- The third 'Double' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of+-- The third 'Float' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of -- the main note. If it is rather great, it can signal that the volume for the second note overTones are greater than for the main note obetones. -- The last one is experimental feature.-overSoXSynthN3 :: Int -> Double -> Double -> Double -> String -> String -> String -> V.Vector Double -> IO ()+overSoXSynthN3 :: Int -> Float -> Float -> Float -> String -> String -> String -> V.Vector Float -> IO () overSoXSynthN3 n ampL time3 dAmpl zs = overSoXSynthN34G n ampL dAmpl (str2DurationsDef n zs time3)  -- | Function to create a melody for the given arguments. 'Duraitons' is used to provide a rhythm. -overSoXSynthN34G :: Int -> Double -> Double -> Durations -> String -> String -> V.Vector Double -> IO ()+overSoXSynthN34G :: Int -> Float -> Float -> Durations -> String -> String -> V.Vector Float -> IO () overSoXSynthN34G n ampL dAmpl v2 tts vs vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT = @@ -289,7 +289,7 @@     else overSoXSynthN34G n ampL1 dAmpl v2 tts vs vec0  -- | Generalized variant of the 'overSoXSynthN34G' where you specify your own 'Intervals'. For more information, please, refer to 'intervalsFromStringG'.-overSoXSynthN35G :: Int -> Double -> Double -> Durations -> String -> Intervals -> V.Vector Double -> IO ()+overSoXSynthN35G :: Int -> Float -> Float -> Durations -> String -> Intervals -> V.Vector Float -> IO () overSoXSynthN35G n ampL dAmpl v2 tts v3 vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT = @@ -331,58 +331,58 @@  -- | Variant of the 'overSoXSynthN34G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-overSoXSynthN34GS :: Int -> Double -> Double -> Double -> String -> String -> String -> V.Vector Double -> IO ()+overSoXSynthN34GS :: Int -> Float -> Float -> Float -> String -> String -> String -> V.Vector Float -> IO () overSoXSynthN34GS n ampL time3 dAmpl zs = overSoXSynthN34G n ampL dAmpl (str2Durations zs time3)  -- | Variant of the 'overSoXSynthN34G' where intervals are obtained from the basic 'Intervals' with the length no more than 29 and a Ukrainian text  -- specified as the last 'String' argument so that you can produce 'Intervals' of the arbitrary length. For more information, please, refer to  -- 'intervalsFromStringG' and 'strToIntG'.-overSoXSynthN35GS :: Int -> Double -> Double -> Double -> String -> String -> Intervals -> String -> V.Vector Double -> IO ()+overSoXSynthN35GS :: Int -> Float -> Float -> Float -> String -> String -> Intervals -> String -> V.Vector Float -> IO () overSoXSynthN35GS n ampL time3 dAmpl zs tts v3 vs = overSoXSynthN35G n ampL dAmpl (str2Durations zs time3) tts (intervalsFromStringG v3 vs)  -- | Similar to 'overSoXSynthN', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one. Besides, the function lifts--- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Double' argument from+-- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Float' argument from -- the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the overTones amplitudes are just maximum ones, -- otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. -- -- For better usage the 'FilePath' should be a filepath for the .wav file.-overSoXSynthNGen :: FilePath -> Int -> Double -> Double -> String -> IO ()+overSoXSynthNGen :: FilePath -> Int -> Float -> Float -> String -> IO () overSoXSynthNGen file m = overSoXSynthNGenE file m 12    -- | Similar to 'overSoXSynthNGen', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'overSoXSynthNGen'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9.-overSoXSynthNGenE :: FilePath -> Int -> Int -> Double -> Double -> String -> IO ()+overSoXSynthNGenE :: FilePath -> Int -> Int -> Float -> Float -> String -> IO () overSoXSynthNGenE file m ku ampL time3 zs = do   n <- duration1000 file   nGenE4Gi n file m ku ampL (str2DurationsDef n zs time3)  -- | Generalized version of the 'overSoXSynthNGenE' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGenEPar :: FilePath -> Params -> Double -> Double -> String -> IO ()+overSoXSynthNGenEPar :: FilePath -> Params -> Float -> Float -> String -> IO () overSoXSynthNGenEPar file params ampL time3 zs = do   n <- duration1000 file   nGenE4GiPar n file params ampL (str2DurationsDef n zs time3)  -- | Variant of the 'overSoXSynthNGenE4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-overSoXSynthNGenE4GS :: FilePath -> Int -> Int -> Double -> Double -> String -> IO ()+overSoXSynthNGenE4GS :: FilePath -> Int -> Int -> Float -> Float -> String -> IO () overSoXSynthNGenE4GS file m ku ampL time3 zs = do   n <- duration1000 file   nGenE4Gi n file m ku ampL (str2Durations zs time3)  -- | Generalized version of the 'overSoXSynthNGenE4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGenE4GSPar :: FilePath -> Params -> Double -> Double -> String -> IO ()+overSoXSynthNGenE4GSPar :: FilePath -> Params -> Float -> Float -> String -> IO () overSoXSynthNGenE4GSPar file params ampL time3 zs = do   n <- duration1000 file   nGenE4GiPar n file params ampL (str2Durations zs time3)    -- | Note that the last two '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 third 'Int' parameter defines that @n@.-nGenE4Gi :: Int -> FilePath -> Int -> Int -> Double -> Durations -> IO ()+nGenE4Gi :: Int -> FilePath -> Int -> Int -> Float -> Durations -> IO () nGenE4Gi n file m ku ampL v2 = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -391,7 +391,7 @@      -- | Generalized version of the 'nGenE4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-nGenE4GiPar :: Int -> FilePath -> Params -> Double -> Durations -> IO ()+nGenE4GiPar :: Int -> FilePath -> Params -> Float -> Durations -> IO () nGenE4GiPar n file params ampL v2 = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -399,62 +399,62 @@   endFromResult               -- | 4G genaralized version of the 'overSoXSynthNGenE' where you provide your own 'Durations'.-overSoXSynthNGenE4G :: FilePath -> Int -> Int -> Double -> Durations -> IO ()+overSoXSynthNGenE4G :: FilePath -> Int -> Int -> Float -> Durations -> IO () overSoXSynthNGenE4G file m ku ampL v2 = do   n <- duration1000 file   nGenE4Gi n file m ku ampL v2  -- | Generalized version of the 'overSoXSynthNGenE4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGenE4GPar :: FilePath -> Params -> Double -> Durations -> IO ()+overSoXSynthNGenE4GPar :: FilePath -> Params -> Float -> Durations -> IO () overSoXSynthNGenE4GPar file params ampL v2 = do   n <- duration1000 file   nGenE4GiPar n file params ampL v2    -- | Similar to 'overSoXSynthN2', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one. Besides, the function lifts--- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Double' argument from+-- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Float' argument from -- the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the overTones amplitudes are just maximum ones, -- otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. --  -- For better usage the 'FilePath' should be a filepath for the .wav file. -- The second 'String' argument is used to define signs of the harmonics coefficients in the generated sounds.-overSoXSynthNGen2 :: FilePath -> Int -> Double -> Double -> String -> String -> IO ()+overSoXSynthNGen2 :: FilePath -> Int -> Float -> Float -> String -> String -> IO () overSoXSynthNGen2 file m = overSoXSynthNGen2E file m 12    -- | Similar to 'overSoXSynthNGen2', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'overSoXSynthNGen2'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9.-overSoXSynthNGen2E :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()+overSoXSynthNGen2E :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> IO () overSoXSynthNGen2E file m ku ampL time3 zs tts = do   n <- duration1000 file   nGen2E4Gi n file m ku ampL (str2DurationsDef n zs time3) tts  -- | Generalized version of the 'overSoXSynthNGen2E' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen2EPar :: FilePath -> Params -> Double -> Double -> String -> String -> IO ()+overSoXSynthNGen2EPar :: FilePath -> Params -> Float -> Float -> String -> String -> IO () overSoXSynthNGen2EPar file params ampL time3 zs tts = do   n <- duration1000 file   nGen2E4GiPar n file params ampL (str2DurationsDef n zs time3) tts    -- | Variant of the 'overSoXSynthNGen2E4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-overSoXSynthNGen2E4GS :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()+overSoXSynthNGen2E4GS :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> IO () overSoXSynthNGen2E4GS file m ku ampL time3 zs tts = do   n <- duration1000 file   nGen2E4Gi n file m ku ampL (str2Durations zs time3) tts  -- | Generalized version of the 'overSoXSynthNGen2E4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen2E4GSPar :: FilePath -> Params -> Double -> Double -> String -> String -> IO ()+overSoXSynthNGen2E4GSPar :: FilePath -> Params -> Float -> Float -> String -> String -> IO () overSoXSynthNGen2E4GSPar file params ampL time3 zs tts = do   n <- duration1000 file   nGen2E4GiPar n file params ampL (str2Durations zs time3) tts  -- | Note that the last two '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 third 'Int' parameter defines that @n@.-nGen2E4Gi :: Int -> FilePath -> Int -> Int -> Double -> Durations -> String -> IO ()+nGen2E4Gi :: Int -> FilePath -> Int -> Int -> Float -> Durations -> String -> IO () nGen2E4Gi n file m ku ampL v2 tts = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -463,7 +463,7 @@  -- | Generalized version of the 'nGen2E4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-nGen2E4GiPar :: Int -> FilePath -> Params -> Double -> Durations -> String -> IO ()+nGen2E4GiPar :: Int -> FilePath -> Params -> Float -> Durations -> String -> IO () nGen2E4GiPar n file params ampL v2 tts = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -471,45 +471,45 @@   endFromResult            -- | 4G genaralized version of the 'overSoXSynthNGen2E' where you provide your own 'Durations'.-overSoXSynthNGen2E4G :: FilePath -> Int -> Int -> Double -> Durations -> String -> IO ()+overSoXSynthNGen2E4G :: FilePath -> Int -> Int -> Float -> Durations -> String -> IO () overSoXSynthNGen2E4G file m ku ampL v2 tts = do   n <- duration1000 file   nGen2E4Gi n file m ku ampL v2 tts  -- | Generalized version of the 'overSoXSynthNGen2E4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen2E4GPar :: FilePath -> Params -> Double -> Durations -> String -> IO ()+overSoXSynthNGen2E4GPar :: FilePath -> Params -> Float -> Durations -> String -> IO () overSoXSynthNGen2E4GPar file params ampL v2 tts = do   n <- duration1000 file   nGen2E4GiPar n file params ampL v2 tts    -- | Similar to 'overSoXSynthN2', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one. Besides, the function lifts--- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Double' argument from+-- the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]). The first 'Float' argument from -- the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the overTones amplitudes are just maximum ones, -- otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. --  -- For better usage the 'FilePath' should be a filepath for the .wav file. -- The second 'String' argument is used to define signs of the harmonics coefficients in the generated sounds. -- The third 'String' argument is used to define the intervals for the notes if any.--- The third 'Double' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of+-- The third 'Float' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of -- the main note. If it is rather great, it can signal that the volume for the second note overTones are greater than for the main note obetones. -- The last one is experimental feature.-overSoXSynthNGen3 :: FilePath -> Int -> Double -> Double -> Double -> String -> String -> String -> IO ()+overSoXSynthNGen3 :: FilePath -> Int -> Float -> Float -> Float -> String -> String -> String -> IO () overSoXSynthNGen3 file m = overSoXSynthNGen3E file m 12    -- | Similar to 'overSoXSynthNGen3', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'overSoXSynthNGen3'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9.-overSoXSynthNGen3E :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> IO ()+overSoXSynthNGen3E :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> IO () overSoXSynthNGen3E file m ku ampL time3 dAmpl zs tts vs = do   n <- duration1000 file   nGen3E4Gi n file m ku ampL dAmpl (str2DurationsDef n zs time3) tts vs  -- | Generalized version of the 'overSoXSynthNGen3E' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3EPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> IO ()+overSoXSynthNGen3EPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> IO () overSoXSynthNGen3EPar file params ampL time3 dAmpl zs tts vs = do   n <- duration1000 file   nGen3E4GiPar n file params ampL dAmpl (str2DurationsDef n zs time3) tts vs  @@ -517,21 +517,21 @@ -- | Variant of the 'overSoXSynthNGen3E4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition. 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@.-overSoXSynthNGen3E4GS :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> IO ()+overSoXSynthNGen3E4GS :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> IO () overSoXSynthNGen3E4GS file m ku ampL time3 dAmpl zs tts vs = do   n <- duration1000 file   nGen3E4Gi n file m ku ampL dAmpl (str2Durations zs time3) tts vs   -- | Generalized version of the 'overSoXSynthNGen3E4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E4GSPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> IO ()+overSoXSynthNGen3E4GSPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> IO () overSoXSynthNGen3E4GSPar file params ampL time3 dAmpl zs tts vs = do   n <- duration1000 file   nGen3E4GiPar n file params ampL dAmpl (str2Durations zs time3) tts vs      -- | Note that the last two '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 third 'Int' parameter defines that @n@.-nGen3E4Gi :: Int -> FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> IO ()+nGen3E4Gi :: Int -> FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> IO () nGen3E4Gi n file m ku ampL dAmpl v2 tts vs = do    vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -540,7 +540,7 @@  -- | Generalized version of the 'nGen3E4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-nGen3E4GiPar :: Int -> FilePath -> Params -> Double -> Double -> Durations -> String -> String -> IO ()+nGen3E4GiPar :: Int -> FilePath -> Params -> Float -> Float -> Durations -> String -> String -> IO () nGen3E4GiPar n file params ampL dAmpl v2 tts vs = do    vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -549,7 +549,7 @@  -- | Note that the last two '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 third 'Int' parameter defines that @n@.-nGen3E5Gi :: Int -> FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> Intervals -> IO ()+nGen3E5Gi :: Int -> FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> Intervals -> IO () nGen3E5Gi n file m ku ampL dAmpl v2 tts v3 = do    vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -558,7 +558,7 @@      -- | Generalized version of the 'nGen3E5Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-nGen3E5GiPar :: Int -> FilePath -> Params -> Double -> Double -> Durations -> String -> Intervals -> IO ()+nGen3E5GiPar :: Int -> FilePath -> Params -> Float -> Float -> Durations -> String -> Intervals -> IO () nGen3E5GiPar n file params ampL dAmpl v2 tts v3 = do    vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -567,28 +567,28 @@  -- | 4G generalized function for 'overSoXSynthNGen3E' where you provide your own 'Durations'. 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@.-overSoXSynthNGen3E4G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> IO ()+overSoXSynthNGen3E4G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> IO () overSoXSynthNGen3E4G file m ku ampL dAmpl v2 tts vs = do   n <- duration1000 file   nGen3E4Gi n file m ku ampL dAmpl v2 tts vs  -- | Generalized version of the 'overSoXSynthNGen3E4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E4GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> String -> IO ()+overSoXSynthNGen3E4GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> String -> IO () overSoXSynthNGen3E4GPar file params ampL dAmpl v2 tts vs = do   n <- duration1000 file   nGen3E4GiPar n file params ampL dAmpl v2 tts vs    -- | 5G generalized function for 'overSoXSynthNGen3E4G' where you provide your own 'Intervals'. 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@.-overSoXSynthNGen3E5G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> Intervals -> IO ()+overSoXSynthNGen3E5G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> Intervals -> IO () overSoXSynthNGen3E5G file m ku ampL dAmpl v2 tts v3 = do   n <- duration1000 file   nGen3E5Gi n file m ku ampL dAmpl v2 tts v3   -- | Generalized version of the 'overSoXSynthNGen3E5G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E5GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> Intervals -> IO ()+overSoXSynthNGen3E5GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> Intervals -> IO () overSoXSynthNGen3E5GPar file params ampL dAmpl v2 tts v3 = do   n <- duration1000 file   nGen3E5GiPar n file params ampL dAmpl v2 tts v3    @@ -597,48 +597,48 @@ -- specified as the last 'String' argument so that you can produce 'Intervals' of the arbitrary length. For more information, please, refer to  -- 'intervalsFromStringG' and 'strToIntG'. 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@.-overSoXSynthNGen3E5GS :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> Intervals -> String -> IO ()+overSoXSynthNGen3E5GS :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> Intervals -> String -> IO () overSoXSynthNGen3E5GS file m ku ampL time3 dAmpl zs tts v3 vs = do   n <- duration1000 file   nGen3E5Gi n file m ku ampL dAmpl (str2Durations zs time3) tts (intervalsFromStringG v3 vs)  -- | Generalized version of the 'overSoXSynthNGen3E5GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E5GSPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> Intervals -> String -> IO ()+overSoXSynthNGen3E5GSPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> Intervals -> String -> IO () overSoXSynthNGen3E5GSPar file params ampL time3 dAmpl zs tts v3 vs = do   n <- duration1000 file   nGen3E5GiPar n file params ampL dAmpl (str2Durations zs time3) tts (intervalsFromStringG v3 vs)      -- | 6G generalized function for 'overSoXSynthNGen3E5G' where you provide your own '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@.-overSoXSynthNGen3E6G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> Intervals -> Strengths -> Double -> IO ()+overSoXSynthNGen3E6G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> Intervals -> Strengths -> Float -> IO () overSoXSynthNGen3E6G file m ku ampL dAmpl v2 tts v3 v6 limV =   overSoXSynthNGen3E5G file m ku ampL dAmpl v2 tts v3 >> apply6G2 v6 "221w" "result" limV >> endFromResult  -- | Generalized version of the 'overSoXSynthNGen3E6G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E6GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> Intervals -> Strengths -> Double -> IO ()+overSoXSynthNGen3E6GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> Intervals -> Strengths -> Float -> IO () overSoXSynthNGen3E6GPar file params ampL dAmpl v2 tts v3 v6 limV =   overSoXSynthNGen3E5GPar file params ampL dAmpl v2 tts v3 >> apply6G2 v6 "221w" "result" limV >> endFromResult   -- | A variant of 'overSoXSynthNGen3E6G' where 'Strengths' are obtained from a Ukrainian text specified as the last 'String' argument. 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@.-overSoXSynthNGen3E6GS :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> Intervals -> String -> Double -> IO ()+overSoXSynthNGen3E6GS :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> Intervals -> String -> Float -> IO () overSoXSynthNGen3E6GS file m ku ampL dAmpl v2 tts v3 xxs limV = overSoXSynthNGen3E6G file m ku ampL dAmpl v2 tts v3 (str2Volume xxs) limV  -- | Generalized version of the 'overSoXSynthNGen3E6GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E6GSPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> Intervals -> String -> Double -> IO ()+overSoXSynthNGen3E6GSPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> Intervals -> String -> Float -> IO () overSoXSynthNGen3E6GSPar file params ampL dAmpl v2 tts v3 xxs limV = overSoXSynthNGen3E6GPar file params ampL dAmpl v2 tts v3 (str2Volume xxs) limV  -- | A variant of 'overSoXSynthNGen3E6GS' where 'Strengths' and 'Durations' are obtained from the same Ukrainian text specified as --- the last 'String' argument. The third 'Double' argument is an average duration of the sounds in seconds. +-- the last 'String' argument. The third 'Float' argument is an average duration of the sounds in seconds.  -- 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@.-overSoXSynthNGen3E6GSu :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> Intervals -> String -> Double -> IO ()+overSoXSynthNGen3E6GSu :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> Intervals -> String -> Float -> IO () overSoXSynthNGen3E6GSu file m ku ampL dAmpl time3 tts v3 xxs = overSoXSynthNGen3E6G file m ku ampL dAmpl (str2Durations xxs time3) tts v3 (str2Volume xxs)  -- | Generalized version of the 'overSoXSynthNGen3E6GSu' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-overSoXSynthNGen3E6GSuPar :: FilePath -> Params -> Double -> Double -> Double -> String -> Intervals -> String -> Double -> IO ()+overSoXSynthNGen3E6GSuPar :: FilePath -> Params -> Float -> Float -> Float -> String -> Intervals -> String -> Float -> IO () overSoXSynthNGen3E6GSuPar file params ampL dAmpl time3 tts v3 xxs = overSoXSynthNGen3E6GPar file params ampL dAmpl (str2Durations xxs time3) tts v3 (str2Volume xxs)

@@ -91,7 +91,7 @@   tempeRa 0   putStrLn "Please, specify, how many seconds long sound data you would like to record."   time <- getLine-  let time0 = read (filter (\t -> isDigit t || t == '.') time)::Double+  let time0 = read (filter (\t -> isDigit t || t == '.') time)::Float   putStrLn "Please, wait for 0.5 second and produce the needed sound now."   recA "x.wav" time0   putStrLn ""@@ -173,7 +173,7 @@  processD5 :: IO String processD5 = onException (do-  putStr "Please, specify the basic duration for the generated sounds as a Double number in the range [0.1..4.0]. "+  putStr "Please, specify the basic duration for the generated sounds as a Float number in the range [0.1..4.0]. "   putStrLn "The default one is 0.5"   putStrLn "To use the default value, you can simply press Enter."   fmap d5H getLine) (do@@ -185,7 +185,7 @@ d5H :: String -> String d5H xs   | null xs = "0.5"-  | otherwise = let time1 = (read (filter (\z -> isDigit z || z == '.') xs)::Double) in+  | otherwise = let time1 = (read (filter (\z -> isDigit z || z == '.') xs)::Float) in       if compare time1 0.1 /= LT && compare time1 4.0 /= GT then showFFloat (Just 4) time1 $ show 0       else let mantissa = time1 - (fromIntegral . truncate $ time1)                ceilP    = (truncate time1::Int) `rem` 4 in@@ -222,7 +222,7 @@ d8H :: String -> String d8H xs   | null xs = "1.0"-  | otherwise = let dAmpl1 = (read (filter (\z -> isDigit z || z == '.') xs)::Double) in+  | otherwise = let dAmpl1 = (read (filter (\z -> isDigit z || z == '.') xs)::Float) in     if compare dAmpl1 0.1 /= LT && compare dAmpl1 2.0 /= GT then showFFloat (Just 4) dAmpl1 $ show 0     else let mantissa = dAmpl1 - (fromIntegral . truncate $ dAmpl1)              ceilP    = (truncate dAmpl1::Int) `rem` 2 in

@@ -87,7 +87,7 @@  -- | For the given frequency of the note it generates a 'V.Vector' of the tuples, each one of which contains the harmonics' frequency and amplitude. For every given -- 'String' structure of the uniqueness (see the documentation for @mmsyn7s@ package and its 'MMSyn7.Syllable' module) it produces the unique timbre.-uniqOvertonesV :: Double -> String -> OvertonesO+uniqOvertonesV :: Float -> String -> OvertonesO uniqOvertonesV note xs =   let ys = uniquenessPeriods xs       z  = sum ys@@ -100,7 +100,7 @@ -- | For the given frequency of the note it generates a 'V.Vector' of the tuples, each one of which contains the harmonics' frequency and amplitude. For every given -- first 'String' argument structure of the uniqueness (see the documentation for @mmsyn7s@ package and its 'MMSyn7.Syllable' module) it produces the unique timbre. -- The second 'String' is used to produce the signs for harmonics coefficients.-uniqOvertonesV2 :: Double -> String -> String -> OvertonesO+uniqOvertonesV2 :: Float -> String -> String -> OvertonesO uniqOvertonesV2 note xs ts =    let ys = uniquenessPeriods xs       z  = sum ys@@ -116,7 +116,7 @@ -- and quickly synthesize differently sounding intervals. The main component of the sound includes the lower pure quint, which can be in -- the same octave or in the one with the number lower by one. Please, check before executing  -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten.-uniqOverSoXSynth :: Double -> String -> IO ()+uniqOverSoXSynth :: Float -> String -> IO () uniqOverSoXSynth x wws = do   let note0 = closestNote x       note1 = pureQuintNote note0@@ -145,7 +145,7 @@ -- the same octave or in the one with the number lower by one. Please, check before executing  -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten. -- The second 'String' argument is used to define signs for the harmonics coefficients for Overtones.-uniqOverSoXSynth2 :: Double -> String -> String -> IO ()+uniqOverSoXSynth2 :: Float -> String -> String -> IO () uniqOverSoXSynth2 x wws tts = do   let note0 = closestNote x       note1 = pureQuintNote note0@@ -159,22 +159,22 @@  -- | Function to create a melody for the given arguments. The first 'String' is used to provide a rhythm. The second one -- to provide a timbre. -- The timbre for another given text usually differs, but can be the same. This gives an opportunity to practically and quickly--- synthesize differently sounding intervals. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones.+-- synthesize differently sounding intervals. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. -- If it is set to 1.0 the overTones amplitudes are just maximum ones, otherwise they are multiplied by the parameter and this results in -- their becoming more silent ones. The main component of the sound is in the given octave with a number given -- by 'Int' parameter. Besides, another main component of the sound includes the lower pure quint, which can be in the same octave or in the one with--- the number lower by one. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- the number lower by one. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten.-uniqOverSoXSynthN :: Int -> Double -> Double -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN :: Int -> Float -> Float -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN n ampL time3 zs = uniqOverSoXSynthN4G n ampL (str2DurationsDef n zs time3)  -- | Variant of the 'uniqOverSoXSynthN4G' function where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-uniqOverSoXSynthN4GS :: Int -> Double -> Double -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN4GS :: Int -> Float -> Float -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN4GS n ampL time3 zs = uniqOverSoXSynthN4G n ampL (str2Durations zs time3)  -- | 4G generalized variant of the 'uniqOverSoXSynthN' where you specify your own 'Durations'.-uniqOverSoXSynthN4G :: Int -> Double -> Durations -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN4G :: Int -> Float -> Durations -> String -> V.Vector Float -> IO () uniqOverSoXSynthN4G n ampL v2 wws vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT =@@ -206,23 +206,23 @@  -- | Function to create a melody for the given arguments. The first 'String' is used to provide a rhythm. The second one -- to provide a timbre. -- The timbre for another given text usually differs, but can be the same. This gives an opportunity to practically and quickly--- synthesize differently sounding intervals. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones.+-- synthesize differently sounding intervals. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. -- If it is set to 1.0 the overTones amplitudes are just maximum ones, otherwise they are multiplied by the parameter and this results in -- their becoming more silent ones. The main component of the sound is in the given octave with a number given -- by 'Int' parameter. Besides, another main component of the sound includes the lower pure quint, which can be in the same octave or in the one with--- the number lower by one. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- the number lower by one. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten. -- The third 'String' argument is used to define signs of the harmonics coefficients in the generated sounds.-uniqOverSoXSynthN3 :: Int -> Double -> Double -> String -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN3 :: Int -> Float -> Float -> String -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN3 n ampL time3 zs = uniqOverSoXSynthN34G n ampL (str2DurationsDef n zs time3)  -- | Variant of the 'uniqOverSoXSynthN34G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-uniqOverSoXSynthN34GS :: Int -> Double -> Double -> String -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN34GS :: Int -> Float -> Float -> String -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN34GS n ampL time3 zs = uniqOverSoXSynthN34G n ampL (str2Durations zs time3)  -- | 4G generalized variant of the 'uniqOverSoXSynthN3' where you specify your own 'Durations'. -uniqOverSoXSynthN34G :: Int -> Double -> Durations -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN34G :: Int -> Float -> Durations -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN34G n ampL v2 wws tts vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT =@@ -253,31 +253,31 @@  -- | Function to create a melody for the given arguments. The first 'String' is used to provide a rhythm. The second one -- to provide a timbre. -- The timbre for another given text usually differs, but can be the same. This gives an opportunity to practically and quickly--- synthesize differently sounding intervals. The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones.+-- synthesize differently sounding intervals. The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. -- If it is set to 1.0 the overTones amplitudes are just maximum ones, otherwise they are multiplied by the parameter and this results in -- their becoming more silent ones. The main component of the sound is in the given octave with a number given -- by 'Int' parameter. Besides, another main component of the sound includes the lower pure quint, which can be in the same octave or in the one with--- the number lower by one. The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- the number lower by one. The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" files in the current directory, because they can be overwritten. -- The third 'String' argument is used to define signs of the harmonics coefficients in the generated sounds. -- The fourth 'String' argument is used to define the intervals for the notes if any.--- The third 'Double' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of+-- The third 'Float' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of -- the main note. If it is rather great, it can signal that the volume for the second note overTones are greater than for the main note obetones. -- The last one is experimental feature.-uniqOverSoXSynthN4 :: Int -> Double -> Double -> Double -> String -> String -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN4 :: Int -> Float -> Float -> Float -> String -> String -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN4 n ampL time3 dAmpl zs = uniqOverSoXSynthN44G n ampL dAmpl (str2DurationsDef n zs time3)  -- | Variant of the 'uniqOverSoXSynthN44G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition.-uniqOverSoXSynthN44GS :: Int -> Double -> Double -> Double -> String -> String -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN44GS :: Int -> Float -> Float -> Float -> String -> String -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN44GS n ampL time3 dAmpl zs = uniqOverSoXSynthN44G n ampL dAmpl (str2Durations zs time3)  -- | 4G generalized variant of the 'uniqOverSoXSynthN4' where you specify your own 'Durations'. -uniqOverSoXSynthN44G :: Int -> Double -> Double -> Durations -> String -> String -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN44G :: Int -> Float -> Float -> Durations -> String -> String -> String -> V.Vector Float -> IO () uniqOverSoXSynthN44G n ampL dAmpl v2 wws tts vs = uniqOverSoXSynthN45G n ampL dAmpl v2 wws tts (intervalsFromString vs)   -- | 5G generalized variant of the 'uniqOverSoXSynthN44G' where you specify your own 'Intervals'. -uniqOverSoXSynthN45G :: Int -> Double -> Double -> Durations -> String -> String -> Intervals -> V.Vector Double -> IO ()+uniqOverSoXSynthN45G :: Int -> Float -> Float -> Durations -> String -> String -> Intervals -> V.Vector Float -> IO () uniqOverSoXSynthN45G n ampL dAmpl v2 wws tts v3 vec0  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | compare (abs ampL) 0.01 /= LT && compare (abs ampL) 1.0 /= GT =@@ -314,9 +314,9 @@     if abs ampL1 < 0.01 then uniqOverSoXSynthN45G n 0.01 dAmpl v2 wws tts v3 vec0     else uniqOverSoXSynthN45G n ampL1 dAmpl v2 wws tts v3 vec0     --- | 6G generalized variant of the 'uniqOverSoXSynthN45G' where you specify your own 'Strengths' and a limit (as the last 'Double') when less volume level +-- | 6G generalized variant of the 'uniqOverSoXSynthN45G' where you specify your own 'Strengths' and a limit (as the last 'Float') when less volume level  -- sound files are treated as a silent ones and are not adjusted. -uniqOverSoXSynthN46G :: Int -> Double -> Double -> Durations -> String -> String -> Intervals -> V.Vector Double -> Strengths -> Double -> IO ()+uniqOverSoXSynthN46G :: Int -> Float -> Float -> Durations -> String -> String -> Intervals -> V.Vector Float -> Strengths -> Float -> IO () uniqOverSoXSynthN46G n ampL dAmpl v2 wws tts v3 vec0 v6 limV  | V.all (== 0.0) v2 = putStrLn "You provided no valid durations data! "  | V.null v6 = putStrLn "You did not provide a volume adjustments vector! "@@ -357,47 +357,47 @@  -- | Variant of the 'uniqOverSoXSynthN45G' where 'Intervals' are obtained from the 'String' using 'intervalsFromStringG' function. Helps to create a speech-like  -- composition.-uniqOverSoXSynthN45GS :: Int -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> V.Vector Double -> IO ()+uniqOverSoXSynthN45GS :: Int -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> V.Vector Float -> IO () uniqOverSoXSynthN45GS n ampL time3 dAmpl zs wws tts v3 vs = uniqOverSoXSynthN45G n ampL dAmpl (str2Durations zs time3) wws tts (intervalsFromStringG v3 vs)   -- | Variant of the 'uniqOverSoXSynthN46G' where 'Strengths' are obtained from the 'String' using 'str2Volume' function. Helps to create a speech-like  -- composition.-uniqOverSoXSynthN46GS :: Int -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> V.Vector Double -> String ->-  Double -> IO ()+uniqOverSoXSynthN46GS :: Int -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> V.Vector Float -> String ->+  Float -> IO () uniqOverSoXSynthN46GS n ampL time3 dAmpl zs wws tts v3 vs vec0 xxs limV = uniqOverSoXSynthN46G n ampL dAmpl (str2Durations zs time3) wws tts    (intervalsFromStringG v3 vs) vec0 (str2Volume xxs) limV  -- | A variant of 'uniqOverSoXSynthN46GS' where 'Strengths' and 'Durations' are obtained from the same Ukrainian text specified as --- the last 'String' argument. The second 'Double' argument is an average duration of the sounds in seconds. +-- the last 'String' argument. The second 'Float' argument is an average duration of the sounds in seconds.  -- 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@.-uniqOverSoXSynthN46GSu :: Int -> Double -> Double -> Double -> String -> String -> Intervals -> String -> V.Vector Double -> String -> Double -> IO ()+uniqOverSoXSynthN46GSu :: Int -> Float -> Float -> Float -> String -> String -> Intervals -> String -> V.Vector Float -> String -> Float -> IO () uniqOverSoXSynthN46GSu n ampL time3 dAmpl wws tts v5 vs vec0 xxs limV =   uniqOverSoXSynthN46G n ampL dAmpl (str2Durations xxs time3) wws tts (intervalsFromStringG v5 vs) vec0 (str2Volume xxs) limV  -- | Similar to 'uniqOverSoXSynthN', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one.  -- Besides, the function lifts the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]).--- The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the+-- The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the -- overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. -- -- For better usage the 'FilePath' should be a filepath for the .wav file.-uniqOverSoXSynthNGen :: FilePath -> Int -> Double -> Double -> String -> String -> IO ()+uniqOverSoXSynthNGen :: FilePath -> Int -> Float -> Float -> String -> String -> IO () uniqOverSoXSynthNGen file m = uniqOverSoXSynthNGenE file m 12  -- | Similar to 'uniqOverSoXSynthNGen', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'uniqOverSoXSynthNGen'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9. 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@.-uniqOverSoXSynthNGenE :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()+uniqOverSoXSynthNGenE :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> IO () uniqOverSoXSynthNGenE file m ku ampL time3 zs wws = do   n <- duration1000 file   unGenNE4Gi n file m ku ampL (str2DurationsDef n zs time3) wws  -- | Generalized version of the 'uniqOverSoXSynthNGenE' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGenEPar :: FilePath -> Params -> Double -> Double -> String -> String -> IO ()+uniqOverSoXSynthNGenEPar :: FilePath -> Params -> Float -> Float -> String -> String -> IO () uniqOverSoXSynthNGenEPar file params ampL time3 zs wws = do   n <- duration1000 file   unGenNE4GiPar n file params ampL (str2DurationsDef n zs time3) wws  @@ -405,21 +405,21 @@ -- | Variant of the 'uniqOverSoXSynthNGenE4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition. 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@.-uniqOverSoXSynthNGenE4GS :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()+uniqOverSoXSynthNGenE4GS :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> IO () uniqOverSoXSynthNGenE4GS file m ku ampL time3 zs wws = do   n <- duration1000 file   unGenNE4Gi n file m ku ampL (str2Durations zs time3) wws    -- | Generalized version of the 'uniqOverSoXSynthNGenE4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGenE4GSPar :: FilePath -> Params -> Double -> Double -> String -> String -> IO ()+uniqOverSoXSynthNGenE4GSPar :: FilePath -> Params -> Float -> Float -> String -> String -> IO () uniqOverSoXSynthNGenE4GSPar file params ampL time3 zs wws = do   n <- duration1000 file   unGenNE4GiPar n file params ampL (str2Durations zs time3) wws    -- | Note that the last two '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 third 'Int' parameter defines that @n@.-unGenNE4Gi :: Int -> FilePath -> Int -> Int -> Double -> Durations -> String -> IO ()+unGenNE4Gi :: Int -> FilePath -> Int -> Int -> Float -> Durations -> String -> IO () unGenNE4Gi n file m ku ampL v2 wws = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -428,7 +428,7 @@  -- | Generalized version of the 'unGenNE4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-unGenNE4GiPar :: Int -> FilePath -> Params -> Double -> Durations -> String -> IO ()+unGenNE4GiPar :: Int -> FilePath -> Params -> Float -> Durations -> String -> IO () unGenNE4GiPar n file params ampL v2 wws = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -437,42 +437,42 @@  -- | 4G genaralized version of the 'uniqOverSoXSynthNGenE' where you provide your own 'Durations'. 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@.-uniqOverSoXSynthNGenE4G :: FilePath -> Int -> Int -> Double -> Durations -> String -> IO ()+uniqOverSoXSynthNGenE4G :: FilePath -> Int -> Int -> Float -> Durations -> String -> IO () uniqOverSoXSynthNGenE4G file m ku ampL v2 wws = do   n <- duration1000 file   unGenNE4Gi n file m ku ampL v2 wws  -- | Generalized version of the 'uniqOverSoXSynthNGenE4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGenE4GPar :: FilePath -> Params -> Double -> Durations -> String -> IO ()+uniqOverSoXSynthNGenE4GPar :: FilePath -> Params -> Float -> Durations -> String -> IO () uniqOverSoXSynthNGenE4GPar file params ampL v2 wws = do   n <- duration1000 file   unGenNE4GiPar n file params ampL v2 wws     -- | Similar to 'uniqOverSoXSynthN', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one.  -- Besides, the function lifts the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]).--- The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the+-- The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the -- overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. -- -- For better usage the 'FilePath' should be a filepath for the .wav file. -- The third 'String' argument is used to define signs of the harmonics coefficients in the generated sounds.-uniqOverSoXSynthNGen3 :: FilePath -> Int -> Double -> Double -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen3 :: FilePath -> Int -> Float -> Float -> String -> String -> String -> IO () uniqOverSoXSynthNGen3 file m = uniqOverSoXSynthNGen3E file m 12  -- | Similar to 'uniqOverSoXSynthNGen3', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'uniqOverSoXSynthNGen3'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9. 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@.-uniqOverSoXSynthNGen3E :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen3E :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> String -> IO () uniqOverSoXSynthNGen3E file m ku ampL time3 zs wws tts = do   n <- duration1000 file   unGenN3E4Gi n file m ku ampL (str2DurationsDef n zs time3) wws tts  -- | Generalized version of the 'uniqOverSoXSynthNGen3E' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen3EPar :: FilePath -> Params -> Double -> Double -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen3EPar :: FilePath -> Params -> Float -> Float -> String -> String -> String -> IO () uniqOverSoXSynthNGen3EPar file params ampL time3 zs wws tts = do   n <- duration1000 file   unGenN3E4GiPar n file params ampL (str2DurationsDef n zs time3) wws tts  @@ -480,21 +480,21 @@ -- | Variant of the 'uniqOverSoXSynthNGen3E4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition. 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@.-uniqOverSoXSynthNGen3E4GS :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen3E4GS :: FilePath -> Int -> Int -> Float -> Float -> String -> String -> String -> IO () uniqOverSoXSynthNGen3E4GS file m ku ampL time3 zs wws tts = do   n <- duration1000 file   unGenN3E4Gi n file m ku ampL (str2Durations zs time3) wws tts  -- | Generalized version of the 'uniqOverSoXSynthNGen3E4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen3E4GSPar :: FilePath -> Params -> Double -> Double -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen3E4GSPar :: FilePath -> Params -> Float -> Float -> String -> String -> String -> IO () uniqOverSoXSynthNGen3E4GSPar file params ampL time3 zs wws tts = do   n <- duration1000 file   unGenN3E4GiPar n file params ampL (str2Durations zs time3) wws tts  -- | Note that the last two '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 third 'Int' parameter defines that @n@.-unGenN3E4Gi :: Int -> FilePath -> Int -> Int -> Double -> Durations -> String -> String -> IO ()+unGenN3E4Gi :: Int -> FilePath -> Int -> Int -> Float -> Durations -> String -> String -> IO () unGenN3E4Gi n file m ku ampL v2 wws tts = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -503,7 +503,7 @@  -- | Generalized version of the 'unGenN3E4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-unGenN3E4GiPar :: Int -> FilePath -> Params -> Double -> Durations -> String -> String -> IO ()+unGenN3E4GiPar :: Int -> FilePath -> Params -> Float -> Durations -> String -> String -> IO () unGenN3E4GiPar n file params ampL v2 wws tts = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -512,46 +512,46 @@  -- | 4G genaralized version of the 'uniqOverSoXSynthNGen3E' where you provide your own 'Durations'. 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@.-uniqOverSoXSynthNGen3E4G :: FilePath -> Int -> Int -> Double -> Durations -> String -> String -> IO ()+uniqOverSoXSynthNGen3E4G :: FilePath -> Int -> Int -> Float -> Durations -> String -> String -> IO () uniqOverSoXSynthNGen3E4G file m ku ampL v2 wws tts = do   n <- duration1000 file   unGenN3E4Gi n file m ku ampL v2 wws tts     -- | Generalized version of the 'uniqOverSoXSynthNGen3E4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen3E4GPar :: FilePath -> Params -> Double -> Durations -> String -> String -> IO ()+uniqOverSoXSynthNGen3E4GPar :: FilePath -> Params -> Float -> Durations -> String -> String -> IO () uniqOverSoXSynthNGen3E4GPar file params ampL v2 wws tts = do   n <- duration1000 file   unGenN3E4GiPar n file params ampL v2 wws tts     -- | Similar to 'uniqOverSoXSynthN', but uses a sound file to obtain the information analogous to 'V.Vector' in the latter one.  -- Besides, the function lifts the frequencies to the octave with the given by 'Int' parameter number (better to use from the range [1..8]).--- The first 'Double' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the+-- The first 'Float' argument from the range [0.01..1.0] is used as a maximum amplitude for Overtones. If it is set to 1.0 the -- overTones amplitudes are just the maximum ones, otherwise they are multiplied by the parameter and this results in their becoming more silent ones.--- The second 'Double' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing+-- The second 'Float' argument is a basic sound duration. The default one is 0.5 (second). Please, check before executing -- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end.wav\" files in the current directory, because they can be overwritten. -- -- For better usage the 'FilePath' should be a filepath for the .wav file. -- The third 'String' argument is used to define signs of the harmonics coefficients in the generated sounds. -- The fourth 'String' argument is used to define the intervals for the notes if any.--- The third 'Double' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of+-- The third 'Float' parameter basically is used to define in how many times the volume for the second lower note is less than the volume of -- the main note. If it is rather great, it can signal that the volume for the second note overTones are greater than for the main note obetones. -- The last one is an experimental feature.-uniqOverSoXSynthNGen4 :: FilePath -> Int -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4 :: FilePath -> Int -> Float -> Float -> Float -> String -> String -> String -> String -> IO () uniqOverSoXSynthNGen4 file m = uniqOverSoXSynthNGen4E file m 12  -- | Similar to 'uniqOverSoXSynthNGen4', but uses additional second 'Int' parameter. It defines, to which n-th elements set (see 'nkyT') belongs the obtained -- higher notes in the intervals. If that parameter equals to 12, then the function is practically equivalent to 'uniqOverSoXSynthNGen4'. To obtain -- its modifications, please, use 2, 3, 4, 6, or 9. 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@.-uniqOverSoXSynthNGen4E :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4E :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> String -> IO () uniqOverSoXSynthNGen4E file m ku ampL time3 dAmpl zs wws tts vs = do   n <- duration1000 file   unGenN4E4Gi n file m ku ampL dAmpl (str2DurationsDef n zs time3) wws tts vs  -- | Generalized version of the 'uniqOverSoXSynthNGen4E' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4EPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4EPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> String -> IO () uniqOverSoXSynthNGen4EPar file params ampL time3 dAmpl zs wws tts vs = do   n <- duration1000 file   unGenN4E4GiPar n file params ampL dAmpl (str2DurationsDef n zs time3) wws tts vs  @@ -559,21 +559,21 @@ -- | Variant of the 'uniqOverSoXSynthNGen4E4G' where 'Durations' are obtained from the 'String' using 'str2Durations' function. Helps to create a speech-like  -- composition. 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@.-uniqOverSoXSynthNGen4E4GS :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4E4GS :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> String -> IO () uniqOverSoXSynthNGen4E4GS file m ku ampL time3 dAmpl zs wws tts vs = do   n <- duration1000 file   unGenN4E4Gi n file m ku ampL dAmpl (str2Durations zs time3) wws tts vs  -- | Generalized version of the 'uniqOverSoXSynthNGen4E4GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E4GSPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4E4GSPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> String -> IO () uniqOverSoXSynthNGen4E4GSPar file params ampL time3 dAmpl zs wws tts vs = do   n <- duration1000 file   unGenN4E4GiPar n file params ampL dAmpl (str2Durations zs time3) wws tts vs    -- | Note that the last two '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 third 'Int' parameter defines that @n@.-unGenN4E4Gi :: Int -> FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> String -> IO ()+unGenN4E4Gi :: Int -> FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> String -> IO () unGenN4E4Gi n file m ku ampL dAmpl v2 wws tts vs = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -582,7 +582,7 @@  -- | Generalized version of the 'unGenN4E4Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-unGenN4E4GiPar :: Int -> FilePath -> Params -> Double -> Double -> Durations -> String -> String -> String -> IO ()+unGenN4E4GiPar :: Int -> FilePath -> Params -> Float -> Float -> Durations -> String -> String -> String -> IO () unGenN4E4GiPar n file params ampL dAmpl v2 wws tts vs = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -591,7 +591,7 @@  -- | Note that the last two '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 third 'Int' parameter defines that @n@.-unGenN4E5Gi :: Int -> FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> Intervals -> IO ()+unGenN4E5Gi :: Int -> FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> Intervals -> IO () unGenN4E5Gi n file m ku ampL dAmpl v2 wws tts v3 = do   vecA <- freqsFromFile file n   let vecB = liftInEnkuV m ku . V.map fromIntegral . V.filter (/= (11440::Int)) $ vecA@@ -600,7 +600,7 @@  -- | Generalized version of the 'unGenN4E5Gi' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-unGenN4E5GiPar :: Int -> FilePath -> Params -> Double -> Double -> Durations -> String -> String -> Intervals -> IO ()+unGenN4E5GiPar :: Int -> FilePath -> Params -> Float -> Float -> Durations -> String -> String -> Intervals -> IO () unGenN4E5GiPar n file params ampL dAmpl v2 wws tts v3 = do   vecA <- freqsFromFile file n   let vecB = liftInParamsV params . V.map fromIntegral $ vecA@@ -609,28 +609,28 @@    -- | 4G genaralized version of the 'uniqOverSoXSynthNGen4E' where you provide your own 'Durations'. 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@.-uniqOverSoXSynthNGen4E4G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4E4G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> String -> IO () uniqOverSoXSynthNGen4E4G file m ku ampL dAmpl v2 wws tts vs = do   n <- duration1000 file   unGenN4E4Gi n file m ku ampL dAmpl v2 wws tts vs  -- | Generalized version of the 'uniqOverSoXSynthNGen4E4G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E4GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> String -> String -> IO ()+uniqOverSoXSynthNGen4E4GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> String -> String -> IO () uniqOverSoXSynthNGen4E4GPar file params ampL dAmpl v2 wws tts vs = do   n <- duration1000 file   unGenN4E4GiPar n file params ampL dAmpl v2 wws tts vs  -- | 5G genaralized version of the 'uniqOverSoXSynthNGen4E' where you provide your own 'Durations' and 'Intervals'. 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@.-uniqOverSoXSynthNGen4E5G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> Intervals -> IO ()+uniqOverSoXSynthNGen4E5G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> Intervals -> IO () uniqOverSoXSynthNGen4E5G file m ku ampL dAmpl v2 wws tts v3 = do   n <- duration1000 file   unGenN4E5Gi n file m ku ampL dAmpl v2 wws tts v3  -- | Generalized version of the 'uniqOverSoXSynthNGen4E5G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E5GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> String -> Intervals -> IO ()+uniqOverSoXSynthNGen4E5GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> String -> Intervals -> IO () uniqOverSoXSynthNGen4E5GPar file params ampL dAmpl v2 wws tts v3 = do   n <- duration1000 file   unGenN4E5GiPar n file params ampL dAmpl v2 wws tts v3  @@ -638,54 +638,54 @@ -- | Variant of the 'uniqOverSoXSynthNGen4E5G' where 'Intervals' are obtained from the 'String' using 'intervalsFromStringG' function. Helps to create a speech-like  -- composition. 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@.-uniqOverSoXSynthNGen4E5GS :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> IO ()+uniqOverSoXSynthNGen4E5GS :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> IO () uniqOverSoXSynthNGen4E5GS file m ku ampL time3 dAmpl zs wws tts v3 vs = do   n <- duration1000 file   unGenN4E5Gi n file m ku ampL dAmpl (str2Durations zs time3) wws tts (intervalsFromStringG v3 vs)  -- | Generalized version of the 'uniqOverSoXSynthNGen4E5GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E5GSPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> IO ()+uniqOverSoXSynthNGen4E5GSPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> IO () uniqOverSoXSynthNGen4E5GSPar file params ampL time3 dAmpl zs wws tts v3 vs = do   n <- duration1000 file   unGenN4E5GiPar n file params ampL dAmpl (str2Durations zs time3) wws tts (intervalsFromStringG v3 vs)    -- | 6G generalized function for 'uniqOverSoXSynthNGen4E5G' where you provide your own '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@.-uniqOverSoXSynthNGen4E6G :: FilePath -> Int -> Int -> Double -> Double -> Durations -> String -> String -> Intervals -> Strengths -> Double -> IO ()+uniqOverSoXSynthNGen4E6G :: FilePath -> Int -> Int -> Float -> Float -> Durations -> String -> String -> Intervals -> Strengths -> Float -> IO () uniqOverSoXSynthNGen4E6G file m ku ampL dAmpl v2 wws tts v3 v6 limV =   uniqOverSoXSynthNGen4E5G file m ku ampL dAmpl v2 wws tts v3 >> apply6G2 v6 "221w" "result" limV >> endFromResult  -- | Generalized version of the 'uniqOverSoXSynthNGen4E6G' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E6GPar :: FilePath -> Params -> Double -> Double -> Durations -> String -> String -> Intervals -> Strengths -> Double -> IO ()+uniqOverSoXSynthNGen4E6GPar :: FilePath -> Params -> Float -> Float -> Durations -> String -> String -> Intervals -> Strengths -> Float -> IO () uniqOverSoXSynthNGen4E6GPar file params ampL dAmpl v2 wws tts v3 v6 limV =   uniqOverSoXSynthNGen4E5GPar file params ampL dAmpl v2 wws tts v3 >> apply6G2 v6 "221w" "result" limV >> endFromResult   -- | A variant of 'uniqOverSoXSynthNGen4E6G' where 'Strengths' are obtained from a Ukrainian text specified as the last 'String' argument. 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@.-uniqOverSoXSynthNGen4E6GS :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> -  String -> Double -> IO ()+uniqOverSoXSynthNGen4E6GS :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> +  String -> Float -> IO () uniqOverSoXSynthNGen4E6GS file m ku ampL time3 dAmpl zs wws tts v5 vs xxs limV =   uniqOverSoXSynthNGen4E6G file m ku ampL dAmpl (str2Durations zs time3) wws tts (intervalsFromStringG v5 vs) (str2Volume xxs) limV  -- | Generalized version of the 'uniqOverSoXSynthNGen4E6GS' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E6GSPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> String -> Intervals -> String -> -  String -> Double -> IO ()+uniqOverSoXSynthNGen4E6GSPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> String -> Intervals -> String -> +  String -> Float -> IO () uniqOverSoXSynthNGen4E6GSPar file params ampL time3 dAmpl zs wws tts v5 vs xxs limV =   uniqOverSoXSynthNGen4E6GPar file params ampL dAmpl (str2Durations zs time3) wws tts (intervalsFromStringG v5 vs) (str2Volume xxs) limV    -- | A variant of 'uniqOverSoXSynthNGen4E6GS' where 'Strengths' and 'Durations' are obtained from the same Ukrainian text specified as --- the last 'String' argument. The second 'Double' argument is an average duration of the sounds in seconds. +-- the last 'String' argument. The second 'Float' argument is an average duration of the sounds in seconds.  -- 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@.-uniqOverSoXSynthNGen4E6GSu :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> Intervals -> String -> String -> Double -> IO ()+uniqOverSoXSynthNGen4E6GSu :: FilePath -> Int -> Int -> Float -> Float -> Float -> String -> String -> Intervals -> String -> String -> Float -> IO () uniqOverSoXSynthNGen4E6GSu file m ku ampL time3 dAmpl wws tts v5 vs xxs limV =   uniqOverSoXSynthNGen4E6G file m ku ampL dAmpl (str2Durations xxs time3) wws tts (intervalsFromStringG v5 vs) (str2Volume xxs) limV   -- | Generalized version of the 'uniqOverSoXSynthNGen4E6GSu' where instead of lifting with 'liftInEnkuV' 'liftInParamsV' is used. It allows e. g. to  -- use some tonality. For more information, please, refer to 'filterInParams'.-uniqOverSoXSynthNGen4E6GSuPar :: FilePath -> Params -> Double -> Double -> Double -> String -> String -> Intervals -> String -> String -> Double -> IO ()+uniqOverSoXSynthNGen4E6GSuPar :: FilePath -> Params -> Float -> Float -> Float -> String -> String -> Intervals -> String -> String -> Float -> IO () uniqOverSoXSynthNGen4E6GSuPar file params ampL time3 dAmpl wws tts v5 vs xxs limV =   uniqOverSoXSynthNGen4E6GPar file params ampL dAmpl (str2Durations xxs time3) wws tts (intervalsFromStringG v5 vs) (str2Volume xxs) limV

@@ -3,7 +3,7 @@                   ***** Usage *****-                -----------------+                =================  You can use it as a library or as an executable. @@ -263,7 +263,7 @@ in the second command line arguments.                  ***** Examples *****-                --------------------+                ====================  Starting from the 0.24.0.0 version, you can refer to examples in the GitHub special repository (https://github.com/OleksandrZhabenko/dobutokO2-examples/). @@ -272,7 +272,7 @@                   ***** Support for not Sound File Variativity Sources *****-                ----------------------------------------------------------+                ==========================================================                  Since 0.28.0.0 version the library supports not only the sound file as a  variativity source but also other types of files. They are used through @@ -286,3 +286,7 @@ logical and semantic structure. The most complicated functions from  DobutokO.Sound.Functional module are moved to a new package dobutokO3. Some code  improvements.++Since 0.42.0.0 version it uses Float instead of Double where possible. Double precision +is redundant. The shift is inspired by: https://www.youtube.com/watch?v=FYTZkE5BZ-0+

@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                dobutokO2-version:             0.41.0.0+version:             0.42.0.0 synopsis:            Helps to create experimental music from a file (or its part) and a Ukrainian text. description:         It can also generate a timbre for the notes. Uses SoX inside. homepage:            https://hackage.haskell.org/package/dobutokO2@@ -20,7 +20,7 @@   exposed-modules:     Main, DobutokO.Sound.Overtones, DobutokO.Sound.Uniq, DobutokO.Sound.Functional, DobutokO.Sound.Process, DobutokO.Sound.Executable, DobutokO.Sound.IntermediateF, DobutokO.Sound.ParseList, DobutokO.Sound.Keyboard, DobutokO.Sound.Functional.Basics, DobutokO.Sound.Functional.Params, DobutokO.Sound.Functional.Split, DobutokO.Sound.DIS5G6G, DobutokO.Sound.Functional.Elements, DobutokO.Sound.Decibel, DobutokO.Sound.Extended, DobutokO.Sound.Octaves, DobutokO.Sound.FunctionF   -- other-modules:   -- other-extensions:-  build-depends:       base >=4.7 && <4.15, bytestring >= 0.10.6 && <1, vector >=0.11 && <0.14, process >=1.4 && <1.9, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.6.7 && <1, directory >=1.2.7 && <1.7, mmsyn7ukr >=0.15.4 && <1, mmsyn2 >=0.1.8 && <1, mmsyn6ukr >=0.7.2 && <1, mmsyn7l >=0.5 && <1+  build-depends:       base >=4.7 && <4.15, bytestring >= 0.10.6 && <1, vector >=0.11 && <0.14, process >=1.4 && <1.9, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.7 && <1, directory >=1.2.7 && <1.7, mmsyn7ukr >=0.16 && <1, mmsyn2 >=0.1.8 && <1, mmsyn6ukr >=0.7.2 && <1, mmsyn7l >=0.7 && <1   -- hs-source-dirs:   default-language:    Haskell2010 @@ -28,7 +28,7 @@   main-is:             Main.hs   -- other-modules:   -- other-extensions:-  build-depends:       base >=4.7 && <4.15, bytestring >= 0.10.6 && <1, vector >=0.11 && <0.14, process >=1.4 && <1.9, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.6.7 && <1, directory >=1.2.7 && <1.7, mmsyn7ukr >=0.15.4 && <1, mmsyn2 >=0.1.8 && <1, mmsyn6ukr >=0.7.2 && <1, mmsyn7l >=0.5 && <1+  build-depends:       base >=4.7 && <4.15, bytestring >= 0.10.6 && <1, vector >=0.11 && <0.14, process >=1.4 && <1.9, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.7 && <1, directory >=1.2.7 && <1.7, mmsyn7ukr >=0.16 && <1, mmsyn2 >=0.1.8 && <1, mmsyn6ukr >=0.7.2 && <1, mmsyn7l >=0.7 && <1   -- hs-source-dirs:   default-language:    Haskell2010