Controlling a Device Using Tabular Data

Abstract

A device controllable via tabular data and a computer-implemented method for interactively performing operations on tabular data. The method comprises providing an input array, an operations array, and an output array, wherein each array includes at least one cell, receiving, in the operations array, a first reference to a cell of the input array, receiving tabular data from an input source, and performing operations on multiple rows of the tabular data. The operations comprise inserting one of the rows of the tabular data into the input array, determining a value of a second cell of the operations array based on the referenced cell of the input array, and storing one of the following in a cell of the output array: the determined value of the operations array and a value of the referenced cell of the input array.

Claims

1. A device controllable via tabular data, the device comprising: a timer for generating events at a predetermined time; a sensor for generating events upon detection of specified changes in the device or in an environment of the device; a computing unit comprising: a memory for storing an input array, an operations array, and an output array, wherein each array includes at least one cell; a receiver for: receiving the operations array, the operations array including a first reference to a cell of the input array, and receiving tabular data from an input source; a processor configured to carry out the following: perform operations on multiple rows of the tabular data, wherein at least one of the rows of the tabular data was produced in response to an event generated by the sensor or the timer, the operations comprising: inserting one of the rows of the tabular data into the input array, determining a value of a second cell of the operations array based on the referenced cell of the input array, and storing one of the following in a cell of the output array: the determined value of the operations array, and a value of the referenced cell of the input array; and copy the output array to an output destination.

2. The device of claim 1, wherein the device is a household appliance, such as a refrigerator.

3. A computer-implemented method for interactively performing operations on tabular data, comprising: providing an input array, an operations array, and an output array, wherein each array includes at least one cell; receiving, in the operations array, a first reference to a cell of the input array; receiving tabular data from an input source; performing operations on multiple rows of the tabular data, the operations comprising: inserting one of the rows of the tabular data into the input array, determining a value of a second cell of the operations array based on the referenced cell of the input array; storing one of the following in a cell of the output array: the determined value of the operations array, and a value of the referenced cell of the input array; displaying the output array; and copying the output array to an output destination.

4. The method of claim 3, wherein the input source is a device, a file, a data stream, a file on the device, or a data stream received from the device.

5. The method of claim 3, further comprising recalculating the operations array after the inserting of one of the rows of the tabular data into the input array, wherein the recalculation comprises: the determination of the value of the second cell of the operations array based on the referenced cell of the input array; the storage of the determined value in the cell of the output array; the display of the output array; and copying of the output array to an output list.

6. The method of claim 3, wherein the first input is a formula referring to the referenced cell of the input array.

7. The method of claim 6, wherein the value of the second cell of the operations array is determined by: copying the value of the referenced cell to the first cell of the operations array, wherein the second cell in the operations array includes another formula specifying a calculation that refers to the first cell of the operations array, wherein the determined value is the result of applying the calculation to the copied value, and wherein the calculation includes at least one of the following: an arithmetic operation, a relational operation, and a function.

8. The method of claim 6, further comprising at least one of the following: displaying the content of each cell in the operations array before performing the operations, wherein displaying the content includes displaying each formula in the operations array, and displaying the values of each cell in the operations array after determining the value of the second cell of the operations array, wherein displaying the values comprises evaluating each formula in the operations array and displaying the results of the evaluations.

9. The method of claim 3, wherein the insertion of one of the rows of tabular data into the input array triggers the determination of the value of the second cell of the operations array, wherein the insertion of one of the rows of tabular data into the input array triggers evaluation of each cell in the operations array, and wherein the multiple rows of tabular data consist of all the rows of tabular data in the input source.

10. The method of claim 3: wherein performing the operations on the rows of tabular data comprises triggering recalculation of a further operations array from the operations array, wherein the recalculation of the further operations array comprises: performing operations according to a formula received in the further operations array on a single row of tabular data received from a further input source in a further input array, or performing operations according to a formula received in the further operations array on multiple rows of tabular data received from the further input source in the further input array, wherein the further operations array includes a reference to a cell of the operations array, wherein the cell contains a value, and wherein the value is copied to the further operations array during the recalculation.

11. The method of claim 3, wherein one or more of the following applies: each array includes multiple cells, each array includes a row and a column, the operations array includes multiple rows, each of the cells of the input array, the operations array, and the output array is addressable by any cell of the operations array, and each of the cells of the operations array is a placeholder for a value or a formula.

12. The method of claim 3, wherein inserting one of the rows of tabular data into the input array further comprises: when an existing row of the tabular data is in the input array, removing the existing row of tabular data from the input array before inserting the row of tabular data into the input array, or when a predetermined number of rows of tabular data are in the input array, removing one of the rows in the input array before inserting the row of tabular data into the input array.

13. The method of claim 3, wherein the input source is a device, the method further comprising: generating, by the device, an event, wherein a row of the tabular data inserted into the input array was produced in response to the event, and wherein each row of the tabular data may have been produced in response to events generated by the device.

14. The method of claim 13, wherein the event is generated in response to detection of a change in the device, a change in the environment of the device, or the occurrence of a specified time, and wherein the change comprises one of the following: a door of the device being opened, the door of the device being closed, an item being removed from the device, an item being added to the device, and an item being placed in the device.

15. A computer program product comprising computer-readable instructions, which, when loaded and executed on a computer system, cause the computer system to perform operations according to the method of claim 3.

Description

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

[0118] The present invention is described in detail below with reference to the attached drawing figures, wherein:

[0119] FIG. 1 depicts tabular data in different forms.

[0120] FIG. 2 shows a symbolic representation of an array.

[0121] FIG. 3 shows a collection of tabular data being sent as an email attachment.

[0122] FIG. 4 shows a machine and components of the machine.

[0123] FIG. 5 shows lists queued for processing by a transactor.

[0124] FIG. 6 shows a list being processed by the transactor while other lists await processing.

[0125] FIG. 7 shows steps of processing tabular data in the list by the transactor.

[0126] FIG. 8 shows processing, ejection, and distribution of the list.

[0127] FIG. 9 shows the start of processing of a further list by the transactor.

[0128] FIG. 10 shows components of the transactor.

[0129] FIG. 11 shows interaction between the components of the transactor.

[0130] FIG. 12 shows settings to control operations of the transactor.

[0131] FIG. 13 demonstrates functionality of an input array when performing operations on the tabular data.

[0132] FIG. 14 shows performing operations on the tabular data in an operations array.

[0133] FIG. 15 shows the transactor receiving the tabular data from an input source and performing operations on multiple rows of the tabular data.

[0134] FIG. 16 shows a copy function for storing determined values of the operations array in an output array.

[0135] FIG. 17 demonstrates functionality of the input array and the output array.

[0136] FIG. 18 demonstrates functionality of the copy function.

[0137] FIG. 19 shows functionality of an eject function.

[0138] FIG. 20 shows operation of an execute function to trigger recalculation of the operations array.

[0139] FIG. 21 shows different ways of triggering recalculation of the operations array.

[0140] FIG. 22 shows use of the copy function.

[0141] FIG. 23 shows functionality for storing values from the operations array in the output array and adding a row to an output list before copying the output array to the output list.

[0142] FIG. 24 shows use of the add function in combination with use of the execute function for recalculation of the operations array.

[0143] FIG. 25 shows five recalculations of a further operations array before finishing performance of operations on tabular data from the input source.

[0144] FIG. 26 shows how the execute function in one transactor triggers the ADD function in another transactor.

[0145] FIG. 27 illustrates performing operations on the five rows of tabular data.

[0146] FIG. 28 shows a content view of cells of two transactors before performing operations on the five rows of tabular data.

[0147] FIG. 29 shows a value view of the two transactors after performing operations on one row out of the five rows of tabular data.

[0148] FIG. 30 shows the value view of the two transactors after performing operations on the five rows of tabular data.

[0149] FIG. 31 shows five recalculation cycles of the two transactors when performing operations on the five rows of tabular data.

[0150] FIG. 32 shows the machine with two transactors and with three transactors when performing operations on tabular data.

[0151] FIG. 33 shows another way of combining three transactors and a way of combining four transactors when performing operations on tabular data.

[0152] FIG. 34 shows two other ways of combining four transactors when performing operations on tabular data.

[0153] FIG. 35 shows a first example of interactively performing operations on tabular data.

[0154] FIG. 36 continues the first example of interactively performing operations on tabular data.

[0155] FIG. 37 continues the first example of interactively performing operations on tabular data.

