tempdisagg: A Python Framework for Temporal Disaggregation of Time Series Data

Extracted main text — title through conclusion, appendix excluded. This is what our citation measures are computed over, published so the extraction can be checked by eye.

44,481 characters · 20 sections · 7 citation commands

Rendered from LaTeX for readability, not typeset faithfully. Citation keys are highlighted; maths is left as source; figures, tables and equation environments are summarised rather than reproduced; unrecognised commands are greyed out so nothing is silently dropped. Email addresses are removed.

abstracttempdisagg is a modern, extensible, and production-ready Python framework for temporal disaggregation of time series data. It transforms low-frequency aggregates into consistent, high-frequency estimates using a wide array of econometric techniques—including Chow-Lin, Denton, Litterman, Fernández, and uniform interpolation—as well as enhanced variants with automated estimation of key parameters such as the autocorrelation coefficient $ \rho $. The package introduces features beyond classical methods, including robust ensemble modeling via non-negative least squares optimization, post-estimation correction of negative values under multiple aggregation rules, and optional regression-based imputation of missing values through a dedicated Retropolarizer module. Architecturally, it follows a modular design inspired by scikit-learn, offering a clean API for validation, modeling, visualization, and result interpretation.

{Keywords: temporal disaggregation; econometric modeling; statistical interpolation; ensemble learning; open source software; machine learning}

Introduction

tempdisagg is a modern, production-ready Python package for temporal disaggregation of time series—designed to transform low-frequency data (e.g., yearly or quarterly statistics) into consistent and statistically sound high-frequency estimates (e.g., monthly or weekly). It bridges the persistent gap between the availability of official aggregate statistics and the growing demand for granular, timely insights in economic monitoring, policy design, and operational forecasting.

Inspired by the well-known R package tempdisagg by sax2013tempdisagg, this Python implementation reimagines the methodology within a clean, extensible, and modular framework. It supports a wide range of classical approaches, including regression-based methods such as chow1971 and litterman1983, smoothing-based techniques such as Denton denton1971 and fernandez1981, as well as uniform interpolation. In addition, it introduces enhanced variants that automatically estimate key model parameters - most notably the autocorrelation coefficient $\rho$ - using maximum likelihood or residual minimization strategies quilis2018, improving both robustness and predictive accuracy.

tempdisagg goes beyond traditional implementations by introducing a set of powerful enhancements. These include automatic handling of missing subperiods, optional imputation of missing target values via a dedicated Retropolarizer module, post-estimation adjustments to correct for negative predictions, and a flexible ensemble prediction engine that optimally combines multiple models into a single disaggregated estimate. Each component is designed with practical use in mind, offering flexibility without sacrificing methodological rigor.

From an architectural perspective, the library is organized around modular components that encapsulate distinct stages of the disaggregation process: input validation and interpolation, aggregation matrix construction, model fitting, post-processing, and visualization. Its API is deliberately modeled after scikit-learn, providing familiar methods such as fit(), predict(), adjust_output(), summary(), and plot(), ensuring smooth integration into existing data science pipelines.

The library is aimed at a broad audience, including economists, statisticians, data scientists, and public institutions, and can be used for tasks ranging from national accounts reconciliation and macroeconomic forecasting to teaching and applied research. Extensive documentation, illustrative notebooks, and real-world examples are provided to accelerate adoption and ensure reproducibility.

In summary, tempdisagg offers a comprehensive and extensible solution for temporal disaggregation in Python. By combining classical econometric techniques with modern features like automatic parameter tuning, ensemble learning, post-estimation correction, and regression-based imputation, it enables high-quality granular estimation from coarse data while remaining fully transparent, reproducible, and open source under the MIT license.

Key Contributions. This paper introduces tempdisagg, a comprehensive Python temporal disaggregation library, with the following key contributions:

