From 51d34ce78eda8831b905fc29d0411bb173331090 Mon Sep 17 00:00:00 2001 From: mdc <201205975@post.au.dk> Date: Sat, 19 Mar 2016 22:21:14 +0100 Subject: [PATCH 1/4] Added functions that need to be overriden to lang_DK, created TODO's, added lang_DK to __init__ and added documentation to README --- README.rst | 1 + num2words/__init__.py | 2 + num2words/lang_DK.py | 172 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 175 insertions(+) create mode 100644 num2words/lang_DK.py diff --git a/README.rst b/README.rst index 96d41c3..d62183e 100644 --- a/README.rst +++ b/README.rst @@ -50,6 +50,7 @@ Besides the numerical argument, there's two optional arguments. * ``en_GB`` (British English) * ``en_IN`` (Indian English) * ``pl`` (Polish) +* ``dk`` (Danish) You can supply values like ``fr_FR``, the code will be correctly interpreted. If you supply an unsupported language, ``NotImplementedError`` is raised. diff --git a/num2words/__init__.py b/num2words/__init__.py index 220f0c3..acfa839 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -26,6 +26,7 @@ from . import lang_ES from . import lang_LT from . import lang_LV from . import lang_PL +from . import lang_DK CONVERTER_CLASSES = { 'en': lang_EN.Num2Word_EN(), @@ -38,6 +39,7 @@ CONVERTER_CLASSES = { 'lt': lang_LT.Num2Word_LT(), 'lv': lang_LV.Num2Word_LV(), 'pl': lang_PL.Num2Word_PL(), + 'dk': lang_DK.Num2Word_DK(), } def num2words(number, ordinal=False, lang='en'): diff --git a/num2words/lang_DK.py b/num2words/lang_DK.py new file mode 100644 index 0000000..7d30732 --- /dev/null +++ b/num2words/lang_DK.py @@ -0,0 +1,172 @@ +# Copyright (c) 2003, Taro Ogawa. All Rights Reserved. +# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. + +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA + +from __future__ import division, unicode_literals +from num2words import lang_EU + +class Num2Word_DK(lang_EU.Num2Word_EU): + def set_high_numwords(self, high): + max = 3 + 6*len(high) + for word, n in zip(high, range(max, 3, -6)): + self.cards[10**n] = word + "illard" + self.cards[10**(n-3)] = word + "illion" + + def setup(self): + self.negword = "minus " + self.pointword = "komma" + self.errmsg_nornum = "Kun tal kan blive konverteret til ord." + self.exclude_title = ["og", "komma", "minus"] + + self.mid_numwords = [(1000, "tusind"), (100, "hundrede"), + (90, "nitten"), (80, "firs"), (70, "halvfjerds"), + (60, "treds"), (50, "halvtreds"), (40, "fyrre"), + (30, "tredive")] + self.low_numwords = ["tyve", "nitten", "atten", "sytten", + "seksten", "femten", "fjorten", "tretten", + "tolv", "elleve", "ti", "ni", "\xe5tte", + "syv", "seks", "fem", "fire", "tre", "to", + "et", "nul"] + self.ords = { "en" : "f\xf8rste", + "to" : "anden", + "tre" : "tredje", + "fire" : "fjerde", + "fem" : "femte", + "seks" : "sjette", + "syv" : "syvende", + "otte" : "ottende", + "ni" : "niende", + "ti" : "tiende", + "elleve" : "ellevte", + "tolv" : "tolvte", + "tyve" : "tyvende" } + + + def merge(self, (ltext, lnum), (rtext, rnum)): + if lnum == 1 and rnum < 100: + return (rtext, rnum) + elif 100 > lnum > rnum : + return ("%s-%s"%(ltext, rtext), lnum + rnum) + elif lnum >= 100 > rnum: + return ("%s og %s"%(ltext, rtext), lnum + rnum) + elif rnum > lnum: + return ("%s %s"%(ltext, rtext), lnum * rnum) + return ("%s, %s"%(ltext, rtext), lnum + rnum) + + #TODO: skal returnere ordnum is 21ende, og ord is tyvende + def to_ordinal(self, value): + self.verify_ordinal(value) + outwords = self.to_cardinal(value).split(" ") + lastwords = outwords[-1].split("-") + lastword = lastwords[-1].lower() + try: + lastword = self.ords[lastword] + except KeyError: + if lastword[-2:] == "ti": + lastword = lastword + "ende" + else: + lastword += "de" + lastwords[-1] = self.title(lastword) + outwords[-1] = "".join(lastwords) + return " ".join(outwords) + + #TODO:Skal returnere "en" istedet for "et" i 21. + def to_splitnum(self, val, hightxt="", lowtxt="", jointxt="", + divisor=100, longval=True, cents = True): + out = [] + try: + high, low = val + except TypeError: + high, low = divmod(val, divisor) + if high: + hightxt = self.title(self.inflect(high, hightxt)) + out.append(self.to_cardinal(high)) + if low: + if longval: + if hightxt: + out.append(hightxt) + if jointxt: + out.append(self.title(jointxt)) + elif hightxt: + out.append(hightxt) + if low: + if cents: + out.append(self.to_cardinal(low)) + else: + out.append("%02d" % low) + if lowtxt and longval: + out.append(self.title(self.inflect(low, lowtxt))) + return " ".join(out) + + #TODO: 21 skal returnere enogtyve i card. + def to_cardinal(self, value): + try: + assert long(value) == value + except (ValueError, TypeError, AssertionError): + return self.to_cardinal_float(value) + + self.verify_num(value) + + out = "" + if value < 0: + value = abs(value) + out = self.negword + + if value >= self.MAXVAL: + raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) + + + val = self.splitnum(value) + words, num = self.clean(val) + return self.title(out + words) + + + def to_ordinal_num(self, value): + self.verify_ordinal(value) + return "%s%s"%(value, self.to_ordinal(value)[-2:]) + + + def to_year(self, val, longval=True): + if not (val//100)%10: + return self.to_cardinal(val) + return self.to_splitnum(val, hightxt="hundrede", jointxt="og", + longval=longval) + + def to_currency(self, val, longval=True): + return self.to_splitnum(val, hightxt="krone/r", lowtxt="\xf8re/r", + jointxt="og", longval=longval, cents = True) + + +n2w = Num2Word_DK() +to_card = n2w.to_cardinal +to_ord = n2w.to_ordinal +to_ordnum = n2w.to_ordinal_num +to_year = n2w.to_year + +def main(): + n2w.test(21) + # for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155, + # 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000, + # 8280, 8291, 150000, 500000, 1000000, 2000000, 2000001, + # -21212121211221211111, -2.121212, -1.0000100]: + # n2w.test(val) + # n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) + # for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]: + # print val, "er", n2w.to_currency(val) + # print val, "er", n2w.to_year(val) + + +if __name__ == "__main__": + main() From cce1455846ccb23e666e39d64d51a9292443b1d7 Mon Sep 17 00:00:00 2001 From: mdc <201205975@post.au.dk> Date: Mon, 21 Mar 2016 11:09:30 +0100 Subject: [PATCH 2/4] Added the German algorithms, and begun adjusting them. --- num2words/lang_DK.py | 143 +++++++++++++++---------------------------- 1 file changed, 49 insertions(+), 94 deletions(-) diff --git a/num2words/lang_DK.py b/num2words/lang_DK.py index 7d30732..551611d 100644 --- a/num2words/lang_DK.py +++ b/num2words/lang_DK.py @@ -21,8 +21,8 @@ class Num2Word_DK(lang_EU.Num2Word_EU): def set_high_numwords(self, high): max = 3 + 6*len(high) for word, n in zip(high, range(max, 3, -6)): - self.cards[10**n] = word + "illard" - self.cards[10**(n-3)] = word + "illion" + self.cards[10**n] = word + "illarder" + self.cards[10**(n-3)] = word + "illioner" def setup(self): self.negword = "minus " @@ -53,101 +53,57 @@ class Num2Word_DK(lang_EU.Num2Word_EU): "tolv" : "tolvte", "tyve" : "tyvende" } + def merge(self, curr, next): + ctext, cnum, ntext, nnum = curr + next + + if cnum == 1: + if nnum < 10**6 or self.ordflag: + return next + ctext = "en" + + if nnum > cnum: + if nnum >= 10**6: + ctext += " " + val = cnum * nnum + else: + if nnum < 10 < cnum < 100: + if nnum == 1: + ntext = "en" + ntext, ctext = ctext, ntext + "og" + elif cnum >= 10**6: + ctext += " " + val = cnum + nnum + + word = ctext + ntext + return (word, val) - def merge(self, (ltext, lnum), (rtext, rnum)): - if lnum == 1 and rnum < 100: - return (rtext, rnum) - elif 100 > lnum > rnum : - return ("%s-%s"%(ltext, rtext), lnum + rnum) - elif lnum >= 100 > rnum: - return ("%s og %s"%(ltext, rtext), lnum + rnum) - elif rnum > lnum: - return ("%s %s"%(ltext, rtext), lnum * rnum) - return ("%s, %s"%(ltext, rtext), lnum + rnum) - #TODO: skal returnere ordnum is 21ende, og ord is tyvende def to_ordinal(self, value): self.verify_ordinal(value) - outwords = self.to_cardinal(value).split(" ") - lastwords = outwords[-1].split("-") - lastword = lastwords[-1].lower() - try: - lastword = self.ords[lastword] - except KeyError: - if lastword[-2:] == "ti": - lastword = lastword + "ende" - else: - lastword += "de" - lastwords[-1] = self.title(lastword) - outwords[-1] = "".join(lastwords) - return " ".join(outwords) - - #TODO:Skal returnere "en" istedet for "et" i 21. - def to_splitnum(self, val, hightxt="", lowtxt="", jointxt="", - divisor=100, longval=True, cents = True): - out = [] - try: - high, low = val - except TypeError: - high, low = divmod(val, divisor) - if high: - hightxt = self.title(self.inflect(high, hightxt)) - out.append(self.to_cardinal(high)) - if low: - if longval: - if hightxt: - out.append(hightxt) - if jointxt: - out.append(self.title(jointxt)) - elif hightxt: - out.append(hightxt) - if low: - if cents: - out.append(self.to_cardinal(low)) - else: - out.append("%02d" % low) - if lowtxt and longval: - out.append(self.title(self.inflect(low, lowtxt))) - return " ".join(out) - - #TODO: 21 skal returnere enogtyve i card. - def to_cardinal(self, value): - try: - assert long(value) == value - except (ValueError, TypeError, AssertionError): - return self.to_cardinal_float(value) - - self.verify_num(value) - - out = "" - if value < 0: - value = abs(value) - out = self.negword - - if value >= self.MAXVAL: - raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) - - - val = self.splitnum(value) - words, num = self.clean(val) - return self.title(out + words) + self.ordflag = True + outword = self.to_cardinal(value) + self.ordflag = False + for key in self.ords: + if outword.endswith(key): + outword = outword[:len(outword) - len(key)] + self.ords[key] + break + return outword + "te" + # Is this correct?? def to_ordinal_num(self, value): self.verify_ordinal(value) - return "%s%s"%(value, self.to_ordinal(value)[-2:]) + return str(value) + "te" + def to_currency(self, val, longval=True): + return self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re", + jointxt="og",longval=longval) + def to_year(self, val, longval=True): if not (val//100)%10: return self.to_cardinal(val) - return self.to_splitnum(val, hightxt="hundrede", jointxt="og", - longval=longval) - - def to_currency(self, val, longval=True): - return self.to_splitnum(val, hightxt="krone/r", lowtxt="\xf8re/r", - jointxt="og", longval=longval, cents = True) - + return self.to_splitnum(val, hightxt="hundrede og", longval=longval) n2w = Num2Word_DK() to_card = n2w.to_cardinal @@ -156,16 +112,15 @@ to_ordnum = n2w.to_ordinal_num to_year = n2w.to_year def main(): - n2w.test(21) - # for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155, - # 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000, - # 8280, 8291, 150000, 500000, 1000000, 2000000, 2000001, - # -21212121211221211111, -2.121212, -1.0000100]: - # n2w.test(val) - # n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) - # for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]: - # print val, "er", n2w.to_currency(val) - # print val, "er", n2w.to_year(val) + for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155, + 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000, + 8280, 8291, 150000, 500000, 1000000, 2000000, 2000001, + -21212121211221211111, -2.121212, -1.0000100]: + n2w.test(val) + n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) + for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]: + print val, "er", n2w.to_currency(val) + print val, "er", n2w.to_year(val) if __name__ == "__main__": From 8fff34e3187460fecab4023c57521ffbae682bac Mon Sep 17 00:00:00 2001 From: mdc <201205975@post.au.dk> Date: Mon, 21 Mar 2016 14:16:06 +0100 Subject: [PATCH 3/4] Added og to hundreds, and a lot of other adjustments in the merge algorithm --- num2words/lang_DK.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/num2words/lang_DK.py b/num2words/lang_DK.py index 551611d..0534e93 100644 --- a/num2words/lang_DK.py +++ b/num2words/lang_DK.py @@ -31,12 +31,12 @@ class Num2Word_DK(lang_EU.Num2Word_EU): self.exclude_title = ["og", "komma", "minus"] self.mid_numwords = [(1000, "tusind"), (100, "hundrede"), - (90, "nitten"), (80, "firs"), (70, "halvfjerds"), + (90, "halvfems"), (80, "firs"), (70, "halvfjerds"), (60, "treds"), (50, "halvtreds"), (40, "fyrre"), (30, "tredive")] self.low_numwords = ["tyve", "nitten", "atten", "sytten", "seksten", "femten", "fjorten", "tretten", - "tolv", "elleve", "ti", "ni", "\xe5tte", + "tolv", "elleve", "ti", "ni", "otte", "syv", "seks", "fem", "fire", "tre", "to", "et", "nul"] self.ords = { "en" : "f\xf8rste", @@ -55,17 +55,22 @@ class Num2Word_DK(lang_EU.Num2Word_EU): def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next + if next[1] == 100 or next[1] == 1000: + lst = list(next) + lst[0] = 'et' + lst[0] + next = tuple(lst) if cnum == 1: if nnum < 10**6 or self.ordflag: return next ctext = "en" - if nnum > cnum: if nnum >= 10**6: ctext += " " val = cnum * nnum else: + if cnum >= 100 and cnum < 10000: + ctext += "og" if nnum < 10 < cnum < 100: if nnum == 1: ntext = "en" @@ -73,7 +78,6 @@ class Num2Word_DK(lang_EU.Num2Word_EU): elif cnum >= 10**6: ctext += " " val = cnum + nnum - word = ctext + ntext return (word, val) @@ -87,13 +91,11 @@ class Num2Word_DK(lang_EU.Num2Word_EU): if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break - return outword + "te" + return outword + "ende" - - # Is this correct?? def to_ordinal_num(self, value): self.verify_ordinal(value) - return str(value) + "te" + return str(value) + "ende" def to_currency(self, val, longval=True): @@ -103,7 +105,7 @@ class Num2Word_DK(lang_EU.Num2Word_EU): def to_year(self, val, longval=True): if not (val//100)%10: return self.to_cardinal(val) - return self.to_splitnum(val, hightxt="hundrede og", longval=longval) + return self.to_splitnum(val, hightxt="hundrede", longval=longval) n2w = Num2Word_DK() to_card = n2w.to_cardinal @@ -112,6 +114,7 @@ to_ordnum = n2w.to_ordinal_num to_year = n2w.to_year def main(): + #print to_card(308) for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155, 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000, 8280, 8291, 150000, 500000, 1000000, 2000000, 2000001, From b1bbe109fc5cfac5c6c0649a6153433292bb3e6c Mon Sep 17 00:00:00 2001 From: mdc <201205975@post.au.dk> Date: Mon, 21 Mar 2016 16:11:54 +0100 Subject: [PATCH 4/4] Corrected for special cases of currency and year --- num2words/lang_DK.py | 40 ++++++++++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/num2words/lang_DK.py b/num2words/lang_DK.py index 0534e93..bc88c06 100644 --- a/num2words/lang_DK.py +++ b/num2words/lang_DK.py @@ -39,7 +39,8 @@ class Num2Word_DK(lang_EU.Num2Word_EU): "tolv", "elleve", "ti", "ni", "otte", "syv", "seks", "fem", "fire", "tre", "to", "et", "nul"] - self.ords = { "en" : "f\xf8rste", + self.ords = { "nul" : "nul", + "et" : "f\xf8rste", "to" : "anden", "tre" : "tredje", "fire" : "fjerde", @@ -51,7 +52,14 @@ class Num2Word_DK(lang_EU.Num2Word_EU): "ti" : "tiende", "elleve" : "ellevte", "tolv" : "tolvte", - "tyve" : "tyvende" } + "tretten" : "trett", + "fjorten" : "fjort", + "femten" : "femt", + "seksten" : "sekst", + "sytten" : "sytt", + "atten" : "att", + "nitten" : "nitt", + "tyve" : "tyv"} def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next @@ -69,8 +77,10 @@ class Num2Word_DK(lang_EU.Num2Word_EU): ctext += " " val = cnum * nnum else: - if cnum >= 100 and cnum < 10000: - ctext += "og" + if cnum >= 100 and cnum < 1000: + ctext += " og " + elif cnum >= 1000 and cnum <= 100000: + ctext += "e og " if nnum < 10 < cnum < 100: if nnum == 1: ntext = "en" @@ -91,18 +101,33 @@ class Num2Word_DK(lang_EU.Num2Word_EU): if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break - return outword + "ende" + if value %100 >= 30 and value %100 <= 39 or value %100 == 0: + outword += "te" + elif value % 100 > 12 or value %100 == 0: + outword += "ende" + return outword def to_ordinal_num(self, value): self.verify_ordinal(value) + vaerdte = (0,1,5,6,11,12) + if value %100 >= 30 and value %100 <= 39 or value % 100 in vaerdte: + return str(value) + "te" + elif value % 100 == 2: + return str(value) + "en" return str(value) + "ende" def to_currency(self, val, longval=True): + if val//100 == 1 or val == 1: + ret = self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re", + jointxt="og",longval=longval) + return "en " + ret[3:] return self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re", jointxt="og",longval=longval) def to_year(self, val, longval=True): + if val == 1: + return 'en' if not (val//100)%10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="hundrede", longval=longval) @@ -114,17 +139,16 @@ to_ordnum = n2w.to_ordinal_num to_year = n2w.to_year def main(): - #print to_card(308) for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155, 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000, 8280, 8291, 150000, 500000, 1000000, 2000000, 2000001, -21212121211221211111, -2.121212, -1.0000100]: n2w.test(val) n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) - for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]: + for val in [1,120, 160, 1000,1120,1800, 1976,2000,2010,2099,2171]: print val, "er", n2w.to_currency(val) print val, "er", n2w.to_year(val) - + n2w.test(65132) if __name__ == "__main__": main()