PATENT ABSTRACT
For inserting a data object as for example a mathematical formula or special characters like Greek characters into a text document, instruction symbols representing the data object are inputted in the form of text characters into the text document. A text portion containing instruction symbols is selected, and the instruction symbols contained in the selected text portion are converted into a data object represented by the instruction symbols. The invention allows rapid input of data objects into the text document, in particular simple mathematical formulae or single special characters without entering a formula editor or the like.

PATENT DESCRIPTION
BACKGROUND OF THE INVENTION 
   1. Field of the Invention 
   The present invention relates generally to generating documents using a computer application, and in particular to inserting a data object like a mathematical formula or special characters like Greek characters into a computer-generated document as for example a text document. 
   2. Description of Related Art 
   Computer word processing applications typically are used to generate a document, referred to as a computer-generated document, that may contain text data, tables, diagrams, etc. and often mathematical formulae or special characters like Greek characters. Mathematical formulae and special characters are particularly important for documents like scientific articles and the like. Similarly, HTML Web page generators generate a document that is effectively a text-based document. 
   For creating a mathematical formula within a text document  100  (FIG.  1 ), so called formula editors were used. Typically, the formula editor was opened from within the computer word processing application by clicking on a menu bar icon, or alternatively using a menu. 
   The formula editor contained a large number of displayed key fields and list boxes representing different elements of mathematical formulae like brackets, integrals, fraction bars, matrices, so forth. For inserting special characters, like for example the Greek character Σ, it was necessary to enter a list box containing the special characters. 
   The user created the desired formula  101  using these keys and list boxes. After having completed the formula, the user returned to the original document and pasted the formula as an imported object into the document. If the user recognized an error in the formula, the user again opened the formula editor, corrected the error, and returned to the original document. 
   Using a formula editor, it was possible to create nearly every desired mathematical formula; however, the operation was complicated and time consuming in particular for simple formulae like simple fractions or square roots, which appeared frequently in a text document. Editing of the formula always required entering the formula editor and subsequently returning into the original document. 
   To simplify the entry of formulas, some formula editors permitted the use of script like phrases that the formula editor converted to the corresponding mathematical expression. However, while this assisted in entering a formula in some situations by minimizing the use of key fields and list boxes, the general problem of having to utilize the formula editor persisted. 
   In an attempt to minimize some of the entry and exit issues, it was known to select an insert option from a menu bar of an application and the formula editor capability was opened so that the user could insert and edit a formula without leaving the application, only the menus and the object bars were changed. After the formula editor capability was used to enter the data object, double clicking on the embedded object launched the formula editor capability so that the formula could be edited. Again, this was done without leaving the application. 
   SUMMARY OF THE INVENTION 
   According to the principles of this invention, inserting or editing a data object like a mathematical formula or special character in a computer-generated document is facilitated and sped up in comparison to the prior art methods that required use of a formula editor. A method of inserting a data object into a computer-generated document includes inputting instruction symbols representing the data object into the document in the form of text characters, selecting the document portion containing instruction symbols, and converting the instruction symbols contained in the selected document portion into a data object represented by the instruction symbols. 
   With the present invention it is possible to input the data object, which may be a mathematical formula or a Greek, Chinese, Korean, Cyrillic, Arabic, Hebrew, or Japanese character, or any other character or symbol, and which can be represented by certain instruction symbols, into the document using standard characters, which are also used for creating a text document. The user does not need to leave the document and can input the instruction symbols in the same way as the text characters, for example by typing on a keyboard. 
   If the selected document portion contains characters, which are not part of an instruction these characters remain unchanged during the converting operation. Those unchanged characters may be variables like a, b, or x in a mathematical formula. 
   In one embodiment, the converted data object is inserted into the document at the position of the selected document portion. The inserted data object is formatted depending on a surrounding content, for example, the same as the format of text in the same line. The inserted data object is automatically stored with the document in this embodiment. The inserted data object is reconvertible into the original document portion for editing purposes. 
   The document portion including the instruction symbols may be input by means of speech decoding. In this case, the present invention is particularly advantageous since the instruction symbols (in contrast to the mathematical symbol itself) may be expressed orally. 
   One embodiment of the invention allows fast and easy generation and editing of a data object like a mathematical formula or special characters. This is particularly useful for simple and short data objects and for data objects, which the user needs frequently and for which the user easily memorizes the instruction symbols representing these data objects. For inserting the object, the user needs not to enter a special tool like a formula editor and then return to the original document. Another advantage of the present invention is that it allows the input of the data objects by speech decoding since the instruction symbols can be expressed orally. 
   Another embodiment of the invention provides a computer program for inserting, on a computer, a data object into a document, comprising inserting instruction symbols representing the data object in the form of text characters into the document, selecting a document portion containing instruction symbols, and converting the instruction symbols contained in the selected document portion into the data object represented by the instruction symbols. 
   Program code may be embodied in any form of a computer program product. A computer program product comprises a medium configured to store or transport computer readable code, or in which computer readable code may be embedded. Some example of computer program products are CD-ROM discs, ROM cards, floppy discs, magnetic tapes, computer hard drives, servers on a network and signals transmitted over a network representing computer readable program code. 
   According to a still further embodiment, the present invention provides a software tool providing instructions for inserting a data object into a computer-generated document by inserting instruction symbols inputted in the form of text characters and representing the data object into the document, converting instruction symbols contained in a selected document portion into the data object represented by the instruction symbols, inserting the converted data object into the document, and providing signals for displaying the document including the converted data object. 
   According to another embodiment, the present invention provides a computer-generated document including a data object generated by a conversion of instruction symbols inputted in the form of text characters, wherein the data object is reconvertible into the instruction symbols. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
       FIG. 1  is a schematic representation of a prior art document containing a mathematical formula. 
       FIG. 2A  is an example of a text document containing instruction symbols representing a data object according to the present invention. 
       FIG. 2B  is a schematic representation of the text document shown in  FIG. 2A  after conversion of a data object. 
       FIG. 2C  is a process flow diagram for the method of the present invention. 
       FIG. 3A  is a schematic illustration of a computer system to which the present invention may be applied. 
       FIG. 3B  is a schematic illustration of a client-server computer system in which the present invention may be transferred and/or downloaded. 
   

   DETAILED DESCRIPTION 
   According to the principles of this invention, a user enters a formula in a computer-generated document by simply typing in text representing the formula and selecting this text. In response to the selection of the text representing the formula, the text representing the formula is automatically converted to a mathematical formula and inserted in the computer-generated document as a data object. 
   Consequently, with this invention, a user generating a document on a computer no longer has to continually open a formula editor to enter a formula. Rather, the user simply continues to input text information in the same form as the rest of the document including text that describes the formula. Similarly, a user can type in text representing a special character, e.g., a Greek, Chinese, Korean, Cyrillic, Arabic, Hebrew, or Japanese character, or any other character or symbol, and use the method of this invention to automatically convert the text representing the special character to a data object that is inserted in the computer-generated document. 
   According to the principles of this invention, in a text-based formula generation method  205 , a user inputs text in an input text operation  221  ( FIG. 2C ) into a computer-generated document  200 A (FIG.  2 A), which is displayed on a display screen  210  by an application  319  ( FIG. 3A ) executing on a computer processor  312 C. In operation  221 , ( FIG. 2C ) the user inputs the text using, for example, a keyboard in input units  320 C ( FIG. 3A ) of a computer system  300 C, which is representative of a computer system input device. The text, however, can be input using another suitable input technique and/or input device, e.g. voice recognition processing or the like. 
   Input text operation  221  transfers to formula check operation  222 . If the user does not want to input a formula, formula check operation  222  returns to input text operation  221 . Conversely, if the user wants to input a formula into document  200 A, formula check operation  222 , which is carried out by the user, transfers to input instruction operation  223 . 
   In input instruction operation  223 , the user inputs the formula using text instruction symbols via one of input units  320 C. For example, as illustrated in  FIG. 2A , the user inputs the text portion “x equal sqrt a over b”, which includes the text instruction symbols, equal, sqrt, and over. The user is not required to change modes of input, and is not required to access a formula editor and type the formula into the editor, but rather the user simply continues inputting characters in a conventional fashion. 
   After completing the text input for the desired formula in input instruction operation  223 , the user selects the text formula instruction in select instruction  224 . In this embodiment, the user first highlights text formula instruction  212  and then moves cursor  211  to an equation icon  213 . With cursor  211  on equation icon  213  and with text formula instruction  212  highlighted, the user clicks a mouse button to complete select instruction operation  224 . In more general terms, select instruction operation  224  identifies a text formula instruction  212  for a generate formula method  230 . Operations  221  to  224  form a text formula instruction generation and identification method  220 . 
   In generate formula method  230 , formula check operation  231  determines whether the user selected a text formula instruction. In this embodiment, check operation  231  determines whether the user clicked on equation icon  213 . If the user selected a text formula instruction, check operation  231  transfers to convert instruction operation  233  and otherwise to continue operation  232 . In one embodiment, check operation  231  is part of an event handler of application  319 , and if the event is not a text formula instruction selection input, event handling continues in continue operation  232  and the application continues as in the prior art. 
   However, if a text formula instruction selection input event occurred, processing transfers to convert instruction operation  233 . Convert instruction operation  233  cuts the selected text formula instruction and pastes the selected text formula instruction into a call to a formula editor that can process the text formula instruction. For example, a prior art formula editor is modified to receive a text formula instruction and output a data object that is a corresponding formula. The modified formula editor executes in the background and the user is unaware of its existence. Upon the modified formula editor returning a data object, which in this example is a mathematical formula 
         x   =         a   b       ·       ,       
 
