num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_SV.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+# 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, print_function, unicode_literals
+
+from . import lang_EUR
+
+
+class Num2Word_SV(lang_EUR.Num2Word_EUR):
+    GIGA_SUFFIX = "iljarder"
+    MEGA_SUFFIX = "iljoner"
+
+    def set_high_numwords(self, high):
+        cap = 3 + 6 * len(high)
+
+        for word, n in zip(high, range(cap, 3, -6)):
+            if self.GIGA_SUFFIX:
+                self.cards[10 ** n] = word + self.GIGA_SUFFIX
+
+            if self.MEGA_SUFFIX:
+                self.cards[10 ** (n - 3)] = word + self.MEGA_SUFFIX
+
+    def setup(self):
+        super(Num2Word_SV, self).setup()
+
+        self.negword = "minus "
+        self.pointword = "komma"
+        self.exclude_title = ["och", "komma", "minus"]
+
+        self.mid_numwords = [(1000, "tusen"), (100, "hundra"),
+                             (90, "nittio"), (80, "åttio"), (70, "sjuttio"),
+                             (60, "sextio"), (50, "femtio"), (40, "förtio"),
+                             (30, "trettio")]
+        self.low_numwords = ["tjugo", "nitton", "arton", "sjutton",
+                             "sexton", "femton", "fjorton", "tretton",
+                             "tolv", "elva", "tio", "nio", "åtta",
+                             "sju", "sex", "fem", "fyra", "tre", "två",
+                             "ett", "noll"]
+        self.ords = {"noll": "nollte",
+                     "ett": "första",
+                     "två": "andra",
+                     "tre": "tredje",
+                     "fyra": "fjärde",
+                     "fem": "femte",
+                     "sex": "sjätte",
+                     "sju": "sjunde",
+                     "åtta": "åttonde",
+                     "nio": "nionde",
+                     "tio": "tionde",
+                     "elva": "elfte",
+                     "tolv": "tolfte",
+                     "tjugo": "tjugonde"}
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+        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%s" % (ltext, rtext), lnum + rnum)
+        elif rnum >= 1000000 and lnum == 1:
+            return ("%s %s" % ('en', rtext[:-2]), lnum + rnum)
+        elif rnum >= 1000000 and lnum > 1:
+            return ("%s %s" % (ltext, rtext), lnum + rnum)
+        elif rnum > lnum:
+            # Special case: Swedish doesn't use "ett" before "hundra" in compounds
+            if lnum == 100 and rnum == 1000:
+                return ("hundratusen", 100000)
+            return ("%s%s" % (ltext, rtext), lnum * rnum)
+        return ("%s %s" % (ltext, rtext), lnum + rnum)
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=',',
+                    adjective=False):
+        # Handle integers specially - just add currency name without cents
+        if isinstance(val, int):
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+            except (KeyError, AttributeError):
+                # Fallback to base implementation for unknown currency
+                return super(Num2Word_SV, self).to_currency(
+                    val, currency=currency, cents=cents, separator=separator,
+                    adjective=adjective)
+
+            minus_str = self.negword if val < 0 else ""
+            abs_val = abs(val)
+            money_str = self.to_cardinal(abs_val)
+
+            # Proper pluralization for currency
+            if abs_val == 1:
+                currency_str = cr1[0] if isinstance(cr1, tuple) else cr1
+            else:
+                currency_str = cr1[1] if isinstance(cr1, tuple) and len(cr1) > 1 else (cr1[0] if isinstance(cr1, tuple) else cr1)
+
+            return (u'%s %s %s' % (minus_str, money_str, currency_str)).strip()
+
+        # For floats, use the parent class implementation
+        return super(Num2Word_SV, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outwords = self.to_cardinal(value).split(" ")
+        lastword = outwords[-1]
+        ending_length = 0
+        try:
+            lastword_ending = self.ords[lastword[-4:]]
+            ending_length = 4
+        except KeyError:
+            try:
+                lastword_ending = self.ords[lastword[-3:]]
+                ending_length = 3
+            except KeyError:
+                lastword_ending = "de"
+        if lastword_ending == 'de':
+            lastword_first_part = self.title(lastword)[:]
+        else:
+            lastword_first_part = self.title(lastword)[:-ending_length]
+        lastword_correct = lastword_first_part + lastword_ending
+        outwords[-1] = lastword_correct
+        return " ".join(outwords)
+
+    def to_ordinal_num(self, value):
+        """Convert to abbreviated ordinal form in Swedish"""
+        # Swedish uses :e, :a, :de, :te etc. for ordinals
+        if value == 1 or value == 2:
+            return str(value) + ':a'
+        elif str(value).endswith(('1', '2')) and value not in (11, 12):
+            return str(value) + ':a'
+        elif str(value).endswith(('3', '4', '5', '6', '7', '8', '9', '0')):
+            return str(value) + ':e'
+        else:
+            return str(value) + ':e'
+
+    def to_year(self, val, longval=True):
+        """Convert number to year representation in Swedish"""
+        if val < 0:
+            # BC years
+            return self.to_cardinal(-val) + " f.Kr."
+        elif val < 1000:
+            # Years before 1000
+            return self.to_cardinal(val)
+        elif val < 2000:
+            # Years 1000-1999: typically "nittonhundra" style
+            century = val // 100
+            remainder = val % 100
+            if remainder == 0:
+                return self.to_cardinal(century) + "hundra"
+            else:
+                return self.to_cardinal(century) + "hundra" + self.to_cardinal(remainder)
+        else:
+            # Years 2000+: typically "tvåtusen" style
+            return self.to_cardinal(val)

num2words2/lang_SW.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+# 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 unicode_literals
+
+from .base import Num2Word_Base
+
+
+class Num2Word_SW(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'TZS': (('shilingi', 'shilingi'), ('senti', 'senti')),  # Tanzanian Shilling
+        'KES': (('shilingi', 'shilingi'), ('senti', 'senti')),  # Kenyan Shilling
+        'UGX': (('shilingi', 'shilingi'), ('senti', 'senti')),  # Ugandan Shilling
+
+        'USD': (('dola', 'dola'), ('senti', 'senti')),          # US Dollar
+        'EUR': (('yuro', 'yuro'), ('senti', 'senti')),          # Euro
+        'GBP': (('pauni', 'pauni'), ('peni', 'peni')),          # British Pound
+    }
+
+    def setup(self):
+        self.negword = "hasi "
+        self.pointword = "nukta"
+
+        # High-level numwords for large numbers
+        self.high_numwords = ["trilioni"]
+
+        self.mid_numwords = [
+            (1000000000, "bilioni"),
+            (1000000, "milioni"),
+            (100000, "laki"),
+            (1000, "elfu"),
+            (100, "mia"),
+            (90, "tisini"),
+            (80, "themanini"),
+            (70, "sabini"),
+            (60, "sitini"),
+            (50, "hamsini"),
+            (40, "arobaini"),
+            (30, "thelathini"),
+            (20, "ishirini")
+        ]
+
+        self.low_numwords = [
+            "kumi na tisa",  # 19
+            "kumi na nane",  # 18
+            "kumi na saba",  # 17
+            "kumi na sita",  # 16
+            "kumi na tano",  # 15
+            "kumi na nne",   # 14
+            "kumi na tatu",  # 13
+            "kumi na mbili",  # 12
+            "kumi na moja",  # 11
+            "kumi",          # 10
+            "tisa",          # 9
+            "nane",          # 8
+            "saba",          # 7
+            "sita",          # 6
+            "tano",          # 5
+            "nne",           # 4
+            "tatu",          # 3
+            "mbili",         # 2
+            "moja",          # 1
+            "sifuri"         # 0
+        ]
+
+        # Ordinal mappings
+        self.ordinal_words = {
+            "moja": "kwanza",
+            "mbili": "pili",
+            "tatu": "tatu",
+            "nne": "nne",
+            "tano": "tano",
+            "sita": "sita",
+            "saba": "saba",
+            "nane": "nane",
+            "tisa": "tisa",
+            "kumi": "kumi",
+        }
+
+    def set_high_numwords(self, high):
+        """Set high numwords for large numbers."""
+        cap = 9 + 9 * len(high)
+        for word, n in zip(high, range(cap, 8, -9)):
+            self.cards[10 ** n] = word
+
+    def merge(self, lpair, rpair):
+        """Merge two number parts using Swahili grammar rules."""
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+
+        if lnum == 1 and rnum < 100:
+            return (rtext, rnum)
+        elif 100 > lnum > rnum:
+            return ("%s na %s" % (ltext, rtext), lnum + rnum)
+        elif lnum >= 100 > rnum:
+            return ("%s na %s" % (ltext, rtext), lnum + rnum)
+        elif rnum >= 1000000:
+            # For millions/billions: "milioni moja", "bilioni mbili", etc.
+            return ("%s %s" % (rtext, ltext), lnum * rnum)
+        elif rnum >= 1000:
+            # For thousands: "elfu moja", "elfu mbili", etc.
+            if lnum < 1000:
+                return ("%s %s" % (rtext, ltext), lnum * rnum)
+            else:
+                # When combining with other thousands, use "na"
+                return ("%s na %s" % (ltext, rtext), lnum + rnum)
+        elif rnum >= 100:
+            # For hundreds: "mia moja", "mia mbili", etc.
+            if lnum < 100:
+                return ("%s %s" % (rtext, ltext), lnum * rnum)
+            else:
+                # When combining with other hundreds or larger, use "na"
+                return ("%s na %s" % (ltext, rtext), lnum + rnum)
+        elif rnum > lnum:
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%s na %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal(self, value):
+        """Convert number to ordinal form."""
+        self.verify_ordinal(value)
+        cardinal_text = self.to_cardinal(value)
+
+        # Check if we have a special ordinal form
+        if cardinal_text in self.ordinal_words:
+            return f"wa {self.ordinal_words[cardinal_text]}"
+
+        # For ordinals, prefix with "wa" (of/the)
+        return f"wa {cardinal_text}"
+
+    def to_ordinal_num(self, value):
+        """Convert number to ordinal number format."""
+        self.verify_ordinal(value)
+        return f"{value}."
+
+    def to_year(self, value, **kwargs):
+        """Convert number to year format."""
+        return self.to_cardinal(value)
+
+    def pluralize(self, number, forms):
+        """Handle pluralization - Swahili doesn't change form much."""
+        # Swahili typically doesn't change the noun form for plurals
+        # So we return the singular form for both cases
+        return forms[0] if len(forms) > 0 else forms
+
+    def _money_verbose(self, number, currency):
+        """Convert money amount to verbose format."""
+        return self.to_cardinal(number)
+
+    def _cents_verbose(self, number, currency):
+        """Convert cents amount to verbose format."""
+        return self.to_cardinal(number)
+
+    def to_currency(self, val, currency='TZS', cents=True, separator=' na',
+                    adjective=False):
+        """
+        Convert number to currency format in Swahili.
+        """
+        # Import the parse function from the base currency module
+        # Check if value has fractional cents
+        from decimal import Decimal
+
+        from .currency import parse_currency_parts
+        decimal_val = Decimal(str(val))
+        has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+        # For Swahili, treat integers as whole currency units, not cents
+        left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False,
+                                                        keep_precision=has_fractional_cents)
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+        except KeyError:
+            raise NotImplementedError(
+                'Currency code "%s" not implemented for "%s"' %
+                (currency, self.__class__.__name__))
+
+        minus_str = "%s " % self.negword.strip() if is_negative else ""
+        money_str = self.to_cardinal(left)
+
+        # Check if input is explicitly a decimal number or has non-zero cents
+        has_decimal = isinstance(val, float) or str(val).find('.') != -1
+
+        # Only include cents if there are actual cents or explicitly decimal
+        if has_decimal or right > 0:
+            # Handle fractional cents
+            from decimal import Decimal
+            if isinstance(right, Decimal):
+                # Convert fractional cents (e.g., 65.3 cents)
+                cents_str = self.to_cardinal_float(float(right)) if cents else str(float(right))
+            else:
+                cents_str = self.to_cardinal(right) if cents else "%02d" % right
+            return u'%s%s %s%s %s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1),
+                separator,
+                cents_str,
+                self.pluralize(right, cr2)
+            )
+        else:
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1)
+            )