itemize• Modular and extensible architecture: A clean object-oriented design that separates the components of preprocessing, model fitting, post-estimation and visualization, promoting clarity, reuse, and testability. • Full suite of classical methods: Implementation of widely used econometric techniques such as Chow-Lin, Denton, Litterman, Fernández and uniform interpolation, matching the functionality of the original R package. • Automatic parameter optimization: Robust estimation of the autocorrelation parameter $ \rho $ using maximum likelihood or residual minimization, improving model accuracy without requiring manual adjustment. • Ensemble prediction engine: A novel nonnegative least squares (NNLS) approach to combine multiple models into a single forecast, ensuring consistency of aggregation and performance stability. • Post-estimation adjustment: A dedicated utility to correct negative values in predictions while preserving aggregation constraints, allowing interpretability and real-world applicability. • Retropolarization module: Optional imputation of missing low-frequency values using proportion-based, regression-based, or neural methods, extending disaggregation to incomplete or real-time datasets. • \textbf{User-friendly API and documentation:} Intuitive interface modeled after \texttt{scikit-learn}, extensive inline validation, and publicly available examples to support adoption and reproducibility.

Methodology

The tempdisagg framework follows a structured modular methodology for temporal disaggregation, systematically converting low-frequency time series into high-frequency estimates while maintaining statistical coherence and consistency. The process is organized into a sequence of well-defined steps, each addressing a key component of the modeling pipeline.

Validation of Input Data Structure

The process begins with a rigorous validation of the input data to ensure structural integrity. The data set must contain four essential columns: Index, which identifies the low-frequency grouping (e.g., year or quarter); Grain, which identifies the high-frequency subperiod within each group (e.g., month or quarter number); y, the low-frequency target variable; and X, the high-frequency indicator variable. Any structural inconsistencies are flagged early to prevent downstream issues. To be compatible with TempDisModel, the input must be formatted as a long format DataFrame, with one row per high-frequency observation. The required columns are summarized in Table (ref).

table[table omitted — 836 chars of source]

An example of a correctly formatted input DataFrame is shown in Table (ref).

table[table omitted — 526 chars of source]

Completion of Missing Sub-Periods Using Robust Interpolation

After validation, the framework fills in any missing high-frequency sub-periods through robust interpolation. This ensures that all combinations of Index and Grain are present, which is essential to construct a complete and coherent time series. Interpolation methods such as linear, nearest-neighbor, or spline can be used depending on the characteristics of the data. The goal is to produce a structurally complete dataset suitable for modeling.

Construction of Aggregation Matrix

Once the data are complete, an aggregation matrix $ C $ is constructed to represent the mapping from high-frequency estimates to low-frequency aggregates. This matrix plays a central role in ensuring internal consistency throughout the modeling process. The user can specify the aggregation rule and the matrix is dynamically built to reflect the relationship between observations.

The supported aggregation rules and corresponding matrix structures are as follows:

itemize• Sum: Each high-frequency observation within a group receives a weight of 1. • Average: Each observation is equally weighted, with a weight of $1/m$, where $m$ is the number of sub-periods per group. • First: Only the first sub-period receives a weight of 1; all others are assigned 0. • Last: Only the last sub-period is assigned a weight of 1; all others are 0.

This aggregation matrix is then used to constrain model predictions, ensuring that disaggregated estimates remain consistent with the original low-frequency data.

Application of Classical and Advanced Disaggregation Models

The tempdisagg framework supports a comprehensive suite of temporal disaggregation methods, which include both classical econometric approaches and modern computational enhancements. Each method takes as input a univariate low-frequency series $ y_l $ and a high-frequency indicator series $ X $, producing a high-frequency estimate $ y $ that respects the aggregation constraint defined by a matrix $ C $, such that $ C y \approx y_l $.

Currently, all models are univariate, meaning that only one explanatory variable is used per disaggregation task. Despite this limitation, the library offers a wide range of disaggregation strategies, including regression-based, smoothing-based, and distribution-based methods. The choice of method depends on the availability and quality of the indicators, the trade-off between smoothness and adherence to $ X $, and assumptions about the underlying data-generating process, such as autocorrelation or prior structures. Below is a summary of the main models implemented:

