-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A program and a library to create experimental music from a mono audio and a Ukrainian text
--   
--   It can also create a timbre for the notes
@package dobutokO2
@version 0.16.0.0


-- | Maintainer : olexandr543@yahoo.com
--   
--   A program and a library to create experimental music from a mono audio
--   and a Ukrainian text.
module DobutokO.Sound

-- | For the given frequency of the note it generates a <a>Vector</a> of
--   the tuples, each one of which contains the harmonics' frequency and
--   amplitude.
oberTones :: Double -> Vector (Double, Double)

-- | 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.
oberSoXSynth :: Double -> IO ()

-- | Function to create a melody for the given arguments. <a>String</a> 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 <a>Double</a> argument from the
--   range [0.01..1.0] is used as a maximum amplitude for obertones. If it
--   is set to 1.0 the obertones amplitudes are just the maximum ones,
--   otherwise they are multiplied by the parameter and this results in
--   their becoming more silent ones. The second <a>Double</a> 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.
oberSoXSynthN :: Int -> Double -> Double -> String -> Vector Double -> IO ()

-- | For the given frequency of the note and a Ukrainian text it generates
--   a <a>Vector</a> of the tuples, each one of which contains the
--   harmonics' frequency and amplitude. The <a>String</a> is used to
--   produce the signs for harmonics coefficients.
oberTones2 :: Double -> String -> Vector (Double, Double)

-- | 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*" files in the current directory, because they can be
--   overwritten. The <a>String</a> argument is used to define signs of the
--   harmonics coefficients for obertones.
oberSoXSynth2 :: Double -> String -> IO ()

-- | Function to create a melody for the given arguments. <a>String</a> 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 <a>Double</a> argument from the
--   range [0.01..1.0] is used as a maximum amplitude for obertones. If it
--   is set to 1.0 the obertones amplitudes are just the maximum ones,
--   otherwise they are multiplied by the parameter and this results in
--   their becoming more silent ones. The second <a>Double</a> 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.
oberSoXSynthN2 :: Int -> Double -> Double -> String -> String -> Vector Double -> IO ()

-- | Function to create a melody for the given arguments. <a>String</a> 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 <a>Double</a> argument from the
--   range [0.01..1.0] is used as a maximum amplitude for obertones. If it
--   is set to 1.0 the obertones amplitudes are just the maximum ones,
--   otherwise they are multiplied by the parameter and this results in
--   their becoming more silent ones. The second <a>Double</a> 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
--   <a>String</a> argument is used to define the intervals for the notes
--   if any. The third <a>Double</a> 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 obertones are greater than for the main
--   note obetones. The last one is experimental feature.
oberSoXSynthN3 :: Int -> Double -> Double -> Double -> String -> String -> String -> Vector Double -> IO ()

-- | Similar to <a>oberSoXSynth</a> except that takes not necessarily pure
--   lower quint note as the second one, but the one specified by the
--   <a>String</a> parameter as an argument to <a>dNote</a>. If you begin
--   the <a>String</a> 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 obertones.
oberSoXSynthDN :: Double -> String -> IO ()

-- | Similar to <a>oberSoXSynthDN</a> except that the resulting duration is
--   specified by the second <a>Double</a> parameter in seconds. For
--   <a>oberSoXSynthDN</a> it is equal to 0.5.
oberSoXSynth2DN :: Double -> Double -> String -> IO ()

-- | Similar to <a>oberSoXSynthN</a>, but uses a sound file to obtain the
--   information analogous to <a>Vector</a> in the latter one. Besides, the
--   function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just maximum ones, otherwise they are multiplied by the
--   parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file.
oberSoXSynthNGen :: FilePath -> Int -> Double -> Double -> String -> IO ()

