Methods and systems for generating a structured language model from a spreadsheet model

Abstract

In one embodiment of the present invention, there is provided a method for easily allowing a user of little to no programming language knowledge to convert a computerized spreadsheet model to a structured programming language model, which method includes: (i) receiving, from the user via a computer input device, outputs and inputs of the computerized spreadsheet model desired to be processed for conversion; (ii) checking the user entries for errors; (iii) if an error is found, then requesting corrected user entry; (iv) if no error is found, then identifying all relevant spreadsheet model cells based on the user entries; (v) processing formulas used in the spreadsheet model for parsing; (vi) converting the formulas into final form and determining calculation priority order; and (vii) generating the structured programming language model. The method of the present invention is carried out by a system including a computer having a user interface, a microprocessor and a storage unit, an input device electronically coupled to the computer, and a software program stored in the storage unit, the software program being programmed to operate the microprocessor for carrying out the steps of the invention.

Claims

What is claimed is:

1. A method for generating a structured programming language model from a spreadsheet model, the method requiring little to no knowledge of the structured programming language by a user and comprising:

receiving, from the user via a computer input device, outputs of the spreadsheet model that the user desires;

checking for errors in the user entries;

if error is detected, then requesting corrected user entries,

if no error is detected, then identifying relevant spreadsheet cells based on dependencies of the selected outputs;

for each relevant cell identified, identifying and adding precedent cells to set of relevant cells,

processing relevant formulas in the spreadsheet model for parsing;

receiving, from the user via the computer input device, information about inputs of the spreadsheet model;

converting the formulas into final form and determining calculation priority order; and

generating the structured programming model, which structured programming model can be used without the spreadsheet model.

2. The method of claim 1, further comprising identifying parent ranges that are convertible into arrays.

3. The method of claim 1, wherein the structured programming language model is in Java code.

4. The method of claim 1, wherein the structured programming language model is in C code.

5. The method of claim 1, wherein the step of receiving the outputs of the spreadsheet model includes receiving, from the user via the computer input device, names for the outputs.

6. The method of claim 1, wherein the step of receiving the information about the inputs of the spreadsheet model includes receiving, from the user via the computer input device, names for the inputs.

7. The method of claim 1, wherein the set of relevant cells is stored in a stack format, the ordering of the relevant cells in the stack based on calculation priority.

8. The method of claim 1, wherein the structured programming language model is providable over the Internet without exposing the proprietary mathematical logic of the model.

9. A method of easily allowing a user of little or no programming language knowledge to convert a computerized spreadsheet model to a structured programming language model, the method comprising:

receiving, from the user via a computer input device, outputs and inputs of the computerized spreadsheet model desired to be processed for conversion;

checking the user entries for errors;

if an error is found, then requesting corrected user entry;

if no error is found, then identifying all relevant spreadsheet model cells based on the user entries;

processing formulas used in the spreadsheet model for parsing;

converting the formulas into final form and determining calculation priority order; and

generating the structured programming language model, which structured programming model can be used without the spreadsheet model.

10. The method of claim 9, further comprising identifying parent ranges that are convertible into arrays.

11. The method of claim 9, wherein the structured programming language model is in Java code.

12. The method of claim 9, wherein the structured programming language model is in C code.

13. The method of claim 9, wherein the step of receiving the outputs and the inputs of the computerized spreadsheet model includes receiving names for the outputs and inputs.

14. The method of claim 9, further comprising the step of storing relevant spreadsheet model cells in a stack format, the ordering of the relevant cells in the stack based on calculation priority.

15. The method of claim 9, wherein the structured programming language model is providable without exposing the proprietary mathematical logic of the model.

16. The method of claim 9, wherein the structured programming language model is providable over the Internet without exposing the proprietary mathematical logic of the model.

17. A system for easily allowing a user of little or no programming language knowledge to convert a computerized spreadsheet model to a structured programming language model, the system comprising:

a computer having a user interface, a microprocessor and a storage unit;

an input device electronically coupled to the computer;

a software program stored in the storage unit, the software program being programmed to operate the microprocessor for:

requesting the user, via the user interface, and receiving from the user, via the input device, outputs and inputs of the computerized spreadsheet model desired to be processed for conversion;

checking the user entries for errors;