combinations of characters in the text formula instruction, which do not represent text instruction symbols, like the variables x, a and b in this example, remain unchanged. Hence, the creation of a formula containing variables is possible. Upon return of the mathematical formula, i.e., the data object, processing transfers from convert instruction operation  233  to insert formula operation  234 .
 
   In insert formula operation  234 , the data object, i.e., formula  214 , is inserted in document  200 B at the location from which the text formula instruction sequence was cut, and is displayed on display unit  210 . Preferably, the formula is formatted like the surrounding text so that the visual appearance of text document  200 B containing the formula is optimized. However, in one embodiment, the user can include text instructions to format any part, or all of the formula in a specific format, which may be different from the format of the surrounding text. 
   Following insert formula operation  234 , document complete check operation  235  determines whether the user has entered an instruction to indicate the document is complete. If a document complete instruction has been issued, the finished document is saved. Preferably, the inserted data object is stored together with the text document in a memory, e.g., memory  311 B, which is this case is located in a file server  300 B. If the document is not complete, check operation  235  returns to input text operation  221 . 
   Those of skill in the art will appreciate that the method of this invention can be multithreaded. For example, one thread permits the user to continue entering additional text, while another thread executes the text formula instruction. Also, as illustrated in  FIGS. 2A and 2B , the content of a text document  200 A, may include in addition to the text data also other data like diagrams, graphics or tables. The text document also may be, for example, an HTML- or XML-document. In addition, the present invention is not restricted to text documents. 
   Hence, according to the principles of this invention, if a user wishes to input a special data object like a formula into the text document, the user enters the formula in the form of a text formula instruction that includes text instruction symbols and variables. For example, the formula 
       a   b       
 
is represented by “a over b”. Here, the characters “a” and “b” represent variables and “over” is a text instruction symbol representing a fraction bar. Other examples of text formula instructions are “sqrt a” for √{square root over (a)}, “3 ind 1” for 3 1  and “int (a,b) Omega dt” for 
         ∫   a   b     ⁢     Ω   ⁢       ⅆ   t     .           
 