-- | Similar to <a>oberSoXSynthN2</a>, but uses a sound file to obtain the
--   information analogous to <a>Vector</a> in the latter one. Besides, the
--   function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just maximum ones, otherwise they are multiplied by the
--   parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file. The second <a>String</a> argument is used to define signs of the
--   harmonics coefficients in the generated sounds.
oberSoXSynthNGen2 :: FilePath -> Int -> Double -> Double -> String -> String -> IO ()

-- | Similar to <a>oberSoXSynthN2</a>, but uses a sound file to obtain the
--   information analogous to <a>Vector</a> in the latter one. Besides, the
--   function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just maximum ones, otherwise they are multiplied by the
--   parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file. The second <a>String</a> argument is used to define signs of the
--   harmonics coefficients in the generated sounds. The third
--   <a>String</a> argument is used to define the intervals for the notes
--   if any. The third <a>Double</a> 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 obertones are greater than for the main
--   note obetones. The last one is experimental feature.
oberSoXSynthNGen3 :: FilePath -> Int -> Double -> Double -> Double -> String -> String -> String -> IO ()

-- | For the given frequency of the note it generates a <a>Vector</a> of
--   the tuples, each one of which contains the harmonics' frequency and
--   amplitude. For every given <a>String</a> structure of the uniqueness
--   (see the documentation for <tt>mmsyn7s</tt> package and its
--   <a>Syllable</a> module) it produces the unique timbre.
uniqOberTonesV :: Double -> String -> Vector (Double, Double)

-- | For the given frequency and a Ukrainian text it generates a musical
--   sound with the timbre obtained from the Ukrainian text (see the
--   documentation for <tt>mmsyn7s</tt> package). The timbre for another
--   given text usually differs, but can be the same. The last one is only
--   if the uniqueness structure and length are the same for both
--   <a>String</a>. Otherwise, they differs. This gives an opportunity to
--   practically 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.
uniqOberSoXSynth :: Double -> String -> IO ()

-- | Function to create a melody for the given arguments. The first
--   <a>String</a> 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
--   <a>Double</a> argument from the range [0.01..1.0] is used as a maximum
--   amplitude for obertones. If it is set to 1.0 the obertones 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
--   <a>Int</a> 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 <a>Double</a>
--   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.
uniqOberSoXSynthN :: Int -> Double -> Double -> String -> String -> Vector Double -> IO ()

-- | For the given frequency of the note it generates a <a>Vector</a> of
--   the tuples, each one of which contains the harmonics' frequency and
--   amplitude. For every given first <a>String</a> argument structure of
--   the uniqueness (see the documentation for <tt>mmsyn7s</tt> package and
--   its <a>Syllable</a> module) it produces the unique timbre. The second
--   <a>String</a> is used to produce the signs for harmonics coefficients.
uniqOberTonesV2 :: Double -> String -> String -> Vector (Double, Double)

-- | For the given frequency and a Ukrainian text it generates a musical
--   sound with the timbre obtained from the Ukrainian text (see the
--   documentation for <tt>mmsyn7s</tt> package). The timbre for another
--   given text usually differs, but can be the same. The last one is only
--   if the uniqueness structure and length are the same for both
--   <a>String</a>. Otherwise, they differs. This gives an opportunity to
--   practically 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. The second <a>String</a> argument is used to define signs
--   for the harmonics coefficients for obertones.
uniqOberSoXSynth2 :: Double -> String -> String -> IO ()

-- | Function to create a melody for the given arguments. The first
--   <a>String</a> 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
--   <a>Double</a> argument from the range [0.01..1.0] is used as a maximum
--   amplitude for obertones. If it is set to 1.0 the obertones 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
--   <a>Int</a> 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 <a>Double</a>
--   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 <a>String</a> argument is used to define signs
--   of the harmonics coefficients in the generated sounds.
uniqOberSoXSynthN3 :: Int -> Double -> Double -> String -> String -> String -> Vector Double -> IO ()

