diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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. diff --git a/DobutokO/Sound/DIS5G6G.hs b/DobutokO/Sound/DIS5G6G.hs --- a/DobutokO/Sound/DIS5G6G.hs +++ b/DobutokO/Sound/DIS5G6G.hs @@ -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) diff --git a/DobutokO/Sound/Decibel.hs b/DobutokO/Sound/Decibel.hs --- a/DobutokO/Sound/Decibel.hs +++ b/DobutokO/Sound/Decibel.hs @@ -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. diff --git a/DobutokO/Sound/Executable.hs b/DobutokO/Sound/Executable.hs --- a/DobutokO/Sound/Executable.hs +++ b/DobutokO/Sound/Executable.hs @@ -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 "" diff --git a/DobutokO/Sound/FunctionF.hs b/DobutokO/Sound/FunctionF.hs --- a/DobutokO/Sound/FunctionF.hs +++ b/DobutokO/Sound/FunctionF.hs @@ -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 = diff --git a/DobutokO/Sound/Functional.hs b/DobutokO/Sound/Functional.hs --- a/DobutokO/Sound/Functional.hs +++ b/DobutokO/Sound/Functional.hs @@ -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 diff --git a/DobutokO/Sound/Functional/Basics.hs b/DobutokO/Sound/Functional/Basics.hs --- a/DobutokO/Sound/Functional/Basics.hs +++ b/DobutokO/Sound/Functional/Basics.hs @@ -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"] diff --git a/DobutokO/Sound/Functional/Elements.hs b/DobutokO/Sound/Functional/Elements.hs --- a/DobutokO/Sound/Functional/Elements.hs +++ b/DobutokO/Sound/Functional/Elements.hs @@ -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))) diff --git a/DobutokO/Sound/Functional/Params.hs b/DobutokO/Sound/Functional/Params.hs --- a/DobutokO/Sound/Functional/Params.hs +++ b/DobutokO/Sound/Functional/Params.hs @@ -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) diff --git a/DobutokO/Sound/Functional/Split.hs b/DobutokO/Sound/Functional/Split.hs --- a/DobutokO/Sound/Functional/Split.hs +++ b/DobutokO/Sound/Functional/Split.hs @@ -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 diff --git a/DobutokO/Sound/Octaves.hs b/DobutokO/Sound/Octaves.hs --- a/DobutokO/Sound/Octaves.hs +++ b/DobutokO/Sound/Octaves.hs @@ -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) -------------------------------------------------------------------------------------------------------------------------------- diff --git a/DobutokO/Sound/Overtones.hs b/DobutokO/Sound/Overtones.hs --- a/DobutokO/Sound/Overtones.hs +++ b/DobutokO/Sound/Overtones.hs @@ -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) diff --git a/DobutokO/Sound/Process.hs b/DobutokO/Sound/Process.hs --- a/DobutokO/Sound/Process.hs +++ b/DobutokO/Sound/Process.hs @@ -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 diff --git a/DobutokO/Sound/Uniq.hs b/DobutokO/Sound/Uniq.hs --- a/DobutokO/Sound/Uniq.hs +++ b/DobutokO/Sound/Uniq.hs @@ -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 diff --git a/README.markdown b/README.markdown --- a/README.markdown +++ b/README.markdown @@ -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 + diff --git a/dobutokO2.cabal b/dobutokO2.cabal --- a/dobutokO2.cabal +++ b/dobutokO2.cabal @@ -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