itemize• Ordinary Least Squares (OLS): Serves as a baseline model by regressing $ y_l $ on aggregated indicators $ C X $, then projecting the estimated coefficient $ \hat{\beta} $ back onto the high-frequency indicator $ X $. It assumes homoskedasticity and no autocorrelation. • Denton Method: A widely adopted approach to smooth disaggregation in the absence of indicators. It minimizes changes between adjacent periods using a differencing operator of order $ h $, ensuring consistency with aggregates while maintaining temporal smoothness. • Denton-Cholette Method: A generalization of Denton introduced by Dagum and Cholette, which adjusts a base series (such as an indicator) by minimizing discrepancies under a quadratic penalty. It also allows for optional weights to give more emphasis to specific sub-periods. • Chow-Lin Method: A regression-based model that accounts for AR(1) autocorrelation in residuals. Parameters are estimated using generalized least squares (GLS), using a covariance matrix $ Q $ defined by the autocorrelation parameter $ \rho $. The optimized variant chow-lin-opt estimates $ \rho $ using maximum likelihood. Additional fixed-$ \rho $ variants inspired by Ecotrim ($ \rho = 0.75 $) and Quilis ($ \rho = 0.15 $) are also included. • Litterman Method: A Bayesian method imposing a priori on high-frequency target series $ y $, typically based on an AR(1) or random walk structure encoded by a precision matrix $ H^\top H $. Unlike Chow-Lin, the prior is directly placed on $ y $. The \texttt{litterman-opt} variant estimates $ \rho $ by minimizing the residual sum of squares. • \textbf{Fernández Method:} A special case of Litterman where $ \rho = 0 $, effectively applying a second-order differencing prior. It produces smooth estimates without requiring autocorrelation estimation. • \textbf{Fast Method:} A computational shortcut that implements the Litterman method with a fixed $ \rho = 0.9 $, offering a balance between speed and reasonable autoregressive smoothing. • \textbf{Uniform Method:} A noninformative baseline that evenly distributes each low-frequency value across its high-frequency subperiods. This approach does not use any indicators and is simply based on the aggregation matrix $ C $.

All models are implemented in a modular fashion within the ModelsHandler class. When applicable, they return not only the high-frequency prediction $ \hat{y} $, but also the estimated parameters $ \hat{\beta} $, autocorrelation $ \hat{\rho} $, residuals, and associated covariance structures ($ Q $, vcov). Table (ref) summarizes the key characteristics and computational principles of each method.

table[table omitted — 2,250 chars of source]

Automatic Optimization of \texorpdfstring{$\rho$}{rho} in Regression-Based Models

In regression-based temporal disaggregation models such as Chow-Lin and Litterman, the autocorrelation parameter $ \rho $ plays a central role in capturing the serial dependence structure of model residuals. An inappropriate or arbitrary choice of $ \rho $ can lead to biased estimates or poor aggregation consistency. To address this, tempdisagg implements a dedicated RhoOptimizer class that automatically estimates the optimal value of $ \rho $ from the data. The optimizer supports two methods for estimating $ \rho $:

itemize• Maximum Log-Likelihood (maxlog): Estimates $ \rho $ by maximizing the Gaussian log-likelihood of the observed low-frequency series, accounting for the implied covariance structure of the residuals. This approach balances model fit and uncertainty under strong statistical assumptions. • Minimum Residual Sum of Squares (minrss): Estimates $ \rho $ by minimizing the generalized residual sum of squares under the GLS framework. This approach is particularly useful when normality assumptions are relaxed or when the interpretability of residuals is prioritized.

Optimization is performed using scalar bounded minimization over a user-defined interval, typically $[-0.9, 0.99]$. Internally, the algorithm:

enumerate• Constructs a power matrix that encodes the absolute time differences between high-frequency periods. • Uses this matrix to compute a parameterized autocorrelation matrix $ Q_\rho $, which serves as the residual covariance structure. • Builds the implied low-frequency variance-covariance matrix $ V = C Q_\rho C^\top $, and uses its (pseudo)inverse in the generalized least-squares estimation of $ \beta $. • Evaluate the objective function (log-likelihood or RSS) in each candidate $ \rho $ and select the optimal one.

Once the optimal $ \rho $ is found, the method returns not only the point estimates for $ \rho $, $ \beta $, and the residuals, but also the full inference results, including:

itemize• The fitted residual covariance matrix $ Q $ and its low-frequency projection $ V $. • Standard errors, t-statistics, and p-values for the estimated coefficients. • A summary table highlighting statistical significance with conventional stars.