-- | Function to create a melody for the given arguments. The first
--   <a>String</a> 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
--   <a>Double</a> argument from the range [0.01..1.0] is used as a maximum
--   amplitude for obertones. If it is set to 1.0 the obertones 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
--   <a>Int</a> 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 <a>Double</a>
--   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 <a>String</a> argument is used to define signs
--   of the harmonics coefficients in the generated sounds. The fourth
--   <a>String</a> argument is used to define the intervals for the notes
--   if any. The third <a>Double</a> 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 obertones are greater than for the main
--   note obetones. The last one is experimental feature.
uniqOberSoXSynthN4 :: Int -> Double -> Double -> Double -> String -> String -> String -> String -> Vector Double -> IO ()

-- | Similar to <a>uniqOberSoXSynthN</a>, but uses a sound file to obtain
--   the information analogous to <a>Vector</a> in the latter one. Besides,
--   the function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just the maximum ones, otherwise they are multiplied by
--   the parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file.
uniqOberSoXSynthNGen :: FilePath -> Int -> Double -> Double -> String -> String -> IO ()

-- | Similar to <a>uniqOberSoXSynthN</a>, but uses a sound file to obtain
--   the information analogous to <a>Vector</a> in the latter one. Besides,
--   the function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just the maximum ones, otherwise they are multiplied by
--   the parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file. The third <a>String</a> argument is used to define signs of the
--   harmonics coefficients in the generated sounds.
uniqOberSoXSynthNGen3 :: FilePath -> Int -> Double -> Double -> String -> String -> String -> IO ()

-- | Similar to <a>uniqOberSoXSynthN</a>, but uses a sound file to obtain
--   the information analogous to <a>Vector</a> in the latter one. Besides,
--   the function lifts the frequencies to the octave with the given by
--   <a>Int</a> parameter number (better to use from the range [1..8]). The
--   first <a>Double</a> argument from the range [0.01..1.0] is used as a
--   maximum amplitude for obertones. If it is set to 1.0 the obertones
--   amplitudes are just the maximum ones, otherwise they are multiplied by
--   the parameter and this results in their becoming more silent ones. The
--   second <a>Double</a> 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 <a>FilePath</a> should be a filepath for the .wav
--   file. The third <a>String</a> argument is used to define signs of the
--   harmonics coefficients in the generated sounds. The fourth
--   <a>String</a> argument is used to define the intervals for the notes
--   if any. The third <a>Double</a> 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 obertones are greater than for the main
--   note obetones. The last one is an experimental feature.
uniqOberSoXSynthNGen4 :: FilePath -> Int -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()

-- | Returns a <a>Vector</a> of tuples with the lowest and highest
--   frequencies for the notes in the octaves.
octavesT :: Vector (Double, Double)

-- | Returns an analogous note in the higher octave (its frequency in Hz).
octaveUp :: Double -> Double

-- | Returns an analogous note in the lower octave (its frequency in Hz).
octaveDown :: Double -> Double

-- | 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 <a>closestNote</a> 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 <a>Nothing</a>.
whichOctave :: Double -> Maybe Int

-- | Function lifts the given frequency to the given number of the octave
--   (in American notation, from 0 to 8). This number is an <a>Int</a>
--   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 <a>Nothing</a>.
liftInOctave :: Int -> Double -> Maybe Double

-- | Function lifts the <a>Vector</a> of <a>Double</a> representing
--   frequencies to the given octave with the <a>Int</a> 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 <a>Vector</a>.
liftInOctaveV :: Int -> Vector Double -> Vector Double

-- | Returns a <a>Vector</a> of tuples with the lowest and highest
--   frequencies for the notes in the sets consisting of <tt>n</tt>
--   consequential notes (including semi-tones). An <a>Int</a> parameter
--   defines this <tt>n</tt>. It can be 2, 3, 4, 6, 9, or 12 (the last one
--   is for default octaves, see <a>octavesT</a>). So for different valid
--   <tt>n</tt> you obtain doubles, triples and so on. The function being
--   applied returns a <a>Vector</a> of such sets with their respective
--   lowest and highest frequencies.
nkyT :: Int -> Vector (Double, Double)