[0156] FIG. 38 continues the first example of interactively performing operations on tabular data.

[0157] FIG. 39 shows an example of generating an output list.

[0158] FIG. 40 continues the example of generating the output list and shows ejection of the output list.

[0159] FIG. 41 shows a second example of interactively performing operations on tabular data.

[0160] FIG. 42 continues the second example of interactively performing operations on tabular data.

[0161] FIG. 43 continues the second example of interactively performing operations on tabular data.

[0162] FIG. 44 continues the second example of interactively performing operations on tabular data.

[0163] FIG. 45 continues the second example of interactively performing operations on tabular data.

[0164] FIG. 46 continues the second example of interactively performing operations on tabular data.

[0165] FIG. 47 continues the second example of interactively performing operations on tabular data.

[0166] FIG. 48 shows the final steps of the second example of interactively performing operations on tabular data.

[0167] FIG. 49 shows transactors and list processing in a third example of interactively performing operations on tabular data.

[0168] FIG. 50 shows initial steps of the third example of interactively performing operations on tabular data.

[0169] FIG. 51 continues the third example of interactively performing operations on tabular data.

[0170] FIG. 52 shows final steps of the third example of interactively performing operations on tabular data.

[0171] FIG. 53 shows an initial step of a fourth example of interactively performing operations on tabular data.

[0172] FIG. 54 continues the fourth example of interactively performing operations on tabular data.

[0173] FIG. 55 continues the fourth example of interactively performing operations on tabular data.

[0174] FIG. 56 shows final steps of the fourth example of interactively performing operations on tabular data.

[0175] FIG. 57 shows physical components of a fifth example of interactively performing operations on tabular data.

[0176] FIG. 58 provides a process description of a primary kitchen device according to the fifth example.

[0177] FIG. 59 shows processing of door action lists by the primary kitchen device according to the fifth example.

[0178] FIG. 60 shows processing of a timer action list by the primary kitchen device according to the fifth example.

[0179] FIG. 61 shows processing of door action lists by a procurement machine according to the fifth example.

[0180] FIG. 62 shows processing carried out by multiple kitchen devices according to the fifth example.

[0181] FIG. 63 shows order handling according to the fifth example.

[0182] FIG. 64 shows two other ways of combining transactors when performing operations on tabular data.

[0183] FIG. 65 shows functionality of the execute function in a flow chart.

DETAILED DESCRIPTION OF THE INVENTION

[0184] In the following text, a detailed description of examples will be given with reference to the drawings. It should be understood that various modifications to the examples may be made. In particular, one or more elements of one example may be combined and used in other examples to form new examples.

[0185] In some figures, a value view (i.e., a display of cell values) and a content view (display of cell formulas) are mixed in the interest of clarity and conciseness. Such a mixed view might not reflect what is actually displayed to a user.

[0186] FIG. 1 shows examples of tabular data that may be received from an input source. The tabular data received from an input source may be referred to as a list. A first exemplary list 101 of tabular data shows an empty list. The list 101 may be represented via a set of null values. In particular, since the list 101 has ten rows and four columns, the list 101 may be represented by a ten row and four column set of null values.

[0187] A second exemplary list 103 shows tabular data displayed in rows and columns and identified by a list name. In the second example 103, the list name is “sample”. The tabular data may be received from the input source as rows of delimited values. In particular, the tabular data may be received in the form of a set of comma separated values (CSV). For example, the tabular data may be received as a sample.csv file 105.

[0188] In addition, the tabular data may be received as a list 107 in XML format.

[0189] FIG. 2 shows a symbolic representation of tabular data in the form of the list 101. In the example of FIG. 2, the list 101 is empty, e.g., filled with null values. The tabular data may be stored in a file. In particular, reading tabular data from the input source may involve extracting the tabular data from a file. The file may be stored on a device.

[0190] FIG. 3 shows tabular data being sent as an attachment of an email message. In particular, in the context of FIG. 3, the list 107 in XML format is sent as the attachment of an email message from machine1 to machine2. Machine1 and machine2 may both include one or more transactors. Machine1 and machine2 may be different processes (i.e., programs in execution) on the same device or different processes on different devices.

[0191] Tabular data may also be sent or distributed using other protocols suitable for transferring data between devices or processes, particularly Internet protocols such as hypertext transfer protocol (HTIP), file transfer protocol (FTP), rsync, secure shell (ssh), and secure copy (scp).

[0192] FIG. 4 shows an example of a machine 401. The machine 401 includes an inbox 403, a machine address 405, and a transactor 407. The inbox 403 may receive tabular data from an input source (e.g., a device or a data stream from another machine). In particular, the inbox 403 may contain one or more lists. The lists in the inbox 403 may be contained in files and/or data streams. For example, the inbox 403 may include a pointer to a file containing a list or a pointer to a location in a file containing a list. Multiple lists may be contained within a file or each file may include only one list.

[0193] The machine 401 may be a device or a process executing on a device. For example, the machine 401 may be a process executing on an electronic device, such as a household or office device.

[0194] The transactor 407 may perform processing of the machine 401. In particular, the transactor 407 may perform operations on multiple rows of tabular data received from the input source. The machine address 405 may be a unique address of the machine 401. The machine address 405 may be used to send or receive a list. The machine address 405 may function in much the same way that an email address functions. In particular, when a list is sent to the machine 401 via the machine address 405 the list may be added to the inbox 403. The inbox 403 may function like a queue.

[0195] FIG. 5 shows lists being added to the inbox 403. In the example of FIG. 5, as soon as there is one list in the inbox 403, the list is received from the inbox 403 at the transactor 407. Accordingly, the transactor 407 performs operations on multiple rows of the tabular data in the list. The tabular data may be processed row-by-row through the transactor.

[0196] FIG. 6 shows the transactor 407 processing one of the lists from the inbox 403, i.e., a list 601. Accordingly, one of the rows of tabular data in the list 601 (depicted as “List A”) has been inserted into an input array of the transactor 407. Operations may be performed on all the rows of the list 601. In particular, each row of the list 601 may be inserted into the input array of the transactor 407. Operations may be performed on the inserted row, e.g., according to received input in an operations array. Results of the performance of the operations may be copied to an output array. The output array may be displayed and then copied to an output destination.

[0197] FIG. 7 shows processing of the list 601 by the transactor 407 in step-by-step fashion. In particular, each row of tabular data in the list 601 may be processed until operations have been performed on all the rows of tabular data in the list 601. Further, during processing of the list 601, a further list may be added to the inbox 403. After all rows of the list 601 have been processed, the list 601 may be ejected from the transactor 407 and from the machine 401. Ejecting the list 601 may involve closing a file containing the list 601 or closing a data stream containing the list 601. Ejecting the list 601 may also involve calling an eject function, discussed in more detail below. The list 601 may be sent to another machine for further processing.

[0198] FIG. 8 shows the list 601, i.e., “List A,” being sent to another machine for further processing after the transactor 407 has performed operations on the rows of the list 601 and the list 601 has been ejected from the transactor 407.

[0199] FIG. 9 shows the beginning of performing operations on tabular data in a list 901 after the performance of operations on the tabular data of the list 601 (i.e., “List A”) has been completed. The list 901 was retrieved from the inbox 403.

[0200] FIG. 10 shows elements and functionality of the transactor 407. In particular, the transactor may include an input array 1001, an operations array 1003, and an output array 1005. The input array 1001 may be referred to as an input reader. The operations array 1003 may be referred to as a sheet or a spreadsheet. The output array 1005 may be referred to as an output writer.

[0201] The transactor 407 performs processing in the machine 401. The machine 401 can contain only the transactor 407 or multiple transactors. If there are multiple transactors in the machine 401, they may be attached to each other and interact with each other. Attaching transactors may be understood as providing a reference in one transactor to another transactor.

[0202] The input array 1001, the operations array 1003, and the output array 1005 each include at least one cell. In the example of FIG. 10, the input array 1001 includes at least four cells. Further, according to the example, the operations array 1003 includes at least twenty cells. Also, according to the example, the output array includes at least four cells.

[0203] In order to perform operations on tabular data received from the input source, a row of the tabular data may be inserted into the input array 1001. After being received from the input source, the tabular data may first be stored in the inbox 403 before a row of the tabular data is inserted into the input array 1001. Functionality connected to the input array 1001 may read cells of the tabular data upon which operations are to be performed. Accordingly, the input array 1001 exposes values of a row of tabular data received from the input source to the operations array 1003 and the output array 1005.

