Patent Publication Number: US-10320685-B1

Title: Iterative autocorrelation calculation for streamed data using components

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application claims the benefit of provisional patent application Ser. No. 62/089,230, filed 2014 Dec. 9 by the present inventor. 
    
    
     BACKGROUND AND RELEVANT ART 
     Internet, mobile communications, navigation, online gaming, sensing technologies and large scale computing infrastructures are producing large amounts of data sets every day. Big Data is data that is beyond the processing capacity of conventional database systems and analyzing capacity of traditional analyzing methods due to its large volume and fast moving and growing speed. More companies now rely on Big Data to make real-time decisions to solve various problems. Current methods involve utilizing a lot of computational resources, which are very costly, yet still may not satisfy the needs of real-time decision making based on the newest information, especially in the financial industry. How to efficiently, promptly and cost-effectively process and analyze Big Data presents a difficult challenge to data analysts and computer scientists. 
     Streamed data is data that is constantly being received by a receiver while being delivered by a provider. Streamed data may be real-time data gathered from sensors and continuously transferred to computing devices or electronic devices. Often this includes receiving similarly formatted data elements in succession separated by some time interval. Streamed data may also be data continuously read from storage devices, e.g., storage devices on multi-computing devices which store a Big Data set. Stream processing has become a focused research area recently due to the following reasons. One reason is that the input data are coming too fast to store entirely for batch processing, so some analysis have to be performed when the data streams in. The second reason is that immediate responses to any changes of the data are required in some application domains, e.g., mobile related applications, online gaming, navigation, real-time stock analysis and automated trading, etc. The third reason is that some applications or electronic devices require streaming processing due to their nature, e.g., audio, video and digital TV, etc. 
     Processing Big Data or streamed data may include performing calculations on a multiple data buffer so that some number of data elements may be stored. Processing the streamed data elements may include accessing data elements stored in the buffer. 
     When performing an autocorrelation calculation on Big Data or streamed data elements, buffer requirements may be quite large. For example, when calculating an autocorrelation, a (potentially large) number of data elements may need to be accessed. 
     Further, some statistical calculations are recalculated as new data are added to a Big Data set or new streamed data elements are accessed or received. Thus, the (potentially large) number of data elements may be repeatedly accessed. For example, it may be that an autocorrelation is calculated for a computation window that includes the last n data elements in a data stream. As such, every time a new data element is accessed or received, the new element is added to the computation window and the current n th  data element is moved out of the computation window. The n data elements in the computation window are then accessed to recalculate the autocorrelation. 
     As such, each data element remains in the computation window for n autocorrelation calculations before it is aged out of the computation window. Accordingly, each data element is read from the buffer n times. When performing an autocorrelation on n data elements all the n data elements in the computation window will be visited and used at least once at a specified lag. 
     In addition, algorithms on streamed data processing may be extended to Big Data processing, because Big Data sets are accumulated over time and they may be considered as a data stream with irregular time intervals. Depending on necessity, the computation window size n may be extremely large, so the data elements in a computation window may be distributed over a cloud comprising hundreds of thousands of computing devices. Re-performing an autocorrelation calculation in traditional ways on Big Data or data stream sets after some data changes inefficiently uses time and computing resources. 
     BRIEF SUMMARY 
     The present disclosure describes methods, systems, and computing system program products for iteratively calculating autocorrelation for streamed data by iteratively calculating one or more (p (p≥1)) components of an autocorrelation and then calculating the autocorrelation using one or more iteratively calculated components. Iteratively calculating autocorrelation avoids visiting all data elements in an adjusted computation window and performing redundant computations thereby increasing calculation efficiency, saving computing resources and reducing computing system&#39;s power consumption. A computing system includes an input buffer for storing streamed data elements. A buffer window size indicates a specified number of streamed data elements for filling computation window for the input buffer. The buffer may reside in memory or other non-transitory computer-readable media, such as a hard disk or other media, and may include multiple distributed files on multiple distributed computing devices, such as may be connected end-to-end to form a “circular buffer”. A specified lag l indicates a lag used for the autocorrelation calculation. 
     The computing system accesses Big Data or streamed data elements for a computation window from the input buffer. For streamed data processing, removing a data or adding a data generally happens at either end of the buffer. The computation window may move to either right or left side direction. For example, when processing streamed data in real-time, the computation window moves to the right side direction. In this case, a new data is always added to the right side of the computation window and an existing data is always removed from the left side of the computation window. When recalculating or reviewing autocorrelation on previous stream data, the computation window may move to the left side direction. In this case, an earlier data is added to the left side of the computation window and a recent data is removed from the right side of the computation window. Both cases may be handled in the same way but just the equations for iterative autocorrelation calculation are different. By way of example, and not limitation, embodiments of the invention are described and explained using the first case (computation window moving to the right side) as an example in the following descriptions. 
     The streamed data elements include an earlier (and possibly initial) streamed data element and one or more additional streamed data elements. The earlier streamed data element was accessed or received prior to the one or more additional streamed data elements. The computing system calculates one or more (p (p≥1)) components of an autocorrelation at the specified lag for the computation window from the earlier streamed element and one or more additional streamed elements. The computing system calculates an autocorrelation for the computation window at the specified lag using the one or more (p (p≥1)) components at the specified lag. 
     The computing system accesses or receives a new streamed data element subsequent to accessing or receiving the one or more additional streamed data elements. The computing system stores the new streamed data element in the input buffer. The computing system adjusts the computation window by removing the earlier streamed data element from the computation window and adding the new streamed data element to the computation window. 
     The computing system directly iteratively calculates one or more v (1≤v≤p) components of an autocorrelation at the specified lag l for the adjusted computation window. Directly iteratively calculating v (1≤v≤p) components at the specified lag includes: accessing the data element removed from the computation window and the new data element added to the computation window from the input buffer and accessing the v components at the specified lag calculated for the previous computation window; removing any contribution of the data element removed from the computation window from each of the v components at the specified lag; mathematically adding a contribution of the new data element to each of the v components at the specified lag. 
     The computing system indirectly iteratively calculates w=p−v components of an autocorrelation at the specified lag for the adjusted computation window as needed. Indirectly iteratively calculating w components at the specified lag includes indirectly iteratively calculating each of the w components at the specified lag one by one. Indirectly iteratively calculating a component at the specified lag includes: accessing one or more components at the specified lag and calculating the component at the specified lag by using one or more components at the specified lag other than the component itself. The one or more components at the specified lag may have been initialized, directly iteratively calculated or indirectly iteratively calculated. 
     The computing system generates an autocorrelation at the specified lag for a given computation window as needed by using one or more iteratively calculated components of an autocorrelation at the specified lag for the given computation window. 
     The computing system may keep accessing or receiving a new data element, storing the data element into a data buffer, adjusting the computation window, directly iteratively calculating v (1≤v≤p) components at the specified lag, indirectly iteratively calculating w=p−v components at the specified lag as needed and generating an autocorrelation at the specified lag as needed, and the computing system may repeat this process for as many times as needed. 
     This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. 
     Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the invention. The features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the present invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       In order to describe the manner in which the above-recited and other advantages and features of the invention may be obtained, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which: 
         FIG. 1  illustrates a high-level overview of an example computing system that facilitates iteratively calculating autocorrelation for streamed data. 
         FIG. 1A  illustrates an example computing system architecture that facilitates iteratively calculating autocorrelation for streamed data with all components being directly iteratively calculated. 
         FIG. 1B  illustrates an example computing system architecture that facilitates iteratively calculating autocorrelation for streamed data with some components being directly iteratively calculated and some components being indirectly iteratively calculated. 
         FIG. 2  illustrates a flow chart of an example method for iteratively calculating an autocorrelation for streamed data. 
         FIG. 3A  illustrates data that is removed from and data is added to a computation window  300 A for iteratively calculating an autocorrelation when the computation window  300 A is moving to the right side. 
         FIG. 3B  illustrates data that is accessed from a computation window  300 A for iteratively calculating autocorrelations at a specified lag when the computation window  300 A is moving to the right side. 
         FIG. 3C  illustrates data that is removed from and data is added to a computation window  300 B for iteratively calculating an autocorrelation when the computation window  300 B is moving to the left side. 
         FIG. 3D  illustrates data that is accessed from a computation window  300 B for iteratively calculating autocorrelations at a specified lag when the computation window  300 B is moving to the left side. 
         FIG. 4A  illustrates the definition of an autocorrelation and traditional equations for calculating an autocorrelation. 
         FIG. 4B  illustrates some example components of an autocorrelation and basic iterative component calculation equations. 
         FIG. 4C  illustrates the equations of the first example iterative autocorrelation calculation algorithm (iterative algorithm 1). 
         FIG. 4D  illustrates the equations of the second example iterative autocorrelation calculation algorithm (iterative algorithm 2). 
         FIG. 4E  illustrates the equations of the third example iterative autocorrelation calculation algorithm (iterative algorithm 3). 
         FIG. 5A  illustrates an example of calculating autocorrelation using traditional algorithms as shown in  FIG. 4A . 
         FIG. 5B  illustrates an example of calculating autocorrelation using iterative algorithm 1 as shown in  FIG. 4C . 
         FIG. 5C  illustrates an example of calculating autocorrelation using iterative algorithm 2 as shown in  FIG. 4D . 
         FIG. 5D  illustrates an example of calculating autocorrelation using iterative algorithm 3 as shown in  FIG. 4E . 
         FIG. 6  illustrates computational loads for traditional autocorrelation algorithms and iterative autocorrelation algorithms 4 when n=4 and l=1. 
         FIG. 7  illustrates computational loads for traditional autocorrelation algorithms and iterative autocorrelation algorithms when n=1,000,000 and l=1. 
     
    
    
     DETAILED DESCRIPTION 
     The present disclosure describes methods, systems, and computing system program products for iteratively calculating an autocorrelation a specified lag l for streamed data by iteratively calculating one or more (p (p≥1)) components of an autocorrelation and then calculating the autocorrelation using one or more iteratively calculated components. Iteratively calculating autocorrelation avoids visiting all data elements in the current computation window and performing redundant computations thereby increasing calculation efficiency, saving computing resources and reducing computing system&#39;s power consumption. A computing system includes a buffer for storing streamed data elements. A computation window size n indicates a specified number of streamed data elements for filling a computation window of the input buffer. The buffer may reside in memory or other non-transitory computer-readable media, such as a hard disk or other media, and may include multiple distributed files on multiple distributed computing devices, such as may be connected end-to-end to form a “circular buffer”. 
     An autocorrelation is a measure of the correlation of a particular time series with the same time series delayed by l lags. It is also called “lagged correlation” or “serial correlation”. It is obtained by dividing the covariance between two observations, separated by l lags, of a time series by the standard deviation. If the autocorrelation is calculated for all values of 1 we obtain the autocorrelation. For a time series that does not change over time, the autocorrelation decreases exponentially to 0. The value of an autocorrelation is between −1 and +1. A value of 1 indicates there is a perfect positive linear relationship between the time series&#39; past and future values. A value of −1 indicates there is an exact negative linear relationship between the time series&#39; past and future values. 
     A computation window is a moving window on a data stream which contains the data elements involved in an autocorrelation calculation. The computation window may move to either right or left direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a data element is always added to the right side of the computation window and a data element is always removed from the left side of the computation window. When recalculating an autocorrelation on previously streamed data, the computation window may move to the left side. In this case, a data element is added to the left side of the computation window and a data element is removed from the right side of the computation window. We want to iteratively calculate the autocorrelation within the computation window whenever the computation window moves to either right or left by one data element. 
     A component of an autocorrelation is a quantity or expression appearing in the autocorrelation&#39;s definition equation or any transforms of the equation. An autocorrelation is the largest component of an autocorrelation itself. An autocorrelation at a specified lag may be calculated using one or more (p (p≥1)) components of the autocorrelation at the specified lag. Some example components of an autocorrelation may be found in  FIG. 4B . 
     A component may be either directly iteratively calculated or indirectly iteratively calculated. The difference between them is that when directly iteratively calculating a component the component is calculated by using the component&#39;s value in previous iteration but when indirectly iteratively calculating a component the component is calculated by using components other than the component itself. 
     For a given component, it might be directly iteratively calculated in one algorithm but indirectly iteratively calculated in another algorithm. 
     For a given algorithm, assume the total number of different components is p (p≥1), the number of directly iteratively calculated components is v (1≤v≤p), then the number of indirectly iteratively calculated components is w=p−v (0≤w&lt;p). For any algorithm, there will be at least one component being directly iteratively calculated. It is possible that all components are directly iteratively calculated (in this case v=p and w=0). However, directly iteratively calculated components must be calculated in every iteration no matter an autocorrelation is accessed or not in a specific iteration. 
     For a given algorithm, if a component is directly iteratively calculated, then the component must be calculated in every iteration (i.e., whenever an existing data element is removed from and a data element is added to the computation window). However, if a component is indirectly iteratively calculated, then the component may be calculated as needed using one or more components other than the component itself, i.e., only when an autocorrelation needs to be calculated and accessed. Thus, when an autocorrelation is not accessed in a specific iteration, only a small number of components need to be iteratively calculated. It should be understood that an indirectly iteratively calculated component may also be used in the calculation of a directly iteratively calculated component. In that case, the indirectly iteratively calculated component should also be calculated in every iteration. 
     A computing system includes an input buffer for storing streamed data elements. A computation window size indicates a specified number of streamed data elements for filling computation windows for the buffer. 
     The computing system accesses streamed data elements for a computation window from the input buffer. For streamed data processing, removing a data or adding a data generally happens at either end of the buffer. The computation window may move to either right or left side direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a new data is always added to the right side of the computation window and an existing data is always removed from the left side of the computation window. When recalculating or reviewing autocorrelations on previous streamed data, the computation window may move to the left. In this case, an earlier data is added to the left side of the computation window and a recent data is removed from the right side of the computation window. Both cases may be handled in the same way but just the equations for iterative autocorrelation calculation are different. By way of example, and not limitation, embodiments of the invention are described and explained using the first case (computation window moving to the right) as an example in the following descriptions. 
     The streamed data elements include an earlier (and possibly initial) streamed data element and one or more additional streamed data elements. The earlier streamed data element was accessed or received prior to the one or more additional streamed data elements. The computing system calculates one or more (p (p≥1)) components of an autocorrelation at the specified lag for the computation window from the earlier streamed element and one or more additional streamed elements. 
     The computing system accesses or receives a new streamed data element subsequent to accessing or receiving the one or more additional streamed data elements. The computing system stores the new streamed data element in the input buffer. The computing system adjusts the computation window by: removing the earlier streamed data element from the computation window and adding the new streamed data element to the computation window. 
     The computing system directly iteratively calculates one or more v (1≤v≤p) components of an autocorrelation at the specified lag for the adjusted computation window. Directly iteratively calculating v (1≤v≤p) components at the specified lag l includes: accessing the data element removed from the computation window, l data elements next to the removed data element in the computation window, the new data element added to the computation window and l data elements next to the new data element in the computation window from the input buffer and accessing the v components at the specified lag l calculated for the previous computation window; removing any contribution of the data element removed from the computation window from each of the v components at the specified lag l; mathematically adding a contribution of the new data element to each of the v components at the specified lag l. 
     The computing system indirectly iteratively calculates w=p−v components of an autocorrelation at the specified lag l for the adjusted computation window as needed. Indirectly iteratively calculating w components at the specified lag l includes indirectly iteratively calculating each of the w components at the specified lag l one by one. Indirectly iteratively calculating a component at the specified lag l includes: accessing one or more components at the specified lag l and calculating the component at the specified lag by using the one or more components at the specified lag other than the component itself (Depending on a specific algorithm used, calculating each of the w components may also need access and use the new data element added to the computation window). The one or more components at the specified lag may have been initialized, directly iteratively calculated or indirectly iteratively calculated. 
     The computing system generates an autocorrelation at the specified lag for the adjusted computation window as needed by using one or more iteratively calculated components of an autocorrelation at the specified lag for the adjusted computation window. 
     The computing system may keep accessing or receiving a new data element, storing the data element into a data buffer, adjusting the computation window, directly iteratively calculating v (1≤v≤p) components at the specified lag, indirectly iteratively calculating w=p−v components at the specified lag as needed and generating an autocorrelation at the specified lag as needed, and the computing system may repeat this process for as many times as needed. 
     Embodiments of the present invention may comprise or utilize a special purpose or general-purpose computing device including computing device hardware, such as, for example, one or more processors and system memory, as discussed in greater detail below. Embodiments within the scope of the present invention also include physical and other computing-device-readable media for carrying or storing computing-device-executable instructions and/or data structures. Such computing-device-readable media may be any available media that may be accessed by a general purpose or special purpose computing device. Computing-device-readable media that store computing-device-executable instructions are computing device storage media (devices). Computing-device-readable media that carry computing-device-executable instructions are transmission media. Thus, by way of example, and not limitation, embodiments of the invention may comprise at least two distinctly different kinds of computing-device-readable media: computing device storage media (devices) and transmission media. 
     Computing device storage media (devices) includes RAM, ROM, EEPROM, CD-ROM, solid state drives (“SSDs”) (e.g., based on RAM), Flash memory, phase-change memory (“PCM”), other types of memory, other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which may be used to store desired program code means in the form of computing-device-executable instructions or data structures and which may be accessed by a general purpose or special purpose computing device. 
     A “network” is defined as one or more data links that enable the transport of electronic data between computing devices and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computing device, the computing device properly views the connection as a transmission medium. Transmissions media may include a network and/or data links which may be used to carry desired program code means in the form of computing-device-executable instructions or data structures and which may be accessed by a general purpose or special purpose computing device. Combinations of the above should also be included within the scope of computing-device-readable media. 
     Further, upon reaching various computing device components, program code means in the form of computing-device-executable instructions or data structures may be transferred automatically from transmission media to computing device storage media (devices) (or vice versa). For example, computing-device-executable instructions or data structures received over a network or data link may be buffered in RAM within a network interface module (e.g., a “NIC”), and then eventually transferred to computing device RAM and/or to less volatile computing device storage media (devices) at a computing device. Thus, it should be understood that computing device storage media (devices) may be included in computing device components that also (or even primarily) utilize transmission media. 
     Computing-device-executable instructions comprise, for example, instructions and data which, when executed at a processor, cause a general purpose computing device or special purpose computing device to perform a certain function or group of functions. The computing device executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims. 
     Those skilled in the art will appreciate that embodiments of the present invention may be practiced in network computing environments with many types of computing device configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, supercomputers, mobile telephones, PDAs, tablets, pagers, routers, switches, and the like. Embodiments of the present invention may also be practiced in distributed system environments where local and remote computing devices, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks. In a distributed system environment, program modules may be located in both local and remote memory storage devices. 
     Embodiments of the invention may also be implemented in cloud computing environments. In this description and the following claims, “cloud computing” is defined as a model for enabling on-demand network access to a shared pool of configurable computing resources. For example, cloud computing may be employed in the marketplace to offer ubiquitous and convenient on-demand access to the shared pool of configurable computing resources. The shared pool of configurable computing resources may be rapidly provisioned via virtualization and released with low management effort or service provider interaction, and then scaled accordingly. 
     A cloud computing model may be composed of various characteristics such as, for example, on-demand self-service, broad network access, resource pooling, rapid elasticity, measured service, and so forth. A cloud computing model may also expose various service models, such as, for example, Software as a Service (“SaaS”), Platform as a Service (“PaaS”), and Infrastructure as a Service (“IaaS”). A cloud computing model may also be deployed using different deployment models such as private cloud, community cloud, public cloud, hybrid cloud, and so forth. In this description and in the claims, a “cloud computing environment” is an environment in which cloud computing is employed. 
     Within this description and the following claims, a “circular buffer” is a data structure that uses a single, fixed-size “buffer” as if it were connected end-to-end. A circular buffer may also be referred to as a cyclic buffer or a ring buffer. The “buffer” may be a commonly used circular buffer which is generally a space allocated in a local memory. The “buffer” may also be a “virtual circular buffer” which doesn&#39;t necessarily be in memory, and it may be a file on a hard disk or even multiple distributed files on multiple distributed computing devices as long as those distributed files logically connected end-to-end to form a “circular buffer”. The detailed information regarding “virtual circular buffer” may be found in a separate patent application, “Virtual Circular Buffer”, by Jizhu Lu. 
     In general, streaming data is added to an input buffer of size at least n. There are two options to deal with the case when the buffer is not filled up. One option is not to calculate an autocorrelation until the buffer is filled up, and once the buffer is filled up, the computing system calculates v (1≤v≤p) components at the specified lag for the first n data elements. The computing system may then indirectly iteratively calculates w=p−v components as needed, and then calculates an autocorrelation as needed by using one or more components at the specified lag. The other option is that when needed an autocorrelation may be incrementally calculated from the very beginning by using “Incremental autocorrelation Calculation for Big Data or Streamed Data Using Components”, a separate patent application by Jizhu Lu. Once the input buffer is filled up and v components of an autocorrelation at the specified lag for the first n input data elements are calculated, an iterative algorithm presented in this description may be used for iteratively calculating the v components of an autocorrelation and then the autocorrelation may be calculated by using the v components. As new data elements are received, v components of a new autocorrelation are calculated by reusing the components of the prior autocorrelation. 
       FIG. 1  illustrates a high-level overview of an example computing system  100  that facilitates iteratively calculating autocorrelation for streamed data. Referring to  FIG. 1 , computing system  100  comprises multiple devices connected by different networks, such as local network, internet and wireless network, etc. The multiple devices include, for example, a data analysis engine  1007 , a storage system  1011 , live data stream  1006 , and multiple distributed computing devices that may schedule data analysis tasks and/or query data analysis results, such as personal computer  1016 , hand-held devices  1017  and desktop computer  1018 , etc. Data analysis engine  1007  may comprise one or more processors, e.g., CPU  1009  and CPU  1010 , one or more system memory, e.g., system memory  1008 , autocorrelation calculation modules  192  and component calculation module  131 . Autocorrelation calculation modules  192  and component calculation module  131  will be illustrated in more details in other figures. Storage system  1011  may comprise one or more storage media, e.g., storage medium  1012  and storage medium  1014 , which may be used for hosting Big Data sets. Data sets on storage system  1011  may be accessed by data analysis engine  1007 . In general, data stream  1006  may comprise streamed data from different data sources, for example, stock quotes, audio data, video data, geospatial data, web data, mobile communication data, online gaming data, banking transaction data, sensor data, closed-captioning data, etc. To depict a few, real-time data  1000  may comprise data collected from sensor  1001 , stock  1002 , web  1003  and bank  1004 , etc. in real-time. Data analysis engine  1007  may receive data elements from data stream  1006 . It should be understood that  FIG. 100  is provided to introduce a selection of concepts in a much simplified form, for example, distributed devices  1016  and  1017  may need to go through a firewall to connect data analysis engine  1007 , and data accessed or received from data stream  1006  and/or storage system  1011  by data analysis engine  1007  may be filtered by data filters, etc. 
       FIG. 1A  illustrates an example computing system architecture  100 A that facilitates iteratively calculating autocorrelation for streamed data with all components (v=p≥1) being directly iteratively calculated.  FIG. 1A  illustrates  1007  and  1006  shown in  FIG. 1 . Referring to  FIG. 1A , computing system architecture  100 A includes component calculation module  131  and autocorrelation calculation module  192 . Component calculation module  131  may be connected to (or is part of) a network, such as, for example, a Local Area Network (“LAN”), a Wide Area Network (“WAN”), and even the Internet. Accordingly, component calculation module  131  as well as any other connected computing devices and their components, may send and receive message related data (e.g., Internet Protocol (“IP”) datagrams and other higher layer protocols that utilize IP datagrams, such as, User Datagram Protocol (“UDP”), Real-time Streaming Protocol (“RTSP”), Real-time Transport Protocol (“RTP”), Microsoft® Media Server (“MMS”), Transmission Control Protocol (“TCP”), Hypertext Transfer Protocol (“HTTP”), Simple Mail Transfer Protocol (“SMTP”), etc.) over the network. The output of component calculation module  131  will be used as the input of autocorrelation calculation module  192 , and autocorrelation calculation module  192  will generate autocorrelation  193 . 
     In general, data stream  190  may be a sequence of digitally encoded signals (e.g., packets of data or data packets) used to transmit or receive information that is in the process of being transmitted. Data stream  190  may stream data elements, such as, for example, stock quotes, audio data, video data, geospatial data, web data, mobile communication data, online gaming data, banking transaction data, sensor data, closed-captioning data, etc., to computing system architecture  100 A. Data stream  190  may stream stored data or be a live stream. 
     As streamed data elements are accessed or received, the streamed data elements may be placed in a location within circular buffer  121 . For example, data element  101  may be placed in location  121 A, data element  102  may be placed in location  121 B, data element  103  may be placed in location  121 C, data element  104  may be placed in location  121 D, data element  105  may be placed in location  121 E, data element  106  may be placed in location  121 F, data element  107  may be placed in location  121 G, data element  108  may be placed in location  121 H, and data element  109  may be placed in location  121 I. 
     Subsequently, data element  110  may be accessed or received. Data element  110  may be placed in location  121 A (overwriting data element  101 ). 
     As depicted, circular buffer  121  has nine locations,  121 A- 121 I and a computation window of eight (i.e., n=8). Data elements within the computation window may rotate as new data elements are placed within circular buffer  121 . For example, when data element  109  is placed in location  121 I, computation window  122  transits to computation window  122 A. When data element  110  is subsequently placed in location  121 A, computation window  122 A transits to computation window  122 B. 
     In general, component calculation module  131  comprises one or more (v (v=p≥1)) component calculation modules for calculating (v (v=p≥1)) components of autocorrelation for a set of n data elements in a computation window. The number v is the number of components involved in a specific iterative autocorrelation algorithm at the specified lag, which varies depending on which iterative algorithm is used. As depicted in  FIG. 1A , component calculation module  131  comprises component Cd 1  calculation module  161  and component Cd v  calculation module  162 , and there are v−2 other component calculation modules between them. Each component calculation module calculates a specific component at the specified lag. At the specified lag, v components are calculated. As depicted in  FIG. 1A , component calculation module  131  comprises component Cd 1  calculation module  161  and component Cd v  calculation module  162 . What between them may be component Cd 2  calculation module, component Cd 3  calculation module, . . . , and component Cd v-1  calculation module. Calculation module  161  comprises initialization module  132  for initializing component Cd 1  at the specified lag and iterative algorithm  133  for directly iteratively calculating component Cd 1  at the specified lag. Calculation module  162  comprises initialization module  138  for initializing component Cd v  at the specified lag and iterative algorithm  139  for directly iteratively calculating component Cd v  at the specified lag. Initialization module  132  is configured to calculate component Cd 1  for a set of n data elements in a computation window at the specified lag and initialization module  138  is configured to calculate component Cd v  for a set of n data elements in a computation window at the specified lag. Component Cd 1    141  and component Cd v    145  access or receive a full set of n data elements (i.e., 8 data elements) from a computation window as input. Initialization module  132  calculates component Cd 1  and initialization module  138  calculates component Cd v  for from the full set of n data elements at the specified lag. Thus, each data element contributes to the calculated components ranging from component Cd 1  to component Cd v  at the specified lag. Initialization module  132  may be used for an initial component Cd 1  calculation or when autocorrelation calculations are reset. Similarly, initialization module  138  may be used for an initial component Cd v  calculation or when autocorrelation calculations are reset. 
     Iterative algorithms are also configured to calculate v components at the specified lag for a set of n data elements in a computation window. Iterative algorithm  133  accesses or receives a prior component Cd 1  at the specified lag and a newly added data element from a computation window as input. Iterative algorithm  133  directly iteratively calculates a new component Cd 1  at the specified lag for a computation window from the prior component Cd 1  at the specified lag for the prior computation window, the data element removed from the computation window and the data element newly added to the computation window. Contribution removal module  133 A may remove any contribution of the removed data element from the component Cd 1  at the specified lag for the prior computation window. Contribution addition module  133 B may add a contribution of the newly added data element to the component Cd 1  at the specified lag for the prior computation window. Removing any contribution of the removed data element along with adding a contribution of the added data element may be used for calculating component Cd 1  at the specified lag for the computation window. Iterative algorithm  139  works in a similar way as iterative algorithm  133 . Iterative algorithm  139  accesses or receives a component Cd v  at the specified lag for the prior computation window and a newly added data element from a computation window as input. Iterative algorithm  139  calculates a new component Cd v  at the specified lag for the current computation window from the component Cd v  at the specified lag for the prior computation window, the data element removed from the computation window and the data element newly added to the computation window. Contribution removal module  139 A may remove any contribution of the removed data element from the prior component Cd v  at the specified lag. Contribution addition module  139 B may add a contribution of the newly added data element to the prior component Cd v  at the specified lag. Removing any contribution of the removed data element along with adding a contribution of the newly added data element may be used for calculating component Cd v  at the specified lag for the computation window. 
     Referring to  FIG. 1A , computing system architecture  100 A also includes autocorrelation calculation module  192  and autocorrelation  193 . Autocorrelation calculation module  192  may calculate the autocorrelation  193  at the specified lag using one or more iteratively calculated components at the specified lag as needed. 
       FIG. 1B  illustrates an example computing system architecture  100 B that facilitates iteratively calculating an autocorrelation for streamed data with some (v (1≤v&lt;p)) components being directly iteratively calculated and some (w (w=p−v)) components being indirectly iteratively calculated. In certain implementations, the difference between computing system architectures  100 B and  100 A may be that architecture  100 B includes a component calculation module  135 . All parts except component calculation module  135  in  100 B work in a similar way as those parts with same reference numbers in  100 A. Instead of repeating what have already been explained in the description about  100 A, only the different part is discussed here. Number v in  100 B may not be the same number v as in  100 A, because some directly iteratively calculated components in  100 A are indirectly iteratively calculated in  100 B. In  100 A, v=p≥1, but in  100 B, 1≤v&lt;p. Referring to  FIG. 1B , computing system architecture  100 B includes component calculation module  135 . The output of components calculation module  131  may be used as the input of component calculation module  135 , and the output of calculation modules  131  and  135  may be used as the input of autocorrelation calculation module  192 , and autocorrelation calculation module  192  may generate autocorrelation  193 . Component calculation module  135  generally includes w=p−v component calculation modules for indirectly iteratively calculating w components. For example, Component calculation module  135  includes calculation module  163  for indirectly iteratively calculating component Ci 1  and calculation module  164  for indirectly iteratively calculating component Ci w , and there are w−2 component calculation modules in between. Indirectly iteratively calculating w components includes indirectly iteratively calculating each of the w components one by one. Indirectly iteratively calculating a component includes accessing and using one or more components other than the component itself. The one or more components may have been initialized, directly iteratively calculated or indirectly iteratively calculated. 
       FIG. 2  illustrates a flow chart of an example method  200  for iteratively calculating autocorrelation for streamed data. Method  200  will be described with respect to the components and data of computing system architectures  100 A and  100 B. 
     Method  200  includes at a specified lag l, initializing v (1≤v≤p, p≥1) components of an autocorrelation for a computation window of a specified size n (n&gt;1) ( 202 ). For example, method  200  may calculate v components according to their definitions by accessing and using streamed data elements for a computation window of the input (circular) buffer  121 , the streamed data elements including an earlier streamed data element and one or more additional streamed data elements, the earlier streamed data element accessed or received prior to the one or more additional streamed data elements. Component calculation module  131  may access data elements  101 ,  102 ,  103 ,  104 ,  105 ,  106 ,  107  and  108  for computation window  122  of buffer  121 . Data element  101  may be the earlier (and potentially initially) streamed element and data elements  102 ,  103 ,  104 ,  105 ,  106 ,  107  and  108  may be the one or more additional elements. Data element  101  may be accessed or received prior to data elements  102 ,  103 ,  104 ,  105 ,  106 ,  107  and  108 . Initialization module  132  may initialize component Cd 1  at the specified lag l using data elements  101 - 108 , and initialization module  138  may initialize component Cd v  at the specified lag using data elements  101 - 108 . For example, at the specified lag, initialization module  132  may be used for calculating component Cd 1    141  at the specified lag from data element  101  and data elements  102 ,  103 ,  104 ,  105 ,  106 ,  107  and  108 . As depicted, component Cd 1    141  includes contribution  151 , contribution  152 , and other contributions  153 . Contribution  151  is a contribution from data element  101  to component Cd 1    141  at the specified lag. Contribution  152  is a contribution from data element  102  to component Cd 1    141  at the specified lag. Other contributions  153  are contributions from data elements  103 ,  104 ,  105 ,  106 ,  107  and  108  to component Cd 1    141  at the specified lag. Similarly, initialization module  138  may be used for calculating component Cd v    145  at the specified lag from data element  101  and data elements  102 ,  103 ,  104 ,  105 ,  106 ,  107  and  108 . As depicted, component Cd v    145  at the specified lag includes contribution  181 , contribution  182 , and other contributions  183 . Contribution  181  is a contribution from data element  101  to component Cd v    145  at the specified lag. Contribution  182  is a contribution from data element  102  to component Cd v    145  at the specified lag. Other contributions  183  are contributions from data elements  103 ,  104 ,  105 ,  106 ,  107  and  108  to component Cd v    145  at the specified lag. 
     Method  200  includes indirectly iteratively calculating each of w=p−v components at the specified lag one by one as needed by using one or more components other than the component itself ( 214 ) when v&lt;p, i.e., not all components are directly iteratively calculated. The w components are calculated only when an autocorrelation is accessed. For example, referring to  FIG. 1B  where some components are directly iteratively calculated and some are indirectly iteratively calculated, calculation module  163  may indirectly iteratively calculate Ci 1  by using one or more components other than Ci 1 , and calculation module  164  may indirectly iteratively calculate one or more components other than Ci w . The one or more components may have been initialized, directly iteratively calculated, or indirectly iteratively calculated. 
     Method  200  includes calculating an autocorrelation at the specified lag l on a needed basis. When an autocorrelation is accessed, the autocorrelation at the specified lag will be calculated by using one or more iteratively calculated components ( 215 ); else only the v components will be iteratively calculated. 
     Method  200  includes accessing or receiving a data element; storing the accessed or received data element in the buffer ( 203 ). For example, referring to  100 A and  100 B, a data element  109  may be accessed or received subsequent to accessing or receiving data elements  101 - 108 . The data element  109  may be stored in location  121 I of circular buffer  121 . 
     Method  200  includes adjusting the computation window, including: removing the least recently accessed or received data element from the computation window and adding the to-be-added data element to the computation window ( 204 ). For example, computation window  122  may be transitioned to computation window  122 A. Adjusting the computation window includes removing an existing (e.g., the least recent) data element from the computation window and adding the accessed or received data element to the computation window. For example, data element  101  is removed from computation window  122 A and data element  109  is added to computation window  122 A. 
     Method  200  includes at the specified lag l directly iteratively calculating v (1≤v≤p) components of a next autocorrelation for the adjusted computation window by using the v components for the previous computation window ( 205 ) including: accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the data element added to the computation window and l data element(s) next to the added data element in the computation window ( 206 ); accessing each of v (1≤v≤p) components ( 207 ); mathematically removing any contribution of the data element removed from the computation window from each of the v components ( 208 ); mathematically adding a contribution of the data element added to the computation window to each of the v components ( 209 ). Details are described below. 
     Directly iteratively calculating v components of a next autocorrelation at the specified lag l for the adjusted computation window includes accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the data element added to the computation window and l data element(s) next to the added data element in the computation window ( 206 ). For example, when at lag l=1, iterative algorithm  133  may access data element  101  which is removed from computation window  122 A, data element  102  which is next to the removed data element  101 , data element  109  which is added to computation window  122 A and data element  108  which is next to the added data element  109 . When at lag l=2, iterative algorithm  133  may access data element  101  which is removed from computation window  122 A, data elements  102  and  103  which are the 2 data elements next to the removed data element  101 , data element  109  which is added to computation window  122 A and data elements  107  and  108  which are the 2 data elements next to the added data element  109  . . . . Similarly, when at lag l=1, iterative algorithm  139  may access data element  101  which is removed from computation window  122 A, data element  102  which is next to the removed data element  101 , data element  109  which is added to computation window  122 A and data element  108  which is next to the added data element  109 . When at lag l=2, iterative algorithm  139  may access data element  101  which is removed from computation window  122 A, data elements  102  and  103  which are the 2 data elements next to the removed data element  101 , data element  109  which is added to computation window  122 A and data elements  107  and  108  which are the 2 data elements next to the added data element  109  . . . . 
     Directly iteratively calculating v components of a next autocorrelation at the specified lag l for the adjusted computation window includes accessing v (1≤v≤p) components of the autocorrelation at the specified lag l in the previous computation window ( 207 ). For example, when at lag l=1, iterative algorithm  133  may access component Cd 1    141  at lag l=1, and when at lag l=2, iterative algorithm  133  may access component Cd 1    141  at lag l=2 Similarly, when at lag l=1, iterative algorithm  139  may access component Cd v    145  at lag l=1, and when at lag 1=2, iterative algorithm  139  may access component Cd v    145  at lag l=2 . . . . 
     Directly iteratively calculating v components of a next autocorrelation at the specified lag l for the adjusted computation window includes mathematically removing any contribution of the data element removed from the computation window from each of the v components ( 208 ). For example, directly iteratively calculating component Cd 1    143  at lag l=1 may include contribution removal module  133 A mathematically removing contribution  151  (i.e., the contribution from data element  101 ) from component Cd 1    141  at lag l=1, and directly iteratively calculating component Cd 1    143  at lag l=2 may include contribution removal module  133 A mathematically removing contribution  151  (i.e., the contribution from data element  101 ) from component Cd 1    141  at lag l=2 Similarly, directly iteratively calculating component Cd v    147  at lag l=1 may include contribution removal module  139 A mathematically removing contribution  181  (i.e., the contribution from data element  101 ) from component Cd v    145  at lag l=1, and directly iteratively calculating component Cd v    147  at lag l=2 may include contribution removal module  139 A mathematically removing contribution  181  (i.e., the contribution from data element  101 ) from component Cd v    145  at lag l=2 . . . . 
     Directly iteratively calculating v components of a next autocorrelation at the specified lag l for the adjusted computation window includes mathematically adding a contribution of the new streamed data element to each of the v components ( 209 ). For example, directly iteratively calculating component Cd 1    143  at lag l=1 may include contribution addition module  133 B mathematically adding contribution  154  to component  141  at lag l=1, and directly iteratively calculating component Cd 1    143  at lag l=2 may include contribution addition module  133 B mathematically adding contribution  154  to component  141  at lag l=2 Similarly, directly iteratively calculating component Cd v    147  at lag l=1 may include contribution addition module  139 B mathematically adding contribution  184  to component Cd v    145  at lag l=1, and directly iteratively calculating component Cd v    147  at lag l=2 may include contribution addition module  139 B mathematically adding contribution  184  to component Cd v    145  at lag l=2 Contribution  154  and  184  are contributions from data element  109 . 
     As depicted in  FIGS. 1A and 1B , at the specified lag l, component Cd 1    143  includes contribution  152  (a contribution from data element  102 ), other contributions  153  (contributions from data elements  103 - 108 ), and contribution  154  (a contribution from data element  109 ). Similarly, component Cd v    147  includes contribution  182  (a contribution from data element  102 ), other contributions  183  (contributions from data elements  103 - 108 ), and contribution  184  (a contribution from data element  109 ). 
     Method  200  includes indirectly iteratively calculating each of w=p−v components at the specified lag l one by one as needed by using one or more components other than the component itself ( 214 ) when v&lt;p, i.e., not all components are directly iteratively calculated. The w components are calculated only when an autocorrelation is accessed. For example, referring to  FIG. 1B  where some components are directly iteratively calculated and some are indirectly iteratively calculated, calculation module  163  may indirectly iteratively calculate Ci 1  by using one or more components other than Ci 1 , and calculation module  164  may indirectly iteratively calculate Ci w  by using one or more components other than Ci w . The one or more components may have been initialized, directly iteratively calculated, or indirectly iteratively calculated. 
     Method  200  calculates autocorrelation on a needed basis. When an autocorrelation is accessed, the autocorrelation will be calculated by using one or more iteratively calculated components; else only the v components will be directly iteratively calculated. When an autocorrelation is accessed, method  200  includes indirectly iteratively calculating w components at the specified lag l as needed ( 214 ). For example, in architecture  100 A, autocorrelation calculation module  192  may calculate autocorrelation  193  at the specified lag. In architecture  100 B, calculation module  163  may indirectly iteratively calculate Ci 1  by using one or more components other than Ci 1 , and calculation module  164  may indirectly iteratively calculate Ci w  by using one or more components other than Ci w , . . . , and autocorrelation calculation module  192  may calculate autocorrelation  193  at the specified lag. Once autocorrelation at the specified lag has been calculated, method  200  includes receiving next streamed data element. 
       203 - 209  may be repeated as additional streamed data elements are accessed or received.  214 - 215  may be repeated as needed. For example, subsequent to accessing or receiving data element  109  and calculating component Cd 1    143  and component Cd v    147  at the specified lag, data element  110  may be accessed or received ( 203 ). Once a new data is accessed or received, method  200  includes adjusting the computation window by removing the least recently accessed or received data element from the computation window and adding the to-be-added data element to the computation window ( 204 ). For example, data element  110  may be placed in location  121 A overwriting data element  101 . Computation window  122 A may be transitioned to computation window  122 B by removing data element  102  and adding data element  110 . 
     Method  200  includes at the specified lag l, directly iteratively calculating v components of a next autocorrelation for the adjusted computation window by using the v components for the previous computation window ( 205 ), including accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the new data element added to the computation window and l data elements next to the added data element in the computation window ( 206 ) and accessing the v components ( 207 ) and mathematically removing any contribution of the data element removed from the computation window from each of the v components ( 208 ) and mathematically adding a contribution of the data element added to the computation window to each of the v components ( 209 ). For example referring to  100 A and  100 B, at a specified lag l, e.g. l=1, iterative algorithm  133  may be used for directly iteratively calculating component Cd 1    144  at lag 1 (for computation window  122 B) by using component Cd 1    143  at lag 1 (for computation window  122 A). Iterative algorithm  133  may access data element  102  which is removed from computation window  122 B, data element  103  which is next to removed data element  102 , data element  110  which is added to computation window  122 B and data element  109  which is next to added data element  110 . Iterative algorithm  133  may access component Cd 1    143  at lag l=1. Directly iteratively calculating component Cd 1    144  at lag l=1 may include contribution removal module  133 A mathematically removing contribution  152  (i.e., the contribution from data element  102 ) from component Cd 1    143  at lag l=1. Directly iteratively calculating component Cd 1    144  at lag l=1 may include contribution addition module  133 B mathematically adding contribution  155  to component Cd 1    143  at lag l=1. Contribution  155  is a contribution from data element  110 . Similarly, at a specified lag l, e.g. l=1, iterative algorithm  139  may be used for directly iteratively calculating component Cd v    148  at lag l=1 (for computation window  122 B) by using component Cd v    147  at lag l=1 (for computation window  122 A). Iterative algorithm  139  may access data element  102  which is removed from computation window  122 B, data element  103  which is next to removed data element  102 , data element  110  which is added to computation window  122 B and data element  109  which is next to added data element  110 . Iterative algorithm  139  may access component Cd v    147  at lag l=1. Directly iteratively calculating component Cd v    148  at lag l=1 may include contribution removal module  139 A mathematically removing contribution  182  (i.e., the contribution from data element  102 ) from component Cd v    147  at lag l=1. Directly iteratively calculating component Cd v    148  may include contribution addition module  139 B mathematically adding contribution  185  to component Cd v    147  at lag l=1. Contribution  185  is a contribution from data element  110 . 
     As depicted, at the specified lag l, component Cd 1    144  includes other contributions  153  (contributions for data elements  103 - 108 ), contribution  154  (a contribution from data element  109 ), and contribution  155  (a contribution from data element  110 ), and component Cd v    148  includes other contributions  183  (contributions for data elements  103 - 108 ), contribution  184  (a contribution from data element  109 ), and contribution  185  (a contribution from data element  110 ). 
     Method  200  includes indirectly iteratively calculating w components and autocorrelations at the specified lag as needed. 
     Method  200  includes indirectly iteratively calculating w components and autocorrelations at the specified lag as needed, i.e., only when an autocorrelation is accessed. If no autocorrelation is accessed, method  200  includes continuing to access or receive next data element and starts calculation for next computation window ( 203 ). If an autocorrelation is accessed, method  200  includes indirectly iteratively calculating w components at the specified lag ( 214 ), calculating autocorrelation at the specified lag using one or more initialized or iteratively calculated components at the specified lag ( 215 ). 
     When a next new streaming data element is accessed or received, component Cd 1    144  may be used for directly iteratively calculating a next component Cd 1  and component Cd v    148  may be used for directly iteratively calculating a next component Cd v . 
       FIG. 3A  illustrates data elements that are removed from and added to computation window  300 A for iteratively calculating an autocorrelation on streamed data. Computation window  300 A moves to the right side direction. Referring to  FIG. 3A , an existing data element is always removed from the left end and a new data element is always added to the right end of computation window  300 A. 
       FIG. 3B  illustrates data elements that are accessed from computation window  300 A for iteratively calculating an autocorrelation on streamed data. For computation window  300 A, the first n data elements are accessed for directly iteratively calculating one or more (v (1≤v≤p)) components at the specified lag for the first computation window and then indirectly iteratively calculating w=p−v components as needed and then calculating an autocorrelation as needed. As time progresses, a least recent data element, e.g., (m+1) th  data element, is removed and a new data element, e.g., (m+1) th  data element, is added to computation window  300 A. One or more (v (1≤v≤p)) components at the specified lag for the adjusted computation window are then directly iteratively calculated by using v components calculated for the first computation window. When lag l=1, 4 data elements are accessed which includes the data element removed, 1 data element next to the data element removed, the data element added and 1 data element next to the data element added. When lag l=2, 6 data elements are accessed which includes the data element removed, 2 data elements next to the data element removed, the data element added and 2 data elements next to the data element added. And at the specified lag l, 2*(l+1) data elements are accessed for directly iteratively calculating v components at lag l. The 2*(l+1) data elements includes the data element removed, l data elements next to the data element removed, the data element added and l data elements next to the data element added. Then indirectly iteratively calculating w=p−v components at the specified lag as needed and then calculating an autocorrelation using one or more iteratively calculated components at the specified lag as needed. Then, computation window  300 A is adjusted again by removing a least recent data element and adding a new data element. For a given iterative algorithm, v is a constant, so the number of operations for directly iteratively calculating v components is a constant, and the number of operations for indirectly iteratively calculating w=p−v components is also a constant. So for a specified lag l, the computation workload is reduced. The larger the n, the more substantial the reduction in computation workload. 
       FIG. 3C  illustrates data elements that are removed from and added to, one of the two computation windows, computation window  300 B for iteratively calculating an autocorrelation on streamed data. Computation window  300 B moves to the left side direction. Referring to  FIG. 3C , a recent data element is always removed from the right end and a least recent data element is always added to the left end of computation window  300 B. 
       FIG. 3D  illustrates data elements that are accessed from, one of the two computation windows, computation window  300 B for iteratively calculating an autocorrelation on streamed data. For computation window  300 B, the first n data elements are accessed for directly iteratively calculating one or more (v (1≤v≤p)) components at the specified lag for the first computation window and then indirectly iteratively calculating w=p−v components and calculating an autocorrelation as needed. As time progresses, a most recent data element, e.g., (m+n) th  data element, is removed and a least recent data element, e.g., m th  data element, is added to computation window  300 B. One or more (v (1≤v≤p)) components at the specified lag for the adjusted computation window are then directly iteratively calculated by using v components calculated for the first computation window. When lag l=1, 4 data elements are accessed which includes the data element removed, 1 data element next to the data element removed, the data element added and 1 data element next to the data element added. When lag l=2, 6 data elements are accessed which includes the data element removed, 2 data elements next to the data element removed, the data element added and 2 data elements next to the data element added . . . . And, 2*(l+1) data elements are accessed for directly iteratively calculating v components at lag l. The 2*(l+1) data elements includes the data element removed, l data elements next to the data element removed, the data element added and l data elements next to the data element added. Then, indirectly iteratively calculating w=p−v components at the specified lag as needed and then calculating an autocorrelation using one or more iteratively calculated components at the specified lag as needed. Then, computation window  300 B is adjusted again by removing a most recent data element and adding a least recent data element . . . . For a given iterative algorithm, v is a constant, so the number of operations for directly iteratively calculating v components is a constant, and the number of operations for indirectly iteratively calculating w=p−v components is also a constant. So for a specified lag, the computation workload is reduced. The larger the n, the more substantial the reduction in computation workload. 
       FIG. 4A  illustrates the definition of autocorrelation. Suppose a computation window X=(x m+1 , x m+2 , . . . , x m+n ) is a window of stream data which contains the data elements to be involved in autocorrelation calculation. The computation window may move to either right or left direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a data is added to the right side of the computation window and a data is removed from the left side of the computation window. When recalculating autocorrelation on previous stream data, the computation window may move to the left. In this case, a data is added to the left side of the computation window and a data is removed from the right side of the computation window. The equations for calculating one or more (p (p≥1)) components for those two cases are different. To distinguish them, define the adjusted computation window as X I  for the former case and X II  for the latter case. Equation  401  is a traditional equation for calculating a sum S k  of all the data elements in X. Equation  402  is a traditional equation for calculating a mean  x   k  of all the data elements in X. Equation  403  is a traditional equation for calculating an autocorrelation ρ (k,l)  with a lag l of all the data elements in a computation window of size n. Equation  404  is a traditional equation for calculating a sum S I   k+1  of all the data elements in the adjusted computation window X I . Equation  405  is a traditional equation for calculating a mean  x   I   k+1  of all the data elements in the adjusted computation window X I . Equation  406  is a traditional equation for calculating an autocorrelation ρ I   (k+1,l)  of all the data elements in the adjusted computation window X I . As stated earlier, when the computation window moves to the left, the adjusted computation window is defined as X II . Equation  407  is a traditional equation for calculating a sum S II   k+1  of all the data elements in the adjusted computation window X II . Equation  408  is a traditional equation for calculating a mean  x   II   k+1  of all the data elements in the adjusted computation window X II . Equation  409  is a traditional equation for calculating an autocorrelation ρ II   (k+1,l)  of all the data elements in the adjusted computation window X II . 
       FIG. 4B  illustrates some example components of an autocorrelation and basic iterative component calculation equations. A component of an autocorrelation is a quantity or expression appearing in the autocorrelation&#39;s definition equation or any transforms of the definition equation. The following are some example components of an autocorrelation.
 
 S   k =Σ 1   n   x   i  
 
   x     k =1/ nΣ   1   n   x   i  
 
 SS   k =Σ 1   n   x   i   2  
 
 SS   k =Σ 1   n   x   i   2  
 
 SX   k =Σ 1   n ( x   1   − x     k ) 2  
 
