Closes #58

TestTranslatorCpp/english_test.cpp

@@ -86,6 +86,47 @@ namespace TranslatorTest
  }
  }
 
+ TEST_METHOD(english_numbers_to_1000)
+ {
+ for (int i = 0; i < 1000; i++)
+ Assert::IsTrue(English::number(i) != "");
+ }
+
+ TEST_METHOD(english_numbers)
+ {
+ Assert::AreEqual("zero", English::number(0).c_str());
+ Assert::AreEqual("one", English::number(1).c_str());
+ Assert::AreEqual("two", English::number(2).c_str());
+
+ Assert::AreEqual("ten", English::number(10).c_str());
+ Assert::AreEqual("eleven", English::number(11).c_str());
+ Assert::AreEqual("twelve", English::number(12).c_str());
+ Assert::AreEqual("thirteen", English::number(13).c_str());
+
+ Assert::AreEqual("twenty", English::number(20).c_str());
+ Assert::AreEqual("twenty-one", English::number(21).c_str());
+
+ Assert::AreEqual("thirty", English::number(30).c_str());
+ Assert::AreEqual("thirty-two", English::number(32).c_str());
+
+ Assert::AreEqual("forty", English::number(40).c_str());
+ Assert::AreEqual("fifty", English::number(50).c_str());
+ Assert::AreEqual("eighty", English::number(80).c_str());
+
+ //100:
+ Assert::AreEqual("one hundred", English::number(100).c_str());
+ Assert::AreEqual("one hundred and one", English::number(101).c_str());
+ Assert::AreEqual("one hundred and ten", English::number(110).c_str());
+ Assert::AreEqual("one hundred and twenty-two", English::number(122).c_str());
+
+ //200:
+ Assert::AreEqual("two hundred", English::number(200).c_str());
+ Assert::AreEqual("two hundred and fifty", English::number(250).c_str());
+
+ //999:
+ Assert::AreEqual("nine hundred and ninety-nine", English::number(999).c_str());
+ }
+
  TEST_METHOD(check_some_noun_forms)
  {
  check<English>("women", "woman", attr_t::plur);

TestTranslatorCpp/serbian_test.cpp

@@ -362,6 +362,48 @@ namespace TranslatorTest
  Assert::AreEqual<int>(6230, count);
  }
 
+ TEST_METHOD(serbian_numbers_to_1000)
+ {
+ for (int i = 0; i < 1000; i++)
+ {
+ test_output << i << ": " << Serbian::number(i) << std::endl;
+ Assert::IsTrue(Serbian::number(i) != L"");
+ }
+ }
+
+ TEST_METHOD(serbian_numbers)
+ {
+ Assert::AreEqual(L"нула", Serbian::number(0).c_str());
+ Assert::AreEqual(L"један", Serbian::number(1).c_str());
+ Assert::AreEqual(L"два", Serbian::number(2).c_str());
+
+ //10:
+ Assert::AreEqual(L"десет", Serbian::number(10).c_str());
+ Assert::AreEqual(L"једанаест", Serbian::number(11).c_str());
+ Assert::AreEqual(L"дванаест", Serbian::number(12).c_str());
+ Assert::AreEqual(L"четрнаест", Serbian::number(14).c_str());
+
+ //20:
+ Assert::AreEqual(L"двадесет", Serbian::number(20).c_str());
+ Assert::AreEqual(L"двадесет један", Serbian::number(21).c_str());
+
+ //30:
+ Assert::AreEqual(L"тридесет", Serbian::number(30).c_str());
+ Assert::AreEqual(L"тридесет два", Serbian::number(32).c_str());
+
+ //90:
+ Assert::AreEqual(L"деведесет један", Serbian::number(91).c_str());
+
+ //100:
+ Assert::AreEqual(L"сто", Serbian::number(100).c_str());
+ Assert::AreEqual(L"сто један", Serbian::number(101).c_str());
+ Assert::AreEqual(L"сто десет", Serbian::number(110).c_str());
+ Assert::AreEqual(L"сто двадесет два", Serbian::number(122).c_str());
+
+ //999:
+ Assert::AreEqual(L"деветсто деведесет девет", Serbian::number(999).c_str());
+ }
+
  TEST_METHOD(random_test)
  {
  for (int i = 0; i < 100; i++)

TranslatorCpp/Languages/English.cpp

@@ -177,6 +177,96 @@ const std::vector<translator::word_rule<English>> ENGLISH_BASE::word_rules
  { { "*" },{ "*" }, pron, { nom } },
 };
 