[0204] The operations array 1003 is able to perform operations on cells in the input array 1001. In particular, the operations array 1003 is able to process and transpose values of cells in the input array 1001. The output array 1005 is connected to functionality that copies values from the cells of the output array 1005 to an output list and an output destination. Copying the output array to an output destination may include copying the output array to the output list and sending the output list to the output destination.

[0205] For example, the output array is connected to functionality that is able to write values from the output array 1005 back to a list currently being processed by the transactor 407. Accordingly, the input source may be the same as the output destination. Once the output list is complete, the output list may be sent back to the input source. Accordingly, values in a row of the tabular data received from the input source can be changed and result in a change of the tabular data at the input source. Further, new rows can be added to the received tabular data or inserted among rows of the received tabular data. In addition, rows can be deleted from the received tabular data, the additions, insertions, and deletions also resulting in changes to the tabular data at the input source.

[0206] The input array 1001, the operations array 1003, and the output array 1005 can each store tabular data. Further, tabular data in the input array 1001, the operations array 1003, and the output array 1005 can be displayed. In the example of FIG. 10, the input array 1001, the operations array 1003, and the output array 1005 have row ordinates 1, 2, 3, . . . and column ordinates A, B, C, . . . .

[0207] Each cell of the input array 1001, the operations array 1003, and the output array 1005 can be referenced via its cell ordinates. Each of the arrays may be labeled. For example, the input array 1001 is labelled “IN.” The operations array 1003 is labelled “T1.” The output array 1005 is labelled “OUT.”

[0208] Accordingly, cells in the input array 1001 can be referenced via the expression “=IN!” followed by the cell ordinates of the cell being referenced. For example, “=IN!A1” would reference the left-most cell of the input array 1001. Input received in the operations array 1003 can reference other cells of the operations array simply by referring to the cell ordinates. For example, “=A2” refers to row 2 column A of the operations array 1003. A reference to cell A2 of the operations array 1003 from a further operations array would need to include the name of the operations array 1003 before the ordinates of the cell. For example, since the operations array 1003 is identified with the label “T1,” cell A2 could be referred to from the further operations array with the reference “=T1 !A2.”

[0209] In the example of FIG. 10, the output array 1005 has the label “OUT.” Accordingly, cells of the output array 1005 may be referenced from the operations array 1003 by using the expression “=OUT!” followed by ordinates of the cell being referenced. For example, to reference cell A1 of the output array 1005, the expression “=OUT!A1” could be used.

[0210] FIG. 11 shows how values of one or more cells of the input array 1001 may be copied to the operations array 1003. After the cells of the input array 1001 are copied to the operations array 1003, values of further cells in the operations array 1003 may be determined based on the copied values (not shown). In addition, determined values of the operations array 1003 may be copied to the output array 1005. In other words, determined values of the operations array 1003 may be stored in cells of the output array 1005.

[0211] FIG. 12 shows transactor settings 1201 for the transactor 407. In the example of FIG. 12, the transactor 407 has two settings to control its operation. A first setting, “List Name Filter,” may define which lists in the inbox 403 can be processed by the transactor 407. The transactor settings 1201 indicates that characters and wild cards may be used to specify which lists in the inbox 403 can be processed by the transactor 407. When a list from the inbox 403 is processed by the transactor 407, operations are performed on multiple rows of tabular data in the list.

[0212] For example, in order to process all lists with list names starting with “0010,” then the List Name Filter of the transactor settings 1201 should be set to “0010*.” If the processor should only process lists with list names “001” to “009,” then the List Name Filter of the transactor settings 1201 should be set to “00?” Other wild cards and regular expressions may also be used to specify list names of lists to be processed. If the transactor 407 should not accept lists from the inbox 403, then the List Name Filter of the transactor settings 1201 should be left blank.

[0213] An “Auto Execute” setting of the transactor settings 1201 determines whether the transactor 407 automatically starts processing when new lists arrive in the inbox 403 of the transactor 407. The Auto Execute setting may also control operation of other transactors in addition to the transactor 407.

[0214] FIG. 13 shows a list 1301 being processed by the transactor 407. When processing the list 1301, the transactor 407 may perform operations on multiple rows of the tabular data in the list 1301. Each row of the list 1301 may be inserted into the input array 1001. Insertion of the row of the list 1301 into the input array 1001 may trigger recalculation of the operations array 1003. The recalculation of the operations array 1003 may occur for each row of the list 1301 inserted into the input array 1001. The operations array 1003 may include a reference to a cell of the input array 1001. Recalculation of the operations array 1003 may include determining a value of a second cell of the operations array 1003 based on the referenced cell of the input array 1001. Recalculation of the operations array 1003 may also include storing the determined value in a cell of the output array 1005, and displaying the output array 1005 including displaying the determined value in the cell of the output array 1005. Recalculation of the operations array 1003 may also include copying the output array 1005 to an output list and ultimately to an output destination.

[0215] FIG. 14 shows the operations array 1003 in the transactor 407. The operations array 1003 includes computational and transactional logic of the transactor 407. The operations array 1003 is capable of performing typical spreadsheet calculations. In addition, the operations array 1003 is capable of generating, transforming, and exchanging lists of tabular data.

[0216] The operations array 1003 may have the following functionality. Each cell of the operations array 1003 may be capable of storing a value and content. The value and the content of a cell may be identical, e.g., when the content of the cell is a number value or a string value. The value of each cell in the operations array 1003 may be initially set to empty, i.e., null. The content of each cell in the operations array 1003 may be a number value, a string value, another type of value, or a formula. Other types of content are also possible.

[0217] It may be possible for a user to display the value or the content of a cell in the operations array 1003. For example, when performing operations on tabular data, the operations array 1003 may typically display values of cells. When receiving input (e.g., a reference to a cell of the input array 1001), the operations array 1003 may typically display cell content (e.g., references and formulas). It may be possible for a user to switch between the display of values and content (e.g., by processing a combination of keys) in the operations array 1003 as desired.

[0218] Formulas may start with an “=” sign and may contain values, functions, mathematical operators, brackets, and cell references. Formulas may also start with a different symbol. Each cell in the operations array 1003 may be referable (i.e., addressable) by any other cell in the operations array 1003, even from itself. For example, the cell “A3” in the operations array 1003 may refer to the cell “A3” in the operations array 1003.

[0219] A recalculation cycle may be performed on the operations array 1003. Performing the recalculation cycle may include determining a value of a second cell in the operations array 1003 based on a referenced cell of the input array 1001 (e.g., deriving the value of the second cell by means of a calculation including the value of the referenced cell). Performing the recalculation cycle may also include storing the determined value in a cell of the output array 1005. Performing the recalculation cycle may further include displaying the output array 1005, e.g., so the user can verify an intermediate result.

[0220] Performing the recalculation cycle may also include copying the output array 1005 to an output destination, e.g., by copying the output array 1005 to an output list and then sending the output list to the output destination when performance of operations is finished. Performing the recalculation cycle may also include calculating the values of other cells in the operations array 1003. In particular, performing the recalculation cycle may include calculating the value of all cells in the operations array 1003 one after the other in a row-by-row order. Performing the recalculation cycle may be carried out by recalculating cells in left-to-right order.

[0221] In one example provided in FIG. 14, the operations array 1003 includes rows of numbers 1401 to 1411 illustrating an exemplary order in which cells of the operations array 1003 may be recalculated. Alternative recalculation ordering is also possible.

[0222] During recalculation, if a cell of the operations array 1003 has a numerical value, a string value, or something other than a formula as content, then the value of the cell is set to this value. If the cell of the operations array 1003 has formula content, then the formula is evaluated and the result of evaluating the formula is stored as the cell value of the cell. Row 1413 of the operations array 1003 shows four cells, each having a formula as cell content. Row 1415 of the operations array 1003 shows the corresponding values for the formulas in row 1413.

[0223] The operations array 1003 may be capable of processing a variety of functions. Each of these functions may be contained within a formula. An example of a function that can be processed by the operations array 1003 is the IF( ) function. The IF( ) function may have the following syntax “=IF(condition, then-expression, else-expression).”

[0224] Other exemplary functions that can be processed within the operations array 1003 are string functions, mathematical functions, statistical functions, and financial functions. Other types of functions are also possible. In particular, any function that excepts numerical or string input and returns a value may be received as input in the operations array and processed accordingly.

