游雁
2023-11-20 df03a020f6d8fe4e9b09c1e784fead2852d90bfc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
# -*- coding: utf-8 -*-
# Khmer
 
from __future__ import division, print_function, unicode_literals
 
from . import lang_EU
 
# Khmer
 
class Num2Word_KH(lang_EU.Num2Word_EU):
    def set_high_numwords(self, high):
        max = 3 * len(high)
        for word, n in zip(high, range(max, 3, -1)):
            # print(word[0],word[1],n)
            self.cards[10 ** n] = word[1]
            # self.cards[10**n] = word + "លាន"
        # try:
        #     ordinal_word = self.high_numwords[high]
        # except KeyError:
        #     max = 3 + 3 * len(high)
        #     for word, n in zip(high, range(max, 3, -3)):
        #         print(word)
        #         print(n)
        #         self.cards[10 ** n] = word
 
    def gen_high_numwords(self, units, tens, lows):
        out = [u + t for t in tens for u in units]
        out.reverse()
        return out + lows
 
    def setup(self):
        super(Num2Word_KH, self).setup()
 
        self.negword = "ដក "
        self.pointword = "ចំណុច"
        self.exclude_title = ["និង", "ចំណុច", "ដក"]
        lows = [""]
        units = [""]
        tens = ["ពាន់លាន","រយលាន","កោដិ","លាន","សែន","ម៉ឺន"]
        self.high_numwords = self.gen_high_numwords(units, tens, lows)
 
        self.high_numwords = [(1000000000, "មួយពាន់លាន"), 
                              (100000000, "មួយរយលាន"),
                              (10000000, "មួយកោដិ"), 
                              (1000000, "មួយលាន"), 
                              (100000, "មួយសែន"),
                              (10000, "មួយម៉ឺន")]
                             # (2400000, "ពីរលានបួនម៉ឺន")
 
        self.mid_numwords = [(1000, "មួយពាន់"), (100, "មួយរយ"),
                             (90, "កៅសិប"), (80, "ប៉ែតសិប"), (70, "ចិតសិប"),
                             (60, "ហុកសិប"), (50, "ហាសិប"), (40, "សែសិប"),
                             (30, "សាមសិប")]
 
        self.low_numwords = ["ម្ភៃ", 
                            "ដប់ប្រាំបួន", 
                            "ដប់ប្រាំបី", 
                            "ដប់ប្រាំពីរ",
                            "ដប់ប្រាំមួយ", 
                            "ដប់ប្រាំ", 
                            "ដប់បួន", 
                            "ដប់បី",
                            "ដប់ពីរ", 
                            "ដប់មួយ", 
                            "ដប់", 
                            "ប្រាំបួន", 
                            "ប្រាំបី",
                            "ប្រាំពីរ", 
                            "ប្រាំមួយ", 
                            "ប្រាំ", 
                            "បួន", 
                            "បី", 
                            "ពីរ",
                            "មួយ", 
                            "សូន្យ"]
 
        self.ords = {"មួយ": "ទីមួយ",
                     "ពីរ": "ទីពីរ",
                     "បី": "ទីបី",
                     "បួន": "ទីបួន",
                     "ប្រាំ": "ទីប្រាំ",
                     "ប្រាំមួយ": "ទីប្រាំមួយ",
                     "ប្រាំពីរ": "ទីប្រាំពីរ",
                     "ប្រាំបី": "ទីប្រាំបី",
                     "ប្រាំបួន": "ទីប្រាំបួន",
                     "ដប់": "ទីដប់",
                     "ដប់មួយ": "ទីដប់មួយ",
                     "ដប់ពីរ": "ទីដប់ពីរ"}
 
    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 > lnum:
            return ("%s%s" % (ltext, rtext), lnum * rnum)
        return ("%s%s" % (ltext, rtext), lnum + rnum)
 
    def to_ordinal_num(self, value):
        self.verify_ordinal(value)
        return "%s%s" % (value, self.to_ordinal(value))
 
    def to_ordinal(self, value):
        self.verify_ordinal(value)
        try:
            ordinal_word = self.ords[value]
        except KeyError:
            ordinal_word = "ទី" + value
        return ordinal_word
 
 
    def to_year(self, val, suffix=None, longval=True):
        if val < 0:
            val = abs(val)
            suffix = 'មុនគ' if not suffix else suffix
        high, low = (val // 100, val % 100)
        # If year is 00XX, X00X, or beyond 9999, go cardinal.
        if (high == 0
                or (high % 10 == 0 and low < 10)
                or high >= 100):
            valtext = self.to_cardinal(val)
        else:
            hightext = self.to_cardinal(high)
            if low == 0:
                lowtext = "រយ"
            elif low < 10:
                lowtext = "%s" % self.to_cardinal(low)
            else:
                lowtext = self.to_cardinal(low)
            valtext = "%s %s" % (hightext, lowtext)
        return (valtext if not suffix
                else "%s %s" % (valtext, suffix))