num2words2/lang_TA.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+# 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 unicode_literals
+
+from .base import Num2Word_Base
+from .currency import parse_currency_parts
+
+
+class Num2Word_TA(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'INR': (
+            ('ரூபாய்', 'ரூபாய்'), ('பைசா', 'பைசா')
+        ),
+        'LKR': (
+            ('ரூபாய்', 'ரூபாய்'), ('சதம்', 'சதம்')
+        ),
+        'USD': (
+            ('டாலர்', 'டாலர்'), ('சென்ட்', 'சென்ட்')
+        ),
+        'EUR': (
+            ('யூரோ', 'யூரோ'), ('சென்ட்', 'சென்ட்')
+        ),
+        'GBP': (
+            ('பவுண்ட்', 'பவுண்ட்'), ('பென்னி', 'பென்னி')
+        ),
+        'SGD': (
+            ('டாலர்', 'டாலர்'), ('சென்ட்', 'சென்ட்')
+        ),
+        'MYR': (
+            ('ரிங்கிட்', 'ரிங்கிட்'), ('சென்', 'சென்')
+        ),
+    }
+
+    def __init__(self):
+        super(Num2Word_TA, self).__init__()
+
+        self.ones = [
+            '',
+            'ஒன்று',
+            'இரண்டு',
+            'மூன்று',
+            'நான்கு',
+            'ஐந்து',
+            'ஆறு',
+            'ஏழு',
+            'எட்டு',
+            'ஒன்பது'
+        ]
+
+        self.tens = [
+            '',
+            'பத்து',
+            'இருபது',
+            'முப்பது',
+            'நாற்பது',
+            'ஐம்பது',
+            'அறுபது',
+            'எழுபது',
+            'எண்பது',
+            'தொண்ணூறு'
+        ]
+
+        self.teens = {
+            11: 'பதினொன்று',
+            12: 'பன்னிரண்டு',
+            13: 'பதின்மூன்று',
+            14: 'பதினான்கு',
+            15: 'பதினைந்து',
+            16: 'பதினாறு',
+            17: 'பதினேழு',
+            18: 'பதினெட்டு',
+            19: 'பத்தொன்பது'
+        }
+
+        self.hundreds_special = {
+            100: 'நூறு',
+            200: 'இருநூறு',
+            300: 'முன்னூறு',
+            400: 'நானூறு',
+            500: 'ஐநூறு',
+            600: 'அறுநூறு',
+            700: 'எழுநூறு',
+            800: 'எண்ணூறு',
+            900: 'தொள்ளாயிரம்'
+        }
+
+        self.scale = {
+            1000: 'ஆயிரம்',
+            100000: 'இலட்சம்',
+            10000000: 'கோடி',
+            1000000000000: 'டிரில்லியன்'
+        }
+
+        self.ordinals = {
+            1: 'முதல்',
+            2: 'இரண்டாம்',
+            3: 'மூன்றாம்',
+            4: 'நான்காம்',
+            5: 'ஐந்தாம்',
+            6: 'ஆறாம்',
+            7: 'ஏழாம்',
+            8: 'எட்டாம்',
+            9: 'ஒன்பதாம்',
+            10: 'பத்தாம்'
+        }
+
+        self.negword = "கழித்தல் "
+        self.pointword = "புள்ளி"
+
+    def _setup(self):
+        super(Num2Word_TA, self)._setup()
+
+    def _int_to_word(self, n):
+        """
+        Converts a number to words in Tamil.
+        Uses Indian numbering system (lakh/crore).
+        """
+        if n == 0:
+            return 'பூஜ்ஜியம்'
+
+        parts = []
+
+        # Handle crores (1 crore = 10,000,000)
+        if n >= 10000000:
+            crores = n // 10000000
+            if crores == 1:
+                parts.append('ஒரு கோடி')
+            else:
+                parts.append(self._int_to_word(crores) + ' கோடி')
+            n %= 10000000
+
+        # Handle lakhs (1 lakh = 100,000)
+        if n >= 100000:
+            lakhs = n // 100000
+            if lakhs == 1:
+                parts.append('ஒரு இலட்சம்')
+            else:
+                parts.append(self._int_to_word(lakhs) + ' இலட்சம்')
+            n %= 100000
+
+        # Handle thousands
+        if n >= 1000:
+            thousands = n // 1000
+            if thousands == 1:
+                parts.append('ஆயிரம்')
+            else:
+                parts.append(self._int_to_word(thousands) + ' ஆயிரம்')
+            n %= 1000
+
+        # Handle hundreds with special forms
+        if n >= 100:
+            hundreds_val = (n // 100) * 100
+            if hundreds_val in self.hundreds_special:
+                parts.append(self.hundreds_special[hundreds_val])
+            else:
+                parts.append(self.ones[n // 100] + ' நூறு')
+            n %= 100
+
+        # Handle special case for teens (11-19)
+        if 10 < n < 20:
+            parts.append(self.teens[n])
+        else:
+            # Handle tens
+            if n >= 10:
+                tens_val = n // 10
+                parts.append(self.tens[tens_val])
+                n %= 10
+
+            # Handle ones
+            if n > 0:
+                parts.append(self.ones[n])
+
+        return ' '.join(parts)
+
+    def _int_to_cardinal(self, n):
+        if n == 0:
+            return 'பூஜ்ஜியம்'
+
+        if n < 0:
+            return self.negword + self._int_to_word(-n)
+
+        return self._int_to_word(n)
+
+    def _int_to_ordinal(self, n):
+        """Convert to ordinal number."""
+        if n == 0:
+            return 'பூஜ்ஜியம்'
+
+        # Special cases for first ten ordinals
+        if n in self.ordinals:
+            return self.ordinals[n]
+
+        # For other numbers, add "-ஆவது" suffix
+        return self._int_to_cardinal(n) + 'ஆவது'
+
+    def to_cardinal(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            return self._int_to_cardinal(n)
+        except BaseException:
+            return self._int_to_cardinal(int(n))
+
+    def to_ordinal(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            return self._int_to_ordinal(n)
+        except BaseException:
+            return self._int_to_ordinal(int(n))
+
+    def to_ordinal_num(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            # In Tamil, ordinal numbers use "-ஆவது" suffix
+            # But for numeric form, use -வது
+            return str(n) + '-வது'
+        except BaseException:
+            return str(n) + '-வது'
+
+    def to_currency(self, n, currency='INR'):
+        try:
+            # Check if value has fractional cents
+            from decimal import Decimal
+            decimal_val = Decimal(str(n))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+            left, right, is_negative = parse_currency_parts(n, is_int_with_cents=False,
+                                                            keep_precision=has_fractional_cents)
+
+            if currency not in self.CURRENCY_FORMS:
+                raise NotImplementedError(
+                    'Currency code "%s" not implemented for "%s"' %
+                    (currency, self.__class__.__name__))
+
+            cr_major, cr_minor = self.CURRENCY_FORMS[currency]
+
+            result = []
+
+            if is_negative:
+                result.append(self.negword.strip())
+
+            left_words = self._int_to_cardinal(left)
+            result.append(left_words)
+            result.append(cr_major[0])
+
+            # Handle paise/cents if non-zero
+            if right > 0:
+                # Handle fractional paise
+                from decimal import Decimal
+                if isinstance(right, Decimal):
+                    # Convert fractional paise (e.g., 65.3 paise)
+                    right_words = self.to_cardinal(float(right))
+                else:
+                    right_words = self._int_to_cardinal(right)
+                result.append(right_words)
+                result.append(cr_minor[0])
+
+            return ' '.join(result)
+        except NotImplementedError:
+            raise
+        except BaseException:
+            return str(n) + ' ' + currency
+
+    def to_year(self, n):
+        """Convert to year representation."""
+        if n < 1000:
+            return self._int_to_cardinal(n)
+        elif n < 2000:
+            # Years like 1999 -> "ஆயிரத்து தொள்ளாயிரத்து தொண்ணூற்று ஒன்பது"
+            thousands = n // 1000
+            remainder = n % 1000
+            result = 'ஆயிரத்து'
+            if remainder > 0:
+                result += ' ' + self._int_to_cardinal(remainder)
+            return result
+        else:
+            # Years like 2023 -> "இரண்டாயிரத்து இருபத்து மூன்று"
+            thousands = n // 1000
+            remainder = n % 1000
+            result = self._int_to_cardinal(thousands) + ' ஆயிரத்து'
+            if remainder > 0:
+                result += ' ' + self._int_to_cardinal(remainder)
+            return result