[0225] Recalculation of the operations array 1003 may be triggered by inserting a row of tabular data into the input array 1001. In particular, recalculation of the operations array 1003 may be triggered after inserting a first row of tabular data from the input source into the input array and again after insertion of each subsequent row of tabular data from the input source into the input array 1001 Accordingly, the operations array 1003 may be recalculated one time for each row of tabular data received from the input source. For example, for the list 1301 shown in FIG. 13, the operations array 1003 would be recalculated eleven times, since there are eleven rows in the list 1301.

[0226] FIG. 15 shows performance of operations on a list 1501. Initially, input is received in the operations array 1003. The input comprises four formulas in four cells of row 1503 of the operations array 1003. Accordingly, input is provided in cells A5:D5 (A5, B5, C5, and D5).

[0227] A row 1505 of tabular data from the list 1501 is inserted into the input array 1001. A row 1507 shows the result of applying the formulas in the row 1503 of the operations array 1003 to the row of tabular data 1505 in the input array 1001. The values in the row 1507 may be determined as a result of performing a first recalculation of the operations array 1003.

[0228] A second row 1509 of the tabular data in the list 1501 is inserted into the input array 1001. Applying the formulas in the row 1503 results in values shown in row 1511. Recalculation of the operations array 1003 can also be triggered by a function in a cell of another operations array. In particular an execute function in a cell of another operations array can trigger recalculation of the operations array 1003.

[0229] FIG. 16 shows the use of the copy function in the operations array 1003. The copy function can be used to store values of the operations array 1003 in the output array 1005. In particular, after determining a value of a second cell of the operations array based on a reference cell of the input array, the copy function can be used to store the determined value in a cell of the output array 1005. The copy function can be used to copy values from the operations array 1003 to the output array 1005 within the transactor 407. Alternatively, the copy function can be used to copy values from the operations array 1003 to an array in another transactor.

[0230] The copy function may be used to copy values from a source range of the operations array 1003 to a target range of cells in another array. The copying may be carried out between arrays on the same machine. A copy action carried out by the copy function may be performed when the operations array 1003 is recalculated. If the copy function is embedded in an IF function, then the copy function will only execute when the corresponding IF condition is TRUE. In the example, the values “454” and “100” are copied from cells C1 and 01 to cells A5 and 85. Accordingly, the copy function as shown in FIG. 16 copies the values of two cells in the operations array 1003 to two different cells in the operations array 1003.

[0231] FIG. 17 shows the transactor 407 performing operations on tabular data and the output destination is the same as the input source. In other words, the transactor 407 writes data back to the list currently being processed and the list is sent back to source from which it was received. According to the example, if operations are being performed on tabular data of a list, the output array 1005 displays a row of data derived from a row of data displayed by the input array 1001.

[0232] In some cases, the copy function may be used to copy cells from the operations array 1003 to the output array 1005 resulting in updated data for the row of tabular data currently being processed. According to the example, values that the copy function stores in the output array 1005 are written back to the output destination. When the output destination is the same as the input source, then the copy function results in the copying of values back to the input source.

[0233] FIG. 18 shows use of the copy function to store determined values from the operations array 1003 in the output array 1005. In particular, in comparison to the tabular data received from the input source, the values 1801 copied to the output destination are modified. In particular, the value in column A is swapped with the value in column B. In addition, mathematical operations are performed on the values in columns C and D. Row 1803 shows values copied from the input array 1001 to the operations array 1003. Row 1805 shows the results of applying the formulas in row 1807 of the operations array 1003 to the values in the input array 1001. The values in the row 1805 are also present in the output array 1005.

[0234] FIG. 19 shows use of an eject function. The eject function may be used to stop the performance of operations on tabular data. For example, the eject function may stop performance of operations on the tabular data of a list currently being processed. The eject function may then delete the list. The eject function could also send the list to another machine for further processing. Other options are also possible. The eject function may be embedded in an IF function, such that the eject function only executes when the IF condition of the IF function evaluates to TRUE. The example of FIG. 19 shows that the operations array 1003 includes a formula (i.e., a reference) in cell A2 to copy the value of cell A1 of the input array 1001 to cell A2 of the operations array 1003. The operations array 1003 also includes an IF function. The IF function specifies that if cell “A2” of the operations array 1003 has a value of “10”, then the list currently being processed will be ejected. Accordingly, since the value in cell “A1” of the input array is “10”, once this value is copied to cell “A2” of the operations array 1003, the IF condition in cell “A5” of the operations array 1003 evaluates to TRUE and the list 1901 is ejected, i.e., performance of operations on the list stops.

[0235] According to one example, the eject function may have an optional argument to assign a new name to the list that is ejected. If this argument is omitted, the name of the list that is ejected stays unchanged. A second possible optional argument of the eject function is the name of the target machine to send a list to after it is ejected. It is also possible to send the list to the same transactor that it was ejected from.

[0236] FIG. 20 shows operation of an execute function. The execute function may be used to trigger recalculation of a further operations array from an operations array that is currently processing tabular data (e.g., a list). Accordingly, the execute function can be used to link multiple transactors on one machine. The execute function may operate by halting execution of a transactor from which it is called until the transactor called by the execute function finishes processing.

[0237] Via the execute function, it is possible that a primary transactor triggers the processing of all rows in a secondary transactor one time for each row in the primary transactor. Alternatively, the execute function can enable the processing of two lists in parallel with a primary transactor triggering processing of a single row of tabular data by a secondary transactor for each row in the list being processed by the primary transactor. The latter option is shown in the example depicted in FIG. 20. In particular, for each row of the list processed by the operations array 1003, the operations array 2001 is recalculated. Accordingly, for each row processed in the operations array 1003, a single row of a list 2003 is processed by the operations array 2001.

[0238] In some cases, the execute function may have three arguments. A first argument may identify a transactor for execution. In the example of FIG. 20, a transactor 2005 is identified via “T2”. A second argument of the execute function is a processing mode parameter that controls whether the execute function triggers execution of one row (argument value “single”) or all rows (argument value “all”) of the transactor specified in the first argument.

[0239] FIG. 21 shows exemplary operating modes of the execute function. In particular, returning to the example of FIG. 20, the execute function may be used to trigger recalculation of the further operations array 2001 from the operations array 1003. At step S2101, the transactor 407 and the transactor 2005 are each configured to process separate lists. Further, the operations array 1003 triggers recalculation of the operations array 2001. The operations array 2001 may be considered an example of a further operations array. At step S2103, it can be seen that the transactor 407 and the transactor 2005 are processing separate lists (i.e., list 601 and list 901) in parallel. At step S2105, a further row of tabular data in each list is processed by the transactor 407 and the transactor 2005.

[0240] Steps S2107, S2109, and S2111 show an alternative way to use the execute function to trigger recalculation of a further operations array from a first operations array. In particular, at step S2107, an operations array 2154 of a transactor 2150 triggers recalculation of an operations array 2156 of a transactor 21 As shown in steps S2109 and S2111, once recalculation of the operations array 2156 is triggered, the transactor 2152 processes all rows of tabular data from its input source before processing of tabular data by the transactor 2150 resumes. This processing can be triggered by calling the execute function with the argument “all.” When triggering recalculation of a further operations array from the operations array 1003 or the operations array 2154, a further input source may be selected. The further input source may be a machine. For example, the further input source may be specified as a third argument for the execute function. Other mechanisms for specifying the further input source are also possible.

[0241] The third argument for the execute function may specify a name or a list to be selected from the inbox 403. If a list having the specified name is in the inbox 403, then operations are performed on multiple rows of tabular data in the list, e.g., according to input received in the further operations array. If the specified list is not in the inbox 403, then execution may be stopped until the list arrives in the inbox 403. Other mechanisms for specifying the further input source can also be used. If a specific list is not specified for processing by the further operations array (e.g., the operations array 2001), then a list matching a List Name Filter specified in the transactor settings 1201 may be selected from the inbox 403. In particular, the first list in the inbox 403 matching the filter criteria specified in the transactor settings 1201 may be selected.

[0242] FIG. 22 shows an exemplary function for storing a determined value of the operations array 1003 to a cell of the output array 1005. According to the example, a row of the operations array 1003 is stored in the output array 1005. This is carried out via the copy function. Thus, continuing the example, the copy function may be used to change or override a row of a list 2201 currently being processed by the transactor 407.

[0243] FIG. 23 shows another exemplary function that can be used in the operations array 1003 to store a determined value of a cell of the operations array 1003 to a cell of the output array 1005. In the example of FIG. 23, the add function is used.