-- | Returns an analogous note in the higher n-th elements set (its
--   frequency in Hz) (see <a>nkyT</a>). An <a>Int</a> parameter defines
--   this <tt>n</tt>.
enkuUp :: Int -> Double -> Double

-- | Returns an analogous note in the lower n-th elements set (its
--   frequency in Hz) (see <a>nkyT</a>). An <a>Int</a> parameter defines
--   this <tt>n</tt>.
enkuDown :: Int -> Double -> Double

-- | Similarly to <a>whichOctave</a> returns a <a>Maybe</a> number
--   (actually frequency) for the n-th elements set of notes (see
--   <a>nkyT</a>). An <a>Int</a> parameter defines that <tt>n</tt>.
whichEnka :: Int -> Double -> Maybe Int

-- | Similarly to <a>liftInOctave</a> returns a <a>Maybe</a> number
--   (actually frequency) for the n-th elements set of notes (see
--   <a>nkyT</a>). A second <a>Int</a> parameter defines that <tt>n</tt>.
liftInEnku :: Int -> Int -> Double -> Maybe Double

-- | Similarly to <a>liftInOctaveV</a> returns a <a>Vector</a>
--   <a>Double</a> (actually frequencies) for the n-th elements set of
--   notes (see <a>nkyT</a>) instead of octaves. A second <a>Int</a>
--   parameter defines that <tt>n</tt>.
liftInEnkuV :: Int -> Int -> Vector Double -> Vector Double
dviykyTA :: Vector (Double, Double)
triykyTA :: Vector (Double, Double)
chetvirkyTA :: Vector (Double, Double)
p'yatirkyTA :: Vector (Double, Double)
shistkyTA :: Vector (Double, Double)
simkyTA :: Vector (Double, Double)
visimkyTA :: Vector (Double, Double)
dev'yatkyTA :: Vector (Double, Double)
desyatkyTA :: Vector (Double, Double)
odynadtsyatkyTA :: Vector (Double, Double)
octavesTA :: Vector (Double, Double)

-- | Similar to <a>oberSoXSynthNGen</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>oberSoXSynthNGen</a>. To obtain its modifications,
--   please, use 2, 3, 4, 6, or 9.
oberSoXSynthNGenE :: FilePath -> Int -> Int -> Double -> Double -> String -> IO ()

-- | Similar to <a>oberSoXSynthNGen2</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>oberSoXSynthNGen2</a>. To obtain its modifications,
--   please, use 2, 3, 4, 6, or 9.
oberSoXSynthNGen2E :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()

-- | Similar to <a>oberSoXSynthNGen3</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>oberSoXSynthNGen3</a>. To obtain its modifications,
--   please, use 2, 3, 4, 6, or 9.
oberSoXSynthNGen3E :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> IO ()

-- | Similar to <a>uniqOberSoXSynthNGen</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>uniqOberSoXSynthNGen</a>. To obtain its
--   modifications, please, use 2, 3, 4, 6, or 9.
uniqOberSoXSynthNGenE :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> IO ()

-- | Similar to <a>uniqOberSoXSynthNGen3</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>uniqOberSoXSynthNGen3</a>. To obtain its
--   modifications, please, use 2, 3, 4, 6, or 9.
uniqOberSoXSynthNGen3E :: FilePath -> Int -> Int -> Double -> Double -> String -> String -> String -> IO ()

-- | Similar to <a>uniqOberSoXSynthNGen4</a>, but uses additional second
--   <a>Int</a> parameter. It defines, to which n-th elements set (see
--   <a>nkyT</a>) belongs the obtained higher notes in the intervals. If
--   that parameter equals to 12, then the function is practically
--   equivalent to <a>uniqOberSoXSynthNGen4</a>. To obtain its
--   modifications, please, use 2, 3, 4, 6, or 9.
uniqOberSoXSynthNGen4E :: FilePath -> Int -> Int -> Double -> Double -> Double -> String -> String -> String -> String -> IO ()

