Transferred from Matlab repository

Author: open-source-modelling

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Gregor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,41 @@
+A block resampling method used for weakly-dependent stationary time-series data proposed in the 1994 paper by [Politis & Romano](https://www.researchgate.net/publication/254287565_The_Stationary_Bootstrap).
+
+## Problem
+When using non-parametric tools to generate counterfactual scenarios or empirical distributions, bootstrapping methods proved to be a powerful and easy-to-use tools. However, the bootstrap in its simplest implementation assumes a time-series in which observations are independent. In a lot of applications this is not the case.
+
+An example of this is interest rate modelling when business cycles need to be considered. The presence of business cycles makes the time-series weakly time dependent. To account for this, block-resampling techniques are used.
+
+## Solution
+
+Stationary bootstrap is a block-resampling technique that relaxes the assumption of a fixed length of a sampling block. The user still needs to specify an average length, but because this is true only on average, shorter/longer blocks are also present in the final sample.
+The algorithm works by randomly selecting a starting point in the time-series and at each step it either increases the block size by one or selects a new block with a new starting point. This choice happens with a fixed probability governed by the parametrisation.
+
+### Input
+ - A time-series that you want to bootstrap
+ - The parameter m describing the average duration of the blocks in the sample
+ - The length of the output sample
+ 
+ ### Output
+ - Vector of bootstrapped values of specified length
+
+## Getting started
+
+Given the time-series with observed values 0.4, 0.2, 0.1, 0.4, 0.3, 0.1, 0.3, 0.4, 0.2, 0.5, 0.1, and 0.2, the user is looking to bootstrap a new sample of length 9 where the average block is of size 4. 
+
+```python
+import numpy as np
+from StationaryBootstrap import StationaryBootstrap
+
+# Original time-series
+data = np.array([0.4,0.2,0.1,0.4,0.3,0.1,0.3,0.4,0.2,0.5,0.1,0.2])
+
+# Average length of the block
+m = 4
+
+# Length of output sample
+sampleLength = 12
+
+ans = StationaryBootstrap(data, m, sampleLength)
+
+print(ans)
+```

StationaryBootstrap.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+def StationaryBootstrap(data: np.ndarray, m, sampleLength)-> np.ndarray:
+ """
+ Returns a bootstraped sample of the time-series "data" of length "sampleLength. 
+ The algorithm used is stationary bootstrap from 1994 Politis & Romano.
+ 
+ Args: 
+ data ... ndarray array. A single vector of numbers containing the time-series.
+ m ... floating number. Parameter to stationary bootstrap indicating the average length of each block in the sample.
+ sampleLength ... integer. Length of the bootstrapped sample returned as output.
+ 
+ Returns: 
+ sample ... ndarray array containing the final bootstraped sample.
+ 
+ Example of use:
+ >>> import numpy as np
+ >>> data = np.array([1,2,3,4,5,6,7,8,9,10])
+ >>> m = 4
+ >>> sampleLength = 12
+ >>> StationaryBootstrap(data, m, sampleLength)
+ Out[0]: array([[9.],
+ [3.],
+ [4.],
+ [5.],
+ [6.],
+ [7.],
+ [8.],
+ [7.],
+ [2.],
+ [3.],
+ [4.],
+ [2.]])
+
+ Original paper about stationary bootstrap:
+ Dimitris N. Politis & Joseph P. Romano (1994) The Stationary Bootstrap, Journal of the American Statistical 
+ Association, 89:428, 1303-1313, DOI: 10.1080/01621459.1994.10476870 
+
+ Implemented by Gregor Fabjan from Qnity Consultants on 12/11/2021.
+
+ """
+ accept = 1/m 
+ lenData = data.shape[0]
+
+ sampleIndex = np.random.randint(0,high =lenData,size=1);
+ sample = np.zeros((sampleLength,1))
+ for iSample in range(sampleLength):
+ if np.random.uniform(0,1,1)>=accept:
+ sampleIndex += 1
+ if sampleIndex >= lenData:
+ sampleIndex=0 
+ else:
+ sampleIndex = np.random.randint(0,high = lenData,size=1)
+
+ sample[iSample,0] = data[sampleIndex]
+ return sample