Patent Application
20180007142
This Non-Provisional Patent Application claims priority to co-pending German Patent Application No. 10 2016 006 342.4, which was foreign filed on May 20, 2016, and which is titled “Controlling a Device Using Tabular Data,” the contents of which is incorporated herein by reference in its entirety.
The technical field of the present application is interactively performing operations on tabular data. In particular, aspects of the application relate to enabling devices to communicate via tabular data and controlling devices via tabular data. Further aspects of the application relate to a computer implemented method for interactively performing operations on tabular data, a computer program product that performs operations according to the method, and a computer system for interactively performing operations on tabular data.
The continuously expanding Internet input structure and the trend toward increasingly smaller microprocessors, increasing numbers of sensors and expanding network connectivity enables the connection of almost all physical objects (e.g., computers, electronic devices, vehicles, and other items) via the Internet to collect and exchange data. The resulting is sometimes referred to as the Internet of Things. It has been predicted that up to 50 billion objects will be connected via the Internet of Things by 2020.
Since each device connected to the Internet of Things may be produced by a different vendor, and each vendor may implement different communication protocols, different data formats, and different APis, it will be a challenge to enable devices in the Internet of Things to communicate such that any one of the devices can interact with any other of the devices. In particular, because different vendors may produce devices that have different requirements when it comes to sending and receiving data, it may be a challenge to enable arbitrary interactions between one of the devices and any other of the devices. However, even more challenging than standardizing protocols, data formats, and APis to enable communication between devices, is the amount of programming work needed to instruct the devices to carry out tasks and interactions.
In practice, it is unlikely that every object (e.g., device) in the Internet of Things will interact with every other object in the Internet of Things; this would lead to an immensely high number of combinations. However, even with a far lower number of realistic combinations, the number of potential interactions between devices or objects in the Internet of Things will be extremely high, and so will be the amount of programming work needed to be done in order to control the interactions between the objects.
Since there is already a shortage of qualified programmers, it is a problem to simplify programming of objects (e.g., in the Internet of Things). In particular, it would be desirable if programming of devices (e.g., in the Internet of Things) could be done by non-programmers. Aspects of the present application may enable people familiar with building spreadsheets to program devices in the Internet of Things. In particular, it is possible that there are more people who are able to build spreadsheets than write procedural code (for example in Java, JavaScript, PHP, or C++). Accordingly, aspects of the present application enable devices to be instructed and controlled using spreadsheet functionality, i.e., without having to write lines of procedural code. In particular, it may be desirable to program or control or instruct devices without writing a single line of procedural code.
An advantage of operating on tabular data (e.g., building a spreadsheet) is that a user can immediately and visually control and test what is being built as it is being built. In particular, it may be possible to see an application execute and watch results of execution even though the application is not fully functional. In contrast, when a programmer works on procedural code for an application or program, the programmer must first write the code completely and ensure that the code is syntactically and semantically correct before running the code to see possible errors. Before the application/program is completely written and functional, the programmer may have to debug the code in his mind or imagine code execution in order to perceive how the code may be executed and what results may be generated.
Further, when writing procedural code, data structures and process logic might not be materially visible in a program development environment. In other words, when writing procedural code the programmer may have to finish writing the entire program and compile the program successfully before being able to see any results of execution of the program. In contrast, when operating on tabular data (e.g., building the spreadsheet), the user may be able to see the results of performing operations even though some of the operations are unsuccessful or incomplete (e.g., there are errors in the operations).
Further, when writing procedural code, data structures and process logic might not be materially visible in a program development environment. In other words, when writing procedural code, the programmer may have to finish writing the entire program and compile the program successfully before being able to see any results of execution of the program. In contrast, when operating on tabular data (e.g., building the spreadsheet), the user may be able to see the results of performing operations even though some of the operations are unsuccessful or incomplete (e.g., there are errors in the operations).
In the context of the Internet of Things, the “thing” may be understood as a physical object embedded with electronics, software, one or more sensors, and network connectivity. The thing or object may be able to exchange data with other objects. The thing or object may be understood as a device. Examples of devices are heart monitoring implants, biochip transponders, electric clamps, automobiles, DNA analysis devices, field operation devices to assist fire fighters, or household or office appliances.
Operating on tabular data provides the advantage of simplicity. In particular, tabular data may be more easily understood and manipulated than other data formats, e.g., procedural code.
According to an aspect, a device controllable via tabular data is provided. The device comprises a timer for generating events at a predetermined time. The device further comprises a sensor for generating events upon detection of specified (i.e., predetermined- or predeterminable) changes in the device or in an environment of the device. The device also comprises a computing unit. The computing unit comprises a memory for storing an input array, an operations array and an output array, wherein each array includes at least one cell. The computing unit further comprises a receiver configured to receive the operations array, the operations array including a first reference to a cell of the input array. The receiver is also configured to receive tabular data from an input source. The device also comprises a processor configured to 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 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. The operations also comprise storing one of the following in a cell of the output array:
The device may be a household or office appliance, such as a refrigerator. The predetermined time may be a time when the device is not generally in use, e.g., 3:00 am. A predetermined (i.e., specified in advance) change in the device might be movement of a part of the device or removal of a part of the device.
A predetermined change in the environment of the device might be bringing another object into contact with the device, placing another object (e.g., an RFID tagged food item) inside the device, or removing an object from the device. For example, when an RFID tagged yogurt container is removed from the device, this may be detected by the sensor, an event may be generated, and a row of tabular data may be produced in response to the event.
According to a further aspect, a computer implemented method for interactively performing operations on tabular data is provided. The operations may comprise instructions to process events generated by a device and/or instructions to formulate instructions for another device. Further, the operations may involve processing event data generated by a first device (e.g., a refrigerator) in order to formulate instructions for a second device (e.g., a grocery distribution processor).
Each device may be connected to other devices. For example, each operation may be an instruction to the device. The device may be a household appliance, such as a vacuum cleaner. A first instruction may cause the vacuum cleaner to move itself to a specific location at a specific time. A second instruction may cause the vacuum cleaner to start vacuuming at a specific time. A third instruction may cause the vacuum cleaner to stop vacuuming at a specific time.
The method comprises providing an input array, an operations array, and an output array. Each array includes at least one cell. The names of the arrays are intended to facilitate identification and distinction. The arrays may also be referred to as a first array, a second array, and a third array.
The input array and/or the output array may be separate from the operations array. Alternatively, the input array and/or the output array may be part of the operations array.
The method may further comprise receiving input in the operations array. The input may comprise a first input in a first cell of the operations array. The first input may be a first reference to a cell of the input array. The input may be provided by a user via a keyboard. The first reference to the cell of the input array may include a row and column of the input array. The first reference may also include a name of the input array.
The method further comprises receiving tabular data from an input source. In addition, the method comprises performing operations on multiple rows of the tabular data.
The operations may be performed according to the received input in the operations array. In other words, the received input, e.g., the first input, specifies how to process multiple rows of the tabular data. For example, the first input may comprise the first reference. Accordingly, the first input may specify a source and destination to copy a column of the tabular data.
The operations comprise inserting one of the rows of the tabular data into the input array. In some cases, the input array may be arbitrarily expanded to accommodate a row of the tabular data. In other cases, the input array may have a predetermined size, and the size of the row of tabular data may be less than the size of the input array. In particular, the input array may have a certain number of columns and the row of tabular data may have fewer columns than the input array.
The method further comprises determining a value of a second cell of the operations array based on the referenced cell of the input array. In some cases, the operations array has at least two cells, and the second cell is different from the first cell. Each element of the following may be a cell: the operations array, the input array, and the output array.
The method further comprises storing one of the following in a cell of the output array: the determined value (i.e., of the second cell) of the operations array and a value of the referenced cell of the input array. The storing step may comprise copying the value of the second cell of the operations array to the cell of the output array.
The input array, the operations array, and the output array may be stored in separate memory areas. Further, it is possible that the input array, the output array, and the operations array do not overlap.
The method may further comprise displaying the output array. Displaying the output array may be carried out by causing a display device, e.g., a computer monitor, to display the output array to a user. The method further comprises copying the output array to an output destination.
The method or the device may comprise one or more of the following, in various combinations.
The output array may reflect information or status of the device. Copying the output array to the output destination may include providing or distributing information about a state of the device.
The input source may be a device, a machine (e.g., a process on a device), a file, a data stream, a file on the device or a data stream received from the device. The input source may also be a transactor. The data stream may be understood as a sequence of data elements (e.g., data packets) made available over time. The file may be stored in memory, e.g., flash memory or a hard disk.
The method may further comprise (or the device may be coupled to a display configured for) displaying the input array before determining the value of the second cell. In some cases, the input array is initially displayed as a blank series of cells. Accordingly, upon insertion of one of the rows of the tabular data into the input array, the values of the elements of the row may be displayed in the cells of the input array. Upon insertion of a new row of tabular data into the input array, the values of the elements of the new row of tabular data may be displayed in the cells of the input array.
In some cases, the determined value of the second cell of the operations array is a value of the referenced cell of the input array. In other words, determining the value of the second cell of the operations array based on the referenced cell of the input array involves copying the value of the referenced cell of the input array to the second cell of the operations array. Alternatively, the determined value of the second cell of the operations array may be a derived value based on the value of the referenced cell of the input array. In this case, the derived value differs from the value of the referenced cell of the input array.
A recalculation of the operations array may be performed after the inserting of one of the rows of the tabular data into the input array. The recalculation may comprise the determination of the value of the second cell of the operations array based on the referenced cell of the input array. The recalculation may further comprise the storage of the determined value in the cell of the output array. The recalculation may further comprise the display of the output array. Also, the recalculation may comprise the copying of the output array to an output list.
The first input may be a formula referring to the referenced cell of the input array. In other words, receiving the first reference in the operations array may comprise receiving a formula that includes the first reference. In particular, the first reference may specify a row and column of the input array. For example, the first reference may consist of one or two case insensitive letters to identify a column of the input array followed by a row number. The first reference may also include an identifier of the input array.
The value of the second cell of the operations array may be determined by copying the value of the referenced cell (i.e., the cell of the input array referred to by the first reference) to the first cell of the operations array. The second cell in the operations array may include another formula specifying a calculation that refers to the first cell of the operations array. The determined value of the second cell of the operations array may be the result of applying the calculation specified by the other formula to the copied value. The calculation may include at least one of the following: an arithmetic operation, a relational operation, and a function. For example, applying the calculation to the copied value may involve multiplying the copied value by two. The determined value of the second cell of the operations array would then be the value of the referenced cell of the input array multiplied by two.
The method may further comprise at least one of the following:
In some cases, the input array and the output array may be different sizes. In particular, the output array may have twice the number of columns as the input array.
In addition to determining the value of the second cell of the operations array, further operations may be performed on the tabular data in the input array. The results of these operations may be stored in further cells of the output array before the output array is displayed.
The output array may then be copied to the output destination. Alternatively, the output array may be copied to an output list, which may be copied to an output destination when it is full or after operations on the tabular data are complete.
The input (e.g., the first reference) received in the operations array may further comprise a second input in a third cell of the operations array. For example, the receiving step may comprise receiving a second reference in the third cell of the operations array. The second input (e.g., second reference) may specify the cell of the output array in which to store the determined value. For example, the second input (e.g., second reference) may specify one or more cells of the operations array. In addition, the second input (e.g., second reference) may identify the output array. Also, the second input (e.g., second reference) may specify one or more cells of the output array. Moreover, the second input may specify whether to add a row to an output list before writing the output array to the output list (i.e., writing the output array to the newly added row of the output list).
The cell of the output array may be in the same position with respect to other cells of the output array in comparison to the position of the referenced cell of the input array with respect to other cells of the input array. For example, the referenced cell may be in row 1 and column B of the input array. Accordingly, the cell of the output array is in row 1 and column B of the output array. Alternatively, the cell of the output array may be in a different position with respect to other cells of the output array in comparison to a position of the referenced cell of the input array with respect to other cells of the input array. For example, the cell of the output array in which the determined value is stored may be in row 1 and column C of the output array. In contrast, the referenced cell of the input array may be in row 1 and column B of the input array.
The tabular data may consist of rows of delimited values. In particular, the tabular data may be in comma separated value (CSV) format. For example, the tabular data may be formatted according to request for comments (RFC) 4180. Alternatively, the tabular data may be in markup language format. In particular, the tabular data may be in extensible markup language (XML) format.
The insertion of one of the rows of tabular data into the input array may trigger the determination of the value of the second cell of the operations array. Further, the insertion of one of the rows of tabular data into the input array may trigger evaluation of each cell in the operations array. In other words, the insertion of one of the rows of tabular data into the input array may trigger recalculation of the operations array. The multiple rows of tabular data may consist of all the rows of tabular data in the input source. For example, if the input source is a data stream, tabular data may be received from the data stream until there is no more data in the data stream. Accordingly, operations may be performed on each row of tabular data in the data stream.
Performing the operations on the input array may comprise triggering recalculation of a further operations array from the operations array. The recalculation of the further operations array may comprise performing operations on a single row of tabular data received from a further input source in a further input array. Alternatively, the recalculation of the further operations array may comprise performing operations on multiple rows of tabular data received from the further input source in the further input array. In both cases, the operations may be performed according to input received in the further operations array.
The multiple rows of tabular data received from the further input source may include all tabular data of the further input source. In particular, the operations performed on the tabular data received from the further input source may correspond to, or may be identical to, the operations performed on the multiple rows of tabular data received from the input source. The further operations array may include a reference to a cell of the operations array. The referenced cell may contain a value. The value may be copied to the further operations array during the recalculation.
One or more of the following may apply:
Inserting one of the rows of tabular data into the input array may further comprise determining whether an existing row of the tabular data is in the input array. When the 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. Alternatively, inserting one of the rows of tabular data into the input array may further comprise determining if a predetermined number of rows of tabular data are in the input array. When the predetermined number of rows of tabular data are in the input array, removing one of the rows already in the input array before inserting the (new) row of tabular data into the input array.
The predetermined number of rows may be less than the number of rows in the operations array.
The operations array may comprise a function for storing a determined value to a cell of the output array. The function may cause a row of values to be stored in the output array. The function may cause a row to be added to an output list before the output array is copied to the output list. The function may fill the output array with values from the operations array.
The output destination may be a file, a data stream, a device, or a machine (e.g., a process on the device). In other words, possible output destinations may correspond to possible input sources, i.e., the same entities may serve as input sources or output destinations. The output destination may be the same as the input source. In particular, the input source may be a process on a device and the output destination may be a different process on the device. Further, when the output destination is the same as the input source, copying the output array to the output destination may cause a row of the input source to be overwritten.
Alternatively, copying the output array to the output destination may cause a row of data to be added to the input source (or a file at the input source). Which alternative is carried out may depend on the function used for storing the determined value to the cell of the output array. When the output destination is a data stream and the output destination is the same as the input source, the method may include streaming data back to the source of the input data stream. When the input source and the output destination are the same file, the file may be opened for reading and writing.
In some cases, the input source is a device (e.g., the device controllable via tabular data or a device communicatively connected to the controllable device). Accordingly, the method may further comprise generating, by the device (or an element of the device), events. A row of the tabular data inserted into the input array may have been produced in response to the event. Each row of the tabular data may have been produced in response to events generated by the device.
One or more of the events may be generated in response to detection of a change in the device, a change in the environment of the device or because a specified point in time has been reached (e.g., it is now 3:00 a.m.). The change may comprise detecting one of the following:
The change in the device or the environment of the device may have been brought about by an action of a user.
An event may also be generated in response to a change in the state of the device. For example, a smart shelf may detect that a product has been removed and may generate a row of tabular data specifying the product and a quantity of the product to be ordered. The change in the state of the device may also be caused by the change in the device or the environment of the device.
According to another aspect, a computer program product comprising computer readable instructions is provided. The instructions, when noted and executed on a computer system, cause the computer system to perform operations according to one or more of the method steps discussed above. The computer program product may be tangibly embodied in a computer readable medium.
According to yet another aspect, a computer system for interactively performing operations on tabular data is provided. The system comprises a memory for storing an input array, an operations array, and an output array. Each array includes at least one cell.
The system may further comprise an input receiving device for receiving input in the operations array. The input may comprise a first input in a first cell of the operations array. The first input may reference a cell of the input array. For example, the input may include a first reference to a cell of the input array.
The input receiving device may be a keyboard or a touchscreen or another device suitable for providing alphanumeric characters to a computer. The system further comprises a processor configured to carry out the following:
The operations may be performed according to the received input in the operations array.
The operations comprise:
Further aspects are as follows. A software implemented software object (e.g., a computer program product) called an input transactor may be provided. The software object can process list style data grids (i.e., tabular data). The software object may comprise an input list (i.e., tabular data received from an input source). The input list may be a row and column based data grid of cells with cells which each contain numerical or string data. The software object may further comprise a spreadsheet (i.e., an operations array). The spreadsheet may be a multi-row and multi-column based data grid with internally and externally referable cells. A row by row and left to right calculation order may be used to evaluate internal and external cell references, mathematical formulas, functions and values in each of the cells of the spreadsheet.
The software object may further comprise an input reader (i.e., an input array). The input reader may be a single-row and multi-column based data grid of cells capable of reading the input list row-by-row while holding the values of the currently processed row in its cells. The cells of the input reader are referable cells that can be referenced by other objects inside and outside of the input transactor.
The software object may further comprise an output writer (i.e., output array). The output array may be a single-row and multi-column based data grid of cells initially reading the same data row as the input reader. The output writer may be capable of copying its current cell values back to the same location of the input source that is currently being read by the input reader when triggered to do so by the recalculation of the spreadsheet.
The software object may further comprise a copy function. The copy function may be a spreadsheet function or a likewise implemented functionality that copies values from specified cells of the spreadsheet to the cells of the output writer.
The input reader may be configured to read the input list row-by-row and trigger, after each row advance, a recalculation cycle of the spreadsheet. The recalculation of the spreadsheet may include execution of the copy function to copy values from the spreadsheet to the output writer. The input reader may also trigger, for each row advance, a write action in the output writer, which copies the current cell values of the output writer to the same row in the input list which has just been read by the input reader.
According to a second further aspect, a software implemented software object called an output transactor that can generate a list style data grid (i.e., tabular data) may be provided. The output transactor may comprise an output list. The output list may be a row and column based data grid of cells with cells which each contain numerical or string data. The output transactor may also comprise the spreadsheet, the input reader, and the output writer.
The output transactor may further comprise an add function. The add function may be a spreadsheet function or a likewise implemented functionality that creates an empty output list (i.e., placeholder for tabular data) in case the output list does not exist in the output transactor. In addition, the add function may add a new row to the newly or previously created output list, advance the output list in the output writer to the new row and then copy the values from specified cells of the spreadsheet to the data cells of the output writer.
The software object may further comprise an eject function. The eject function may be a spreadsheet function or a likewise implemented functionality that ejects an output list from the output transactor when one or more specified value conditions are met in the spreadsheet.
When externally called to do so, the output transactor may trigger a recalculation cycle of the spreadsheet. The recalculation cycle may include the execution of the add function to copy values from the spreadsheet to the output writer. The recalculation cycle may also include an execution of a write action in the output writer. The write action may copy the current cell values of the output writer to the current new row in the output list of the output writer. The write action may gradually result in an output list that is growing row-by-row until the eject function is executed in the spreadsheet.
According to a third further aspect, a software implemented software object called a replication transactor is provided. The replication transactor may be configured to generate list style data grids by processing and transforming data from existing data grids. The replication transactor may comprise the input transactor, the output transactor, and an execute function.
The execute function is a spreadsheet function or likewise implemented functionality that enables the input transactor to trigger one recalculation cycle of the spreadsheet of the attached output transactor. The recalculation cycle results in the generation of one new row in the output list, as described above.
The input reader may read the input list row-by-row and, after each row advance, trigger one recalculation cycle of the spreadsheet inside the input transactor. The recalculation cycle may include execution of the execute function to trigger recalculation of the spreadsheet inside the output transactor as described above. Recalculation of the spreadsheet inside the output transactor may result in a row-by-row production and final ejection of the output list with values resulting from the processing of the formulas of the spreadsheets of the input and/or output transactors.
Aspects of the present application may lead to one or more of the following advantages. It may be possible to evaluate results of processing a first row tabular data before processing a second row of tabular data and evaluate results of processing a second row of the tabular data before processing a third row of the tabular data. In particular, it may be possible to see results of processing an intermediate row of tabular data in order to determine whether a desired result will be achieved. This is accomplished by performing operations on multiple rows of tabular data and displaying the output array including results of operations performed on one of the rows before performing operations on further rows. Accordingly, a user can determine if each intermediate result fits in with the desired overall result.
Further, by referencing a cell of the input array including tabular data and determining a value of a cell of the operations array based on the reference cell, cell values in the operations array can be determined or modified more easily, particularly in comparison to the determination or modification of values via procedural code.
Accordingly, less user training is required and fewer programming resources are required. The reduction in training and programming resources is particularly apparent when formulas are part of the received input in the operations array. Moreover, the use of spatial relationships (e.g., relative position, absolute position, named locations) that is possible via cell referencing may make it easier for a user to write useful programs, e.g., to control a device, particularly when the device is networked to other devices.
Also, once operations have been interactively performed on tabular data and the user can see that the desired result will be achieved, operations performed on tabular data received from an input source can be carried out without displaying the output array and without any further user interaction. The elimination of user interaction and/or display of data may be advantageous for performance reasons.
The following definitions are provided in order to aid understanding of terms used in the present application. The terms should also be understood in the light of common general knowledge.
A machine may be a processing device, e.g., a household appliance. In other words, a machine may be a stand-alone device that may be communicably connected to other devices. Alternatively, a machine may be implemented as a process on the device.
Tabular data may be in the form of a list. Tabular data may include multiple rows and multiple columns of data or a single row with multiple columns. Tabular data may also be multidimensional, e.g., the data may have three or more dimensions. Tabular data may have a variety of formats including CSV or XML. The list may be understood as a tabular data object or a collection or a set of tabular data
A transactor may be a basic processing unit on a machine. The transactor may be capable of processing data. The transactor may be implemented via a thread, e.g., in the case when the machine is implemented as a process. Alternatively, a transactor may be implemented as a process or within a process. In particular, a transactor may perform operations on (i.e., processing) multiple rows of tabular data according to input received in an operations array. The transactor may be capable of processing tabular data independently or in combination with other transactors. A transactor may process tabular data in first-in-first-out (FIFO) order. Last-in-first-out (LIFO) processing is also possible. The transactor may be associated with an identifier (e.g., T1) that can be referred to by other transactors.
A cell may be understood as a box or placeholder for holding data. Data may be a value or a formula. In other words, the contents of a cell may be a value or a formula. The cell can be referenced, e.g., via row and column designations/identifiers. The cell may contain a value, or a formula, or the cell may be empty.
A range may be a group of cells, possibly contiguous.
A value may be raw data. In particular, the value may be numeric or text data. The value may be a result of applying a formula. The value can be contrasted with a formula.
A formula may identify a calculation needed to place a result in the cell containing the formula. The formula describes how to compute a new value from one or more existing values or formulas. The formula may assign a value to a cell or assign values to a range of cells. The formula may include an expression. The expression may include one or more of the following: a value, a reference to another cell, an arithmetic operator, a relational operator, and a function.
The content of a cell may refer to input provided to the cell. The content of the cell may be a value, a formula, or nothing (i.e., the cell may be empty). If the input is a formula, then the content is the formula itself rather than the result of applying the formula.
An array may be a collection of elements (i.e., cells) selectable via indices. The array be multi-dimensional. A table and a grid are examples of arrays. Cells of the array may reference other cells in the same array or cells in other arrays. The array may be implemented as a sheet, i.e., a grid of cells.
Interactive may refer to software or a program which accepts and responds to input from a user. The input may include data or a command.
Recalculation of an array may involve evaluating each cell in the array. Each formula contained in the cells is applied (e.g., if the formula specifies a calculation then the calculation is performed). Applying a formula may be understood as performing the operations specified by the formula, for example performing a calculation or executing a function.
A reference may be understood as a pointer. Accordingly, input referencing a cell may be pointing to the cell or addressing the cell. For example, a reference may specify a row and column of a cell. The reference may be included in a formula.
An input array may provide a window into the input source. For example, displaying the input array to a user may enable the user to see data from the input source before the data is processed. In other words, the input array may enable a user to see the tabular data from the input source before operations are performed on the tabular data. The input array may hold tabular data from the input source upon which operations are being performed. Cells of the input array may be addressable (i.e., the cells can be referenced) from an operations array (discussed below). In some cases, the input array may be part of the operations array. The input array may be referred to as an input reader.
An output array may provide a window into an output destination. In particular, displaying the output array to the user may enable the user to see tabular data before the tabular data is sent to the output destination. The output array may hold tabular data determined based on the input array. The output array may hold tabular data copied from the operations array. In some cases, the output array may be part of the operations array. The output array may be referred to as an output writer.
The operations array may receive user input. In particular, user input may be entered in cells of the operations array. Cells of the operations array may refer to the input array or the output array. Cells of the operations array may also refer to other cells of the operations array and perform calculations including references to those cells. The operations array may also include relational functions, functions for performing mathematical calculations, functions for storing cell values in the output array, functions to trigger the recalculation of other operations arrays, and list manipulation functions. The operations array may also include functions that carry out other actions. The operations array may be referred to as a spreadsheet.
The subject matter described in this application can be implemented as a method or on a device, possibly in the form of one or more computer program products. The subject matter described in the application can be implemented in a data signal or in a machine readable medium, where the medium is embodied in one or more information carriers, such as a CD ROM, a DVD ROM, a semiconductor memory, or a hard disk. Such computer program products may cause a data processing apparatus to perform one or more operations described in the application.
In addition, subject matter described in the application can be implemented as a system including a processor, and a memory coupled to the processor. The memory may encode one or more programs to cause the processor to perform one or more of the methods described in the application. Further subject matter described in the application can be implemented using various devices.
Details of one or more implementations are set forth in the exemplary drawings and description below. Other features will be apparent from the description, the drawings, and from the claims.
The present invention is described in detail below with reference to the attached drawing figures, wherein:
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.
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.
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.
In addition, the tabular data may be received as a list 107 in XML format.
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).
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.
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.
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.
The input array 1001, the operations array 1003, and the output array 1005 each include at least one cell. In the example of
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.
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.
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.
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
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.”
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.”
In the example of
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.
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.
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.
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.
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.
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.
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.
In one example provided in
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.
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).”
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.
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
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.
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.
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
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.
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.
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
In some cases, the execute function may have three arguments. A first argument may identify a transactor for execution. In the example of
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
At step S4103, no output is shown in the output array 2401.
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.
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.
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.
The steps of
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.
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.
The list 4001 may undergo further processing at machine M2.
In the example discussed in connection with
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.
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.
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.
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.
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.
In contrast, because the operations array 2001 of the transactor 2005 includes add function, the output list 5150 differs from the input list 5050.
The output list 5152 is shown for the transactor 4007. The output 5152 includes unmodified tabular data as received from the input source.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The refrigerator 5701 may be implemented as a specific refrigerator or as a generic kitchen device as shown in
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.
According to the example of
In the example of
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,
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.
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.
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.
An operations array 6101 of the second transactor may be configured to send the order list 5815 to a printer 6301 (as shown in
In addition or alternatively, the order list may be sent directly to a different output destination (e.g., a grocery store) for further processing.
The example discussed above in the context of
Conventionally, in order to provide a solution to the problem solved via the example of
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.
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.
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.
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.
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.
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
If the execute function is called with the “all” argument, as discussed above in the context of
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.
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.
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.
| Number | Date | Country | Kind |
|---|---|---|---|
| 102016006342.4 | May 2016 | DE | national |