From the last example, it is obvious that the present invention is also very useful for inserting special characters like Greek characters into a text document. “pi” may represent the Greek character π, “alpha” may represent α or “lambda” may represent λ. It is also possible to distinguish between small and capital letters, “Lambda” may for example represent Λ. It is immediately apparent that typing the instruction symbols is in many cases much easier and faster than using a special program like a formula editor or a list box for Greek symbols. The same can apply to other special characters like Chinese, Korean, Cyrillic, Arabic, Hebrew, or Japanese characters, or any other character or symbol characters. In another embodiment, a character, e.g., a percent sign, is used before the name of the character to assist in distinguishing between when the user wants the text word, and when the user wants the Greek or other symbol.
 
   Table 1 lists a number of different formula symbols that can be generated in using a text formula instruction. Notice that in each instance, the text formula instruction utilizes only characters that are found on a conventional computer keyboard. The last column in a row of Table 1 gives a simple example of a text instruction for a formula that utilizes the symbol presented in the first column of the row. In the last column, a, b, x, y, and z are used as variables. The text instruction symbol is in a bold font. 
   
     
       
             
             
             
             
           
         
             
               TABLE 1 
             
             
                 
             
             
               Symbol 
                 
                 
                 
             
             
               Presented 
                 
                 
               Example of 
             
             
               in 
                 
                 
               text formula 
             
             
               Formula 
               Type 
               Description 
               instruction 
             
             
                 
             
           
           
             
               + 
               Unary 
               Plus Sign 
               +a 
             
             
                 
               operator 
             
             
               − 
               Unary 
               Minus Sign 
               −a 
             
             
                 
               operator 
             
             
               ± 
               Unary 
               Plus Minus Sign 
               plusminus a 
             
             
                 
               operator 
             
             
               ∓ 
               Unary 
               Minus Plus Sign 
               minusplus a 
             
             
                 
               operator 
             
             
               
                         
               
               Unary 
               Logical 
               neg a 
             
             
                 
               operator 
               negation 
             
             
               |         | 
               Unary 
               Absolute value 
               abs a 
             
             
                 
               operator/ 
             
             
                 
               function 
             
             
               ! 
               Unary 
               Factorial 
               fact a 
             
             
                 
               operator/ 
             
             
                 
               function 
             
             
               √ 
               Unary 
               Square root 
               sqrt a 
             
             
                 
               operator/ 
             
             
                 
               function 
             
             
                 n √ 
               Unary 
               n-th root 
               nroot n a -- 
             
             
                 
               operator/ 
                 
               where n is the 
             
             
                 
               function 
                 
               desired nth 
             
             
                 
                 
                 
               root of a 
             
             
                 
               Unary 
               User-defined 
               uoper % theta x 
             
             
                 
               operator 
               operator 
             
             
               = 
               Binary 
               Equal 
               a = b 
             
             
                 
               operator/ 
             
             
                 
               relation 
             
             
               ≠ 
               Binary 
               Not equal 
               a neq b, or 
             
             
                 
               operator/ 
                 
               a &lt;&gt; b 
             
             
                 
               relation 
             
             
               + 
               Binary 
               Addition 
               a + b 
             
             
                 
               operator 
             
             
               ⊕ 
               Binary 
               Add symbol in 
               a oplus b 
             
             
                 
               operator 
               circle 
             
             
               − 
               Binary 
               Substraction 
               a − b 
             
             
                 
               operator 
             
             
               ⊖ 
               Binary 
               Subtract symbol 
               a ominus b 
             
             
                 
               operator 
               in circle 
             
             
               * 
               Binary 
               Multiply 
               a * b 
             
             
                 
               operator 
             
             
               • 
               Binary 
               Dot product 
               a cdot b 
             
             
                 
               operator 
             
             
               ⊙ 
               Binary 
               Dot product in 
               a odot b 
             
             
                 
               operator 
               a circle 
             
             
               × 
               Binary 
               Multiplication 
               a times b 
             
             
                 
               operator 
             
             
               
                         
               
               Binary 
               Multiply symbol 
               a otimes b 
             
             
                 
               operator 
               in circle 
             
             
               / 
               Binary 
               Division 
               a / b 
             
             
                 
               operator 
             
             
               / 
               Binary 
               Slash for 
               a slash b 
             
             
                 
               operator 
               quotient set 
               slash c 
             
             
                 
                 
               between two 
             
             
                 
                 
               characters 
             
             
                         /           
               Binary 
               Slash between 
               a wideslash b 
             
             
                 
               operator 
               two characters, 
             
             
                 
                 
               of which the 
             
             
                 
                 
               left character 
             
             
                 
                 
               is superscript, 
             
             
                 
                 
               and the right 
             
             
                 
                 
               is subsript 
             
             
                         \           
               Binary 
               Back Slash 
               a widebslash b 
             
             
                 
               operator 
               between two 
             
             
                 
                 
               characters, of 
             
             
                 
                 
               which the right 
             
             
                 
                 
               character is 
             
             
                 
                 
               superscript, 
             
             
                 
                 
               and the left 
             
             
                 
                 
               subscript 
             
             
               
                         
               
               Binary 
               Slash in circle 
               a odivide b 
             
             
                 
               operator 
             
             
               ÷ 
               Binary 
               Division 
               a div b 
             
             
                 
               operator 
             
             
               
                 a 
               
               Binary 
               Division/ 
               a over b 
             
             
               b 
               operator 
               Fraction 
             
             
               
                         
               
               Binary 
               Logical AND 
               a and b, or 
             
             
                 
               operator 
                 
               a &amp; b 
             
             
               
                         
               
               Binary 
               Logical Or 
               a or b, or 
             
             
                 
               operator 
                 
               a | b 
             
             
               ∘ 
               Binary 
               Concatenate 
               a circ b 
             
             
                 
               operator 
             
             
               | 
               Binary 
               Divides 
               5 divides 30 
             
             
                 
               operator 
             
             
               
                         
               
               Binary 
               Does not Divide 
               7 ndivides 30 
             
             
                 
               operator 
             
             
               &gt; 
               Binary 
               Greater than 
               a gt b, or 
             
             
                 
               operator/ 
                 
               a &gt; b 
             
             
                 
               Relation 
             
             
               &lt; 
               Binary 
               Less than 
               a le b, or 
             
             
                 
               operator/ 
                 
               a &lt; b 
             
             
                 
               Relation 
             
             
               ≧ 
               Binary 
               Greater than or 
               a gt b, or 
             
             
                 
               operator/ 
               equal to 
               a &gt;= b 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Greater than- 
               a gtslant b 
             
             
                 
               operator/ 
               equal to 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Much greater 
               a gg b, or 
             
             
                 
               operator/ 
               than 
               a &gt;&gt; b 
             
             
                 
               Relation 
             
             
               ≦ 
               Binary 
               Less than or 
               a le b, or 
             
             
                 
               operator/ 
               equal to 
               a &lt;= b 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Less than-equal 
               a leslant b 
             
             
                 
               operator/ 
               to 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Much less than 
               a 11 b, or 
             
             
                 
               operator/ 
                 
               a &lt;&lt; b 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Is defined as/ 
               a def b 
             
             
                 
               operator/ 
               by definition 
             
             
                 
               Relation 
               equal to 
             
             
               ≡ 
               Binary 
               Is equivalent/ 
               a equiv b 
             
             
                 
               operator/ 
               congruent to 
             
             
                 
               Relation 
             
             
               ≈ 
               Binary 
               Is 
               a approx b 
             
             
                 
               operator/ 
               approximately 
             
             
                 
               Relation 
             
             
               ˜ 
               Binary 
               Is similar to 
               a sim b 
             
             
                 
               operator/ 
             
             
                 
               Relation 
             
             
               ≅ 
               Binary 
               Is similar or 
               a simeq b 
             
             
                 
               operator/ 
               equal to 
             
             
                 
               Relation 
             
             
               ∝ 
               Binary 
               Is proportional 
               a prop b 
             
             
                 
               operator/ 
               to 
             
             
                 
               Relation 
             
             
               ⊥ 
               Binary 
               Is orthogonal 
               a ortho b 
             
             
                 
               operator/ 
               to 
             
             
                 
               Relation 
             
             
               ∥ 
               Binary 
               Is parallel to 
               a parallel b 
             
             
                 
               operator/ 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Correspondence 
               a transl b 
             
             
                 
               operator/ 
               symbol image of 
             
             
                 
               Relation 
             
             
               
                         
               
               Binary 
               Correspondence 
               a transr b 
             
             
                 
               operator/ 
               symbol original 
             
             
                 
               Relation 
               of 
             
             
               ∈ 
               Binary 
               Is contained in 
               a in b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               ∉ 
               Binary 
               Is not 
               a notin b 
             
             
                 
               operator/ 
               contained in 
             
             
                 
               Set operator 
             
             
               ⊂ 
               Binary 
               Subset 
               a subset b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Subset or equal 
               a subseteq b 
             
             
                 
               operator/ 
               to 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Not subset to 
               a nsubset b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Not subset or 
               a nsubseteq b 
             
             
                 
               operator/ 
               equal to 
             
             
                 
               Set operator 
             
             
               ⊃ 
               Binary 
               Superset 
               a supset b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Superset or 
               a supseteq b 
             
             
                 
               operator/ 
               equal to 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Not superset to 
               a nsupset b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Not superset or 
               a nsupseteq b 
             
             
                 
               operator/ 
               equal to 
             
             
                 
               Set operator 
             
             
               
                         
               
               Binary 
               Contains 
               a owns b, or 
             
             
                 
               operator/ 
                 
               a ni b 
             
             
                 
               Set operator 
             
             
               ∪ 
               Binary 
               Union of Sets 
               a union b 
             
             
                 
               operator/ 
             
             
                 
               Set operator 
             
             
               ∩ 
               Binary 
               Intersection of 
               a intersection 
             
             
                 
               operator/ 
               Sets 
               b 
             
             
                 
               Set operator 
             
             
               \ 
               Binary 
               Difference 
               a setminus b, 
             
             
                 
               operator/ 
               between Sets 
               or 
             
             
                 
               Set operator 
                 
               a bslash b 
             
             
               X n   
               Binary 
               x with index n 
               x sub n 
             
             
                 
               operator 
             
             
               X n   
               Binary 
               n-th power of x 
               x sup n 
             
             
                 
               operator 
             
             
               → 
               Binary 
               Toward 
               a toward b 
             
             
                 
               operator/ 
             
             
                 
               Relation 
             
             
                 
               Binary 
               User defined 
               x boper % theta 
             
             
                 
               opeator 
               binary operator 
               y --used to 
             
             
                 
                 
                 
               insert greek 
             
             
                 
                 
                 
               character 
             
             
                 
                 
                 
               theta 
             
             
               Σ 
               Operator 
               Sum 
               Sum x sub i 
             
             
               Π 
               Operator 
               Product 
               prod x sub i 
             
             
               
                         
               
               Operator 
               Coproduct 
               coprod x sub I 
             
             
               lim 
               Operator 
               Limit 
               lim x toward 
             
             
                 
                 
                 
               infinity 
             
             
               lim inf 
               Operator 
               Limit inferior 
               liminf 
             
             
               lim sup 
               Operator 
               Limit superior 
               limsup 
             
             
               
                         
               
               Operator/ 
               Physics 
               hbar 
             
             
                 
               Physics 
               Constant 
             
             
               
                         
               
               Operator/ 
               Physics 
               lambdabar 
             
             
                 
               Physics 
               Constant 
             
             
               ∃ 
               Operator/ 
               Existential 
               a exists b 
             
             
                 
               Logic 
               quantifier, 
             
             
                 
                 
               there is at 
             
             
                 
                 
               least one 
             
             
               ∀ 
               Operator/ 
               Universal 
               a forall b 
             
             
                 
               Logic 
               quantifier, for 
             
             
                 
                 
               all 
             
             
               
                         
               
               Operator/ 
               Arrow with 
               a drarrow b 
             
             
                 
               Logic 
               double line to 
             
             
                 
                 
               the left 
             
             
               
                         
               
               Operator/ 
               Arrow with 
               a drarrow b 
             
             
                 
               Logic 
               double line to 
             
             
                 
                 
               the right 
             
             
               
                         
               
               Operator 
               Arrow with 
               a dlrarrow b 
             
             
                 
               Logic 
               double line to 
             
             
                 
                 
               the left and to 
             
             
                 
                 
               the right 
             
             
               ↑ 
               Operator 
               Up arrow 
               a uparrow b 
             
             
               ↓ 
               Operator 
               Down arrow 
               a downarrow b 
             
             
               ← 
               Operator 
               Left arrow 
               a leftarrow b 
             
             
               → 
               Operator 
               Right arrow 
               a rightarrow b 
             
             
               ∫ 
               Operator 
               Integral 
               in xdx 
             
             
               ∫∫ 
               Operator 
               Double Integral 
               iint 
             
             
                 
                 
                 
               f (x,y) dxdy 
             
             
               ∫∫∫ 
               Operator 
               Triple Integral 
               iiint 
             
             
                 
                 
                 
               f (x,y,z) dxdydz 
             
             
               
                         
               
               Operator 
               Curve integral 
               lint 
             
             
               
                         
               
               Operator 
               Double curve 
               llint 
             
             
                 
                 
               integral 
             
             
               
                         
               
               Operator 
               Triple curve 
               lllint 
             
             
                 
                 
               integral 
             
             
                 
               Operator 
               User defined 
               oper % union 
             
             
                 
                 
               operator 
               from {i = 1} to 
             
             
                 
                 
                 
               n x_{i} 
             
             
                 
               Operator 
               Range from . . . 
               from {i = 1} to 
             
             
                 
                 
               to 
               n 
             
             
                 
               Operator 
               Lower limit of 
               from {i = 1} 
             
             
                 
                 
               an operator 
             
             
                 
               Operator 
               Upper limit of 
               to n 
             
             
                 
                 
               an operator 
             
             
               sin() 
               Function 
               Sine 
               sin x 
             
             
               cos() 
               Function 
               Cosine 
               cos x 
             
             
               tan() 
               Function 
               Tangent 
               tan x 
             
             
               cot() 
               Function 
               Cotangent 
               cot x 
             
             
               arcsin() 
               Function 
               Arcsine 
               arcsin x 
             
             
               arccos() 
               Function 
               Arccosine 
               arccos x 
             
             
               arctan() 
               Function 
               Arctangent 
               arctan x 
             
             
               arccot() 
               Function 
               Arccotangent 
               arccot x 
             
             
               sinh() 
               Function 
               Hyperbolic sine 
               sinh x 
             
             
               cosh() 
               Function 
               Hyperbolic 
               cosh x 
             
             
                 
                 
               cosine 
             
             
               tanh() 
               Function 
               Hyperbolic 
               tanh x 
             
             
                 
                 
               tanget 
             
             
               coth() 
               Function 
               Hyperbolic 
               coth x 
             
             
                 
                 
               cotangent 
             
             
               arsinh() 
               Function 
               Area hyperbolic 
               arsinh x 
             
             
                 
                 
               sine 
             
             
               arcosh() 
               Function 
               Area hyperbolic 
               arcosh x 
             
             
                 
                 
               cosine 
             
             
               artanh() 
               Function 
               Area hyperbolic 
               artanh x 
             
             
                 
                 
               tanget 
             
             
               arcoth() 
               Function 
               Area hyperbolic 
               arcoth x 
             
             
                 
                 
               cotangent 
             
             
               exp() 
               Function 
               General 
               exp x 
             
             
                 
                 
               exponential 
             
             
                 
                 
               function 
             
             
               ln 
               Function 
               Natural 
               ln x 
             
             
                 
                 
               logarithm 
             
             
               log 
               Function 
               Logarithm 
               log x 
             
             
                 
                 
               base 10 
             
             
               e □   
               Function 
               Natural 
               func ^{x} 
             
             
                 
                 
               exponential 
             
             
                 
                 
               function 
             
             
               IN 
               Mathematical 
               Natural number 
               setn a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Integer 
               setz a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Rational number 
               setq a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Real number 
               setr a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Complex number 
               setc a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Cardinal number 
               aleph a 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               back epsilon 
               backepsilon 
             
             
                 
               symbol 
             
             
               Ø 
               Mathematical 
               Empty set 
               emptyset 
             
             
                 
               symbol 
             
             
               
                         
               
               Mathematical 
               Real part of a 
               re a 
             
             
                 
               symbol 
               complex number 
             
             
               
                         
               
               Mathematical 
               Imaginary part 
               im a 
             
             
                 
               symbol 
               of a complex 
             
             
                 
                 
               number 
             
             
               ∞ 
               Mathematical 
               Infinity 
               infinity, 
             
             
                 
               symbol 
                 
               or 
             
             
                 
                 
                 
               infty 
             
             
               ∇ 
               Mathematical 
               Nabla vector 
               nabla x 
             
             
                 
               symbol 
             
             
               ∂ 
               Mathematical 
               Partial 
               partial x 
             
             
                 
               symbol 
               differentiation 
             
             
                 
                 
               or set margin 
             
             
               
                         
               
               Mathematical 
               p function 
               wp 
             
             
                 
               symbol 
             
             
               ... 
               Other symbol 
               Three dots 
               dotsaxis 
             
             
                 
                 
               vertically in 
             
             
                 
                 
               the symbol 
             
             
                 
                 
               center 
             
             
               
                         
               
               Other symbol 
               Three dots 
               dotsup, 
             
             
                 
                 
               diagonally from 
               or 
             
             
                 
                 
               lower left to 
               dotsdiag 
             
             
                 
                 
               upper right 
             
             
               
                         
               
               Other symbol 
               Three dots 
               dotsdown 
             
             
                 
                 
               diagonally from 
             
             
                 
                 
               upper right to 
             
             
                 
                 
               lower left 
             
             
               ... 
               Other symbol 
               Three dots 
               dotslow 
             
             
                 
                 
               horizontally 
             
             
                 
                 
               below 
             
             
               
                         
               
               Other symbol 
               Three dots 
               dotsvert 
             
             
                 
                 
               vertical 
             
             
               □ 
               Other symbol 
               Placeholder 
               &lt;?&gt; 
             
             
               () 
               Bracket with 
               Normal round 
               (a over b) 
             
             
                 
               grouping 
               left and right 
               oplus c 
             
             
                 
               function 
               brackets 
             
             
               [] 
               Bracket with 
               Normal left and 
               [a over b] 
             
             
                 
               grouping 
               right square 
               oplus c 
             
             
                 
               function 
               brackets 
             
             
               
                         
               
               Bracket with 
               Left and right 
               icibracket . . . 
             
             
                 
               grouping 
               double square 
               rdbracket 
             
             
                 
               function 
               brackets 
             
             
               {} 
               Bracket with 
               Left and right 
               ibrace . . . 
             
             
                 
               grouping 
               curly brackets, 
               rbrace 
             
             
                 
               function 
               set bracket 
             
             
               ︷ 
               Bracket with 
               Scalable curly 
               . . . 
             
             
                 
               grouping 
               set bracket on 
               overbrace 
             
             
                 
               function 
               top 
               . . . 
             
             
               ︸ 
               Bracket with 
               Scalable curly 
               . . . 
             
             
                 
               grouping 
               set bracket 
               underbrace 
             
             
                 
               function 
               below 
               . . . 
             
             
               &lt;&gt; 
               Bracket with 
               Left and right 
               langle . . . 
             
             
                 
               grouping 
               pointed 
               rangle 
             
             
                 
               function 
               brackets 
             
             
               &lt;|&gt; 
               Bracket with 
               Left and right 
               langle . . . 
             
             
                 
               grouping 
               pointed 
               mline . . . 
             
             
                 
               function 
               operator 
               rangle 
             
             
                 
                 
               brackets 
             
             
               &lt;|&gt; 
               Bracket with 
               Scalable left 
               left langle 
             
             
                 
               grouping 
               and right 
               . . . mline 
             
             
                 
               function 
               pointed 
               . . . right 
             
             
                 
                 
               operator 
               rangle 
             
             
                 
                 
               brackets 
             
             
               | | 
               Bracket with 
               Left and right 
               lline . . . 
             
             
                 
               grouping 
               vertical lines 
               rline 
             
             
                 
               function 
             
             
               ∥ ∥ 
               Bracket with 
               Left and right 
               ldline . . . 
             
             
                 
               grouping 
               double lines 
               rdline 
             
             
                 
               function 
             
             
               └ ┘ 
               Bracket with 
               Left and right 
               lfloor . . . 
             
             
                 
               grouping 
               lines with 
               rfloor 
             
             
                 
               function 
               lower edges 
             
             
               ┌ ┐ 
               Bracket with 
               Left and right 
               lceil . . . 
             
             
                 
               grouping 
               lines with 
               rceil 
             
             
                 
               function 
               upper edges 
             
             
                 
               Bracket with 
               Automatic 
             
             
                 
               grouping 
               sizing of 
             
             
                 
               function 
               brackets by 
             
             
                 
                 
               putting left 
             
             
                 
                 
               and right (left 
             
             
                 
                 
               . . . right . . . ) 
             
             
                 
                 
               up front, 
             
             
                 
                 
               e.g., left(a 
             
             
                 
                 
               over b right) 
             
             
                 
                 
               or left lceil 
             
             
                 
                 
               . . . right 
             
             
                 
                 
               lceil. This 
             
             
                 
                 
               way round, 
             
             
                 
                 
               square, double 
             
             
                 
                 
               square, single, 
             
             
                 
                 
               double, single, 
             
             
                 
                 
               curley, 
             
             
                 
                 
               pointed, and 
             
             
                 
                 
               operator 
             
             
                 
                 
               brackets can be 
             
             
                 
                 
               changed. 
             
             
               ( 
               Bracket, 
               round left 
               \( 
             
             
                 
               also 
               bracket 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ) 
               Bracket, 
               Normal round 
               \) 
             
             
                 
               also 
               right bracket 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               [ 
               Bracket, 
               Normal left 
               \[ 
             
             
                 
               also 
               square bracket 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ] 
               Bracket, 
               Normal right 
               \] 
             
             
                 
               also 
               square bracket 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               { 
               Bracket, 
               Left curly 
               \lbrace, 
             
             
                 
               also 
               bracket 
               or, 
             
             
                 
               widowed, 
                 
               \{ 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               } 
               Bracket, 
               Right curly 
               \lbrace, 
             
             
                 
               also 
               bracket 
               or, 
             
             
                 
               widowed, 
                 
               \} 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               &lt; 
               Bracket, 
               Left pointed 
               \langle 
             
             
                 
               also 
               bracket 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               &gt; 
               Bracket, 
               Right pointed 
               \rangle 
             
             
                 
               also 
               brackets 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               |... 
               Bracket, 
               Left vertical 
               \lline 
             
             
                 
               also 
               line 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ...| 
               Bracket, 
               Right vertical 
               \rline 
             
             
                 
               also 
               line 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ∥... 
               Bracket, 
               Left double 
               \ldline 
             
             
                 
               also 
               line 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ...∥ 
               Bracket, 
               Right double 
               \rdline 
             
             
                 
               also 
               lines 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               └ 
               Bracket, 
               Left line with 
               \lfloor 
             
             
                 
               also 
               lower edge 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ┘ 
               Bracket, 
               Right line with 
               \rfloor 
             
             
                 
               also 
               lower edge 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ┌ 
               Bracket, 
               Left line with 
               \lceil 
             
             
                 
               also 
               upper edge 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               ┐ 
               Bracket, 
               Right line with 
               \rceil 
             
             
                 
               also 
               upper edge 
             
             
                 
               widowed, 
             
             
                 
               without 
             
             
                 
               grouping 
             
             
                 
               function 
             
             
               □ □   
               Indexes and 
               Right index 
               _, or 
             
             
                 
               exponents (su 
                 
               sub, or 
             
             
                 
               b-and 
                 
               rsub 
             
             
                 
               superscript) 
             
             
               □ □   
               Indexes and 
               Right exponent 
               ^, or 
             
             
                 
               exponents (su 
                 
               sup, or 
             
             
                 
               b-and 
                 
               rsup 
             
             
                 
               superscript) 
             
             
                 □ □ 
               Indexes and 
               Left index 
               lsub 
             
             
                 
               exponents(su 
             
             
                 
               b-and 
             
             
                 
               superscript) 
             
             
                 □ □ 
               Indexes and 
               Left exponent 
               lsup 
             
             
                 
               exponents (su 
             
             
                 
               b-and 
             
             
                 
               superscript) 
             
             
                 
               Indexes and 
               Exponent 
               csup 
             
             
                 
               exponents(su 
               directly above 
             
             
                 
               b-and 
               a character 
             
             
                 
               superscript) 
             
             
                 
               Indexes and 
               Index directly 
               csub 
             
             
                 
               exponents (su 
               below a 
             
             
                 
               b-and 
               character 
             
             
                 
               superscript) 
             
             
                 
               Formatting 
               Horizontal 
               alignl, or 
             
             
                 
                 
               alignment -- 
               alignc, or 
             
             
                 
                 
               left, center, 
               alignr 
             
             
                 
                 
               right 
             
             
                 
               Formatting 
               Space/Blank 
               ˜ 
             
             
                 
               Formatting 
               Small space/ 
                 
             
             
                 
                 
               small blank 
             
             
                 
               Formatting 
               Newline 
               newline 
             
             
               □ 
               Formatting 
               Binom 
               binom 
             
             
               □ 
             
             
               □ 
               Formatting 
               Stack 
               stack{x#y#z} 
             
             
               □ 
             
             
               □ 
             
             
               □□ 
               Formatting 
               Matrix 
               matrix{a#b##c#d} 
             
             
               □□ 
             
             
               ’ 
               Attribute 
               Accent to the 
               acute a 
             
             
                 
               with fixed 
               right above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               — 
               Attribute 
               Horizontal bar 
               bar a 
             
             
                 
               with fixed 
               above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Upside down 
               breve a 
             
             
                 
               with fixed 
               roof above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Upside down 
               check 
             
             
                 
               with fixed 
               roof 
             
             
                 
               character 
             
             
                 
               width 
             
             
               ° 
               Attribute 
               Circle above a 
               circle a 
             
             
                 
               with fixed 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               . 
               Attribute 
               Dot above a 
               dot a 
             
             
                 
               with fixed 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               .. 
               Attribute 
               Two dots above 
               ddot a 
             
             
                 
               with fixed 
               a character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               ... 
               Attribute 
               Three dots 
               dddot a 
             
             
                 
               with fixed 
               above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               ‘ 
               Attribute 
               Accent to the 
               grave a 
             
             
                 
               with fixed 
               left above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Roof above a 
               hat a 
             
             
                 
               with fixed 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               ˜ 
               Attribute 
               Tilde above a 
               tilde a 
             
             
                 
               with fixed 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               → 
               Attribute 
               Vector arrow 
               vec a 
             
             
                 
               with fixed 
               above a 
             
             
                 
               character 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Horizontal bar 
               underline a 
             
             
                 
               with 
               below a 
             
             
                 
               variable 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Horizontal bar 
               overline a 
             
             
                 
               with 
               above a 
             
             
                 
               variable 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Horizontal bar 
               overstrike a 
             
             
                 
               with 
               through a 
             
             
                 
               variable 
               character 
             
             
                 
               character 
             
             
                 
               width 
             
             
               → 
               Attribute 
               Wide vector 
               widevec a 
             
             
                 
               with 
               arrow, adjusts 
             
             
                 
               variable 
               to the 
             
             
                 
               character 
               character size 
             
             
                 
               width 
             
             
               ˜ 
               Attribute 
               Wide tilde, 
               widetilde 
             
             
                 
               with 
               adjusts to the 
             
             
                 
               variable 
               character size 
             
             
                 
               character 
             
             
                 
               width 
             
             
               
                         
               
               Attribute 
               Wide roof, 
               widehat 
             
             
                 
               with 
               adjusts to the 
             
             
                 
               variable 
               character size 
             
             
                 
               character 
             
             
                 
               width 
             
             
                 
               Font 
               Italics 
               ital 
             
             
                 
               attributes 
             
             
                 
               Font 
               Remove italics 
               nitalic 
             
             
                 
               attributes 
             
             
                 
               Font 
               Bold 
               bold 
             
             
                 
               attributes 
             
             
                 
               Font 
               Remove bold 
               nbold 
             
             
                 
               attributes 
             
             
                 
               Font 
               Phantom 
               phantom 
             
             
                 
               attributes 
               character 
             
             
                 
               Font 
               Command to 
               font sans a 
             
             
                 
               attributes 
               change 
             
             
                 
                 
               characters; 
             
             
                 
                 
               first the font 
             
             
                 
                 
               name (sans, 
             
             
                 
                 
               serif, or 
             
             
                 
                 
               attributes 
             
             
                 
                 
               fixed) is 
             
             
                 
                 
               entered, then 
             
             
                 
                 
               the characters 
             
             
                 
                 
               to be changed 
             
             
                 
                 
               are entered. 
             
             
                 
               Font 
               Command to 
               size *2 font 
             
             
                 
               attributes 
               change the font 
               sans a 
             
             
                 
                 
               size; first the 
             
             
                 
                 
               size is 
             
             
                 
                 
               entered, then 
             
             
                 
                 
               the characters 
             
             
                 
                 
               to be changed 
             
             
                 
                 
               are entered; 
             
             
                 
                 
               for the entered 
             
             
                 
                 
               sizes arguments 
             
             
                 
                 
               following the 
             
             
                 
                 
               pattern n, +n, 
             
             
                 
                 
               −n *n or /n can 
             
             
                 
                 
               be indicated; 
             
             
                 
                 
               size +n and −n 
             
             
                 
                 
               are changed in 
             
             
                 
                 
               points(pt); a 
             
             
                 
                 
               percentage 
             
             
                 
                 
               change to 
             
             
                 
                 
               e.g. 17% must 
             
             
                 
                 
               be entered as 
             
             
                 
                 
               *1.17 
             
             
                 
               Font 
               The command to 
               color green 
             
             
                 
               attributes 
               change the 
               abc 
             
             
                 
                 
               character 
             
             
                 
                 
               color; first 
             
             
                 
                 
               color green 
             
             
                 
                 
               the color name 
             
             
                 
                 
               (blank, white, 
             
             
                 
                 
               cyna, magenta, 
             
             
                 
                 
               red, blue, 
             
             
                 
                 
               green and 
             
             
                 
                 
               yellow) is 
             
             
                 
                 
               entered, then 
             
             
                 
                 
               the characters 
             
             
                 
                 
               to be changed 
             
             
                 
                 
               are entered. 
             
             
                 
             
           
        
       
     
   
   In addition to easy generation of a formula, the present invention includes an easy way to edit a data object like a mathematical formula. The object is entered by, e.g., a mouse click, on the object, and then is reconverted into the text formula instruction containing the text instruction symbols. The user edits the object by editing the text formula instruction, selects the edited text formula instruction again, and converts the same again into a data object, as described above. The editing operation can thus be carried out easily without entering a special tool like a formula editor. 
   Further, those of skill in the art will appreciate that while memory  311 C is illustrated as one unit that can include both volatile memory and non-volatile memory, in most computer systems, memory  311 C is implemented as a plurality of memory units. In more general terms, method  205  is stored in a computer readable medium, and when method  205  is loaded from the computer readable medium into a memory of a device, the device is configured to be a special purpose machine that executes method  205 . Alternatively, the application used to execute method  220 , e.g., application  319 , may be stored in one computer readable medium, and method  230  stored in another computer readable medium. 
   Also, herein, a computer program product comprises a medium configured to store or transport computer readable code for method  205 , method  220 , and/or method  230  or in which computer readable code for method  205 , method  220 , and/or method  230  is stored. Some examples of computer program products are CD-ROM discs, ROM cards, floppy discs, magnetic tapes, computer hard drives, servers on a network and signals transmitted over a network representing computer readable program code. 
   As illustrated in  FIG. 3A , this storage medium may belong to computer system  300 C itself. However, the storage medium also may be removed from computer system  300 C. For example, method  205  may be stored in either memory  311 A or  311 B that is physically located in a location different from processor  312 C. The only requirement is that processor  312 C is coupled to memory. This could be accomplished in a client-server system, e.g. system  300 C is the client and system  300 B is the server, or alternatively via a connection to another computer via modems and analog lines, or digital interfaces and a digital carrier line. 
   For example, memory  311 C could be in a World Wide Web portal, while the display unit and processor are in a personal digital assistant (PDA), or a wireless telephone, for example, system  300 A. Conversely, the display unit and at least one of the input devices could be in a client computer, a wireless telephone, or a PDA, while the memory and processor are part of a server computer on a wide area network, a local area network, or the Internet. In this paragraph, method  205  that includes the application used to perform method  220 , as well as method  230  was considered. However, those of skill in the art will appreciate that a similar description can be made for only method  220  and for only method  230 . Accordingly, this description and that which follows is not repeated for each of the possible combinations and permutations for using and storing methods  220  and  230 . 
   More specifically, computer system  300 C, in one embodiment, can be a portable computer, a workstation, a two-way pager, a cellular telephone, a digital wireless telephone, a personal digital assistant, a server computer, an Internet appliance, or any other device that includes the components shown and that can execute method  205 . Similarly, in another embodiment, computer system  300 C can be comprised of multiple different computers, wireless devices, cellular telephones, digital telephones, two-way pagers, or personal digital assistants, server computers, or any desired combination of these devices that are interconnected to perform, method  205  as described herein. See, for example, FIG.  3 A. 
   Accordingly, a computer memory refers to a volatile memory, a non-volatile memory, or a combination of the two in any one of these devices. Similarly, a computer input unit and a display unit refers to the features providing the required functionality to input the information described herein, and to display the information described herein, respectively, in any one of the aforementioned or equivalent devices. 
   In view of this disclosure, method  230  and method  220  can be implemented in a wide variety of computer system configurations. In addition, method  205  could be stored as different modules in memories of different devices. For example, method  205  could initially be stored in a server computer, and then as necessary, a module of method  205  could be transferred to a client device and executed on the client device. Consequently, part of method  205  would be executed on the server processor, and another part of method  205  would be executed on the client device. In view of this disclosure, those of skill in the art can implement the invention of a wide-variety of physical hardware configurations using an operating system and computer programming language of interest to the user. 
   In yet another embodiment illustrated in  FIG. 3B , method  205  is stored in memory  311 B of system  300 B. Stored method  205  is transferred, over network  315  to memory  311 C in system  300 C. In this embodiment, network interfaces  330 B and  330 C can be analog modems, digital modems, or a network interface card. If modems are used, network  315  includes a communications network, and method  205  is downloaded via the communications network. 
   While the invention has been particularly shown with reference to a preferred embodiment thereof, it will be understood by those skilled in the art that various other changes in the form and details may be made therein without departing from the spirit and scope of the invention.