Scottish Gaelic Gàidhlig

BCP 47 language tag: gd

Lokalized supports cardinality, cardinality range, and ordinality rules for Scottish Gaelic.

Scottish Gaelic is most often spoken in the United Kingdom.

Cardinalities

  • CARDINALITY_ONE

    Matches n = 1,11

    Example Integers: 1, 11

    Example Decimals: 1.0, 11.0, 1.00, 11.00, 1.000, 11.000, 1.0000

  • CARDINALITY_TWO

    Matches n = 2,12

    Example Integers: 2, 12

    Example Decimals: 2.0, 12.0, 2.00, 12.00, 2.000, 12.000, 2.0000

  • CARDINALITY_FEW

    Matches n = 3..10,13..19

    Example Integers: 3, 10, 13, 19

    Example Decimals: 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 3.00

  • CARDINALITY_OTHER

    Matches all other values

    Example Integers: 0, 20, 34, 100, 1000, 10000, 100000, 1000000, …

    Example Decimals: 0.0, 0.9, 1.1, 1.6, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …

Cardinality example

This localized strings example uses complete, page-local CLDR minimal-pair patterns to demonstrate every Cardinality category defined for the locale. Minimal-pair text contrasts grammatical forms; it is language-reference data, not reusable application copy.

Source: Unicode CLDR 48.2 gd locale data.

Sample localized strings file
gd.json Localized Strings File (Scottish Gaelic) 
{
  "Cardinality.MinimalPair": {
    "commentary": "Demonstrates every CLDR cardinal category defined for this locale.",
    "translation": "{{cardinalityExample}}",
    "placeholders": {
      "cardinalityExample": {
        "value": "cardinalityValue",
        "translations": {
          "CARDINALITY_ONE": "{{formattedCardinalityValue}} bhròg",
          "CARDINALITY_TWO": "{{formattedCardinalityValue}} bhròig",
          "CARDINALITY_FEW": "{{formattedCardinalityValue}} brògan",
          "CARDINALITY_OTHER": "{{formattedCardinalityValue}} bròg"
        }
      }
    }
  }
}
Usage and expected results

The Java code passes each raw number for cardinality selection and formats its display value separately with NumberFormat.

Locale locale = Locale.forLanguageTag("gd");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);

// Raw numbers select language forms; NumberFormat produces the display values

// CARDINALITY_ONE
Number oneCardinalityValue = 1;
String oneFormattedCardinalityValue = numberFormat.format(oneCardinalityValue);

assertEquals(Cardinality.ONE, Cardinality.forNumber(oneCardinalityValue, locale));

// Expected: 1 bhròg
assertEquals(oneFormattedCardinalityValue + " bhròg", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", oneCardinalityValue,
    "formattedCardinalityValue", oneFormattedCardinalityValue
  )
));

// CARDINALITY_TWO
Number twoCardinalityValue = 2;
String twoFormattedCardinalityValue = numberFormat.format(twoCardinalityValue);

assertEquals(Cardinality.TWO, Cardinality.forNumber(twoCardinalityValue, locale));

// Expected: 2 bhròig
assertEquals(twoFormattedCardinalityValue + " bhròig", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", twoCardinalityValue,
    "formattedCardinalityValue", twoFormattedCardinalityValue
  )
));

// CARDINALITY_FEW
Number fewCardinalityValue = 3;
String fewFormattedCardinalityValue = numberFormat.format(fewCardinalityValue);

assertEquals(Cardinality.FEW, Cardinality.forNumber(fewCardinalityValue, locale));

// Expected: 3 brògan
assertEquals(fewFormattedCardinalityValue + " brògan", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", fewCardinalityValue,
    "formattedCardinalityValue", fewFormattedCardinalityValue
  )
));

// CARDINALITY_OTHER
Number otherCardinalityValue = 0;
String otherFormattedCardinalityValue = numberFormat.format(otherCardinalityValue);