cov X   (k,l) =Σ 1+l   n ( x   i   − x     k )( x   i-l   − x     k ) ( l  is the lag)
 
An autocorrelation may be calculated based on one or more (p (p≥1)) components or combinations of them, so there are multiple algorithms supporting iterative autocorrelation calculation. To illustrate how to use components to iteratively calculate autocorrelation, three different iterative autocorrelation calculation algorithms are given as examples. A new iteration of calculation is started each time any component of an autocorrelation is recalculated due to a data change in the computation window which causes a computation window to change to a new computation window (e.g.,  122 → 122 A→ 122 B). A sum or a mean is the basic component to be used for calculating an autocorrelation. The equations for iteratively calculating a sum or a mean are basic iterative component equations which will be used by all example iterative autocorrelation calculation algorithms, therefore they are presented in  FIG. 4B  instead of each example iterative autocorrelation calculation algorithm. As stated earlier, when the computation window moves to the right, the adjusted computation window is defined as X I . Equation  410  is an equation for directly iteratively calculating a sum S I   k+1  of all the data elements in the adjusted computation window X I  by mathematically removing any contribution of the removed data element from the previous sum and mathematically adding a contribution of the added data element to the previous sum. Equation  411  is an equation for directly iteratively calculating a mean  x   I   k+1  of all the data elements in the adjusted computation window X I  by mathematically removing any contribution of the removed data element from the previous mean and mathematically adding a contribution of the added data element to the previous mean. As stated earlier, when the computation window moves to the left, the adjusted computation window is defined as X II . Equation  412  is an equation for iteratively calculating a sum S II   k+1  of all the data elements in the adjusted computation window X″. Equation  413  is an equation for iteratively calculating a mean  x   II   k+1  of all the data elements in the adjusted computation window X II . Either a sum or a mean will be used in all three iterative autocorrelation calculation algorithms described below.
 
       FIG. 4C  illustrates the first example iterative autocorrelation calculation algorithm (iterative algorithm 1). As depicted in  FIG. 4C , when a computation window moves to the right, iterative algorithm 1 comprises iterative calculation of components S I   k+1  or  x   I   k+1 , SS I   k+1 , SX I   k+1 , and covX I   (k+1,l) , and an autocorrelation ρ I   (k+1,l)  may be calculated by using components SX I   k+1  and covX I   (k+1,l)  once they are calculated. Equation  410  may be used for directly iteratively calculating component S I   k+1  if component S k  is available. Equation  411  may be used for directly iteratively calculating component  x   I   k+1  if component  x   k  is available. Equation  414  is a traditional equation for calculating component SS k  in the computation window X. Equation  415  is a traditional equation for calculating component SS I   k+1  in the adjusted computation window X I . Equation  416  may be used for directly iteratively calculating component SS I   k+1  in the adjusted computation window X I  if component SS k  is available. Equation  417  is a traditional equation for calculating component SX k  in the computation window X. Equation  418  is a traditional equation for calculating component SX I   k+1  in the adjusted computation window X I . Equations  419  may be used for indirectly iteratively calculating component SX I   k+1  in the adjusted computation window X I  if components S I   k+1  or  x   I   k+1  and SS I   k+1  are available. Equations  419  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  420  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  421  is a traditional equation for calculating component covX I   (k+1,l)  in the adjusted computation window X I . Equations  422  may be used for directly iteratively calculating component covX I   (k+1,l)  in the adjusted computation window X I  if components covX (k,l) , SS I   k+1 , S k  or  x   k  and S I   k+1  or  x   I   k+1  are available. Equations  422  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  423  may be used for indirectly calculating the autocorrelation ρ I   (k+1,l)  at a specified lag l for the adjusted computation window X I  once components covX I   (k+1,l)  and SX I   k+1  are calculated. As depicted in  FIG. 4C  Cont&#39;d, when a computation window moves to the left, iterative algorithm 1 comprises iterative calculation of components S II   k+1  or  x   k+1 , SS II   k+1 , SX II   k+1 , and covX II   (k+1,l) , and an autocorrelation ρ II   (k+1,l)  may be directly calculated by using components SX II   k+1  and covX II   (k+1,l)  once they are calculated. Equation  412  may be used for directly iteratively calculating component S II   k+1  if component S k  is available. Equation  413  may be used for directly iteratively calculating component  x   II   k+1  if component  x   k  is available. Equation  424  is a traditional equation for calculating component SS k  in the computation window X. Equation  425  is a traditional equation for calculating component SS II   k+1  in the adjusted computation window Equation  426  may be used for directly iteratively calculating component SS II   k+1  in the adjusted computation window if component SS k  is available. Equation  427  is a traditional equation for calculating component SX k  in the computation window X. Equation  428  is a traditional equation for calculating component SX II   k+1  in the adjusted computation window Equations  429  may be used for indirectly iteratively calculating component SX II   k+1  in the adjusted computation window X II  if components S II   k+1  and/or  x   II   k+1  and SS II   k+1  are available. Equations  429  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  430  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  431  is a traditional equation for calculating component covX II   (k+1,l)  in the adjusted computation window Equations  432  may be used for directly iteratively calculating component covX II   (k+1,l)  in the adjusted computation window if components covX (k,l) , SS II   k+1 , S k  or  x   k  and S II   k+1  or  x   II   k+1  are available. Equations  432  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  433  may be used for indirectly calculating the autocorrelation ρ II   (k+1,l)  at a specified lag l for the adjusted computation window once components covX II   (k+1,l)  and SX II   k+1  are calculated. 
       FIG. 4D  illustrates the second example iterative autocorrelation calculation algorithm (iterative algorithm 2). As depicted in  FIG. 4D , when a computation window moves to the right, iterative algorithm 2 comprises iterative calculation of components S I   k+1  or  x   I   k+1 , SX I   k+1 , and covX I   (k+1,l) , and an autocorrelation may be calculated by using components SX I   k+1  and covX I   (k+1,l) , once they are calculated. Equation  410  may be used for directly iteratively calculating component S I   k+1  if component S k  is available. Equation  411  may be used for directly iteratively calculating component  x   I   k+1  if component  x   k  is available. Equation  434  is a traditional equation for calculating component SX k  in the computation window X. Equation  435  is a traditional equation for calculating component SX I   k+1  in the adjusted computation window X I . Equations  436  may be used for directly iteratively calculating component SX I   k+1  in the adjusted computation window X I  if components SX k , S I   k+1  and/or X I   k+1  are available. Equations  436  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  437  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  438  is a traditional equation for calculating component covX I   (k+1,l)  in the adjusted computation window X I . Equations  439  may be used for directly iteratively calculating component covX I   (k+1,l)  in the adjusted computation window X I  if components covX (k,l) , S k  or  x   k  and S I   k+1  or  x   k+1  are available. Equations  439  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  440  may be used for indirectly iteratively calculating the autocorrelation ρ I   (k+1,l)  for the adjusted computation window X I  using components covX I   (k+1,l)  and SX I   k+1  once they are calculated. As depicted in  FIG. 4D  Cont&#39;d, when a computation window moves to the left, iterative algorithm 2 comprises iterative calculation of components S II   k+1  or  x   II   k+1 , SX II   k+1 , and covX II   (k+1,l) , and an autocorrelation ρ II   (k+1,1)  may be calculated by using components SX II   k+1  and covX II   (k+1,l)  once they are calculated. Equation  412  may be used for directly iteratively calculating component S II   k+1  if component S k  is available. Equation  413  may be used for directly iteratively calculating component  x   II   k+1  if component  x   k  is available. Equation  441  is a traditional equation for calculating SX k  in the computation window X. Equation  442  is a traditional equation for calculating component SX II   k+1  in the adjusted computation window Equations  443  may be used for directly iteratively calculating component SX II   k+1  in the adjusted computation window if components SX k , S ii   k+1  and/or  x   II   k+1  are available. Equations  443  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  444  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  445  is a traditional equation for calculating component covX II   (k+1,l)  in the adjusted computation window Equations  446  may be used for directly iteratively calculating component covX II   (k+1,l)  in the adjusted computation window if components covX (k,l) , S k  or  x   k  and S II   k+1  or X II   k+1  are available. Equations  446  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  447  may be used for calculating the autocorrelation ρ II   (k+1,l)  for the adjusted computation window X II  using components covX I   (k+1,l)  and SX II   k+1  once they are calculated. 
       FIG. 4E  illustrates the third example iterative autocorrelation calculation algorithm (iterative algorithm 3). As depicted in  FIG. 4E , iterative algorithm 3 comprises iterative calculation of components S I   k+1  or  x   I   k+1 , SX I   k+1 , and covX I   (k+1,l) , and an autocorrelation may be calculated by using components SX I   k+1  and covX I   (k+1,l) , once they are calculated. Equation  410  may be used for directly iteratively calculating component S I   k+1  if component S k  is available. Equation  411  may be used for directly iteratively calculating component  x   I   k+1  if component  x   k  is available. Equation  448  is a traditional equation for calculating component SX k  in the computation window X. Equation  449  is a traditional equation for calculating component SX I   k+1  in the adjusted computation window X I . Equations  450  are equations that may be used for directly iteratively calculating component SX I   k+1  in the adjusted computation window X I  if components SX k , S I   k+1  and/or  x   I   k+1  are available. Equations  450  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  451  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  452  is a traditional equation for calculating component covX I   (k+1,l)  in the adjusted computation window X I . Equations  453  are equations that may be used for directly iteratively calculating component covX I   (k+1,l)  in the adjusted computation window X I  if components covX (k,l) , S k  or  x   k  and S I   k+1  or  x   I   k+1  are available. Equations  453  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  454  is an equation that may be used for calculating the autocorrelation ρ I   (k+1,l)  for the adjusted computation window X I  using components covX I   (k+1,l)  and SX I   k+1  once they are calculated. As depicted in  FIG. 4E  Cont&#39;d, when a computation window moves to the left, iterative algorithm 3 comprises iterative calculation of components S II   k+1  or  x   II   k+1 , SX II   k+1 , and covX II   (k+1,l) , and an autocorrelation may be calculated by using components SX II   k+1  and covX II   (k+1,l) , once they are calculated. Equation  412  may be used for directly iteratively calculating component S II   k+1  if component S k  is available. Equation  413  may be used for directly iteratively calculating component  x   II   k+1 , if component  x   k  is available. Equation  455  is a traditional equation for calculating component SX k  in the computation window X. Equation  456  is a traditional equation for calculating component SX II   k+1  in the adjusted computation window Equations  457  are equations that may be used for directly iteratively calculating component SX II   k+1  in the adjusted computation window if components SX k , S k  and/or  x   k , and S II   k+1  and/or  x   II   k+1  are available. Equations  457  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  458  is a traditional equation for calculating component covX (k,l)  in the computation window X. Equation  459  is a traditional equation for calculating component covX II   (k+1,l)  in the adjusted computation window Equations  460  are equations that may be used for directly iteratively calculating component covX II   (k+1,l)  in the adjusted computation window if components covX (k,l) , S k  or  x   k  and S II   k+1  or X II   k+1  are available. Equations  460  comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation  461  is an equation that may be used for calculating the autocorrelation ρ II (k+ 1 ,l) for the adjusted computation window X II  by using components covX II   (k+1,l)  and SX II   k+1  once they are calculated. 
     To demonstrate iterative autocorrelation calculation algorithms and their comparison against traditional algorithms, three examples are given below. Three computation windows of data elements are used. For traditional algorithms, the calculations for all three computation windows are exactly the same. For iterative algorithms, initialization of one or more components is performed for the first computation window, and iterative calculations are performed for the second and third computation windows. 
       FIG. 5A  illustrates an example of calculating an autocorrelation at lag=1 for Data Stream  501  using traditional algorithms. The example assumes the computation window moves from left to right. Computation window size  502  ( n ) is 4. Computation window  503  includes the first four data elements in Data Stream  501 . There are a total of 2 divisions, 7 multiplications, 8 additions, 10 subtractions when calculating the autocorrelation at lag=1 on 4 data elements without any optimization. 
     The same equations may be used for calculating the autocorrelation at lag=1 for computation window  504  as shown in  FIG. 5A  Cont&#39;d 1 and the autocorrelation at lag=1 for computation window  505  as shown in  FIG. 5A  Cont&#39;d 2 respectively. Each of these calculations also includes a total of 2 divisions, 7 multiplications, 8 additions, 10 subtractions when calculating the autocorrelation on 4 data elements without any optimization. Traditional algorithms for calculating autocorrelation on n data elements at a specified lag l typically take a total of 2 divisions, 2n−l multiplications, 3n−(l+3) additions, and 3n−2l subtractions without any optimization. 
       FIG. 5B  illustrates an example of calculating an autocorrelation at lag=1 using iterative algorithm 1. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations for computation window  503  uses traditional equations to calculate the initial values of components  x   1 , SS 1 , SX 1 , and covX (1,1) . The autocorrelation of computation window  503  is then calculated by using those components. Equation  402  is used for calculating component  x   1 . Equation  414  is used for calculating component SS 1 . Equation  417  is used for calculating component SX 1 . Equation  420  is used for calculating component covX (1,1) . Equation  423  is used for calculating component ρ (1,1) . The autocorrelation ρ (1,1)  for computation window  503  at lag=1 is calculated by using covX (1,1)  and SX 1 . There is a total of 2 divisions, 9 multiplications, 8 additions and 7 subtractions when calculating the autocorrelation at lag=1 on a computation window of size 4. 
     However, starting from computation window  504 , the components of the autocorrelation at lag=1 for computation window  504  may be iteratively calculated from the components of the autocorrelation for computation window  503 . For example, equation  411  may be used for directly iteratively calculating the component  x   2  by using  x   1  previously calculated for computation window  503 . Equation  416  may be used for directly iteratively calculating the component SS 2  by using SS 1  previously calculated for computation window  503 . Equation  419  may be used for indirectly iteratively calculating the component SX 2  by using SS 2  and  x   2 . Equation  422  may be used for directly iteratively calculating the component covX (2,1)  (lag=1) by using  x   1  and covX (1,1)  (lag=1) previously calculated for computation window  503  and  x   2 . Equation  423  may be used for indirectly iteratively calculating the autocorrelation ρ (2,1)  at lag=1 by using covX (2,1)  and SX 2 . There is a total of 2 divisions, 10 multiplications, 8 additions and 7 subtractions when calculating the autocorrelation at lag=1 on a computation window of size 4. 
     The same equations may also be used for iteratively calculating the components of autocorrelation at lag=1 for computation window  505  from the components of autocorrelation for computation window  504 . There is also a total of 2 divisions, 10 multiplications, 8 additions and 7 subtractions when iteratively calculating the autocorrelation at lag=1. As such, since the number of operations performed by the iterative autocorrelation calculation algorithm is fixed and not changing with the computation window size, starting from computation window  504 , the number of operations used when iteratively calculating the autocorrelation is (potentially substantially) less than when using traditional equations for computation windows with a large size. 
       FIG. 5C  illustrates an example of calculating autocorrelation at lag=1 using iterative algorithm 2. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations of calculating an autocorrelation for computation window  503  uses traditional equations to calculate the initial values of components  x   1 , SX 1 , and covX (1,1) . For example, equation  402  may be used for calculating  x   1 . Equation  434  may be used for calculating SX 1 . Equation  437  may be used for calculating covX (1,1) . The autocorrelation of computation window  503  ρ (1,1)  (lag=1) is then calculated by using those components through equation  440 . There is a total of 2 divisions, 7 multiplications, 8 additions and 10 subtractions when calculating the autocorrelation at lag=1 on a computation window of size 4. 
     However, starting from computation window  504 , the components of the autocorrelation at lag=1 for computation window  504  may be iteratively calculated from the components of the autocorrelation for computation window  503 . For example, equation  411  may be used for directly iteratively calculating the component  x   2  by using  x   1  previously calculated for computation window  503 . Equation  436  may be used for directly iteratively calculating the component SX 2  by using SX 1  and  x   2 . Equation  439  may be used for directly iteratively calculating the component covX (2,1)  (lag=1) by using  x   1 ,  x   2  and covX (1,1) . Equation  440  may then be used for indirectly iteratively calculating the autocorrelations ρ (2,1)  (lag=1) by using covX (2,1)  and SX 2 . There is a total of 2 divisions, 7 multiplications, 10 additions and 7 subtractions when calculating the autocorrelation at lag l=1 on a computation window of size 4. 
     The same equations may also be used for iteratively calculating the components of autocorrelation for computation window  505  from the components of autocorrelation for computation window  504 . There is a total of 2 divisions, 7 multiplications, 10 additions and 7 subtractions when iteratively calculating the autocorrelation at lag=1. As such, since the number of operations performed by the iterative autocorrelation calculation algorithm is fixed and not changing with the computation window size, starting from computation window  504 , the number of operations used when iteratively calculating the autocorrelation is (potentially substantially) less than when using traditional equations for computation windows with a large size. 
       FIG. 5D  illustrates an example of calculating an autocorrelation at lag=1 using iterative algorithm 3. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations for computation window  503  uses traditional equations to calculate the initial values of components  x   1 , SX 1 , and covX (1,1) . For example, equation  402  may be used for calculating  x   1 . Equation  448  may be used for calculating SX 1 . Equation  451  may be used for calculating covX (1,1) . Equation  454  may then be used for calculating the autocorrelation of computation window  503  ρ (1,1)  (lag=1) by using covX (1,1)  and SX 1 . There is a total of 2 divisions, 7 multiplications, 8 additions and 10 subtractions when calculating the autocorrelation at lag=1 on a computation window of size 4. 
     However, for window  504 , the components of the autocorrelation at lag=1 for computation window  504  may be iteratively calculated from the components of the autocorrelation for computation window  503 . For example, equation  411  may be used for directly iteratively calculating the component  x   2  by using  x   1  previously calculated for computation window  503 . Equation  450  may be used for directly iteratively calculating the component SX 2  by using SX 1 ,  x   1  and  x   2 . Equation  453  may be used for directly iteratively calculating the component covX (2,1)  by using  x   1 ,  x   2 , and covX (1,1) . Equation  454  may then be used for indirectly iteratively calculating the autocorrelation ρ (2,1)  (lag=1) by using covX (2,1)  and SX 2 . There is a total of 2 divisions, 7 multiplications, 9 additions and 8 subtractions when calculating the autocorrelation. 
     The same equations may also be used for iteratively calculating the components of autocorrelation for computation window  505  from the components of autocorrelation for computation window  504 . There is also a total of 2 divisions, 7 multiplications, 9 additions and 8 subtractions when iteratively calculating the autocorrelation at lag=1. As such, since the number of operations performed by the iterative autocorrelation calculation algorithm is fixed and not changing with the computation window size, starting from since the number of operations performed by the iterative autocorrelation calculation algorithm is fixed and not changing with the computation window size, starting from computation window  504 , the number of operations used when iteratively calculating the autocorrelation is (potentially substantially) less than when using traditional equations for computation windows with a large size. 
     In the three examples above, a mean is used for the iterative autocorrelation calculation. If a sum instead of a mean is used, autocorrelation may also be iteratively calculated though the numbers of operations are different. Also, the computation window moves from left to right in the above three examples. It works in a similar way when the computation window moves from right to left but just use a different set of equations. 
       FIG. 6  illustrates computational loads for traditional autocorrelation algorithm and iterative autocorrelation algorithms at lag l=1 for n=4 for computation window  505 . As depicted, the computation loads are roughly at same level for traditional algorithms and iterative algorithms for computation windows of size 4. 
       FIG. 7  illustrates computational loads for traditional algorithms and iterative algorithms at lag  l =1 for n=1,000,000 for any computation window other than the first computation window. As depicted, there are substantially fewer multiplication operations, fewer addition operations, and fewer subtraction operations using any one of the iterative algorithms. 
     The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope.