diff --git a/Duckling/AmountOfMoney/EN/Corpus.hs b/Duckling/AmountOfMoney/EN/Corpus.hs --- a/Duckling/AmountOfMoney/EN/Corpus.hs +++ b/Duckling/AmountOfMoney/EN/Corpus.hs @@ -22,31 +22,36 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 1) + [ "$1" + , "one dollar" + , "a dollar" + ] + , examples (simple Dollar 10) [ "$10" , "$ 10" , "10$" , "10 dollars" , "ten dollars" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "10 cent" , "ten pennies" , "ten cents" , "10 c" , "10¢" ] - , examples (AmountOfMoneyValue Dollar 1e4) + , examples (simple Dollar 1e4) [ "$10K" , "10k$" , "$10,000" ] - , examples (AmountOfMoneyValue USD 3.14) + , examples (simple USD 3.14) [ "USD3.14" , "3.14US$" , "US$ 3.14" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20\x20ac" , "20 euros" , "20 Euro" @@ -56,22 +61,22 @@ , "20€" , "20 €ur" ] - , examples (AmountOfMoneyValue Pound 10) + , examples (simple Pound 10) [ "\x00a3\&10" , "ten pounds" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rupees" , "20Rs" , "Rs20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupees 43" , "twenty rupees 43" ] - , examples (AmountOfMoneyValue Dollar 20.43) + , examples (simple Dollar 20.43) [ "$20 and 43c" , "$20 43" , "20 dollar 43c" @@ -80,34 +85,81 @@ , "20 dollar 43" , "twenty dollar and 43" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3.01" , "GBP 3.01" - , "3 GBP 1 cent" + , "3 GBP 1 pence" ] - , examples (AmountOfMoneyValue Unnamed 42) + , examples (simple Unnamed 42) [ "42 bucks" , "around 42 bucks" , "exactly 42 bucks" ] - , examples (AmountOfMoneyValue KWD 42) + , examples (simple KWD 42) [ "42 KWD" , "42 kuwaiti Dinar" ] - , examples (AmountOfMoneyValue LBP 42) + , examples (simple LBP 42) [ "42 LBP" , "42 Lebanese Pounds" ] - , examples (AmountOfMoneyValue EGP 42) + , examples (simple EGP 42) [ "42 EGP" , "42 egyptianpound" ] - , examples (AmountOfMoneyValue QAR 42) + , examples (simple QAR 42) [ "42 QAR" , "42 qatari riyals" ] - , examples (AmountOfMoneyValue SAR 42) + , examples (simple SAR 42) [ "42 SAR" , "42 Saudiriyal" + ] + , examples (simple MYR 42) + [ "42 MYR" + , "42 RM" + , "RM 42" + , "MYR 42" + , "42MYR" + , "42RM" + , "RM42" + , "MYR42" + , "ringgit 42" + , "42 ringgit" + , "42 malaysia ringgit" + , "malaysia ringgit 42" + , "42 malaysian ringgit" + , "malaysian ringgit 42" + , "42 malaysia ringgits" + , "malaysia ringgits 42" + , "42 malaysian ringgits" + , "malaysian ringgits 42" + ] + , examples (simple MYR 20.43) + [ "20 ringgit and 43c" + , "20 ringgit and 43 sen" + , "twenty ringgit 43 sens" + , "20 ringgit 43" + , "twenty ringgit and 43" + ] + , examples (between Dollar (10, 20)) + [ "between 10 and 20 dollars" + , "from 10 dollars to 20 dollars" + , "around 10-20 dollars" + , "between 10 dollars and 20 dollars" + , "from 10 to 20 dollars" + , "about $10-$20" + , "10-20 dollars" + ] + , examples (under EUR 7) + [ "under seven euros" + , "less than 7 EUR" + , "lower than 7€" + ] + , examples (above Dollar 1.42) + [ "more than 1 dollar and forty-two cents" + , "at least $1.42" + , "over 1.42 dollars" + , "above a dollar and 42 cents" ] ] diff --git a/Duckling/AmountOfMoney/EN/Rules.hs b/Duckling/AmountOfMoney/EN/Rules.hs --- a/Duckling/AmountOfMoney/EN/Rules.hs +++ b/Duckling/AmountOfMoney/EN/Rules.hs @@ -85,11 +85,20 @@ , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly AED } +ruleRinggit :: Rule +ruleRinggit = Rule + { name = "ringgit" + , pattern = + [ regex "(malaysian? )?ringgits?" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly MYR + } + ruleCent :: Rule ruleCent = Rule { name = "cent" , pattern = - [ regex "cents?|penn(y|ies)" + [ regex "cents?|penn(y|ies)|pence|sens?" ] , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent } @@ -103,6 +112,18 @@ , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Unnamed } +ruleACurrency :: Rule +ruleACurrency = Rule + { name = "a " + , pattern = + [ regex "an?" + , financeWith TAmountOfMoney.value isNothing + ] + , prod = \tokens -> case tokens of + (_:Token AmountOfMoney fd:_) -> Just . Token AmountOfMoney $ fd {TAmountOfMoney.value = Just 1} + _ -> Nothing + } + ruleIntersectAndXCents :: Rule ruleIntersectAndXCents = Rule { name = "intersect (and X cents)" @@ -154,7 +175,9 @@ { name = "intersect (X cents)" , pattern = [ financeWith TAmountOfMoney.value isJust - , financeWith TAmountOfMoney.currency (== Cent) + , financeWith id $ \x -> case TAmountOfMoney.value x of + Just v | v > 0 -> TAmountOfMoney.currency x == Cent + _ -> False ] , prod = \tokens -> case tokens of (Token AmountOfMoney fd: @@ -168,16 +191,117 @@ { name = "about|exactly " , pattern = [ regex "exactly|precisely|about|approx(\\.|imately)?|close to|near( to)?|around|almost" - , financeWith TAmountOfMoney.value isJust + , dimension AmountOfMoney ] , prod = \tokens -> case tokens of (_:token:_) -> Just token _ -> Nothing } +ruleIntervalBetweenNumeral :: Rule +ruleIntervalBetweenNumeral = Rule + { name = "between|from to|and " + , pattern = + [ regex "between|from" + , dimension Numeral + , regex "to|and" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token Numeral (NumeralData {TNumeral.value = from}): + _: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}): + _) -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c + _ -> Nothing + } + +ruleIntervalBetween :: Rule +ruleIntervalBetween = Rule + { name = "between|from to|and " + , pattern = + [ regex "between|from" + , financeWith TAmountOfMoney.value isJust + , regex "to|and" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just from, TAmountOfMoney.currency = c1}): + _: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c2}): + _) | c1 == c2 -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1 + _ -> Nothing + } + +ruleIntervalNumeralDash :: Rule +ruleIntervalNumeralDash = Rule + { name = " - " + , pattern = + [ dimension Numeral + , regex "-" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (Token Numeral (NumeralData {TNumeral.value = from}): + _: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}): + _) -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c + _ -> Nothing + } + +ruleIntervalDash :: Rule +ruleIntervalDash = Rule + { name = " - " + , pattern = + [ financeWith TAmountOfMoney.value isJust + , regex "-" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just from, TAmountOfMoney.currency = c1}): + _: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c2}): + _) | c1 == c2 -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1 + _ -> Nothing + } + +ruleIntervalMax :: Rule +ruleIntervalMax = Rule + { name = "under/less/lower/no more than " + , pattern = + [ regex "under|(less|lower|not? more) than" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}): + _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c + _ -> Nothing + } + +ruleIntervalMin :: Rule +ruleIntervalMin = Rule + { name = "over/above/at least/more than " + , pattern = + [ regex "over|above|at least|more than" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}): + _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c + _ -> Nothing + } + rules :: [Rule] rules = - [ ruleBucks + [ ruleACurrency + , ruleBucks , ruleCent , ruleDinars , ruleDirham @@ -185,8 +309,15 @@ , ruleIntersectAndNumeral , ruleIntersectAndXCents , ruleIntersectXCents + , ruleIntervalBetweenNumeral + , ruleIntervalBetween + , ruleIntervalMax + , ruleIntervalMin + , ruleIntervalNumeralDash + , ruleIntervalDash , ruleOtherPounds , rulePounds , rulePrecision + , ruleRinggit , ruleRiyals ] diff --git a/Duckling/AmountOfMoney/ES/Corpus.hs b/Duckling/AmountOfMoney/ES/Corpus.hs --- a/Duckling/AmountOfMoney/ES/Corpus.hs +++ b/Duckling/AmountOfMoney/ES/Corpus.hs @@ -24,42 +24,42 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "diez dollars" , "diez dólares" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "nueve pounds" , "9 libras" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" , "3 gbp 1 centavo" , "3 gbp y 1 centavo" ] - , examples (AmountOfMoneyValue PTS 15) + , examples (simple PTS 15) [ "15 Pt" , "15pta" , "15Ptas" diff --git a/Duckling/AmountOfMoney/FR/Corpus.hs b/Duckling/AmountOfMoney/FR/Corpus.hs --- a/Duckling/AmountOfMoney/FR/Corpus.hs +++ b/Duckling/AmountOfMoney/FR/Corpus.hs @@ -24,41 +24,41 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "dix dollars" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" , "1 USD et 23 centimes" , "1 USD 23 cents" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue Unnamed 3) + , examples (simple Unnamed 3) [ "3 balles" , "à peu près 3 pouloutes" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "exactement £9" , "neuf pounds" , "quasi neuf livres" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] diff --git a/Duckling/AmountOfMoney/GA/Corpus.hs b/Duckling/AmountOfMoney/GA/Corpus.hs --- a/Duckling/AmountOfMoney/GA/Corpus.hs +++ b/Duckling/AmountOfMoney/GA/Corpus.hs @@ -24,62 +24,62 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "deich dollair" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "deich ceinteanna" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10,000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue EUR 10000) + , examples (simple EUR 10000) [ "€10,000" , "10K€" , "€10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1.23" ] - , examples (AmountOfMoneyValue Dollar 2.23) + , examples (simple Dollar 2.23) [ "2 dhollair agus 23 ceinteanna" , "dhá dhollair 23 ceinteanna" , "2 dhollair 23" , "dhá dhollair agus 23" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29.99" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rúpaí" , "20Rs" , "Rs20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupees 43" , "fiche rúpaí 43" ] - , examples (AmountOfMoneyValue INR 33) + , examples (simple INR 33) [ "INR33" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "naoi bpunt" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3.01" , "GBP 3.01" ] diff --git a/Duckling/AmountOfMoney/HR/Corpus.hs b/Duckling/AmountOfMoney/HR/Corpus.hs --- a/Duckling/AmountOfMoney/HR/Corpus.hs +++ b/Duckling/AmountOfMoney/HR/Corpus.hs @@ -23,73 +23,73 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "deset dolara" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "deset centa" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue Dollar 2.23) + , examples (simple Dollar 2.23) [ "2 dolara i 23 centa" , "dva dolara 23 centa" , "2 dolara 23" , "dva dolara i 23" ] - , examples (AmountOfMoneyValue HRK 2.23) + , examples (simple HRK 2.23) [ "2 kune i 23 lipe" , "dvije kune 23 lipe" , "2 kune 23" , "dvije kune i 23" ] - , examples (AmountOfMoneyValue HRK 100) + , examples (simple HRK 100) [ "100 kuna" , "sto kuna" ] - , examples (AmountOfMoneyValue HRK 200) + , examples (simple HRK 200) [ "200 kuna" , "dvije stotine kuna" , "dvjesto kuna" , "dvjesta kuna" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rupija" , "20Rs" , "Rs20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupija 43" , "dvadeset rupija 43" ] - , examples (AmountOfMoneyValue INR 33) + , examples (simple INR 33) [ "INR33" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "devet funti" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] diff --git a/Duckling/AmountOfMoney/Helpers.hs b/Duckling/AmountOfMoney/Helpers.hs --- a/Duckling/AmountOfMoney/Helpers.hs +++ b/Duckling/AmountOfMoney/Helpers.hs @@ -13,14 +13,17 @@ ( currencyOnly , financeWith , withCents + , withInterval + , withMax + , withMin , withValue ) where import Prelude -import Duckling.Dimensions.Types import Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..)) +import Duckling.Dimensions.Types import Duckling.Types hiding (Entity(..)) -- ----------------------------------------------------------------- @@ -36,7 +39,8 @@ -- Production currencyOnly :: Currency -> AmountOfMoneyData -currencyOnly c = AmountOfMoneyData {currency = c, value = Nothing} +currencyOnly c = AmountOfMoneyData + {currency = c, value = Nothing, minValue = Nothing, maxValue = Nothing} withValue :: Double -> AmountOfMoneyData -> AmountOfMoneyData withValue x fd = fd {value = Just x} @@ -45,4 +49,13 @@ withCents x fd@AmountOfMoneyData {value = Just value} = fd {value = Just $ value + x / 100} withCents x AmountOfMoneyData {value = Nothing} = AmountOfMoneyData - {value = Just x, currency = Cent} + {value = Just x, currency = Cent, minValue = Nothing, maxValue = Nothing} + +withInterval :: (Double, Double) -> AmountOfMoneyData -> AmountOfMoneyData +withInterval (from, to) fd = fd {minValue = Just from, maxValue = Just to} + +withMin :: Double -> AmountOfMoneyData -> AmountOfMoneyData +withMin x fd = fd {minValue = Just x} + +withMax :: Double -> AmountOfMoneyData -> AmountOfMoneyData +withMax x fd = fd {maxValue = Just x} diff --git a/Duckling/AmountOfMoney/ID/Corpus.hs b/Duckling/AmountOfMoney/ID/Corpus.hs --- a/Duckling/AmountOfMoney/ID/Corpus.hs +++ b/Duckling/AmountOfMoney/ID/Corpus.hs @@ -24,24 +24,24 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "sepuluh dolar" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue Dollar 2) + , examples (simple Dollar 2) [ "2 dola" , "dua dolar" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" @@ -49,32 +49,32 @@ , "EUR 20" , "dua puluh Euro" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue IDR 315) + , examples (simple IDR 315) [ "Rp. 315,00" ] - , examples (AmountOfMoneyValue IDR 20) + , examples (simple IDR 20) [ "Rp 20" , "20 Rupiah" , "20Rp" , "Rp20" ] - , examples (AmountOfMoneyValue IDR 33000) + , examples (simple IDR 33000) [ "IDR33000" , "IDR 33.000" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "sembilan pound" , "sembilan pound sterling" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] - , examples (AmountOfMoneyValue JPY 10) + , examples (simple JPY 10) [ "10 yen" , "10¥" , "10 ¥." diff --git a/Duckling/AmountOfMoney/KO/Corpus.hs b/Duckling/AmountOfMoney/KO/Corpus.hs --- a/Duckling/AmountOfMoney/KO/Corpus.hs +++ b/Duckling/AmountOfMoney/KO/Corpus.hs @@ -24,53 +24,53 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "십달러" , "십불" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "십센트" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "만달러" , "만불" ] - , examples (AmountOfMoneyValue Dollar 1.23) + , examples (simple Dollar 1.23) [ "일점이삼달러" , "일쩜이삼달러" , "일점이삼불" , "일쩜이삼불" ] - , examples (AmountOfMoneyValue Dollar 2.23) + , examples (simple Dollar 2.23) [ "이달러이십삼센트" , "이불이십삼센트" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "이십유로" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "이십구점구구유로" , "EUR29.99" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "구파운드" ] - , examples (AmountOfMoneyValue KRW 27350000) + , examples (simple KRW 27350000) [ "이천칠백삼십오만원" , "27,350,000원" , "27350000원" ] - , examples (AmountOfMoneyValue KRW 27000) + , examples (simple KRW 27000) [ "이만칠천원" , "27,000원" , "27000원" ] - , examples (AmountOfMoneyValue KRW 100) + , examples (simple KRW 100) [ "백원" , "100원" ] - , examples (AmountOfMoneyValue KRW 10) + , examples (simple KRW 10) [ "십원" , "10원" , "10₩" diff --git a/Duckling/AmountOfMoney/NB/Corpus.hs b/Duckling/AmountOfMoney/NB/Corpus.hs --- a/Duckling/AmountOfMoney/NB/Corpus.hs +++ b/Duckling/AmountOfMoney/NB/Corpus.hs @@ -24,45 +24,45 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "ti dollar" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "ti øre" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue NOK 10) + , examples (simple NOK 10) [ "10kroner" , "10kr" , "ti kroner" , "10 NOK" ] - , examples (AmountOfMoneyValue NOK 2.23) + , examples (simple NOK 2.23) [ "2 kroner og 23 øre" , "to kroner 23 øre" , "to kroner og 23 øre" , "to kr 23" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euro" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rupees" @@ -70,16 +70,16 @@ , "Rs20" , "INR20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupees 43" , "tjue rupees 43" , "tjue rupees 43¢" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "ni pund" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] diff --git a/Duckling/AmountOfMoney/PT/Corpus.hs b/Duckling/AmountOfMoney/PT/Corpus.hs --- a/Duckling/AmountOfMoney/PT/Corpus.hs +++ b/Duckling/AmountOfMoney/PT/Corpus.hs @@ -24,49 +24,49 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "dez dolares" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "nove libras" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] - , examples (AmountOfMoneyValue PTS 15) + , examples (simple PTS 15) [ "15 Pt" , "15pta" , "15Ptas" ] - , examples (AmountOfMoneyValue BRL 15) + , examples (simple BRL 15) [ "15 reais" , "15reais" , "15 Reais" , "BRL 15" ] - , examples (AmountOfMoneyValue BRL 2.0) + , examples (simple BRL 2.0) [ "R$2,00" , "R$ 2,00" , "2,00 reais" diff --git a/Duckling/AmountOfMoney/RO/Corpus.hs b/Duckling/AmountOfMoney/RO/Corpus.hs --- a/Duckling/AmountOfMoney/RO/Corpus.hs +++ b/Duckling/AmountOfMoney/RO/Corpus.hs @@ -24,49 +24,49 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue RON 10) + [ examples (simple RON 10) [ "10 lei" , "10 roni" , "10 RON" ] - , examples (AmountOfMoneyValue Cent 50) + , examples (simple Cent 50) [ "50 bani" , "50 BANI" ] - , examples (AmountOfMoneyValue RON 10.5) + , examples (simple RON 10.5) [ "10,5 lei" , "10,5 ron" , "10 lei si 50 bani" ] - , examples (AmountOfMoneyValue Dollar 10) + , examples (simple Dollar 10) [ "$10" , "10$" , "zece dolari" , "10 dolari" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "zece centi" , "zece cenți" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "$10000" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue Dollar 1) + , examples (simple Dollar 1) [ "1 dolar" , "un dolar" , "$1" ] - , examples (AmountOfMoneyValue Cent 2) + , examples (simple Cent 2) [ "2 centi" ] - , examples (AmountOfMoneyValue Cent 23) + , examples (simple Cent 23) [ "23 centi" ] - , examples (AmountOfMoneyValue Dollar 2.23) + , examples (simple Dollar 2.23) [ "2 dolari si 23 centi" , "2 dolari și 23 cenți" , "doi dolari si douăzeci si trei centi" @@ -75,45 +75,45 @@ , "doi dolari si 23" , "doi dolari și 23" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euro" , "20 Euro" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "noua lir" , "nouă lire" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] - , examples (AmountOfMoneyValue QAR 1) + , examples (simple QAR 1) [ "un rial qatarian" , "1 rial qataria" ] - , examples (AmountOfMoneyValue EGP 10) + , examples (simple EGP 10) [ "zece lira egiptiana" ] - , examples (AmountOfMoneyValue LBP 1) + , examples (simple LBP 1) [ "una liră libaneză" ] - , examples (AmountOfMoneyValue INR 42) + , examples (simple INR 42) [ "42 rupii" , "Rs. 42" ] - , examples (AmountOfMoneyValue KWD 1) + , examples (simple KWD 1) [ "un dinar kuweitian" ] - , examples (AmountOfMoneyValue AED 2) + , examples (simple AED 2) [ "2 dirhami" ] - , examples (AmountOfMoneyValue SAR 1) + , examples (simple SAR 1) [ "1 rial saudit" , "un rial saudi" ] diff --git a/Duckling/AmountOfMoney/Rules.hs b/Duckling/AmountOfMoney/Rules.hs --- a/Duckling/AmountOfMoney/Rules.hs +++ b/Duckling/AmountOfMoney/Rules.hs @@ -14,21 +14,21 @@ ) where import Data.HashMap.Strict (HashMap) -import qualified Data.HashMap.Strict as HashMap import Data.Maybe import Data.String import Data.Text (Text) -import qualified Data.Text as Text import Prelude +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) -import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import Duckling.Dimensions.Types import Duckling.Numeral.Types (NumeralData (..)) -import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types import Duckling.Types +import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney +import qualified Duckling.Numeral.Types as TNumeral currencies :: HashMap Text Currency currencies = HashMap.fromList @@ -64,6 +64,8 @@ , ("krw", KRW) , ("kwd", KWD) , ("lbp", LBP) + , ("myr", MYR) + , ("rm", MYR) , ("nok", NOK) , ("\x00a3", Pound) , ("pt", PTS) @@ -84,7 +86,7 @@ ruleCurrencies = Rule { name = "currencies" , pattern = - [ regex "(aed|aud|brl|\x00a2|c|\\$|dollars?|egp|(e|\x20ac)uro?s?|\x20ac|gbp|hrk|idr|inr|\x00a5|jpy|krw|kwd|lbp|nok|\x00a3|pta?s?|qar|rs\\.?|ron|rupees?|sar|sek|sgb|us(d|\\$)|vnd|yen)" + [ regex "(aed|aud|brl|\x00a2|c|\\$|dollars?|egp|(e|\x20ac)uro?s?|\x20ac|gbp|hrk|idr|inr|\x00a5|jpy|krw|kwd|lbp|myr|rm|nok|\x00a3|pta?s?|qar|rs\\.?|ron|rupees?|sar|sek|sgb|us(d|\\$)|vnd|yen)" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> do diff --git a/Duckling/AmountOfMoney/SV/Corpus.hs b/Duckling/AmountOfMoney/SV/Corpus.hs --- a/Duckling/AmountOfMoney/SV/Corpus.hs +++ b/Duckling/AmountOfMoney/SV/Corpus.hs @@ -24,67 +24,67 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "tio dollar" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "tio öre" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10.000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1,23" ] - , examples (AmountOfMoneyValue SEK 10) + , examples (simple SEK 10) [ "10kronor" , "10kr" , "10 kr" , "tio kronor" , "10 SEK" ] - , examples (AmountOfMoneyValue SEK 2.23) + , examples (simple SEK 2.23) [ "2 kronor och 23 öre" , "två kronor 23 öre" , "två kronor och 23 öre" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euro" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29,99" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rupees" , "20Rs" , "Rs20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupees 43" , "tjugo rupees 43" ] - , examples (AmountOfMoneyValue INR 33) + , examples (simple INR 33) [ "INR33" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "nio pund" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3,01" , "GBP 3,01" ] - , examples (AmountOfMoneyValue NOK 10) + , examples (simple NOK 10) [ "10 norska kronor" , "10 nkr" ] diff --git a/Duckling/AmountOfMoney/Types.hs b/Duckling/AmountOfMoney/Types.hs --- a/Duckling/AmountOfMoney/Types.hs +++ b/Duckling/AmountOfMoney/Types.hs @@ -21,6 +21,7 @@ import Data.Text (Text) import GHC.Generics import Prelude +import qualified Data.HashMap.Strict as H import Duckling.Resolve (Resolve(..)) @@ -44,6 +45,7 @@ | KRW | KWD | LBP + | MYR | NOK | PTS | QAR @@ -73,6 +75,7 @@ toJSON KRW = "KRW" toJSON KWD = "KWD" toJSON LBP = "LBP" + toJSON MYR = "MYR" toJSON NOK = "NOK" toJSON PTS = "PTS" toJSON QAR = "QAR" @@ -86,24 +89,79 @@ data AmountOfMoneyData = AmountOfMoneyData { value :: Maybe Double , currency :: Currency + , minValue :: Maybe Double + , maxValue :: Maybe Double } deriving (Eq, Generic, Hashable, Show, Ord, NFData) -data AmountOfMoneyValue = AmountOfMoneyValue +instance Resolve AmountOfMoneyData where + type ResolvedValue AmountOfMoneyData = AmountOfMoneyValue + resolve _ AmountOfMoneyData {value = Nothing, minValue = Nothing, maxValue = Nothing} = Nothing + resolve _ AmountOfMoneyData {value = Just value, currency} = + Just $ simple currency value + resolve _ AmountOfMoneyData {value = Nothing, currency = c, minValue = Just from, maxValue = Just to} = + Just $ between c (from, to) + resolve _ AmountOfMoneyData {value = Nothing, currency = c, minValue = Just v, maxValue = Nothing} = + Just $ above c v + resolve _ AmountOfMoneyData {value = Nothing, currency = c, minValue = Nothing, maxValue = Just v} = + Just $ under c v + +data IntervalDirection = Above | Under + deriving (Eq, Generic, Hashable, Ord, Show, NFData) + +data SingleValue = SingleValue { vCurrency :: Currency , vValue :: Double } deriving (Eq, Show) -instance Resolve AmountOfMoneyData where - type ResolvedValue AmountOfMoneyData = AmountOfMoneyValue - resolve _ AmountOfMoneyData {value = Nothing} = Nothing - resolve _ AmountOfMoneyData {value = Just value, currency} = - Just AmountOfMoneyValue {vValue = value, vCurrency = currency} +instance ToJSON SingleValue where + toJSON SingleValue {vCurrency, vValue} = object + [ "value" .= vValue + , "unit" .= vCurrency + ] +data AmountOfMoneyValue + = SimpleValue SingleValue + | IntervalValue (SingleValue, SingleValue) + | OpenIntervalValue (SingleValue, IntervalDirection) + deriving (Show, Eq) + instance ToJSON AmountOfMoneyValue where - toJSON AmountOfMoneyValue {vCurrency, vValue} = object - [ "type" .= ("value" :: Text) - , "value" .= vValue - , "unit" .= vCurrency + toJSON (SimpleValue value) = case toJSON value of + Object o -> Object $ H.insert "type" (toJSON ("value" :: Text)) o + _ -> Object H.empty + toJSON (IntervalValue (from, to)) = object + [ "type" .= ("interval" :: Text) + , "from" .= toJSON from + , "to" .= toJSON to ] + toJSON (OpenIntervalValue (from, Above)) = object + [ "type" .= ("interval" :: Text) + , "from" .= toJSON from + ] + toJSON (OpenIntervalValue (to, Under)) = object + [ "type" .= ("interval" :: Text) + , "to" .= toJSON to + ] + +-- ----------------------------------------------------------------- +-- Value helpers + +simple :: Currency -> Double -> AmountOfMoneyValue +simple c v = SimpleValue $ single c v + +between :: Currency -> (Double, Double) -> AmountOfMoneyValue +between c (from, to) = IntervalValue (single c from, single c to) + +above :: Currency -> Double -> AmountOfMoneyValue +above = openInterval Above + +under :: Currency -> Double -> AmountOfMoneyValue +under = openInterval Under + +openInterval :: IntervalDirection -> Currency -> Double -> AmountOfMoneyValue +openInterval direction c v = OpenIntervalValue (single c v, direction) + +single :: Currency -> Double -> SingleValue +single c v = SingleValue {vCurrency = c, vValue = v} diff --git a/Duckling/AmountOfMoney/VI/Corpus.hs b/Duckling/AmountOfMoney/VI/Corpus.hs --- a/Duckling/AmountOfMoney/VI/Corpus.hs +++ b/Duckling/AmountOfMoney/VI/Corpus.hs @@ -24,26 +24,26 @@ allExamples :: [Example] allExamples = concat - [ examples (AmountOfMoneyValue Dollar 10) + [ examples (simple Dollar 10) [ "$10" , "10$" , "mười đô" , "mười đô la" , "mười đô mỹ" ] - , examples (AmountOfMoneyValue Cent 10) + , examples (simple Cent 10) [ "mười xen" , "mười xu" ] - , examples (AmountOfMoneyValue Dollar 10000) + , examples (simple Dollar 10000) [ "$10,000" , "10K$" , "$10k" ] - , examples (AmountOfMoneyValue USD 1.23) + , examples (simple USD 1.23) [ "USD1.23" ] - , examples (AmountOfMoneyValue Dollar 2.23) + , examples (simple Dollar 2.23) [ "2 đô la và 23 xen" , "hai đô la và 23 xen" , "2 đô 23 xu" @@ -51,52 +51,52 @@ , "2 chấm 23 đô la" , "hai phẩy 23 đô" ] - , examples (AmountOfMoneyValue VND 10) + , examples (simple VND 10) [ "mười đồng" ] - , examples (AmountOfMoneyValue VND 10000) + , examples (simple VND 10000) [ "10,000 đồng" , "10K đồng" , "10k đồng" ] - , examples (AmountOfMoneyValue VND 1000) + , examples (simple VND 1000) [ "1000 VNĐ" , "VN$1000" ] - , examples (AmountOfMoneyValue EUR 20) + , examples (simple EUR 20) [ "20€" , "20 euros" , "20 Euro" , "20 Euros" , "EUR 20" ] - , examples (AmountOfMoneyValue EUR 29.99) + , examples (simple EUR 29.99) [ "EUR29.99" ] - , examples (AmountOfMoneyValue INR 20) + , examples (simple INR 20) [ "Rs. 20" , "Rs 20" , "20 Rupees" , "20Rs" , "Rs20" ] - , examples (AmountOfMoneyValue INR 20.43) + , examples (simple INR 20.43) [ "20 Rupees 43" , "hai mươi rupees 43" , "hai mươi rupees 43 xen" ] - , examples (AmountOfMoneyValue INR 33) + , examples (simple INR 33) [ "INR33" ] - , examples (AmountOfMoneyValue Pound 9) + , examples (simple Pound 9) [ "£9" , "chín pounds" ] - , examples (AmountOfMoneyValue GBP 3.01) + , examples (simple GBP 3.01) [ "GBP3.01" , "GBP 3.01" ] - , examples (AmountOfMoneyValue AED 1) + , examples (simple AED 1) [ "1 AED." , "1 dirham" ] diff --git a/Duckling/Api.hs b/Duckling/Api.hs --- a/Duckling/Api.hs +++ b/Duckling/Api.hs @@ -55,8 +55,7 @@ -- | Converts the resolved token to the API format formatToken :: Text -> ResolvedToken -> Entity -formatToken sentence (Resolved (Range start end) (Node{token=Token dimension _}) jsonValue) = - Entity (toName dimension) body val start end +formatToken sentence (Resolved (Range start end) (Node{token=Token dimension _}) value) = + Entity (toName dimension) body value start end where body = Text.drop start $ Text.take end sentence - val = toJText jsonValue diff --git a/Duckling/Core.hs b/Duckling/Core.hs --- a/Duckling/Core.hs +++ b/Duckling/Core.hs @@ -25,16 +25,17 @@ -- Reference time builders , currentReftime + , fromZonedTime , makeReftime ) where import Data.HashMap.Strict (HashMap) -import qualified Data.HashMap.Strict as HashMap import Data.Maybe import Data.Text (Text) import Data.Time import Data.Time.LocalTime.TimeZone.Series import Prelude +import qualified Data.HashMap.Strict as HashMap import Duckling.Api import Duckling.Dimensions.Types @@ -56,3 +57,8 @@ currentReftime series tz = do utcNow <- getCurrentTime return $ makeReftime series tz utcNow + +-- | Builds a `DucklingTime` from a `ZonedTime`. +fromZonedTime :: ZonedTime -> DucklingTime +fromZonedTime (ZonedTime localTime timeZone) = DucklingTime $ + ZoneSeriesTime (toUTC localTime) (TimeZoneSeries timeZone []) diff --git a/Duckling/Dimensions.hs b/Duckling/Dimensions.hs --- a/Duckling/Dimensions.hs +++ b/Duckling/Dimensions.hs @@ -21,6 +21,7 @@ import Duckling.Dimensions.Types import qualified Duckling.Dimensions.Common as CommonDimensions import qualified Duckling.Dimensions.AR as ARDimensions +import qualified Duckling.Dimensions.CS as CSDimensions import qualified Duckling.Dimensions.DA as DADimensions import qualified Duckling.Dimensions.DE as DEDimensions import qualified Duckling.Dimensions.EN as ENDimensions @@ -77,6 +78,7 @@ langDimensions :: Lang -> [Some Dimension] langDimensions AR = ARDimensions.allDimensions +langDimensions CS = CSDimensions.allDimensions langDimensions DA = DADimensions.allDimensions langDimensions DE = DEDimensions.allDimensions langDimensions EN = ENDimensions.allDimensions diff --git a/Duckling/Dimensions/CS.hs b/Duckling/Dimensions/CS.hs new file mode 100644 --- /dev/null +++ b/Duckling/Dimensions/CS.hs @@ -0,0 +1,19 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +module Duckling.Dimensions.CS + ( allDimensions + ) where + +import Duckling.Dimensions.Types + +allDimensions :: [Some Dimension] +allDimensions = + [ This Distance + , This Numeral + ] diff --git a/Duckling/Dimensions/TR.hs b/Duckling/Dimensions/TR.hs --- a/Duckling/Dimensions/TR.hs +++ b/Duckling/Dimensions/TR.hs @@ -14,6 +14,10 @@ allDimensions :: [Some Dimension] allDimensions = - [ This Numeral + [ This Distance + , This Duration + , This Numeral , This Ordinal + , This Temperature + , This Volume ] diff --git a/Duckling/Distance/CS/Corpus.hs b/Duckling/Distance/CS/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/CS/Corpus.hs @@ -0,0 +1,60 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.CS.Corpus + ( corpus ) where + +import Data.String +import Prelude + +import Duckling.Distance.Types +import Duckling.Lang +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {lang = CS}, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (DistanceValue Kilometre 3) + [ "3 kilometry" + , "3 km" + , "3km" + ] + , examples (DistanceValue Mile 8) + [ "8 mil" + , "osm mil" + ] + , examples (DistanceValue Metre 1) + [ "1m" + , "1 metr" + ] + , examples (DistanceValue Metre 2) + [ "2m" + , "2 metry" + ] + , examples (DistanceValue Metre 9) + [ "9m" + , "9 metrů" + ] + , examples (DistanceValue Centimetre 1) + [ "1cm" + , "1 centimetr" + ] + , examples (DistanceValue Centimetre 2) + [ "2cm" + , "2 centimetry" + ] + , examples (DistanceValue Centimetre 9) + [ "9cm" + , "9 centimetrů" + ] + ] diff --git a/Duckling/Distance/CS/Rules.hs b/Duckling/Distance/CS/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/CS/Rules.hs @@ -0,0 +1,81 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.CS.Rules + ( rules ) where + +import Data.String +import Prelude + +import Duckling.Dimensions.Types +import Duckling.Distance.Helpers +import Duckling.Types +import qualified Duckling.Distance.Types as TDistance + +ruleLatentDistKm :: Rule +ruleLatentDistKm = Rule + { name = " km" + , pattern = + [ dimension Distance + , regex "km|kilometr(y|\x016f)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Kilometre dd + _ -> Nothing + } + +ruleDistMeters :: Rule +ruleDistMeters = Rule + { name = " meters" + , pattern = + [ dimension Distance + , regex "metr(y|\x016f)?|m" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Metre dd + _ -> Nothing + } + +ruleDistCentimeters :: Rule +ruleDistCentimeters = Rule + { name = " centimeters" + , pattern = + [ dimension Distance + , regex "cm|centimetr(y|\x016f)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Centimetre dd + _ -> Nothing + } + +ruleDistMiles :: Rule +ruleDistMiles = Rule + { name = " miles" + , pattern = + [ dimension Distance + , regex "mil" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Mile dd + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDistCentimeters + , ruleDistMeters + , ruleDistMiles + , ruleLatentDistKm + ] diff --git a/Duckling/Distance/EN/Corpus.hs b/Duckling/Distance/EN/Corpus.hs --- a/Duckling/Distance/EN/Corpus.hs +++ b/Duckling/Distance/EN/Corpus.hs @@ -32,6 +32,7 @@ , examples (DistanceValue Mile 8) [ "8 miles" , "eight mile" + , "8 mi" ] , examples (DistanceValue M 9) [ "9m" @@ -39,5 +40,11 @@ , examples (DistanceValue Centimetre 2) [ "2cm" , "2 centimeters" + ] + , examples (DistanceValue Inch 5) + [ "5 in" + , "5''" + , "five inches" + , "5\"" ] ] diff --git a/Duckling/Distance/EN/Rules.hs b/Duckling/Distance/EN/Rules.hs --- a/Duckling/Distance/EN/Rules.hs +++ b/Duckling/Distance/EN/Rules.hs @@ -58,11 +58,11 @@ distances :: [(Text, String, TDistance.Unit)] distances = [ (" km", "k(ilo)?m?(eter)?s?", TDistance.Kilometre) , (" feet", "('|f(oo|ee)?ts?)", TDistance.Foot) - , (" inch", "(''|inch(es)?)", TDistance.Inch) + , (" inch", "(\"|''|in(ch(es)?)?)", TDistance.Inch) , (" yard", "y(ar)?ds?", TDistance.Yard) , (" meters", "meters?", TDistance.Metre) , (" centimeters", "cm|centimeters?", TDistance.Centimetre) - , (" miles", "miles?", TDistance.Mile) + , (" miles", "mi(le(s)?)?", TDistance.Mile) , (" m (ambiguous miles or meters)", "m", TDistance.M) ] diff --git a/Duckling/Distance/TR/Corpus.hs b/Duckling/Distance/TR/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/TR/Corpus.hs @@ -0,0 +1,52 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.TR.Corpus + ( corpus ) where + +import Data.String +import Prelude + +import Duckling.Distance.Types +import Duckling.Lang +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {lang = TR}, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (DistanceValue Kilometre 3) + [ "3 Kilometre" + , "3 kilometre" + , "3 km" + , "3km" + ] + , examples (DistanceValue Kilometre 3.0) + [ "3,0 km" + ] + , examples (DistanceValue Mile 8) + [ "8 Mil" + , "8 mil" + ] + , examples (DistanceValue Metre 9) + [ "9 Metre" + , "9 metre" + , "9 m" + , "9m" + ] + , examples (DistanceValue Centimetre 2) + [ "2 Santimetre" + , "2 santim" + , "2 cm" + , "2cm" + ] + ] diff --git a/Duckling/Distance/TR/Rules.hs b/Duckling/Distance/TR/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/TR/Rules.hs @@ -0,0 +1,81 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.TR.Rules + ( rules ) where + +import Data.String +import Prelude + +import Duckling.Dimensions.Types +import Duckling.Distance.Helpers +import qualified Duckling.Distance.Types as TDistance +import Duckling.Types + +ruleLatentDistKm :: Rule +ruleLatentDistKm = Rule + { name = " km" + , pattern = + [ dimension Distance + , regex "k(ilo)?m?(etre)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Kilometre dd + _ -> Nothing + } + +ruleDistMeters :: Rule +ruleDistMeters = Rule + { name = " meters" + , pattern = + [ dimension Distance + , regex "m(etre)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Metre dd + _ -> Nothing + } + +ruleDistCentimeters :: Rule +ruleDistCentimeters = Rule + { name = " centimeters" + , pattern = + [ dimension Distance + , regex "cm|santim(etre)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Centimetre dd + _ -> Nothing + } + +ruleDistMiles :: Rule +ruleDistMiles = Rule + { name = " miles" + , pattern = + [ dimension Distance + , regex "mil" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Mile dd + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDistCentimeters + , ruleDistMeters + , ruleDistMiles + , ruleLatentDistKm + ] diff --git a/Duckling/Duration/DA/Rules.hs b/Duckling/Duration/DA/Rules.hs --- a/Duckling/Duration/DA/Rules.hs +++ b/Duckling/Duration/DA/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData (..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -109,14 +109,11 @@ , regex "timer?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/DE/Rules.hs b/Duckling/Duration/DE/Rules.hs --- a/Duckling/Duration/DE/Rules.hs +++ b/Duckling/Duration/DE/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData (..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -67,14 +67,11 @@ [ regex "(\\d+)\\.(\\d+) stunden?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/EN/Rules.hs b/Duckling/Duration/EN/Rules.hs --- a/Duckling/Duration/EN/Rules.hs +++ b/Duckling/Duration/EN/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInt, parseInteger) import Duckling.Numeral.Types (NumeralData(..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -90,14 +90,11 @@ { name = "number.number hours" , pattern = [regex "(\\d+)\\.(\\d+) *hours?"] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/HE/Rules.hs b/Duckling/Duration/HE/Rules.hs --- a/Duckling/Duration/HE/Rules.hs +++ b/Duckling/Duration/HE/Rules.hs @@ -21,7 +21,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers import Duckling.Duration.Types (DurationData (..)) -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData(..)) import Duckling.Regex.Types import Duckling.Types @@ -64,14 +64,11 @@ , regex "\x05e9\x05e2\x05d4|\x05e9\x05e2\x05d5\x05ea" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/HR/Rules.hs b/Duckling/Duration/HR/Rules.hs --- a/Duckling/Duration/HR/Rules.hs +++ b/Duckling/Duration/HR/Rules.hs @@ -21,7 +21,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers import Duckling.Duration.Types (DurationData (..)) -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData(..)) import Duckling.Regex.Types import Duckling.Types @@ -99,14 +99,11 @@ , regex "sat(i|a)?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/Helpers.hs b/Duckling/Duration/Helpers.hs --- a/Duckling/Duration/Helpers.hs +++ b/Duckling/Duration/Helpers.hs @@ -14,6 +14,7 @@ , isGrain , isNatural , isNumeralWith + , minutesFromHourMixedFraction ) where import Prelude @@ -48,3 +49,7 @@ duration :: TG.Grain -> Int -> DurationData duration grain n = DurationData {TDuration.grain = grain, TDuration.value = n} + +minutesFromHourMixedFraction :: Integer -> Integer -> Integer -> DurationData +minutesFromHourMixedFraction h n d = + duration TG.Minute $ fromIntegral $ 60 * h + quot (n * 60) d diff --git a/Duckling/Duration/KO/Rules.hs b/Duckling/Duration/KO/Rules.hs --- a/Duckling/Duration/KO/Rules.hs +++ b/Duckling/Duration/KO/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData (..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -53,14 +53,11 @@ , regex "\xc2dc\xac04" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do - hh <- parseInt m1 - dec <- parseInt m2 - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length m2 - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/NB/Rules.hs b/Duckling/Duration/NB/Rules.hs --- a/Duckling/Duration/NB/Rules.hs +++ b/Duckling/Duration/NB/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData (..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -57,14 +57,11 @@ [ regex "(\\d+)\\,(\\d+) *timer?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration $ duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/PL/Rules.hs b/Duckling/Duration/PL/Rules.hs --- a/Duckling/Duration/PL/Rules.hs +++ b/Duckling/Duration/PL/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData (..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -59,14 +59,11 @@ , regex "godzin(y)?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/SV/Rules.hs b/Duckling/Duration/SV/Rules.hs --- a/Duckling/Duration/SV/Rules.hs +++ b/Duckling/Duration/SV/Rules.hs @@ -19,7 +19,7 @@ import Duckling.Dimensions.Types import Duckling.Duration.Helpers -import Duckling.Numeral.Helpers (parseInt) +import Duckling.Numeral.Helpers (parseInteger) import Duckling.Numeral.Types (NumeralData(..)) import qualified Duckling.Numeral.Types as TNumeral import Duckling.Regex.Types @@ -58,14 +58,11 @@ , regex "timm(e|ar)?" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (h:d:_)):_) -> do - hh <- parseInt h - dec <- parseInt d - let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) ** - fromIntegral (Text.length d - 1) - numerator = fromIntegral $ 6 * dec - Just . Token Duration . duration TG.Minute $ - 60 * hh + quot numerator divisor + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden _ -> Nothing } diff --git a/Duckling/Duration/TR/Corpus.hs b/Duckling/Duration/TR/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Duration/TR/Corpus.hs @@ -0,0 +1,55 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Duration.TR.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Duration.Types +import Duckling.Lang +import Duckling.Resolve +import Duckling.Testing.Types +import Duckling.TimeGrain.Types (Grain (..)) + +corpus :: Corpus +corpus = (testContext {lang = TR}, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (DurationData 1 Second) + [ "bir sn" + , "1 saniye" + , "1\"" + ] + , examples (DurationData 2 Minute) + [ "2 dk" + , "iki dakika" + , "2'" + ] + , examples (DurationData 30 Day) + [ "30 gün" + ] + , examples (DurationData 7 Week) + [ "yedi hafta" + ] + , examples (DurationData 1 Month) + [ "1 ay" + , "bir ay" + ] + , examples (DurationData 3 Quarter) + [ "3 çeyrek yıl" + ] + , examples (DurationData 2 Year) + [ "2 yıl" + ] + ] diff --git a/Duckling/Duration/TR/Rules.hs b/Duckling/Duration/TR/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Duration/TR/Rules.hs @@ -0,0 +1,124 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Duration.TR.Rules + ( rules + ) where + +import Control.Monad (join) +import Data.String +import Prelude +import qualified Data.Text as Text + +import Duckling.Dimensions.Types +import Duckling.Duration.Helpers +import Duckling.Numeral.Helpers (parseInteger) +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Regex.Types +import Duckling.Types +import qualified Duckling.Numeral.Types as TNumeral +import qualified Duckling.TimeGrain.Types as TG + +ruleDurationQuarterOfAnHour :: Rule +ruleDurationQuarterOfAnHour = Rule + { name = "quarter of an hour" + , pattern = [ regex "(1/4\\s?sa(at)?|\x00e7eyrek saat)" ] + , prod = \_ -> Just . Token Duration $ duration TG.Minute 15 + } + +ruleDurationHalfAnHour :: Rule +ruleDurationHalfAnHour = Rule + { name = "half an hour" + , pattern = [regex "(1/2\\s?sa(at)?|yar\305m saat)"] + , prod = \_ -> Just . Token Duration $ duration TG.Minute 30 + } + +ruleDurationThreeQuartersOfAnHour :: Rule +ruleDurationThreeQuartersOfAnHour = Rule + { name = "three-quarters of an hour" + , pattern = [regex "(3/4\\s?sa(at)?|\x00fc\x00e7e \231eyrek sa(at)?)"] + , prod = \_ -> Just . Token Duration $ duration TG.Minute 45 + } + +ruleDurationFortnight :: Rule +ruleDurationFortnight = Rule + { name = "fortnight" + , pattern = [regex "iki hafta"] + , prod = \_ -> Just . Token Duration $ duration TG.Day 14 + } + +ruleNumeralQuotes :: Rule +ruleNumeralQuotes = Rule + { name = " + '\"" + , pattern = + [ Predicate isNatural + , regex "(['\"])" + ] + , prod = \tokens -> case tokens of + (Token Numeral (NumeralData {TNumeral.value = v}): + Token RegexMatch (GroupMatch (x:_)): + _) -> case x of + "'" -> Just . Token Duration . duration TG.Minute $ floor v + "\"" -> Just . Token Duration . duration TG.Second $ floor v + _ -> Nothing + _ -> Nothing + } + +ruleDurationDotNumeralHours :: Rule +ruleDurationDotNumeralHours = Rule + { name = "number.number hours" + , pattern = [regex "(\\d+)(\\.|,)(\\d+) *sa(at)?"] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (h:m:_)):_) -> do + hh <- parseInteger h + mnum <- parseInteger m + let mden = 10 ^ Text.length m + Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden + _ -> Nothing + } + +ruleDurationAndHalfHour :: Rule +ruleDurationAndHalfHour = Rule + { name = " and an half hour" + , pattern = + [ Predicate isNatural + , regex "bu\x00e7euk sa(at)?" + ] + , prod = \tokens -> case tokens of + (Token Numeral (NumeralData {TNumeral.value = v}):_) -> + Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v + _ -> Nothing + } + + +ruleDurationPrecision :: Rule +ruleDurationPrecision = Rule + { name = " about|exactly" + , pattern = + [ regex "(gibi|civar\305nda|yakla\x015f\305k|tam( olarak)?)" + , dimension Duration + ] + , prod = \tokens -> case tokens of + (_:token:_) -> Just token + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDurationQuarterOfAnHour + , ruleDurationHalfAnHour + , ruleDurationThreeQuartersOfAnHour + , ruleDurationFortnight + , ruleDurationDotNumeralHours + , ruleDurationAndHalfHour + , ruleDurationPrecision + , ruleNumeralQuotes + ] diff --git a/Duckling/Duration/ZH/Corpus.hs b/Duckling/Duration/ZH/Corpus.hs --- a/Duckling/Duration/ZH/Corpus.hs +++ b/Duckling/Duration/ZH/Corpus.hs @@ -27,10 +27,20 @@ [ examples (DurationData 1 Second) [ "1 秒钟" , "一 秒鐘" + , "一 秒" ] + , examples (DurationData 1 Minute) + [ "1 分鐘" + , "一 分鐘" + ] + , examples (DurationData 1 Hour) + [ "1 小時" + , "一 小時" + ] , examples (DurationData 5 Day) [ "5 天" , "五 天" + , "五 日" ] , examples (DurationData 10 Month) [ "10 月" diff --git a/Duckling/Lang.hs b/Duckling/Lang.hs --- a/Duckling/Lang.hs +++ b/Duckling/Lang.hs @@ -23,6 +23,7 @@ data Lang = AR + | CS | DA | DE | EN diff --git a/Duckling/Numeral/CS/Corpus.hs b/Duckling/Numeral/CS/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Numeral/CS/Corpus.hs @@ -0,0 +1,47 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Numeral.CS.Corpus + ( corpus ) where + +import Data.String +import Prelude + +import Duckling.Lang +import Duckling.Numeral.Types +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {lang = CS}, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (NumeralValue 0) + [ "0" + , "nula" + ] + , examples (NumeralValue 1) + [ "1" + , "jeden" + , "jedna" + , "jedno" + ] + , examples (NumeralValue 2) + [ "dva" + , "dvĕ" + ] + , examples (NumeralValue 3) + [ "tři" + ] + , examples (NumeralValue 4) + [ "čtyři" + ] + ] diff --git a/Duckling/Numeral/CS/Rules.hs b/Duckling/Numeral/CS/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Numeral/CS/Rules.hs @@ -0,0 +1,78 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Numeral.CS.Rules + ( rules ) where + +import Data.HashMap.Strict (HashMap) +import Data.Maybe +import Data.String +import Data.Text (Text) +import Prelude +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text + +import Duckling.Dimensions.Types +import Duckling.Numeral.Helpers +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Regex.Types +import Duckling.Types +import qualified Duckling.Numeral.Types as TNumeral + +ruleIntegerNumeric :: Rule +ruleIntegerNumeric = Rule + { name = "integer (numeric)" + , pattern = + [ regex "(\\d{1,18})" + ] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (match:_)): + _) -> do + v <- parseInt match + integer $ toInteger v + _ -> Nothing + } + +ruleNumeralMap :: HashMap Text Integer +ruleNumeralMap = HashMap.fromList + [ ( "nula", 0 ) + , ( "jeden", 1 ) + , ( "jedna", 1 ) + , ( "jedno", 1 ) + , ( "dva", 2 ) + , ( "dv\x0115", 2 ) + , ( "t\x0159i", 3 ) + , ( "\x010dty\x0159i", 4 ) + , ( "p\x0115t", 5) + , ( "\x0161est", 6) + , ( "sedm", 7) + , ( "osm", 8) + , ( "dev\x0115t", 9) + , ( "deset", 10) + ] + +ruleNumeral :: Rule +ruleNumeral = Rule + { name = "number (0..10)" + , pattern = + [ regex "(nula|jed(en|n[ao])|dv(a|\x0115)|t(\x0159)i|(\x010d)ty(\x0159)i|p(\x0115)t|(\x0161)est|sedm|osm|dev(\x0115)t|deset)" + ] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (match:_)):_) -> + HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleIntegerNumeric + , ruleNumeral + ] diff --git a/Duckling/Numeral/EN/Corpus.hs b/Duckling/Numeral/EN/Corpus.hs --- a/Duckling/Numeral/EN/Corpus.hs +++ b/Duckling/Numeral/EN/Corpus.hs @@ -103,6 +103,12 @@ , "100k" , "one hundred thousand" ] + , examples (NumeralValue 0.2) + [ "1/5" + , "2/10" + , "3/15" + , "20/100" + ] , examples (NumeralValue 3e6) [ "3M" , "3000K" diff --git a/Duckling/Numeral/EN/Rules.hs b/Duckling/Numeral/EN/Rules.hs --- a/Duckling/Numeral/EN/Rules.hs +++ b/Duckling/Numeral/EN/Rules.hs @@ -8,6 +8,7 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE NoRebindableSyntax #-} module Duckling.Numeral.EN.Rules ( rules ) where @@ -197,6 +198,18 @@ _ -> Nothing } +ruleFractions :: Rule +ruleFractions = Rule + { name = "fractional number" + , pattern = [regex "(\\d+)/(\\d+)"] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (numerator:denominator:_)):_) -> do + n <- parseDecimal False numerator + d <- parseDecimal False denominator + divide n d + _ -> Nothing + } + ruleCommas :: Rule ruleCommas = Rule { name = "comma-separated numbers" @@ -293,6 +306,7 @@ , ruleDotSpelledOut , ruleLeadingDotSpelledOut , ruleDecimals + , ruleFractions , ruleCommas , ruleSuffixes , ruleNegative diff --git a/Duckling/Numeral/Helpers.hs b/Duckling/Numeral/Helpers.hs --- a/Duckling/Numeral/Helpers.hs +++ b/Duckling/Numeral/Helpers.hs @@ -14,11 +14,13 @@ , double , integer , multiply + , divide , numberBetween , numberWith , oneOf , parseDouble , parseInt + , parseInteger , withGrain , withMultipliable , parseDecimal, @@ -44,7 +46,10 @@ comma = Text.singleton ',' parseInt :: Text -> Maybe Int -parseInt = +parseInt = (fromIntegral <$>) . parseInteger + +parseInteger :: Text -> Maybe Integer +parseInteger = either (const Nothing) Just . Atto.parseOnly (Atto.signed Atto.decimal) -- | Add leading 0 when leading . for double parsing to succeed @@ -119,6 +124,14 @@ Just grain | v2 > v1 -> double (v1 * v2) >>= withGrain grain | otherwise -> Nothing multiply _ _ = Nothing + +divide :: Token -> Token -> Maybe Token +divide + (Token Numeral (NumeralData {value = v1})) + (Token Numeral (NumeralData {value = v2})) = case v1 / v2 of + x | isInfinite x || isNaN x -> Nothing + x -> double x +divide _ _ = Nothing parseDecimal :: Bool -> Text -> Maybe Token parseDecimal isDot match diff --git a/Duckling/Numeral/ID/Rules.hs b/Duckling/Numeral/ID/Rules.hs --- a/Duckling/Numeral/ID/Rules.hs +++ b/Duckling/Numeral/ID/Rules.hs @@ -12,8 +12,11 @@ module Duckling.Numeral.ID.Rules ( rules ) where +import qualified Data.HashMap.Strict as HashMap +import Data.HashMap.Strict (HashMap) import Data.Maybe import qualified Data.Text as Text +import Data.Text (Text) import Prelude import Data.String @@ -24,6 +27,22 @@ import Duckling.Regex.Types import Duckling.Types +ruleIntegerMap :: HashMap Text Integer +ruleIntegerMap = HashMap.fromList + [ ( "kosong" , 0 ) + , ( "nol" , 0 ) + , ( "satu" , 1 ) + , ( "dua" , 2 ) + , ( "tiga" , 3 ) + , ( "empat" , 4 ) + , ( "lima" , 5 ) + , ( "enam" , 6 ) + , ( "tujuh" , 7 ) + , ( "delapan" , 8 ) + , ( "sembilan", 9 ) + , ( "sebelas" , 11 ) + ] + ruleTeen :: Rule ruleTeen = Rule { name = "teen" @@ -209,20 +228,8 @@ [ regex "(kosong|nol|satu|dua|tiga|empat|lima|enam|tujuh|delapan|sembilan|sebelas)" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of - "kosong" -> integer 0 - "nol" -> integer 0 - "satu" -> integer 1 - "dua" -> integer 2 - "tiga" -> integer 3 - "empat" -> integer 4 - "lima" -> integer 5 - "enam" -> integer 6 - "tujuh" -> integer 7 - "delapan" -> integer 8 - "sembilan" -> integer 9 - "sebelas" -> integer 11 - _ -> Nothing + (Token RegexMatch (GroupMatch (match:_)):_) -> + HashMap.lookup (Text.toLower match) ruleIntegerMap >>= integer _ -> Nothing } diff --git a/Duckling/Numeral/TR/Corpus.hs b/Duckling/Numeral/TR/Corpus.hs --- a/Duckling/Numeral/TR/Corpus.hs +++ b/Duckling/Numeral/TR/Corpus.hs @@ -68,18 +68,20 @@ , "on sekiz" ] , examples (NumeralValue 1.1) - [ "1.1" - , "1.10" - , "01.10" + [ "1,1" + , "1,10" + , "01,10" , "bir virgül bir" , "bir nokta bir" ] , examples (NumeralValue 0.77) - [ "0.77" - , ".77" + [ "0,77" + , ",77" + , "sıfır virgül yetmişyedi" + , "sıfır virgül yetmiş yedi" ] , examples (NumeralValue 100000) - [ "100,000" + [ "100.000" , "100000" , "100K" , "100k" @@ -89,24 +91,24 @@ [ "3M" , "3000K" , "3000000" - , "3,000,000" + , "3.000.000" ] , examples (NumeralValue 1200000) - [ "1,200,000" + [ "1.200.000" , "1200000" - , "1.2M" + , "1,2M" , "1200K" - , ".0012G" + , ",0012G" , "1200B" ] , examples (NumeralValue (-1200000)) - [ "- 1,200,000" + [ "- 1.200.000" , "-1200000" - , "eksi 1,200,000" + , "eksi 1.200.000" , "negatif 1200000" - , "-1.2M" + , "-1,2M" , "-1200K" - , "-.0012G" + , "-,0012G" , "-1200B" ] , examples (NumeralValue 5000) @@ -149,32 +151,34 @@ [ "beş buçuk" , "beşbuçuk" , "5 buçuk" - , "5.5" + , "5,5" ] , examples (NumeralValue 3500000) - [ "3.5 milyon" + [ "3,5 milyon" , "3500000" , "üç buçuk milyon" , "üçbuçuk milyon" - , "3.5M" + , "3,5M" ] , examples (NumeralValue 0.5) [ "yarım" - , "0.5" + , "0,5" ] , examples (NumeralValue 2500) - [ "2.5 bin" + [ "2,5 bin" , "2500" - , "iki buçuk bin" - , "ikibuçuk bin" + , "iki bin beş yüz" + , "ikibin beşyüz" ] , examples (NumeralValue 2200000) - [ "2.2 milyon" + [ "2,2 milyon" , "iki nokta iki milyon" + , "iki virgül iki milyon" ] , examples (NumeralValue 72.5) [ "yetmişikibuçuk" , "yetmişiki buçuk" - , "72.5" + , "yetmiş iki buçuk" + , "72,5" ] ] diff --git a/Duckling/Numeral/TR/Rules.hs b/Duckling/Numeral/TR/Rules.hs --- a/Duckling/Numeral/TR/Rules.hs +++ b/Duckling/Numeral/TR/Rules.hs @@ -110,11 +110,14 @@ ruleDecimalWithThousandsSeparator = Rule { name = "decimal with thousands separator" , pattern = - [ regex "(\\d+(,\\d\\d\\d)+\\.\\d+)" + [ regex "(\\d+(\\.\\d\\d\\d)+,\\d+)" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> - parseDouble (Text.replace (Text.singleton ',') Text.empty match) >>= double + let dot = Text.singleton '.' + comma = Text.singleton ',' + fmt = Text.replace comma dot $ Text.replace dot Text.empty match + in parseDouble fmt >>= double _ -> Nothing } @@ -138,11 +141,11 @@ ruleDecimalNumeral = Rule { name = "decimal number" , pattern = - [ regex "(\\d*\\.\\d+)" + [ regex "(\\d*,\\d+)" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> - parseDecimal True match + parseDecimal False match _ -> Nothing } @@ -689,13 +692,13 @@ ruleIntegerWithThousandsSeparator :: Rule ruleIntegerWithThousandsSeparator = Rule - { name = "integer with thousands separator ," + { name = "integer with thousands separator ." , pattern = - [ regex "(\\d{1,3}(,\\d\\d\\d){1,5})" + [ regex "(\\d{1,3}(\\.\\d\\d\\d){1,5})" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> - parseDouble (Text.replace (Text.singleton ',') Text.empty match) >>= double + parseDouble (Text.replace (Text.singleton '.') Text.empty match) >>= double _ -> Nothing } diff --git a/Duckling/Ordinal/DE/Corpus.hs b/Duckling/Ordinal/DE/Corpus.hs --- a/Duckling/Ordinal/DE/Corpus.hs +++ b/Duckling/Ordinal/DE/Corpus.hs @@ -9,7 +9,9 @@ {-# LANGUAGE OverloadedStrings #-} module Duckling.Ordinal.DE.Corpus - ( corpus ) where + ( corpus + , negativeCorpus + ) where import Prelude import Data.String @@ -22,10 +24,19 @@ corpus :: Corpus corpus = (testContext {lang = DE}, allExamples) +negativeCorpus :: NegativeCorpus +negativeCorpus = (testContext {lang = DE}, examples) + where + examples = + [ "1.1" + , "1.1." + ] + allExamples :: [Example] allExamples = examples (OrdinalData 4) [ "vierter" , "4ter" , "Vierter" + , "4." ] diff --git a/Duckling/Ordinal/DE/Rules.hs b/Duckling/Ordinal/DE/Rules.hs --- a/Duckling/Ordinal/DE/Rules.hs +++ b/Duckling/Ordinal/DE/Rules.hs @@ -77,7 +77,7 @@ ruleOrdinalDigits = Rule { name = "ordinal (digits)" , pattern = - [ regex "0*(\\d+)(\\.| ?(te(n|r|s)?)|(ste(n|r|s)?))" + [ regex "(? case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> do diff --git a/Duckling/Quantity/EN/Corpus.hs b/Duckling/Quantity/EN/Corpus.hs --- a/Duckling/Quantity/EN/Corpus.hs +++ b/Duckling/Quantity/EN/Corpus.hs @@ -31,4 +31,13 @@ , examples (QuantityData Cup 3 (Just "sugar")) [ "3 Cups of sugar" ] + , examples (QuantityData Cup 0.75 Nothing) + [ "3/4 cup" + , "0.75 cup" + , ".75 cups" + ] + , examples (QuantityData Gram 500 (Just "strawberries")) + [ "500 grams of strawberries" + , "500g of strawberries" + ] ] diff --git a/Duckling/Quantity/EN/Rules.hs b/Duckling/Quantity/EN/Rules.hs --- a/Duckling/Quantity/EN/Rules.hs +++ b/Duckling/Quantity/EN/Rules.hs @@ -12,46 +12,57 @@ module Duckling.Quantity.EN.Rules ( rules ) where -import qualified Data.Text as Text -import Prelude import Data.String +import Prelude +import qualified Data.Text as Text -import qualified Duckling.Numeral.Types as TNumeral +import Duckling.Dimensions.Types import Duckling.Quantity.Helpers -import qualified Duckling.Quantity.Types as TQuantity import Duckling.Regex.Types -import Duckling.Dimensions.Types import Duckling.Types +import qualified Duckling.Numeral.Types as TNumeral +import qualified Duckling.Quantity.Types as TQuantity ruleNumeralQuantity :: Rule ruleNumeralQuantity = Rule { name = " " , pattern = [ dimension Numeral - , regex "(pound|cup)s?" + , regex "((pound|cup|gram)s?|g)" ] , prod = \tokens -> case tokens of (Token Numeral nd: Token RegexMatch (GroupMatch (match:_)): _) -> case Text.toLower match of - "cup" -> Just . Token Quantity . quantity TQuantity.Cup $ TNumeral.value nd - "cups" -> Just . Token Quantity . quantity TQuantity.Cup $ TNumeral.value nd - "pound" -> Just . Token Quantity . quantity TQuantity.Pound $ TNumeral.value nd - "pounds" -> Just . Token Quantity . quantity TQuantity.Pound $ TNumeral.value nd - _ -> Nothing + "cup" -> + Just . Token Quantity . quantity TQuantity.Cup $ TNumeral.value nd + "cups" -> + Just . Token Quantity . quantity TQuantity.Cup $ TNumeral.value nd + "g" -> + Just . Token Quantity . quantity TQuantity.Gram $ TNumeral.value nd + "gram" -> + Just . Token Quantity . quantity TQuantity.Gram $ TNumeral.value nd + "grams" -> + Just . Token Quantity . quantity TQuantity.Gram $ TNumeral.value nd + "pound" -> + Just . Token Quantity . quantity TQuantity.Pound $ TNumeral.value nd + "pounds" -> + Just . Token Quantity . quantity TQuantity.Pound $ TNumeral.value nd + _ -> Nothing _ -> Nothing } ruleAQuantity :: Rule ruleAQuantity = Rule { name = "a quantity" - , pattern = [ regex "a (pound|cup)s?"] + , pattern = + [ regex "a (pound|cup|gram)s?" + ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of "cup" -> Just . Token Quantity $ quantity TQuantity.Cup 1 - "cups" -> Just . Token Quantity $ quantity TQuantity.Cup 1 + "gram" -> Just . Token Quantity $ quantity TQuantity.Gram 1 "pound" -> Just . Token Quantity $ quantity TQuantity.Pound 1 - "pounds" -> Just . Token Quantity $ quantity TQuantity.Pound 1 _ -> Nothing _ -> Nothing } @@ -61,7 +72,7 @@ { name = " of product" , pattern = [ dimension Quantity - , regex "of (meat|sugar)" + , regex "of (\\w+)" ] , prod = \tokens -> case tokens of (Token Quantity qd:Token RegexMatch (GroupMatch (product:_)):_) -> diff --git a/Duckling/Ranking/Classifiers.hs b/Duckling/Ranking/Classifiers.hs --- a/Duckling/Ranking/Classifiers.hs +++ b/Duckling/Ranking/Classifiers.hs @@ -12,6 +12,7 @@ import Duckling.Lang import qualified Duckling.Ranking.Classifiers.AR as ARClassifiers +import qualified Duckling.Ranking.Classifiers.CS as CSClassifiers import qualified Duckling.Ranking.Classifiers.DA as DAClassifiers import qualified Duckling.Ranking.Classifiers.DE as DEClassifiers import qualified Duckling.Ranking.Classifiers.EN as ENClassifiers @@ -41,6 +42,7 @@ classifiers :: Lang -> Classifiers classifiers AR = ARClassifiers.classifiers +classifiers CS = CSClassifiers.classifiers classifiers DA = DAClassifiers.classifiers classifiers DE = DEClassifiers.classifiers classifiers EN = ENClassifiers.classifiers diff --git a/Duckling/Ranking/Classifiers/CS.hs b/Duckling/Ranking/Classifiers/CS.hs new file mode 100644 --- /dev/null +++ b/Duckling/Ranking/Classifiers/CS.hs @@ -0,0 +1,22 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + +----------------------------------------------------------------- +-- Auto-generated by regenClassifiers +-- +-- DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING +-- @generated +----------------------------------------------------------------- +{-# LANGUAGE OverloadedStrings #-} +module Duckling.Ranking.Classifiers.CS (classifiers) where +import Prelude +import Duckling.Ranking.Types +import qualified Data.HashMap.Strict as HashMap +import Data.String + +classifiers :: Classifiers +classifiers = HashMap.fromList [] diff --git a/Duckling/Ranking/Classifiers/DE.hs b/Duckling/Ranking/Classifiers/DE.hs --- a/Duckling/Ranking/Classifiers/DE.hs +++ b/Duckling/Ranking/Classifiers/DE.hs @@ -35,11 +35,11 @@ likelihoods = HashMap.fromList [], n = 0}}), ("integer (numeric)", Classifier{okData = - ClassData{prior = -0.668083211896729, unseen = -4.634728988229636, - likelihoods = HashMap.fromList [("", 0.0)], n = 101}, + ClassData{prior = -0.6616839111041602, unseen = -4.74493212836325, + likelihoods = HashMap.fromList [("", 0.0)], n = 113}, koData = - ClassData{prior = -0.7188555372701523, unseen = -4.584967478670572, - likelihoods = HashMap.fromList [("", 0.0)], n = 96}}), + ClassData{prior = -0.7256326357044337, unseen = -4.68213122712422, + likelihoods = HashMap.fromList [("", 0.0)], n = 106}}), ("exactly ", Classifier{okData = ClassData{prior = 0.0, unseen = -2.3025850929940455, @@ -175,34 +175,35 @@ likelihoods = HashMap.fromList [], n = 0}}), ("mm/dd", Classifier{okData = - ClassData{prior = -0.2231435513142097, unseen = -1.791759469228055, - likelihoods = HashMap.fromList [("", 0.0)], n = 4}, + ClassData{prior = -0.13353139262452263, + unseen = -2.1972245773362196, + likelihoods = HashMap.fromList [("", 0.0)], n = 7}, koData = - ClassData{prior = -1.6094379124341003, + ClassData{prior = -2.0794415416798357, unseen = -1.0986122886681098, likelihoods = HashMap.fromList [("", 0.0)], n = 1}}), ("at ", Classifier{okData = - ClassData{prior = -0.20972053098206903, - unseen = -4.276666119016055, + ClassData{prior = -0.19237189264745613, + unseen = -4.356708826689592, likelihoods = HashMap.fromList - [(" o'clock", -2.065455299705096), + [(" o'clock", -2.0412203288596382), ("half (german style hour-of-day)", - -3.56953269648137), - ("about ", -3.164067588373206), - ("time-of-day (latent)", -1.6236225474260568), + -3.6506582412937383), + ("about ", -2.7343675094195836), + ("time-of-day (latent)", -1.7047480922384253), ("relative minutes after|past (hour-of-day)", - -3.56953269648137), - ("hh:mm", -2.8763855159214247), + -3.6506582412937383), + ("hh:mm", -2.9575110607337933), ("quarter after|past (hour-of-day)", - -3.56953269648137), - ("hour", -1.08462604669337), ("minute", -2.1832383353614793), + -3.6506582412937383), + ("hour", -1.0479685558493548), ("minute", -2.264363880173848), (" (as relative minutes)", - -3.56953269648137)], - n = 30}, + -3.6506582412937383)], + n = 33}, koData = - ClassData{prior = -1.6650077635889111, unseen = -3.258096538021482, + ClassData{prior = -1.742969305058623, unseen = -3.258096538021482, likelihoods = HashMap.fromList [("time-of-day (latent)", -1.6094379124341003), @@ -211,37 +212,40 @@ n = 7}}), ("absorption of , after named day", Classifier{okData = - ClassData{prior = 0.0, unseen = -3.1780538303479458, + ClassData{prior = -7.410797215372185e-2, + unseen = -3.4011973816621555, likelihoods = HashMap.fromList - [("on ", -2.03688192726104), ("day", -0.7375989431307791), - ("named-day", -0.9382696385929302)], - n = 10}, + [("on ", -2.268683541318364), ("day", -0.7282385003712154), + ("named-day", -0.8823891801984737)], + n = 13}, koData = - ClassData{prior = -infinity, unseen = -1.3862943611198906, - likelihoods = HashMap.fromList [], n = 0}}), + ClassData{prior = -2.639057329615259, unseen = -1.791759469228055, + likelihoods = + HashMap.fromList + [("day", -0.916290731874155), ("named-day", -0.916290731874155)], + n = 1}}), ("on ", Classifier{okData = - ClassData{prior = -0.20409535634351528, - unseen = -4.820281565605037, + ClassData{prior = -0.2076393647782445, unseen = -4.804021044733257, likelihoods = HashMap.fromList - [("mm/dd", -4.119037174812472), - ("absorption of , after named day", -3.713572066704308), - ("intersect", -1.867745376205977), - ("after lunch", -2.866274206317104), - ("day", -1.4799798451972137), ("afternoon", -2.866274206317104), - ("named-day", -2.866274206317104), - ("intersect by ','", -2.866274206317104), - ("intersect by 'of', 'from', 's", -3.4258899942525267), - (" (ordinal)", -3.713572066704308), - ("hour", -1.9218125974762528), ("evening", -4.119037174812472), - (" - (interval)", -4.119037174812472), - ("minute", -2.509599262378372), - ("morning", -4.119037174812472)], - n = 53}, + [("mm/dd", -4.102643365036796), + ("absorption of , after named day", -3.6971782569286313), + ("intersect", -1.8513515664303006), + ("after lunch", -2.849880396541428), + ("day", -1.499953679592412), ("afternoon", -2.849880396541428), + ("named-day", -2.849880396541428), + ("intersect by ','", -2.849880396541428), + ("intersect by 'of', 'from', 's", -3.4094961844768505), + (" (ordinal)", -4.102643365036796), + ("hour", -1.9054187877005764), ("evening", -4.102643365036796), + (" - (interval)", -4.102643365036796), + ("minute", -2.4932054526026954), + ("morning", -4.102643365036796)], + n = 52}, koData = - ClassData{prior = -1.6894806201076367, + ClassData{prior = -1.6739764335716716, unseen = -3.7376696182833684, likelihoods = HashMap.fromList @@ -304,24 +308,24 @@ likelihoods = HashMap.fromList [], n = 0}}), (" o'clock", Classifier{okData = - ClassData{prior = -4.348511193973878e-2, - unseen = -4.61512051684126, + ClassData{prior = -3.077165866675366e-2, + unseen = -4.9344739331306915, likelihoods = HashMap.fromList - [("exactly ", -3.912023005428146), - ("at ", -2.4079456086518722), + [("exactly ", -4.23410650459726), + ("at ", -2.624668592163159), ("half (german style hour-of-day)", - -3.912023005428146), - ("about ", -3.2188758248682006), - ("time-of-day (latent)", -1.3470736479666092), + -4.23410650459726), + ("about ", -2.847812143477369), + ("time-of-day (latent)", -1.3437347467010947), ("quarter after|past (hour-of-day)", - -3.912023005428146), - ("until ", -3.2188758248682006), - ("hour", -0.8209805520698302), ("minute", -3.506557897319982), - ("after ", -3.2188758248682006)], - n = 45}, + -4.23410650459726), + ("until ", -3.1354942159291497), + ("hour", -0.7841189587656721), ("minute", -3.828641396489095), + ("after ", -3.1354942159291497)], + n = 64}, koData = - ClassData{prior = -3.1570004211501135, unseen = -2.70805020110221, + ClassData{prior = -3.4965075614664802, unseen = -2.70805020110221, likelihoods = HashMap.fromList [("time-of-day (latent)", -1.9459101490553135), @@ -354,252 +358,264 @@ n = 1}}), ("intersect", Classifier{okData = - ClassData{prior = -0.24751603072644626, unseen = -6.8001700683022, + ClassData{prior = -0.23031204079282233, + unseen = -6.885509670034817, likelihoods = HashMap.fromList - [("intersect by ','named-month", -4.49647076906475), - ("hourday", -4.8531457130034825), - ("dayhour", -2.481567748522486), - ("daymonth", -3.3333199592590694), + [("intersect by ','named-month", -4.399580002254782), + ("hourday", -4.93857650298747), ("dayhour", -2.527777825353191), + ("daymonth", -3.1232865363492204), ("(ordinal) year o'clock", - -6.105908681498851), - ("monthyear", -4.49647076906475), - ("yearhour", -6.105908681498851), - ("intersect o'clock", -3.9658425180025803), - ("christmasyear", -6.105908681498851), - ("after lunchat ", -6.105908681498851), - ("named-daylast ", -6.105908681498851), - ("intersect by 'of', 'from', 'syear", -5.700443573390687), - (" am|pmintersect", -5.0072963928307415), - ("intersect