assertEquals(Cardinality.OTHER, Cardinality.forNumber(otherCardinalityValue, locale));

// Expected: 0 bròg
assertEquals(otherFormattedCardinalityValue + " bròg", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", otherCardinalityValue,
    "formattedCardinalityValue", otherFormattedCardinalityValue
  )
));

Cardinality Ranges

No explicit CLDR cardinality-range mapping is defined for this language. Cardinality.forRange(...) therefore falls back to the ending cardinality for every range.

Cardinality range example

Because CLDR defines no explicit range mapping for this locale, the ending cardinality selects the result. The selected form wraps a separately formatted display range.

Sample localized strings file
gd.json Localized Strings File (Scottish Gaelic) 
{
  "Delivery.Window": {
    "commentary": "Estimated delivery window, expressed as a range of days.",
    "translation": "{{window}}",
    "placeholders": {
      "window": {
        "range": {
          "start": "minDays",
          "end": "maxDays"
        },
        "translations": {
          "CARDINALITY_ONE": "{{formattedDayRange}} latha",
          "CARDINALITY_TWO": "{{formattedDayRange}} latha",
          "CARDINALITY_FEW": "{{formattedDayRange}} làithean",
          "CARDINALITY_OTHER": "{{formattedDayRange}} latha"
        }
      }
    }
  }
}
Usage and expected results

The Java code passes raw range endpoints for selection. Because NumberFormat formats one number at a time, it formats both endpoints separately and joins them for display; choose range punctuation appropriate to your application.

Locale locale = Locale.forLanguageTag("gd");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);

// Raw numbers select language forms; NumberFormat produces the display values

// CARDINALITY_OTHER range (ending-cardinality fallback)
Number minDays = 0;
String formattedMinDays = numberFormat.format(minDays);
Number maxDays = new java.math.BigDecimal("0.9");
NumberFormat maxDaysFormat = NumberFormat.getNumberInstance(locale);
maxDaysFormat.setMinimumFractionDigits(1);
maxDaysFormat.setMaximumFractionDigits(1);
String formattedMaxDays = maxDaysFormat.format(maxDays);
String formattedDayRange = formattedMinDays + "-" + formattedMaxDays;

assertEquals(Cardinality.OTHER, Cardinality.forRange(
  Cardinality.forNumber(minDays, locale),
  Cardinality.forNumber(maxDays, locale),
  locale
));

// Expected: 0-0.9 latha
assertEquals(formattedDayRange + " latha", strings.get(
  "Delivery.Window",
  Map.of("minDays", minDays, "maxDays", maxDays, "formattedDayRange", formattedDayRange)
));

Ordinalities

  • ORDINALITY_ONE

    Matches n = 1,11

    Example Integers: 1, 11

  • ORDINALITY_TWO

    Matches n = 2,12

    Example Integers: 2, 12

  • ORDINALITY_FEW

    Matches n = 3,13

    Example Integers: 3, 13

  • ORDINALITY_OTHER

    Matches all other values

    Example Integers: 0, 4, 10, 14, 21, 100, 1000, 10000, 100000, 1000000, …

Ordinality example

This localized strings example uses complete CLDR minimal-pair patterns to demonstrate every Ordinality category defined for the locale.

Source: Unicode CLDR 48.2 gd locale data.

Sample localized strings file
gd.json Localized Strings File (Scottish Gaelic) 
{
  "Ordinal.MinimalPair": {
    "commentary": "Demonstrates every CLDR ordinal category defined for this locale.",
    "translation": "{{ordinalExample}}",
    "placeholders": {
      "ordinalExample": {
        "value": "ordinalValue",
        "translations": {
          "ORDINALITY_ONE": "Tionndaidh ris an làimh dheas aig a’ {{formattedOrdinalValue}}d ghobhal.",
          "ORDINALITY_TWO": "Tionndaidh ris an làimh dheas aig an {{formattedOrdinalValue}}na gobhal.",
          "ORDINALITY_FEW": "Tionndaidh ris an làimh dheas aig an {{formattedOrdinalValue}}s gobhal.",
          "ORDINALITY_OTHER": "Tionndaidh ris an làimh dheas aig a’ {{formattedOrdinalValue}}mh gobhal."
        }
      }
    }
  }
}
Usage and expected results