[0244] The add function includes a first argument specifying a row of the operations array 1003 and a second argument specifying a row of the output array 1005. By means of the add function, a row is first inserted into the output destination, and then the values in the cells of the operations array 1003 specified in the first argument of the add function are copied to the cells of the output array 1005 specified in the second argument of the add function. The add function differs from the copy function in that the add function causes a new row to be added to the output destination before writing the row in the output array 1005 to the output destination. In contrast, the copy function causes a row of the tabular data to be overwritten by the row in the output array 1005. The add function can also be used to cause data to be copied to the output destination even if an empty set of tabular data is received from the input source.

[0245] FIG. 24 shows use of the add function in the operations array 2001 to store determined values of the operations array to cells of an output array 2401. At step S2450, a view of the contents of the cells of the operations array 2001 is shown. In particular, a row of random values is calculated in cells A2 to 02. Row 5 of the operations array 2001 indicates that after five recalculations of the operations array 2001, “List B” is ejected and processing stops.

[0246] Step S2452 shows values of the operations array 2001 after three recalculation cycles. The output array 2401 shows a further row of values to be copied to the output destination. At this stage, two rows have already been copied to the output destination.

[0247] FIG. 25 shows the five recalculation cycles that would be carried out in view of the formulas in the operations array 2001 of the transactor 2005, as depicted in FIG. 24.

[0248] FIG. 26 shows an example of triggering execution of the add function.

[0249] In particular, a function in the operations array 1003 triggers recalculation of the further operations array 2001. In this example, the function is the execute function and it is called with an identifier of the operations array 2001 as an argument. Recalculation of the operations array 2001 will be triggered for each row of tabular data inserted into the input array 1001. Upon the completion of performance of operations on tabular data from the input source supplying tabular data to the transactor 407 and an input source supplying tabular data to the transactor 2005, the same number of rows will be provided to the output destination of the transactor 407 as are provided to the output destination of the transactor 2005. However, because the operations array 1003 has different formulas than the operations array 2001, different values will be sent to the output destination of the transactor 407 in comparison to the values sent to the output destination of the transactor 2005.

[0250] FIG. 27 shows an example of the operations array 1003 triggering recalculation of the operations array 2001. Step S2701 shows the transactor 407 and the transactor 2005 after one recalculation has been performed for both transactors. Step S2703 shows the transactor 407 and the transactor 2005 after five recalculations have been performed by both transactors. In both steps S2701 and S2703, rows 1 and 2 of the operations arrays 1003 and 2001 show values corresponding to the contents shown in FIG. 26. In particular, rows 1 and 2 of the operations array 1003 of FIG. 26 and row 2 of the operations array 2001 of FIG. 26 include formulas. The values of these formulas are shown in rows 1 and 2 of the operations array 1003 of FIG. 27 and row 2 of the operations array 2001 of FIG. 27, respectively.

[0251] FIG. 28 shows another example of use of the execute function to trigger recalculation of the operations array 2001 from the operations array 1003. In addition, use of the add function in the operations array 2001 causes a new row to be inserted in the output destination before copying the output array 2401 to the output destination.

[0252] FIG. 29 shows processing of a list by the transactors 407 and 2005. The operations array 1003 includes the formulas depicted in FIG. 29. Similarly, the operations array 2001 includes the formulas depicted in FIG. 26.

[0253] FIG. 29 also shows the values in each cell of the operations array 1003 and the operations array 2001 after processing one row of a list 2901 and evaluating the formulas shown in FIG. 26.

[0254] FIG. 30 shows the values in each cell of the operations array 1003 and the operations array 2001 after processing five rows of the list 2901. Each cell of the operations array 1003 contains the formulas depicted in FIG. 26. Similarly, each cell of the operations array 2001 contains the formulas depicted in FIG. 26. FIG. 30 shows the values of each of the formulas depicted in FIG. 26 after five recalculation cycles.

[0255] FIG. 31 shows the results of five recalculation cycles and an ejection step after the fifth recalculation cycle. In particular, FIG. 31 shows the steps of applying the formulas depicted in the operations array 1003 and the operations array 2001 as shown in FIG. 26.

[0256] FIG. 32 shows a combination of multiple transactors in the machine 401. In one example, the transactor 407 and the transactor 2005 are combined in the machine 401. In a further example, the transactor 407, the transactor 2005, and a transactor 3201 are combined in the machine 401. Processing in the transactor 2005 may be triggered by calling the execute function from the transactor 407. Similarly, processing in the transactor 3201 may be triggered by use of the execute function in the transactor 2005. Each call to the execute function may be made with the “single” argument, as discussed in connection with FIG. 20.

[0257] FIG. 33 shows two examples of the machine 401 processing multiple transactors. In the first example, three transactors are being processed. In particular, the transactor 407, the transactor 2005, and the transactor 3201 are being processed. In the first example, the transactor 407 is reading a list while triggering the transactors 2005 and 3201 in parallel, each of which write two separate lists.

[0258] In the second example, four transactors are processing lists within the machine 401. In particular, in the second example, the transactor 407, the transactor 2005, the transactor 3201, and a transactor 3301 are each processing separate lists.

[0259] Processing in the transactors to the right of the transactor 407 may be triggered via an execute function in the previous transactor. As in the examples of FIG. 32, in the examples of FIG. 33, the execute function may be called with the “single” argument, as discussed in connection with FIG. 20.

[0260] FIG. 34 shows two examples of the machine 401 including four transactors. Processing in one of the transactors, other than the transactor 407, may be triggered by the execute function in one of the previous transactors. In particular, processing in the transactor 2005 may be triggered by the execute function in the transactor 407. Similarly, processing in the transaction 3201 may be triggered by the execute function in the transactor 2005. Further, processing in the transactor 3301, may be triggered by the execute function in the transactor 3201. In these examples, the execute function may be called with the “single” argument (i.e., the word “single” passed as an argument to the function), as discussed above with respect to the processing mode parameter.

[0261] FIGS. 35 to 38 show processing to modify the content of a list according to an example.

[0262] FIG. 35 shows the transactor 407 and the operations array 1003. The operations array 1003 includes formulas for processing a list 3501. According to the example, the input source is the same as the output destination. In particular, the list 3501 may be received from the input source (e.g., a machine on a refrigerator), operations are performed on the list 3501 and then the list 3501 is sent to the output destination (i.e., the machine on the refrigerator). Accordingly, carrying out the example of FIGS. 35 to 38 will result in the list 3501 having modified values.

[0263] The formulas in the operations array 1003 will swap the values in the third and fourth columns of the list 3501. In addition, the formulas in the operations array 1003 will cause the values in the third column of the list 3501 to be multiplied by two and the values in the fourth column of the list 3501 to be divided by two. This is shown in the first row of intermediate list 3503. After all the rows of tabular data in the list 3501 have been processed, i.e., after operations have been performed on the rows of tabular data in the list 3501 according to the formulas received as input in the operations array, a finished list will be ejected from the transactor 407 and processing will stop.

[0264] FIG. 36 shows steps according to the example. In particular, at step S3901, a row of tabular data is taken from the list 3501. At step S3902, the row of tabular data from the list 3501 may be inserted into the input array 1001. Further, at step S3902, the row of tabular data from the list 3501 that was inserted into the input array 1001 may also be inserted into the output array 1005.

[0265] FIG. 37 shows further steps according to the example. In particular, at step S3701, a recalculation of the operations array 1003 is performed. At step S3703, the copy function in the operations array 1003 causes determined values in the second row of the operations array 1003 to be stored in cells of the output array 1005.

[0266] FIG. 38 shows further steps according to the example. At step S3801, the values stored in the output array 1005 are copied to the output destination. Accordingly, the values stored in the output array 1005 are copied to the intermediate list 3503, which may be copied to or sent to the output destination after it is ejected. After step S3803, it is possible to insert the next row of the list 3501 into the input array 1001.

[0267] FIGS. 39 to 41 show a second example of interactively performing operations on tabular data.

[0268] FIG. 39 shows recalculation of the operations array 1003. Because the add function is included in the operations array 1003, step S3901 shows insertion of a new row at the output list. At step S3905, values from the output array 1005 are copied to the output list.

[0269] After a second recalculation of the operations array 1003, step S3907 shows a new row being added to the output list. Step S3909 shows the values from the output array being copied to the new row at the output list. Step S3911 shows the output list after the second recalculation of the operations array 1003.

[0270] FIG. 40 shows results of performance of further operations on tabular data according to the example.

