コード例 #1
0
            public override string[] GetDecimalName(CasesEnum Case)
            {
                switch (Case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { "копейка", "копейки", "копеек" });

                case CasesEnum.Genitive:
                    return(new string[] { "копейки", "копеек", "копеек" });

                case CasesEnum.Dative:
                    return(new string[] { "копейке", "копейкам", "копейкам" });

                case CasesEnum.Accusative:
                    return(new string[] { "копейку", "копейки", "копеек" });

                case CasesEnum.Instrumental:
                    return(new string[] { "копейкой", "копейками", "копейками" });

                case CasesEnum.Prepositional:
                    return(new string[] { "копейке", "копейках", "копейках" });
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #2
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по неточному совпадению с автоматическим определением рода, падежа и числа.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное в любом роде, числе и падеже.</param>
        /// <param name="foundWord">Существительное, найденное в словаре.</param>
        /// <param name="number">Число найденного существительного.</param>
        /// <param name="case">Падеж найденного существительного.</param>
        /// <returns></returns>
        public CyrNoun GetOrDefault(string word, out string foundWord, out CasesEnum @case, out NumbersEnum number)
        {
            CyrNoun noun = this.GetOrDefault(word, out @case, out number);

            if (noun != null)
            {
                foundWord = word;
                return(new CyrNoun(noun));
            }

            foundWord = this.GetSimilar(word, this.NounMinSameLetters, this.NounMaxSameLetters);

            if (string.IsNullOrEmpty(foundWord))
            {
                return(null);
            }

            noun = this.GetOrDefault(foundWord, out @case, out number);

            if (noun != null)
            {
                noun = new CyrNoun(noun);
                noun.SetName(word, @case, number);
                return(noun);
            }

            return(null);
        }
コード例 #3
0
ファイル: CyrAdjective.cs プロジェクト: ne2poy/Cyriller
        public void SetName(string name, GendersEnum gender, CasesEnum @case, NumbersEnum number, AnimatesEnum animate)
        {
            CyrRule[] rules = this.GetRules(gender, number, animate);
            CyrRule   rule  = rules[(int)@case - 1];

            this.Name = rule.Revert(this.Name, name);
        }
コード例 #4
0
ファイル: CyrNumber.Item.cs プロジェクト: ne2poy/Cyriller
            protected string[] GetNeuter(CasesEnum @case)
            {
                switch (@case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { singular[1], singular[2], plural[2] });

                case CasesEnum.Genitive:
                    return(new string[] { singular[2], plural[2], plural[2] });

                case CasesEnum.Dative:
                    return(new string[] { singular[3], plural[3], plural[3] });

                case CasesEnum.Accusative:
                    return(new string[] { singular[4], singular[2], plural[2] });

                case CasesEnum.Instrumental:
                    return(new string[] { singular[5], plural[5], plural[5] });

                case CasesEnum.Prepositional:
                    return(new string[] { singular[6], plural[6], plural[6] });

                default:
                    throw new ArgumentException("Invalid Case!");
                }
            }