The Java code passes each raw number to Ordinality.forNumber(...) and formats its display value separately with NumberFormat.

Locale locale = Locale.forLanguageTag("gd");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);

// Raw numbers select language forms; NumberFormat produces the display values

// ORDINALITY_ONE
Number oneOrdinalValue = 1;
String oneFormattedOrdinalValue = numberFormat.format(oneOrdinalValue);

assertEquals(Ordinality.ONE, Ordinality.forNumber(oneOrdinalValue, locale));

// Expected: Tionndaidh ris an làimh dheas aig a’ 1d ghobhal.
assertEquals(
  // U+2019 RIGHT SINGLE QUOTATION MARK preserves the punctuation used by the localized source text
  "Tionndaidh ris an làimh dheas aig a\u2019 " + oneFormattedOrdinalValue + "d ghobhal.",
  strings.get(
    "Ordinal.MinimalPair",
    Map.of("ordinalValue", oneOrdinalValue, "formattedOrdinalValue", oneFormattedOrdinalValue)
  )
);

// ORDINALITY_TWO
Number twoOrdinalValue = 2;
String twoFormattedOrdinalValue = numberFormat.format(twoOrdinalValue);

assertEquals(Ordinality.TWO, Ordinality.forNumber(twoOrdinalValue, locale));

// Expected: Tionndaidh ris an làimh dheas aig an 2na gobhal.
assertEquals(
  "Tionndaidh ris an làimh dheas aig an " + twoFormattedOrdinalValue + "na gobhal.",
  strings.get(
    "Ordinal.MinimalPair",
    Map.of("ordinalValue", twoOrdinalValue, "formattedOrdinalValue", twoFormattedOrdinalValue)
  )
);

// ORDINALITY_FEW
Number fewOrdinalValue = 3;
String fewFormattedOrdinalValue = numberFormat.format(fewOrdinalValue);

assertEquals(Ordinality.FEW, Ordinality.forNumber(fewOrdinalValue, locale));

// Expected: Tionndaidh ris an làimh dheas aig an 3s gobhal.
assertEquals(
  "Tionndaidh ris an làimh dheas aig an " + fewFormattedOrdinalValue + "s gobhal.",
  strings.get(
    "Ordinal.MinimalPair",
    Map.of("ordinalValue", fewOrdinalValue, "formattedOrdinalValue", fewFormattedOrdinalValue)
  )
);

// ORDINALITY_OTHER
Number otherOrdinalValue = 4;
String otherFormattedOrdinalValue = numberFormat.format(otherOrdinalValue);

assertEquals(Ordinality.OTHER, Ordinality.forNumber(otherOrdinalValue, locale));

// Expected: Tionndaidh ris an làimh dheas aig a’ 4mh gobhal.
assertEquals(
  "Tionndaidh ris an làimh dheas aig a\u2019 " + otherFormattedOrdinalValue + "mh gobhal.",
  strings.get(
    "Ordinal.MinimalPair",
    Map.of("ordinalValue", otherOrdinalValue, "formattedOrdinalValue", otherFormattedOrdinalValue)
  )
);

Addendum: Language Form Rules

The language form expressions above are specified by Unicode Technical Standard #35 and use the following notation:

  • n absolute value of the source number (integer and decimals)
  • i integer digits of n
  • v number of visible fraction digits in n, with trailing zeros
  • w number of visible fraction digits in n, without trailing zeros
  • f visible fractional digits in n, with trailing zeros
  • t visible fractional digits in n, without trailing zeros
  • c/e compact decimal exponent operands used by some CLDR compact-number rules