+std::string _number10(int n)
+{
+ if (n == 0)
+ return "";
+
+ ASSERT(n < 10);
+ switch (n)
+ {
+ case 1: return "one";
+ case 2: return "two";
+ case 3: return "three";
+ case 4: return "four";
+ case 5: return "five";
+ case 6: return "six";
+ case 7: return "seven";
+ case 8: return "eight";
+ case 9: return "nine";
+ case 10: return "ten";
+ default:
+ ASSERT(false);
+ }
+}
+
+std::string _number20(int n)
+{
+ ASSERT(n < 20);
+ if (n < 10)
+ return _number10(n);
+
+ if (n >= 16)
+ return _number10(n - 10) + "teen";
+
+ switch (n)
+ {
+ case 10: return "ten";
+ case 11: return "eleven";
+ case 12: return "twelve";
+ case 13: return "thirteen";
+ case 14: return "fourteen";
+ case 15: return "fifteen";
+ default:
+ ASSERT(false);
+ }
+}
+
+std::string _number100(int n)
+{
+ if (n < 20) return _number20(n);
+
+ int n1 = n % 10;
+ int n10 = n / 10;
+
+ std::string ty;
+ switch (n10)
+ {
+ case 2: ty = "twenty"; break;
+ case 3: ty = "thirty"; break;
+ case 4: ty = "forty"; break;
+ case 5: ty = "fifty"; break;
+ case 8: ty = "eighty"; break;
+ default:
+ ty = _number10(n / 10) + "ty";
+ }
+ if (n1 == 0)
+ return ty;
+
+ return ty + "-" + _number10(n % 10);
+}
+
+std::string _number1000(int n)
+{
+ if (n < 100) return _number100(n);
+
+ return _number10(n / 100) + " hundred" + (n%100==0 ? "" : " and " + _number100(n % 100));
+}
+
+std::string ENGLISH_BASE::number(int n)
+{
+ if (n == 0)
+ return "zero";
+
+ return _number1000(n);
+}
+
+std::string ordinal_number(int n)
+{
+ //"*one" -> "*first";
+ return _number100(n);
+}
+
 const std::vector<translator::word_to_word_rule<English>> ENGLISH_BASE::word_to_word_rules
 {
  {"*", "*ly", adj, adv, {} },

TranslatorCpp/Languages/Serbian.cpp

@@ -37,6 +37,75 @@ std::vector<translator::dictionary_word<Serbian>> SERBIAN_BASE::_dictWords
 #include "Serbian_words.h"
 };
 
+std::wstring _number10(int n)
+{
+ switch (n)
+ {
+ case 0: return L"";
+ case 1: return L"један";
+ case 2: return L"два";
+ case 3: return L"три";
+ case 4: return L"четири";
+ case 5: return L"пет";
+ case 6: return L"шест";
+ case 7: return L"седам";
+ case 8: return L"осам";
+ case 9: return L"девет";
+ case 10: return L"десет";
+ default:
+ ASSERT(false);
+ }
+}
+
+std::wstring _number20(int n)
+{
+ if (n <= 10)
+ return _number10(n);
+ switch (n)
+ {
+ case 11: return L"једанаест";
+ case 14: return L"четрнаест";
+ }
+
+ return _number10(n - 10) + L"наест"; 
+}
+
+std::wstring _number100(int n)
+{
+ if (n < 20) return _number20(n);
+ std::wstring st10;
+ switch (n / 10)
+ {
+ case 9: st10 = L"деведесет"; break;
+ default: st10 = _number10(n / 10) + L"десет";
+ }
+
+ return st10 + (n%10 == 0 ? L"" : L" " + _number10(n % 10));
+}
+
+std::wstring _number1000(int n)
+{
+ if (n < 100)
+ return _number100(n);
+
+ if (n == 100)
+ return L"сто";
+
+ if (n < 200)
+ return L"сто " + _number100(n - 100);
+
+ int n100 = n / 100;
+ return _number10(n100) + (n100 < 4 ? L"ста " : L"сто ") + _number100(n % 100);
+}
+
+std::wstring SERBIAN_BASE::number(int n)
+{
+ if (n == 0)
+ return L"нула";
+
+ return _number1000(n);
+}
+
 const std::vector<translator::word_rule<Serbian>> SERBIAN_BASE::word_rules
 {
 #include "Serbian_word_rules.h"

TranslatorCpp/language.h

@@ -202,6 +202,8 @@ namespace translator
  return _dictWords;
  }
 
+ static string_t number(int n);
+
  static const std::vector<word_to_word_rule<Lang>> word_to_word_rules;
 
  static const std::vector<rule<Lang>> grammar_rules;