This module is fully integrated into the regression-based methods of the framework (e.g., chow-lin-opt, litterman-opt), providing a robust and transparent approach to autocorrelation estimation that improves both the statistical validity and the practical usefulness of the resulting disaggregated series.

Ensemble Modeling for Robust Disaggregation

In scenarios where no single disaggregation method performs consistently well in all datasets or applications, ensemble modeling offers a powerful alternative. The tempdisagg framework integrates an ensemble prediction module that combines the outputs of multiple disaggregation models into a single unified estimate. This ensemble is designed to capitalize on the complementary strengths of individual models while mitigating their weaknesses.

The ensemble is constructed through a constrained nonnegative least squares (NNLS) optimization, which assigns a weight $ w_i $ to each model's high-frequency prediction $ \hat{y}_i $, so that the aggregated prediction best approximates the observed low-frequency totals $ y_l $. Specifically, the optimization problem is defined as follows:

\[ \min_{w \geq 0} \left\| C \left( \sum_{i=1}^{M} w_i \hat{y}_i \right) - y_l \right\|^2 \quad \text{subject to} \quad \sum_{i=1}^{M} w_i = 1 \]

where $ C $ is the aggregation matrix and $ M $ is the number of models being combined. The non-negativity constraint ensures interpretability (no negative contribution from any model), while the sum-to-one constraint ensures that the ensemble remains a convex combination of valid predictions.

This process is managed by the EnsemblePredictor class, which orchestrates the following steps:

enumerate• Input Preparation: Uses DisaggInputPreparer to validate the dataset, apply interpolation or retropolarization if necessary, and generate the aggregation matrix $ C $. • Model Execution: Runs a predefined or user-specified set of disaggregation methods (e.g., ols, chow-lin, denton-opt, etc.) via the \texttt{EnsemblePrediction} component. • \textbf{Weight Optimization}: Solves the NNLS problem to assign optimal weights to each method. • \textbf{Prediction Aggregation}: Combines weighted predictions into a single ensemble forecast $ \hat{y}_{\text{ensemble}} $. • \textbf{Diagnostics and Visualization}: Offers summary tables (including coefficients, scores, and weights), compact evaluation metrics (e.g., MAE, RMSE), and visual plots comparing ensemble and individual model predictions.

The ensemble model is compatible with the larger tempdisagg architecture and can be treated as a standard model object. It includes attributes for accessing the ensemble prediction, weights, constituent models, and inference results. Moreover, it supports exporting to a compatible model interface via to_model(), enabling seamless use in validation and reporting. In practice, the ensemble approach improves the robustness and reliability of temporal disaggregation, especially in heterogeneous or noisy environments. The ensemble prediction strategy uses nonnegative least squares (NNLS) to compute optimal weights for combining individual model outputs, under the constraint that weights are non-negative and sum to one. This approach provides a more robust alternative to simple averaging, avoiding negative contributions and improving interpretability by highlighting the relative importance of each method.

Post-Estimation Adjustment of Negative Values

A critical step in practical temporal disaggregation is ensuring that the high-frequency predictions remain non-negative, particularly relevant for variables such as population, GDP, or sales, where negative values are not interpretable. Although most of the disaggregation methods implemented in tempdisagg are statistically rigorous, some may still yield negative values, especially under noisy or sparse indicators. To address this, the framework includes a dedicated post-estimation utility class, PostEstimation, which adjusts predicted values to enforce non-negativity while preserving internal consistency with the selected aggregation rule.

PostEstimation operates after model predictions and supports all major aggregation types: sum, average, first, and last. For each low-frequency group with negative predictions, the method applies one of the following correction strategies:

