Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computing-system-implemented method for reducing redundant data access or retrieval from storage media when generating an autocorrelation at a specified lag for an adjusted computation window, the method comprising: initializing, by a computing-device-based computing system, a lag l (l>0), a computation window size counter n (n>2*l+1), and two or more components of an autocorrelation at lag l for a pre-adjusted computation window, wherein the pre-adjusted computation window contains n data elements of a data set which is stored in at least one of one or more storage media in the computing-device-based computing system; accessing or receiving, by the computing-device-based computing system, a data element to be removed from the pre-adjusted computation window; adjusting, by the computing-device-based computing system, the pre-adjusted computation window by: removing the accessed or received data element from the pre-adjusted computation window; and adjusting the computation window size counter; decrementally deriving, by the computing-device-based computing system, two or more components of an autocorrelation at lag l for the adjusted computation window based at least in part on the two or more components of the autocorrelation at lag l initialized or derived for the pre-adjusted computation window without accessing and using all data elements in the adjusted computation window from at least one of the one or more storage media to reduce data access latency and reduce operations performed by the computing-device-based computing system thereby saving computing resources, increasing calculation efficiency, and reducing the computing-device-based computing system's power consumption; and generating, by the computing-device-based computing system, an autocorrelation at lag l for the adjusted computation window based on one or more of the decrementally derived components.
This invention relates to optimizing autocorrelation calculations in computing systems by reducing redundant data access from storage media. The problem addressed is the computational inefficiency and latency associated with recalculating autocorrelation from scratch when a data window is adjusted, particularly in systems where storage access is costly in terms of time and resources. The method initializes a lag value (l>0), a computation window size counter (n>2l+1), and two or more components of an autocorrelation for a pre-adjusted window containing n data elements stored in system memory. When a data element is removed from the window, the system adjusts the window by removing the element and updating the counter. Instead of re-accessing all data elements from storage, the system incrementally derives updated autocorrelation components based on the previous autocorrelation values, reducing the need for full data retrieval. This approach minimizes storage access latency, computational operations, and power consumption while improving calculation efficiency. The final step generates the autocorrelation for the adjusted window using the derived components. The technique is particularly useful in real-time or resource-constrained environments where frequent window adjustments are required.
2. The computing-system-implemented method of claim 1 , wherein the generating an autocorrelation further comprises indirectly decrementally deriving, by the computing-device-based computing system, one or more components of the autocorrelation at lag l for the adjusted computation window, wherein the indirectly decrementally deriving the one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
This invention relates to computing systems that analyze time-series data using autocorrelation techniques. The problem addressed is the computational inefficiency of traditional autocorrelation calculations, particularly when processing large datasets or in real-time applications where performance is critical. The method involves generating an autocorrelation function for a time-series dataset within a specified computation window. The key innovation lies in the way the autocorrelation components are derived. Instead of recalculating each component from scratch, the system indirectly and decrementally computes each component based on previously calculated components. This means that for a given lag l, the autocorrelation at that lag is determined by leveraging intermediate results from other components rather than performing full recalculations. This approach reduces computational overhead by reusing partial results, thereby improving efficiency without sacrificing accuracy. The method is particularly useful in applications where time-series data is processed in real-time or where computational resources are limited. By minimizing redundant calculations, the system can handle larger datasets or provide faster results, making it suitable for fields such as signal processing, financial analysis, and sensor data monitoring. The technique ensures that the autocorrelation function remains accurate while significantly reducing the number of operations required.
3. The computing-system-implemented method of claim 1 , wherein decrementally deriving two or more components without accessing and using all data elements in the adjusted computation window comprises decrementally deriving two or more components with accessing and using only 2*l data elements in the adjusted computation window.
This invention relates to computing systems that process data streams or large datasets, particularly focusing on efficient computation of statistical or analytical components without requiring full access to all data elements in a given window. The problem addressed is the computational inefficiency and resource overhead associated with recalculating components from scratch whenever a data window is adjusted, such as when new data arrives or old data expires. Traditional methods often require reprocessing all data elements in the window, which is time-consuming and resource-intensive, especially for large datasets or real-time applications. The invention provides a method for decrementally deriving two or more components (e.g., statistical measures like mean, variance, or other analytical results) by accessing and using only a subset of the data elements in the adjusted computation window. Specifically, the method ensures that only 2*l data elements are accessed and used, where l represents a parameter related to the window size or the number of new/expired data elements. This approach minimizes redundant computations by leveraging previously computed results and selectively updating only the necessary portions of the data. The technique is particularly useful in streaming data environments, time-series analysis, or any scenario where efficient incremental updates are required to maintain accurate and up-to-date analytical results without full reprocessing. The method optimizes performance by reducing the number of data elements accessed during each update, thereby improving speed and reducing computational overhead.
4. The computing-system-implemented method of claim 1 , wherein accessing or receiving a data element to be removed from the computation window includes accessing or receiving a plurality of z (z>1) data elements to be removed from the pre-adjusted computation window, and wherein the method further comprises performing, for each of the respective z data elements to be removed, the adjusting the pre-adjusted computation window, the decrementally deriving two or more components of an autocorrelation at lag l for the adjusted computation window, and the generating an autocorrelation at lag l for the adjusted computation window.
This invention relates to computing systems that process data streams, specifically methods for efficiently updating autocorrelation calculations when multiple data elements are removed from a computation window. The problem addressed is the computational inefficiency of recalculating autocorrelation from scratch when a window of data is adjusted by removing elements, which is common in real-time data analysis, signal processing, and time-series forecasting. The method involves adjusting a computation window by removing multiple data elements (z>1) and incrementally updating the autocorrelation at a specified lag (l) without full recomputation. For each removed data element, the method adjusts the computation window, decrementally derives two or more components of the autocorrelation, and generates the updated autocorrelation for the adjusted window. This approach reduces computational overhead by reusing intermediate results rather than recalculating the entire autocorrelation from the raw data. The technique is particularly useful in applications where data streams are continuously processed, such as financial modeling, sensor data analysis, or network traffic monitoring, where maintaining up-to-date statistical measures with minimal latency is critical. The method ensures accurate autocorrelation values while optimizing performance for dynamic data environments.
5. The computing-system-implemented method of claim 1 , wherein accessing or receiving a data element to be removed from the computation window includes accessing or receiving a plurality of z (z>1) data elements to be removed from the pre-adjusted computation window, and wherein the method further comprises performing, for each of the respective z data elements to be removed, the adjusting the pre-adjusted computation window, the decrementally deriving two or more components for the adjusted computation window.
This invention relates to computing systems that manage data elements within a computation window, particularly for adjusting the window when multiple data elements are removed. The problem addressed is efficiently updating the computation window when multiple data elements are deleted, ensuring accurate and incremental adjustments without recalculating the entire window from scratch. The method involves accessing or receiving a set of z data elements (where z is greater than 1) that need to be removed from a pre-adjusted computation window. For each of these z data elements, the computation window is adjusted incrementally. This adjustment includes decrementally deriving two or more components of the adjusted computation window. The components may include statistical measures, aggregated values, or other derived metrics that depend on the data elements within the window. By processing each data element individually and updating the window components incrementally, the method avoids the computational overhead of recalculating the entire window after each removal. This approach is particularly useful in real-time or high-frequency applications where rapid adjustments are necessary. The technique ensures that the computation window remains accurate and up-to-date with minimal processing overhead.
6. The computing-system-implemented method of claim 3 , wherein the generating an autocorrelation at lag l for the adjusted computation window comprises generating an autocorrelation at lag l for the adjusted computation window only when the autocorrelation is accessed.
The invention relates to computing systems that process time-series data, specifically improving efficiency in autocorrelation calculations. Autocorrelation is a statistical measure used to identify repeating patterns in data, but computing it for every possible lag can be computationally expensive. The invention addresses this by generating autocorrelation values only when they are needed, rather than precomputing all possible lags. This selective computation reduces unnecessary processing, particularly in applications where only specific lags are relevant. The method involves adjusting a computation window of the time-series data and then generating an autocorrelation at a specific lag (l) only when that autocorrelation value is requested. This on-demand approach optimizes resource usage by avoiding redundant calculations. The invention is particularly useful in real-time systems or large-scale data processing where computational efficiency is critical. By dynamically computing autocorrelations only when accessed, the system conserves processing power and memory, making it suitable for applications like signal processing, financial analysis, or sensor data monitoring. The method ensures accurate autocorrelation results while minimizing computational overhead.
7. The computing-system-implemented method of claim 5 , wherein the generating an autocorrelation at lag l for an adjusted computation window further comprises indirectly decrementally deriving, by the computing-device-based computing system, one or more components of the autocorrelation at lag l for the adjusted computation window, wherein the indirectly decrementally deriving one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
This invention relates to computing systems that analyze time-series data, specifically improving the efficiency of autocorrelation calculations. Autocorrelation is a statistical measure used to identify repeating patterns in data, such as signals or time-series datasets, but traditional methods require significant computational resources, especially for large datasets or real-time applications. The invention addresses this by optimizing the computation of autocorrelation values at a specific lag (l) for an adjusted computation window, reducing the computational overhead. The method involves indirectly and decrementally deriving components of the autocorrelation at lag l. Instead of recalculating each component from scratch, the system computes each component based on previously derived components, leveraging dependencies between them. This approach minimizes redundant calculations, improving efficiency without sacrificing accuracy. The technique is particularly useful in applications where real-time processing or resource constraints are critical, such as signal processing, financial data analysis, or sensor monitoring. The invention builds on prior methods that adjust computation windows to focus on relevant data segments, further refining the process by optimizing how autocorrelation components are derived. By reusing intermediate results, the system reduces the number of arithmetic operations, making it feasible to handle larger datasets or perform faster computations. This method is applicable in any domain where autocorrelation is used to analyze periodic or repeating patterns in time-series data.
8. A computing system, the computing system comprising: one or more computing devices; each of the one or more computing devices comprising one or more processors; one or more storage media; and one or more calculation modules that, when executed by at least one of the one or more computing devices, reduce redundant data access or retrieval when determining an autocorrelation at a specified lag for an adjusted computation window, wherein the one or more calculation modules configured to: a. initialize a lag l (l>0), a computation window size counter n (n>2*l+1), two or more components of an autocorrelation at lag l for a pre-adjusted computation window containing n data elements of a data set on at least one of the one or more storage media; b. access or receive a data element to be removed from the pre-adjusted computation window; c. adjust the pre-adjusted computation window by removing the accessed or received data element from the pre-adjusted computation window and adjusting the computation window size counter; d. decrementally calculate two or more components of an autocorrelation at lag l for the adjusted computation window based at least in part on the two or more components of the autocorrelation at lag l for the pre-adjusted computation window without accessing and using all data elements in the adjusted computation window from at least one of the one or more storage media to reduce data access latency and reduce operations performed by the computing-device-based computing system thereby saving computing resources, increasing calculation efficiency, and reducing the computing-device-based computing system's power consumption; and e. generate an autocorrelation at lag l for the adjusted computation window based on one or more of the decrementally calculated components.
The computing system is designed to efficiently compute autocorrelation for time-series data by reducing redundant data access and retrieval. Autocorrelation measures the similarity between a data series and a lagged version of itself, which is computationally intensive when recalculated from scratch for each window adjustment. The system includes one or more computing devices with processors and storage media, along with calculation modules that optimize autocorrelation computation. The system initializes a lag value (l>0), a computation window size (n>2l+1), and precomputes autocorrelation components for a pre-adjusted window containing n data elements. When a data element is removed from the window, the system adjusts the window size and incrementally recalculates autocorrelation components for the new window. Instead of reprocessing all data elements, it leverages previously computed values, reducing storage access and computational overhead. This approach minimizes latency, conserves computing resources, and lowers power consumption by avoiding full recomputation. The system generates an updated autocorrelation value for the adjusted window based on the incrementally calculated components. This method is particularly useful in real-time data analysis where frequent window adjustments are required, such as in signal processing or financial time-series analysis. The efficiency gains make it suitable for resource-constrained environments.
9. The computing system of claim 8 , wherein the generating an autocorrelation at lag l further comprises indirectly decrementally calculate one or more components of the autocorrelation at lag l for the adjusted computation window, wherein the indirectly decrementally calculating the one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
This invention relates to computing systems that process signals, particularly for calculating autocorrelations efficiently. The problem addressed is the computational inefficiency in traditional autocorrelation calculations, especially when dealing with adjusted computation windows or lagged values. The invention improves upon prior methods by enabling indirect decremental calculations of autocorrelation components, reducing redundant computations. The system generates an autocorrelation at a specific lag (l) by adjusting a computation window and then calculating one or more components of the autocorrelation for this window. Instead of computing each component directly, the system indirectly calculates them by deriving each component from other previously computed components. This approach avoids redundant calculations, improving efficiency. The method involves breaking down the autocorrelation into smaller, interdependent components and computing them in a sequence where each component relies on others, rather than recalculating from scratch. This technique is particularly useful in signal processing applications where autocorrelation is frequently recalculated, such as in real-time systems or iterative algorithms. By reducing the number of operations, the system achieves faster processing and lower computational overhead. The invention is applicable to any computing system performing autocorrelation calculations, including those in digital signal processing, time-series analysis, and statistical modeling.
10. The computing system of claim 8 , wherein the decrementally calculating two or more components without accessing and using all data elements in the adjusted computation window comprises decrementally calculating two or more components with accessing and using only 2*l data elements in the adjusted computation window.
This invention relates to computing systems that perform incremental or decremental calculations on data elements within a computation window, particularly in scenarios where the window is adjusted (e.g., shifted or resized). The problem addressed is the computational inefficiency of recalculating components from scratch when the window changes, which requires reprocessing all data elements. The solution involves decrementally updating components by reusing previously computed results and only accessing a subset of data elements in the adjusted window. The system calculates two or more components (e.g., statistical measures, aggregations, or other derived values) by incrementally or decrementally updating them when the computation window is modified. Instead of reprocessing all data elements in the new window, the system accesses and uses only 2*l data elements, where l is a parameter defining the window size or adjustment. This reduces computational overhead by avoiding redundant calculations. The method ensures accuracy by selectively incorporating only the necessary data elements affected by the window adjustment, such as those entering or exiting the window. The approach is applicable to streaming data, time-series analysis, or any scenario requiring dynamic window-based computations.
11. The computing system of claim 8 , wherein the one or more calculation modules, when executed by at least one of the one or more computing devices, perform b, c, d, and e multiple times.
A computing system is designed to process data by executing one or more calculation modules across multiple computing devices. The system addresses the challenge of efficiently distributing and managing computational tasks in a distributed environment, ensuring accuracy and performance. The calculation modules are configured to perform a series of operations, including data retrieval, transformation, analysis, and output generation. These operations are executed iteratively, allowing the system to handle large-scale data processing tasks with improved efficiency and reliability. The iterative execution ensures that intermediate results are validated and refined, enhancing the overall accuracy of the computations. The system dynamically allocates tasks among the computing devices based on their availability and processing capabilities, optimizing resource utilization. This approach reduces processing time and minimizes errors, making the system suitable for applications requiring high-performance data processing, such as scientific simulations, financial modeling, and large-scale data analytics. The iterative execution of the calculation modules ensures that the system can adapt to varying workloads and maintain consistent performance across different computational scenarios.
12. The computing system of claim 8 , wherein the one or more calculation modules, when executed by at least one of the one or more computing devices, perform b, c, and d multiple times.
A computing system is designed to process data by performing iterative calculations. The system includes multiple computing devices and one or more calculation modules that execute on these devices. The calculation modules are configured to perform a series of operations, labeled b, c, and d, repeatedly. These operations involve processing input data to generate intermediate or final results. The iterative execution of these operations allows the system to refine or accumulate data over multiple cycles, improving accuracy or efficiency in tasks such as data analysis, optimization, or simulation. The system may be used in applications requiring repeated computations, such as machine learning, scientific modeling, or financial forecasting. The modular design enables parallel processing, where different computing devices can handle different parts of the calculation sequence, enhancing performance. The system ensures that the operations b, c, and d are executed in a controlled manner, with each iteration potentially using outputs from previous iterations to progress toward a solution. This approach is particularly useful in scenarios where convergence or iterative refinement is necessary to achieve desired results.
13. The computing system of claim 11 , wherein the performing e comprises generating an autocorrelation at lag l for the adjusted computation window only when the autocorrelation is accessed.
The invention relates to computing systems designed to optimize the calculation of autocorrelations in signal processing applications. The problem addressed is the computational inefficiency in traditional systems where autocorrelations are precomputed for all possible lags, even when only specific lags are needed. This leads to unnecessary processing and memory usage. The system includes a processor configured to perform computations on a signal within a defined window. The key improvement involves dynamically generating an autocorrelation at a specific lag (l) only when that autocorrelation is requested, rather than precomputing it for all lags. This selective computation reduces computational overhead and memory consumption, particularly in applications where only certain lags are relevant. The system adjusts the computation window based on predefined criteria, such as signal characteristics or processing requirements, to ensure accurate autocorrelation calculations. The invention also includes a memory component to store the signal data and intermediate results, and an interface to receive input signals and output the computed autocorrelations. The selective generation of autocorrelations is particularly useful in real-time processing systems where computational efficiency is critical, such as in audio processing, telecommunications, or sensor data analysis. By avoiding unnecessary calculations, the system improves performance without sacrificing accuracy.
14. The computing system of claim 13 , wherein the generating an autocorrelation at lag l for an adjusted computation window comprises indirectly decrementally calculating one or more components of the autocorrelation at lag l for the adjusted computation window, wherein the indirectly decrementally calculating one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
This invention relates to computing systems for efficiently calculating autocorrelations in signal processing, particularly for adjusted computation windows. The problem addressed is the computational inefficiency in traditional autocorrelation methods, which often require redundant calculations when processing adjusted or shifted windows of data. The solution involves a method for indirectly decrementally calculating autocorrelation components at a specific lag (l) for an adjusted computation window. Instead of recalculating all components from scratch, the system computes each component based on previously calculated components, reducing redundant operations. This approach leverages interdependencies between components to minimize computational overhead. The system may also include preprocessing steps to prepare the data window and post-processing to refine the autocorrelation results. The method is particularly useful in real-time signal processing applications where computational efficiency is critical, such as in audio processing, telecommunications, or financial time-series analysis. By avoiding full recomputation, the system achieves faster and more resource-efficient autocorrelation calculations.
15. A computing system program product comprising one or more non-transitory computing-device-readable storage media having stored thereon computing-device-executable instructions that, when executed by at least one of one or more computing devices in a configured computing system, cause the configured computing system to perform a method for reducing redundant data access or retrieval from storage media when generating an autocorrelation at a specified lag for data elements in an adjusted computation window, the method including steps to: initialize, by the configured computing system, a lag l (l>0), a computation window size n (n>2*l+1), and two or more components of an autocorrelation at lag l for a pre-adjusted computation window which contains n data elements of a data set on at least one of one or more storage media in the configured computing system; access or receive, by the configured computing system, a data element to be removed from the pre-adjusted computation window; adjust, by the configured computing system, the pre-adjusted computation window by: removing the to-be-removed data element from the pre-adjusted computation window; and decreasing the computation window size by 1; decrementally calculate, by the configured computing system and based at least in part on the two or more components of the autocorrelation at lag l initialized or calculated for the pre-adjusted computation window, two or more components of an autocorrelation at lag l for the adjusted computation window without accessing and using all data elements in the adjusted computation window from at least one of the one or more storage media to reduce data access latency and reduce operations performed by the computing-device-based computing system thereby saving computing resources, increasing calculation efficiency, and reducing the computing-device-based computing system's power consumption; and generate, by the configured computing system, an autocorrelation at lag l for the adjusted computation window based on one or more of the decrementally calculated components.
The invention relates to a computing system program product designed to optimize autocorrelation calculations by reducing redundant data access and retrieval from storage media. Autocorrelation is a statistical measure used to analyze the relationship between a data set and a lagged version of itself, often employed in signal processing, time series analysis, and machine learning. The problem addressed is the computational inefficiency and latency associated with recalculating autocorrelation from scratch whenever a data element is removed from the computation window, which involves accessing all data elements in the window from storage media. The system initializes parameters including a lag value (l), a computation window size (n), and components of the autocorrelation at lag l for a pre-adjusted window containing n data elements. When a data element is removed, the window is adjusted by removing the element and decreasing the window size by 1. Instead of recalculating the autocorrelation from scratch, the system decrementally updates the autocorrelation components based on the pre-adjusted window's values. This approach avoids re-accessing all data elements in the adjusted window, reducing data access latency, computational operations, and power consumption. The result is an efficient, incremental autocorrelation calculation that conserves computing resources and improves performance.
16. The computing system program product of claim 15 , wherein the decrementally calculating two or more components without accessing and using all data elements in the adjusted computation window comprises decrementally calculating two or more components with accessing and using only 2*l data elements in the adjusted computation window.
This invention relates to computing systems that perform incremental or decremental calculations on data sets, particularly for optimizing computational efficiency when processing sliding or adjusted computation windows. The problem addressed is the computational overhead and inefficiency of recalculating components from scratch when only a subset of data elements changes, such as in sliding window computations or dynamic data analysis. The invention provides a method for decrementally calculating two or more components of a computation without accessing or using all data elements in the adjusted computation window. Specifically, the system calculates components by accessing and using only 2*l data elements, where l represents a parameter related to the window size or the number of elements that have changed. This approach reduces the computational load by avoiding full recalculations, instead leveraging partial updates based on the differences between the original and adjusted windows. The method ensures accuracy while minimizing the number of data elements processed, improving performance in applications like real-time analytics, signal processing, or database queries where windowed computations are common. The system dynamically adjusts the computation window and efficiently updates the results without redundant processing.
17. The computing system program product of claim 15 , wherein the computing-device-executable instructions that, when executed, further cause the configured computing system to access or receive a data element to be removed, to adjust the pre-adjusted computation window, to decrementally calculate two or more components, and to generate an autocorrelation at lag l for the adjusted computation window for each of multiple data elements to be accessed or received.
This invention relates to computing systems that process data elements to generate autocorrelation values. The technology addresses the challenge of efficiently computing autocorrelation for dynamic datasets where data elements may be added or removed, requiring adjustments to the computation window without recalculating the entire dataset from scratch. The system includes a computing device with executable instructions that perform incremental adjustments to the computation window. When a data element is to be removed, the system accesses the element, adjusts the computation window, and decrementally calculates two or more components of the autocorrelation function. This allows the system to generate an autocorrelation value at a specified lag (l) for the adjusted window, ensuring accurate results without full recomputation. The method leverages incremental updates to maintain efficiency, particularly in scenarios where frequent adjustments to the dataset are necessary. The system may also handle multiple data elements sequentially, applying the same adjustment and calculation process to each. This approach optimizes computational resources by avoiding redundant calculations, making it suitable for real-time or large-scale data processing applications.
18. The computing system program product of claim 15 , wherein the computing-device-executable instructions that, when executed, further cause the configured computing system to access or receive a data element to be removed, to adjust the pre-adjusted computation window, to decrementally calculate two or more components for the adjusted computation window for each of multiple data elements to be accessed or received.
This invention relates to computing systems that process data elements within a computation window, addressing the challenge of efficiently adjusting the window and calculating components for multiple data elements. The system includes a computing device with executable instructions that configure it to perform specific operations. The instructions enable the system to access or receive a data element designated for removal, adjust a pre-adjusted computation window, and then decrementally calculate two or more components for the adjusted window. These calculations are performed for each of multiple data elements that are accessed or received. The decremental calculation approach allows for efficient updates to the computation window without recalculating all components from scratch, improving performance. The system may also include a data storage component to store the computation window and its components, and a user interface to display the results. The invention ensures accurate and efficient data processing by dynamically adjusting the computation window and recalculating only the necessary components, reducing computational overhead. This method is particularly useful in applications requiring real-time data analysis or frequent updates to the computation window.
19. The computing system program product of claim 17 , wherein the generating an autocorrelation at lag l for the adjusted computation window comprises generating an autocorrelation at lag l for the adjusted computation window only when the autocorrelation is accessed.
The invention relates to computing systems that process time-series data, particularly for generating autocorrelation values in an efficient manner. The problem addressed is the computational inefficiency in calculating autocorrelation values for time-series data, especially when these values are not always needed. Traditional methods compute autocorrelation for all possible lags, even if some are unused, wasting processing resources. The invention improves efficiency by generating autocorrelation values only when they are accessed. Specifically, the system adjusts a computation window of time-series data and calculates an autocorrelation at a specific lag (l) only when that autocorrelation value is requested. This on-demand approach reduces unnecessary computations, optimizing resource usage. The system may also include preprocessing steps, such as adjusting the computation window to exclude irrelevant data points, ensuring accurate autocorrelation calculations. The invention applies to computing systems handling time-series data, such as signal processing, financial analysis, or sensor data monitoring. By deferring autocorrelation calculations until needed, the system conserves computational power and memory, making it suitable for real-time applications where efficiency is critical. The method ensures that autocorrelation values are computed only when required, improving overall system performance.
20. The computing system program product of claim 19 , wherein the generating an autocorrelation at lag l for the adjusted computation window comprises indirectly decrementally calculating one or more components of the autocorrelation at lag l for the adjusted computation window, wherein the indirectly decrementally calculating one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
The invention relates to computing systems for efficiently calculating autocorrelations in signal processing, particularly for adjusted computation windows. Autocorrelation is a mathematical tool used to measure the similarity of a signal with a delayed copy of itself, which is essential in applications like speech recognition, vibration analysis, and time-series forecasting. A key challenge in computing autocorrelations is the computational overhead, especially when dealing with large datasets or real-time processing, where traditional methods may be inefficient. The invention addresses this problem by providing a method for indirectly decrementally calculating one or more components of the autocorrelation at a specific lag (l) for an adjusted computation window. Instead of directly computing each component, the system calculates each component based on other previously computed components, reducing redundant calculations and improving efficiency. This approach leverages incremental updates to the autocorrelation values, allowing for faster and more resource-efficient processing. The method is particularly useful in scenarios where the computation window is dynamically adjusted, such as in adaptive filtering or real-time signal analysis, where maintaining computational efficiency is critical. By minimizing the number of direct calculations, the system optimizes performance without sacrificing accuracy.
Unknown
May 19, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.