if an error is found, then requesting, via the user interface, corrected user entry;

if no error is found, then identifying all relevant spreadsheet model cells based on the user entries;

processing formulas used in the spreadsheet model for parsing;

converting the formulas into final form and determining calculation priority order; and

generating the structured programming language model, which structured programming model can be used without the spreadsheet model.

18. The system of claim 17, wherein the software program is further programmed to operate the microprocessor for identifying parent ranges that are convertible into arrays.

19. The system of claim 17, wherein the structured programming language model is in Java code.

20. The system of claim 17, wherein the structured programming language model is in C code.

21. The system of claim 17, further comprising a second computer that can access the computer over a telecommunication link, the second computer storing the computerized spreadsheet model that is converted by the software program operating on the computer.

22. The method of claim 1, wherein the structured programming model that is generated can be used on a computer other than a computer on which the spreadsheet model was developed.

23. The method of claim 22, wherein the structured programming model that is generated can be used with an operating system other than an operating system with which the spreadsheet model was developed.

24. The method of claim 9, wherein the structured programming model that is generated can be used on a computer other than a computer on which the spreadsheet model was developed.

25. The method of claim 24, wherein the structured programming model that is generated can be used with an operating system other than an operating system with which the spreadsheet model was developed.

26. The system of claim 16, wherein the structured programming model that is generated can be used on a computer other than a computer on which the spreadsheet model was developed.

27. The system of claim 26, wherein the structured programming model that is generated can be used with an operating system other than an operating system with which the spreadsheet model was developed.

Description

BACKGROUND OF THE INVENTION

Computerized spreadsheets, such as provided by Microsoft Corporation's Excel software product or Lotus Development Corporation's Lotus 1-2-3, have gained widespread use. Individuals and businesses routinely use computerized spreadsheets for a variety of purposes, such as accounting, finance and investments.

Generally, a spreadsheet is made up of rows and columns of individual cells. In Microsoft's Excel, for example, each row is identified by a number and each column is identified by a letter. Thus, "D5" is identified as the cell in column D and row 5.

A user may enter a number or text into an individual cell. In addition, computerized spreadsheets allow users to define mathematical functions or formulas within individual cells. Formulas can refer to other cells. For example, as provided in the Help section of Microsoft Excel, a cell may contain the following formula:

"=(B4+25)/SUM(D5:F5)"

This formula adds the value in cell B4 with 25, then divides the result by the sum of cells D5, E5 and F5. A formula, in Microsoft Excel, begins with an equal sign, followed by what the formula calculates.

For people working in finance, investment, accounting, engineering or the like, computerized spreadsheets are essential tools. Employees of the assignee of the present invention--JP Morgan & Co. Inc.--for example, often use computerized spreadsheets to develop and create financial products which are marketed to potential and existing clients. There are disadvantages and shortcomings that are encountered by such users. These include: the models may not be transferable from one computer to another unless the receiving computer has the same spreadsheet software product, i.e., a spreadsheet model developed using one computerized spreadsheet program may not operate on another spreadsheet program; models cannot be provided to a client or a potential client without exposing the proprietary mathematical logic of the models; computerized spreadsheets may suffer from slow executions; computerized spreadsheets have limited security and version control; computerized spreadsheets may not easily be interfaced with other systems or programs; and the user is limited to the graphical user interface provided by the computerized spreadsheet program when presenting the spreadsheet model to a client/potential client.

What is desired, therefore, is a method and system that overcomes the disadvantages and shortcomings described above. More specifically, what is desired is a method and system for generating a structured language model, such as in C or Java code, from a spreadsheet model that overcomes the disadvantages and shortcomings described above.

SUMMARY OF THE INVENTION

In one embodiment of the present invention, there is provided a method for easily allowing a user of little to no programming language knowledge to convert a computerized spreadsheet model to a structured programming language model, which method includes:

receiving, from the user via a computer input device, outputs and inputs of the computerized spreadsheet model desired to be processed for conversion;

checking the user entries for errors;

if an error is found, then requesting corrected user entry;

if no error is found, then identifying all relevant spreadsheet model cells based on the user entries;

processing formulas used in the spreadsheet model for parsing;

converting the formulas into final form and determining calculation priority order; and

generating the structured programming language model.

The method of the present invention is carried out by a system including a computer having a user interface, a microprocessor and a storage unit, an input device electronically coupled to the computer, and a software program stored in the storage unit, the software program being programmed to operate the microprocessor for carrying out the steps of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an exemplary spreadsheet model from which a structured programming language model is to be generated;

FIG. 2 shows the spreadsheet model of FIG. 1, with the formulas employed in the model disclosed; and

FIG. 3 shows a flow chart illustrating the steps for generating a structured programming language model from the spreadsheet model of FIGS. 1 and 2.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

FIG. 1 is an example of a spreadsheet model 10 from which a structured language model is to be generated. For exemplary purposes, the spreadsheet model was developed using Microsoft Excel and the structured language model to be generated is in Java code. It should be apparent to one of ordinary skill in the art that a structured language model may also be generated from spreadsheet models developed using other software products, such as Lotus 1-2-3, without departing from the scope or the spirit of the invention. Also, it should be apparent to one of ordinary skill in the art that different structured language models, such as in C code, may be generated from a spreadsheet model pursuant to the scope and the spirit of the invention as described and claimed herein.

In the spreadsheet model 10 of FIG. 1, cell B2, identified by reference numeral 20, contains a value for the state tax rate--12% in this example, cell B3, identified by reference numeral 22, contains a value for the federal tax rate--30%, and cell B4, identified by reference numeral 24, contains a value for the total tax rate--42%. Cell B6, identified by reference numeral 26, contains the base year--2000, cell B7, identified by reference numeral 28, contains a value for the discount rate--10%, and cell B8, identified by reference numeral 30, contains a value for the initial investment--15,000.

In addition to the six inputs identified above, the spreadsheet model 10 includes a column labeled "Period," with cells D2, D3 and D4, identified by reference numerals 32, 34, 36, respectively, containing the base year--2000 and the following two years--2001, 2002. The column labeled "EBITDA" includes three cells, E2, E3 and E4, identified by reference numerals 38, 40, 42, respectively, containing values 10,000, 18,000 and 24,000. EBITDA stands for earnings before interest, taxes, depreciation and amortization. The column labeled "Free CFL" includes three cells F2, F3 and F4, identified by reference numerals 44, 46, 48, respectively, containing values 5,800, 10,440 and 13,920. Free CFL stands for free cash flow, which is defined as operating cash flow (net income plus amortization and depreciation) minus capital expenditures and dividends.

The exemplary spreadsheet model 10 of FIG. 1 also includes three outputs. Cell 12, identified by reference numeral 50, contains a value for the present value ("PV") of cash flows--24,359, cell I3, identified by reference numeral 52, contains a value for the sum of the cash flows--30,160, and cell 14, identified by reference numeral 54, contains a value for the net present value ("NPV") of the investment--9,359. Present value of cash flows is the current value of one or more future cash payments discounted at some appropriate interest rate. Net present value is the present value of an investment's future net cash flows minus the initial investment.

FIG. 2 shows the spreadsheet model 10 of FIG. 1, with the formulas employed in the model revealed. The value for the total tax rate in cell B4 is calculated from adding the value for the state tax rate in cell B2 and the value for the federal tax rate in cell B3. All the other inputs are values entered by the user. The values for periods in cells D2, D3 and D4 are derived from the base year in cell B6, base year plus 1, and base year plus 1 plus 1, respectively. EBITDA values are entered by the user.

Free CFL values in cells F2, F3 and F4 are calculated as follows: cell F2 value is calculated by subtracting the total tax rate in cell B4 (0.42) from 1 to get 0.58, then multiplying this result with the EBITDA value in cell E2 (10,000) to get 5,800; cell F3 value is calculated by subtracting the total tax rate in cell B4 from 1 to get 0.58, then multiplying this result with the EBITDA value in cell E3 (18,000) to get 10,440; and cell F4 value is calculated by subtracting the total tax rate in cell B4 from 1 to get 0.58, then multiplying this result with the EBITDA value in cell E4 (24,000) to get 13,920.