itemize• Sum Aggregation: Negative values are absorbed by redistributing their absolute total proportionally among positive values within the same group. If no positive values are available, the total is evenly distributed across all periods. This ensures that the adjusted series still sums up to the original low-frequency total. • Average Aggregation: The adjusted series must preserve the original mean. To achieve this, the method solves a constrained optimization problem that minimizes the squared deviation from the original series, subject to non-negativity and mean preservation constraints. Formally, it solves: \[ \min_{y \geq 0} \| y - y_{\text{original}} \|^2 \quad \text{subject to} \quad \text{mean}(y) = \text{mean}(y_{\text{original}}) \] This is implemented using Sequential Least Squares Programming (SLSQP). If the optimization fails (e.g. due to ill-conditioning), the method defaults to setting negative values to zero. • First Aggregation: The first value of each group is prioritized. If it is negative, its value is reset to zero, and the discrepancy is redistributed among the remaining values. If the rest of the group contains negatives, they are adjusted, while attempting to preserve the first value as is, provided that overall consistency with the aggregate is maintained. • Last Aggregation: Similar to the first case, but applied to the last subperiod in each group. If the last value is negative, it is reset and the remainder of the group compensates accordingly. Positive values are scaled proportionally to absorb any residual discrepancy.

Each correction is applied group-wise based on the low-frequency identifier (e.g., year or quarter), and the adjusted values replace the original predictions in a copy of the DataFrame. Importantly, these corrections are designed to avoid large distortions in the overall distribution while ensuring that the aggregation constraint (e.g. $\sum y = y_l$) is respected. This post-estimation step adds robustness to the modeling pipeline and ensures that the outputs of tempdisagg are not only statistically sound, but also practical and interpretable in applied settings. The summary of these procedures can be seen in Table (ref).

table[table omitted — 1,434 chars of source]

Retropolarization of Missing Low-Frequency Values

An additional feature of tempdisagg is the ability to estimate missing values in the low-frequency target variable $ y_l $ before disaggregation, through a module known as the Retropolarizer. This component is designed to address situations where recent or historical values of $ y_l $ are not available but are required for temporal disaggregation, particularly in real-time forecasting, incomplete administrative records, or data reporting delays.

The Retropolarizer operates by inferring missing values in $ y_l $ using the available high-frequency indicator $ X $ (or an auxiliary predictor if specified). It supports a range of inference techniques tailored to the characteristics of the data:

itemize• Proportional Adjustment: Fills missing values by proportionally scaling available data using observed indicator trends. • Linear Regression: Learns a linear relationship between $ y_l $ and $ X $ (or an auxiliary column) and uses it to predict missing entries. • Polynomial Regression: Captures more complex relationships using second- or third-order polynomial fits. • Exponential Smoothing: Use weighted averages of past observations to project values forward. • Neural Networks (MLP): Employs a simple multilayer perceptron for nonlinear inference, especially when more data is available.

The choice of method can be explicitly specified by the user or automatically selected on the basis of the completeness or variability of the data. Once completed, the augmented low-frequency series $ y_l $ is seamlessly passed to the disaggregation workflow. If activated, the system checks for missing values in $ y_l $, applies the selected reconstruction method, and logs the operation. This ensures that disaggregation remains feasible even when partial data is supplied, increasing the usability of the framework in forecasting and nowcasting applications.

Illustrative Examples

U.S. Macroeconomic Data (Annual to Quarterly)

To illustrate the basic functionality of tempdisagg, we used the macrodata dataset available in the statsmodels library. This data set contains quarterly macroeconomic indicators for the United States from 1959Q1 to 2009Q3. Specifically, we simulated a temporal disaggregation scenario in which the real Gross Domestic Product (GDP) was artificially aggregated to an annual frequency and then disaggregated back to quarterly estimates using real consumption as the high-frequency indicator. The annual GDP values were computed as the mean of the quarterly GDP observations for each year. These aggregated totals served as the low-frequency target variable (y), while the original quarterly consumption series (realcons) was used as the high-frequency indicator (X). The resulting data set was then passed to \texttt{tempdisagg}, demonstrating the model's ability to recover coherent quarterly estimates that align with the original annual aggregates. As shown in Figure (ref), the disaggregated estimates closely follow the quarterly dynamics implied by the high-frequency indicator.

figure[figure omitted — 254 chars of source]

U.S. Macroeconomic Data (Quarterly to Monthly)

To test the performance of tempdisagg on real high-frequency data, we used the Industrial Production Index (INDPRO) of the US Federal Reserve Economic Data (FRED) as the monthly indicator from 1947M1 to 2024M12. The INDPRO series reflects real output from the manufacturing, mining, and utilities sectors and is widely used as a proxy for economic activity at high temporal resolutions.