-- | <a>Vector</a> of musical notes in Hz.
notes :: Vector Double

-- | 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 -> Vector Double -> (Double, Double)

-- | Returns the closest note to the given frequency in Hz.
closestNote :: Double -> Double

-- | Returns a pure quint lower than the given note.
pureQuintNote :: Double -> Double

-- | 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.
syllableStr :: Int -> String -> [Int]

-- | Additional function to produce signs from the given <a>String</a> of
--   the Ukrainian text. Ukrainian vowels and voiced consonants gives "+"
--   sign (+1), voiceless and sonorous consonants gives "-" sign (-1).
--   Voiceless2 gives "0". Other symbols are not taken into account.
signsFromString :: Int -> String -> Vector Int

-- | Additional function to prepend zeroes to the given <a>String</a>. The
--   number of them are just that one to fulfill the length to the given
--   <a>Int</a> parameter.
prependZeroes :: Int -> String -> String

-- | Function is used to get numbers of intervals from a Ukrainian
--   <a>String</a>. It is used internally in the <a>uniqOberSoXSynthN4</a>
--   function.
intervalsFromString :: String -> Vector Int

-- | Function to get from the number of semi-tones and a note a
--   <a>Maybe</a> 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
--   <a>Nothing</a>.
dNote :: Int -> Double -> Maybe Double

-- | Is a minimal number of decimal places that are just enough to
--   represent a length of the <a>Vector</a> given. For an <a>empty</a>
--   returns 0.
numVZeroesPre :: Vector a -> Int


-- | Maintainer : olexandr543@yahoo.com
--   
--   A program and a library to create experimental music from a mono audio
--   and a Ukrainian text.
module DobutokO.Sound.Functional

-- | Similar to <a>oberSoXSynth2DN</a> but instead of <a>oberTones</a>
--   function, it uses volatile function <tt>f::Double -&gt; Vector
--   (Double, Double)</tt> with somewhat sophisticated mechanism to
--   normalize the resulting <a>Vector</a> elements <tt>(Double,
--   Double)</tt>. 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
--   <a>convertToProperUkrainian</a> to the <a>String</a> parameter must
--   not be <a>empty</a>.
--   
--   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 <a>oberSoXSynth2FDN</a>.
oberSoXSynth2FDN :: (Double -> Vector (Double, Double)) -> (Double, Double) -> String -> IO ()

-- | Similar to <a>oberSoXSynth2DN</a> but instead of <a>oberTones</a>
--   function, it uses volatile function <tt>f::Double -&gt; Vector
--   (Double, Double)</tt> with somewhat sophisticated mechanism to
--   normalize the resulting <a>Vector</a> elements <tt>(Double,
--   Double)</tt>. 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
--   <a>convertToProperUkrainian</a> to the <a>String</a> parameter must
--   not be <a>empty</a>. The function also tries to perform filtering to
--   avoid possible beating. The third <a>Double</a> 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
--   <tt>[0.1..10.0]</tt>.
--   
--   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 <a>oberSoXSynth2FDN_B</a>.
oberSoXSynth2FDN_B :: (Double -> Vector (Double, Double)) -> (Double, Double, Double) -> String -> IO ()

-- | Similar to <a>oberSoXSynth2FDN</a> but it does not make any
--   normalizing transformations with the <a>Vector</a> argument. To be
--   used properly, it is needed that every second element in the tuple in
--   the <a>Vector</a> argument must be in the range [-1.0..1.0] and every
--   first element must be in between 16.351597831287414 and
--   7902.132820097988 (Hz).
--   
--   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 <a>oberSoXSynth2FDN_S</a>.
oberSoXSynth2FDN_S :: (Double -> Vector (Double, Double)) -> (Double, Double) -> String -> IO ()

