skia / external / github.com / unicode-org / icu / refs/tags/icu-release-3-6-d02 / . / source / data / rbnf / en.txt

// *************************************************************************** | |

// * | |

// * Copyright (C) 2004, International Business Machines | |

// * Corporation and others. All Rights Reserved. | |

// * | |

// *************************************************************************** | |

// | |

en { | |

//------------------------------------------------------------ | |

// Rule Based Number Format Support | |

//------------------------------------------------------------ | |

// * Spellout rules for U.S. English. This rule set has two variants: | |

// * %simplified is a set of rules showing the simple method of spelling | |

// * out numbers in English: 289 is formatted as "two hundred eighty-nine". | |

// * %default uses a more complicated algorithm to format | |

// * numbers in a more natural way: 289 is formatted as "two hundred AND | |

// * eighty-nine" and commas are inserted between the thousands groups for | |

// * values above 100,000. | |

SpelloutRules { | |

// This rule set shows the normal simple formatting rules for English | |

"%simplified:\n" | |

// negative number rule. This rule is used to format negative | |

// numbers. The result of formatting the number's absolute | |

// value is placed where the >> is. | |

"-x: minus >>;\n" | |

// faction rule. This rule is used for formatting numbers | |

// with fractional parts. The result of formatting the | |

// number's integral part is substituted for the <<, and | |

// the result of formatting the number's fractional part | |

// (one digit at a time, e.g., 0.123 is "zero point one two | |

// three") replaces the >>. | |

"x.x: << point >>;\n" | |

// the rules for the values from 0 to 19 are simply the | |

// words for those numbers | |

"zero; one; two; three; four; five; six; seven; eight; nine;\n" | |

"ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n" | |

"seventeen; eighteen; nineteen;\n" | |

// beginning at 20, we use the >> to mark the position where | |

// the result of formatting the number's ones digit. Thus, | |

// we only need a new rule at every multiple of 10. Text in | |

// backets is omitted if the value being formatted is an | |

// even multiple of 10. | |

"20: twenty[->>];\n" | |

"30: thirty[->>];\n" | |

"40: forty[->>];\n" | |

"50: fifty[->>];\n" | |

"60: sixty[->>];\n" | |

"70: seventy[->>];\n" | |

"80: eighty[->>];\n" | |

"90: ninety[->>];\n" | |

// beginning at 100, we can use << to mark the position where | |

// the result of formatting the multiple of 100 is to be | |

// inserted. Notice also that the meaning of >> has shifted: | |

// here, it refers to both the ones place and the tens place. | |

// The meanings of the << and >> tokens depend on the base value | |

// of the rule. A rule's divisor is (usually) the highest | |

// power of 10 that is less than or equal to the rule's base | |

// value. The value being formatted is divided by the rule's | |

// divisor, and the integral quotient is used to get the text | |

// for <<, while the remainder is used to produce the text | |

// for >>. Again, text in brackets is omitted if the value | |

// being formatted is an even multiple of the rule's divisor | |

// (in this case, an even multiple of 100) | |

"100: << hundred[ >>];\n" | |

// The rules for the higher numbers work the same way as the | |

// rule for 100: Again, the << and >> tokens depend on the | |

// rule's divisor, which for all these rules is also the rule's | |

// base value. To group by thousand, we simply don't have any | |

// rules between 1,000 and 1,000,000. | |

"1000: << thousand[ >>];\n" | |

"1,000,000: << million[ >>];\n" | |

"1,000,000,000: << billion[ >>];\n" | |

"1,000,000,000,000: << trillion[ >>];\n" | |

// overflow rule. This rule specifies that values of a | |

// quadrillion or more are shown in numerals rather than words. | |

// The == token means to format (with new rules) the value | |

// being formatted by this rule and place the result where | |

// the == is. The #,##0 inside the == signs is a | |

// DecimalFormat pattern. It specifies that the value should | |

// be formatted with a DecimalFormat object, and that it | |

// should be formatted with no decimal places, at least one | |

// digit, and a thousands separator. | |

"1,000,000,000,000,000: =#,##0=;\n" | |

// %default is a more elaborate form of %simplified; It is basically | |

// the same, except that it introduces "and" before the ones digit | |

// when appropriate (basically, between the tens and ones digits) and | |

// separates the thousands groups with commas in values over 100,000. | |

"%default:\n" | |

// negative-number and fraction rules. These are the same | |

// as those for %simplified, but have to be stated here too | |

// because this is an entry point | |

"-x: minus >>;\n" | |

"x.x: << point >>;\n" | |

// just use %simplified for values below 100 | |

"=%simplified=;\n" | |

// for values from 100 to 9,999 use %%and to decide whether or | |

// not to interpose the "and" | |

"100: << hundred[ >%%and>];\n" | |

"1000: << thousand[ >%%and>];\n" | |

// for values of 100,000 and up, use %%commas to interpose the | |

// commas in the right places (and also to interpose the "and") | |

"100,000>>: << thousand[>%%commas>];\n" | |

"1,000,000: << million[>%%commas>];\n" | |

"1,000,000,000: << billion[>%%commas>];\n" | |

"1,000,000,000,000: << trillion[>%%commas>];\n" | |

"1,000,000,000,000,000: =#,##0=;\n" | |

// if the value passed to this rule set is greater than 100, don't | |

// add the "and"; if it's less than 100, add "and" before the last | |

// digits | |

"%%and:\n" | |

"and =%default=;\n" | |

"100: =%default=;\n" | |

// this rule set is used to place the commas | |

"%%commas:\n" | |

// for values below 100, add "and" (the apostrophe at the | |

// beginning is ignored, but causes the space that follows it | |

// to be significant: this is necessary because the rules | |

// calling %%commas don't put a space before it) | |

"' and =%default=;\n" | |

// put a comma after the thousands (or whatever preceded the | |

// hundreds) | |

"100: , =%default=;\n" | |

// put a comma after the millions (or whatever precedes the | |

// thousands) | |

"1000: , <%default< thousand, >%default>;\n" | |

// and so on... | |

"1,000,000: , =%default=;" | |

// %%lenient-parse isn't really a set of number formatting rules; | |

// it's a set of collation rules. Lenient-parse mode uses a Collator | |

// object to compare fragments of the text being parsed to the text | |

// in the rules, allowing more leeway in the matching text. This set | |

// of rules tells the formatter to ignore commas when parsing (it | |

// already ignores spaces, which is why we refer to the space; it also | |

// ignores hyphens, making "twenty one" and "twenty-one" parse | |

// identically) | |

"%%lenient-parse:\n" | |

// "& ' ' , ',' ;\n" | |

" &\u0000 << ' ' << ',' << '-'; \n" | |

} | |

// * This rule set adds an English ordinal abbreviation to the end of a | |

// * number. For example, 2 is formatted as "2nd". Parsing doesn't work with | |

// * this rule set. To parse, use DecimalFormat on the numeral. | |

OrdinalRules { | |

// this rule set formats the numeral and calls %%abbrev to | |

// supply the abbreviation | |

"%main:\n" | |

"=#,##0==%%abbrev=;\n" | |

// this rule set supplies the abbreviation | |

"%%abbrev:\n" | |

// the abbreviations. Everything from 4 to 19 ends in "th" | |

"th; st; nd; rd; th;\n" | |

// at 20, we begin repeating the cycle every 10 (13 is "13th", | |

// but 23 and 33 are "23rd" and "33rd") We do this by | |

// ignoring all bug the ones digit in selecting the abbreviation | |

"20: >>;\n" | |

// at 100, we repeat the whole cycle by considering only the | |

// tens and ones digits in picking an abbreviation | |

"100: >>;\n" | |

} | |

// * This rule set formats a number of seconds in sexagesimal notation | |

// * (i.e., hours, minutes, and seconds). %with-words formats it with | |

// * words (3,740 is "1 hour, 2 minutes, 20 seconds") and %in-numerals | |

// * formats it entirely in numerals (3,740 is "1:02:20"). | |

DurationRules { | |

// main rule set for formatting with words | |

"%with-words:\n" | |

// take care of singular and plural forms of "second" | |

"0 seconds; 1 second; =0= seconds;\n" | |

// use %%min to format values greater than 60 seconds | |

"60/60: <%%min<[, >>];\n" | |

// use %%hr to format values greater than 3,600 seconds | |

// (the ">>>" below causes us to see the number of minutes | |

// when when there are zero minutes) | |

"3600/60: <%%hr<[, >>>];\n" | |

// this rule set takes care of the singular and plural forms | |

// of "minute" | |

"%%min:\n" | |

"0 minutes; 1 minute; =0= minutes;\n" | |

// this rule set takes care of the singular and plural forms | |

// of "hour" | |

"%%hr:\n" | |

"0 hours; 1 hour; =0= hours;\n" | |

// main rule set for formatting in numerals | |

"%in-numerals:\n" | |

// values below 60 seconds are shown with "sec." | |

"=0= sec.;\n" | |

// higher values are shown with colons: %%min-sec is used for | |

// values below 3,600 seconds... | |

"60: =%%min-sec=;\n" | |

// ...and %%hr-min-sec is used for values of 3,600 seconds | |

// and above | |

"3600: =%%hr-min-sec=;\n" | |

// this rule causes values of less than 10 minutes to show without | |

// a leading zero | |

"%%min-sec:\n" | |

"0: :=00=;\n" | |

"60/60: <0<>>;\n" | |

// this rule set is used for values of 3,600 or more. Minutes are always | |

// shown, and always shown with two digits | |

"%%hr-min-sec:\n" | |

"0: :=00=;\n" | |

"60/60: <00<>>;\n" | |

"3600/60: <#,##0<:>>>;\n" | |

// the lenient-parse rules allow several different characters to be used | |

// as delimiters between hours, minutes, and seconds | |

"%%lenient-parse:\n" | |

"& ':' = '.' = ' ' = '-';\n" | |

} | |

} |