The outputs in the exemplary spreadsheet model 10 are calculated as follows: The PV of cash flows, cell 12, is calculated by the NPV function of Microsoft Excel, using the value of the discount rate in cell B7 and the cash flow values in cells F2, F3 and F4. The sum of cash flows, cell I3, is calculated by the SUM function of Microsoft Excel, adding the cash flow values in cells F2, F3 and F4. And the NPV of investment, cell I4, is calculated by subtracting the initial investment value in cell B8 from the calculated PV of cash flows in cell I2.

FIG. 3 is a flow chart illustrating the steps of the present invention for generating a structured language model from a spreadsheet model, such as the Excel spreadsheet model 10 of FIGS. 1 and 2. At step 100, the user is prompted for the outputs of the spreadsheet model that he desires and preferably, also the name that he wants to use for the model. Optionally, the user may also be prompted to select display formatting parameters and/or the inputs of the spreadsheet model. While the following description is based on receiving only the output selections from the user, the system of the present invention may be modified in a manner apparent to one of ordinary skill in the art to receive input selections from the user as well. After receiving the user entries, the system, at step 102, checks for errors in the user entries. If the system detects an error at step 104, then the system returns to step 100 with an appropriate error message. Note that depending upon how the user is prompted for entries from the spreadsheet, this error checking step may not be required.

If no error is detected, then at step 106, the system identifies relevant spreadsheet cells based on dependencies of the selected outputs. For example, if a selected output has the following formula, =SUM(A1:A3), then the system will identify cells A1, A2 and A3 as being relevant. At step 108, for each relevant cell identified, precedent cells are identified and added to set of relevant cells. For example, let's assume that cell A2 is dependent on sum of the values in cells B3 and B4. In this case, cells B3 and B4 will be added to the set of relevant cells.

At step 110, the formulas used in the spreadsheet model are processed for parsing. This step prepares the spreadsheet formulas for conversion to the structured language model. At step 114, the user is asked to verify which of the non-formulaic cells are inputs and which are constants. For those cells that are inputs, the user is optionally requested to enter desired names for the inputs. Note that this step could be optionally carried out at step 100, as described above. Finally, at step 116, the system converts the formulas into final form, specific to the desired structured language, and relevant cells are placed into calculation priority based on the dependencies. The system then generates the structured language model.

To further illustrate the steps of FIG. 3, we will look at the conversion of the exemplary spreadsheet model 10 in FIGS. 1 and 2 into a model in Java code. It should be apparent to one of ordinary skill in the art that the details set forth herein are only one way of converting a spreadsheet model to a model in Java code and that other ways of converting a spreadsheet model may be utilized without departing from the spirit and scope of the invention.

The user is prompted for the outputs of the spreadsheet he desires and is asked to provide a name for the Java class. As described above with respect to step 100 of FIG. 3, the user may also be prompted to select the inputs of the spreadsheet model. In this example, let's assume the user selects cells I2 and I4 as the desired outputs, selects the name "Patent" as the Java class name and selects the display format (note that the display format is for a Java servlet that may call the structured language model generated pursuant to the present invention). The system then checks for errors. If an error is detected, then the system provides an appropriate error message and requests the user to correct the user entry.

If no error is detected, then the system places the selected output cells onto a Formula Stack. Such a Stack may look as follows:

Formula Stack

        Cell               Formula           Input/Output Parent
        [Pat04.xls]Demo!I2 NPV(B7,F2:F4)     _Bk1Wk1I2I2
        [Pat04.xls]Demo!I4 I2-B8             _Bk1Wk1I4I4

              Name                 Output Parent Range
              _Bk1Wk1I2I2          [Pat04.xls]Demo!I2
              _Bk1Wk1I4I4          [Pat04.xls]Demo!I4

                                                   Input/Output
    Cell              Formula            Precedents Parent
    [Pat04.xls]Demo!I2 NPV(#@B7@#,        B7,F2:F4  _Bk1Wk1I2I2
                      #@F2:F4@#)
    [Pat04.xls]Demo!I4 #@I2@#-#@B8@#      12,B8     _Bk1Wk1I4I4
    [Pat04.xls]Demo!B7 0.1
    [Pat04.xls]Demo!F2 #@E2@#*(1-#@$B     E2,B4
                      $4@#)
    [Pat04.xls]Demo!F3 #@E3@#*(1-#@$B     E3,B4
                      $4@#)
    [Pat04.xls]Demo!F4 #@E4@#*(1-#@$B     E4,B4
                      $4@#)
    [Pat04.xls]Demo!B8 15000
    [Pat04.xls]Demo!E2 10000
    [Pat04.xls]Demo!E3 18000
    [Pat04.xls]Demo!E4 24000
    [Pat04.xls]Demo!B4 #@B2@#+#@B3@#      B2,B3
    [Pat04.xls]Demo!B2 0.12
    [Pat04.xls]Demo!B3 0.3

    Cell              Formula                  Precedents Main Parent
     Input/Output Parent
    [Pat04.xls]Demo!I2 NPV(#@B7@#,#@F2:F4@#)    B7,F2:F4  _Bk1Wk1I2I2
     _Bk1Wk1I2I2
    [Pat04.xls]Demo!I4 #@I2@#-#@B8@#            12,B8     _Bk1Wk1I4I4
     _Bk1Wk1I4I4
    [Pat04.xls]Demo!B7 0.1                                _Bk1Wk1B7B8
     _Bk1Wk1B7B8
    [Pat04.xls]Demo!F2 #@E2@#*(1-#@$B$4@#)      E2,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!F3 #@E3@#*(1-#@$B$4@#)      E3,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!F4 #@E4@#*(1-#@$B$4@#)      E4,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!B8 15000                              _Bk1Wk1B7B8
     _Bk1Wk1B7B8
    [Pat04.xls]Demo!E2 10000                              _Bk1Wk1E2F4
     _Bk1Wk1E2E4
    [Pat04.xls]Demo!E3 18000                              _Bk1Wk1E2F4
     _Bk1Wk1E2E4
    [Pat04.xls]Demo!E4 24000                              _Bk1Wk1E2F4
     _Bk1Wk1E2E4
    [Pat04.xls]Demo!B4 #@B2@#+#@B3@#            B2,B3     _Bk1Wk1B2B4
    [Pat04.xls]Demo!B2 0.12                               _Bk1Wk1B2B4
    [Pat04.xls]Demo!B3 0.3                                _Bk1Wk1B2B4

            Name                   Parent Range
            _Bk1Wk1I2I2            [Pat04.xls]Demo!I2
            _Bk1Wk1I4I4            [Pat04.xls]Demo!I4
            _Bk1Wk1B7B8            [Pat04.xls]Demo!B7:B8
            _Bk1Wk1E2F4            [Pat04.xls]Demo!E2:F4
            _Bk1Wk1B2B4            [Pat04.xls]Demo!B2:B4

            Name                   Input Range Range
            _Bk1Wk1B7B8            [Pat04.xls]Demo!B7:B8
            _Bk1Wk1E2E4            [Pat04.xls]Demo!E2:E4

    Cell              Formula                  Precedents Main Parent
     Input/Output Parent
    [Pat04.xls]Demo!I2 NPV(#@B7@#,#@F2:F4@#)    B7,F2:F4  _Bk1Wk1I2I2
     _PVofCash
    [Pat04.xls]Demo!I4 #@I2@#-#@B8@#            I2,B8     _Bk1Wk1I4I4
     _NPVofInv
    [Pat04.xls]Demo!B7 0.1                                _Bk1Wk1B7B8
     _DiscRate
    [Pat04.xls]Demo!F2 #@E2@#*(1-#@$B$4@#)      E2,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!F3 #@E3@#*(1-#@$B$4@#)      E3,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!F4 #@E4@#*(1-#@$B$4@#)      E4,B4     _Bk1Wk1E2F4
    [Pat04.xls]Demo!B8 15000                              _Bk1Wk1B7B8
     _InitInv
    [Pat04.xls]Demo!E2 10000                              _Bk1Wk1E2F4
     _EBITDA[0]
    [Pat04.xls]Demo!E3 18000                              _Bk1Wk1E2F4
     _EBITDA[1]
    [Pat04.xls]Demo!E4 24000                              _Bk1Wk1E2F4
     _EBITDA[2]
    [Pat04.xls]Demo!B4 #@B2@#+#@B3@#            B2,B3     _Bk1Wk1B2B4
    [Pat04.xls]Demo!B2 0.12                               _Bk1Wk1B2B4
    [Pat04.xls]Demo!B3 0.3                                _Bk1Wk1B2B4

          Name              Output Parent Range      Type
          _PvofCash         [Pat04.xls]Demo!I2       Double
          _NPVofInv         [Pat04.xls]Demo!I4       Double

        Name              Input Parent Range       Type
        _DiscRate         [Pat04.xls]Demo!B7       Double
        _InitInv          [Pat04.xls]Demo!B8       Double
        _EBITDA           [Pat04.xls]Demo!E2:E4    Double

             Input/Output  Default
    Cell              Formula                                 Precedents Main
     Parent     Parent        Value
    [Pat04.xls]Demo!I4 _Bk1Wk1I4I4[0][0].setVal(_Bk1Wk1I2I2[0][0]. I2,B8
     _Bk1Wk1I4I4     _PVofCash
                      getVal()-_Bk1Wk1B7B8[1][0].getVal());
    [Pat04.xls]Demo!I2 _Bk1Wk1I2I2[0][0].setVal(NPV(_Bk1Wk1B7  B7,F2:F4
     _Bk1Wk1I2I2     _NPVofInv
                      B8[0][0].getVal,
                      _Bk1Wk1E2F4.getArr(),0,1,2,1));
    [Pat04.xls]Demo!B7 _Bk1Wk1B7B8[0][0].setVal(_DiscRate);
     _Bk1Wk1B7B8     _DiscRate       0.1
    [Pat04.xls]Demo!F2 _Bk1Wk1E2F4[0][1].setVal(_Bk1Wk1E2F4[0] E2,B4
     _Bk1Wk1E2F4
                      [0].getVal()*(1-
                      _Bk1Wk1B2B4[2][0].getVal()));
    [Pat04.xls]Demo!F3 _Bk1Wk1E2F4[1][1].setVal(_Bk1Wk1E2F4[1] E3,B4
     _Bk1Wk1E2F4
                      [0].getVal()*(1-
                      _Bk1Wk1B2B4[2][0].getVal()));
    [Pat04.xls]Demo!F4 _Bk1Wk1E2F4[2][1].setVal(_Bk1Wk1E2F4[2] E4,B4
     _Bk1Wk1E2F4
                      [0].getVal()*(1-
                      Bk1Wk1B2B4[2][0].getVal()));
    [Pat04.xls]Demo!B8 _Bk1Wk1B7B8[1][0].setVal(_InitInv);
     _Bk1Wk1B7B8     _InitInv      15000
    [Pat04.xls]Demo!E2 _Bk1Wk1E2F4[0][0].setVal(_EBITDA[0]);
     _Bk1Wk1E2F4     .sub.--       10000
             EBITDA[0]
    [Pat04.xls]Demo!E3 _Bk1Wk1E2F4[1][0].setVal(_EBITDA[1]);
     _Bk1Wk1E2F4     .sub.--       18000
             EBITDA[1]
    [Pat04.xls]Demo!E4 _Bk1Wk1E2F4[2][0].setVal(_EBITDA[2]);
     _Bk1Wk1E2F4     .sub.--       24000
             EBITDA[2]
    [Pat04.xls]Demo!B4 _Bk1Wk1B2B4[2][0].setVal(_Bk1Wk1B24[0]  B2,B3
     _Bk1Wk1B2B4
                      [0].getVal()+_Bk1Wk1B2B4[1][0].getVal());
    [Pat04.xls]Demo!B2 _Bk1Wk1B2B4[0][0].setVal(0.12);
     _Bk1Wk1B2B4                     0.12
    [Pat04.xls]Demo!B3 _Bk1Wk1B2B4[1][0].setVal(0.30);
     _Bk1Wk1B2B4                     0.3

• Inventors
  Khosrowshahi, Farzad; Woloshin, Murray I.;
• Assignee
  FurrayLogic Ltd. (New York, NY)
• Published
  Jul-20-2004
• Current US Classes:
  715/504
  717/140
• Application #
  718781
• International Classes
  G06F 009/45
• Field of Search
  717/136-144 707/10 707/104.1 707/503-504 707/526 709/200-203 345/751
• Examiner
  Zhen; Wei Y.
• Agent
  Horowitz; Steven
• US Patent References:
  5471612
  5600584
  6281874
  6694309