-- | Similar to <a>oberSoXSynth2FDN_S</a> but additionally the program
--   filters out from the resulting <a>Vector</a> after "f" application
--   values that are smaller by absolute value than 0.001.
--   
--   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 <a>oberSoXSynth2FDN_Sf</a>.
oberSoXSynth2FDN_Sf :: (Double -> Vector (Double, Double)) -> (Double, Double) -> String -> IO ()

-- | Similar to <a>oberSoXSynth2FDN_S</a> but additionally the program
--   filters out from the resulting <a>Vector</a> after "f" application
--   values that are smaller than the third <a>Double</a> parameter by an
--   absolute value in the triple of <tt>Double</tt>'s.
--   
--   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 <a>oberSoXSynth2FDN_Sf3</a>.
oberSoXSynth2FDN_Sf3 :: (Double -> Vector (Double, Double)) -> (Double, Double, Double) -> String -> IO ()


-- | Maintainer : olexandr543@yahoo.com
--   
--   A program and a library to create experimental music from a mono audio
--   and a Ukrainian text.
module DobutokO.Sound.IntermediateF

-- | Gets sizes of the "result*.wav" files in the current directory.
getFileRSizes :: IO (Vector Integer)

-- | Similar to <a>getFileRSizes</a>, but sizes are <a>Int</a>, not
--   <a>Integer</a>. For most cases it is more memory efficient.
getFileRSizesS :: IO (Vector Int)

-- | Variant of <a>getFileRSizes</a> function.
getFileRSizesS2 :: IO (Vector Int)

-- | Gets <a>Vector</a> of tuples of the pairs of "result*.wav" files and
--   their respective sizes.
getFileRTuples :: IO (Vector (FilePath, Integer))

-- | Gets <a>Vector</a> of the filenames for "result*.wav" files in the
--   current directory.
listVDirectory :: IO (Vector FilePath)

-- | Function-predicate to check whether a file corresponding to its
--   <a>String</a> argument is considered as one of higher quality and
--   therefore can be used to replace the not so suitable ones while
--   processing.
isHighQ :: String -> Bool

-- | Function-predicate to check whether a file corresponding to its
--   <a>String</a> argument is needed to be replaced while processing.
shouldBeReplaced :: String -> Bool

-- | Gets an index of the <a>Vector</a> element corresponding to the
--   <a>String</a> generated by <a>playAndMark</a> function.
indexesFromMrk :: String -> Int

-- | During function evaluation you can listen to the sound files and mark
--   them with "1" and "0". The first one means that the sound is
--   considered of higher quality and is intended to be used as a
--   replacement for the worse sounds markd by "0". The function returns a
--   <a>Vector</a> of specially formatted <a>String</a> that represents
--   only those files that are connected with the replacement procedure.
playAndMark :: Vector FilePath -> IO (Vector String)

-- | Function <a>playAndMark</a> applied to all the "result*.wav" files in
--   the current directory.
playAMrk :: IO (Vector String)

-- | Process the sound corresponding to the first element in the first
--   argument. Returns a <a>tail</a> of the first element of the first
--   command line argument. Replaces (if specified) the sound with a
--   sequence of (or just one, or made no replacement at all) sounds
--   considered of higher quality.
pAnR1 :: Vector String -> IO (Vector String)

-- | Process the sounds consequently corresponding to the elements in the
--   first argument. Replaces (if specified) the sounds with a sequence of
--   (or just one, or made no replacement at all) sounds considered of
--   higher quality for every sound needed.
pAnR2 :: Vector String -> IO ()

-- | Marks the needed files as of needed to be replaced or those ones
--   considered of higher quality that will replace the needed ones. Then
--   actually replaces them as specified. Uses internally <a>playAMrk</a>
--   and <a>pAnR2</a> functions.
pAnR_ :: IO ()

-- | Parser to the result of <a>listVDirectory</a> function to get the
--   needed information.
infoFromV :: Vector String -> [(Vector Int, Vector String)]

