Old docs

coreforecast/differences.mdx

@@ -0,0 +1,94 @@
+
+
+
+
+# <kbd>module</kbd> `coreforecast.differences`
+
+
+
+
+
+---
+
+
+
+## <kbd>function</kbd> `num_diffs`
+
+```python
+num_diffs(x: ndarray, max_d: int = 1) → int
+```
+
+Find the optimal number of differences 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Array with the time series. 
+ - <b>`max_d`</b> (int, optional):  Maximum number of differences to consider. Defaults to 1. 
+
+
+
+**Returns:**
+
+ - <b>`int`</b>:  Optimal number of differences. 
+
+
+---
+
+
+
+## <kbd>function</kbd> `num_seas_diffs`
+
+```python
+num_seas_diffs(x: ndarray, season_length: int, max_d: int = 1) → int
+```
+
+Find the optimal number of seasonal differences 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Array with the time series. 
+ - <b>`season_length`</b> (int):  Length of the seasonal pattern. 
+ - <b>`max_d`</b> (int, optional):  Maximum number of differences to consider. Defaults to 1. 
+
+
+
+**Returns:**
+
+ - <b>`int`</b>:  Optimal number of seasonal differences. 
+
+
+---
+
+
+
+## <kbd>function</kbd> `diff`
+
+```python
+diff(x: ndarray, d: int) → ndarray
+```
+
+Subtract previous values of the series 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Array with the time series. 
+ - <b>`d`</b> (int):  Lag to subtract 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Differenced time series. 
+
+
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

coreforecast/expanding.mdx

@@ -0,0 +1,141 @@
+
+
+
+
+# <kbd>module</kbd> `coreforecast.expanding`
+
+
+
+
+
+---
+
+
+
+## <kbd>function</kbd> `expanding_mean`
+
+```python
+expanding_mean(x: ndarray) → ndarray
+```
+
+Compute the expanding_mean of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the expanding statistic 
+
+
+---
+
+
+
+## <kbd>function</kbd> `expanding_std`
+
+```python
+expanding_std(x: ndarray) → ndarray
+```
+
+Compute the expanding_std of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the expanding statistic 
+
+
+---
+
+
+
+## <kbd>function</kbd> `expanding_min`
+
+```python
+expanding_min(x: ndarray) → ndarray
+```
+
+Compute the expanding_min of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the expanding statistic 
+
+
+---
+
+
+
+## <kbd>function</kbd> `expanding_max`
+
+```python
+expanding_max(x: ndarray) → ndarray
+```
+
+Compute the expanding_max of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the expanding statistic 
+
+
+---
+
+
+
+## <kbd>function</kbd> `expanding_quantile`
+
+```python
+expanding_quantile(x: ndarray, p: float) → ndarray
+```
+
+Compute the expanding_quantile of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+ - <b>`p`</b> (float):  Quantile to compute. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the expanding statistic 
+
+
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

coreforecast/exponentially_weighted.mdx

@@ -0,0 +1,41 @@
+
+
+
+
+# <kbd>module</kbd> `coreforecast.exponentially_weighted`
+
+
+
+
+
+---
+
+
+
+## <kbd>function</kbd> `exponentially_weighted_mean`
+
+```python
+exponentially_weighted_mean(x: ndarray, alpha: float) → ndarray
+```
+
+Compute the exponentially weighted mean of the input array. 
+
+
+
+**Args:**
+
+ - <b>`x`</b> (np.ndarray):  Input array. 
+ - <b>`alpha`</b> (float):  Weight parameter. 
+
+
+
+**Returns:**
+
+ - <b>`np.ndarray`</b>:  Array with the exponentially weighted mean. 
+
+
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

coreforecast/grouped_array.mdx

@@ -0,0 +1,16 @@
+
+
+
+
+# <kbd>module</kbd> `coreforecast.grouped_array`
+
+
+
+
+
+
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

coreforecast/index.mdx

@@ -0,0 +1,58 @@
+---
+description: Fast implementations of common forecasting routines
+title: "coreforecast"
+---
+## Motivation
+At Nixtla we have implemented several libraries to deal with time series data. We often have to apply some transformation over all of the series, which can prove time consuming even for simple operations like performing some kind of scaling.
+
+We've used [numba](https://numba.pydata.org/) to speed up our expensive computations, however that comes with other issues such as cold starts and more dependencies (LLVM). That's why we developed this library, which implements several operators in C++ to transform time series data (or other kind of data that can be thought of as independent groups), with the possibility to use multithreading to get the best performance possible.
+
+You probably won't need to use this library directly but rather use one of our higher level libraries like [mlforecast](https://nixtlaverse.nixtla.io/mlforecast/docs/how-to-guides/lag_transforms_guide.html#built-in-transformations-experimental), which will use this library under the hood. If you're interested on using this library directly (only depends on numpy) you should continue reading.
+
+## Installation
+
+### PyPI
+```python
+pip install coreforecast
+```
+
+### conda-forge
+```python
+conda install -c conda-forge coreforecast
+```
+
+## Minimal example
+The base data structure is the "grouped array" which holds two numpy 1d arrays:
+
+* **data**: values of the series.
+* **indptr**: series boundaries such that `data[indptr[i] : indptr[i + 1]]` returns the `i-th` series. For example, if you have two series of sizes 5 and 10 the indptr would be [0, 5, 15].
+
+```python
+import numpy as np
+from coreforecast.grouped_array import GroupedArray
+
+data = np.arange(10)
+indptr = np.array([0, 3, 10])
+ga = GroupedArray(data, indptr)
+```
+
+Once you have this structure you can run any of the provided transformations, for example:
+
+```python
+from coreforecast.lag_transforms import ExpandingMean
+from coreforecast.scalers import LocalStandardScaler
+
+exp_mean = ExpandingMean(lag=1).transform(ga)
+scaler = LocalStandardScaler().fit(ga)
+standardized = scaler.transform(ga)
+```
+
+## Single-array functions
+We've also implemented some functions that work on single arrays, you can refer to the following pages:
+
+* [differences](https://nixtlaverse.nixtla.io/coreforecast/differences)
+* [scalers](https://nixtlaverse.nixtla.io/coreforecast/scalers)
+* [seasonal](https://nixtlaverse.nixtla.io/coreforecast/seasonal)
+* [rolling](https://nixtlaverse.nixtla.io/coreforecast/rolling)
+* [expanding](https://nixtlaverse.nixtla.io/coreforecast/expanding)
+* [exponentially weighted](https://nixtlaverse.nixtla.io/coreforecast/exponentially_weighted)