├── .gitignore
├── LICENSE
├── MANIFEST.in
├── README.md
├── examples
    ├── application_example_allan_variance.html
    ├── application_example_allan_variance.ipynb
    ├── overview_of_noise_sources.html
    └── overview_of_noise_sources.ipynb
├── pyplnoise.py
├── setup.cfg
└── setup.py


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | *.egg-info/
 24 | .installed.cfg
 25 | *.egg
 26 | MANIFEST
 27 | 
 28 | # PyInstaller
 29 | #  Usually these files are written by a python script from a template
 30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 31 | *.manifest
 32 | *.spec
 33 | 
 34 | # Installer logs
 35 | pip-log.txt
 36 | pip-delete-this-directory.txt
 37 | 
 38 | # Unit test / coverage reports
 39 | htmlcov/
 40 | .tox/
 41 | .coverage
 42 | .coverage.*
 43 | .cache
 44 | nosetests.xml
 45 | coverage.xml
 46 | *.cover
 47 | .hypothesis/
 48 | .pytest_cache/
 49 | 
 50 | # Translations
 51 | *.mo
 52 | *.pot
 53 | 
 54 | # Django stuff:
 55 | *.log
 56 | local_settings.py
 57 | db.sqlite3
 58 | 
 59 | # Flask stuff:
 60 | instance/
 61 | .webassets-cache
 62 | 
 63 | # Scrapy stuff:
 64 | .scrapy
 65 | 
 66 | # Sphinx documentation
 67 | docs/_build/
 68 | 
 69 | # PyBuilder
 70 | target/
 71 | 
 72 | # Jupyter Notebook
 73 | .ipynb_checkpoints
 74 | 
 75 | # pyenv
 76 | .python-version
 77 | 
 78 | # celery beat schedule file
 79 | celerybeat-schedule
 80 | 
 81 | # SageMath parsed files
 82 | *.sage.py
 83 | 
 84 | # Environments
 85 | .env
 86 | .venv
 87 | env/
 88 | venv/
 89 | ENV/
 90 | env.bak/
 91 | venv.bak/
 92 | 
 93 | # Spyder project settings
 94 | .spyderproject
 95 | .spyproject
 96 | 
 97 | # Rope project settings
 98 | .ropeproject
 99 | 