-- | Used to obtain parameters for processment.
internalConv :: ([String], [String]) -> (Vector Int, Vector String)

-- | Axiliary function to get a <a>String</a> of consequent digits in the
--   name of the "result*.wav" file.
ixFromRes :: String -> String

-- | Given an index of the element in the <a>listVDirectory</a> output
--   returns a tuple of the boundaries of the indexes usable for playback.
--   Note: index0 is probably from [0..], l1 is necessarily from [0..].
--   Interesting case is: 0 &lt;= index0 &lt; l1.
ixInterv :: Int -> IO (Int, Int)

-- | <a>IO</a> checkbox whether to add the sound played to the sequence of
--   sounds that will replace the needed one.
thisOne :: IO Bool

-- | Plays a sequence of sounds in the interval of them obtained by
--   <a>ixInterv</a> function.
playSeqAR :: Int -> IO ()

-- | Plays a sequence of consequential sounds in the melody in the interval
--   of them obtained by <a>ixInterv</a> function for each element index
--   from <a>Vector</a> of indexes.
playSeqARV :: Vector Int -> IO ()

-- | Plays a sequence of sounds considered of higher quality.
playSeqARV2 :: Vector String -> IO ()

-- | Plays a sound file considered to be of higher quality and then you
--   define whether to use the played sound to replace that one considered
--   to be replaced.
playCollect1Dec :: Vector String -> Int -> IO Bool

-- | The same as <a>playSeqARV2</a>, but additionally collects the
--   resulting <a>Bool</a> values and then returns them. It is used to
--   define, which sounds from those of higher quality will replace those
--   ones considered to be replaced.
playCollectDec :: Vector String -> IO (Vector Bool)

-- | Actually replaces the file represented by <a>FilePath</a> argument
--   with no (then there is no replacement at all), or with just one, or
--   with a sequence of sounds being considered of higher quality to form a
--   new melody. If the lengths of the second and the third arguments
--   differs from each other then the function uses as these arguments
--   truncated vectors of the minimal of the two lengths.
replaceWithHQs :: FilePath -> Vector Bool -> Vector FilePath -> IO ()


-- | Maintainer : olexandr543@yahoo.com
--   
--   A program and a library to create experimental music from a mono audio
--   and a Ukrainian text.
module DobutokO.Sound.Executable

-- | Function that actually makes processing in the <tt>dobutokO2</tt>
--   executable. 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.
dobutokO2 :: IO ()

-- | Function records and processes the sound data needed to generate the
--   "end.wav" file in the <a>dobutokO2</a> function. Please, check before
--   executing whether there is no "x.wav" file in the current directory,
--   because it can be overwritten.
recAndProcess :: FilePath -> Int -> IO String

-- | Used to obtain one multiline specially formatted textual input and do
--   the full processment for the sound. The function generates obertones
--   using additional <a>String</a> and allows maximum control over the
--   parameters. Besides, all the needed information it obtains from the
--   singular formatted input, which can be ended with a keyboard keys
--   combination that means an end of input (e. g. for Unices, that is
--   probably Ctrl + D). '@' are separators for the input parts for their
--   respective parts. For more information about the format of the single
--   input, see:
--   
--   'https://drive.google.com/open?id=10Z_GRZR4TKoL5KXfqPm-t-4humuHN0O4'
--   
--   The file is also provided with the package as text.dat.txt. The last
--   two or three inputs (an input just here means a textual input between
--   two '@') can be omitted, the program will work also but with less
--   control for the user possible.
dobutokO2H7 :: Bool -> String -> FilePath -> IO ()

-- | Actually works as <a>pAnR_</a> function.
dobutokO2H9 :: Bool -> String -> FilePath -> IO ()


-- | Maintainer : olexandr543@yahoo.com
--   
--   A program and a library to create experimental music from a mono audio
--   and a Ukrainian text.
module Main
main :: IO ()