コード例 #5
0
            public override string[] GetDecimalName(CasesEnum Case)
            {
                switch (Case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });

                case CasesEnum.Genitive:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });

                case CasesEnum.Dative:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });

                case CasesEnum.Accusative:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });

                case CasesEnum.Instrumental:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });

                case CasesEnum.Prepositional:
                    return(new string[] { "цзяо", "цзяо", "цзяо" });
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #6
0
            public override string[] GetIntegerName(CasesEnum Case)
            {
                switch (Case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { "рубль", "рубля", "рублей" });

                case CasesEnum.Genitive:
                    return(new string[] { "рубля", "рублей", "рублей" });

                case CasesEnum.Dative:
                    return(new string[] { "рублю", "рублям", "рублям" });

                case CasesEnum.Accusative:
                    return(new string[] { "рубль", "рубля", "рублей" });

                case CasesEnum.Instrumental:
                    return(new string[] { "рублем", "рублями", "рублями" });

                case CasesEnum.Prepositional:
                    return(new string[] { "рубле", "рублях", "рублях" });
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #7
0
        public string ToString(decimal Value, CasesEnum Case, Item Item)
        {
            long          i  = (long)Value;
            StringBuilder sb = new StringBuilder();
            //Strings s = new Strings(Case, Item.Gender, Item.Animate);
            GendersEnum  gender  = i < Value ? GendersEnum.Feminine : Item.Gender;
            AnimatesEnum animate = i == Value && i < 20 ? Item.Animate : AnimatesEnum.Inanimated;

            string[] name;

            sb.Append(this.ToString(Value, Case, gender, animate)).Append(" ");

            if (i < Value)
            {
                name = Item.GetName(CasesEnum.Nominative, i);
                sb.Append(name[1]);
            }
            else
            {
                name = Item.GetName(Case, i);
                sb.Append(this.Case(i, name[0], name[1], name[2]));
            }

            return(sb.ToString());
        }
コード例 #8
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по точному совпадению с автоматическим определением рода, падежа и числа.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное в любом роде, числе и падеже.</param>
        /// <param name="number">Число найденного существительного.</param>
        /// <param name="case">Падеж найденного существительного.</param>
        /// <returns></returns>
        public CyrNoun GetOrDefault(string word, out CasesEnum @case, out NumbersEnum number)
        {
            DictionaryKey key;
            CyrNoun       noun;

            // Существительные, без формы единственного числа, не имеют рода. К примеру "ворота" или "шахматы".
            GendersEnum[] gendersWithZero = new GendersEnum[] { GendersEnum.Masculine, GendersEnum.Feminine, GendersEnum.Neuter, GendersEnum.Undefined };

            foreach (CasesEnum c in this.cases)
            {
                foreach (NumbersEnum n in this.numbers)
                {
                    foreach (GendersEnum g in gendersWithZero)
                    {
                        key = new DictionaryKey(word, g, c, n);

                        if (this.words.TryGetValue(key, out noun))
                        {
                            @case  = key.Case;
                            number = key.Number;

                            return(noun);
                        }
                    }
                }
            }

            @case  = 0;
            number = 0;

            return(null);
        }
コード例 #9
0
ファイル: CyrNumber.Currency.cs プロジェクト: ne2poy/Cyriller
            public override string[] GetDecimalName(CasesEnum @case)
            {
                switch (@case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { "цент", "цента", "центов" });

                case CasesEnum.Genitive:
                    return(new string[] { "цента", "центов", "центов" });

                case CasesEnum.Dative:
                    return(new string[] { "центу", "центам", "центам" });

                case CasesEnum.Accusative:
                    return(new string[] { "цент", "цента", "центов" });

                case CasesEnum.Instrumental:
                    return(new string[] { "центом", "центами", "центами" });

                case CasesEnum.Prepositional:
                    return(new string[] { "центе", "центах", "центах" });
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #10
0
 public DictionaryKey(string name, GendersEnum gender, CasesEnum @case, NumbersEnum number)
 {
     this.Name   = name;
     this.Gender = gender;
     this.Case   = @case;
     this.Number = number;
 }
コード例 #11
0
            public override string[] GetIntegerName(CasesEnum Case)
            {
                switch (Case)
                {
                case CasesEnum.Nominative:
                    return(new string[] { "доллар", "доллара", "долларов" });

                case CasesEnum.Genitive:
                    return(new string[] { "доллара", "долларов", "долларов" });

                case CasesEnum.Dative:
                    return(new string[] { "доллару", "долларам", "долларам" });

                case CasesEnum.Accusative:
                    return(new string[] { "доллар", "доллара", "долларов" });

                case CasesEnum.Instrumental:
                    return(new string[] { "долларов", "долларами", "долларами" });

                case CasesEnum.Prepositional:
                    return(new string[] { "долларе", "долларах", "долларах" });
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #12
0
 public CyrDeclineCase(string nameRu, string nameEn, string description, int index, CasesEnum value)
 {
     this.NameRu      = nameRu;
     this.NameEn      = nameEn;
     this.Description = description;
     this.Index       = index;
     this.Value       = value;
 }
コード例 #13
0
 public CyrWordNotFoundException(string word, GendersEnum gender, CasesEnum @case, NumbersEnum number, AnimatesEnum animate)
     : base($"The word was not found in the collection. Word: [{word}], gender: [{gender}], case: [{@case}], number: [{number}], animte: [{animate}].")
 {
     this.Word    = word;
     this.Gender  = gender;
     this.Case    = @case;
     this.Number  = number;
     this.Animate = animate;
 }
コード例 #14
0
        /// <summary>
        /// Поиск прилагательного по точному совпадению с автоматическим определением рода, падежа, числа и одушевленности.
        /// Выбрасывает <see cref="CyrWordNotFoundException"/> если слово не было найдено.
        /// </summary>
        /// <param name="word">Прилагательное в любом роде, числе и падеже.</param>
        /// <param name="gender">Род найденного прилагательного.</param>
        /// <param name="number">Число найденного прилагательного.</param>
        /// <param name="case">Падеж найденного прилагательного.</param>
        /// <returns></returns>
        public CyrAdjective Get(string word, out GendersEnum gender, out CasesEnum @case, out NumbersEnum number, out AnimatesEnum animate)
        {
            CyrAdjective adjective = this.GetOrDefault(word, out gender, out @case, out number, out animate);

            if (adjective == null)
            {
                throw new CyrWordNotFoundException(word, gender, @case, number, animate);
            }

            return(adjective);
        }
コード例 #15
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по неточному совпадению с автоматическим определением рода, падежа и числа.
        /// Выбрасывает <see cref="CyrWordNotFoundException"/> если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное в любом роде, числе и падеже.</param>
        /// <param name="foundWord">Существительное, найденное в словаре.</param>
        /// <param name="number">Число найденного существительного.</param>
        /// <param name="case">Падеж найденного существительного.</param>
        /// <returns></returns>
        public CyrNoun Get(string word, out string foundWord, out CasesEnum @case, out NumbersEnum number)
        {
            CyrNoun noun = this.GetOrDefault(word, out foundWord, out @case, out number);

            if (noun == null)
            {
                throw new CyrWordNotFoundException(word, 0, @case, number, 0);
            }

            return(noun);
        }
コード例 #16
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по точному совпадению с указанием рода, падежа и числа.
        /// Выбрасывает <see cref="CyrWordNotFoundException"/> если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное.</param>
        /// <param name="gender">Род, в котором указано существительного.</param>
        /// <param name="case">Падеж, в котором указано существительного.</param>
        /// <param name="number">Число, в котором указано существительного.</param>
        /// <returns></returns>
        public CyrNoun Get(string word, GendersEnum gender, CasesEnum @case, NumbersEnum number)
        {
            CyrNoun noun = this.GetOrDefault(word, gender, @case, number);

            if (noun == null)
            {
                throw new CyrWordNotFoundException(word, gender, @case, number, 0);
            }

            return(noun);
        }
コード例 #17
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по точному совпадению.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное.</param>
        /// <param name="gender">Род, в котором указано существительного.</param>
        /// <param name="case">Падеж, в котором указано существительного.</param>
        /// <param name="number">Число, в котором указано существительного.</param>
        /// <returns></returns>
        public CyrNoun GetOrDefault(string word, GendersEnum gender, CasesEnum @case, NumbersEnum number)
        {
            DictionaryKey key = new DictionaryKey(word, gender, @case, number);
            CyrNoun       noun;

            if (this.words.TryGetValue(key, out noun))
            {
                return(new CyrNoun(noun));
            }

            return(null);
        }
コード例 #18
0
        /// <summary>
        /// Поиск прилагательного по точному совпадению с указанием рода, падежа, числа и одушевленности.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Прилагательное.</param>
        /// <param name="gender">Род, в котором указано прилагательное.</param>
        /// <param name="case">Падеж, в котором указано прилагательное.</param>
        /// <param name="number">Число, в котором указано прилагательное.</param>
        /// <param name="animate">Одушевленность прилагательного.</param>
        /// <returns></returns>
        public CyrAdjective GetOrDefault(string word, GendersEnum gender, CasesEnum @case, NumbersEnum number, AnimatesEnum animate)
        {
            DictionaryKey key = new DictionaryKey(word, gender, @case, number, animate);
            CyrAdjective  adjective;

            if (this.words.TryGetValue(key, out adjective))
            {
                return(new CyrAdjective(adjective));
            }

            return(null);
        }
コード例 #19
0
        public string ToString(decimal Value, CasesEnum Case, GendersEnum Gender, AnimatesEnum Animate)
        {
            string str = Value.ToString(System.Globalization.CultureInfo.InvariantCulture);

            string[]      parts = str.Split('.');
            long          i     = long.Parse(parts[0]);
            StringBuilder sb    = new StringBuilder();
            Strings       s     = new Strings(Case, Gender, Animate);

            sb.Append(this.ToString(i, Case, Gender, Animate));

            if (parts.Length > 1)
            {
                parts[1] = parts[1].TrimEnd('0');
            }

            if (parts.Length > 1 && !string.IsNullOrEmpty(parts[1]))
            {
                string[] decimals;
                long     d  = long.Parse(parts[1]);
                long     dr = long.Parse(string.Join(string.Empty, parts[1].Reverse().ToArray()));

                if (dr < 10)
                {
                    decimals = s.DecimalTen;
                }
                else if (dr < 100)
                {
                    decimals = s.DecimalHundred;
                }
                else if (dr < 1000)
                {
                    decimals = s.DecimalThousand;
                }
                else if (dr < 1000000)
                {
                    decimals = s.DecimalMillion;
                }
                else
                {
                    decimals = s.DecimalBillion;
                }

                sb.Append(" ");
                sb.Append(this.Case(i, s.Integer[0], s.Integer[1], s.Integer[2]));
                sb.Append(" и ");
                sb.Append(this.ToString(d, Case, Gender, Animate));
                sb.Append(" ");
                sb.Append(this.Case(d, decimals[0], decimals[1], decimals[2]));
            }

            return(sb.ToString());
        }
コード例 #20
0
        public void SetName(string name, CasesEnum @case, NumbersEnum number)
        {
            if (this.rules.Length > rulesPerNoun)
            {
                throw new NotImplementedException($"{nameof(SetName)} is not yet supported for composite nouns.");
            }

            CyrRule[] rules = this.GetRules(number, 0);
            CyrRule   rule  = rules[(int)@case - 1];

            this.Name = rule.Revert(this.Name, name);
        }
コード例 #21
0
        public Dictionary <CasesEnum, string> ToDictionary()
        {
            CasesEnum[] caseNames = new CasesEnum[] { CasesEnum.Nominative, CasesEnum.Genitive, CasesEnum.Dative, CasesEnum.Accusative, CasesEnum.Instrumental, CasesEnum.Prepositional };
            Dictionary <CasesEnum, string> result = new Dictionary <CasesEnum, string>();

            result.Add(caseNames[0], case1);
            result.Add(caseNames[1], case2);
            result.Add(caseNames[2], case3);
            result.Add(caseNames[3], case4);
            result.Add(caseNames[4], case5);
            result.Add(caseNames[5], case6);

            return(result);
        }
コード例 #22
0
ファイル: CyrNumber.Item.cs プロジェクト: ne2poy/Cyriller
 public string[] GetName(CasesEnum @case, long value)
 {
     if (this.Gender == GendersEnum.Feminine)
     {
         return(GetFeminine(@case));
     }
     else if (this.Gender == GendersEnum.Neuter)
     {
         return(GetNeuter(@case));
     }
     else
     {
         return(this.GetMasculine(@case, value));
     }
 }
コード例 #23
0
        /// <summary>
        /// Поиск прилагательного по точному совпадению с автоматическим определением рода, падежа, числа и одушевленности.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Прилагательное в любом роде, числе и падеже.</param>
        /// <param name="gender">Род найденного прилагательного.</param>
        /// <param name="number">Число найденного прилагательного.</param>
        /// <param name="case">Падеж найденного прилагательного.</param>
        /// <returns></returns>
        public CyrAdjective GetOrDefault(string word, out GendersEnum gender, out CasesEnum @case, out NumbersEnum number, out AnimatesEnum animate)
        {
            DictionaryKey key;
            CyrAdjective  adjective;

            foreach (AnimatesEnum a in this.animates)
            {
                foreach (GendersEnum g in this.genders)
                {
                    foreach (CasesEnum c in this.cases)
                    {
                        key = new DictionaryKey(word, g, c, NumbersEnum.Singular, a);

                        if (this.words.TryGetValue(key, out adjective))
                        {
                            gender  = key.Gender;
                            @case   = key.Case;
                            number  = key.Number;
                            animate = key.Animate;

                            return(adjective);
                        }
                    }
                }

                foreach (CasesEnum c in this.cases)
                {
                    key = new DictionaryKey(word, 0, c, NumbersEnum.Plural, a);

                    if (this.words.TryGetValue(key, out adjective))
                    {
                        gender  = key.Gender;
                        @case   = key.Case;
                        number  = key.Number;
                        animate = key.Animate;

                        return(adjective);
                    }
                }
            }

            gender  = 0;
            @case   = 0;
            number  = 0;
            animate = 0;

            return(null);
        }
コード例 #24
0
        public string ToString(decimal Value, CasesEnum Case, Currency Currency)
        {
            string str = Value.ToString(System.Globalization.CultureInfo.InvariantCulture);

            string[]      parts = str.Split('.');
            long          i     = long.Parse(parts[0]);
            StringBuilder sb    = new StringBuilder();
            Strings       s     = new Strings(Case, Currency.IntegerGender, AnimatesEnum.Inanimated);

            string[] iname = Currency.GetIntegerName(Case);
            string[] dname = Currency.GetDecimalName(Case);

            sb.Append(this.ToString(i, Case, Currency.IntegerGender, AnimatesEnum.Inanimated));
            sb.Append(" ").Append(this.Case(i, iname[0], iname[1], iname[2]));

            if (parts.Length > 1)
            {
                parts[1] = parts[1].TrimEnd('0');
            }

            if (parts.Length > 1 && !string.IsNullOrEmpty(parts[1]))
            {
                string v = parts[1];

                while (v.Length < Currency.Decimals)
                {
                    v += "0";
                }

                if (v.Length > Currency.Decimals)
                {
                    List <char> chars = v.ToCharArray().ToList();

                    chars.Insert(Currency.Decimals, '.');
                    v = string.Join(string.Empty, chars.ToArray());
                }

                long d = (long)Math.Round(decimal.Parse(v, System.Globalization.CultureInfo.InvariantCulture.NumberFormat), 0);

                sb.Append(" и ");
                sb.Append(this.ToString(d, Case, Currency.DecimalGender, AnimatesEnum.Inanimated));
                sb.Append(" ");
                sb.Append(this.Case(d, dname[0], dname[1], dname[2]));
            }

            return(sb.ToString());
        }
コード例 #25
0
        protected virtual string GetCaseStringRu(CasesEnum @case)
        {
            switch (@case)
            {
            case CasesEnum.Nominative: return("именительный падеж");

            case CasesEnum.Genitive: return("родительный падеж");

            case CasesEnum.Dative: return("дательный падеж");

            case CasesEnum.Accusative: return("винительный падеж");

            case CasesEnum.Instrumental: return("творительный падеж");

            case CasesEnum.Prepositional: return("предложный падеж");

            default: return(string.Empty);
            }
        }
コード例 #26
0
        public void Set(CasesEnum Case, string Value)
        {
            switch (Case)
            {
            case CasesEnum.Nominative: case1 = Value; break;

            case CasesEnum.Genitive: case2 = Value; break;

            case CasesEnum.Dative: case3 = Value; break;

            case CasesEnum.Accusative: case4 = Value; break;

            case CasesEnum.Instrumental: case5 = Value; break;

            case CasesEnum.Prepositional: case6 = Value; break;

            default: case1 = Value; break;
            }
        }
コード例 #27
0
        public string Get(CasesEnum Case)
        {
            switch (Case)
            {
            case CasesEnum.Nominative: return(case1);

            case CasesEnum.Genitive: return(case2);

            case CasesEnum.Dative: return(case3);

            case CasesEnum.Accusative: return(case4);

            case CasesEnum.Instrumental: return(case5);

            case CasesEnum.Prepositional: return(case6);

            default: return(case1);
            }
        }
コード例 #28
0
            public override string[] GetIntegerName(CasesEnum Case)
            {
                switch (Case)
                {
                    case CasesEnum.Nominative:
                        return new string[] { "евро", "евро", "евро" };
                    case CasesEnum.Genitive:
                        return new string[] { "евро", "евро", "евро" };
                    case CasesEnum.Dative:
                        return new string[] { "евро", "евро", "евро" };
                    case CasesEnum.Accusative:
                        return new string[] { "евро", "евро", "евро" };
                    case CasesEnum.Instrumental:
                        return new string[] { "евро", "евро", "евро" };
                    case CasesEnum.Prepositional:
                        return new string[] { "евро", "евро", "евро" };
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #29
0
            public override string[] GetDecimalName(CasesEnum Case)
            {
                switch (Case)
                {
                    case CasesEnum.Nominative:
                        return new string[] { "цент", "цента", "центов" };
                    case CasesEnum.Genitive:
                        return new string[] { "цента", "центов", "центов" };
                    case CasesEnum.Dative:
                        return new string[] { "центу", "центам", "центам" };
                    case CasesEnum.Accusative:
                        return new string[] { "цент", "цента", "центов" };
                    case CasesEnum.Instrumental:
                        return new string[] { "центом", "центами", "центами" };
                    case CasesEnum.Prepositional:
                        return new string[] { "центе", "центах", "центах" };
                }

                throw new ArgumentOutOfRangeException("Invalid decline case!");
            }
コード例 #30
0
            public Strings(CasesEnum Case, GendersEnum Gender, AnimatesEnum Animate)
            {
                switch (Case)
                {
                    case CasesEnum.Nominative:
                        this.Hundreds = new string[] { "сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот", "восемьсот", "девятьсот" };
                        this.Tens = new string[] { "десять", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто" };
                        this.Numbers = new string[] { "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать", "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать" };
                        this.Thousand = new string[] { "тысяча", "тысячи", "тысяч" };
                        this.Million = new string[] { "миллион", "миллиона", "миллионов" };
                        this.Billion = new string[] { "миллиард", "миллиарда", "миллиардов" };
                        this.Zero = "ноль";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целая", "целые", "целых" };
                            this.DecimalTen = new string[] { "десятая", "десятые", "десятых" };
                            this.DecimalHundred = new string[] { "сотая", "сотые", "сотых" };
                            this.DecimalThousand = new string[] { "тысячная", "тысячные", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионная", "миллионные", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардная", "миллиардные", "миллиардных" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целый", "целых", "целых" };
                            this.DecimalTen = new string[] { "десятый", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотый", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячный", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионный", "миллионных", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардный", "миллиардных", "миллиардных" };
                        }
                        break;
                    case CasesEnum.Genitive:
                        this.Hundreds = new string[] { "ста", "двухсот", "трехсот", "четырехсот", "пятисот", "шестисот", "семисот", "восьмисот", "девятисот" };
                        this.Tens = new string[] { "десяти", "двадцати", "тридцати", "сорока", "пятидесяти", "шестидесяти", "семидесяти", "весьмидесяти", "девяноста" };
                        this.Numbers = new string[] { "одного", "двух", "трех", "четырех", "пяти", "шести", "семи", "восьми", "девяти", "десяти", "одиннадцати", "двенадцати", "тринадцати", "четырнадцати", "пятнадцати", "шестнадцати", "семнадцати", "восемнадцати", "девятнадцати" };
                        this.Thousand = new string[] { "тысячи", "тысячь", "тысячь" };
                        this.Million = new string[] { "миллиона", "миллионов", "миллионов" };
                        this.Billion = new string[] { "миллиарда", "миллиардов", "миллиардов" };
                        this.Zero = "ноля";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целой", "целыми", "целыми" };
                            this.DecimalTen = new string[] { "десятой", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотой", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячной", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионной", "миллионных", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардной", "миллиардных", "миллиардных" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целого", "целых", "целых" };
                            this.DecimalTen = new string[] { "десятого", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотого", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячного", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионного", "миллионных", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардного", "миллиардных", "миллиардных" };
                        }
                        break;
                    case CasesEnum.Dative:
                        this.Hundreds = new string[] { "ста", "двумстам", "тремстам", "четыремстам", "пятистам", "шестистам", "семистам", "восьмистам", "девятистам" };
                        this.Tens = new string[] { "десяти", "двадцати", "тридцати", "сорока", "пятидесяти", "шестидесяти", "семидесяти", "весьмидесяти", "девяноста" };
                        this.Numbers = new string[] { "одному", "двум", "трем", "четырем", "пяти", "шести", "семи", "восьми", "девяти", "десяти", "одиннадцати", "двенадцати", "тринадцати", "четырнадцати", "пятнадцати", "шестнадцати", "семнадцати", "восемнадцати", "девятнадцати" };
                        this.Thousand = new string[] { "тысяче", "тысячам", "тысячам" };
                        this.Million = new string[] { "миллиону", "миллионам", "миллионам" };
                        this.Billion = new string[] { "миллиарду", "миллиардам", "миллиардам" };
                        this.Zero = "ноля";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целой", "целым", "целым" };
                            this.DecimalTen = new string[] { "десятой", "десятым", "десятым" };
                            this.DecimalHundred = new string[] { "сотой", "сотым", "сотым" };
                            this.DecimalThousand = new string[] { "тысячной", "тысячным", "тысячным" };
                            this.DecimalMillion = new string[] { "миллионной", "миллионным", "миллионным" };
                            this.DecimalBillion = new string[] { "миллиардной", "миллиардным", "миллиардным" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целому", "целым", "целым" };
                            this.DecimalTen = new string[] { "десятому", "десятым", "десятым" };
                            this.DecimalHundred = new string[] { "сотому", "сотым", "сотым" };
                            this.DecimalThousand = new string[] { "тысячному", "тысячным", "тысячным" };
                            this.DecimalMillion = new string[] { "миллионному", "миллионным", "миллионным" };
                            this.DecimalBillion = new string[] { "миллиардному", "миллиардным", "миллиардным" };
                        }
                        break;
                    case CasesEnum.Accusative:
                        this.Hundreds = new string[] { "сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот", "восемьсот", "девятьсот" };
                        this.Tens = new string[] { "десять", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто" };

                        if (Animate == AnimatesEnum.Animated)
                        {
                            this.Numbers = new string[] { "одного", "двух", "трех", "четырех", "пять", "шести", "семи", "восьми", "девяти", "десяти", "одиннадцати", "двенадцати", "тринадцати", "четырнадцати", "пятнадцати", "шестнадцати", "семнадцати", "восемнадцати", "девятнадцати" };
                        }
                        else
                        {
                            this.Numbers = new string[] { "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать", "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать" };
                        }

                        this.Thousand = new string[] { "тысячу", "тысячи", "тысяч" };
                        this.Million = new string[] { "миллион", "миллиона", "миллионов" };
                        this.Billion = new string[] { "миллиард", "миллиарда", "миллиардов" };
                        this.Zero = "ноль";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целую", "целые", "целых" };
                            this.DecimalTen = new string[] { "десятую", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотую", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячную", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионную", "миллионныех", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардную", "миллиардных", "миллиардных" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целого", "целых", "целых" };
                            this.DecimalTen = new string[] { "десятый", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотый", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячный", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионный", "миллионныех", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардный", "миллиардных", "миллиардных" };
                        }
                        break;
                    case CasesEnum.Instrumental:
                        this.Hundreds = new string[] { "ста", "двумястами", "тремястами", "четырьмястами", "пятьюстами", "шестьюстами", "семьюстами", "восьмьюстами", "девятьюстами" };
                        this.Tens = new string[] { "десятью", "двадцатью", "тридцатью", "сорока", "пятьюдесятью", "шестьюдесятью", "семьюдесятью", "восьмьюдесятью", "девяноста" };
                        this.Numbers = new string[] { "одним", "двумя", "тремя", "четырьмя", "пятью", "шестью", "семью", "восемью", "девятью", "десятью", "одиннадцатью", "двенадцатью", "тринадцатью", "четырнадцатью", "пятнадцатью", "шестнадцатью", "семнадцатью", "восемнадцатью", "девятнадцатью" };
                        this.Thousand = new string[] { "тысячей", "тысячами", "тысячами" };
                        this.Million = new string[] { "миллионом", "миллионами", "миллионами" };
                        this.Billion = new string[] { "миллиардом", "миллиардами", "миллиардами" };
                        this.Zero = "нолем";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целой", "целыми", "целыми" };
                            this.DecimalTen = new string[] { "десятой", "десятыми", "десятыми" };
                            this.DecimalHundred = new string[] { "сотой", "сотыми", "сотыми" };
                            this.DecimalThousand = new string[] { "тысячной", "тысячными", "тысячными" };
                            this.DecimalMillion = new string[] { "миллионной", "миллионными", "миллионными" };
                            this.DecimalBillion = new string[] { "миллиардной", "миллиардными", "миллиардными" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целым", "целыми", "целыми" };
                            this.DecimalTen = new string[] { "десятым", "десятыми", "десятыми" };
                            this.DecimalHundred = new string[] { "сотым", "сотыми", "сотыми" };
                            this.DecimalThousand = new string[] { "тысячным", "тысячными", "тысячными" };
                            this.DecimalMillion = new string[] { "миллионным", "миллионными", "миллионными" };
                            this.DecimalBillion = new string[] { "миллиардным", "миллиардными", "миллиардными" };
                        }
                        break;
                    case CasesEnum.Prepositional:
                        this.Hundreds = new string[] { "ста", "двухстах", "трехстах", "четырехстах", "пятистах", "шестистах", "семистах", "восьмистах", "девятистах" };
                        this.Tens = new string[] { "десяти", "двадцати", "тридцати", "сорока", "пятидесяти", "шестидесяти", "семидесяти", "восьмидесяти", "девяноста" };
                        this.Numbers = new string[] { "одном", "двух", "трех", "четырех", "пяти", "шести", "семи", "восеми", "девяти", "десяти", "одиннадцати", "двенадцати", "тринадцати", "четырнадцати", "пятнадцати", "шестнадцати", "семнадцати", "восемнадцати", "девятнадцати" };
                        this.Thousand = new string[] { "тысяче", "тысячах", "тысячах" };
                        this.Million = new string[] { "миллионе", "миллионах", "миллионах" };
                        this.Billion = new string[] { "миллиарде", "миллиардах", "миллиардах" };
                        this.Zero = "ноле";

                        if (Gender == GendersEnum.Feminine)
                        {
                            this.Integer = new string[] { "целой", "целых", "целых" };
                            this.DecimalTen = new string[] { "десятой", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотой", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячной", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионной", "миллионных", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардной", "миллиардных", "миллиардных" };
                        }
                        else
                        {
                            this.Integer = new string[] { "целом", "целых", "целых" };
                            this.DecimalTen = new string[] { "десятом", "десятых", "десятых" };
                            this.DecimalHundred = new string[] { "сотом", "сотых", "сотых" };
                            this.DecimalThousand = new string[] { "тысячном", "тысячных", "тысячных" };
                            this.DecimalMillion = new string[] { "миллионном", "миллионных", "миллионных" };
                            this.DecimalBillion = new string[] { "миллиардном", "миллиардных", "миллиардных" };
                        }
                        break;
                }

                if (Gender == GendersEnum.Feminine)
                {
                    switch (Case)
                    {
                        case CasesEnum.Nominative:
                            this.Numbers[0] = "одна";
                            this.Numbers[1] = "две";
                            break;
                        case CasesEnum.Genitive:
                            this.Numbers[0] = "одной";
                            this.Numbers[1] = "двух";
                            break;
                        case CasesEnum.Dative:
                            this.Numbers[0] = "одной";
                            this.Numbers[1] = "двум";
                            break;
                        case CasesEnum.Accusative:
                            this.Numbers[0] = "одну";

                            if (Animate == AnimatesEnum.Animated)
                            {
                                this.Numbers[1] = "двух";
                            }
                            else
                            {
                                this.Numbers[1] = "две";
                            }

                            break;
                        case CasesEnum.Instrumental:
                            this.Numbers[0] = "одной";
                            this.Numbers[1] = "двумя";
                            break;
                        case CasesEnum.Prepositional:
                            this.Numbers[0] = "одной";
                            this.Numbers[1] = "двух";
                            break;
                    }
                }
                else if (Gender == GendersEnum.Neuter)
                {
                    switch (Case)
                    {
                        case CasesEnum.Nominative:
                            this.Numbers[0] = "одно";
                            break;
                        case CasesEnum.Genitive:
                            this.Numbers[0] = "одного";
                            break;
                        case CasesEnum.Dative:
                            this.Numbers[0] = "одному";
                            break;
                        case CasesEnum.Accusative:
                            this.Numbers[0] = "одно";
                            break;
                        case CasesEnum.Instrumental:
                            this.Numbers[0] = "одним";
                            break;
                        case CasesEnum.Prepositional:
                            this.Numbers[0] = "одном";
                            break;
                    }
                }
            }
コード例 #31
0
ファイル: CyrResult.cs プロジェクト: ArsenShnurkov/Cyriller
 public string Get(CasesEnum Case)
 {
     switch (Case)
     {
         case CasesEnum.Nominative: return case1;
         case CasesEnum.Genitive: return case2;
         case CasesEnum.Dative: return case3;
         case CasesEnum.Accusative: return case4;
         case CasesEnum.Instrumental: return case5;
         case CasesEnum.Prepositional: return case6;
         default: return case1;
     }
 }
コード例 #32
0
 public string ToString(decimal Value, CasesEnum Case)
 {
     return(this.ToString(Value, Case, GendersEnum.Masculine, AnimatesEnum.Inanimated));
 }
コード例 #33
0
        public string ToString(long Value, CasesEnum Case, GendersEnum Gender, AnimatesEnum Animate)
        {
            if (Value > 9999999999)
            {
                throw new ArgumentOutOfRangeException("The maximum value is 9999999999.");
            }

            Strings s = new Strings(Case, Gender, Animate);

            if (Value == 0)
            {
                return(s.Zero);
            }

            StringBuilder r = new StringBuilder();
            long          v;

            if (Value < 0)
            {
                r.Append("минус ");
                Value = Math.Abs(Value);
            }

            v = Value / 1000000000;

            if (v > 0)
            {
                r.Append(this.ToString(v, Case, GendersEnum.Masculine, Animate)).Append(" ").Append(this.Case(v, s.Billion[0], s.Billion[1], s.Billion[2])).Append(" ");
                Value = Value - 1000000000 * v;
            }

            v = Value / 1000000;

            if (v > 0)
            {
                r.Append(this.ToString(v, Case, GendersEnum.Masculine, Animate)).Append(" ").Append(this.Case(v, s.Million[0], s.Million[1], s.Million[2])).Append(" ");
                Value = Value - 1000000 * v;
            }

            v = Value / 1000;

            if (v > 0)
            {
                r.Append(this.ToString(v, Case, GendersEnum.Feminine, Animate)).Append(" ").Append(this.Case(v, s.Thousand[0], s.Thousand[1], s.Thousand[2])).Append(" ");
                Value = Value - 1000 * v;
            }

            v = Value / 100;

            if (v > 0)
            {
                r.Append(s.Hundreds[v - 1]).Append(" ");
                Value = Value - 100 * v;
            }

            if (Value >= 20 || Value == 10)
            {
                v = Value / 10;
                r.Append(s.Tens[v - 1]).Append(" ");
                Value = Value - v * 10;
            }

            if (Value > 0)
            {
                r.Append(s.Numbers[Value - 1]);
            }

            return(r.ToString().Trim(' '));
        }
コード例 #34
0
ファイル: CyrResult.cs プロジェクト: ArsenShnurkov/Cyriller
 public void Set(CasesEnum Case, string Value)
 {
     switch (Case)
     {
         case CasesEnum.Nominative: case1 = Value; break;
         case CasesEnum.Genitive: case2 = Value; break;
         case CasesEnum.Dative: case3 = Value; break;
         case CasesEnum.Accusative: case4 = Value; break;
         case CasesEnum.Instrumental: case5 = Value; break;
         case CasesEnum.Prepositional: case6 = Value; break;
         default: case1 = Value; break;
     }
 }
コード例 #35
0
ファイル: CyrResult.cs プロジェクト: ArsenShnurkov/Cyriller
        public Dictionary<CasesEnum, string> ToDictionary()
        {
            CasesEnum[] caseNames = new CasesEnum[] { CasesEnum.Nominative, CasesEnum.Genitive, CasesEnum.Dative, CasesEnum.Accusative, CasesEnum.Instrumental, CasesEnum.Prepositional };
            Dictionary<CasesEnum, string> result = new Dictionary<CasesEnum, string>();

            result.Add(caseNames[0], case1);
            result.Add(caseNames[1], case2);
            result.Add(caseNames[2], case3);
            result.Add(caseNames[3], case4);
            result.Add(caseNames[4], case5);
            result.Add(caseNames[5], case6);

            return result;
        }
コード例 #36
0
ファイル: CyrNounCollection.cs プロジェクト: ne2poy/Cyriller
        /// <summary>
        /// Поиск существительного по неточному совпадению с указанием рода, падежа и числа.
        /// Возвращает null если слово не было найдено.
        /// </summary>
        /// <param name="word">Существительное.</param>
        /// <param name="foundWord">Существительное, найденное в словаре.</param>
        /// <param name="gender">Род, в котором указано существительного.</param>
        /// <param name="case">Падеж, в котором указано существительного.</param>
        /// <param name="number">Число, в котором указано существительного.</param>
        /// <returns></returns>
        public CyrNoun GetOrDefault(string word, out string foundWord, GendersEnum gender, CasesEnum @case, NumbersEnum number)
        {
            CyrNoun noun = this.GetOrDefault(word, gender, @case, number);

            if (noun != null)
            {
                foundWord = word;
                return(new CyrNoun(noun));
            }

            DictionaryKey key = default;

            foundWord = null;

            if (this.EnableCache)
            {
                key = new DictionaryKey(word, gender, @case, number);

                if (this.similarSearchByKeyCache.TryGetValue(key, out foundWord))
                {
                    noun = this.GetOrDefault(foundWord, gender, @case, number);
                    noun = new CyrNoun(noun);
                    noun.SetName(word, @case, number);

                    return(noun);
                }
            }

            foreach (string candidate in this.cyrData.GetSimilars(word, this.wordCandidates, this.NounMinSameLetters, this.NounMaxSameLetters))
            {
                noun = this.GetOrDefault(candidate, gender, @case, number);

                if (noun == null)
                {
                    continue;
                }

                noun = new CyrNoun(noun);
                noun.SetName(word, @case, number);
                foundWord = candidate;

                break;
            }

            if (this.EnableCache)
            {
                this.similarSearchByKeyCache.Add(key, foundWord);
            }

            return(noun);
        }
コード例 #37
0
 public abstract string[] GetIntegerName(CasesEnum Case);
コード例 #38
0
 public abstract string[] GetDecimalName(CasesEnum Case);