Back in the 60's, since my days in the engineering school, I always had a passion for calculating devices. First it was the slide-rule and latter, at the beginning of the 70's, it shifted to the pocket calculators. Yes, it all started in the 70's. ARISTO was always my favorite slide-rule brand, so I couldn't resist the temptation of buying this ARISTO M36 pocket calculator from a friend who came from Germany. Although it had only the four basic arithmetic functions, it is indeed the best calculator I have ever had. Its power and flexibility came from two special keys: a Memory key and a Swap key. The Memory key was used in combination with the arithmetic functions and the Equal key. The Swap key was also used in combination with other keys. For example: [Memory][Swap] would swap the memory contents with the display value. Can you do that with your standard non-scientific calculator? It didn't have scientific functions, not even the square root, but because of its flexibility it was easy (and fun) to compute a square root by applying to the number the Newton-Raphson iteration a few times. I used it while studying for my Master degree in Industrial and Management Engineering at Columbia University, and later several years during my professional career, until one day somebody stole it from my office. When I tried to get another one, it was too late, ARISTO had already moved into the LCD display technology and their calculators looked more like the standard ones. I was disappointed to discover that the memory key had disappeared and Square Root key had taken the place of the Swap key. Few years after ARISTO succumbed to the competition. Then, the microcomputers arrived, and MS-DOS with the unbelievable power of the TSR memory resident applications started inundating the market and my attention. Of course, my natural reaction was to use all this wonderful power in writing an emulator of my beloved ARISTO. It was 1992 and since this was just my after hours hobby, it took much more time than I though. To start with, I had to learn some C and the usage of TSR memory management functions. The project was running fine until I had to write the routines to perform the data-entry. Here I decided to include most of the capabilities I had found in other calculators during my quest in searching for an ARISTO like functionality. One of this capabilities was the usage of a Hundred key [00] (to replace pressing the Zero key twice while entering cents or numbers with many zeroes). So, since the magic of the microprocessor was so easy to handle, I said to myself why not a Thousand key [000]? Soon I discovered why the calculator manufacturers never included a Thousand key and very few included the Hundred key. It was easier to press the Zero key two or three times as required. But it was also at this point where I realized that not only the Hundred key, but also the Thousand key and even a Million key can prove to be very helpful if they could be used in a mnemonic mode to enter a number in the same way as we think on the number. Think on this number for example: 2001. I'm sure that you read it mentally as "Two Thousand One." Your mind didn't read the number as "Two Zero Zero One." Shouldn't it be easier to enter a number in a keyboard by using the same way as our mind thinks on the number? For example, how about to have a calculator equipped with three additional keys: a Hundred key [00], a Thousand key [000], and a Million key [0x6]. Entering the number 2001 would require pressing the following sequence: [2][000][1] (for Two-Thousand-One). Soon I realized that there were some unexpected results. First, it was no longer required to convert mentally the number into its sequence of digits prior to entering the number (this can be challenging with certain numbers), but even better, the number of keystrokes required to enter a number was in most cases less than the number of keystrokes required by the conventional procedure. I checked the idea with my daughter-advisor Marisol (then 14) and she liked the idea. Great, so let's write some functions that would do that I said to myself. It sounded simple and easy to implement. Well it was not. Marisol would be able to help me now that she is going for her MS at MIT, but not on those days. So it took me a couple of years to develop my concept of the Verbal Numerals and the algorithms required to do the conversion. I filed for a patent application in February 11 of 1992, and finally after four years of browsing through the pages of the book "Patent It Yourself" by David Pressman, and writing countless pages answering observations posted by the Patent Office, I got my patent 5623433 issued in April 22, 1997. It has been a long and interesting journey but, of course, hopefully this is just the beginning... James Redin April 22, 1997. |
Background and
Objectives | When a number is
expressed orally, several rules, which are sometimes
language dependent, must be applied in order to determine
the proper way to express the number. For example, the number 100,000 cannot be expressed as "One thousand hundred" (although it can be actually considered as made up of thousand hundreds), instead, it must be expressed as "One hundred thousand." Another interesting example is the way the number 1,200 can be expressed in English; note that in this case the notation "Twelve hundred" or "One thousand two hundred" are equally acceptable; this does not hold true in other languages like in Spanish, when only the equivalent for the second form is accepted: "Mil docientos." The purpose of this document is to analyze the rules that govern the expression of numbers in the English language, as well as its similarities and main differences with other occidental languages such as Spanish, French and Dutch. This may prove to be useful in designing a new method to input numbers in numerical devices such as computers and electronic calculators. |
Small Numbers | In every language,
special names and/or special naming conventions are
applied to numbers under 100. For the purpose of this
analysis these numbers will be referred to as "small
numbers." The smaller the number, the more specific
the name. In English, numbers ranging from 0 to 12 have
proper single names which do not follow any rule at all,
each name is unique and shows no relationship with the
others; numbers ranging from 13 to 19 also have single
names, but this time the name is formed by combining a
root taken from the names assigned to numbers 3 to 9 with
a suffix "teen." A similar approach is used to
name the remaining multiples of ten, 20 to 90, by using
the suffix "ty." Numbers starting with 21 up to
99 not included in the later set, have a composite name
made up from the name of the immediate lower multiple of
10 plus the unique name assigned to the number that
corresponds to the remaining number of units; as
illustration example, the number 37 is expressed as
"Thirty- seven." In Spanish a similar scheme is applied, except that numbers from 0 to 15, and multiples of 20 to 90 have been assigned single names, while every other number in the range have a composite name constructed in a way similar to the described above for English; as illustration example, the number 17 is expressed as "Diez y siete," many numbers like the one in this example have been assigned special concatenated single names; in Spanish, for example, the proper way to write the name of number 17 is "Diesisiete" instead of "Diez y siete." It is interesting to notice the way some small numbers are constructed in French. For example, the numbers 70 and 80, instead or being assigned single names as its counterparts in other languages and other multiples of ten in the same language, are expressed with the composite names "Soixant Dix" and "Quatre Vingts", which translated literally into English would mean "Sixty Ten" and "Four Twenties." It follows from the discussion above, that small numbers have no general naming conventions, and the way they are expressed greatly depends on the language applied. |
Unit Structures | In the case of numbers
greater than 99, special single names have been assigned
to some powers of ten, the most common are the names
assigned to 100, 1,000 and 1,000,000, which in English
are "Hundred," "Thousand" and
"Million." Equivalent names are also used in
other languages, for example: "Cien,"
"Mil," and "Millon" in Spanish;
"Cent," "Mille," and
"Million" in French. Larger powers of ten have also been assigned single names but not always have consistent meanings. The most typical case is the name "Billion" which in United States means one thousand millions (1,000,000,000) while in England it means one million millions (1,000,000,000,000). By the same token, the name "Trillion" in United States represents a unit followed by twelve zeroes, while in England it represents a unit followed by eighteen zeroes. French notation fixes this inconsistency by assigning different names to the U.S. Billion and the English Billion. "Milliard" is used for 1,000,000,000, and "Billion" for 1,000,000,000,000. For the purpose of this analysis, all the powers of ten greater or equal to 100 which have been assigned single names will be referred to as "unit structures." The following table shows the different names assigned in several languages to the main unit structures: Unit English Structure US UK Spanish French --------- ------- -------- ------- -------- 10**2 Hundred Hundred Cien Cent 10**3 Thousand Thousand Mil Mille 10**6 Million Million Millon Million 10**9 Billion - - Milliard 10**12 Trillion Billion Billon Billion 10**18 - Trillion Trillon Trillion - ----------------------------------------------- It follows from these observations, that the numbers "Hundred," "Thousand," and "Million" are the only unit structures which remain consistent across all the Western languages. |
Large Numbers and Order Parameters Consistent with the
definition given above for small numbers, a "large
number" will be defined as any integer greater that
99; therefore, every large number is greater than at
least one unit structure. For the purpose of this
analysis, the largest available unit structure smaller
than the number will be defined as the "Order"
of the number. The Order of the number is a parameter of
the number and can be used to represent the number by
using the following expression:
where int(number/Order) represents the result of applying an integer division of the number by its Order, and rem(number/Order) represents the remainder of the same operation. For the purpose of this analysis, the values of int(number/Order) and rem(number/Order) will be defined as the "Factor" of the number and the "Module" of the number, respectively. Therefore, above expression can be written as follows:
Above expression may be
generalized for all numbers if the order of small numbers
is defined as 1. Notice that in this case the Factor is equal to the value of the small number
and the Module is zero. number Factor Order Module ----------- ------ ---------- ------- 100,000 100 1,000 0 350 3 100 50 99 99 1 0 0 0 1 0 2,457,128 2 1,000,000 457,128 457,128 457 1,000 128 -------------------------------------------- |
Verbal Numerical
Expressions. | As shown in the
examples of the previous section, in some cases the
Factor and/or the Module can be large numbers. In these
cases, the original expression can be expanded
recursively until all the Factors and Modules of the
expression are small numbers as described in the
following algorithm: (1) find the Order, Factor and Module of the number; (2) if the Factor is a large number, apply recursively steps (1) to (5) to obtain the Factor expression and then enclose the factor expression within parentheses, otherwise use the Factor as the Factor expression; (3) if the Module is a large number, apply recursively steps (1) to (5) to obtain the Module expression, otherwise use the Module as the Module expression; (4) if the order is greater than 1, append "Factor expression x Order" to the number expression; otherwise, append "Factor expression to the number expression; (5) if the module is greater than 0, append "+ Module expression" to the number expression. Figure A1 shows a flow diagram for the algorithm described above. Notice that the recursive procedure is applied twice, however, due to the similarity of steps (2) and (3), the procedure can be simplified to use only one single call to the recursive procedure by subtracting the product Factor x Order from the number and then repeating the procedures until the result is zero. The simplified procedure is shown in Figure A2. As illustration example, the application of above algorithm to number 457,128 yields the following expressions: 457 x 1,000 + 128 (4 x 100 + 57) x 1,000 + 128 (4 x 100 + 57) x 1,000 + 1 x 100 + 28. Now, it is interesting to realize that the expressions obtained by the application of above procedure have a total consistency with the verbal expression of the number. In fact, notice that the name of the number can be easily obtained just by arranging the names of the numbers and unit structures of the expression in the same order as they appear in the expression without paying attention to the arithmetic symbols used in the expression. For example, the final expression can be used to obtain the name of the number 457,128 by using exclusively the names of the small numbers and unit structures as follows: (4 x 100 + 57) x 1,000 + 1 x 100 + 28 four hundred fifty-seven
thousand one hundred twenty-eight. 1,000 x (4 x 100 + 57) + 1 x 100 + 28 still represents the number of the example, however, it is no longer consistent with its verbal notation. Notice that "thousand four hundred fifty-seven one hundred twenty-eight" is not even the name of a valid number. |
Properties of
Verbal Numerical Expressions | By observing the nature
of the verbal numerical expressions, the following
properties can be found: a) the Module is always smaller than the Order; b) whenever the Order is smaller than the largest unit structure available in the set of unit structures used to construct a verbal numerical expression, the Factor is smaller than the Order; c) except for the representation of zero, Factor and Module components are always greater than zero; and d) Order components are always greater than 1. Notice that consistent with properties (c) and (d), small numbers are never expressed as "Factor x Order + Module" in a verbal numerical expression. Above properties may be used to determine if a given expression is a valid verbal numerical expression. |
Structural
Verbal Notation and Verbal Numerals | In the previous section
it was shown that the name of a number is actually the
representation of a verbal numerical expression. Another
way to represent a verbal numerical expression is by
assigning symbols to the unit structures (i.e.:
"H," "T" and "M" for
Hundred, Thousand and Million) and combining them with
the small numbers used in the verbal numerical expression
in a mode similar to the way the name of the number is
constructed orally. As illustration example, the application of the verbal expression algorithm to the number 35,178,971 will yield the following intermediate and final verbal numerical expressions: |
35 x 1,000,000 + 178,971 35 x 1,000,000 + 178 x 1,000 + 971 35 x 1,000,000 + (1 x 100 + 78) x 1,000 + 971 35 x 1,000,000 + (1 x 100 + 78) x 1,000 + 9 x 100 + 71. |
These expressions can
also be expressed symbolically with sequences of numbers
and unit structure symbols as follows:35M178971 35M178T971 35M1H78T971 35M1H78T9H71. Some languages, like Spanish, omit the pronunciation of the Factor when it is equal to 1. As illustration example, the number "One thousand one hundred" (1T1H) is expressed in Spanish as "Mil cien" (TH). This seems to be a convenient feature to be included in a verbal numeral because it reduces the number of components required by some verbal numerals, for example, the number illustrated above could also be represented as follows: 35MH78T971 35MH78T9H71. Since a verbal numerical
expression represents a number, the symbolic
representation of a verbal numerical expression will also
represent a number. A numeral is the symbolic
representation of a number, therefore all the symbolic
representations of verbal numerical expressions are
numerals. |
Conversion
of numbers into verbal numerals | Since a verbal numeral
is the symbolic representation of a verbal numerical
expression, the procedure used to obtain the verbal
numeral of a number should be similar to the verbal
expression algorithm. The following is an algorithm that can be used to convert a number into a verbal numeral: (1) find the Order, Factor and Module of the number; (2) if the Factor is a large number, apply recursively steps (1) to (4) to obtain the verbal numeral of the Factor, otherwise use the decimal representation of the Factor as the verbal numeral of the Factor; (3) if the Module is a large number, apply recursively steps (1) to (4) to obtain the verbal numeral of the Module, otherwise use the decimal representation of the Module as the verbal numeral of the Module; (4) obtain the verbal numeral of the number by appending to the verbal numeral of the Factor the symbol of the Order and the verbal numeral of the Module, in that order. Figure A3 shows a flow-diagram with the simplified version of this algorithm. |
Constructing
the names of large numbers | There are many
applications where it is desirable to build the textual
name of a number. Example of these applications are
programs and routines used to print the textual dollar
amount in a check. Notice that the algorithm described in
the previous section can easily be modified to build up
the name of a number by replacing the symbols of the unit
structures and the decimal representations of the small
numbers with their corresponding names. Figure A4 shows a flow diagram with an algorithm to find the English name of a number. It may be easily adapted to other languages, for example, the explicit expression of the number "one" when preceding a unit structure must be done when implemented in Spanish. |
Conversion of
verbal numerals into numbers | The verbal expression
algorithm can also be used to develop an algorithm to
obtain the value of the number represented by a verbal
numeral. Basically, this procedure should be equal to the
verbal expression algorithm, except that this time the
expression components are actually computed and added to
the number, and the Order is extracted directly from the
verbal numeral rather than computed from the number. The
algorithm may be summarized as follows: (1) find the Order symbol of the verbal numeral by locating the right-most symbol of the largest structure contained in the verbal numeral; if found, the Order is the absolute value of the Order symbol; otherwise the Order is 1; (2) get the value of the Factor by using the segment of the verbal numeral located at the left side of the Order symbol, if no Order symbol is available, use the verbal numeral as the segment. If no segment is available the value of the Factor is 1. If the segment contains at least one structure symbol, apply recursively steps (1) to (4) on this segment to obtain the value of the Factor, otherwise use the value represented by the digits in the segment as the value of the Factor; (3) get the value of the Module by using the segment of the verbal numeral located at the right side of the Order symbol, if no Order symbol or no segment is available, the value of the Module is zero. If the segment contains at least one structure symbol, apply recursively steps (1) to (4) on the segment to obtain the value of the Module, otherwise use the value represented by the digits in the segment as the value of the Module; (4) determine the value of the number by using the following expression: Factor x Order + Module. Figure A5 shows a simplified version of above algorithm with a provision to check the validity of the verbal numeral. The algorithm developed in this section can be implemented in the logic of a numerical data-entry device such as a calculator or computer to accept numbers entered in structured mode by using keys with structure symbols. The same procedure can also be adapted to enter numbers in voice recognition devices. |
Advantages of
Verbal Numerals | One obvious advantage
of the Structural Verbal Notation is its consistency with
the way the number is expressed orally. This allows to
build a valid verbal numeral without applying the
procedures described before, just by replacing the unit
structures used to express the name of the number with
the corresponding symbols and writing down the remaining
numbers in the corresponding sequence. In many instances verbal numerals require fewer number of symbols than decimal numerals. Here are several examples: 3,000,005 3M5 245,000,000,072 245M72 350,000 3H50T or 350T 2,000,305 2M3H5 or 2M305 1,001,000 1M1T or MT 1,000,000,000 1TM or TM 1,000,000,100 1TM1H or TMH A large number usually
may be represented by several verbal numerals, this
provides a flexibility not available on decimal numerals. Numeral Decimal Verbal Name Numeral Numeral ------- --------- -------- Five... 5 5 million... 5,000,000 5M three... 5,000,003 5M3 hundred... 5,000,300 5M3H thousand... 5,300,000 5M3HT six 5,300,006 5M3HT6 ---------------------------------- Notice that while the
decimal numeral changes substantially in each
intermediate step of the number, the verbal numeral does
not change except for the addition of the new component
to the previous numeral. |
Extended
Numerical Keyboards | All numerical keyboards
have two categories of keys: a) Data-entry keys. b) Function keys. Data-entry keys are the ones used to input a number into the device read buffer. In any numerical keyboard, data-entry keys can be clearly differentiated from function keys by the fact that pressing a data-entry key does not end the number entry procedure. On the other hand, function keys are the ones that, whenever pressed, end the number entry procedure and starts another type of procedure associated with the nature of the function key pressed. The most common data-entry keys are the digits 0 to 9 and the decimal period (dot key). Some scientific calculators also have an exponential key which allows the entry of numbers in scientific notation. Some business calculators have a "00" and a "000" key (multi-zero keys) to avoid pressing the zero digit several consecutive times when appropriate (i.e.: to enter zero cents in a currency amount). Another example of a data-entry key is the delete key which deletes the last digit entered. The most common function keys are the following: + to add the number to the value in accumulator. - to subtract the number from the value in accumulator. x to multiply the number by the value in accumulator. / to divide the number by the value in accumulator. = to display value in accumulator. CE to clear entry in read buffer. C to clear entry in read buffer and value in accumulator. M+ to add number to value in memory. M- to subtract number from value in memory. MC to clear value in memory. MR to copy value in memory to value in accumulator. Scientific and business
calculators also include specialized function keys used
to manipulate the numbers in the memory and/or
accumulators. In some cases, these functions can be
programmed by the user to perform special manipulations. |
