react-native-executorch 0.10.6 → 0.10.7

package/third-party/common/phonemis/src/phonemis/lang/de/num2word.cpp

@@ -1,393 +1,439 @@
-#include "num2word.h"
 #include "constants.h"
-#include <phonemis/base/processor/constants.h>
-#include <phonemis/utils/conversions.h>
+#include "num2word.h"
+#include "patterns.h"
+#include <phonemis/base/processor/layers/num2word/numerals.h>
+#include <phonemis/base/processor/layers/num2word/patterns.h>
+#include <phonemis/base/processor/layers/num2word/primitives.h>
+#include <phonemis/utils/strings.h>
 #include <phonemis/utils/unicode.h>
-#include <algorithm>
-#include <cctype>
-#include <cmath>
-#include <cstdlib>
+
+#include <array>
 
 namespace phonemis::de {
 
-using namespace constants;
-using namespace phonemis::utils;
-using processor::num2word::Mode;
-using processor::num2word::StringifiedNumber;
+using namespace constants::num2word;
+using namespace processor;
+using namespace processor::num2word;
+using namespace utils;
 
 namespace {
-// Checks if a character serves as a word boundary.
-bool is_boundary(char32_t c) {
-  return !utils::unicode::isalnum(c) && c != U'_';
+uint64_t value(const Number& number) {
+  return value_of(number.integer).value_or(0);
 }
 
-// Counts and returns the number of consecutive digits from the start index
-size_t count_digits(std::u32string_view input, size_t start) {
-  auto it = std::find_if(
-      input.begin() + start, input.end(),
-      [](char32_t c) { return !utils::unicode::isdigit(c); });
-  return static_cast<size_t>(it - (input.begin() + start));
+// ------------------------
+// ----- Number words -----
+// ------------------------
+
+std::u32string cardinal(uint64_t n);
+
+// A cardinal as the first part of a compound: ein, einundzwanzig, einhundertein
+std::u32string stem(uint64_t n) {
+  std::u32string words = cardinal(n);
+  return words.ends_with(U"eins") ? words.substr(0, words.size() - 1) : words;
 }
 
-// Checks if a character is a known currency symbol.
-bool is_currency(char32_t c) {
-  for (auto sym : processor::constants::kCurrencies) {
-    if (c == sym) return true;
+std::u32string cardinal(uint64_t n) {
+  if (n < 20) {
+    return std::u32string(kOnes[n]);
+  }
+  if (n < 100) {
+    return (n % 10 ? stem(n % 10) + U"und" : U"") + std::u32string(kTens[n / 10]);
+  }
+  if (n < 1000) {
+    return stem(n / 100) + U"hundert" + (n % 100 ? cardinal(n % 100) : U"");
+  }
+  if (n < 1000000) {
+    return stem(n / 1000) + U"tausend" + (n % 1000 ? cardinal(n % 1000) : U"");
+  }
+  for (auto [scale, one, many] :
+       {std::tuple{1000000000ULL, U"Milliarde", U"Milliarden"}, std::tuple{1000000ULL, U"Million", U"Millionen"}}) {
+    if (n >= scale) {
+      uint64_t q = n / scale, r = n % scale;
+      std::u32string head = q == 1 ? U"eine " + std::u32string(one) : cardinal(q) + U" " + std::u32string(many);
+      return head + (r ? U" " + cardinal(r) : U"");
+    }
   }
-  return false;
+  return U"";
 }
 
-bool has_nominative_article(std::u32string_view input, size_t start) {
-  size_t pos = start;
-  while (pos > 0 && utils::unicode::isspace(input[pos - 1])) {
-    pos--;
+// 1100-1999 in hundreds (neunzehnhundertneunzig); later years read like cardinals
+std::u32string year(uint64_t n) {
+  if (n >= 1100 && n <= 1999) {
+    return cardinal(n / 100) + U"hundert" + (n % 100 ? cardinal(n % 100) : U"");
   }
-  size_t end = pos;
-  while (pos > 0 && utils::unicode::isalpha(input[pos - 1])) {
-    pos--;
+  return cardinal(n);
+}
+
+std::u32string ordinal(uint64_t n, std::u32string_view ending) {
+  std::u32string words = cardinal(n);
+  uint64_t r = n % 100;
+  if (r > 0 && r < 20) {
+    std::u32string one(kOnes[r]);
+    auto it = kOrdinalStems.find(one);
+    std::u32string base = words.substr(0, words.size() - one.size());
+    return base + (it != kOrdinalStems.end() ? it->second : one) + U"t" + std::u32string(ending);
   }
-  if (pos == end) return false;
+  return words + U"st" + std::u32string(ending);
+}
 
-  std::u32string word(input.substr(pos, end - pos));
-  for (auto& ch : word) {
-    ch = utils::unicode::tolower(ch);
+std::u32string digits(std::u32string_view text) {
+  std::vector<std::u32string> words;
+  for (char32_t c : text) {
+    words.emplace_back(kOnes[c - U'0']);
   }
+  return join(words);
+}
 
-  return word == U"der" || word == U"die" || word == U"das" ||
-         word == U"ein" || word == U"eine";
+// "1" said like an article, by case and gender: eine Stunde, mit einem Mal
+std::u32string article(Case c, Gender g) {
+  static const std::array<std::array<std::u32string_view, 3>, 4> forms = {{
+      {U"ein", U"eine", U"ein"},      // Nominative
+      {U"eines", U"einer", U"eines"}, // Genitive
+      {U"einem", U"einer", U"einem"}, // Dative
+      {U"einen", U"eine", U"ein"},    // Accusative
+  }};
+  size_t row = c == Case::GENITIVE ? 1 : c == Case::DATIVE ? 2 : c == Case::ACCUSATIVE ? 3 : 0;
+  return std::u32string(forms[row][static_cast<size_t>(g)]);
 }
-} // namespace
 
-std::u32string Num2Word::transform(std::u32string_view input) const {
-  char32_t dec_sep = decimal_separator();
-  std::u32string owned;
-  std::u32string_view work = input;
-  if (dec_sep != U'.') {
-    owned.reserve(input.size());
-    for (size_t i = 0; i < input.size(); ++i) {
-      if (input[i] == dec_sep && i > 0 && i + 1 < input.size() &&
-          utils::unicode::isdigit(input[i - 1]) && utils::unicode::isdigit(input[i + 1])) {
-        owned.push_back(U'.');
-      } else {
-        owned.push_back(input[i]);
-      }
-    }
-    work = owned;
+// The adjective ending of an ordinal: am dritten, der dritte, ein zweiter, dritter
+std::u32string_view ending(const NumberReading& reading) {
+  static const std::array<std::array<std::u32string_view, 3>, 4> strong = {{
+      {U"er", U"e", U"es"},  // Nominative
+      {U"en", U"er", U"en"}, // Genitive
+      {U"em", U"er", U"em"}, // Dative
+      {U"en", U"e", U"es"},  // Accusative
+  }};
+  switch (reading.declension) {
+    case Declension::WEAK:
+      return reading.grammatical_case == Case::NOMINATIVE ? U"e" : U"en";
+    case Declension::MIXED:
+      return reading.gender == Gender::NEUTER ? U"es" : U"er";
+    default:
+      Case c = reading.grammatical_case;
+      size_t row = c == Case::GENITIVE ? 1 : c == Case::DATIVE ? 2 : c == Case::ACCUSATIVE ? 3 : 0;
+      return strong[row][static_cast<size_t>(reading.gender)];
   }
+}
 
-  std::u32string result;
-  result.reserve(work.size());
-
-  size_t last_pos = 0;
-  for (size_t i = 0; i < work.size(); ++i) {
-    if (!utils::unicode::isdigit(work[i])) continue;
-    if (i > 0 && !is_boundary(work[i - 1])) continue;
-
-    size_t start = i;
-    size_t len = 0;
-    Mode mode = Mode::CARDINAL;
-
-    size_t p1 = count_digits(work, start);
-    size_t curr = start + p1;
-
-    if (curr < work.size() && (work[curr] == U'.' || work[curr] == U'-' || work[curr] == U'/')) {
-      char32_t sep = work[curr];
-      size_t p2 = count_digits(work, curr + 1);
-
-      if (p2 > 0) {
-        size_t next_curr = curr + 1 + p2;
-
-        if (next_curr < work.size() && work[next_curr] == sep && (sep == U'.' || sep == U'-')) {
-          size_t p3 = count_digits(work, next_curr + 1);
-          if (p3 > 0 &&
-              (next_curr + 1 + p3 == work.size() || is_boundary(work[next_curr + 1 + p3]))) {
-            if (p1 <= 4 && p2 <= 2 && p3 <= 4) {
-              len = next_curr + 1 + p3 - start;
-              mode = Mode::DATE;
-            }
-          }
-        }
+// -------------------
+// ----- Context -----
+// -------------------
 
-        if (len == 0 && (curr + 1 + p2 == work.size() || is_boundary(work[curr + 1 + p2]))) {
-          len = curr + 1 + p2 - start;
-          size_t after = start + len;
-          if (sep != U'/' && after < work.size() && is_currency(work[after]) &&
-              (after + 1 == work.size() || is_boundary(work[after + 1]))) {
-            len++;
-            mode = Mode::CURRENCY;
-          } else {
-            mode = (sep == U'/') ? Mode::FRACTION : Mode::CARDINAL;
-          }
-        }
-      } else if (sep == U'.') {
-        len = p1 + 1;
-        mode = Mode::ORDINAL;
+Gender gender_of(std::u32string_view noun) {
+  std::u32string word = strings::to_lower(noun);
 
-        size_t next_pos = start + len;
-        while (next_pos < work.size() && utils::unicode::isspace(work[next_pos])) {
-          next_pos++;
-        }
-        bool next_is_word = (next_pos < work.size()) && utils::unicode::isalpha(work[next_pos]);
-        if (!config_.allow_general_ord_notation || !next_is_word) {
-          mode = Mode::CARDINAL;
-          len--;
-        }
-      }
+  // The longest known ending decides, then the regular ones
+  size_t longest = 0;
+  Gender gender = Gender::MASCULINE;
+  for (const auto& [key, key_gender] : kGenders) {
+    if (key.size() > longest && word.ends_with(key)) {
+      longest = key.size();
+      gender = key_gender;
     }
+  }
+  if (longest > 0) {
+    return gender;
+  }
 
-    if (len == 0) {
-      if (curr < work.size() && is_currency(work[curr]) &&
-          (curr + 1 == work.size() || is_boundary(work[curr + 1]))) {
-        len = p1 + 1;
-        mode = Mode::CURRENCY;
-      } else {
-        size_t alpha = 0;
-        while (curr + alpha < work.size() && utils::unicode::isalpha(work[curr + alpha])) {
-          alpha++;
-        }
-
-        if (alpha > 0 && (curr + alpha == work.size() || is_boundary(work[curr + alpha]))) {
-          len = p1 + alpha;
-          mode = Mode::POTENTIALLY_ORDINAL;
-        } else if (curr == work.size() || is_boundary(work[curr])) {
-          len = p1;
-          mode = Mode::CARDINAL;
-        }
-      }
-    }
+  auto ends_with_any = [&](const std::vector<std::u32string>& endings) {
+    return std::ranges::any_of(endings, [&](const auto& e) { return word.ends_with(e); });
+  };
+  return ends_with_any(kFeminineEndings) ? Gender::FEMININE :
+         ends_with_any(kNeuterEndings)   ? Gender::NEUTER :
+                                           Gender::MASCULINE;
+}
 
-    if (len > 0) {
-      result.append(work.substr(last_pos, start - last_pos));
-
-      if (mode == Mode::DATE) {
-        char32_t sep = (work.substr(start, len).find(U'.') != std::u32string_view::npos) ? U'.' : U'-';
-        size_t first_sep = work.find(sep, start);
-        size_t second_sep = work.find(sep, first_sep + 1);
-
-        std::u32string_view p1 = work.substr(start, first_sep - start);
-        std::u32string_view p2 = work.substr(first_sep + 1, second_sep - first_sep - 1);
-        std::u32string_view p3 = work.substr(second_sep + 1, start + len - second_sep - 1);
-
-        auto val1 = as_int(p1);
-        auto val2 = as_int(p2);
-        auto val3 = as_int(p3);
-
-        if (!val1 || !val2 || !val3) {
-          result.append(work.substr(start, len));
-        } else {
-          bool nominative = has_nominative_article(work, start);
-          std::u32string day_word;
-
-          if (p1.size() == 4) {
-            day_word = to_ordinal_int(static_cast<int32_t>(*val3), nominative ? U"e" : U"en");
-            result.append(day_word + U" " + to_month(*val2) + U" " + to_year(*val1));
-          } else {
-            day_word = to_ordinal_int(static_cast<int32_t>(*val1), nominative ? U"e" : U"en");
-            result.append(day_word + U" " + to_month(*val2) + U" " + to_year(*val3));
-          }
-        }
-      } else {
-        result.append(verbalize({work.substr(start, len), mode}));
-      }
+Case case_after(std::u32string_view word) {
+  std::u32string w(word);
+  return kDative.contains(w)     ? Case::DATIVE :
+         kAccusative.contains(w) ? Case::ACCUSATIVE :
+         kGenitive.contains(w)   ? Case::GENITIVE :
+                                   Case::NOMINATIVE;
+}
 
-      last_pos = start + len;
-      i = start + len - 1;
-    }
-  }
+bool capitalized(std::u32string_view word) {
+  return !word.empty() && unicode::isupper(word[0]);
+}
 
-  result.append(work.substr(last_pos));
-  return result;
+bool all_digits(std::u32string_view word) {
+  return !word.empty() && std::ranges::all_of(word, unicode::isdigit);
 }
 
-std::u32string Num2Word::to_cardinal_int(int32_t value) const {
-  if (value < 0) {
-    return U"minus " + to_cardinal_int(std::abs(value));
-  }
+// A number right after a capitalized noun is its label: Seite 1, Platz 1
+bool labelled(const Context& context) {
+  auto head = words_of(context.head());
+  return !head.empty() && capitalized(head.back()) &&
+         !(head.size() == 1 || strings::contains(std::u32string_view(U".!?"), head[head.size() - 2].back()));
+}
 
-  if (value < 20) {
-    return num2word::kCardinals.at(value);
+// The ending of an ordinal from the words before it, and the noun it qualifies.
+void resolve_ending(const Context& context, std::u32string_view noun, NumberReading& reading) {
+  std::vector<std::u32string> before;
+  for (auto word : words_of(context.head())) {
+    before.push_back(strings::to_lower(stripped(word)));
   }
 
-  if (value < 100) {
-    int32_t units = value % 10;
-    int32_t tens = (value / 10) * 10;
-    if (units == 0) {
-        return num2word::kCardinals.at(tens);
+  // "in 2. und 3. Lesung", "vom 1. 5. bis 3. 5.": both take the ending of the first
+  static const std::array<std::u32string_view, 4> joining = {U"und", U"oder", U"bis", U"sowie"};
+  while (before.size() >= 2 && std::ranges::find(joining, before.back()) != joining.end() &&
+         all_digits(before[before.size() - 2])) {
+    before.resize(before.size() - 2);
+    while (!before.empty() && all_digits(before.back())) {
+      before.pop_back();
     }
-    std::u32string unit_str = (units == 1) ? U"ein" : num2word::kCardinals.at(units);
-    return unit_str + U"und" + num2word::kCardinals.at(tens);
   }
+  std::u32string w1 = before.empty() ? U"" : before.back();
+  std::u32string w2 = before.size() < 2 ? U"" : before[before.size() - 2];
+
+  reading.gender = gender_of(noun);
+  if (kWeak.contains(w1) || (w1 == U"der" && (kDative.contains(w2) || kGenitive.contains(w2)))) {
+    reading.declension = Declension::WEAK;
+    reading.grammatical_case = Case::DATIVE;
+  } else if (kWeakNominative.contains(w1)) {
+    reading.declension = Declension::WEAK;
+    reading.grammatical_case = Case::NOMINATIVE;
+  } else if (kMixed.contains(w1)) {
+    reading.declension = Declension::MIXED;
+  } else {
+    reading.declension = Declension::STRONG;
+    reading.grammatical_case = case_after(w1);
+  }
+}
+} // namespace
 
-  for (auto it = num2word::kLargeCardinals.rbegin(); it != num2word::kLargeCardinals.rend(); ++it) {
-    int64_t base = it->first;
-    if (static_cast<int64_t>(value) >= base) {
-      int32_t high = value / static_cast<int32_t>(base);
-      int32_t low = value % static_cast<int32_t>(base);
-
-      std::u32string head;
-      if (high == 1) {
-          head = (base >= 1000000LL) ? U"eine " : U"ein";
-      } else {
-          head = to_cardinal_int(high);
-          if (base >= 1000000LL) {
-              head += U" ";
-          }
-      }
-
-      std::u32string scale = it->second;
-      if (base >= 1000000LL && high > 1) {
-          if (base == 1000000LL) scale = U"Millionen";
-          else if (base == 1000000000LL) scale = U"Milliarden";
-      }
+Num2Word::Num2Word() : Num2WordLayer(kNotation, kJoiners) {
+  add_pattern(std::make_unique<DatePattern>(kDateFormat));
+  add_pattern(std::make_unique<PhonePattern>());
+  add_pattern(std::make_unique<DotOrdinalPattern>());
+  add_pattern(std::make_unique<SuffixPattern>(Kind::DECADE, kDecadeSuffixes, kDecadeFormat));
+}
 
-      std::u32string res = head + scale;
-      if (low > 0) {
-          if (base >= 1000000LL) res += U" ";
-          res += to_cardinal_int(low);
+// -----------------------
+// ----- Resolution -----
+// -----------------------
+
+bool Num2Word::accept(const Match& match, const Context& context) const {
+  switch (match.kind) {
+    case Kind::DATE:
+      // "am 12. 3." is a date, "Platz 1. 2 Tore" is not
+      return match.text.find(U' ') == std::u32string_view::npos || kDateCues.contains(context.before());
+    case Kind::TIME:
+      if (match.numbers.size() == 2) {
+        bool decimal = match.separator == U'.' && match.suffix.empty();
+        return value(match.numbers[0]) <= 24 && value(match.numbers[1]) <= 59 && !decimal;
       }
-      return res;
+      return true;
+    case Kind::ORDINAL: {
+      // "Platz 3. Danach", "Platz 1. 2 Tore": a sentence end, not an ordinal
+      static const std::unordered_set<std::u32string> inflecting = [] {
+        std::unordered_set<std::u32string> words = {U"und", U"oder", U"bis"};
+        for (const auto* set : {&kWeak, &kWeakNominative, &kMixed, &kDative, &kAccusative, &kGenitive}) {
+          words.insert(set->begin(), set->end());
+        }
+        return words;
+      }();
+      auto words = words_of(context.tail());
+      std::u32string_view next = words.empty() ? U"" : words[0];
+      bool month = std::ranges::find(kMonths, next) != kMonths.end();
+      bool sentence = capitalized(next) && !month && !inflecting.contains(context.before());
+      return !next.empty() && !unicode::isdigit(next[0]) && !sentence;
     }
+    default:
+      return true;
   }
-
-  return conversions::utf8_to_u32(std::to_string(value));
 }
 
-std::u32string Num2Word::to_cardinal_float(float value, std::u32string_view repr) const {
-  if (value < 0.0f) {
-    return U"minus " + to_cardinal_float(std::abs(value), repr);
-  }
+NumberReading Num2Word::resolve(const Match& match, const Context& context) const {
+  NumberReading reading;
+
+  switch (match.kind) {
+    case Kind::DATE:
+      resolve_ending(context, U"Monat", reading);
+      return reading;
+
+    case Kind::ORDINAL: {
+      // The noun is the first capitalized word after it: der 3. Platz
+      std::u32string_view noun;
+      for (auto word : words_of(context.tail())) {
+        if (capitalized(word)) {
+          size_t end = word.find_last_not_of(U".,;:!?");
+          noun = word.substr(0, end == std::u32string_view::npos ? 0 : end + 1);
+          break;
+        }
+      }
+      resolve_ending(context, noun, reading);
+      return reading;
+    }
 
-  std::string value_str = conversions::u32_to_utf8(repr);
-  std::replace(value_str.begin(), value_str.end(), ',', '.');
+    case Kind::DECADE: {
+      std::u32string next = context.after();
+      reading.capitalized = next != U"Jahre" && next != U"Jahren" && next != U"Jahrgang";
+      return reading;
+    }
 
-  auto rit = std::find_if(value_str.rbegin(), value_str.rend(), [](char c) { return c != '0'; });
-  value_str = std::string(value_str.begin(), rit.base());
-  if (!value_str.empty() && value_str.back() == '.') {
-    value_str.pop_back();
+    default:
+      break;
   }
 
-  size_t dot_pos = value_str.find('.');
-  if (dot_pos == std::string::npos) {
-    return to_cardinal_int(value_str.empty() ? 0 : std::stoi(value_str));
+  // "1" before a noun is said like an article, in the case of the word before it: mit einer Stimme
+  std::u32string next = context.after();
+  std::u32string noun = next;
+  if ((next == U"bis" || next == U"oder") && all_digits(context.after(2))) {
+    // "1 bis 2 Werktage": gendered by the plural noun
+    noun = context.after(3);
+    if (noun.ends_with(U"en")) {
+      noun.pop_back();
+    } else if (noun.ends_with(U'e')) {
+      noun.pop_back();
+    }
   }
+  reading.article = capitalized(noun) && noun != U"Quadrat" && (noun != next || !labelled(context));
+  reading.grammatical_case = case_after(context.before());
+  reading.gender = gender_of(noun);
+
+  // 1998 Abi gemacht, im Jahr 1945; but 1945 Einwohner, 1920 mal 1080
+  bool month = std::ranges::find(kMonths, next) != kMonths.end();
+  bool measure = next.ends_with(U'e') || next.ends_with(U'n') || next.ends_with(U"er") || next.ends_with(U's') ||
+                 kMeasureWords.contains(next);
+  bool counted = capitalized(next) && measure && !month;
+  std::u32string previous = context.before();
+  bool times = next == U"mal" || previous == U"mal";
+  reading.year = !times && (kYearCues.contains(previous) || !counted);
+  return reading;
+}
 
-  std::string integer_part_str = value_str.substr(0, dot_pos);
-  std::string fractional_part_str = value_str.substr(dot_pos + 1);
-
-  int32_t integer_part = integer_part_str.empty() ? 0 : std::stoi(integer_part_str);
+// --------------------
+// ----- Readings -----
+// --------------------
 
-  std::u32string res = to_cardinal_int(integer_part) + U" Komma";
-  for (char c : fractional_part_str) {
-    if (isdigit(static_cast<unsigned char>(c))) {
-      res += U" " + to_cardinal_int(c - '0');
-    }
+std::u32string Num2Word::read_number(const Number& number, const NumberReading& reading) const {
+  if (!number.fraction.empty()) {
+    std::u32string head = number.integer.empty() ? U"" : cardinal(value(number)) + U" ";
+    return head + U"Komma " + digits(number.fraction);
   }
 
-  return res;
+  auto n = value_of(number.integer);
+  if (!n || spoken_digits(number, 5)) {
+    return digits(number.integer);
+  }
+  if (*n == 1 && reading.article) {
+    return article(reading.grammatical_case, reading.gender);
+  }
+  if (number.integer.size() == 4 && !number.grouped && reading.year) {
+    return year(*n);
+  }
+  return cardinal(*n);
 }
 
-std::u32string Num2Word::to_ordinal_int(int32_t value, std::u32string_view suffix) const {
-  if (value < 0) {
-    return U"minus " + to_ordinal_int(std::abs(value), suffix);
+std::u32string Num2Word::read_code_digits(std::u32string_view text) const {
+  auto n = value_of(text);
+  if ((text.size() > 1 && text[0] == U'0') || text.size() > 4 || !n) {
+    return digits(text);
   }
+  return year(*n);
+}
+
+std::u32string Num2Word::read_date(const Match& match, const NumberReading& reading) const {
+  std::u32string words =
+      ordinal(value(match.numbers[0]), ending(reading)) + U" " + kMonths[value(match.numbers[1]) - 1];
+  return match.numbers.size() < 3 ? words : words + U" " + year(value(match.numbers[2]));
+}
 
-  std::u32string stem;
-  if (value == 1) stem = U"erst";
-  else if (value == 3) stem = U"dritt";
-  else if (value == 7) stem = U"siebt";
-  else if (value == 8) stem = U"acht";
-  else if (value < 20) stem = to_cardinal_int(value) + U"t";
-  else stem = to_cardinal_int(value) + U"st";
-
-  std::u32string ending = U"e";
-  if (!suffix.empty()) {
-    char32_t last = utils::unicode::tolower(suffix.back());
-    if (last == U'n') ending = U"en";
-    else if (last == U'r') ending = U"er";
-    else if (last == U's') ending = U"es";
-    else if (last == U'm') ending = U"em";
+std::u32string Num2Word::read_phone(const Match& match, const NumberReading& reading) const {
+  std::u32string all;
+  for (const auto& group : match.numbers) {
+    all += group.integer;
   }
+  return digits(all);
+}
 
-  return stem + ending;
+std::u32string Num2Word::read_fraction(const Match& match, const NumberReading& reading) const {
+  uint64_t a = value(match.numbers[0]), b = value(match.numbers[1]);
+  auto it = kFractions.find({a, b});
+  return it != kFractions.end() ? it->second : cardinal(a) + U" durch " + cardinal(b);
 }
 
-std::u32string Num2Word::to_currency(char32_t currency, std::variant<int32_t, float> number) const {
-  if (!num2word::kCurrencies.contains(currency)) {
-    return std::u32string(1, currency);
+std::u32string Num2Word::read_time(const Match& match, const NumberReading& reading) const {
+  std::u32string words = stem(value(match.numbers[0])) + U" Uhr";
+  if (match.numbers.size() == 2 && value(match.numbers[1]) > 0) {
+    words += U" " + cardinal(value(match.numbers[1]));
   }
-  return num2word::kCurrencies.at(currency);
+  return words;
 }
 
-std::u32string Num2Word::to_month(uint32_t month) const {
-  if (month >= 1 && month <= 12) {
-    return num2word::kMonths[month];
-  }
-  return U"";
+std::u32string Num2Word::read_ordinal(const Match& match, const NumberReading& reading) const {
+  return ordinal(value(match.numbers[0]), ending(reading));
 }
 
-std::u32string Num2Word::to_year(uint32_t year) const {
-  if (year >= 1100 && year < 2000) {
-    int32_t hundreds = year / 100;
-    int32_t remainder = year % 100;
-    std::u32string res = to_cardinal_int(hundreds) + U"hundert";
-    if (remainder > 0) {
-        res += to_cardinal_int(remainder);
-    }
-    return res;
+std::u32string Num2Word::read_decade(const Match& match, const NumberReading& reading) const {
+  // 90er, 90ern: neunziger, neunzigern; 1990er: neunzehnhundertneunziger
+  const auto& digits = match.numbers[0].integer;
+  std::u32string number = digits.size() > 1 && digits[0] == U'0' ? U"null" + cardinal(value(match.numbers[0])) :
+                                                                   year(value(match.numbers[0]));
+  std::u32string words = number + std::u32string(match.suffix);
+  if (reading.capitalized) {
+    words[0] = unicode::toupper(words[0]);
   }
-  return to_cardinal_int(static_cast<int32_t>(year));
+  return words;
 }
 
-bool Num2Word::is_ordinal_suffix(std::u32string_view suffix) const {
-  return num2word::kOrdinalSuffixes.contains(std::u32string(suffix));
+std::u32string Num2Word::read_compound(const Match& match, const NumberReading& reading) const {
+  // 30-jährige: dreißigjährige; 4-Zimmer-Wohnung: Vier-Zimmer-Wohnung
+  const Number& number = match.numbers[0];
+  std::u32string words =
+      number.fraction.empty() && !number.grouped ? stem(value(number)) : read_number(number, reading);
+  if (capitalized(match.suffix)) {
+    words[0] = unicode::toupper(words[0]);
+    return words + U"-" + std::u32string(match.suffix);
+  }
+  return words + std::u32string(match.suffix);
 }
 
-std::u32string Num2Word::to_fraction(int32_t numerator, int32_t denominator) const {
-  std::u32string num_word = (numerator == 1) ? U"ein" : to_cardinal_int(numerator);
-  std::u32string den_word;
-  if (denominator == 2) {
-    den_word = U"halb";
-  } else if (denominator == 3) {
-    den_word = U"drittel";
-  } else if (denominator == 4) {
-    den_word = U"viertel";
-  } else if (denominator < 20) {
-    den_word = to_cardinal_int(denominator) + U"tel";
-  } else {
-    den_word = to_cardinal_int(denominator) + U"stel";
+std::u32string Num2Word::read_money(const Number& number, const Match& match, const NumberReading& reading) const {
+  const std::u32string& noun = kCurrencies.at(std::u32string(match.unit));
+  std::u32string one = article(reading.grammatical_case, gender_of(noun));
+  if (!match.scale.empty()) {
+    return read_scale(number, match, reading) + U" " + noun;
   }
 
-  if (!den_word.empty()) {
-    den_word[0] = utils::unicode::toupper(den_word[0]);
+  // A price: drei Euro fünfzig, neunundneunzig Cent
+  if (number.fraction.size() == 2) {
+    uint64_t cents = value_of(number.fraction).value_or(0);
+    if (value(number) == 0) {
+      return cardinal(cents) + U" Cent";
+    }
+    Number whole{.integer = number.integer, .grouped = number.grouped};
+    std::u32string words = number.integer == U"1" ? one : read_number(whole, reading);
+    return words + U" " + noun + U" " + cardinal(cents);
   }
-  return num_word + U" " + den_word;
-}
 
-std::u32string Num2Word::to_day(uint32_t day) const {
-  return to_ordinal_int(static_cast<int32_t>(day));
+  bool single = number.integer == U"1" && number.fraction.empty();
+  return (single ? one : read_number(number, reading)) + U" " + noun;
 }
 
-std::u32string Num2Word::verbalize(const StringifiedNumber& number) const {
-  if (number.conversionMode != Mode::CURRENCY) {
-    return Num2WordLayer::verbalize(number);
+std::u32string Num2Word::read_scale(const Number& number, const Match& match, const NumberReading& reading) const {
+  const Forms& scale = kScales.at(std::u32string(match.scale));
+  if (scale.many == U"tausend") {
+    return read_number(number, reading) + U"tausend";
   }
+  bool single = number.integer == U"1" && number.fraction.empty();
+  return single ? U"eine " + scale.one : read_number(number, reading) + U" " + scale.many;
+}
 
-  char32_t currency = number.text.back();
-  std::u32string_view num_part = number.text.substr(0, number.text.size() - 1);
+std::u32string Num2Word::read_percent(const Number& number, const Match& match, const NumberReading& reading) const {
+  std::u32string words = read_number(number, reading);
+  // 8%ige: achtprozentige
+  return match.suffix.empty() ? words + U" Prozent" : words + U"prozent" + std::u32string(match.suffix);
+}
 
-  if (num_part.find(U'.') != std::u32string_view::npos) {
-    auto val = as_float(num_part);
-    if (!val) return U"";
-    bool singular = std::abs(*val - 1.0F) < 1e-6F;
-    std::u32string amount = singular ? U"ein" : to_cardinal_float(*val, num_part);
-    return amount + U" " + to_currency(currency, *val);
+std::u32string Num2Word::read_unit(const Number& number, const Match& match, const NumberReading& reading) const {
+  const Forms& unit = kUnits.at(std::u32string(match.unit));
+  if (number.integer == U"1" && number.fraction.empty()) {
+    return article(reading.grammatical_case, gender_of(unit.one)) + U" " + unit.one;
   }
-
-  auto val = as_int(num_part);
-  if (!val) return U"";
-  bool singular = (*val == 1);
-  std::u32string amount = singular ? U"ein" : to_cardinal_int(*val);
-  return amount + U" " + to_currency(currency, *val);
+  return read_number(number, reading) + U" " + unit.many;
 }
 
 } // namespace phonemis::de