In this case, we simulated a low-frequency annual series by aggregating the monthly INDPRO values using a summation rule, which served as the target variable for disaggregation. The original monthly INDPRO values were retained as the high-frequency indicator. This setting allowed us to evaluate how well tempdisagg could recover monthly-level signals that are consistent with the aggregated annual totals.

The model was applied using the chow-lin-opt method with the sum conversion rule, and the resulting estimates showed strong alignment with the underlying monthly patterns of the indicator. As shown in Figure (ref), the temporal disaggregation of annual GDP growth into monthly estimates generally follows the underlying trend implied by the indicator. However, the model has reduced the accuracy in capturing abrupt or atypical fluctuations in economic growth. These deviations highlight a known limitation of classical disaggregation methods such as Chow-Lin, which tend to smooth out extreme values and may underrepresent sharp inflections or economic shocks at higher frequencies.

figure[figure omitted — 267 chars of source]

National and Departmental Population

To evaluate the performance of the proposed framework using population data, we applied tempdisagg to the official projections of Colombia's population. The disaggregation task consisted of transforming annual national totals into monthly estimates per department. Specifically, we used the chow-lin-opt method with the average aggregation rule, using official national monthly totals as a high-frequency indicator. The model generated monthly estimates for each department (dep_population) which were then aggregated back to the annual level. These reconstructed values were compared with the official annual figures (population) to assess the precision of the disaggregation technique.

We computed standard error metrics for each department, namely, mean absolute error (MAE), root mean squared error (RMSE), and mean squared error (MSE), and averaged the results across all departments. The average MAE was 107.61, suggesting that, on average, departmental aggregates deviated by approximately 108 individuals per year from the official national totals. The average RMSE reached 537.76, highlighting the presence of more substantial deviations in certain departments. These results indicate that tempdisagg is capable of producing consistent and accurate subnational estimates from national-level population data, even under real-world conditions. However, caution is advised when interpreting extreme cases, as traditional disaggregation methods may struggle with highly volatile or irregular series. A detailed summary of these results in terms of the three metrics is provided in Table (ref).

table[table omitted — 1,062 chars of source]

Libraries Comparison

To further assess the behavior of temporal disaggregation methods in different software ecosystems, we compared the results obtained with tempdisagg against those produced by the R package tempdisagg sax2013tempdisagg. Both frameworks were configured to use the chow-lin-opt method with an average aggregation rule, using the same input dataset and high-frequency indicator. The disaggregated estimates generated by each library were highly similar throughout most of the series, with both approaches producing nearly identical monthly population values when reaggregated to the annual level.

figure[figure omitted — 228 chars of source]

However, a key divergence emerged at the boundaries of the time series, particularly in the last year, because of differences in how each library handles incomplete periods and automatic padding. While the R implementation of tempdisagg trims or excludes periods that do not form complete low-frequency groups, the Python framework explicitly allows for padding and interpolation of partial subperiods via the TimeSeriesCompleter component. As a result, Python estimates preserve continuity by filling in missing months at the end of the series, potentially improving applicability in real-time or near-term forecasting. However, this flexibility introduces slight discrepancies in the final period compared to the R output, as the interpolation step affects the structure of the aggregation matrix and thus the final disaggregated estimates. Overall, both implementations are consistent in their core estimation logic and provide statistically robust disaggregation results. However, users should be aware of the default assumptions that each library makes regarding series completeness, padding, and structural interpolation, as these choices can subtly affect the resulting high-frequency predictions, especially at the edges of the data.

Limitations and Future Work

Currently, tempdisagg supports only univariate temporal disaggregation methods, which rely on a single high-frequency indicator series. Although this design ensures simplicity and interpretability, it limits the capacity to capture complex dynamics that may require multiple explanatory variables. Support for multivariate disaggregation—incorporating several high-frequency indicators simultaneously—is planned as a key future enhancement.

Furthermore, classical disaggregation models, such as Chow-Lin, Denton, and Litterman, assume relatively smooth behavior in the underlying high-frequency structure. When the target series exhibits abrupt changes, discontinuities, or extreme volatility - common in projections for certain regions or administrative units - these models may struggle to produce stable and realistic estimates. This sensitivity to irregularity can result in extreme values or local inconsistencies, particularly in sparse or noisy settings.