[0271] Step S4001 shows formulas initially present as contents of the operations array 1003. Step S4003 shows the transactor 2005 after eight recalculations of the operations array 1003. A list 4001 is shown as the output list. Further, an additional row 4003 is copied from the output array 1005 to the list 4001. Since the IF condition in the operations array 1003 is met at step S4003, the output list 4001 is ejected at step S4003. FIG. 40 also shows that the list 4001 is sent to machine “M2”. Machine “M2” may be considered the output destination. The sending of the list 4001 to the machine “M2” is triggered by the second argument to the eject function in the operations array 1003.

[0272] FIG. 41 shows the first steps of the example of FIGS. 39 to 48. According to the example, the input array is part of the operations array 2001. In particular, the input array is the second row of the operations array 2001. Further, although the output array 2401 is shown as being separate from the operations array 2001, it is possible that the output array is part of the operations array 2001. According to the example, tabular data is received from an input source. In the example, the input source is a random number generator. Accordingly, the tabular data is received as a row of random numbers. Input received as formulas in other cells of the operations array 2001 describes operations to perform on the input array. At step S4101, before any addition operation is performed, cell “A1” of the operations array 2001 evaluates to “0”.

[0273] At step S4103, no output is shown in the output array 2401.

[0274] FIG. 42 shows further steps according to the example. In particular, step S4203 follows step S4103. At step S4203, recalculation of the operations array 2001 is triggered. The recalculation may be triggered by user input. Other means of triggering the recalculation, e.g., from another operations array, are also possible. At step S4205, the content of cell “A1,” i.e., the formula “=A1+1,” increments the value of cell “A1” of the operations array 2001 from 0 to 1.

[0275] At step S4207, the functions in cells A2:02 (i.e., the cells in row 2) generate random numbers. In other words, the functions in the cells of the input array generate random numbers. The random numbers may be considered tabular data and may be inserted into the input array. At step S4209, the add function in cell A4 of the operations array 2001 causes the creation of a new output list. The new list has one row. At step S4211, values of cells of the input array referenced by the add function are stored in cells of the output array 2401. In particular, the add function in the operations array 2001 references four cells of the input array which are also cells of the operations array 2001. The value of the cell containing the add function is determined based on the cells referenced by the add function.

[0276] FIG. 43 shows a further step according to the example.

[0277] Step S4301 is carried out after step S4211. At step S4301, the output array 2401 is copied to the output list 4001. Accordingly, copying the output array 2401 to an output destination may include copying the output array 2401 to then output list 4001 and copying the output list 4001 to the output destination.

[0278] FIG. 44 shows further steps according to the example. Step S4401 is carried out after step S4301. At step S4401, a recalculation of the operations array 2001 is carried out. At step S4403, the formula in cell A1 of the operations array 2001 increments the value of cell A1 from 1 to 2 in view of the recalculation triggered at step S4401. Step S4405 is also triggered by the recalculation of step S4401. At step S4405, random numbers are generated in the cells of row 2 of the operations array 2001. Row 2 of the operations array 2001 is also the input array according to the example. Step S4407 is also triggered by the recalculation of the operations array 2001 carried out step S4401.

[0279] At step S4407, the add function in cell A4 of the operations array 2001 adds a new row to the output list 4001. At step S4409, the add function in cell A4 of the operations array 2001 copies values of cells of the input array referenced by the add function to the output array 2401. In other words, the add function stores values of cell of the input array referenced by the add function in the output array 2401.

[0280] FIG. 45 shows a further step according to the example. Step S4501 is carried out after step S4409. At step S4501, the output array 2401 is copied to the output list 4001. In particular, the output array 2401 is calculated to the new row of the output list 4001 created by the add function.

[0281] The steps of FIGS. 44 and 45 are repeated five more times according to the example.

[0282] FIG. 46 shows further steps according to the example. At step S4601, a recalculation of the operations array 2001 is triggered. At step S4603, the formula in cell A1 of the operations array 2001 is incremented from 7 to 8. At step S4605, the formulas in row 2 of the operations array 2001 generate random numbers. In particular, the four cells A2:D2 generate random numbers.

[0283] At step S4606, the add function in cell A4 adds an empty new row to the output list 4001. At step S4607, execution of the add function in the operations array 2001 also causes the values of the cells of the input array referenced by the add function to be stored in the output array 2401. The values are displayed, e.g., so that the user can verify that the values are correct.

[0284] FIG. 47 shows further steps carried out according to the example. At step S4701, the IF condition in row 5 of the operations array 2001 evaluates to TRUE. Accordingly, the output list 4001 is ejected from the transactor 2005. Step S4702 shows the contents of the output array 2401 being written to the output list 4001. In particular, step S4702 shows the copying of the output array 2401 to the output list 4001. The copying may occur before the output list 4001 is ejected from the transactor 2005. Steps S4603 to S4702 may have been triggered by the recalculation of the operations array 2001 carried out at step S4601.

[0285] FIG. 48 shows the final steps of the example.

[0286] Step S4801 shows the transactor 2005 after completion of performance of operations on the tabular data received from the input source and execution of the eject function. At step S4803, the output list 4001 is completed. At step S4805, the list 4001 is forwarded to machine “M2.” The machine M2 may be understood as the output destination. Thus, copying the output array 2401 to the output destination may include copying the output array 2401 to the output list 4001 and copying the output list 4001 to the output destination.

[0287] The list 4001 may undergo further processing at machine M2.

[0288] FIGS. 49 to 52 show yet another example of interactively performing operations on tabular data.

[0289] FIG. 49 shows interaction between two transactors when processing lists according to the example. Since the transactor 407 does not include the add function or the copy function, the transactor 407 does not alter its input list. In particular, tabular data in an output list 5152 is identical to the tabular data received from an input source.

[0290] In the example discussed in connection with FIGS. 49 to 52, two transactors work together to create a new list that is a modified version of a list (including tabular data) received from an input source.

[0291] FIG. 50 shows the first steps according to the example.

[0292] At step S5001, tabular data is received from an input source. The tabular data is received in the form of an input list 5050. At step S5002, a row of the tabular data is inserted into the input array 1001.

[0293] FIG. 51 shows further steps according to the example.

[0294] At step S5101, insertion of a row of tabular data into the input array 1001 may trigger recalculation of the operations array 1003. At step S5103, an execute function in cell “A4” of the operations array 1003 may trigger recalculation of the operations array 2001. The execute function may be carried out in view of the recalculation of step S5101.

[0295] At step S5105 the operations array 2001 is recalculated. Step S5105 may be understood as an example of the recalculation of a further operations array triggered by performance of operations on the rows of tabular data, e.g., according to received input in the operations array 1003.

[0296] At step S5107, references in the operations array 2001 cause values to be copied from the operations array 1003 in response to the recalculation in step S5105. At step S5109, an add function in the operations array 2001 causes data from the operations array 2001 to be stored in cells of the output array 2401. Step S5111 is carried out in response to the add function called in step S5109. In step S5111, a new row is added to an output list 5150 as a result of calling the add function in step S5109. Step S5113 may be carried out in preparation for inserting the output array in the output list 5150.

[0297] The output list 5152 is identical to the input list 5050 because the operations array 1003 does not include the add function or the copy function. Accordingly, data from the input list 5050 is simply copied to the output list 5152.

[0298] In contrast, because the operations array 2001 of the transactor 2005 includes add function, the output list 5150 differs from the input list 5050.

[0299] FIG. 52 shows further steps of the example. Step S5201 is carried out after step S5113. At step S5201, the output array 2401 is copied to the output list 5150. In particular, values in the output array 2401 are copied to the output list 5150. At step S5203, this processing may continue.

[0300] The output list 5152 is shown for the transactor 4007. The output 5152 includes unmodified tabular data as received from the input source.

[0301] The output list 5152 may be ejected from the transactor 407 if an IF function in the operations array 1003 evaluates to TRUE. The output list 5150 may be ejected if an IF function in the operations array 2001 evaluates to TRUE. The output list 5150 may be sent to an output destination. Accordingly, copying the output array 2401 to the output destination may include copying the output array 2401 to the output list 5150 and sending the output list 5150 to the output destination.

[0302] FIGS. 53 to 56 show an additional example of interactively performing operations on tabular data. According to the example, two transactors operate in combination to merge content of one list into the content of a second list.

[0303] FIG. 53 shows the first steps according to the example. At step S5301, tabular data in the form of a list 5350 is received from an input source. At step S5302, a row of the tabular data is inserted into the input array 1001.

