protected virtual void CollectPartsUnderAHundred(ICollection<string> parts, ref int number, GrammaticalGender gender, bool pluralize)
{
if (number < 20)
{
parts.Add(GetUnits(number, gender));
}
else
{
var units = number%10;
var tens = GetTens(number/10);
if (units == 0)
{
parts.Add(tens);
}
else if (units == 1)
{
parts.Add(tens);
parts.Add("et");
parts.Add(GetUnits(1, gender));
}
else
{
parts.Add(string.Format("{0}-{1}", tens, GetUnits(units, gender)));
}
}
}
public AdjectiveWordToken(string text, InflectionCase inflectionCase,
GrammaticalGender grammaticalGender, DecliantionNumber decliantionNumber, AdjectiveLevel level)
: base(text, inflectionCase, decliantionNumber)
{
this.level = level;
this.genre = grammaticalGender;
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
// No ordinal for 0 (zero) in Romanian.
if (number == 0)
{
return "0";
}
// Exception from the rule.
if (number == 1)
{
if (gender == GrammaticalGender.Feminine)
{
return "prima"; // întâia
}
return "primul"; // întâiul
}
if (gender == GrammaticalGender.Feminine)
{
return string.Format("a {0}-a", numberString);
}
return string.Format("al {0}-lea", numberString);
}
public ItalianCardinalNumberCruncher(int number, GrammaticalGender gender)
{
_fullNumber = number;
_threeDigitParts = SplitEveryThreeDigits(number);
_gender = gender;
_nextSet = ThreeDigitSets.Units;
}
private static void CollectPartsUnderOneThousand(ICollection<string> parts, int number, GrammaticalGender gender)
{
if (number >= 100)
{
var hundreds = number/100;
number %= 100;
parts.Add(HundredsMap[hundreds]);
}
if (number >= 20)
{
var tens = number/10;
parts.Add(TensMap[tens]);
number %= 10;
}
if (number > 0)
{
if (number == 1 && gender == GrammaticalGender.Feminine)
parts.Add("одна");
else if (number == 1 && gender == GrammaticalGender.Neuter)
parts.Add("одне");
else if (number == 2 && gender == GrammaticalGender.Feminine)
parts.Add("дві");
else if (number < 20)
parts.Add(UnitsMap[number]);
}
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
// N/A in Dutch
if (number == 0)
return "0";
return numberString + "e";
}
public string GetForm(GrammaticalGender genre, InflectionCase aCase, DecliantionNumber amount, AdjectiveLevel level)
{
AdjectiveWordToken token = new AdjectiveWordToken(null, aCase, genre, amount, level);
foreach (AdjectiveWordToken tok in Irregulars)
if (tok.Is(token))
return tok.Text;
return null;
}
protected override void CollectPartsUnderAHundred(ICollection<string> parts, ref int number, GrammaticalGender gender, bool pluralize)
{
if (number == 80)
parts.Add(pluralize ? "quatre-vingts" : "quatre-vingt");
else if (number == 81)
parts.Add(gender == GrammaticalGender.Feminine ? "quatre-vingt-une" : "quatre-vingt-un");
else
base.CollectPartsUnderAHundred(parts, ref number, gender, pluralize);
}
protected static string GetUnits(int number, GrammaticalGender gender)
{
if (number == 1 && gender == GrammaticalGender.Feminine)
{
return "une";
}
return UnitsMap[number];
}
public override string Convert(int number, GrammaticalGender gender)
{
if (number < 0)
return "meno " + Convert(Math.Abs(number), gender);
var cruncher = new ItalianCardinalNumberCruncher(number, gender);
return cruncher.Convert();
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
if (gender == GrammaticalGender.Masculine)
return numberString + "-й";
if (gender == GrammaticalGender.Feminine)
return numberString + "-я";
return numberString + "-е";
}
public NounPostfixToken(GrammaticalGender grammaticalGender, InflectionCase inflectionCase, DecliantionNumber decliantionNumber,
string wordDeclination, params string[] wordPostfixes)
{
this.genre = grammaticalGender;
this.inflectionCase = inflectionCase;
this.amount = decliantionNumber;
this.nounDeclination = wordDeclination;
this.postfixes = wordPostfixes;
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
// No ordinal for 0 in italian (neologism apart)
if (number == 0)
return "0";
if (gender == GrammaticalGender.Feminine)
return numberString + "ª";
return numberString + "°";
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
// N/A in Spanish
if (number == 0)
return "0";
if (gender == GrammaticalGender.Feminine)
return numberString + ".ª";
else
return numberString + ".º";
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
// N/A in Portuguese
if (number == 0)
return "0";
if (gender == GrammaticalGender.Feminine)
return numberString + "ª";
return numberString + "º";
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
// N/A in Portuguese ordinal
if (number == 0)
return "zero";
var parts = new List<string>();
if ((number / 1000000000) > 0)
{
parts.Add(number / 1000000000 == 1
? ApplyOrdinalGender("bilionésimo", gender)
: string.Format("{0} " + ApplyOrdinalGender("bilionésimo", gender), ConvertToOrdinal(number / 1000000000, gender)));
number %= 1000000000;
}
if ((number / 1000000) > 0)
{
parts.Add(number / 1000000 == 1
? ApplyOrdinalGender("milionésimo", gender)
: string.Format("{0}" + ApplyOrdinalGender("milionésimo", gender), ConvertToOrdinal(number / 1000000000, gender)));
number %= 1000000;
}
if ((number / 1000) > 0)
{
parts.Add(number / 1000 == 1
? ApplyOrdinalGender("milésimo", gender)
: string.Format("{0} " + ApplyOrdinalGender("milésimo", gender), ConvertToOrdinal(number / 1000, gender)));
number %= 1000;
}
if ((number / 100) > 0)
{
parts.Add(ApplyOrdinalGender(PortugueseOrdinalHundredsMap[number / 100], gender));
number %= 100;
}
if ((number / 10) > 0)
{
parts.Add(ApplyOrdinalGender(PortugueseOrdinalTensMap[number / 10], gender));
number %= 10;
}
if (number > 0)
parts.Add(ApplyOrdinalGender(PortugueseOrdinalUnitsMap[number], gender));
return string.Join(" ", parts.ToArray());
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
if (number == 0)
return "null" + GetEndingForGender(gender);
var parts = new List<string>();
if (number < 0)
{
parts.Add("minus ");
number = -number;
}
var billions = number/1000000000;
if (billions > 0)
{
number %= 1000000000;
var noRest = NoRestIndex(number);
parts.Add(Part(BillionOrdinalPlural[noRest], BillionOrdinalSingular[noRest], billions));
}
var millions = number/1000000;
if (millions > 0)
{
number %= 1000000;
var noRest = NoRestIndex(number);
parts.Add(Part(MillionOrdinalPlural[noRest], MillionOrdinalSingular[noRest], millions));
}
var thousands = number/1000;
if (thousands > 0)
{
parts.Add(Part("{0}tausend", "eintausend", thousands));
number %= 1000;
}
var hundreds = number/100;
if (hundreds > 0)
{
parts.Add(Part("{0}hundert", "einhundert", hundreds));
number %= 100;
}
if (number > 0)
parts.Add(number < 20 ? UnitsOrdinal[number] : Convert(number));
if (number == 0 || number >= 20)
parts.Add("s");
parts.Add(GetEndingForGender(gender));
return string.Join("", parts);
}
protected override void CollectPartsUnderAHundred(ICollection<string> parts, ref int number, GrammaticalGender gender, bool pluralize)
{
if (number == 71)
parts.Add("soixante et onze");
else if (number == 80)
parts.Add(pluralize ? "quatre-vingts" : "quatre-vingt");
else if (number >= 70)
{
var @base = number < 80 ? 60 : 80;
int units = number - @base;
var tens = @base/10;
parts.Add(string.Format("{0}-{1}", GetTens(tens), GetUnits(units, gender)));
}
else
base.CollectPartsUnderAHundred(parts, ref number, gender, pluralize);
}
public override string Convert(int number, string numberString, GrammaticalGender gender)
{
if (number == 0)
{
return "0";
}
if (gender == GrammaticalGender.Feminine)
{
return numberString + "ª";
}
else
{
return numberString + "º";
}
}
public override string Convert(int number, GrammaticalGender gender)
{
if (number == 0)
return "ноль";
if (number < 0)
return string.Format("минус {0}", Convert(-number, gender));
var parts = new List<string>();
var milliards = number / 1000000000;
if (milliards > 0)
{
var map = new[] { "миллиард", "миллиарда", "миллиардов" };
var grammaticalNumber = RussianGrammaticalNumberDetector.Detect(milliards);
parts.Add(string.Format("{0} {1}", ToWordsUnderThousand(milliards, GrammaticalGender.Masculine), map[GetIndex(grammaticalNumber)]));
number %= 1000000000;
}
var millions = number / 1000000;
if (millions > 0)
{
var map = new[] { "миллион", "миллиона", "миллионов" };
var grammaticalNumber = RussianGrammaticalNumberDetector.Detect(millions);
parts.Add(string.Format("{0} {1}", ToWordsUnderThousand(millions, GrammaticalGender.Masculine), map[GetIndex(grammaticalNumber)]));
number %= 1000000;
}
var thousands = number / 1000;
if (thousands > 0)
{
var map = new[] { "тысяча", "тысячи", "тысячь" };
var grammaticalNumber = RussianGrammaticalNumberDetector.Detect(thousands);
parts.Add(string.Format("{0} {1}", ToWordsUnderThousand(thousands, GrammaticalGender.Feminine), map[GetIndex(grammaticalNumber)]));
number %= 1000;
}
if (number > 0)
{
parts.Add(ToWordsUnderThousand(number, gender));
}
return string.Join(" ", parts.ToArray());
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
if (number == 0)
return "нулев" + GetEndingForGender(gender, number);
var parts = new List<string>();
if (number < 0)
{
parts.Add("минус");
number = -number;
}
CollectOrdinalParts(parts, ref number, 1000000000, GrammaticalGender.Masculine, "миллиардн" + GetEndingForGender(gender, number), "миллиард", "миллиарда", "миллиардов");
CollectOrdinalParts(parts, ref number, 1000000, GrammaticalGender.Masculine, "миллионн" + GetEndingForGender(gender, number), "миллион", "миллиона", "миллионов");
CollectOrdinalParts(parts, ref number, 1000, GrammaticalGender.Feminine, "тысячн" + GetEndingForGender(gender, number), "тысяча", "тысячи", "тысячь");
if (number >= 100)
{
var ending = GetEndingForGender(gender, number);
var hundreds = number/100;
number %= 100;
if (number == 0)
parts.Add(UnitsOrdinalPrefixes[hundreds] + "сот" + ending);
else
parts.Add(HundredsMap[hundreds]);
}
if (number >= 20)
{
var ending = GetEndingForGender(gender, number);
var tens = number/10;
number %= 10;
if (number == 0)
parts.Add(TensOrdinal[tens] + ending);
else
parts.Add(TensMap[tens]);
}
if (number > 0)
parts.Add(UnitsOrdinal[number] + GetEndingForGender(gender, number));
return string.Join(" ", parts);
}
public override string Convert(int number, GrammaticalGender gender)
{
if (number == 0)
return UnitsMap[0];
var parts = new List<string>();
if (number < 0)
{
parts.Add("moins");
number = -number;
}
CollectParts(parts, ref number, 1000000000, "milliard");
CollectParts(parts, ref number, 1000000, "million");
CollectThousands(parts, ref number, 1000, "mille");
CollectPartsUnderAThousand(parts, number, gender, true);
return string.Join(" ", parts);
}
public override string Convert(int number, GrammaticalGender gender)
{
if (number == 0)
return "ноль";
var parts = new List<string>();
if (number < 0)
{
parts.Add("минус");
number = -number;
}
CollectParts(parts, ref number, 1000000000, GrammaticalGender.Masculine, "миллиард", "миллиарда", "миллиардов");
CollectParts(parts, ref number, 1000000, GrammaticalGender.Masculine, "миллион", "миллиона", "миллионов");
CollectParts(parts, ref number, 1000, GrammaticalGender.Feminine, "тысяча", "тысячи", "тысячь");
if (number > 0)
CollectPartsUnderOneThousand(parts, number, gender);
return string.Join(" ", parts);
}
private static string ToWordsUnderThousand(int number, GrammaticalGender gender)
{
var parts = new List<string>();
var hunderdsMap = new[] { "ноль", "сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот", "восемьсот", "девятьсот" };
var hunderds = number / 100;
if (hunderds > 0)
{
parts.Add(hunderdsMap[hunderds]);
number %= 100;
}
var tens = number / 10;
if (tens > 1)
{
var tensMap = new[] { "ноль", "десять", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто" };
parts.Add(tensMap[tens]);
number %= 10;
}
if (number > 0)
{
if (number == 1 && gender == GrammaticalGender.Feminine)
parts.Add("одна");
else if (number == 1 && gender == GrammaticalGender.Neuter)
parts.Add("одно");
else if (number == 2 && gender == GrammaticalGender.Feminine)
parts.Add("две");
else
{
var unitsMap = new[] { "ноль", "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать", "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать" };
if (number < 20)
parts.Add(unitsMap[number]);
}
}
return string.Join(" ", parts);
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
if (number == 1)
return gender == GrammaticalGender.Feminine ? "première" : "premier";
var convertedNumber = Convert(number);
if (convertedNumber.EndsWith("s") && !convertedNumber.EndsWith("trois"))
convertedNumber = convertedNumber.TrimEnd('s');
else if (convertedNumber.EndsWith("cinq"))
convertedNumber += "u";
else if (convertedNumber.EndsWith("neuf"))
convertedNumber = convertedNumber.TrimEnd('f') + "v";
if (convertedNumber.StartsWith("un "))
convertedNumber = convertedNumber.Remove(0, 3);
if (number == 0)
convertedNumber += "t";
convertedNumber = convertedNumber.TrimEnd('e');
convertedNumber += "ième";
return convertedNumber;
}
public Noun GetNoun(GrammaticalGender? genre, int? categoryId, bool shallSupportSingular, bool shallSupportPlural)
{
List<Noun> searchResults = nouns.FindAll(p => (genre == null || p.Genre == genre)
&& (categoryId == null || p.Categories.Contains(categoryId ?? -1))
&& (!shallSupportPlural || p.CanBePlural)
&& (!shallSupportSingular || p.CanBeSingular));
if (searchResults == null || searchResults.Count < 1)
return null;
return searchResults[rnd.Next(0, searchResults.Count)];
}
/// <summary>
/// Turns a number into an ordinal number used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
/// Gender for Brazilian Portuguese locale
/// 1.Ordinalize(GrammaticalGender.Masculine) -> "1º"
/// 1.Ordinalize(GrammaticalGender.Feminine) -> "1ª"
/// </summary>
/// <param name="number">The number to be ordinalized</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <returns></returns>
public static string Ordinalize(this int number, GrammaticalGender gender)
{
return(Configurator.Ordinalizer.Convert(number, number.ToString(CultureInfo.InvariantCulture), gender));
}
private static string GetTens(long value, bool usePrefixMap, bool usePrefixMapForLowerDigits, GrammaticalGender gender)
{
if (value == 1 && gender == GrammaticalGender.Feminine)
{
return("waħda");
}
if (value < 11 && usePrefixMap && usePrefixMapForLowerDigits)
{
return(PrefixMap[value]);
}
if (value < 11 && usePrefixMap && !usePrefixMapForLowerDigits)
{
return(HundredsMap[value]);
}
if (value > 10 && value < 20 && usePrefixMap)
{
return(PrefixMap[value]);
}
if (value < 20)
{
return(UnitsMap[value]);
}
var single = value % 10;
var numberOfTens = value / 10;
if (single == 0)
{
return(TensMap[numberOfTens]);
}
return($"{UnitsMap[single]} u {TensMap[numberOfTens]}");
}
private static string GetHundreds(long value, bool usePrefixMap, bool usePrefixMapForLowerValueDigits, GrammaticalGender gender)
{
if (value < 100)
{
return(GetTens(value, usePrefixMap, usePrefixMapForLowerValueDigits, gender));
}
var tens = value % 100;
var numberOfHundreds = value / 100;
var hundredsText = string.Empty;
if (numberOfHundreds == 1)
{
hundredsText = "mija";
}
else if (numberOfHundreds == 2)
{
hundredsText = "mitejn";
}
else
{
hundredsText = HundredsMap[numberOfHundreds] + " mija";
}
if (tens == 0)
{
return(hundredsText);
}
return($"{hundredsText} u {GetTens(tens, usePrefixMap, usePrefixMapForLowerValueDigits, gender)}");
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
return(number.ToString(_culture));
}
/// <summary> /// Converts the number to string using the provided grammatical gender /// </summary> /// <param name="number"></param> /// <param name="gender"></param> /// <returns></returns> public abstract string Convert(long number, GrammaticalGender gender);
private static void CollectOrdinalParts(ICollection <string> parts, ref int number, int divisor, GrammaticalGender gender, string prefixedForm, params string[] forms)
{
if (number < divisor)
{
return;
}
var result = number / divisor;
number %= divisor;
if (number == 0)
{
if (result == 1)
{
parts.Add(prefixedForm);
}
else
{
parts.Add(GetPrefix(result) + prefixedForm);
}
}
else
{
CollectPartsUnderOneThousand(parts, result, gender);
parts.Add(ChooseOneForGrammaticalNumber(result, forms));
}
}
private string getPartByGender(string multiGenderPart, GrammaticalGender gender)
{
if (multiGenderPart.Contains("|"))
{
var parts = multiGenderPart.Split('|');
if (gender == GrammaticalGender.Feminine)
return parts[1];
else
return parts[0];
}
else
return multiGenderPart;
}
public virtual string Convert(int number, string numberString, GrammaticalGender gender)
{
return(Convert(number, numberString));
}
protected GenderedNumberToWordsConverter(GrammaticalGender defaultGender = GrammaticalGender.Masculine)
{
_defaultGender = defaultGender;
}
/// <summary> /// Converts the number to ordinal string using the provided grammatical gender /// </summary> /// <param name="number"></param> /// <param name="gender"></param> /// <returns></returns> public abstract string ConvertToOrdinal(int number, GrammaticalGender gender);
public void ToWordsWithGender(int number, string expected, GrammaticalGender gender)
{
Assert.Equal(expected, number.ToWords(gender));
}
private void CollectPartsUnderAThousand(ICollection <string> parts, int number, GrammaticalGender gender, bool pluralize)
{
CollectHundreds(parts, ref number, 100, "cent", pluralize);
if (number > 0)
{
CollectPartsUnderAHundred(parts, ref number, gender, pluralize);
}
}
public static string NumberToWords(int number, GrammaticalGender gender = GrammaticalGender.Masculine)
{
if (number == 0)
{
return("cero");
}
if (number < 0)
{
return(string.Format("menos {0}", NumberToWords(Math.Abs(number))));
}
var parts = new List <string>();
if ((number / 1000000000) > 0)
{
parts.Add(number / 1000000000 == 1
? "mil millones"
: string.Format("{0} mil millones", NumberToWords(number / 1000000000)));
number %= 1000000000;
}
if ((number / 1000000) > 0)
{
parts.Add(number / 1000000 == 1
? "un millón"
: string.Format("{0} millones", NumberToWords(number / 1000000)));
number %= 1000000;
}
if ((number / 1000) > 0)
{
parts.Add(number / 1000 == 1
? "mil"
: string.Format("{0} mil", NumberToWords(number / 1000, gender)));
number %= 1000;
}
if ((number / 100) > 0)
{
parts.Add(number == 100
? "cien"
: gender == GrammaticalGender.Feminine
? FeminineHundredsMap[(number / 100)]
: HundredsMap[(number / 100)]);
number %= 100;
}
if (number > 0)
{
if (number < 30)
{
if (gender == GrammaticalGender.Feminine && (number == 1 || number == 21))
{
parts.Add(number == 1 ? Feminine1 : Feminine21);
}
else
{
parts.Add(UnitsMap[number]);
}
}
else
{
var lastPart = TensMap[number / 10];
int units = number % 10;
if (units == 1 && gender == GrammaticalGender.Feminine)
{
lastPart += " y una";
}
else if (units > 0)
{
lastPart += string.Format(" y {0}", UnitsMap[number % 10]);
}
parts.Add(lastPart);
}
}
return(string.Join(" ", parts.ToArray()));
}
/// <inheritdoc /> public string Convert(long number, GrammaticalGender gender) => Transformer.Transform(Inner.Convert(number, gender));
public void ToWordsWithGender(int number, string expected, GrammaticalGender gender)
{
Assert.Equal(expected, number.ToWords(gender));
}
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
var cruncher = new ItalianOrdinalNumberCruncher(number, gender);
return(cruncher.Convert());
}
protected virtual void CollectPartsUnderAHundred(ICollection <string> parts, ref int number, GrammaticalGender gender, bool pluralize)
{
if (number < 20)
{
parts.Add(GetUnits(number, gender));
}
else
{
var units = number % 10;
var tens = GetTens(number / 10);
if (units == 0)
{
parts.Add(tens);
}
else if (units == 1)
{
parts.Add(tens);
parts.Add("et");
parts.Add(GetUnits(1, gender));
}
else
{
parts.Add($"{tens}-{GetUnits(units, gender)}");
}
}
}
/// <summary>
/// for Brazilian Portuguese locale
/// 1.ToOrdinalWords(GrammaticalGender.Masculine) -> "primeiro"
/// 1.ToOrdinalWords(GrammaticalGender.Feminine) -> "primeira"
/// </summary>
/// <param name="number">Number to be turned to words</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <returns></returns>
public static string ToOrdinalWords(this int number, GrammaticalGender gender)
{
return(Converter.ConvertToOrdinal(number, gender));
}
/// <inheritdoc /> public string ConvertToOrdinal(int number, GrammaticalGender gender) => Transformer.Transform(Inner.ConvertToOrdinal(number, gender));
public override string ConvertToOrdinal(int number, GrammaticalGender gender)
{
var parts = new List <string>();
if (number > 9999) // @mihemihe: Implemented only up to 9999 - Dec-2017
{
return(Convert(number, gender));
}
if (number < 0)
{
return(string.Format("menos {0}", Convert(Math.Abs(number))));
}
if (number == 0)
{
return(string.Format("cero"));
}
if ((number / 1000) > 0)
{
var thousandsPart = ThousandsMapOrdinal[(number / 1000)];
if (gender == GrammaticalGender.Feminine)
{
thousandsPart = thousandsPart.TrimEnd('o') + "a";
}
parts.Add(thousandsPart);
number %= 1000;
}
if ((number / 100) > 0)
{
var hundredsPart = HundredsMapOrdinal[(number / 100)];
if (gender == GrammaticalGender.Feminine)
{
hundredsPart = hundredsPart.TrimEnd('o') + "a";
}
parts.Add(hundredsPart);
number %= 100;
}
if ((number / 10) > 0)
{
var tensPart = TensMapOrdinal[(number / 10)];
if (gender == GrammaticalGender.Feminine)
{
tensPart = tensPart.TrimEnd('o') + "a";
}
parts.Add(tensPart);
number %= 10;
}
if (Ordinals.TryGetValue(number, out var towords))
{
if (gender == GrammaticalGender.Feminine)
{
towords = towords.TrimEnd('o') + "a";
}
else if (gender == GrammaticalGender.Neuter && (number == 1 || number == 3))
{
towords = towords.TrimEnd('o');
}
parts.Add(towords);
}
return(string.Join(" ", parts.ToArray()));
}
public override string Convert(long input, GrammaticalGender gender)
{
if (input > Int32.MaxValue || input < Int32.MinValue)
{
throw new NotImplementedException();
}
var number = (int)input;
if (number < 0)
{
return(string.Format("מינוס {0}", Convert(-number, gender)));
}
if (number == 0)
{
return(UnitsFeminine[0]);
}
var parts = new List <string>();
if (number >= (int)Group.Billions)
{
ToBigNumber(number, Group.Billions, parts);
number %= (int)Group.Billions;
}
if (number >= (int)Group.Millions)
{
ToBigNumber(number, Group.Millions, parts);
number %= (int)Group.Millions;
}
if (number >= (int)Group.Thousands)
{
ToThousands(number, parts);
number %= (int)Group.Thousands;
}
if (number >= (int)Group.Hundreds)
{
ToHundreds(number, parts);
number %= (int)Group.Hundreds;
}
if (number > 0)
{
var appendAnd = parts.Count != 0;
if (number <= 10)
{
var unit = gender == GrammaticalGender.Masculine ? UnitsMasculine[number] : UnitsFeminine[number];
if (appendAnd)
{
unit = "ו" + unit;
}
parts.Add(unit);
}
else if (number < 20)
{
var unit = Convert(number % 10, gender);
unit = unit.Replace("יי", "י");
unit = string.Format("{0} {1}", unit, gender == GrammaticalGender.Masculine ? "עשר" : "עשרה");
if (appendAnd)
{
unit = "ו" + unit;
}
parts.Add(unit);
}
else
{
var tenUnit = TensUnit[number / 10 - 1];
if (number % 10 == 0)
{
parts.Add(tenUnit);
}
else
{
var unit = Convert(number % 10, gender);
parts.Add(string.Format("{0} ו{1}", tenUnit, unit));
}
}
}
return(string.Join(" ", parts));
}
public override string Convert(long input, GrammaticalGender gender, bool addAnd = true)
{
if (input > Int32.MaxValue || input < Int32.MinValue)
{
throw new NotImplementedException();
}
var number = (int)input;
if (number == 0)
{
return("cero");
}
if (number < 0)
{
return(string.Format("menos {0}", Convert(Math.Abs(number))));
}
var parts = new List <string>();
if ((number / 1000000000) > 0)
{
parts.Add(number / 1000000000 == 1
? "mil millones"
: string.Format("{0} mil millones", Convert(number / 1000000000)));
number %= 1000000000;
}
if ((number / 1000000) > 0)
{
parts.Add(number / 1000000 == 1
? "un millón"
: string.Format("{0} millones", Convert(number / 1000000)));
number %= 1000000;
}
if ((number / 1000) > 0)
{
parts.Add(number / 1000 == 1
? "mil"
: string.Format("{0} mil", Convert(number / 1000, gender)));
number %= 1000;
}
if ((number / 100) > 0)
{
parts.Add(number == 100
? "cien"
: gender == GrammaticalGender.Feminine
? FeminineHundredsMap[(number / 100)]
: HundredsMap[(number / 100)]);
number %= 100;
}
if (number > 0)
{
if (number < 30)
{
if (gender == GrammaticalGender.Feminine && (number == 1 || number == 21))
{
parts.Add(number == 1 ? Feminine1 : Feminine21);
}
else
{
parts.Add(UnitsMap[number]);
}
}
else
{
var lastPart = TensMap[number / 10];
var units = number % 10;
if (units == 1 && gender == GrammaticalGender.Feminine)
{
lastPart += " y una";
}
else if (units > 0)
{
lastPart += string.Format(" y {0}", UnitsMap[number % 10]);
}
parts.Add(lastPart);
}
}
return(string.Join(" ", parts.ToArray()));
}
private static string GetPrefixText(long thousands, long tensInThousands, string singular, string dual, string plural, bool usePrefixMapForLowerValueDigits, GrammaticalGender gender)
{
if (thousands == 1)
{
return(singular);
}
if (thousands == 2)
{
return(dual);
}
if (tensInThousands > 10)
{
return($"{GetHundreds(thousands, true, usePrefixMapForLowerValueDigits, gender)} {singular}");
}
if (thousands == 100)
{
return($"mitt {singular}");
}
if (thousands == 101)
{
return($"mija u {singular}");
}
return($"{GetHundreds(thousands, true, usePrefixMapForLowerValueDigits, gender)} {plural}");
}
/// <summary>
/// Converts the specified input.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="gender">The gender.</param>
/// <returns>System.String.</returns>
/// <exception cref="NotImplementedException"></exception>
public override string Convert(long input, GrammaticalGender gender)
{
if (input > Int32.MaxValue || input < Int32.MinValue)
{
throw new NotImplementedException();
}
var number = (int)input;
if (number == 0)
{
return("zero");
}
if (number < 0)
{
return(string.Format("menos {0}", Convert(Math.Abs(number), gender)));
}
var parts = new List <string>();
if ((number / 1000000000) > 0)
{
// gender is not applied for billions
parts.Add(number / 1000000000 >= 2
? string.Format("{0} bilhões", Convert(number / 1000000000, GrammaticalGender.Masculine))
: string.Format("{0} bilhão", Convert(number / 1000000000, GrammaticalGender.Masculine)));
number %= 1000000000;
}
if ((number / 1000000) > 0)
{
// gender is not applied for millions
parts.Add(number / 1000000 >= 2
? string.Format("{0} milhões", Convert(number / 1000000, GrammaticalGender.Masculine))
: string.Format("{0} milhão", Convert(number / 1000000, GrammaticalGender.Masculine)));
number %= 1000000;
}
if ((number / 1000) > 0)
{
// gender is not applied for thousands
parts.Add(number / 1000 == 1 ? "mil" : string.Format("{0} mil", Convert(number / 1000, GrammaticalGender.Masculine)));
number %= 1000;
}
if ((number / 100) > 0)
{
if (number == 100)
{
parts.Add(parts.Count > 0 ? "e cem" : "cem");
}
else
{
// Gender is applied to hundreds starting from 200
parts.Add(ApplyGender(PortugueseHundredsMap[(number / 100)], gender));
}
number %= 100;
}
if (number > 0)
{
if (parts.Count != 0)
{
parts.Add("e");
}
if (number < 20)
{
parts.Add(ApplyGender(PortugueseUnitsMap[number], gender));
}
else
{
var lastPart = PortugueseTensMap[number / 10];
if ((number % 10) > 0)
{
lastPart += string.Format(" e {0}", ApplyGender(PortugueseUnitsMap[number % 10], gender));
}
parts.Add(lastPart);
}
}
return(string.Join(" ", parts.ToArray()));
}
/// <summary>
/// Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
/// Gender for Brazilian Portuguese locale
/// 1.Ordinalize(GrammaticalGender.Masculine) -> "1º"
/// 1.Ordinalize(GrammaticalGender.Feminine) -> "1ª"
/// </summary>
/// <param name="numberString">The number, in string, to be ordinalized</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <returns></returns>
public static string Ordinalize(this string numberString, GrammaticalGender gender)
{
return(Configurator.Ordinalizer.Convert(int.Parse(numberString), numberString, gender));
}
/// <summary>
/// Collects the parts under a hundred.
/// </summary>
/// <param name="parts">The parts.</param>
/// <param name="number">The number.</param>
/// <param name="gender">The gender.</param>
/// <param name="pluralize">if set to <c>true</c> [pluralize].</param>
protected override void CollectPartsUnderAHundred(ICollection <string> parts, ref int number, GrammaticalGender gender, bool pluralize)
{
if (number == 71)
{
parts.Add("soixante et onze");
}
else if (number == 80)
{
parts.Add(pluralize ? "quatre-vingts" : "quatre-vingt");
}
else if (number >= 70)
{
var @base = number < 80 ? 60 : 80;
int units = number - @base;
var tens = @base / 10;
parts.Add($"{GetTens(tens)}-{GetUnits(units, gender)}");
}
else
{
base.CollectPartsUnderAHundred(parts, ref number, gender, pluralize);
}
}
/// <summary>
/// for Brazilian Portuguese
/// 1.ToOrdinalWords(GrammaticalGender.Masculine) -> "primeiro"
/// 1.ToOrdinalWords(GrammaticalGender.Feminine) -> "primeira"
/// </summary>
/// <param name="number">Number to be turned to words</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <returns></returns>
public virtual string ConvertToOrdinal(int number, GrammaticalGender gender)
{
return(ConvertToOrdinal(number));
}
private static void CollectPartsUnderOneThousand(ICollection <string> parts, int number, GrammaticalGender gender)
{
if (number >= 100)
{
var hundreds = number / 100;
number %= 100;
parts.Add(HundredsMap[hundreds]);
}
if (number >= 20)
{
var tens = number / 10;
parts.Add(TensMap[tens]);
number %= 10;
}
if (number > 0)
{
if (number == 1 && gender == GrammaticalGender.Feminine)
{
parts.Add("одна");
}
else if (number == 1 && gender == GrammaticalGender.Neuter)
{
parts.Add("одно");
}
else if (number == 2 && gender == GrammaticalGender.Feminine)
{
parts.Add("две");
}
else if (number < 20)
{
parts.Add(UnitsMap[number]);
}
}
}
public Noun GetNounEx(GrammaticalGender? genre, List<int> categoryIds, bool shallSupportSingular, bool shallSupportPlural)
{
List<Noun> searchResults = nouns.FindAll(p => (genre == null || p.Genre == genre)
&& (categoryIds == null || categoryIds.Count == 0 || p.Categories.Exists(d => categoryIds.Contains(d)))
&& (!shallSupportSingular || p.CanBeSingular));
if (searchResults == null || searchResults.Count < 1)
return null;
return searchResults[rnd.Next(0, searchResults.Count)];
}
private static void CollectParts(ICollection <string> parts, ref int number, int divisor, GrammaticalGender gender, params string[] forms)
{
if (number < divisor)
{
return;
}
var result = number / divisor;
number %= divisor;
CollectPartsUnderOneThousand(parts, result, gender);
parts.Add(ChooseOneForGrammaticalNumber(result, forms));
}
/// <summary>
/// For locales that support gender-specific forms
/// </summary>
/// <example>
/// Russian:
/// <code>
/// 1.ToWords(GrammaticalGender.Masculine) -> "один"
/// 1.ToWords(GrammaticalGender.Feminine) -> "одна"
/// </code>
/// Hebrew:
/// <code>
/// 1.ToWords(GrammaticalGender.Masculine) -> "אחד"
/// 1.ToWords(GrammaticalGender.Feminine) -> "אחת"
/// </code>
/// </example>
///
/// <param name="number">Number to be turned to words</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <param name="culture">Culture to use. If null, current thread's UI culture is used.</param>
/// <returns></returns>
public static string ToWords(this int number, GrammaticalGender gender, CultureInfo culture = null)
{
return(((long)number).ToWords(gender, culture));
}
public void ToOrdinalWords(int number, string words, GrammaticalGender gender)
{
Assert.Equal(words, number.ToOrdinalWords(gender));
}
public string Convert(int number, GrammaticalGender gender)
{
// it's easier to treat zero as a completely distinct case
if (number == 0)
return "zero";
else if (number == 1)
// no prefixes for primul/prima
return this.getPartByGender(_ordinalsUnder10[number], gender);
else if (number <= 9)
// units ordinals, 2 to 9, are totally different than the rest: treat them as a distinct case
return string.Format("{0} {1}",
gender == GrammaticalGender.Feminine ? _femininePrefix : _masculinePrefix,
this.getPartByGender(_ordinalsUnder10[number], gender)
);
else
{
var coverter = new RomanianCardinalNumberConverter();
var words = coverter.Convert(number, gender);
// remove 'de' preposition
words = words.Replace(" de ", " ");
if ((gender == GrammaticalGender.Feminine) && words.EndsWith("zeci"))
{
words = words.Substring(0, words.Length - 4) + "zece";
}
else if ((gender == GrammaticalGender.Feminine) && words.Contains("zeci") && (words.Contains("milioane") || words.Contains("miliarde")))
{
words = words.Replace("zeci", "zecea");
}
if ((gender == GrammaticalGender.Feminine) && words.StartsWith("un "))
{
words = words.Substring(2).TrimStart();
}
if (words.EndsWith("milioane"))
{
if (gender == GrammaticalGender.Feminine)
words = words.Substring(0, words.Length - 8) + "milioana";
}
var customMasculineSuffix = _masculineSuffix;
if (words.EndsWith("milion"))
{
if (gender == GrammaticalGender.Feminine)
words = words.Substring(0, words.Length - 6) + "milioana";
else
customMasculineSuffix = "u" + _masculineSuffix;
}
else if (words.EndsWith("miliard"))
{
if (gender == GrammaticalGender.Masculine)
customMasculineSuffix = "u" + _masculineSuffix;
}
// trim last letter
if ((gender == GrammaticalGender.Feminine) && (!words.EndsWith("zece") &&
(words.EndsWith("a") ||
words.EndsWith("ă") ||
words.EndsWith("e") ||
words.EndsWith("i"))))
{
words = words.Substring(0, words.Length - 1);
}
return string.Format("{0} {1}{2}",
gender == GrammaticalGender.Feminine ? _femininePrefix : _masculinePrefix,
words,
gender == GrammaticalGender.Feminine ? _feminineSuffix : customMasculineSuffix
);
}
}
/// <summary>
/// For locales that support gender-specific forms
/// </summary>
/// <example>
/// Russian:
/// <code>
/// 1.ToWords(GrammaticalGender.Masculine) -> "один"
/// 1.ToWords(GrammaticalGender.Feminine) -> "одна"
/// </code>
/// Hebrew:
/// <code>
/// 1.ToWords(GrammaticalGender.Masculine) -> "אחד"
/// 1.ToWords(GrammaticalGender.Feminine) -> "אחת"
/// </code>
/// </example>
///
/// <param name="number">Number to be turned to words</param>
/// <param name="gender">The grammatical gender to use for output words</param>
/// <param name="culture">Culture to use. If null, current thread's UI culture is used.</param>
/// <returns></returns>
public static string ToWords(this long number, GrammaticalGender gender, CultureInfo culture = null)
{
return(Configurator.GetNumberToWordsConverter(culture).Convert(number, gender));
}