100 | # mkdocs documentation
101 | /site
102 | 
103 | # mypy
104 | .mypy_cache/
105 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2019, Jan Waldmann
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this
10 |    list of conditions and the following disclaimer.
11 | 
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 |    this list of conditions and the following disclaimer in the documentation
14 |    and/or other materials provided with the distribution.
15 | 
16 | 3. Neither the name of the copyright holder nor the names of its
17 |    contributors may be used to endorse or promote products derived from
18 |    this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | graft examples
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Warning
 2 | This package is no longer maintained. Compatibility with recent versions of
 3 | Python, NumPy or SciPy cannot be guaranteed.
 4 | # pyplnoise
 5 | **Py**thon **p**ower **l**aw **noise** generates arbitrarily long streams of power law noise
 6 | using NumPy and SciPy.
 7 | 
 8 | The noise is generated with shaping filters and the methodology closely follows
 9 | [Stephane Plaszczynski, Fluct. Noise Lett. 7: R–R13, 2007](https://doi.org/10.1142/S0219477507003635).
10 | You can also find the article on [arXiv:astro-ph/0510081](https://arxiv.org/abs/astro-ph/0510081).
11 | 
12 | **pyplnoise** consists of a single module providing classes implementing the following
13 | noise sources:
14 | * general 1/f<sup>&alpha;</sup> power law noise with upper and lower frequency
15 |   limits (class `AlphaNoise`),
16 | * a fast red (Brownian) noise generator with a lower frequency limit (class `RedNoise`),
17 | * a convenience alias for pink noise (aka 1/f noise; class `PinkNoise`),
18 | * and of course white noise (class `WhiteNoise`).
19 | 
20 | ## Quick example
21 | The interface is very simple: just instantiate one of the above classes and run
22 | `get_sample()` to retrieve a single sample or `get_series(npts)` to
23 | retrieve an array of `npts` samples. Detailed interface documentation is available in the code.
24 | 
25 | ```python
26 | import pyplnoise
27 | import numpy as np
28 | 
29 | fs = 10. # sampling frequency in Hz
30 | 
31 | # instantiate a noise source with lower frequency limit 1e-3 Hz,
32 | # upper frequency limit 5 Hz and 1/f^1.5 power spectrum
33 | noisegen = pyplnoise.AlphaNoise(fs, 1e-3, fs/2., alpha=1.5, seed=42)
34 | 
35 | one_sample = noisegen.get_sample()
36 | many_samples = noisegen.get_series(100000)
37 | ```
38 | 
39 | ## Detailed examples
40 | Jupyter notebooks are provided in the [/examples](https://github.com/janwaldmann/pyplnoise/tree/master/examples) directory:
41 | 1. [Overview of the noise sources and their properties](https://github.com/janwaldmann/pyplnoise/tree/master/examples/overview_of_noise_sources.ipynb)
42 | 2. [Application example: modeling the random signal errors of a gyroscope (Allan variance
43 |    of synthetic noise)](https://github.com/janwaldmann/pyplnoise/tree/master/examples/application_example_allan_variance.ipynb)
44 | 
45 | ## Installation
46 | ### Dependencies
47 | * NumPy &ge; 1.17 (see NEP 19)
48 | * SciPy &ge; 1.3
49 | 
50 | ### Installing from [PyPI](https://pypi.org/project/pyplnoise/)
51 | ```python
52 | pip install pyplnoise
53 | ```
54 | 
55 | ### Installing directly from GitHub
56 | Download the release tarball and run
57 | ```python
58 | python setup.py install
59 | ```
60 | 
61 | Because everything is contained in the module `pyplnoise`, you can alternatively just copy
62 | the module and the LICENSE file into your project.
63 | 
64 | ## You may find pyplnoise useful, if...
65 | * ...you're looking to generate 1/f<sup>&alpha;</sup> noise with very long correlation
66 |   times (frequencies &ll; 10<sup>-7</sup> Hz); particularly if your machine has limited
67 |   memory resources.
68 | * ...you like to superimpose many colored noise sources, possibly sampled at different
69 |   frequencies and possessing different bandwidths.
70 | 
71 | ## You may *not* find pyplnoise useful, if...
72 | * ...you're looking for a pink noise source for your software synthesizer or other audio stuff.
73 |   There are lots of interesting solutions for such applications, notably
74 |   "[A New Shade of Pink](https://github.com/Stenzel/newshadeofpink)",
75 |   the [Voss-McCartney Algorithm, which is also available in Python](https://www.dsprelated.com/showarticle/908.php)
76 |   and [some highly specialized filters](http://www.firstpr.com.au/dsp/pink-noise/).
77 | * ...you want to generate finite 1/f<sup>&alpha;</sup> noise streams with relatively short
78 |   correlation times (frequencies &ge; 10<sup>-7</sup> Hz). In such a case [Fourier transform
79 |   methods](https://github.com/felixpatzelt/colorednoise) are tractable and in some cases these
80 |   methods deliver higher quality results than the shaping filters used by **pyplnoise**.
81 | 
82 | 


--------------------------------------------------------------------------------
/examples/application_example_allan_variance.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Application Example: Gyroscope Allan Variance"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "The signals of, e.g., angular rate sensors contain white noise along with colored noise resulting from a variety of sources. With the ``pyplnoise``module, this noise can be generated and added on top of the deterministic sensor errors in a sensor model. Such a sensor model can be used for example for the simulation of a Kalman filter accommodating correlated noise terms.\n",
 15 |     "\n",
 16 |     "In the code below it is outlined how you can use ``pyplnoise`` to approximate the Allan variance of a real yaw rate sensor. Familiarity with the IEEE Standard 952 is helpful."
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {},
 23 |    "outputs": [],
 24 |    "source": [
 25 |     "%matplotlib inline\n",
 26 |     "import pyplnoise\n",
 27 |     "import allan\n",
 28 |     "import numpy as np\n",
 29 |     "import matplotlib.pyplot as plt"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "markdown",
 34 |    "metadata": {},
 35 |    "source": [
 36 |     "The angular rate sensor is described by the quantities $N$ (angle random walk), $B$ (bias instability) and $K$ (rate random walk) from the IEEE Std 952. The values prescribed here approximate the properties of a Bosch SMI130 yaw rate sensor."
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": 2,
 42 |    "metadata": {},
 43 |    "outputs": [],
 44 |    "source": [
 45 |     "N = 5e-3 # °/sqrt(s) = 0.3 °/sqrt(h)\n",
 46 |     "B = 7e-4 # °/s = 2.5 °/h\n",
 47 |     "K = 6e-6 # °/s/sqrt(s)"
 48 |    ]
 49 |   },
 50 |   {
 51 |    "cell_type": "markdown",
 52 |    "metadata": {},
 53 |    "source": [
 54 |     "Define the sampling rate ``fs`` and initialize noise sources:"
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": 3,
 60 |    "metadata": {},
 61 |    "outputs": [],
 62 |    "source": [
 63 |     "fs = 10.\n",
 64 |     "npts = 70000000\n",
 65 |     "t = np.linspace(0., npts/fs, num=npts)"
 66 |    ]
 67 |   },
 68 |   {
 69 |    "cell_type": "code",
 70 |    "execution_count": 4,
 71 |    "metadata": {},
 72 |    "outputs": [],
 73 |    "source": [
 74 |     "whnoise = pyplnoise.WhiteNoise(fs)\n",
 75 |     "rdnoise = pyplnoise.RedNoise(fs, 1e-8)\n",
 76 |     "pknoise = pyplnoise.PinkNoise(fs, 1e-6, fs/2.)"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "markdown",
 81 |    "metadata": {},
 82 |    "source": [
 83 |     "Now create an artifical sensor noise signal $w_{noise}$ from the individual noise sources denoted by $\\xi$. The noise is additive and the coefficients $N$, $B$ and $K$ from the IEEE Std 952 enter as follows:\n",
 84 |     "\n",
 85 |     "$$w_{noise} = N\\xi_{white} + \\frac{B}{\\sqrt{2\\pi}}\\xi_{pink} + \\frac{K}{2\\pi}\\xi_{red}$$"
 86 |    ]
 87 |   },
 88 |   {
 89 |    "cell_type": "code",
 90 |    "execution_count": 5,
 91 |    "metadata": {},
 92 |    "outputs": [],
 93 |    "source": [
 94 |     "w = N * whnoise.get_series(npts) + B / np.sqrt(2. * np.pi) * pknoise.get_series(npts) +\\\n",
 95 |     "K / (2. * np.pi) * rdnoise.get_series(npts)"
 96 |    ]
 97 |   },
 98 |   {
 99 |    "cell_type": "markdown",
100 |    "metadata": {},
101 |    "source": [
102 |     "Now calculate the Allan variance. The module ``allan`` is not provided by ``pyplnoise``, but many similar codes can be found on pypi."
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "code",
107 |    "execution_count": 6,
108 |    "metadata": {},
109 |    "outputs": [],
110 |    "source": [
111 |     "tau, avar, adev, error_adev_pct = allan.allan_variance(w, dt=1./fs, n_clusters=8000,\n",
112 |     "                                                       verbose=False)"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": 7,
118 |    "metadata": {},
119 |    "outputs": [],
120 |    "source": [
121 |     "# omit values with insufficient statistical quality\n",
122 |     "idx_valid = error_adev_pct < 10\n",
123 |     "avar_valid = avar[idx_valid]\n",
124 |     "adev_valid = adev[idx_valid]\n",
125 |     "tau_valid = tau[idx_valid]"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "markdown",
130 |    "metadata": {},
131 |    "source": [
132 |     "Here's how the calculated Allan deviation looks like."
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "code",
137 |    "execution_count": 15,
138 |    "metadata": {},
139 |    "outputs": [
140 |     {
141 |      "data": {
142 |       "image/png": "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\n",
143 |       "text/plain": [
144 |        "<Figure size 720x576 with 1 Axes>"
145 |       ]
146 |      },
147 |      "metadata": {
148 |       "needs_background": "light"
149 |      },
150 |      "output_type": "display_data"
151 |     }
152 |    ],
153 |    "source": [
154 |     "plt.rcParams.update({'font.size': 14})\n",
155 |     "fig = plt.figure(figsize=(10,8))\n",
156 |     "ax = fig.gca()\n",
157 |     "ax.loglog(tau_valid, adev_valid*3600)\n",
158 |     "ax.set_xlabel(\"Cluster length (s)\")\n",
159 |     "ax.set_ylabel(\"Allan deviation (°/h)\")\n",
160 |     "ax.grid(True, which='major')\n",
161 |     "ax.grid(True, which='minor', axis='y')"
162 |    ]
163 |   },
164 |   {
165 |    "cell_type": "markdown",
166 |    "metadata": {},
167 |    "source": [
168 |     "Let's extract the properties $N$, $B$ and $K$ automatically:"
169 |    ]
170 |   },
171 |   {
172 |    "cell_type": "code",
173 |    "execution_count": 9,
174 |    "metadata": {},
175 |    "outputs": [
176 |     {
177 |      "name": "stdout",
178 |      "output_type": "stream",
179 |      "text": [
180 |       "Extracted angle random walk: N = 0.005027 °/s/sqrt(Hz) = 0.30159 °/sqrt(h)\n",
181 |       "Extracted bias instability: B = 0.0007754 °/s = 2.79154 °/h\n",
182 |       "Extracted rate random walk: K = 6.792e-06 °/s^(3/2) = 1.46705 °/h^(3/2)\n"
183 |      ]
184 |     }
185 |    ],
186 |    "source": [
187 |     "noise_density, a_n_fit, b_n_fit = allan.read_noise_density(adev_valid, tau_valid)\n",
188 |     "print(\"Extracted angle random walk: N = {:.4g} °/s/sqrt(Hz) = {:.5f} °/sqrt(h)\"\n",
189 |     "      .format(noise_density, noise_density*60))\n",
190 |     "bias_instability = allan.read_bias_instability(adev_valid, tau_valid)\n",
191 |     "print(\"Extracted bias instability: B = {:.4g} °/s = {:.5f} °/h\"\n",
192 |     "      .format(bias_instability, bias_instability*3600))\n",
193 |     "rate_random_walk, a_k_fit, b_k_fit = allan.read_rate_random_walk(adev_valid, tau_valid)\n",
194 |     "print(\"Extracted rate random walk: K = {:.4g} °/s^(3/2) = {:.5f} °/h^(3/2)\"\n",
195 |     "      .format(rate_random_walk, rate_random_walk*3600**(3/2)))"
196 |    ]
197 |   },
198 |   {
199 |    "cell_type": "markdown",
200 |    "metadata": {},
201 |    "source": [
202 |     "If you rather prefer to find these values manually, you can read off the value of the red line at $\\tau = 1$ to get $N$. The value of the green line at $\\tau = 3$ is equal to $K$, and multiplication of the global minimum by $\\sqrt{\\frac{\\pi}{2\\ln 2}}\\approx1/0.664$ yields $B$."
203 |    ]
204 |   },
205 |   {
206 |    "cell_type": "code",
207 |    "execution_count": 16,
208 |    "metadata": {},
209 |    "outputs": [
210 |     {
211 |      "data": {
212 |       "image/png": "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\n",
213 |       "text/plain": [
214 |        "<Figure size 864x720 with 1 Axes>"
215 |       ]
216 |      },
217 |      "metadata": {
218 |       "needs_background": "light"
219 |      },
220 |      "output_type": "display_data"
221 |     }
222 |    ],
223 |    "source": [
224 |     "fit_vals_n = np.power(10.0, a_n_fit * np.log10(tau_valid) + b_n_fit)\n",
225 |     "fit_vals_k = np.power(10.0, a_k_fit * np.log10(tau_valid) + b_k_fit)\n",
226 |     "fig = plt.figure(figsize=(12,10))\n",
227 |     "ax = fig.gca()\n",
228 |     "ax.loglog(tau_valid, adev_valid)\n",
229 |     "ax.loglog(tau_valid, fit_vals_n, color='red')\n",
230 |     "ax.loglog(tau_valid, fit_vals_k, color='green')\n",
231 |     "ax.set_xlabel(\"Cluster length (s)\")\n",
232 |     "ax.set_ylabel(\"Allan deviation (°/s)\")\n",
233 |     "ax.grid(True, which='both')"
234 |    ]
235 |   }
236 |  ],
237 |  "metadata": {},
238 |  "nbformat": 4,
239 |  "nbformat_minor": 2
240 | }
241 | 


--------------------------------------------------------------------------------
/pyplnoise.py:
--------------------------------------------------------------------------------
  1 | """Noise generators for long streams of 1/f^alpha noise.
  2 | 
  3 | The time domain methods used here follow Stephane Plaszczynski, Fluct.
  4 | Noise Lett. 7: R-R13, 2007. DOI: 10.1142/S0219477507003635, see also
  5 | https://arxiv.org/abs/astro-ph/0510081. The code sticks to the notation
  6 | in this article (which is different to the SciPy docs).
  7 | 
  8 | Examples and documentation are available on GitHub:
  9 | https://github.com/janwaldmann/pyplnoise
 10 | """
 11 | 
 12 | from typing import List, Optional, Tuple
 13 | 
 14 | import numpy as np
 15 | from scipy import signal
 16 | 
 17 | 
 18 | class WhiteNoise:
 19 |     """White noise generator (constant power spectrum)."""
 20 | 
 21 |     @property
 22 |     def fs(self) -> float:
 23 |         """Get the sampling frequency."""
 24 |         return self._fs
 25 | 
 26 |     @property
 27 |     def rms(self) -> float:
 28 |         """Get the noise signal RMS value."""
 29 |         return self._rms
 30 | 
 31 |     def __init__(self,
 32 |                  f_sample: float,
 33 |                  psd: float = 1.,
 34 |                  seed: Optional[int] = None) -> None:
 35 |         """Create a WhiteNoise instance.
 36 | 
 37 |         Args:
 38 |             f_sample: sampling frequency in Hz.
 39 |             psd: constant value of the two-sided power
 40 |                 spectral density. The RMS value of the generated noise
 41 |                 is sqrt(f_sample x psd).
 42 |             seed: seed for the random number generator. If none is provided,
 43 |                 entropy from the system will be used.
 44 |         """
 45 |         self._fs = f_sample
 46 |         self._rms = np.sqrt(f_sample * psd)
 47 |         self._rng = np.random.default_rng(seed)
 48 | 
 49 |     def get_sample(self) -> float:
 50 |         """Retrieve a single sample."""
 51 |         return self._rng.normal(loc=0., scale=self.rms)
 52 | 
 53 |     def get_series(self, npts: int) -> np.ndarray:
 54 |         """Retrieve an array of npts samples."""
 55 |         if npts > np.iinfo(int).max:
 56 |             raise ValueError("""Argument 'npts' must be an integer <= {}.
 57 | If you want to obtain more samples, run get_series() several times and
 58 | concatenate the results.""".format(np.iinfo(int).max))
 59 |         return self._rng.normal(loc=0., scale=self.rms, size=npts)
 60 | 
 61 | 
 62 | class RedNoise:
 63 |     """Red (Brownian) noise generator (1/f^2 power spectrum).
 64 | 
 65 |     The two-sided power spectral density (PSD) is scaled such that
 66 |     PSD(f = 1 Hz) = 1. Below f_min, the noise is white.
 67 |     """
 68 | 
 69 |     @property
 70 |     def fs(self) -> float:
 71 |         """Get the sampling rate."""
 72 |         return self._fs
 73 | 
 74 |     @property
 75 |     def fmin(self) -> float:
 76 |         """Get the lower cutoff frequency."""
 77 |         return self._fmin
 78 | 
 79 |     def __init__(self,
 80 |                  f_sample: float,
 81 |                  f_min: float,
 82 |                  init_filter: bool = True,
 83 |                  seed: Optional[int] = None) -> None:
 84 |         """Create a RedNoise instance.
 85 | 
 86 |         Args:
 87 |             f_sample: sampling frequency in Hz.
 88 |             f_min: frequency cutoff in Hz. Below f_min, the noise
 89 |                 will be white.
 90 |             init_filter: settle filter during object initialization. This
 91 |                 might take some time depending on the magnitude of the
 92 |                 ratio f_sample/f_min. Default and highly recommended: True.
 93 |             seed: seed for the random number generator. If none is
 94 |                 provided, entropy from the system will be used.
 95 | 
 96 |         """
 97 |         self._fs = f_sample
 98 |         self._fmin = f_min
 99 |         self._whitenoise = WhiteNoise(self.fs, psd=1., seed=seed)
100 |         self._scaling = 1. / (self.fs * self.fmin)
101 |         self._a = np.array([2. * np.pi * self.fmin])
102 |         self._b = np.array(
103 |             [1., -1. * np.exp(-2. * np.pi * self.fmin / self.fs)])
104 |         self._zi = signal.lfilter_zi(self._a,
105 |                                      self._b) * self._whitenoise.get_sample()
106 |         if init_filter:
107 |             npts_req = np.ceil(2. * self.fs / self.fmin)
108 |             # safeguard for machines with small memory
109 |             npts_per_run_max = 150000000
110 |             if npts_req > npts_per_run_max:
111 |                 for i in range(
112 |                         np.ceil(npts_req / npts_per_run_max).astype(int)):
113 |                     _ = self.get_series(npts_per_run_max)
114 |             else:
115 |                 _ = self.get_series(int(npts_req))
116 | 
117 |     def get_sample(self) -> np.float64:
118 |         """Retrieve a single sample."""
119 |         sample, self._zi = signal.lfilter(self._a,
120 |                                           self._b,
121 |                                           np.array(
122 |                                               [self._whitenoise.get_sample()]),
123 |                                           zi=self._zi)
124 |         return sample[0] * self._scaling
125 | 
126 |     def get_series(self, npts: int) -> np.ndarray:
127 |         """Retrieve an array of npts samples."""
128 |         if npts > np.iinfo(int).max:
129 |             raise ValueError("""Argument 'npts' must be an integer <= {}.
130 | If you want to obtain more samples, run get_series() several times and
131 | concatenate the results.""".format(np.iinfo(int).max))
132 |         samples, self._zi = signal.lfilter(self._a,
133 |                                            self._b,
134 |                                            self._whitenoise.get_series(npts),
135 |                                            zi=self._zi)
136 |         return samples * self._scaling
137 | 
138 | 
139 | class AlphaNoise:
140 |     """Colored noise noise generator (arbitrary 1/f^alpha power spectrum).
141 | 
142 |     The two-sided power spectral density (PSD) is scaled such that
143 |     PSD(f = 1 Hz) = 1. The noise generator has user-specified lower and
144 |     upper cutoff frequencies. Below and above these frequencies, the
145 |     generated noise is white.
146 |     """
147 | 
148 |     @property
149 |     def fs(self) -> float:
150 |         """Get the sampling rate."""
151 |         return self._fs
152 | 
153 |     @property
154 |     def fmin(self) -> float:
155 |         """Get the lower cutoff frequency."""
156 |         return self._fmin
157 | 
158 |     @property
159 |     def fmax(self) -> float:
160 |         """Get the upper cutoff frequency."""
161 |         return self._fmax
162 | 
163 |     @property
164 |     def alpha(self) -> float:
165 |         """Get the exponent of the 1/f^alpha power spectrum."""
166 |         return self._alpha
167 | 
168 |     def __init__(self,
169 |                  f_sample: float,
170 |                  f_min: float,
171 |                  f_max: float,
172 |                  alpha: float,
173 |                  init_filter: bool = True,
174 |                  seed: Optional[int] = None) -> None:
175 |         """Create an AlphaNoise instance.
176 | 
177 |         Args:
178 |             f_sample: sampling frequency in Hz.
179 |             f_min: lower frequency cutoff in Hz. Below f_min, the noise
180 |                 will be white.
181 |             f_max: upper frequency cutoff in Hz. Above f_max, the noise
182 |                 will be white.
183 |             alpha: exponent of the 1/f^alpha power spectrum. Must be in the
184 |                 interval [0.01, 2.0].
185 |             init_filter: settle filter during object initialization. This
186 |                 might take some time depending on the magnitude of the
187 |                 ratio f_sample/f_min. Default and highly recommended: True.
188 |             seed: seed for the random number generator. If none is
189 |                 provided, entropy from the system will be used.
190 |         """
191 |         if alpha > 2. or alpha < 0.01:
192 |             raise ValueError(
193 |                 "The exponent must be in the range 0.01 <= alpha <= 2.")
194 |         if f_sample < 2. * f_max:
195 |             raise ValueError(
196 |                 "The sampling rate must be at least 2 x f_max (= {}).".format(
197 |                     2. * f_max))
198 |         self._fs = f_sample
199 |         self._fmin = f_min
200 |         self._fmax = f_max
201 |         self._alpha = alpha
202 |         self._whitenoise = WhiteNoise(self.fs, psd=1., seed=seed)
203 |         log_w_min = np.log10(2. * np.pi * self.fmin)
204 |         log_w_max = np.log10(2. * np.pi * self.fmax)
205 |         self._num_spectra = np.ceil(4.5 * (log_w_max - log_w_min)).astype(int)
206 |         dp = (log_w_max - log_w_min) / self._num_spectra
207 |         self._a: List[np.ndarray] = [None] * self._num_spectra
208 |         self._b: List[np.ndarray] = [None] * self._num_spectra
209 |         self._zi: List[np.ndarray] = [None] * self._num_spectra
210 |         for i in range(0, self._num_spectra):
211 |             log_p_i = log_w_min + dp * 0.5 * ((2. * i + 1.) - self.alpha / 2.)
212 |             filter_f_min = np.power(10., log_p_i) / (2. * np.pi)
213 |             filter_f_max = np.power(10., log_p_i +
214 |                                     (dp * self.alpha / 2.)) / (2. * np.pi)
215 |             if i == 0:
216 |                 self._fmin = filter_f_min
217 |             a0, a1, b1 = self._calc_filter_coeff(filter_f_min, filter_f_max)
218 |             self._a[i] = np.array([a0, a1])
219 |             self._b[i] = np.array([1., -1. * b1])
220 |             self._zi[i] = signal.lfilter_zi(self._a[i], self._b[i])
221 |         self._fmax = filter_f_max
222 |         self._scaling = 1. / np.power(self.fmax, self.alpha / 2.)
223 |         if init_filter:
224 |             npts_req = np.ceil(2. * self.fs / self.fmin)
225 |             # safeguard for machines with small memory
226 |             npts_per_run_max = 150000000
227 |             if npts_req > npts_per_run_max:
228 |                 for i in range(
229 |                         np.ceil(npts_req / npts_per_run_max).astype(int)):
230 |                     _ = self.get_series(npts_per_run_max)
231 |             else:
232 |                 _ = self.get_series(int(npts_req))
233 | 
234 |     def get_sample(self) -> np.float64:
235 |         """Retrieve a single sample."""
236 |         sample = np.array([self._whitenoise.get_sample()])
237 |         for i in range(0, self._num_spectra):
238 |             sample, self._zi[i] = signal.lfilter(self._a[i],
239 |                                                  self._b[i],
240 |                                                  sample,
241 |                                                  zi=self._zi[i])
242 |         return sample[0] * self._scaling
243 | 
244 |     def get_series(self, npts: int) -> np.ndarray:
245 |         """Retrieve an array of npts samples."""
246 |         if npts > np.iinfo(int).max:
247 |             raise ValueError("""Argument 'npts' must be an integer <= {}.
248 | If you want to obtain more samples, run get_series() several times and
249 | concatenate the results.""".format(np.iinfo(int).max))
250 |         samples = self._whitenoise.get_series(npts)
251 |         for i in range(0, self._num_spectra):
252 |             samples, self._zi[i] = signal.lfilter(self._a[i],
253 |                                                   self._b[i],
254 |                                                   samples,
255 |                                                   zi=self._zi[i])
256 |         return samples * self._scaling
257 | 
258 |     def _calc_filter_coeff(self, f_min: float,
259 |                            f_max: float) -> Tuple[float, float, float]:
260 |         a0 = (self.fs + f_max * np.pi) / (self.fs + f_min * np.pi)
261 |         a1 = -1. * (self.fs - f_max * np.pi) / (self.fs + f_min * np.pi)
262 |         b1 = (self.fs - f_min * np.pi) / (self.fs + f_min * np.pi)
263 |         return (a0, a1, b1)
264 | 
265 | 
266 | class PinkNoise(AlphaNoise):
267 |     """Pink noise generator (1/f power spectrum)."""
268 | 
269 |     @property
270 |     def fs(self) -> float:
271 |         """Get the sampling rate."""
272 |         return self._fs
273 | 
274 |     @property
275 |     def fmin(self) -> float:
276 |         """Get the lower cutoff frequency."""
277 |         return self._fmin
278 | 
279 |     @property
280 |     def fmax(self) -> float:
281 |         """Get the upper cutoff frequency."""
282 |         return self._fmax
283 | 
284 |     def __init__(self,
285 |                  f_sample: float,
286 |                  f_min: float,
287 |                  f_max: float,
288 |                  init_filter: bool = True,
289 |                  seed: Optional[int] = None) -> None:
290 |         """Create a PinkNoise instance."""
291 |         self._fs = f_sample
292 |         self._fmin = f_min
293 |         self._fmax = f_max
294 |         AlphaNoise.__init__(self, f_sample, f_min, f_max, 1., init_filter,
295 |                             seed)
296 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
 1 | [yapf]
 2 | based_on_style = pep8
 3 | blank_line_before_nested_class_or_def = True
 4 | 
 5 | [flake8]
 6 | ignore = E501,W504
 7 | 
 8 | [mypy-numpy.*]
 9 | ignore_missing_imports = True
10 | 
11 | [mypy-scipy.*]
12 | ignore_missing_imports = True
13 | 
14 | [mypy-setuptools.*]
15 | ignore_missing_imports = True
16 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | import setuptools
 2 | 
 3 | with open("README.md", "r") as f:
 4 |     LONG_DESC = f.read()
 5 | 
 6 | setuptools.setup(
 7 |     name="pyplnoise",
 8 |     version="1.4",
 9 |     description="Arbitrarily long streams of power law noise using NumPy and SciPy.",
10 |     long_description=LONG_DESC,
11 |     long_description_content_type="text/markdown",
12 |     author="Jan Waldmann",
13 |     author_email="dev@pgmail.org",
14 |     py_modules=['pyplnoise'],
15 |     license='BSD',
16 |     url='https://github.com/janwaldmann/pyplnoise',
17 |     python_requires='>=3.7,<3.99',
18 |     install_requires=[
19 |         "numpy >= 1.17.0",
20 |         "scipy >= 1.3.0",
21 |     ],
22 |     classifiers=[
23 |         "Programming Language :: Python :: 3",
24 |         "License :: OSI Approved :: BSD License",
25 |         "Operating System :: OS Independent",
26 |         "Development Status :: 7 - Inactive",
27 |         "Intended Audience :: Developers",
28 |         "Topic :: Scientific/Engineering :: Physics",
29 |         "Topic :: Scientific/Engineering :: Information Analysis"
30 |     ],
31 | )
32 | 


--------------------------------------------------------------------------------