packages feed

phonetic-languages-phonetics-basics 0.6.1.0 → 0.6.2.0

raw patch · 8 files changed

+155/−135 lines, 8 files

Files

ChangeLog.md view
@@ -72,3 +72,8 @@  * Sixth version revised B. Fixed issues with wrong order of the concatenations in the Data.Phonetic.Languages.PrepareText functions. Added some new functions for this.++## 0.6.2.0 -- 2021-05-10++* Sixth version revised C. Some documentation improvements. Fixed issues with being not compiled because of 2 doc-style comments+(thanks to: Jonathan Ringer at notifications@github.com).
Data/Phonetic/Languages/Base.hs view
@@ -181,39 +181,36 @@         stringToX' rss m vs = bs : stringToX' rss m us            where (!bs,!us) = f vs m rss -{-| Uses the simplest variant of the 'GWritingSystemPRPLX' with just two generations where all the 'PREmptyC' elements in the-'WritingSystemPRPLX' are used in the last order. Can be suitable for simple languages (e. g. Esperanto).--}+-- | Uses the simplest variant of the 'GWritingSystemPRPLX' with just two generations where all the 'PREmptyC' elements in the+-- 'WritingSystemPRPLX' are used in the last order. Can be suitable for simple languages (e. g. Esperanto). string2X :: WritingSystemPRPLX -> String -> [PhoneticsRepresentationPLX] string2X xs = stringToXG [(zs,1),(ys,0)]   where (ys,zs) = partition isPREmptyC xs {-# INLINE string2X #-} -{-| Each generation represents a subset of rules for representation transformation. The 'PhoneticsRepresentationPLX'-are groupped by the generations so that in every group with the same generation number ('Int8' value, typically starting-from 1) the rules represented have no conflicts with each other (this guarantees that they can be applied simultaneously-without the danger of incorrect interference). Usage of 'Generations' is a design decision and is inspired by the-GHC RULES pragma and the GHC compilation multistage process. --}+-- | Each generation represents a subset of rules for representation transformation. The 'PhoneticsRepresentationPLX'+-- are groupped by the generations so that in every group with the same generation number ('Int8' value, typically starting+-- from 1) the rules represented have no conflicts with each other (this guarantees that they can be applied simultaneously+-- without the danger of incorrect interference). Usage of 'Generations' is a design decision and is inspired by the+-- GHC RULES pragma and the GHC compilation multistage process.  type Generations = Int8 -{-| Each value represents temporary intermediate resulting 'String' data to be transformed further into the representation.--}+-- | Each value represents temporary intermediate resulting 'String' data to be transformed further into the representation. type InterGenerationsString = String -{-| If the list here is proper and complete, then it usually represents the whole writing system of the language. For proper usage,-the list must be sorted in the ascending order.--}+-- | If the list here is proper and complete, then it usually represents the whole writing system of the language. For proper usage,+-- the list must be sorted in the ascending order. type WritingSystemPRPLX = [PhoneticsRepresentationPLX] -{-| The \'dynamic\' representation of the general writing system that specifies what transformations are made simultaneously-during the conversion to the phonetic languages phonetics representation. During transformations those elements that have-greater 'Generations' are used earlier than others. The last ones are used those elements with the 'Generations' element-equal to 0 that must correspond to the 'PREmptyC' constructor-built records. For proper usage, the lists on the first-place of the tuples must be sorted in the ascending order.--}+-- | The \'dynamic\' representation of the general writing system that specifies what transformations are made simultaneously+-- during the conversion to the phonetic languages phonetics representation. During transformations those elements that have+-- greater 'Generations' are used earlier than others. The last ones are used those elements with the 'Generations' element+-- equal to 0 that must correspond to the 'PREmptyC' constructor-built records. For proper usage, the lists on the first+-- place of the tuples must be sorted in the ascending order. type GWritingSystemPRPLX = [([PhoneticsRepresentationPLX],Generations)] +{-| The intermediate representation of the phonetic languages data. Is used during conversions.+-} type PhoneticRepresentationXInter = Either PhoneticsRepresentationPLX InterGenerationsString  fromPhoneticRX :: [PhoneticsRepresentationPLX] -> [PhoneticRepresentationXInter] -> [PhoneticsRepresentationPLX]@@ -222,11 +219,12 @@         fromInter2X _ (Left x) = [x]         fromInter2X ys (Right z) = filter ((== z) . stringX) ys -{-| The \'dynamic\' representation of the process of transformation for the general writing system during the conversion.-Is not intended to be produced by hand, but automatically by programs.--}+-- | The \'dynamic\' representation of the process of transformation for the general writing system during the conversion.+-- Is not intended to be produced by hand, but automatically by programs. type IGWritingSystemPRPLX = [(PhoneticRepresentationXInter,Generations)] +-- | Splits the given list using 4 predicates into tuple of 4 lists of elements satisfying the predicates in the order+-- being preserved. fHelp4 :: (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> [a] -> ([a],[a],[a],[a]) fHelp4 p1 p2 p3 p4 = foldr g v   where v = ([],[],[],[])@@ -316,10 +314,9 @@ #endif #endif -{-| Finds and element in the 'Array' that the corresponding 'PhoneticsRepresentationPLX' from the first argument is '~=' to the-it. The 'String' arguments inside the tuple pair are the 'beforeString' and the 'afterString' elements of it to be used in 'Right'-case.--}+-- | Finds and element in the 'Array' that the corresponding 'PhoneticsRepresentationPLX' from the first argument is '~=' to the+-- it. The 'String' arguments inside the tuple pair are the 'beforeString' and the 'afterString' elements of it to be used in 'Right'+-- case. findSAI   :: PhoneticRepresentationXInter   -> (String, String)@@ -374,9 +371,7 @@                   !r4s = listArray (0,length r4ls - 1) r4ls                   !r5s = listArray (0,length r5ls - 1) r5ls -{-|-Is used internally in the 'stringToXSG' and 'stringToXG' functions respectively. --}+-- | Is used internally in the 'stringToXSG' and 'stringToXG' functions respectively.  stringToXSGI :: GWritingSystemPRPLX -> Generations -> IGWritingSystemPRPLX -> IGWritingSystemPRPLX stringToXSGI xs n ys  | n > 0 = stringToXSGI (xs \\ ts) (n - 1) . xsGI zs n $ ys@@ -413,8 +408,7 @@                    !r4s = listArray (0,length r4ls - 1) r4ls                    !r5s = listArray (0,length r5ls - 1) r5ls         -{-| The full conversion function. Applies conversion into representation using the 'GWritingSystemPRPLX' provided.--}+-- | The full conversion function. Applies conversion into representation using the 'GWritingSystemPRPLX' provided. stringToXG :: GWritingSystemPRPLX -> String -> [PhoneticsRepresentationPLX] stringToXG xs ys = fromPhoneticRX ts . map fst . stringToXSG xs n $ ys  where n = maximum . map snd $ xs
Data/Phonetic/Languages/PrepareText.hs view
@@ -47,13 +47,12 @@ import GHC.Arr import Data.List (sort,sortOn) -{-| The lists in the list are sorted in the descending order by the word counts in the inner 'String's. All the 'String's-in each inner list have the same number of words, and if there is no 'String' with some intermediate number of words (e. g. there-are not empty 'String's for 4 and 2 words, but there is no one for 3 words 'String's) then such corresponding list is empty, but-it is, nevertheless, present. Probably the maximum number of words can be no more than 4, and the minimum number can be-probably no less than 1, but it depends (especially for the maximum). The 'String's in the inner lists must be (unlike the inner-lists themselves) sorted in the ascending order for the data type to work correctly in the functions of the module.--}+-- | The lists in the list are sorted in the descending order by the word counts in the inner 'String's. All the 'String's+-- in each inner list have the same number of words, and if there is no 'String' with some intermediate number of words (e. g. there+-- are not empty 'String's for 4 and 2 words, but there is no one for 3 words 'String's) then such corresponding list is empty, but+-- it is, nevertheless, present. Probably the maximum number of words can be no more than 4, and the minimum number can be+-- probably no less than 1, but it depends (especially for the maximum). The 'String's in the inner lists must be (unlike the inner+-- lists themselves) sorted in the ascending order for the data type to work correctly in the functions of the module. type Concatenations = [[String]]  -- | Is used to convert a phonetic language text into list of 'String' each of which is ready to be@@ -70,22 +69,32 @@ prepareText ysss xs = filter (any (isPLL xs)) . splitLines . map (unwords . complexNWords ysss . words .   filter (\t -> isAlpha t || isSpC t)) . filter (not . null) . lines -sort2Concat :: [[String]] -> Concatenations+sort2Concat+ :: [[String]]+ -> Concatenations  -- ^ Data used to concatenate the basic grammar preserving words and word sequences to the next word to+ -- leave the most of the meaning (semantics) of the text available to easy understanding while reading and listening to. sort2Concat xsss  | null xsss = []  | otherwise = map sort . reverse . sortOn (map (length . words)) $ xsss -toSequentialApp :: Concatenations -> [Concatenations]+toSequentialApp+ :: Concatenations -- ^ Data used to concatenate the basic grammar preserving words and word sequences to the next word to+ -- leave the most of the meaning (semantics) of the text available to easy understanding while reading and listening to.+ -> [Concatenations] toSequentialApp ysss@(xss:xsss)  | null xss = toSequentialApp xsss  | otherwise = [xss, replicate (n - 1) []] : toSequentialApp xsss      where n = length . words . head $ xss toSequentialApp _ = [] -prepareConcats :: [[String]] -> [Concatenations]+prepareConcats+ :: [[String]]+ -> [Concatenations] prepareConcats = toSequentialApp . sort2Concat {-# INLINABLE prepareConcats #-} +{-| Applies the full complex words concatenations (opposite to the 'complexWords' that applies only partial concatenations). +-} complexNWords :: [[String]] -> [String] -> [String] complexNWords xsss yss = complexNWords' tssss yss   where tssss = prepareConcats xsss@@ -116,6 +125,7 @@ prepareTextN n ysss xs = filter (any (isPLL xs)) . splitLinesN n . map (unwords . complexNWords ysss . words .   filter (\t -> isAlpha t || isSpC t)) . filter (not . null) . lines +-- | A predicate to check whether the given character is one of the \"\' \\x2019\\x02BC-\". isSpC :: Char -> Bool isSpC x = x == '\'' || x == ' ' || x == '\x2019' || x == '\x02BC' || x == '-' {-# INLINE isSpC #-}
Data/Phonetic/Languages/SpecificationsRead.hs view
@@ -5,8 +5,7 @@ -- Stability   :  Experimental -- Maintainer  :  olexandr543@yahoo.com ---{-| Provides functions to read data specifications for other modules from textual files.--}+--  Provides functions to read data specifications for other modules from textual files.  module Data.Phonetic.Languages.SpecificationsRead where @@ -23,12 +22,20 @@ charLine :: Char -> String -> Bool charLine c = (== [c]) . take 1 -groupBetweenChars :: Char -> [String] -> [[String]]+groupBetweenChars+ :: Char  -- ^ A delimiter (can be used probably multiple times) used between different parts of the data.+ -> [String] -- ^ A list of 'String' that is partitioned using the 'String' starting with the delimiter.+ -> [[String]] groupBetweenChars c [] = [] groupBetweenChars c xs = css : groupBetweenChars c (dropWhile (charLine c) dss)   where (css,dss) = span (charLine c) xs -getGWritingSystem :: Char -> String -> GWritingSystemPRPLX+{-| An example of the needed data structure to be read correctly is in the file gwrsysExample.txt in the source tarball. +-}+getGWritingSystem+  :: Char -- ^ A delimiter (cab be used probably multiple times) between different parts of the data file. Usually, a tilda sign \'~\'.+  -> String -- ^ Actually the 'String' that is read into the result. +  -> GWritingSystemPRPLX -- ^ The data is used to obtain the phonetic language representation of the text. getGWritingSystem c xs = map ((\(t1,t2) -> (sort . map (\kt -> fromJust (readPEMaybe kt::Maybe PhoneticsRepresentationPLX)) $ t2,          read (concat t1)::Int8)) . splitAt 1) . groupBetweenChars c . lines $ xs
Data/Phonetic/Languages/Syllables.hs view
@@ -72,7 +72,9 @@  data PRS = SylS {   charS :: !Char, -- ^ Phonetic languages phenomenon representation. Usually, a phoneme, but it can be otherwise something different.-  phoneType :: !PhoneticType -- ^ Some encoded type.+  phoneType :: !PhoneticType -- ^ Some encoded type. For the vowels it has reserved value of 'P' 0, for the sonorous consonants - 'P' 1 and 'P' 2,+  -- for the voiced consonants - 'P' 3 and 'P' 4, for the voiceless consonants - 'P' 5 and 'P' 6. Nevertheless, it is possible to redefine the data by rewriting the+  -- respective parts of the code here. } deriving ( Eq, Read )  instance Ord PRS where@@ -92,13 +94,11 @@ fromPhoneticType :: PhoneticType -> Int fromPhoneticType (P x) = fromEnum x -{-| The 'Array' 'Int' must be sorted in the ascending order to be used in the module correctly.--}+-- | The 'Array' 'Int' must be sorted in the ascending order to be used in the module correctly. type CharPhoneticClassification = Array Int PRS -{-| The 'String' of converted phonetic language representation 'Char' data is converted to this type to apply syllable-segmentation or other transformations.--}+-- | The 'String' of converted phonetic language representation 'Char' data is converted to this type to apply syllable+-- segmentation or other transformations. type StringRepresentation = [PRS]  -- | Is somewhat rewritten from the 'CaseBi.Arr.gBF3' function (not exported) from the @mmsyn2-array@ package.@@ -202,20 +202,19 @@            _ -> Nothing         _ -> Nothing -{-| We can think of 'SegmentationPredFunction' in terms of @f ('SI' fN pN) ks [x_{1},x_{2},...,x_{i},...,x_{fN}]@. Comparing with-'divCnsnts' from the @ukrainian-phonetics-basics-array@ we can postulate that it consists of the following logical terms in-the symbolic form:--1) 'phoneType' x_{i} \`'elem'\` (X{...} = 'map' 'P' ['Int8'])--2) 'notEqC' ks x_{i} x_{j} (j /= i)--combined with the standard logic Boolean operations of '(&&)', '(||)' and 'not'. Further, the 'not' can be transformed into the-positive (affirmative) form using the notion of the universal set for the task. This transformation needs that the similar-phonetic phenomenae (e. g. the double sounds -- the prolonged ones) belong to the one syllable and not to the different ones-(so they are not related to different syllables, but just to the one and the same). Since such assumption has been used,-we can further represent the function by the following data type and operations with it, see 'SegmentationPredFData'.--}+-- | We can think of 'SegmentationPredFunction' in terms of @f ('SI' fN pN) ks [x_{1},x_{2},...,x_{i},...,x_{fN}]@. Comparing with+-- 'divCnsnts' from the @ukrainian-phonetics-basics-array@ we can postulate that it consists of the following logical terms in+-- the symbolic form:+-- +-- 1) 'phoneType' x_{i} \`'elem'\` (X{...} = 'map' 'P' ['Int8'])+-- +-- 2) 'notEqC' ks x_{i} x_{j} (j /= i)+-- +-- combined with the standard logic Boolean operations of '(&&)', '(||)' and 'not'. Further, the 'not' can be transformed into the+-- positive (affirmative) form using the notion of the universal set for the task. This transformation needs that the similar+-- phonetic phenomenae (e. g. the double sounds -- the prolonged ones) belong to the one syllable and not to the different ones+-- (so they are not related to different syllables, but just to the one and the same). Since such assumption has been used,+-- we can further represent the function by the following data type and operations with it, see 'SegmentationPredFData'. data SegmentationPredFunction = PF (SegmentationInfo1 -> [(Char, Char)] -> [PRS] -> Bool)  data SegmentationPredFData a b = L Int [Int] (Array Int a) | NEC Int Int (Array Int a) [b] | C (SegmentationPredFData a b) (SegmentationPredFData a b) |@@ -263,9 +262,8 @@   -- The length of the list must be equal to the ('fromEnum' . 'predicateN' . 'infoS') value. }   -{-| List of the 'SegmentationRules1' sorted in the descending order by the 'fieldN' 'SegmentationInfo1' data and where the-length of all the 'SegmentationPredFunction' lists of 'PRS' are equal to the 'fieldN' 'SegmentationInfo1' data by definition.--}+-- | List of the 'SegmentationRules1' sorted in the descending order by the 'fieldN' 'SegmentationInfo1' data and where the+-- length of all the 'SegmentationPredFunction' lists of 'PRS' are equal to the 'fieldN' 'SegmentationInfo1' data by definition. type SegmentRulesG = [SegmentationRules1]  -- | Function 'divCnsnts' is used to divide groups of consonants into two-elements lists that later are made belonging to@@ -273,13 +271,21 @@ -- The example phonetical information for the proper performance in Ukrainian can be found from the: -- https://msn.khnu.km.ua/pluginfile.php/302375/mod_resource/content/1/%D0%9B.3.%D0%86%D0%86.%20%D0%A1%D0%BA%D0%BB%D0%B0%D0%B4.%D0%9D%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D1%81.pdf -- The example of the 'divCnsnts' can be found at: https://hackage.haskell.org/package/ukrainian-phonetics-basic-array-0.1.2.0/docs/src/Languages.Phonetic.Ukrainian.Syllable.Arr.html#divCnsnts-divCnsnts :: [(Char,Char)] -> SegmentRulesG -> [PRS] -> DListFunctionResult+divCnsnts+ :: [(Char,Char)] -- ^ The pairs of the 'Char' that corresponds to the similar phonetic languages consonant phenomenon (e. g. allophones). Must be sorted in the ascending order to be used correctly. + -> SegmentRulesG+ -> [PRS]+ -> DListFunctionResult divCnsnts ks gs xs@(_:_) = toDLR left xs   where !js = fromJust . L.find ((== length xs) . fromEnum . fieldN . infoS) $ gs -- js :: SegmentationRules1         !left = resF . fromJust . L.find (eval2Bool . predF). lineFs $ js divCnsnts _ _ [] = (id,id) -reSyllableCntnts :: [(Char,Char)] -> SegmentRulesG -> [[PRS]] -> [[PRS]]+reSyllableCntnts+ :: [(Char,Char)] -- ^ The pairs of the 'Char' that corresponds to the similar phonetic languages consonant phenomenon (e. g. allophones). Must be sorted in the ascending order to be used correctly. + -> SegmentRulesG+ -> [[PRS]]+ -> [[PRS]] reSyllableCntnts ks gs (xs:ys:zs:xss)   | (/= P 0) . phoneType . last $ ys = fst (divCnsnts ks gs ys) xs:reSyllableCntnts ks gs (snd (divCnsnts ks gs ys) zs:xss)   | otherwise = reSyllableCntnts ks gs ((xs `mappend` ys):zs:xss)@@ -291,9 +297,12 @@   where h3 us = [ys `mappend` take 1 zs] `mappend` (L.groupBy (\x y -> phoneType x == P 0 && phoneType y /= P 0) . drop 1 $ zs)                   where (ys,zs) = span (\t -> phoneType t /= P 0) us +{-| The function actually creates syllables using the provided data. Each resulting inner-most list is a phonetic language representation+of the syllable according to the rules provided.+-} createSyllablesPL-  :: GWritingSystemPRPLX-  -> [(Char,Char)]+  :: GWritingSystemPRPLX -- ^ Data used to obtain the phonetic language representation of the text.+  -> [(Char,Char)] -- ^ The pairs of the 'Char' that corresponds to the similar phonetic languages consonant phenomenon (e. g. allophones). Must be sorted in the ascending order to be used correctly.    -> CharPhoneticClassification   -> SegmentRulesG   -> String -- ^ Corresponds to the \'0\' symbol delimiter in the @ukrainian-phonetics-basic-array@ package.
Main.hs view
@@ -5,28 +5,27 @@ -- Stability   :  Experimental -- Maintainer  :  olexandr543@yahoo.com ---{-| Can be used to calculate the durations of the approximations of the phonemes-using some prepared text with its correct (at least mostly) pronunciation.-The prepared text is located in the same directory and contains lines -the-phonetic language word and its duration in seconds separated with whitespace.-The library is intended to use the functionality of the :--1) R programming language https://www.r-project.org/--2) Rglpk library https://cran.r-project.org/web/packages/Rglpk/index.html--3) GNU GLPK library https://www.gnu.org/software/glpk/glpk.html--For more information, please, see the documentation for them.--For the model correctness the js here refers to sorted list of the 'Char' representations of the phonetic language phenomenae.--The length of the 'String' js is refered to as 'lng'::'Int'. The number of 'pairs'' function elements in the lists is refered to-as 'nn'::'Int'. The number of constraints is refered here as 'nc'::'Int'. @nc == nn `quot` 2@.--Is generalized from the Numeric.Wrapper.R.GLPK.Phonetics.Ukrainian.Durations module from-the @r-glpk-phonetic-languages-ukrainian-durations@ package.--}+-- Can be used to calculate the durations of the approximations of the phonemes+-- using some prepared text with its correct (at least mostly) pronunciation.+-- The prepared text is located in the same directory and contains lines -the+-- phonetic language word and its duration in seconds separated with whitespace.+-- The library is intended to use the functionality of the :+-- +-- 1) R programming language https://www.r-project.org/+-- +-- 2) Rglpk library https://cran.r-project.org/web/packages/Rglpk/index.html+-- +-- 3) GNU GLPK library https://www.gnu.org/software/glpk/glpk.html+-- +-- For more information, please, see the documentation for them.+-- +-- For the model correctness the js here refers to sorted list of the 'Char' representations of the phonetic language phenomenae.+-- +-- The length of the 'String' js is refered to as 'lng'::'Int'. The number of 'pairs'' function elements in the lists is refered to+-- as 'nn'::'Int'. The number of constraints is refered here as 'nc'::'Int'. @nc == nn `quot` 2@.+-- +-- Is generalized from the Numeric.Wrapper.R.GLPK.Phonetics.Ukrainian.Durations module from+-- the @r-glpk-phonetic-languages-ukrainian-durations@ package.  module Main where
Numeric/Wrapper/R/GLPK/Phonetic/Languages/Durations.hs view
@@ -1,36 +1,34 @@ {-# LANGUAGE CPP #-} {-# OPTIONS_HADDOCK show-extensions #-} -{-|-Module      :  Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations-Copyright   :  (c) OleksandrZhabenko 2020-2021-License     :  MIT-Stability   :  Experimental-Maintainer  :  olexandr543@yahoo.com+-- |+-- Module      :  Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations+-- Copyright   :  (c) OleksandrZhabenko 2020-2021+-- License     :  MIT+-- Stability   :  Experimental+-- Maintainer  :  olexandr543@yahoo.com ---Can be used to calculate the durations of the approximations of the phonemes-using some prepared text with its correct (at least mostly) pronunciation.-The prepared text is located in the same directory and contains lines -the-phonetic language word and its duration in seconds separated with whitespace.-The library is intended to use the functionality of the :--1) R programming language https://www.r-project.org/--2) Rglpk library https://cran.r-project.org/web/packages/Rglpk/index.html--3) GNU GLPK library https://www.gnu.org/software/glpk/glpk.html--For more information, please, see the documentation for them.--For the model correctness the js here refers to sorted list of the 'Char' representations of the phonetic language phenomenae.--The length of the 'String' js is refered to as 'lng'::'Int'. The number of 'pairs'' function elements in the lists is refered to-as 'nn'::'Int'. The number of constraints is refered here as 'nc'::'Int'. @nc == nn `quot` 2@.--Is generalized from the Numeric.Wrapper.R.GLPK.Phonetics.Ukrainian.Durations module from-the @r-glpk-phonetic-languages-ukrainian-durations@ package.--}-+-- Can be used to calculate the durations of the approximations of the phonemes+-- using some prepared text with its correct (at least mostly) pronunciation.+-- The prepared text is located in the same directory and contains lines -the+-- phonetic language word and its duration in seconds separated with whitespace.+-- The library is intended to use the functionality of the :+-- +-- 1) R programming language https://www.r-project.org/+-- +-- 2) Rglpk library https://cran.r-project.org/web/packages/Rglpk/index.html+-- +-- 3) GNU GLPK library https://www.gnu.org/software/glpk/glpk.html+-- +-- For more information, please, see the documentation for them.+-- +-- For the model correctness the js here refers to sorted list of the 'Char' representations of the phonetic language phenomenae.+-- +-- The length of the 'String' js is refered to as 'lng'::'Int'. The number of 'pairs'' function elements in the lists is refered to+-- as 'nn'::'Int'. The number of constraints is refered here as 'nc'::'Int'. @nc == nn `quot` 2@.+-- +-- Is generalized from the Numeric.Wrapper.R.GLPK.Phonetics.Ukrainian.Durations module from+-- the @r-glpk-phonetic-languages-ukrainian-durations@ package.  module Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations where @@ -77,12 +75,11 @@ pairwiseComparings :: Char -> PairwiseC -> [Int] -> [Int] pairwiseComparings x y zs = zs `mappend` pairs' y x -{-| A way to encode the pairs of the phonetic language representations that give some additional associations, connections-between elements, usually being caused by some similarity or commonality of the pronunciation act for the phenomenae-corresponding to these elements. -All ['Int'] must be equal in 'length' throughout the same namespace and this length is given as 'Int' argument in-the 'PairwisePL'. This 'Int' parameter is @nn@.--}+-- | A way to encode the pairs of the phonetic language representations that give some additional associations, connections+-- between elements, usually being caused by some similarity or commonality of the pronunciation act for the phenomenae+-- corresponding to these elements. +-- All ['Int'] must be equal in 'length' throughout the same namespace and this length is given as 'Int' argument in+-- the 'PairwisePL'. This 'Int' parameter is @nn@. data PairwisePL = PW Char Int [Int] deriving (Eq, Read, Show)  lengthPW :: PairwisePL -> Int@@ -134,8 +131,7 @@       ")", newLineEnding]  | otherwise = error "Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations.objLine: Not defined for the short argument. " -{-| A way to reorder the coefficients of the input and the elements representations related to each other.--}+-- | A way to reorder the coefficients of the input and the elements representations related to each other. objCoeffsNew   :: Int -- ^ The length of the 'String' js that is a sorted list of the phonetic language representations as 'Char's that   -- appears in the file with test words and their spoken durations.@@ -221,7 +217,7 @@  -> [Double] maxDurations lng mx = replicate lng mx --- | A variant of the more general 'answer2' where the randomization parameters are used to produce every time being run+-- | A variant of the more general 'answer2' where the predefined randomization parameters are used to produce every time being run -- a new result (e. g. this allows to model accents). answer  :: Int -- ^ The length of the 'String' js that is a sorted list of the phonetic language representations as 'Char's that@@ -289,4 +285,4 @@  -- read ("SylS {charS=\'k\', phoneType=P 6")::PRS --- pldUkr 0.01 0.01 0.1 0.2 words.txt 1.8 -1 0.01 0.01 2.5 2.5 2.5 2.5 2.5 2.5+
phonetic-languages-phonetics-basics.cabal view
@@ -3,7 +3,7 @@ -- http://haskell.org/cabal/users-guide/  name:                phonetic-languages-phonetics-basics-version:             0.6.1.0+version:             0.6.2.0 synopsis:            A library for working with generalized phonetic languages usage. description:         There already exists a Ukrainian implementation for the phonetic languages approach published at: https://hackage.haskell.org/package/phonetic-languages-simplified-examples-array. It is optimized for the Ukrainian only and needs to be rewritten for every new language mostly from scratch using it as a template. To avoid this boilerplate, this one is provided. It can be used for different languages and even for music or other fields. Now it combines the functionality of the @r-glpk-phonetic-languages-ukrainian-durations@ and @phonetic-languages-ukrainian-array@ and some dependencies of the mentioned one. homepage:            https://hackage.haskell.org/package/phonetic-languages-phonetics-basics