Future work will explore the integration of robust statistical techniques, regularization, and machine learning models to better handle such challenging cases. Extensions to support hierarchical reconciliation, uncertainty quantification, and scenario-based projections are also being considered to improve the framework's applicability across diverse domains and data environments.

Project Description

itemize• Repository location:: \begin{itemize} • \url{https://github.com/jaimevera1107/tempdisagg} • \url{https://pypi.org/project/tempdisagg/} \end{itemize} • Language: Python, English • License: MIT

Conclusions

The tempdisagg package provides a comprehensive and versatile solution for temporal disaggregation in Python, delivering an accessible and production-ready toolkit for researchers, statisticians, economists, and data analysts. Its modular design, rigorous validation framework, and user-friendly API ensure high usability, transparency, and reproducibility, effectively bridging the gap between traditional econometric practices and modern data science workflows.

Beyond replicating classical methods like Chow-Lin, Denton, Fernández, and Litterman, the package introduces ensemble modeling capabilities and post-estimation adjustments, allowing users to improve robustness and respect real-world constraints such as non-negativity and aggregation consistency. These features make tempdisagg particularly valuable for applications in national statistics, policy evaluation, and economic forecasting.

By combining theoretical rigor with software engineering best practices, tempdisagg serves as both a practical tool and an extensible research platform. Future developments may include support for multivariate disaggregation, integration with state-space models, and Bayesian estimation approaches, further extending its applicability in time-series analysis.

Acknowledgments

Thanks to the R package tempdisagg for their methodological foundation. The appreciation also goes to the open source community for tools such as NumPy, SciPy, and Pandas.

Funding Statement

This project did not receive external funding. The author has no competing interests to declare.

thebibliography{99} \bibitem{chow1971} Chow, G. C., & Lin, A. L. (1971). Best linear unbiased interpolation, distribution, and extrapolation of time series by related series. The Review of Economics and Statistics, 53(4), 372--375. \bibitem{denton1971} Denton, F. T. (1971). Adjustment of monthly or quarterly series to annual totals: An approach based on quadratic minimization. Journal of the American Statistical Association, 66(333), 99--102. \bibitem{dagum2006benchmarking} Dagum, E. B., & Cholette, P. A. (2006). Benchmarking, temporal distribution, and reconciliation methods for time series. Statistics Canada. \bibitem{litterman1983} Litterman, R. B. (1983). A random walk, Markov model for the distribution of time series. Journal of Business & Economic Statistics, \textit{1}(2), 169--173. \bibitem{fernandez1981} Fernández, R. B. (1981). A methodological note on the estimation of time series. \textit{The Review of Economics and Statistics}, \textit{63}(3), 471--476. \bibitem{sax2013tempdisagg} Sax, C., & Steiner, P. (2013). \textit{tempdisagg: Methods for Temporal Disaggregation and Interpolation of Time Series} (R package version 1.0). Retrieved from \url{https://CRAN.R-project.org/package=tempdisagg} \bibitem{harvey1989} Harvey, A. C. (1989). \textit{Forecasting, structural time series models and the Kalman filter}. Cambridge University Press. \bibitem{quilis2018} Quilis, E. M. (2018). A generalized version of the Chow--Lin procedure for temporal disaggregation. \textit{Journal of Official Statistics}, \textit{34}(2), 523--542. \bibitem{lutkepohl2005new} Lütkepohl, H. (2005). \textit{New introduction to multiple time series analysis}. Springer Science & Business Media. \bibitem{brockwell1991time} Brockwell, P. J., & Davis, R. A. (1991). \textit{Time series: Theory and methods}. Springer Science & Business Media. \bibitem{box2015time} Box, G. E. P., Jenkins, G. M., Reinsel, G. C., & Ljung, G. M. (2015). \textit{Time series analysis: Forecasting and control}. John Wiley & Sons. \bibitem{proietti2006temporal} Proietti, T. (2006). Temporal disaggregation by state space methods: Dynamic regression methods revisited. \textit{Econometrics Journal}, \textit{9}(3), 357--372.