[0304] FIG. 54 shows further steps carried out according to the example. At step S5401, insertion of the row of tabular data into the input array 1001 triggers performance of further operations on the row of tabular data. In particular, the operations array 1003 is recalculated at step S5401. Recalculation of the operations array 1003 causes the execute function in the operations array 1003 to be executed at step 85402. Accordingly, performance of operations on the rows of tabular data triggers recalculation of a further operations array from the operations array 1003. The further operations array is shown as the operations array 2001.

[0305] Upon recalculation of the operations array 2001, tabular data is received from a further input source at step S5404. At step S5405, a row of the tabular data received from the further input source is inserted into a further input array 5450 and into the output array 2401.

[0306] FIG. 55 shows further steps carried out according to the example. At step S5501, the operations array 2001 is recalculated. Steps S5404, S5405, and S5501 may be triggered by the execute function executed in step S5402. At step S5503, a copy function in the operations array 2001 causes the second row of the operations array 2001 to be copied to the output array 2401.

[0307] FIG. 56 shows the final steps according to the example. At step S5601, the output array 2401 is copied to a list 5650. At step 85603, processing of data continues. When the IF condition in the transactor 407 evaluates to TRUE the list 5350 is ejected from the transactor 407. When the IF condition in the operations array 2001 evaluates to TRUE, the list 5650 currently being processed by the transactor 2005 is ejected. The list 5650 is then sent to an output destination. Accordingly, copying the output array 2401 to the output destination may include copying the output array 2401 to the list 5650 and then sending the list 5650 to the output destination.

[0308] Ejection of a list from a transactor means that processing on that list by the transactor ceases. The transactor may process another list or may stop processing altogether.

[0309] FIGS. 57 to 63 show a device (e.g., a smart kitchen device) controllable via tabular data. In particular, FIGS. 57 to 63 show a system to automatically create a grocery shopping list for grocery orders based on consumption monitored via radio frequency identification (RFID) at smart kitchen devices.

[0310] Other practical implementations of the method for interactively performing operations on tabular data are also possible. For example, another possible implementation involves an automated system for grocery stores or retailers with a frequently changing range or products. The system may read order lists sent from consumers (generated by machines implementing the method for interactively performing operations on tabular data) and automatically send the order lists to a number of machines in a warehouse that each run the method for interactively performing operations on tabular data. The machines may act as automated order selection systems to carry out the instructions in the lists.

[0311] Another possible scenario involves a manufacturing plant with frequent product changes. In particular, the devices (e.g., devices controllable via tabular data) in the manufacturing plant must be frequently reconfigured to produce various products. The production devices in the plant process orders to produce a quantity of goods and simultaneously use machines for interactively performing operations on tabular data to order new material that is needed by devices in the plant.

[0312] FIG. 57 shows a device controllable via tabular data according to an example. FIG. 57 also shows application of a method for interactively performing operations on tabular data.

[0313] According to the example, the device is configured to automatically create a list or grocery orders based on consumption monitored via RFID at the device. Other technologies for monitoring consumption at the device are also possible.

[0314] According to the example, a refrigerator 5701 is provided as an example of a device controllable via tabular data. Other examples of smart kitchen devices controllable via tabular data are a cupboard and a freezer.

[0315] The refrigerator 5701 may be equipped with a sensor 5703 that detects near field movement of RFID equipped groceries. In particular, the refrigerator 5701 may be able to sense when RFID tagged items are put into or taken out of the refrigerator 5701. This may be accomplished via the sensor 5703. The sensor 5703 may be implemented as an RFID sensor. A container of yogurt 5705 is shown as an example of an RFID tagged grocery item that can be detected when it is placed inside or taken out of the refrigerator 5701.

[0316] The refrigerator 5701 may include a computing unit 5707. The computing unit 5707 may be capable of processing information from the sensor 5703. In particular, the computing unit 5707 may be capable of generating an event when the sensor 5703 detects that the yogurt 5705 (or another grocery item) is taken out of or placed inside of the refrigerator 5701. The event may cause a row of tabular data to be produced. This row of tabular data may be received along with other tabular data from an input source. In particular, the refrigerator 5701 is an example of the input source.

[0317] The refrigerator 5701 may also include a timer 5709 (e.g., a system clock). The timer 5709 may be used to trigger time based actions. Accordingly, the rows of tabular data operated on according to the method for interactively performing operations on tabular data may have been generated or produced in response to events generated by the refrigerator 5701, or a similar device.

[0318] Since grocery orders differ for every household, it would be impossible for standard software to provide all possible variations even when offering a wide variety of customization parameters. Accordingly, it may be advantageous to enable a user to provide input into an operations array, where the input may include references and calculations that can affect operations performed on rows of tabular data received from the input source, e.g., the refrigerator 5701 or the computing unit 5703.

[0319] FIG. 58 shows an example of controlling a device via tabular data. In addition, FIG. 58 shows an exemplary application of the method for interactively performing operations on tabular data in the context of the components shown in FIG. 57.

[0320] The refrigerator 5701 may be implemented as a specific refrigerator or as a generic kitchen device as shown in FIG. 58. The refrigerator 5701 is an example of a primary kitchen device. The primary kitchen device may perform procurement, i.e., organize the ordering of items, for other devices in the kitchen. The primary kitchen device 5701 may also organize procurement for other RFID equipped entities, such as a kitchen cabinet or a pantry. These other RFID equipped entities may also be equipped with the computing unit 5707, the sensor 5703 and the timer 5709 as shown in FIG. 57. Accordingly, there may be a number of RFID equipped entities controllable via tabular data, i.e., equipped to perform operations on tabular data, generate events, and trigger the procurement of items by the primary kitchen device.

[0321] Accordingly, the sensor 5703 may detect that an RFID equipped grocery item, such as the yogurt 5705, has been added to the refrigerator 5701. In particular, the sensor 5703 may detect that the yogurt 5705 has passed through the door of the refrigerator 5701. The sensor 5703 may read the identifier of the yogurt 5705 and determine the direction that the yogurt has passed, e.g., into the refrigerator 5701 or out of the refrigerator 5701.

[0322] According to the example of FIG. 58, removing the yogurt 5705 from the refrigerator may be represented by a “1” in the tabular data. Further, adding the yogurt 5705 to the refrigerator 5701 may be represented as “−1” in the tabular data. The computing unit 5707 is an example of an input source. The computing unit 5707 may produce a row of tabular data for each event generated. An event may be generated each time the sensor 5703 detects that an item (e.g., the yogurt 5705) passes into or out of the refrigerator 5701. Each row of tabular data produced by the computing unit 5707 may be provided by the computing unit 5707 to the inbox 403 as a one row list. Each one row list may be labeled “door_action.” Each “door_action” list may contain two cells, the first cell containing the identifier of the item that passed through the door of the refrigerator 5701 and the second cell containing the representation of the direction in which the item passed (i.e., “−1” for going into the refrigerator 5701 and “1” for going out of the refrigerator 5701).

[0323] In the example of FIG. 58, the machine 401 and the machine 5801 run as separate processors on the computing unit 5707. The machine 5801 also includes an inbox 5805, and a transactor including an input array 5807 and operations array 5809 and an output array 5811. The machine 5801 is identified via a machine name 5803. Accordingly, an eject function in the operations array 1003 can be used to send a list of door actions 5813 from the machine 401 to the machine 5801. Upon receipt of the door actions at machine 5801, the door actions are placed in the inbox 5805. The transactor of the machine 5801 may perform operations on the list of door actions 5810 in order to produce a list of order actions 5815.

[0324] FIG. 59 shows the machine 401 of the refrigerator 5701 in more detail. The machine 401 may be implemented as a process on the refrigerator 5701.

[0325] The operations array 1003 includes received input (e.g., a reference to a cell of the input array 1001) used to control the performance of operations on the rows of tabular data produced in response to events generated by the refrigerator 5701. Each event may have been generated by an item passing through the door of the refrigerator 5701. In particular, each event may have been generated when the sensor 5703 detected an item passing through the door of the refrigerator 5701. Accordingly, FIG. 59 shows the processing of door actions by the machine 401 of the refrigerator 5701.

