num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_FI.py

@@ -0,0 +1,759 @@
+# -*- 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 collections import OrderedDict
+
+from . import lang_EUR
+
+GENERIC_CENTS = ('sentti', 'senttiä')
+GENERIC_CENTAVOS = ('centavo', 'centavoa')
+
+# grammatical cases
+NOM = 10  # nominative: the dictionary form
+GEN = 11  # genitive: ~of/'s
+ACC = 12  # accusative: not used; either nominative or genitive
+PTV = 13  # partitive: as an object
+# locative cases (internal)
+INE = 14  # inessive: in
+ELA = 15  # elative: from/out of
+ILL = 16  # illative: into
+# locative cases (external)
+ADE = 17  # adessive: at/on
+ABL = 18  # ablative: from (after being at/on, not in)
+ALL = 19  # allative: to
+# essive
+ESS = 20     # essive: as (in the role of)
+TRANSL = 21  # translative: to (the role of; being sth)
+# rare
+INSTRUC = 22  # instructive: with (plural is the same as singular)
+ABE = 23      # abessive: without
+COM = 24      # comitative: together with (plural = singular)
+
+NAME_TO_CASE = {
+    'nominative': NOM,
+    'genitive': GEN,
+    'accusative': ACC,
+    'partitive': PTV,
+    'inessive': INE,
+    'elative': ELA,
+    'illative': ILL,
+    'adessive': ADE,
+    'ablative': ABL,
+    'allative': ALL,
+    'essive': ESS,
+    'translative': TRANSL,
+    'instructive': INSTRUC,
+    'abessive': ABE,
+    'comitative': COM,
+}
+
+# https://en.wikibooks.org/wiki/Finnish/Grammar-Vowel_harmony
+BACK_TO_FRONT = {
+    'a': 'ä',
+    'o': 'ö',
+    'u': 'y',
+}
+
+# https://en.wiktionary.org/wiki/Appendix:Finnish_nominal_inflection
+# CASE: (SINGULAR_SUFFIX+, PLURAL_SUFFIX+)
+KOTUS_TYPE = {
+
+    # Kotus type 5/risti, no gradation
+    5: {
+        # grammatical
+        NOM: ('i', 'it'),
+        GEN: ('in', 'ien'),
+        PTV: ('ia', 'eja'),
+        # locative, internal
+        INE: ('issa', 'eissa'),
+        ELA: ('ista', 'eista'),
+        ILL: ('iin', 'eihin'),
+        # locative, external
+        ADE: ('illa', 'eilla'),
+        ABL: ('ilta', 'eilta'),
+        ALL: ('ille', 'eille'),
+        # essive
+        ESS: ('ina', 'eina'),
+        TRANSL: ('iksi', 'eiksi'),
+        # rare
+        INSTRUC: ('ein', 'ein'),
+        ABE: ('itta', 'eitta'),
+        COM: ('eine', 'eine'),  # works better
+    },
+
+    # Kotus type 7/ovi, no gradation
+    7: {
+        # grammatical
+        NOM: ('i', 'et'),
+        GEN: ('en', 'ien'),
+        PTV: ('ea', 'ia'),
+        # locative, internal
+        INE: ('essa', 'issa'),
+        ELA: ('esta', 'ista'),
+        ILL: ('een', 'iin'),
+        # locative, external
+        ADE: ('ella', 'illa'),
+        ABL: ('elta', 'ilta'),
+        ALL: ('elle', 'ille'),
+        # essive
+        ESS: ('ena', 'ina'),
+        TRANSL: ('eksi', 'iksi'),
+        # rare
+        INSTRUC: ('in', 'in'),
+        ABE: ('etta', 'itta'),
+        COM: ('ine', 'ine'),  # works better
+    },
+
+    # Kotus type 8/nalle, no gradation
+    8: {
+        # grammatical
+        NOM: ('e', 'et'),
+        GEN: ('en', ('ejen', 'ein')),
+        PTV: ('ea', 'eja'),
+        # locative, internal
+        INE: ('essa', 'eissa'),
+        ELA: ('esta', 'eista'),
+        ILL: ('een', 'eihin'),
+        # locative, external
+        ADE: ('ella', 'eilla'),
+        ABL: ('elta', 'eilta'),
+        ALL: ('elle', 'eille'),
+        # essive
+        ESS: ('ena', 'eina'),
+        TRANSL: ('eksi', 'eiksi'),
+        # rare
+        INSTRUC: ('ein', 'ein'),
+        ABE: ('etta', 'eitta'),
+        COM: ('eine', 'eine'),  # works better
+    },
+
+    # Kotus type 9/kala, t-d gradation (sata)
+    109: {
+        # grammatical
+        NOM: ('ta', 'dat'),
+        GEN: ('dan', ('tojen', 'tain')),
+        PTV: ('taa', 'toja'),
+        # locative, internal
+        INE: ('dassa', 'doissa'),
+        ELA: ('dasta', 'doista'),
+        ILL: ('taan', 'toihin'),
+        # locative, external
+        ADE: ('dalla', 'doilla'),
+        ABL: ('dalta', 'doilta'),
+        ALL: ('dalle', 'doille'),
+        # essive
+        ESS: ('tana', 'toina'),
+        TRANSL: ('daksi', 'doiksi'),
+        # rare
+        INSTRUC: ('doin', 'doin'),
+        ABE: ('datta', 'doitta'),
+        COM: ('toine', 'toine'),  # works better
+    },
+
+    # Kotus type 10/koira, no gradation
+    10: {
+        # grammatical
+        NOM: ('a', 'at'),
+        GEN: ('an', ('ien', 'ain')),
+        PTV: ('aa', 'ia'),
+        # locative, internal
+        INE: ('assa', 'issa'),
+        ELA: ('asta', 'ista'),
+        ILL: ('aan', 'iin'),
+        # locative, external
+        ADE: ('alla', 'illa'),
+        ABL: ('alta', 'ilta'),
+        ALL: ('alle', 'ille'),
+        # essive
+        ESS: ('ana', 'ina'),
+        TRANSL: ('aksi', 'iksi'),
+        # rare
+        INSTRUC: ('in', 'in'),
+        ABE: ('atta', 'itta'),
+        COM: ('ine', 'ine'),  # works better
+    },
+
+    # Kotus type 27/käsi, t-d gradation
+    27: {
+        # grammatical
+        NOM: ('si', 'det'),
+        GEN: ('den', ('sien', 'tten')),
+        PTV: ('tta', 'sia'),
+        # locative, internal
+        INE: ('dessa', 'sissa'),
+        ELA: ('desta', 'sista'),
+        ILL: ('teen', 'siin'),
+        # locative, external
+        ADE: ('della', 'silla'),
+        ABL: ('delta', 'silta'),
+        ALL: ('delle', 'sille'),
+        # essive
+        ESS: ('tena', 'sina'),
+        TRANSL: ('deksi', 'siksi'),
+        # rare
+        INSTRUC: ('sin', 'sin'),
+        ABE: ('detta', 'sitta'),
+        COM: ('sine', 'sine'),  # works better
+    },
+
+    # Kotus type 31/kaksi, t-d gradation
+    31: {
+        # grammatical
+        NOM: ('ksi', 'hdet'),
+        GEN: ('hden', 'ksien'),
+        PTV: ('hta', 'ksia'),
+        # locative, internal
+        INE: ('hdessa', 'ksissa'),
+        ELA: ('hdesta', 'ksista'),
+        ILL: ('hteen', 'ksiin'),
+        # locative, external
+        ADE: ('hdella', 'ksilla'),
+        ABL: ('hdelta', 'ksilta'),
+        ALL: ('hdelle', 'ksille'),
+        # essive
+        ESS: ('htena', 'ksina'),
+        TRANSL: ('hdeksi', 'ksiksi'),
+        # rare
+        INSTRUC: ('ksin', 'ksin'),
+        ABE: ('hdetta', 'ksitta'),
+        COM: ('ksine', 'ksine'),  # works better
+    },
+
+    # Kotus type 32/sisar, no gradation
+    32: {
+        # grammatical
+        NOM: ('', 'et'),
+        GEN: ('en', ('ien', 'ten')),
+        PTV: ('ta', 'ia'),
+        # locative, internal
+        INE: ('essa', 'issa'),
+        ELA: ('esta', 'ista'),
+        ILL: ('een', 'iin'),
+        # locative, external
+        ADE: ('ella', 'illa'),
+        ABL: ('elta', 'ilta'),
+        ALL: ('elle', 'ille'),
+        # essive
+        ESS: ('ena', 'ina'),
+        TRANSL: ('eksi', 'iksi'),
+        # rare
+        INSTRUC: ('in', 'in'),
+        ABE: ('etta', 'itta'),
+        COM: ('ine', 'ine'),  # works better
+    },
+
+    # Kotus type 38/nainen, no gradation
+    38: {
+        # grammatical
+        NOM: ('nen', 'set'),
+        GEN: ('sen', ('sten', 'sien')),
+        PTV: ('sta', 'sia'),
+        # locative, internal
+        INE: ('sessa', 'sissa'),
+        ELA: ('sesta', 'sista'),
+        ILL: ('seen', 'siin'),
+        # locative, external
+        ADE: ('sella', 'silla'),
+        ABL: ('selta', 'silta'),
+        ALL: ('selle', 'sille'),
+        # essive
+        ESS: ('sena', 'sina'),
+        TRANSL: ('seksi', 'siksi'),
+        # rare
+        INSTRUC: ('sin', 'sin'),
+        ABE: ('setta', 'sitta'),
+        COM: ('sine', 'sine'),  # works better
+    },
+
+    # Kotus type 45/kahdeksas, nt-nn gradation
+    45: {
+        # grammatical
+        NOM: ('s', 'nnet'),
+        GEN: ('nnen', 'nsien'),
+        PTV: ('tta', 'nsia'),
+        # locative, internal
+        INE: ('nnessa', 'nsissa'),
+        ELA: ('nnesta', 'nsista'),
+        ILL: ('nteen', 'nsiin'),
+        # locative, external
+        ADE: ('nnella', 'nsilla'),
+        ABL: ('nnelta', 'nsilta'),
+        ALL: ('nnelle', 'nsille'),
+        # essive
+        ESS: ('ntena', 'nsina'),
+        TRANSL: ('nneksi', 'nsiksi'),
+        # rare
+        INSTRUC: ('nsin', 'nsin'),
+        ABE: ('nnetta', 'nsitta'),
+        COM: ('nsine', 'nsine'),  # works better
+    },
+
+    # Kotus type 46/tuhat, nt-nn gradation
+    46: {
+        # grammatical
+        NOM: ('t', 'nnet'),
+        GEN: ('nnen', ('nsien', 'nten')),
+        PTV: ('tta', 'nsia'),
+        # locative, internal
+        INE: ('nnessa', 'nsissa'),
+        ELA: ('nnesta', 'nsista'),
+        ILL: ('nteen', 'nsiin'),
+        # locative, external
+        ADE: ('nnella', 'nsilla'),
+        ABL: ('nnelta', 'nsilta'),
+        ALL: ('nnelle', 'nsille'),
+        # essive
+        ESS: ('ntena', 'nsina'),
+        TRANSL: ('nneksi', 'nsiksi'),
+        # rare
+        INSTRUC: ('nsin', 'nsin'),
+        ABE: ('nnetta', 'nsitta'),
+        COM: ('nsine', 'nsine'),  # works better
+    },
+}
+
+# kolme
+KOTUS_TYPE[108] = {
+    c: (KOTUS_TYPE[8][c][0], KOTUS_TYPE[7][c][1])
+    for c in KOTUS_TYPE[8]
+}
+KOTUS_TYPE[108][INSTRUC] = ('en', 'in')
+KOTUS_TYPE[108][ABE] = ('etta', 'itta')
+KOTUS_TYPE[108][COM] = ('ine', 'ine')
+
+# seitsemän, kahdeksan, yhdeksän
+KOTUS_TYPE[110] = KOTUS_TYPE[10].copy()
+KOTUS_TYPE[110][NOM] = ('an', 'at')
+
+# kymmenen
+KOTUS_TYPE[132] = KOTUS_TYPE[32].copy()
+KOTUS_TYPE[132][NOM] = ('en', 'et')
+
+
+def inflect(parts, options):
+    if not isinstance(parts, list):
+        parts = [parts]
+
+    out = ''
+    for part in parts:
+        # part is plain text, concat and continue
+        if not isinstance(part, tuple):
+            out += part
+            continue
+        # predefined case (kaksikymmentä, ...)
+        tmp_case = options.case
+        if len(part) == 3:
+            # override singular nominative only
+            if options.case == NOM and not options.plural:
+                tmp_case = part[2]
+            part = part[:2]
+        # stem and suffix
+        stem, kotus_type = part
+        suffix = KOTUS_TYPE[kotus_type][tmp_case][options.plural]
+        # many choices, choose preferred or first
+        if isinstance(suffix, tuple):
+            common = set(suffix) & set(options.prefer or set())
+            if len(common) == 1:
+                suffix = common.pop()
+            else:
+                suffix = suffix[0]
+        # apply vowel harmony
+        if not set(BACK_TO_FRONT) & set(stem):
+            for back, front in BACK_TO_FRONT.items():
+                suffix = suffix.replace(back, front)
+        # concat
+        out += stem + suffix
+
+    return out
+
+
+class Options(object):
+    def __init__(self, ordinal, case, plural, prefer):
+        self.ordinal = ordinal
+        self.case = case
+        self.plural = plural
+        self.prefer = prefer
+
+    def variation(self, ordinal=None, case=None, plural=None, prefer=None):
+        return Options(
+            ordinal if ordinal is not None else self.ordinal,
+            case if case is not None else self.case,
+            plural if plural is not None else self.plural,
+            prefer if prefer is not None else self.prefer,
+        )
+
+
+class Num2Word_FI(lang_EUR.Num2Word_EUR):
+    CURRENCY_FORMS = {
+        'BRL': (('real', 'realia'), GENERIC_CENTAVOS),
+        'CHF': (('frangi', 'frangia'), ('rappen', 'rappenia')),
+        'CNY': (('juan', 'juania'), ('fen', 'feniä')),
+        'EUR': (('euro', 'euroa'), GENERIC_CENTS),
+        'FIM': (('markka', 'markkaa'), ('penni', 'penniä')),  # historical
+        'INR': (('rupia', 'rupiaa'), ('paisa', 'paisaa')),
+        'JPY': (('jeni', 'jeniä'), ('sen', 'seniä')),  # rare subunit
+        'KRW': (('won', 'wonia'), ('jeon', 'jeonia')),  # rare subunit
+        'KPW': (('won', 'wonia'), ('chon', 'chonia')),  # rare subunit
+        'MXN': (('peso', 'pesoa'), GENERIC_CENTAVOS),
+        'RUB': (('rupla', 'ruplaa'), ('kopeekka', 'kopeekkaa')),
+        'TRY': (('liira', 'liiraa'), ('kuruş', 'kuruşia')),
+        'ZAR': (('randi', 'randia'), GENERIC_CENTS),
+    }
+
+    # crowns
+    for curr_code in 'DKK', 'ISK', 'NOK', 'SEK':
+        CURRENCY_FORMS[curr_code] = (('kruunu', 'kruunua'), ('äyri', 'äyriä'))
+
+    # dollars
+    for curr_code in 'AUD', 'CAD', 'HKD', 'NZD', 'SGD', 'USD':
+        CURRENCY_FORMS[curr_code] = (
+            ('dollari', 'dollaria'), GENERIC_CENTS)
+
+    # pounds
+    for curr_code in ('GBP',):
+        CURRENCY_FORMS[curr_code] = (('punta', 'puntaa'), ('penny', 'pennyä'))
+
+    CURRENCY_ADJECTIVES = {
+        'AUD': 'Australian',
+        'BRL': 'Brasilian',
+        'CAD': 'Kanadan',
+        'CHF': 'Sveitsin',
+        'DKK': 'Tanskan',
+        'FIM': 'Suomen',  # historical
+        'GBP': 'Englannin',
+        'HKD': 'Hongkongin',
+        'INR': 'Intian',
+        'ISK': 'Islannin',
+        'KRW': 'Etelä-Korean',
+        'KPW': 'Pohjois-Korean',
+        'MXN': 'Meksikon',
+        'NOK': 'Norjan',
+        'NZD': 'Uuden-Seelannin',
+        'RUB': 'Venäjän',
+        'SEK': 'Ruotsin',
+        'SGD': 'Singaporen',
+        'TRY': 'Turkin',
+        'USD': 'Yhdysvaltain',
+        'ZAR': 'Etelä-Afrikan',
+    }
+
+    def __init__(self):
+        self.ords = OrderedDict()
+        super(Num2Word_FI, self).__init__()
+
+    def set_numwords(self):
+        self.set_high_numwords(self.high_numwords)
+        self.set_mid_numwords(self.mid_numwords, self.mid_ords)
+        self.set_low_numwords(self.low_numwords, self.low_ords)
+
+    def set_high_numwords(self, high):
+        # references:
+        # https://fi.wikipedia.org/wiki/Suurten_lukujen_nimet
+        # https://en.wikipedia.org/wiki/Names_of_large_numbers#Standard_dictionary_numbers
+
+        # translate to Finnish
+        replacements = [
+            ("qu", "kv"),
+            ("x", "ks"),
+            ("c", "k"),
+            ("kent", "sent"),  # applied after c -> k to cent
+        ]
+        translated = []
+        for i, numword in enumerate(high):
+            # notes:
+            # - 1e6**9 can be either noviljoona or noniljoona
+            # - 1e6**38 and above are untested
+
+            # 1e6**6 is sekstiljoona but 1e6**16 is sedekiljoona
+            if numword.startswith("sex") and numword != "sext":
+                numword = numword.replace("sex", "se")
+            # 1e6**7 is septiljoona but 1e6**17 is septendekiljoona
+            elif numword.startswith("sept") and numword != "sept":
+                numword = "septen" + numword[len("sept"):]
+            # 1e6**8 is oktiljoona but 1e6**18 is duodevigintiljoona
+            # (2 from 20)
+            elif numword.startswith("octo"):
+                numword = high[i + -10]
+                numword = "duode" + numword[len("octo"):]
+            # 1e6**9 is noniljoona but 1e6**19 is undevigintiljoona (1 from 20)
+            elif numword.startswith("nove"):
+                numword = high[i + -10]
+                numword = "unde" + numword[len("nove") + 1:]
+
+            # apply general replacements to all numwords
+            for repl in replacements:
+                numword = numword.replace(repl[0], repl[1])
+            translated.append(numword)
+
+        max = 6 * len(translated)
+        for word, n in zip(translated, range(max, 0, -6)):
+            if n == 6:
+                # irregularity considering short scale and long scale
+                self.cards[10 ** 9] = ("miljard", 5)
+                self.ords[10 ** 9] = ("miljardi", 45)
+            self.cards[10 ** n] = (word + "iljoon", 10)
+            self.ords[10 ** n] = (word + "iljoona", 45)
+
+    def set_mid_numwords(self, cards, ords):
+        for key, val in cards:
+            self.cards[key] = val
+        for key, val in ords:
+            self.ords[key] = val
+
+    def set_low_numwords(self, cards, ords):
+        for key, val in cards:
+            self.cards[key] = val
+        for key, val in ords:
+            self.ords[key] = val
+
+    def setup(self):
+        super(Num2Word_FI, self).setup()
+
+        self.negword = "miinus "
+        self.pointword = "pilkku"
+        self.exclude_title = ["pilkku", "miinus"]
+
+        self.mid_numwords = [
+            (1000, ("tuha", 46)),
+            (100, ("sa", 109)),
+            (90, [("yhdeks", 110), ("kymmen", 132, PTV)]),
+            (80, [("kahdeks", 110), ("kymmen", 132, PTV)]),
+            (70, [("seitsem", 110), ("kymmen", 132, PTV)]),
+            (60, [("kuu", 27), ("kymmen", 132, PTV)]),
+            (50, [("vii", 27), ("kymmen", 132, PTV)]),
+            (40, [("nelj", 10), ("kymmen", 132, PTV)]),
+            (30, [("kolm", 108), ("kymmen", 132, PTV)]),
+        ]
+
+        self.mid_ords = [
+            (1000, ("tuhanne", 45)),
+            (100, ("sada", 45)),
+            (90, [("yhdeksä", 45), ("kymmene", 45)]),
+            (80, [("kahdeksa", 45), ("kymmene", 45)]),
+            (70, [("seitsemä", 45), ("kymmene", 45)]),
+            (60, [("kuude", 45), ("kymmene", 45)]),
+            (50, [("viide", 45), ("kymmene", 45)]),
+            (40, [("neljä", 45), ("kymmene", 45)]),
+            (30, [("kolma", 45), ("kymmene", 45)]),
+        ]
+
+        self.low_numwords = [
+            (20, [("ka", 31), ("kymmen", 132, PTV)]),
+            (19, [("yhdeks", 110), "toista"]),
+            (18, [("kahdeks", 110), "toista"]),
+            (17, [("seitsem", 110), "toista"]),
+            (16, [("kuu", 27), "toista"]),
+            (15, [("vii", 27), "toista"]),
+            (14, [("nelj", 10), "toista"]),
+            (13, [("kolm", 108), "toista"]),
+            (12, [("ka", 31), "toista"]),
+            (11, [("y", 31), "toista"]),
+            (10, ("kymmen", 132)),
+            (9, ("yhdeks", 110)),
+            (8, ("kahdeks", 110)),
+            (7, ("seitsem", 110)),
+            (6, ("kuu", 27)),
+            (5, ("vii", 27)),
+            (4, ("nelj", 10)),
+            (3, ("kolm", 108)),
+            (2, ("ka", 31)),
+            (1, ("y", 31)),
+            (0, ("noll", 10)),
+        ]
+
+        self.low_ords = [
+            (20, [("kahde", 45), ("kymmene", 45)]),
+            (19, [("yhdeksä", 45), "toista"]),
+            (18, [("kahdeksa", 45), "toista"]),
+            (17, [("seitsemä", 45), "toista"]),
+            (16, [("kuude", 45), "toista"]),
+            (15, [("viide", 45), "toista"]),
+            (14, [("neljä", 45), "toista"]),
+            (13, [("kolma", 45), "toista"]),
+            (12, [("kahde", 45), "toista"]),
+            (11, [("yhde", 45), "toista"]),
+            (10, ("kymmene", 45)),
+            (9, ("yhdeksä", 45)),
+            (8, ("kahdeksa", 45)),
+            (7, ("seitsemä", 45)),
+            (6, ("kuude", 45)),
+            (5, ("viide", 45)),
+            (4, ("neljä", 45)),
+            (3, ("kolma", 45)),
+            (2, ("toi", 38)),
+            (1, ("ensimmäi", 38)),
+            (0, ("nolla", 45)),
+        ]
+
+    def merge(self, lpair, rpair, options):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+
+        # http://www.kielitoimistonohjepankki.fi/ohje/49
+        fmt = "%s%s"
+        # ignore lpair if lnum is 1
+        if lnum == 1:
+            rtext = inflect(rtext, options)
+            return (rtext, rnum)
+        # rnum is added to lnum
+        elif lnum > rnum:
+            ltext = inflect(ltext, options)
+            rtext = inflect(rtext, options)
+            # separate groups with space
+            if lnum >= 1000:
+                fmt = "%s %s"
+            return (fmt % (ltext, rtext), lnum + rnum)
+        # rnum is multiplied by lnum
+        elif lnum < rnum:
+            if options.ordinal:
+                # kahdessadas, not toinensadas
+                if lnum == 2:
+                    ltext = ("kahde", 45)
+                rtext = inflect(rtext, options)
+            else:
+                # kaksituhatta but kahdettuhannet
+                rcase = options.case
+                if options.case == NOM and not options.plural:
+                    rcase = PTV
+                rtext = inflect(rtext, options.variation(case=rcase))
+            ltext = inflect(ltext, options)
+            return (fmt % (ltext, rtext), lnum * rnum)
+
+    def to_cardinal(self, value, case='nominative', plural=False, prefer=None):
+        case = NAME_TO_CASE[case]
+        options = Options(False, case, plural, prefer)
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            if case != NOM:
+                raise NotImplementedError(
+                    "Cases other than nominative are not implemented for "
+                    "cardinal floating point numbers.")
+            return self.to_cardinal_float(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, options)
+        words, num = self.clean(val, options)
+        return self.title(out + words)
+
+    def to_ordinal(self, value, case='nominative', plural=False, prefer=None):
+        case = NAME_TO_CASE[case]
+        options = Options(True, case, plural, prefer)
+
+        self.verify_ordinal(value)
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        val = self.splitnum(value, options)
+        words, num = self.clean(val, options)
+        return self.title(words)
+
+    def to_ordinal_num(self, value, case='nominative', plural=False):
+        """Convert to abbreviated ordinal form (1., 2., 3. etc)"""
+        return str(value) + '.'
+
+    def to_year(self, val, suffix=None, longval=True):
+        suffix = suffix or ""
+        if val < 0:
+            val = abs(val)
+            suffix = suffix or " ennen ajanlaskun alkua"
+        return self.to_cardinal(val).replace(" ", "") + suffix
+
+    def to_currency(self, val, currency="EUR", cents=True, separator=" ja",
+                    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_FI, 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_FI, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def splitnum(self, value, options):
+        elems = self.ords if options.ordinal else self.cards
+        for elem in elems:
+            if elem > value:
+                continue
+
+            out = []
+            if value == 0:
+                div, mod = 1, 0
+            else:
+                div, mod = divmod(value, elem)
+
+            if div == 1:
+                out.append((elems[1], 1))
+            else:
+                if div == value:  # The system tallies, eg Roman Numerals
+                    return [(div * elems[elem], div * elem)]
+                out.append(self.splitnum(div, options))
+
+            out.append((elems[elem], elem))
+
+            if mod:
+                out.append(self.splitnum(mod, options))
+
+            return out
+
+    def clean(self, val, options):
+        out = val
+        while len(val) != 1:
+            out = []
+            left, right = val[:2]
+            if isinstance(left, tuple) and isinstance(right, tuple):
+                out.append(self.merge(left, right, options))
+                if val[2:]:
+                    out.append(val[2:])
+            else:
+                for elem in val:
+                    if isinstance(elem, list):
+                        if len(elem) == 1:
+                            out.append(elem[0])
+                        else:
+                            out.append(self.clean(elem, options))
+                    else:
+                        out.append(elem)
+            val = out
+        return out[0]