[0326] FIG. 60 depicts processing of a “timer action” list by the machine 401 of the refrigerator 5701. According to the example, at a predetermined time (e.g., 3 am) the computing unit 5707 may send a timer action list 6001 to the machine 401. The timer action list 6001 may include a first cell with the string “timer” and a second cell with a date. The timer action list 6001 may be used to trigger a procurement action. In particular, the timer action list 6001 may cause an IF condition in the operations array 1003 to evaluate to TRUE. Accordingly, the list of door actions being processed in the machine 401 may be ejected and may be sent to the procurement machine 5801 so that an order for items can be generated. The order for items may be implemented as the order list 5815.

[0327] FIG. 61 shows the procurement machine 5801 in more detail.

[0328] The procurement machine may be configured to accumulate incoming door actions from the refrigerator 5701 and other kitchen devices in order to create the order list 5815. The procurement machine 5801 may include two transactors.

[0329] The listcreate function called from the operations array 5809 may include a first argument specifying the name of a list. When the listcreate function is executed in the operations array 5809, the function checks whether a list with the name provided as an argument exists in the inbox 403. If such a list does not exist, the listcreate function creates an empty list with the name provided as an argument. If a list already exists with the list name provided as an argument to the listcreate function, the listcreate function does nothing.

[0330] Row 4 of the operations array 6101 includes a listindex function and a listcount function. The listindex function may be called without an argument. When the listindex function is executed in the operations array 6101, the function returns the index of the row of the list that is currently being processed in the operations array 6101. If there is no list being processed by the operations array 6101, then the listindex function returns −1. The listcount function may also be called with no argument. When the listcount function is executed in the operations array 6101, the function returns the number of elements in the current list that is being processed by the transactor of the operations array 6101. If there is no list in the current transactor, the listcount function returns −1.

[0331] An operations array 6101 of the second transactor may be configured to send the order list 5815 to a printer 6301 (as shown in FIG. 63). The printer 6301 may be considered an output destination. The_order_list_5815 may be sent to the printer 6301 when the size of the order list 5815 exceeds a predetermined number of rows. In the example of FIG. 61, the predetermined number of rows is 50. Accordingly, if more than 50 entries are on the order list 5815, the order list 5815 may be ejected and sent to a machine having the name “orders@penny.com.” Otherwise the order list 5815 is sent back to the inbox 403. The inbox 403 in the procurement machine 5801 may have the same functionality as the inbox 403 in the machine 407.

[0332] In addition or alternatively, the order list may be sent directly to a different output destination (e.g., a grocery store) for further processing.

[0333] FIG. 62 shows interaction between a primary kitchen device and other kitchen devices. According to the specific example, the primary kitchen device is implemented as the refrigerator 5701. Other devices connected to the refrigerator 5701 may include a kitchen cabinet 6201 and a freezer 6203. The other kitchen devices 6201 and 6203 may function similarly to the refrigerator 5701. The devices 6201 and 6203 may each include a machine similar to the machine 401 of the refrigerator 5701. However, according to the example, the devices 6201 and 6203 do not include procurement machines corresponding to the procurement machine 5801 of the refrigerator 5701. Instead, the devices 6201 and 6203 are configured to send their door action lists to the procurement machine 5801 of the refrigerator 5701. These door action lists are processed by the procurement machine 5801 similar to the way the procurement machine 5801 handles door action lists from the machine 5401 of the refrigerator 5701.

[0334] FIG. 63 shows the order list 5815 being sent to the printer 6301 or a machine 6303 of the grocery store for further processing.

[0335] The example discussed above in the context of FIGS. 57 to 63 may be expanded. In particular, there may be multiple suppliers or various items. Accordingly, the procurement machine 5801 may be configured to send lists to different places depending on various conditions. In addition, the procurement machine 5801 may be configured to release orders for items only when certain quantities of the items are reached. This may allow a household to take advantage of discounts for larger quantities of items. This system could also be configured to receive special deals via the inbox and condition the distribution of orders according to the special deals. Other rules may also be configured. In particular, a user may provide input to configure the procurement machine such that milk is not ordered on Tuesdays except when it is May or October. Virtually any type of ordering can be modeled.

[0336] Conventionally, in order to provide a solution to the problem solved via the example of FIGS. 57 to 63, a database in conjunction with a procedural programming language would be provided. This would require at least the following resources: [0337] a database, e.g., an SQL database [0338] a collection of custom software modules programmed in a procedural language (e.g., Java, C++, Basic) [0339] an application server to host the software module [0340] a development environment integrated with a debugging environment [0341] a programming resource capable of modeling and altering database designs [0342] a programming resource capable of writing and testing procedural software code.
Accordingly, the conventional implementation would require significant computing power and significant skilled programming resources. In other words, the conventional solution would be more expensive in terms of required equipment and training.

[0343] FIG. 64 shows two instances of the machine 401. In the first instance, the machine 401 includes the three transactors 407, 2005 and 3201. In the second instance, the machine 401 includes the four transactors 407, 2005, 3201, and 3301.

[0344] In the first instance of the machine 401, the processing mode parameter of the execute function is changed from “single” to “all”. This means that the transactor 407 and the transactor 2005 will not process both input lists in parallel. Instead, the transactor 2005 will process all rows of its input list for each row processed by the transactor 407. The resulting list from the transactor 3201 will have as many rows as the product of the number of rows from the list processed by the transactor 407 and the list processed by the transactor 2005. The resulting list from the transactor 3201 has 9 rows since only 3 rows from each of the transactors 407 and 2005 have been processed.

[0345] In the second instance of the machine 401, the processing mode parameter of the first three left transactors is changed from “Single” to “All,” and the resulting list from the transactor 3301 will have as many rows as the product of the number of rows in the lists of the first three transactors 407, 2005, and 3201.

[0346] FIG. 65 shows a flow chart for the execute function. As discussed above, when provided as input in the operations array 1003, upon recalculation of the operations array 1003, the execute function may trigger recalculation of a further operations array 2001. An identifier of the further operations array 2001 may be provided as an argument to the execute function.

[0347] At step S6401, processing may begin. In particular, the transactor 407 may begin processing. At step 86403, it is determined whether the transactor 407 accepts lists from the inbox 403. The lists in the inbox 403 may include tabular data received from an input source such as the refrigerator 5701. As discussed above, the transactor 407 may be configured not to accept lists from the inbox 403 if the List Name Filter of the transactor settings 1201 is set to a blank value. If the transactor 407 is not configured to accept lists from the inbox 403, step S6405 is carried out and the operations array 1003 is recalculated. After evaluating all formulas in the operations array 1003, the process ends.

[0348] If the transactor 407 is configured to accept lists from the inbox 403, step S6407 is carried out. The transactor 407 is configured to accept lists from the inbox 403 by setting the List Name Filter of the transactor settings 1201 to a non-blank value. If a list is currently being processed by the transactor 407, step S6409 is carried out. At step S6409, a determination is made as to whether the last row of the list being processed by the transactor 407 has been reached. If the last row of the list being processed by the transactor 407 has not been reached, a row of tabular data from the list is inserted into the input array 1001 at step S6411. Following that, the operations array 1003 is recalculated at step S6405.

[0349] If it is determined at step S6407 that there is no list currently being processed by the transactor 407, step S6413 is carried out. At step S6413, it is determined whether there is a list in the inbox 403. If there is no list in the inbox 403, the transactor 407 waits for a list to be inserted into the inbox 403 at 56414. In other words, the machine 401 waits to receive tabular data from an input source, such as the computing unit 5707.

[0350] Once a new list is received in the inbox 403, a row of tabular data from the list is inserted into the input array 1001 at step S6415. Following step S6415, the operations array 1003 is recalculated at step S6405. If the execute function was called with the argument “single”, as discussed above in the context of FIG. 20, a determination is made at step S6417 to end the process at step S6419.

[0351] If the execute function is called with the “all” argument, as discussed above in the context of FIG. 20, step 86421 is carried out. Accordingly, the process continues until all rows are processed by the transactor 407. Execute functions may be nested. In other words, an execute function in the transactor 407 may cause the transactor 2005 to recalculate the operations array 2001. The operations array 2001 may include an execute function that causes yet another transactor to recalculate its operations array. Further nesting of execute functions may also be carried out.

[0352] From the foregoing, it will be seen that this invention is one well adapted to attain all the ends and objects hereinabove set forth together with other advantages which are obvious and which are inherent to the structure.

[0353] It will be understood that certain features and subcombinations are of utility and may be employed without reference to other features and subcombinations. This is contemplated by and is within the scope of the claims.

[0354] Since many possible embodiments may be made of the invention without departing from the scope thereof, it is to be understood that all matter herein set forth or shown in the accompanying drawings is to be interpreted as illustrative and not in a limiting sense.