From 020a064c311db6543294b22fbcfc4b9ee7688c5c Mon Sep 17 00:00:00 2001 From: Fabi Date: Tue, 6 Aug 2024 19:15:08 +0200 Subject: [PATCH 01/11] moved url in pyproject.toml to suggested location --- pyproject.toml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 4bd7e79..dfb0d22 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,7 +8,7 @@ authors = [ {name = "Fabian Schmidt", email = "schmidtfa91@gmail.com"}, {name = "Thomas Hartmann", email = "thomas.hartmann@th-ht.de"} ] -homepage = "https://github.com/schmidtfa/pyrasa" + classifiers = [ 'Development Status :: 4 - Beta', 'Intended Audience :: Science/Research', @@ -24,6 +24,8 @@ dependencies = ["numpy", "pandas", "scipy>=1.12", "attrs"] [project.optional-dependencies] mne = ['mne'] +[project.urls] +repository = "https://github.com/schmidtfa/pyrasa" [build-system] requires = ["hatchling", "hatch-regex-commit"] From 9d140a5dcc7eb08d50b132403ee58e1f99536d5a Mon Sep 17 00:00:00 2001 From: Fabi Date: Tue, 6 Aug 2024 19:50:42 +0200 Subject: [PATCH 02/11] added example for generating custom slope fits --- examples/custom_fit_functions.ipynb | 303 ++++++++++++++++++++++++++++ examples/custom_fit_functions.py | 50 ----- pixi.lock | 2 +- 3 files changed, 304 insertions(+), 51 deletions(-) create mode 100644 examples/custom_fit_functions.ipynb delete mode 100644 examples/custom_fit_functions.py diff --git a/examples/custom_fit_functions.ipynb b/examples/custom_fit_functions.ipynb new file mode 100644 index 0000000..4af782a --- /dev/null +++ b/examples/custom_fit_functions.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Custom functions to model aperiodic signals\n", + "\n", + "Aperiodic changes in a power spectrum can be modeled using a variety of different linear models. This can be easily accomplished using scipy's curve_fit function.\n", + "`PyRASA` aims to give users both some preset models that are similar to what has been implemented in specparam, as well as ability to fit custom models.\n", + "The preset models are called `fixed` and `knee` and can be entered to the compute_slope method in the `IrasaSpectrum` returned by the `pyrasa.irasa` function.\n", + "However, users can also import the class `AbstractFitFun` from `pyrasa.utils.fit_funcs` and inherit from it. \n", + "Below we will illustrate how this is done and how the resultant child class can be used as a Custom fit function to model aperiodic signals.\n", + "\n", + "\n", + "First we simulated a signal with a spectral exponent of 1.5" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import scipy.signal as dsp\n", + "from pyrasa.utils.aperiodic_utils import compute_slope\n", + "from pyrasa.utils.fit_funcs import AbstractFitFun\n", + "from pyrasa import irasa\n", + "import numpy as np\n", + "from neurodsp.sim import sim_powerlaw\n", + "import pandas as pd\n", + "\n", + "n_secs = 60\n", + "fs=1000\n", + "f_range = [1.5, 150]\n", + "exponent = -1.5\n", + "\n", + "sig = sim_powerlaw(n_seconds=n_secs, fs=fs, exponent=exponent)\n", + "freqs, psd = dsp.welch(sig, fs, nperseg=int(4 * fs))\n", + "freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1])\n", + "psd, freqs = psd[freq_logical], freqs[freq_logical]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to simply overwrite the func method and enter it as a fit_func to either the `compute_slope` function imported from`from pyrasa.utils.aperiodic_utils`.\n", + "Or we can use the method of the `IrasaSpectrum` returned by the `pyrasa.irasa` function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class CustomFitFun(AbstractFitFun):\n", + " log10_aperiodic = True\n", + " log10_freq = True\n", + " \n", + " def func(self, x: np.ndarray, a: float, b: float) -> np.ndarray:\n", + " \"\"\"\n", + " Fixed fitting function.\n", + " Use this to model aperiodic activity without a spectral knee\n", + " \"\"\"\n", + " y_hat = a - b * x\n", + "\n", + " return y_hat\n", + " \n", + "\n", + "slope_fit = compute_slope(psd, freqs, fit_func=CustomFitFun)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abfit_typech_name
0-1.2240851.523086custom0
\n", + "
" + ], + "text/plain": [ + " a b fit_type ch_name\n", + "0 -1.224085 1.523086 custom 0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "slope_fit.aperiodic_params" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "slope_fit_2 = irasa(sig, fs=fs, band=f_range, psd_kwargs={'nperseg': 4 * fs}).compute_slope(fit_func=CustomFitFun)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abfit_typech_name
0-1.0425331.502152custom0
\n", + "
" + ], + "text/plain": [ + " a b fit_type ch_name\n", + "0 -1.042533 1.502152 custom 0" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "slope_fit_2.aperiodic_params" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mser_squaredBICAICfit_typech_name
00.0074810.978260-2899.955931-2908.733054custom0
00.0003050.999099-4803.801397-4812.578520custom0
\n", + "
" + ], + "text/plain": [ + " mse r_squared BIC AIC fit_type ch_name\n", + "0 0.007481 0.978260 -2899.955931 -2908.733054 custom 0\n", + "0 0.000305 0.999099 -4803.801397 -4812.578520 custom 0" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.concat([slope_fit.gof,\n", + " slope_fit_2.gof])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "default", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/custom_fit_functions.py b/examples/custom_fit_functions.py deleted file mode 100644 index 7ef2e0c..0000000 --- a/examples/custom_fit_functions.py +++ /dev/null @@ -1,50 +0,0 @@ -#%% -import scipy.signal as dsp -from pyrasa.utils.aperiodic_utils import compute_slope -from pyrasa.utils.fit_funcs import AbstractFitFun -import numpy as np -from neurodsp.sim import sim_powerlaw -from typing import Any - -n_secs = 60 -fs=500 -f_range = [1.5, 300] -exponent = -1.5 - -sig = sim_powerlaw(n_seconds=n_secs, fs=fs, exponent=exponent) - -# test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum -freqs, psd = dsp.welch(sig, fs, nperseg=int(4 * fs)) -freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) -psd, freqs = psd[freq_logical], freqs[freq_logical] - - -class CustomFitFun(AbstractFitFun): - def func(self, x: np.ndarray, a: float, b: float) -> np.ndarray: - """ - Specparams fixed fitting function. - Use this to model aperiodic activity without a spectral knee - """ - y_hat = a + b * x - - return y_hat - - @property - def curve_kwargs(self) -> dict[str, Any]: - aperiodic_nolog = 10**self.aperiodic_spectrum - off_guess = [aperiodic_nolog[0]] - exp_guess = [ - np.abs(np.log10(aperiodic_nolog[0] / aperiodic_nolog[-1]) / np.log10(self.freq[-1] / self.freq[0])) - ] - return { - 'maxfev': 10_000, - 'ftol': 1e-5, - 'xtol': 1e-5, - 'gtol': 1e-5, - 'p0': np.array(off_guess + exp_guess), - 'bounds': ((-np.inf, -np.inf), (np.inf, np.inf)), - } - -#%% -slope_fit = compute_slope(np.log10(psd), np.log10(freqs), fit_func=CustomFitFun) -# %% diff --git a/pixi.lock b/pixi.lock index 46a3615..5cd5666 100644 --- a/pixi.lock +++ b/pixi.lock @@ -28539,7 +28539,7 @@ packages: name: pyrasa version: 0.1.0.dev0 path: . - sha256: 39640bc3e1a4ead8752644076a356e607560548282bc8947616e21831a4d7587 + sha256: c5f6392cb2cf7ae255bb2526468a889d68bfaeaefabc20f2ec6cec4722953de5 requires_dist: - attrs - numpy From 8b5f85a1f7f9e83b12bec32db7ec8f9a0adacd77 Mon Sep 17 00:00:00 2001 From: Fabi Date: Wed, 7 Aug 2024 01:08:08 +0200 Subject: [PATCH 03/11] added examples --- examples/basic_func_fun.py | 64 ------ examples/check_irasa_mne.py | 189 ------------------ examples/custom_fit_functions.ipynb | 125 +++++++++--- examples/irasa_sprint.ipynb | 290 ++++++++++++++++++++++++++++ examples/irasa_sprint_example.py | 267 ------------------------- pyrasa/utils/fit_funcs.py | 6 +- 6 files changed, 394 insertions(+), 547 deletions(-) delete mode 100644 examples/basic_func_fun.py delete mode 100644 examples/check_irasa_mne.py create mode 100644 examples/irasa_sprint.ipynb delete mode 100644 examples/irasa_sprint_example.py diff --git a/examples/basic_func_fun.py b/examples/basic_func_fun.py deleted file mode 100644 index 294b711..0000000 --- a/examples/basic_func_fun.py +++ /dev/null @@ -1,64 +0,0 @@ -#%% -from neurodsp.sim import sim_combined -from neurodsp.utils import create_times -import numpy as np -import scipy.signal as dsp -import matplotlib.pyplot as plt -import pandas as pd -from pyrasa.irasa import irasa - - -fs = 500 -n_seconds = 60 -duration=2 -overlap=0.5 - -sim_components = {'sim_powerlaw': {'exponent' : -1}, - 'sim_oscillation': {'freq' : 10}} - - -sig = sim_combined(n_seconds=n_seconds, fs=fs, components=sim_components) -times = create_times(n_seconds=n_seconds, fs=fs) - -max_times = times < 1 -f, axes = plt.subplots(ncols=2, figsize=(8, 4)) -axes[0].plot(times[max_times], sig[max_times]) -axes[0].set_ylabel('Amplitude (a.u.)') -axes[0].set_xlabel('Time (s)') -freq, psd = dsp.welch(sig, fs=fs, nperseg=duration*fs, noverlap=duration*fs*overlap) -axes[1].loglog(freq, psd) -axes[1].set_ylabel('Power (a.u.)') -axes[1].set_xlabel('Frequency (Hz)') - -plt.tight_layout() - -#from pyrasa.irasa import irasa -#%% -irasa_result = irasa(sig, - fs=fs, - band=(1, 100), - psd_kwargs={'nperseg': duration*fs, - 'noverlap': duration*fs*overlap - }, - hset_info=(1, 2, 0.05)) - -f, axes = plt.subplots(ncols=2, figsize=(8, 4)) -axes[0].set_title('Periodic') -axes[0].plot(irasa_result.freqs, irasa_result.periodic[0,:]) -axes[0].set_ylabel('Power (a.u.)') -axes[0].set_xlabel('Frequency (Hz)') -axes[1].set_title('Aperiodic') -axes[1].loglog(irasa_result.freqs, irasa_result.aperiodic[0,:]) -axes[1].set_ylabel('Power (a.u.)') -axes[1].set_xlabel('Frequency (Hz)') - -f.tight_layout() - -# %% get periodic stuff - -pe_params = irasa_result.get_peaks() -pe_params -#%% get aperiodics -ap_params = irasa_result.get_slopes(fit_func='knee') -ap_params.gof -# %% diff --git a/examples/check_irasa_mne.py b/examples/check_irasa_mne.py deleted file mode 100644 index 598fb50..0000000 --- a/examples/check_irasa_mne.py +++ /dev/null @@ -1,189 +0,0 @@ -# %% -import sys - -import numpy as np -import seaborn as sns -from neurodsp.sim import sim_combined - -sns.set_style('ticks') -sns.set_context('paper') -sys.path.append('../') - - -import matplotlib as mpl - -new_rc_params = {'text.usetex': False, 'svg.fonttype': 'none'} -mpl.rcParams.update(new_rc_params) - -import mne -from mne.datasets import sample - -from pyrasa.irasa_mne import irasa_epochs, irasa_raw - -# %% now lets check the mne python implementation - - -data_path = sample.data_path() -subjects_dir = data_path / 'subjects' -subject = 'sample' - -meg_path = data_path / 'MEG' / 'sample' -raw_fname = meg_path / 'sample_audvis_raw.fif' -fwd_fname = meg_path / 'sample_audvis-meg-eeg-oct-6-fwd.fif' -fwd = mne.read_forward_solution(fwd_fname) -src = fwd['src'] - - -raw = mne.io.read_raw_fif(raw_fname) -picks = mne.pick_types(raw.info, meg='mag', eeg=False, stim=False, eog=False, exclude='bads') -raw.pick(picks) - -# %% lets simulate 2 different signals -info = raw.info.copy() -tstep = 1.0 / info['sfreq'] - -alpha = sim_combined( - 60, - info['sfreq'], - components={ - 'sim_oscillation': {'freq': 10}, - 'sim_powerlaw': { - 'exponent': -1.5, - }, - }, -) - -beta = sim_combined( - 60, - info['sfreq'], - components={ - 'sim_oscillation': {'freq': 20}, - 'sim_powerlaw': { - 'exponent': -1.5, - }, - }, -) - - -# %% now lets simulate some data -# TODO: put in a helper function - -def simulate_raw_(signal, scaling_fator, region, subject, info, subjects_dir): - """Shorthand function to simulate a dipole""" - - selected_label = mne.read_labels_from_annot( - subject, - regexp=region, - subjects_dir=subjects_dir, - )[0] - location = 'center' # Use the center of the region as a seed. - extent = 10.0 # Extent in mm of the region. - label = mne.label.select_sources( - subject, selected_label, location=location, extent=extent, subjects_dir=subjects_dir - ) - - # this is the source ts - source_time_series = signal * scaling_fator - - n_events = 1 - events = np.zeros((n_events, 3), int) - events[:, 0] = np.arange(n_events) # Events sample. - events[:, 2] = 1 # All events have the sample id. - - source_simulator = mne.simulation.SourceSimulator(src, tstep=tstep) - source_simulator.add_data(label, source_time_series, events) - - raw = mne.simulation.simulate_raw(info, source_simulator, forward=fwd) - # cov = mne.make_ad_hoc_cov(raw.info) - # mne.simulation.add_noise(raw, cov, iir_filter=[0.2, -0.2, 0.04]) - - return raw - - -# %% simulate alpha + beta and combine -raw_alpha = simulate_raw_(alpha, 5e-9, 'caudalmiddlefrontal-rh', subject, info, subjects_dir) - -raw_beta = simulate_raw_(beta, 10e-10, 'caudalmiddlefrontal-lh', subject, info, subjects_dir) - -raw_data = raw_alpha.get_data() + raw_beta.get_data() - -raw = mne.io.RawArray(raw_data, info) - -picks = mne.pick_types(raw.info, meg='mag', eeg=False, stim=False, eog=False, exclude='bads') -raw.pick(picks) - -# %% -aperiodic_mne, periodic_mne = irasa_raw(raw, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05), as_array=False) -# %% -df_slopes, df_gof = aperiodic_mne.get_slopes() - -# %% -df_slopes.head() -# %% -df_gof.head() - -# %% - -peak_df = periodic_mne.get_peaks() - -peak_df.head() - -periodic_mne.plot() - -# %% now lets check-out the events -event_id = { - 'Auditory/Left': 1, - 'Auditory/Right': 2, - 'Visual/Left': 3, - 'Visual/Right': 4, -} -tmin = -0.2 -tmax = 0.5 - -# Load real data as the template -event_fname = meg_path / 'sample_audvis_filt-0-40_raw-eve.fif' -events = mne.read_events(event_fname) - - -epochs = mne.Epochs( - raw, - events, - event_id, - tmin, - tmax, - # picks=picks, - baseline=None, - preload=True, - verbose=False, -) - -# %% - -aperiodic, periodic = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05), as_array=False) - -# %% -periodic.get_peaks(polyorder=0) - -# %% -aperiodic.get_slopes() - -# %% -periodic['Auditory/Left'].average().plot_topomap(dB=False) -# %% -periodic['Auditory/Right'].average().plot_topomap(dB=False) -# %% -periodic['Visual/Left'].average().plot_topomap(dB=False) -# %% -periodic['Visual/Right'].average().plot_topomap(dB=False) - - -# %% -aperiodic['Auditory/Left'].average().plot_topomap(dB=False) -# %% -aperiodic['Auditory/Right'].average().plot_topomap(dB=False) -# %% -aperiodic['Visual/Left'].average().plot_topomap(dB=False) -# %% -aperiodic['Visual/Right'].average().plot_topomap(dB=False) - -# %% diff --git a/examples/custom_fit_functions.ipynb b/examples/custom_fit_functions.ipynb index 4af782a..9c2510d 100644 --- a/examples/custom_fit_functions.ipynb +++ b/examples/custom_fit_functions.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -75,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -108,8 +108,8 @@ " \n", " \n", " 0\n", - " -1.224085\n", - " 1.523086\n", + " -1.303769\n", + " 1.502504\n", " custom\n", " 0\n", " \n", @@ -119,10 +119,10 @@ ], "text/plain": [ " a b fit_type ch_name\n", - "0 -1.224085 1.523086 custom 0" + "0 -1.303769 1.502504 custom 0" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -133,16 +133,16 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "slope_fit_2 = irasa(sig, fs=fs, band=f_range, psd_kwargs={'nperseg': 4 * fs}).compute_slope(fit_func=CustomFitFun)" + "slope_fit_2 = irasa(sig, fs=fs, band=f_range, psd_kwargs={'nperseg': 4 * fs}).get_slopes(fit_func=CustomFitFun)" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -175,8 +175,8 @@ " \n", " \n", " 0\n", - " -1.042533\n", - " 1.502152\n", + " -1.308971\n", + " 1.498613\n", " custom\n", " 0\n", " \n", @@ -186,10 +186,10 @@ ], "text/plain": [ " a b fit_type ch_name\n", - "0 -1.042533 1.502152 custom 0" + "0 -1.308971 1.498613 custom 0" ] }, - "execution_count": 55, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -200,7 +200,80 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mser_squaredBICAICfit_typech_name
00.0065490.980624-1290.629341-1299.406464custom0
00.0002660.999197-3197.348170-3206.125292custom0
\n", + "
" + ], + "text/plain": [ + " mse r_squared BIC AIC fit_type ch_name\n", + "0 0.006549 0.980624 -1290.629341 -1299.406464 custom 0\n", + "0 0.000266 0.999197 -3197.348170 -3206.125292 custom 0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.concat([slope_fit.gof,\n", + " slope_fit_2.gof])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -235,19 +308,19 @@ " \n", " \n", " 0\n", - " 0.007481\n", - " 0.978260\n", - " -2899.955931\n", - " -2908.733054\n", + " 0.007478\n", + " 0.978371\n", + " -2900.221645\n", + " -2908.998768\n", " custom\n", " 0\n", " \n", " \n", " 0\n", - " 0.000305\n", - " 0.999099\n", - " -4803.801397\n", - " -4812.578520\n", + " 0.000337\n", + " 0.998999\n", + " -4744.265350\n", + " -4753.042473\n", " custom\n", " 0\n", " \n", @@ -257,11 +330,11 @@ ], "text/plain": [ " mse r_squared BIC AIC fit_type ch_name\n", - "0 0.007481 0.978260 -2899.955931 -2908.733054 custom 0\n", - "0 0.000305 0.999099 -4803.801397 -4812.578520 custom 0" + "0 0.007478 0.978371 -2900.221645 -2908.998768 custom 0\n", + "0 0.000337 0.998999 -4744.265350 -4753.042473 custom 0" ] }, - "execution_count": 56, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } diff --git a/examples/irasa_sprint.ipynb b/examples/irasa_sprint.ipynb new file mode 100644 index 0000000..1da1eb4 --- /dev/null +++ b/examples/irasa_sprint.ipynb @@ -0,0 +1,290 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "from neurodsp.sim import set_random_seed\n", + "from neurodsp.sim import sim_powerlaw, sim_oscillation\n", + "from neurodsp.utils import create_times\n", + "from neurodsp.plts import plot_timefrequency#\n", + "\n", + "from neurodsp.timefrequency import compute_wavelet_transform\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "#import seaborn as sns\n", + "import pandas as pd\n", + "\n", + "import matplotlib as mpl\n", + "new_rc_params = {'text.usetex': False,\n", + " \"svg.fonttype\": 'none'\n", + "}\n", + "mpl.rcParams.update(new_rc_params)\n", + "\n", + "set_random_seed(42)\n", + "\n", + "from pyrasa.irasa import irasa_sprint" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set some general settings, to be used across all simulations\n", + "fs = 500\n", + "n_seconds = 15\n", + "duration=4\n", + "overlap=0.5\n", + "\n", + "# Create a times vector for the simulations\n", + "times = create_times(n_seconds, fs)\n", + "\n", + "\n", + "alpha = sim_oscillation(n_seconds=.5, fs=fs, freq=10)\n", + "no_alpha = np.zeros(len(alpha))\n", + "beta = sim_oscillation(n_seconds=.5, fs=fs, freq=25)\n", + "no_beta = np.zeros(len(beta))\n", + "\n", + "exp_1 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-1)\n", + "exp_2 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-2)\n", + "\n", + "\n", + "alphas = np.concatenate([no_alpha, alpha, no_alpha, alpha, no_alpha])\n", + "betas = np.concatenate([beta, no_beta, beta, no_beta, beta])\n", + "\n", + "sim_ts = np.concatenate([exp_1 + alphas, \n", + " exp_1 + alphas + betas, \n", + " exp_1 + betas, \n", + " exp_2 + alphas, \n", + " exp_2 + alphas + betas, \n", + " exp_2 + betas, ])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "freqs = np.arange(1, 100, 0.5)\n", + "\n", + "mwt = compute_wavelet_transform(sim_ts, fs=fs, \n", + " freqs=freqs, n_cycles=11,\n", + " )\n", + "\n", + "irasa_sprint_spectrum = irasa_sprint(sim_ts[np.newaxis, :], fs=fs,\n", + " band=(1, 100),\n", + " freq_res=0.5,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#%%\n", + "f, axes = plt.subplots(figsize=(14, 4), ncols=3)\n", + "mwt = np.abs(mwt)\n", + "plot_timefrequency(times, freqs, mwt, vmin=0, ax=axes[0])\n", + "plot_timefrequency(irasa_sprint_spectrum.time, irasa_sprint_spectrum.freqs, np.squeeze(irasa_sprint_spectrum.aperiodic), vmin=0, ax=axes[1])\n", + "plot_timefrequency(irasa_sprint_spectrum.time, irasa_sprint_spectrum.freqs, np.squeeze(irasa_sprint_spectrum.periodic), vmin=0, ax=axes[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "slope_spec = irasa_sprint_spectrum.get_slopes()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(nrows=3, figsize=(8, 7))\n", + "\n", + "ax[0].plot(slope_spec.aperiodic_params['time'], slope_spec.aperiodic_params['Offset'])\n", + "ax[0].set_ylabel('Offset')\n", + "ax[0].set_xlabel('time (s)')\n", + "ax[1].plot(slope_spec.aperiodic_params['time'], slope_spec.aperiodic_params['Exponent'])\n", + "ax[1].set_ylabel('Exponent')\n", + "ax[1].set_xlabel('time (s)')\n", + "ax[2].plot(slope_spec.aperiodic_params['time'], slope_spec.gof['r_squared'])\n", + "ax[2].set_ylabel('R2')\n", + "ax[2].set_xlabel('time (s)')\n", + "\n", + "f.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "peaks_spec = irasa_sprint_spectrum.get_peaks(cut_spectrum=(1, 40),\n", + " smooth=True,\n", + " smoothing_window=1,\n", + " peak_threshold=1,\n", + " min_peak_height=0.01,\n", + " peak_width_limits=(0.5, 12))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(nrows=3, figsize=(8, 7))\n", + "\n", + "for ix, cur_key in enumerate(['cf', 'pw', 'bw']):\n", + "\n", + " ax[ix].plot(peaks_spec['time'], peaks_spec[cur_key])\n", + " ax[ix].set_ylabel(cur_key)\n", + " ax[ix].set_xlabel('time (s)')\n", + " ax[ix].set_xlim(0, 15)\n", + "\n", + "f.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pyrasa.utils.peak_utils import get_band_info\n", + "\n", + "df_alpha = get_band_info(peaks_spec, freq_range=(8,12), ch_names=[])\n", + "alpha_peaks = df_alpha.query('pw > 0.10')\n", + "\n", + "beta_ts = alpha_peaks['time'].to_numpy()\n", + "t1 = beta_ts[0]\n", + "n_peaks = 0\n", + "for ix, i in enumerate(beta_ts):\n", + " try: \n", + " diff = beta_ts[ix + 1] - i\n", + " if diff > 0.025:\n", + " n_peaks += 1\n", + " except IndexError:\n", + " pass\n", + "n_peaks\n", + "\n", + "#%%\n", + "df_beta = get_band_info(peaks_spec, freq_range=(20, 30), ch_names=[])\n", + "beta_peaks = df_beta.query('pw > 0.10')\n", + "\n", + "beta_ts = beta_peaks['time'].to_numpy()\n", + "t1 = beta_ts[0]\n", + "n_peaks = 0\n", + "for ix, i in enumerate(beta_ts):\n", + " try: \n", + " diff = beta_ts[ix + 1] - i\n", + " if diff > 0.025:\n", + " n_peaks += 1\n", + " except IndexError:\n", + " pass\n", + "n_peaks\n", + "\n", + "\n", + "# %%\n", + "f, ax = plt.subplots(figsize=(12, 4), ncols=2)\n", + "\n", + "ax[0].plot(df_alpha['time'], df_alpha['pw'])\n", + "ax[1].plot(df_beta['time'], df_beta['pw'])\n", + "\n", + "yax = ['Alpha Power (8-12Hz)', 'Beta Power (20-30Hz)']\n", + "for ix, c_ax in enumerate(ax):\n", + " c_ax.axhline(0.1, color='r', linestyle='--')\n", + " c_ax.set_xlabel('Time (s)')\n", + " c_ax.set_ylabel(yax[ix])\n", + "\n", + "f.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/irasa_sprint_example.py b/examples/irasa_sprint_example.py deleted file mode 100644 index e36ad05..0000000 --- a/examples/irasa_sprint_example.py +++ /dev/null @@ -1,267 +0,0 @@ -#%% -import sys -from neurodsp.sim import set_random_seed -from neurodsp.sim import sim_powerlaw, sim_oscillation -from neurodsp.utils import create_times -from neurodsp.plts import plot_timefrequency# - -from neurodsp.timefrequency import compute_wavelet_transform -import numpy as np -import matplotlib.pyplot as plt -#import seaborn as sns -import pandas as pd - -import matplotlib as mpl -new_rc_params = {'text.usetex': False, - "svg.fonttype": 'none' -} -mpl.rcParams.update(new_rc_params) - - -#sns.set_style('ticks') -#sns.set_context('talk') - -set_random_seed(42) - -from pyrasa.irasa import irasa_sprint -# %% -# Set some general settings, to be used across all simulations -fs = 500 -n_seconds = 15 -duration=4 -overlap=0.5 - -# Create a times vector for the simulations -times = create_times(n_seconds, fs) - -#%% -alpha = sim_oscillation(n_seconds=.5, fs=fs, freq=10) -no_alpha = np.zeros(len(alpha)) -beta = sim_oscillation(n_seconds=.5, fs=fs, freq=25) -no_beta = np.zeros(len(beta)) - -exp_1 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-1) -exp_2 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-2) - -# %% -alphas = np.concatenate([no_alpha, alpha, no_alpha, alpha, no_alpha]) -betas = np.concatenate([beta, no_beta, beta, no_beta, beta]) - -sim_ts = np.concatenate([exp_1 + alphas, - exp_1 + alphas + betas, - exp_1 + betas, - exp_2 + alphas, - exp_2 + alphas + betas, - exp_2 + betas, ]) -# %% -plt.plot(times, sim_ts) -# %% -freqs = np.arange(1, 100, 0.5) - -#%% -mwt = compute_wavelet_transform(sim_ts, fs=fs, - freqs=freqs, n_cycles=11, - ) - - -#%% - - -#f.savefig('../results/time_freq_sim_mwt.svg') -# %% -sgramm_ap, sgramm_p, freqs_ir, times_ir = irasa_sprint(sim_ts[np.newaxis, :], fs=fs, - band=(1, 100), - freq_res=0.5, - #smooth=True, - #n_avgs=[3, 7, 11] - ) - -#%% -f, axes = plt.subplots(figsize=(14, 4), ncols=3) -mwt = np.abs(mwt) -plot_timefrequency(times, freqs, mwt, vmin=0, ax=axes[0]) -plot_timefrequency(times_ir, freqs_ir, np.squeeze(sgramm_ap), vmin=0, ax=axes[1]) -plot_timefrequency(times_ir, freqs_ir, np.squeeze(sgramm_p), vmin=0, ax=axes[2]) - -#f.savefig('../results/time_freq_split.svg') -# %% now extract the aperiodic features -from pyrasa.utils.aperiodic_utils import compute_slope_sprint - -df_aps, df_gof = compute_slope_sprint(sgramm_ap[np.newaxis, :, :], freqs=freqs_ir, - times=times_ir, fit_func='fixed') - -#%% -ave = df_gof['r_squared'].mean() -std = df_gof['r_squared'].std() -print(f'Average goodness of fit {ave} and deviation is {std}') - - -#%% -ave = df_gof.query('time < 7')['r_squared'].mean() -std = df_gof.query('time < 7')['r_squared'].std() -print(f'Average goodness of fit {ave} and deviation is {std}') - - -#%% -ave = df_gof.query('time > 7')['r_squared'].mean() -std = df_gof.query('time > 7')['r_squared'].std() -print(f'Average goodness of fit {ave} and deviation is {std}') - - -# %% -f, ax = plt.subplots(nrows=3, figsize=(8, 7)) - -ax[0].plot(df_aps['time'], df_aps['Offset']) -ax[0].set_ylabel('Offset') -ax[0].set_xlabel('time (s)') -ax[1].plot(df_aps['time'], df_aps['Exponent']) -ax[1].set_ylabel('Exponent') -ax[1].set_xlabel('time (s)') -ax[2].plot(df_aps['time'], df_gof['r_squared']) -ax[2].set_ylabel('R2') -ax[2].set_xlabel('time (s)') - -f.tight_layout() -#f.savefig('../results/time_resolved_exp_r2.svg') -# %% -# %% -from pyrasa.utils.peak_utils import get_peak_params_sprint - -df_peaks = get_peak_params_sprint(sgramm_p[np.newaxis,:, :], - freqs=freqs_ir, - times=times_ir, - cut_spectrum=(1, 40), - smooth=True, - smoothing_window=1, - peak_threshold=1, - min_peak_height=0.01, - peak_width_limits=(0.5, 12)) - -plot_timefrequency(times_ir, freqs_ir, sgramm_p, vmin=0) - -# %% Plot peak results -f, ax = plt.subplots(nrows=3, figsize=(8, 7)) - -for ix, cur_key in enumerate(['cf', 'pw', 'bw']): - - ax[ix].plot(df_peaks['time'], df_peaks[cur_key]) - ax[ix].set_ylabel(cur_key) - ax[ix].set_xlabel('time (s)') - ax[ix].set_xlim(0, 15) - -f.tight_layout() -#f.savefig('../results/time_resolved_peak_params.svg') -#%% -sys.path.append('/home/schmidtfa/git/SPRiNT') -from SPRiNT_py import SPRiNT_stft_py -# %% - - -opt = { - "sfreq": fs, # Input sampling rate - "WinLength": 0.5, # STFT window length - "WinOverlap": 50, # Overlap between sliding windows (in %) - "WinAverage": 3, # Number of overlapping windows being averaged - "rmoutliers": 1, # Apply peak post-processing - "maxTime": 6, # Maximum distance of nearby peaks in time (in n windows) - "maxFreq": 2.5, # Maximum distance of nearby peaks in frequency (in Hz) - "minNear": 3, # Minimum number of similar peaks nearby (using above bounds) - } - -output = SPRiNT_stft_py(sim_ts, opt) - -from fooof import FOOOFGroup, fit_fooof_3d - - -fg = FOOOFGroup(peak_width_limits=[1, 8], - min_peak_height=0.01, - max_n_peaks = 8) -fgs = fit_fooof_3d(fg, output['freqs'], output['TF']) - - - -df_fooof = pd.DataFrame(fgs[0].get_params('peak_params'), columns=('CF', 'PW', 'BW', 'Time')) -dict_a = dict(zip(df_fooof['Time'].unique().astype(int), output['ts'])) -df_fooof['Time'] = df_fooof['Time'].replace(dict_a) -df_fooof['Time'] = df_fooof['Time'] / 2 - -df_alpha_fooof = df_fooof.query('CF < 12').query('CF > 8') -df_beta_fooof = df_fooof.query('CF < 30').query('CF > 20') -# %% -df_alpha_fooof -# %% -from pyrasa.utils.peak_utils import get_band_info - -df_alpha = get_band_info(df_peaks, freq_range=(8,12), ch_names=[]) -alpha_peaks = df_alpha.query('pw > 0.10') - -beta_ts = alpha_peaks['time'].to_numpy() -t1 = beta_ts[0] -n_peaks = 0 -for ix, i in enumerate(beta_ts): - try: - diff = beta_ts[ix + 1] - i - if diff > 0.025: - n_peaks += 1 - except IndexError: - pass -n_peaks - -#%% -df_beta = get_band_info(df_peaks, freq_range=(20, 30), ch_names=[]) -beta_peaks = df_beta.query('pw > 0.10') - -beta_ts = beta_peaks['time'].to_numpy() -t1 = beta_ts[0] -n_peaks = 0 -for ix, i in enumerate(beta_ts): - try: - diff = beta_ts[ix + 1] - i - if diff > 0.025: - n_peaks += 1 - except IndexError: - pass -n_peaks - - -# %% -f, ax = plt.subplots(figsize=(12, 4), ncols=2) - -ax[0].plot(df_alpha['time'], df_alpha['pw']) -ax[1].plot(df_beta['time'], df_beta['pw']) - -yax = ['Alpha Power (8-12Hz)', 'Beta Power (20-30Hz)'] -for ix, c_ax in enumerate(ax): - c_ax.set_xlabel('Time (s)') - c_ax.set_ylabel(yax[ix]) - -#sns.despine() -f.tight_layout() -#f.savefig('../results/detected_peaks_pyrasa.svg') - -#%% -plt.plot(df_beta['time'], df_beta['pw'] ) - - -#%% - -f, ax = plt.subplots(figsize=(12, 4), ncols=2) - -ax[0].plot(df_alpha_fooof['Time'], df_alpha_fooof['PW']) -ax[1].plot(df_beta_fooof['Time'], df_beta_fooof['PW']) - -yax = ['Alpha Power (8-12Hz)', 'Beta Power (20-30Hz)'] -for ix, c_ax in enumerate(ax): - c_ax.set_xlabel('Time (s)') - c_ax.set_ylabel(yax[ix]) - -#sns.despine() -f.tight_layout() -#f.savefig('../results/detected_peaks_sprint.svg') - - -#%% -df_alpha_fooof -# %% - -# %% diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index f58020e..45699f7 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -27,8 +27,12 @@ def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_type: str) -> pd ss_tot = np.sum((psd - np.mean(psd)) ** 2) mse = np.mean(residuals**2) - n = len(psd) + + # loglik = -n/2.*(1+np.log(mse)+np.log(2*np.pi)) + # aic = 2 * (k-loglik) + # bic = k * np.log(n)-2 * loglik + bic = n * np.log(mse) + k * np.log(n) aic = n * np.log(mse) + 2 * k From 23abaac367b08870333db736ac4b6f0311dcbcf7 Mon Sep 17 00:00:00 2001 From: Fabi Date: Wed, 7 Aug 2024 17:00:19 +0200 Subject: [PATCH 04/11] fixed some core issues with irasa_sprint --- examples/basic_functionality.ipynb | 25 ++-- examples/irasa_sprint.ipynb | 41 ++++--- examples/test_td.py | 183 +++++++++++++++++++++++++++++ pyrasa/irasa.py | 4 +- pyrasa/utils/irasa_utils.py | 34 ++---- 5 files changed, 235 insertions(+), 52 deletions(-) create mode 100644 examples/test_td.py diff --git a/examples/basic_functionality.ipynb b/examples/basic_functionality.ipynb index 6bd8e98..f89e4cc 100644 --- a/examples/basic_functionality.ipynb +++ b/examples/basic_functionality.ipynb @@ -37,7 +37,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -81,27 +81,28 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "TypeError", + "evalue": "cannot unpack non-iterable IrasaSpectrum object", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyrasa\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mirasa\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m irasa\n\u001b[0;32m----> 3\u001b[0m freq_irasa, psd_ap, psd_p \u001b[38;5;241m=\u001b[39m irasa(sig, \n\u001b[1;32m 4\u001b[0m fs\u001b[38;5;241m=\u001b[39mfs, \n\u001b[1;32m 5\u001b[0m band\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m100\u001b[39m), \n\u001b[1;32m 6\u001b[0m psd_kwargs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnperseg\u001b[39m\u001b[38;5;124m'\u001b[39m: duration\u001b[38;5;241m*\u001b[39mfs, \n\u001b[1;32m 7\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnoverlap\u001b[39m\u001b[38;5;124m'\u001b[39m: duration\u001b[38;5;241m*\u001b[39mfs\u001b[38;5;241m*\u001b[39moverlap\n\u001b[1;32m 8\u001b[0m },\n\u001b[1;32m 9\u001b[0m hset_info\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0.05\u001b[39m))\n\u001b[1;32m 11\u001b[0m f, axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(ncols\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[1;32m 12\u001b[0m axes[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mset_title(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPeriodic\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mTypeError\u001b[0m: cannot unpack non-iterable IrasaSpectrum object" + ] } ], "source": [ "from pyrasa.irasa import irasa\n", "\n", - "freq_irasa, psd_ap, psd_p = irasa(sig, \n", + "irasa_out = irasa(sig, \n", " fs=fs, \n", " band=(1, 100), \n", - " irasa_kwargs={'nperseg': duration*fs, \n", + " psd_kwargs={'nperseg': duration*fs, \n", " 'noverlap': duration*fs*overlap\n", " },\n", " hset_info=(1, 2, 0.05))\n", diff --git a/examples/irasa_sprint.ipynb b/examples/irasa_sprint.ipynb index 1da1eb4..ec4934f 100644 --- a/examples/irasa_sprint.ipynb +++ b/examples/irasa_sprint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -67,11 +67,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "freqs = np.arange(1, 100, 0.5)\n", + "import scipy.signal as dsp\n", "\n", "mwt = compute_wavelet_transform(sim_ts, fs=fs, \n", " freqs=freqs, n_cycles=11,\n", @@ -79,18 +80,21 @@ "\n", "irasa_sprint_spectrum = irasa_sprint(sim_ts[np.newaxis, :], fs=fs,\n", " band=(1, 100),\n", - " freq_res=0.5,\n", - " )" + " freq_res=.5,\n", + " hop=25,\n", + " win_duration=1,\n", + " hset_info=(1.05, 2., 0.05),\n", + " win_func=dsp.windows.hann)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 50, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -110,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -119,12 +123,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 52, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -151,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -165,12 +169,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -194,12 +198,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 55, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -258,6 +262,13 @@ "f.tight_layout()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/examples/test_td.py b/examples/test_td.py new file mode 100644 index 0000000..9d7791b --- /dev/null +++ b/examples/test_td.py @@ -0,0 +1,183 @@ +#%% +from neurodsp.sim import sim_combined +from neurodsp.utils import create_times +import numpy as np +import scipy.signal as dsp + + +fs = 1000 +n_seconds = 60 +duration=2 +overlap=0.5 + +sim_components = {'sim_powerlaw': {'exponent' : -1}, + 'sim_oscillation': {'freq' : 10}} + + +sig = sim_combined(n_seconds=n_seconds, fs=fs, components=sim_components) +times = create_times(n_seconds=n_seconds, fs=fs) +#%% +import fractions +kwargs_psd = {'nperseg': duration*fs, + 'noverlap': duration*fs*overlap} + +resampling_factor = 1.5 + +rat = fractions.Fraction(str(resampling_factor)) +up, down = rat.numerator, rat.denominator + +# Much faster than FFT-based resampling +data_up = dsp.resample_poly(sig, up, down, axis=-1) +data_down = dsp.resample_poly(sig, down, up, axis=-1) + +# Calculate an up/downsampled version of the PSD using same params as original +win_duration = 2 +hop = 100 + +nperseg = int(np.floor(fs * win_duration)) + +win = dsp.windows.hann(nperseg) + +SFT = dsp.ShortTimeFFT(win, hop=hop, fs=fs, scale_to='psd') +t_inc = SFT.T +psd = SFT.spectrogram(sig, detr='constant') + +hop_up = int(hop * resampling_factor) +SFT_u = dsp.ShortTimeFFT.from_window('hann', + nperseg=nperseg, + fs=fs * resampling_factor, + noverlap=nperseg-hop_up) +psd_up = SFT_u.stft(data_up) + + +#%% +hop_dw = int(hop / resampling_factor) +noverlap=nperseg-hop_dw +N = len(data_down) +SFT_d = dsp.ShortTimeFFT.from_window('hann', + nperseg=nperseg, + fs=fs / resampling_factor, + noverlap=nperseg-hop_dw, + fft_mode='centered',) +psd_dw = SFT_d.spectrogram(data_down, p0=0, p1=(N-noverlap)//SFT_d.hop, k_offset=N//2) + +# %% +psd_dw.shape + +# %% +psd.shape +# %% +psd_up.shape + + +# %% +import numpy as np +import scipy.signal as dsp +import fractions +from neurodsp.sim import sim_oscillation, sim_powerlaw + +# Example signal and parameters +# Set some general settings, to be used across all simulations +fs = 500 +n_seconds = 15 +duration=4 +overlap=0.5 + +# Create a times vector for the simulations +#times = create_times(n_seconds, fs) + + +alpha = sim_oscillation(n_seconds=.5, fs=fs, freq=10) +no_alpha = np.zeros(len(alpha)) +beta = sim_oscillation(n_seconds=.5, fs=fs, freq=25) +no_beta = np.zeros(len(beta)) + +exp_1 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-1) +exp_2 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-2) + + +alphas = np.concatenate([no_alpha, alpha, no_alpha, alpha, no_alpha]) +betas = np.concatenate([beta, no_beta, beta, no_beta, beta]) + +sig = np.concatenate([exp_1 + alphas, + exp_1 + alphas + betas, + exp_1 + betas, + exp_2 + alphas, + exp_2 + alphas + betas, + exp_2 + betas, ]) + +resampling_factor = 1.1 # Resampling factor +win_duration = 1 # Window duration for spectrogram +hop = 10 # Hop size for spectrogram +hset = np.arange(1, 2, 0.05).round(2) +freq_res = 0.5 +nfft = int(fs / freq_res) + +# Original spectrogram +# Window and hop size for spectrogram +nperseg = int(np.floor(fs * win_duration)) +win = dsp.windows.hann(nperseg) +freq, t, psd = dsp.stft(sig, fs=fs, nfft=nfft, window=win, nperseg=nperseg, + noverlap=nperseg - hop, scaling='psd') + +psd = (np.abs(psd) ** 2) + +average_psd = np.zeros([len(hset), *psd.shape]) + +for i, resampling_factor in enumerate(hset): + # Calculate resampling factors + rat = fractions.Fraction(str(resampling_factor)) + up, down = rat.numerator, rat.denominator + + # Resample the signal + data_up = dsp.resample_poly(sig, up, down, axis=-1) + data_down = dsp.resample_poly(sig, down, up, axis=-1) + + # Upsampled spectrogram + hop_up = int(hop * resampling_factor) + f_up, t_up, psd_up = dsp.stft(data_up, nfft=nfft, fs=fs * resampling_factor, + window=win, nperseg=nperseg, + noverlap=nperseg - hop_up, scaling='psd') + + # Downsampled spectrogram + hop_down = int(hop / resampling_factor) + f_dw, t_dw, psd_dw = dsp.stft(data_down, nfft=nfft, fs=fs / resampling_factor, + window=win, nperseg=nperseg, + noverlap=nperseg - hop_down, scaling='psd') + + # Ensure the time axis has the same number of values by adjusting the hop size + psd_up = psd_up[:, :psd.shape[1]] + psd_dw = psd_dw[:, :psd.shape[1]] + + # Average the PSDs + average_psd[i,:,:] = np.sqrt((np.abs(psd_up) ** 2) * (np.abs(psd_dw) ** 2)) + # If needed, the time axis can be derived from the spectrogram output + #time_axis = np.linspace(0, len(sig) / fs, psd.shape[1]) + + print("Average PSD shape:", average_psd.shape) + #print("Time axis length:", len(time_axis)) + +aperiodic = np.median(average_psd, axis=0) +periodic = psd - aperiodic + +#%% +from neurodsp.plts import plot_timefrequency# +import matplotlib.pyplot as plt +f, axes = plt.subplots(figsize=(14, 4), ncols=3) + +fmask = freq < 50 + +plot_timefrequency(t, freq[fmask], psd[fmask,:], vmin=0, ax=axes[0]) +plot_timefrequency(t, freq[fmask], aperiodic[fmask,:], vmin=0, ax=axes[1]) +plot_timefrequency(t, freq[fmask], periodic[fmask,:], vmin=0, ax=axes[2]) + +# %% +from pyrasa.irasa import irasa_sprint + +irasa_sprint_spectrum = irasa_sprint(sig[np.newaxis, :], fs=fs, + band=(1, 100), + freq_res=.5, + hop=100, + win_duration=1., + hset_info=(1.05, 2., 0.05)) +# %% diff --git a/pyrasa/irasa.py b/pyrasa/irasa.py index 279a5e2..6bb5b74 100644 --- a/pyrasa/irasa.py +++ b/pyrasa/irasa.py @@ -252,7 +252,7 @@ def irasa_sprint( # noqa PLR0915 C901 hset = np.round(np.arange(*hset_info), hset_accuracy) - mfft = int(fs / freq_res) + nfft = int(fs / freq_res) win_kwargs = {'win_func': win_func, 'win_func_kwargs': win_func_kwargs} dpss_settings = { 'time_bandwidth': dpss_settings_time_bandwidth, @@ -261,7 +261,7 @@ def irasa_sprint( # noqa PLR0915 C901 } irasa_kwargs: IrasaSprintKwargsTyped = { - 'mfft': mfft, + 'nfft': nfft, 'hop': hop, 'win_duration': win_duration, 'dpss_settings': dpss_settings, diff --git a/pyrasa/utils/irasa_utils.py b/pyrasa/utils/irasa_utils.py index 9df90b8..bb395ce 100644 --- a/pyrasa/utils/irasa_utils.py +++ b/pyrasa/utils/irasa_utils.py @@ -6,7 +6,6 @@ import numpy as np import scipy.signal as dsp -from scipy.signal import ShortTimeFFT from pyrasa.utils.types import IrasaFun @@ -226,9 +225,9 @@ def _compute_psd_welch( def _compute_sgramm( # noqa C901 x: np.ndarray, fs: int, - mfft: int, - hop: int, + nfft: int, win_duration: float, + hop: int, dpss_settings: dict, win_kwargs: dict, up_down: str | None = None, @@ -237,22 +236,22 @@ def _compute_sgramm( # noqa C901 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Function to compute spectrograms""" - if h is None: - nperseg = int(np.floor(fs * win_duration)) - elif np.logical_and(h is not None, up_down == 'up'): - nperseg = int(np.floor(fs * win_duration * h)) + nperseg = int(np.floor(fs * win_duration)) + + if np.logical_and(h is not None, up_down == 'up'): hop = int(hop * h) elif np.logical_and(h is not None, up_down == 'down'): - nperseg = int(np.floor(fs * win_duration / h)) hop = int(hop / h) win, ratios = _get_windows(nperseg, dpss_settings, **win_kwargs) sgramms = [] for cur_win in win: - SFT = ShortTimeFFT(cur_win, hop=hop, mfft=mfft, fs=fs, scale_to='psd') # noqa N806 - cur_sgramm = SFT.spectrogram(x, detr='constant') - sgramms.append(cur_sgramm) + freq, time, sgramm = dsp.stft( + x, nfft=nfft, nperseg=nperseg, noverlap=nperseg - hop, fs=fs, window=cur_win, scaling='psd' + ) + sgramm = np.abs(sgramm) ** 2 + sgramms.append(sgramm) if ratios is None: sgramm = np.mean(sgramms, axis=0) @@ -260,19 +259,8 @@ def _compute_sgramm( # noqa C901 weighted_sgramms = [ratios[ix] * cur_sgramm for ix, cur_sgramm in enumerate(sgramms)] sgramm = np.sum(weighted_sgramms, axis=0) / np.sum(ratios) - time = _gen_time_from_sft(SFT, x) - freq = SFT.f[SFT.f > 0] - - # subsample the upsampled data in the time domain to allow averaging - # This is necessary as division by h can cause slight rounding differences that - # result in actual unintended temporal differences in up/dw for very long segments. if time_orig is not None: - sgramm = np.array([_find_nearest(sgramm, time, t) for t in time_orig]) - max_t_ix = time_orig.shape[0] - # swapping axes is necessitated by _find_nearest - sgramm = np.swapaxes( - np.swapaxes(sgramm[:max_t_ix, :, :], 1, 2), 0, 2 - ) # cut time axis for up/downsampled data to allow averaging + sgramm = sgramm[:, :, : time_orig.shape[-1]] sgramm = np.squeeze(sgramm) # bring in proper format From 87cf1ea4b088d2cdb09c255e63e5bc564dc2c0c6 Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 09:46:03 +0200 Subject: [PATCH 05/11] made type checker happy --- pyrasa/irasa.py | 2 +- pyrasa/utils/irasa_utils.py | 7 ++++--- pyrasa/utils/types.py | 4 ++-- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/pyrasa/irasa.py b/pyrasa/irasa.py index 6bb5b74..20dd126 100644 --- a/pyrasa/irasa.py +++ b/pyrasa/irasa.py @@ -271,7 +271,7 @@ def irasa_sprint( # noqa PLR0915 C901 def _local_irasa_fun( data: np.ndarray, fs: int, - h: int | None, + h: float, up_down: str | None, time_orig: np.ndarray | None = None, ) -> np.ndarray: diff --git a/pyrasa/utils/irasa_utils.py b/pyrasa/utils/irasa_utils.py index bb395ce..f0fdee4 100644 --- a/pyrasa/utils/irasa_utils.py +++ b/pyrasa/utils/irasa_utils.py @@ -230,17 +230,18 @@ def _compute_sgramm( # noqa C901 hop: int, dpss_settings: dict, win_kwargs: dict, + h: float = 1.0, up_down: str | None = None, - h: int | None = None, time_orig: np.ndarray | None = None, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Function to compute spectrograms""" nperseg = int(np.floor(fs * win_duration)) - if np.logical_and(h is not None, up_down == 'up'): + if up_down == 'up': hop = int(hop * h) - elif np.logical_and(h is not None, up_down == 'down'): + + if up_down == 'down': hop = int(hop / h) win, ratios = _get_windows(nperseg, dpss_settings, **win_kwargs) diff --git a/pyrasa/utils/types.py b/pyrasa/utils/types.py index c8795a1..ab6f815 100644 --- a/pyrasa/utils/types.py +++ b/pyrasa/utils/types.py @@ -7,12 +7,12 @@ class IrasaFun(Protocol): def __call__( - self, data: np.ndarray, fs: int, h: int | None, up_down: str | None, time_orig: np.ndarray | None = None + self, data: np.ndarray, fs: int, h: float, up_down: str | None, time_orig: np.ndarray | None = None ) -> np.ndarray: ... class IrasaSprintKwargsTyped(TypedDict): - mfft: int + nfft: int hop: int win_duration: float dpss_settings: dict From ecc24ca1abfe29062c8d02fae0e595bf9547b25f Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 17:32:06 +0200 Subject: [PATCH 06/11] fixed examples --- examples/basic_functionality.ipynb | 387 +- examples/custom_fit_functions.ipynb | 105 +- examples/irasa_mne.ipynb | 5277 ++++++++++++++------------- 3 files changed, 2799 insertions(+), 2970 deletions(-) diff --git a/examples/basic_functionality.ipynb b/examples/basic_functionality.ipynb index f89e4cc..9bcbe9b 100644 --- a/examples/basic_functionality.ipynb +++ b/examples/basic_functionality.ipynb @@ -37,7 +37,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -81,67 +81,44 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "cannot unpack non-iterable IrasaSpectrum object", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyrasa\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mirasa\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m irasa\n\u001b[0;32m----> 3\u001b[0m freq_irasa, psd_ap, psd_p \u001b[38;5;241m=\u001b[39m irasa(sig, \n\u001b[1;32m 4\u001b[0m fs\u001b[38;5;241m=\u001b[39mfs, \n\u001b[1;32m 5\u001b[0m band\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m100\u001b[39m), \n\u001b[1;32m 6\u001b[0m psd_kwargs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnperseg\u001b[39m\u001b[38;5;124m'\u001b[39m: duration\u001b[38;5;241m*\u001b[39mfs, \n\u001b[1;32m 7\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnoverlap\u001b[39m\u001b[38;5;124m'\u001b[39m: duration\u001b[38;5;241m*\u001b[39mfs\u001b[38;5;241m*\u001b[39moverlap\n\u001b[1;32m 8\u001b[0m },\n\u001b[1;32m 9\u001b[0m hset_info\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0.05\u001b[39m))\n\u001b[1;32m 11\u001b[0m f, axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(ncols\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[1;32m 12\u001b[0m axes[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mset_title(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPeriodic\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mTypeError\u001b[0m: cannot unpack non-iterable IrasaSpectrum object" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "from pyrasa.irasa import irasa\n", "\n", "irasa_out = irasa(sig, \n", - " fs=fs, \n", - " band=(1, 100), \n", - " psd_kwargs={'nperseg': duration*fs, \n", - " 'noverlap': duration*fs*overlap\n", - " },\n", - " hset_info=(1, 2, 0.05))\n", + " fs=fs, \n", + " band=(1, 100), \n", + " psd_kwargs={'nperseg': duration*fs, \n", + " 'noverlap': duration*fs*overlap\n", + " },\n", + " hset_info=(1, 2, 0.05))\n", "\n", "f, axes = plt.subplots(ncols=2, figsize=(8, 4))\n", "axes[0].set_title('Periodic')\n", - "axes[0].plot(freq_irasa, psd_p[0,:])\n", + "axes[0].plot(irasa_out.freqs, irasa_out.periodic[0,:])\n", "axes[0].set_ylabel('Power (a.u.)')\n", "axes[0].set_xlabel('Frequency (Hz)')\n", "axes[1].set_title('Aperiodic')\n", - "axes[1].loglog(freq_irasa, psd_ap[0,:])\n", + "axes[1].loglog(irasa_out.freqs, irasa_out.aperiodic[0,:])\n", "axes[1].set_ylabel('Power (a.u.)')\n", "axes[1].set_xlabel('Frequency (Hz)')\n", "\n", "f.tight_layout()\n" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int(freq_irasa[0]) == 1\n", - "\n", - "bool(np.logical_and(freq_irasa[0] == 1, freq_irasa[-1] == 100))" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -151,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -185,112 +162,92 @@ " \n", " 0\n", " 0\n", - " 10.0\n", - " 1.437975\n", - " 0.414345\n", + " 9.5\n", + " 1.436964\n", + " 0.417941\n", " \n", " \n", "\n", "" ], "text/plain": [ - " ch_name cf bw pw\n", - "0 0 10.0 1.437975 0.414345" + " ch_name cf bw pw\n", + "0 0 9.5 1.436964 0.417941" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# %% get periodic stuff\n", - "from pyrasa.utils.peak_utils import get_peak_params\n", - "get_peak_params(psd_p, freqs=freq_irasa)" + "irasa_out.get_peaks()" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:189: UserWarning: The first frequency appears to be 0 this will result in slope fitting problems. Frequencies will be evaluated starting from the next highest in Hz\n", - " warnings.warn('The first frequency appears to be 0 this will result in slope fitting problems. Frequencies will be evaluated starting from the next highest in Hz')\n" - ] - }, - { - "ename": "ValueError", - "evalue": "No objects to concatenate", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[13], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# %% get aperiodic stuff\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyrasa\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01maperiodic_utils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m compute_slope\n\u001b[0;32m----> 4\u001b[0m ap_params, gof_params \u001b[38;5;241m=\u001b[39m \u001b[43mcompute_slope\u001b[49m\u001b[43m(\u001b[49m\u001b[43maperiodic_spectrum\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpsd_ap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreqs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq_irasa\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mfit_func\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mfixed\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#fit_bounds=[0, 40]\u001b[39;49;00m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m ap_params\n", - "File \u001b[0;32m~/git/pyrasa/pyrasa/utils/aperiodic_utils.py:225\u001b[0m, in \u001b[0;36mcompute_slope\u001b[0;34m(aperiodic_spectrum, freqs, fit_func, ch_names, scale, fit_bounds)\u001b[0m\n\u001b[1;32m 222\u001b[0m gof_list\u001b[38;5;241m.\u001b[39mappend(gof)\n\u001b[1;32m 224\u001b[0m \u001b[38;5;66;03m# combine & return\u001b[39;00m\n\u001b[0;32m--> 225\u001b[0m df_aps \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcat\u001b[49m\u001b[43m(\u001b[49m\u001b[43map_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 226\u001b[0m df_gof \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mconcat(gof_list)\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m df_aps, df_gof\n", - "File \u001b[0;32m~/git/pyrasa/.pixi/envs/default/lib/python3.12/site-packages/pandas/core/reshape/concat.py:382\u001b[0m, in \u001b[0;36mconcat\u001b[0;34m(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m copy \u001b[38;5;129;01mand\u001b[39;00m using_copy_on_write():\n\u001b[1;32m 380\u001b[0m copy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 382\u001b[0m op \u001b[38;5;241m=\u001b[39m \u001b[43m_Concatenator\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 383\u001b[0m \u001b[43m \u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 384\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 385\u001b[0m \u001b[43m \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 386\u001b[0m \u001b[43m \u001b[49m\u001b[43mjoin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 387\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 388\u001b[0m \u001b[43m \u001b[49m\u001b[43mlevels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlevels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 389\u001b[0m \u001b[43m \u001b[49m\u001b[43mnames\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnames\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 390\u001b[0m \u001b[43m \u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverify_integrity\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 391\u001b[0m \u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 392\u001b[0m \u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 393\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m op\u001b[38;5;241m.\u001b[39mget_result()\n", - "File \u001b[0;32m~/git/pyrasa/.pixi/envs/default/lib/python3.12/site-packages/pandas/core/reshape/concat.py:445\u001b[0m, in \u001b[0;36m_Concatenator.__init__\u001b[0;34m(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)\u001b[0m\n\u001b[1;32m 442\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverify_integrity \u001b[38;5;241m=\u001b[39m verify_integrity\n\u001b[1;32m 443\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcopy \u001b[38;5;241m=\u001b[39m copy\n\u001b[0;32m--> 445\u001b[0m objs, keys \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_clean_keys_and_objs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 447\u001b[0m \u001b[38;5;66;03m# figure out what our result ndim is going to be\u001b[39;00m\n\u001b[1;32m 448\u001b[0m ndims \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_ndims(objs)\n", - "File \u001b[0;32m~/git/pyrasa/.pixi/envs/default/lib/python3.12/site-packages/pandas/core/reshape/concat.py:507\u001b[0m, in \u001b[0;36m_Concatenator._clean_keys_and_objs\u001b[0;34m(self, objs, keys)\u001b[0m\n\u001b[1;32m 504\u001b[0m objs_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(objs)\n\u001b[1;32m 506\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(objs_list) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 507\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo objects to concatenate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 509\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m keys \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 510\u001b[0m objs_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(com\u001b[38;5;241m.\u001b[39mnot_none(\u001b[38;5;241m*\u001b[39mobjs_list))\n", - "\u001b[0;31mValueError\u001b[0m: No objects to concatenate" - ] - } - ], - "source": [ - "# %% get aperiodic stuff\n", - "from pyrasa.utils.aperiodic_utils import compute_slope\n", - "\n", - "ap_params, gof_params = compute_slope(aperiodic_spectrum=psd_ap,\n", - " freqs=freq_irasa-1, \n", - " fit_func='fixed',\n", - " #fit_bounds=[0, 40]\n", - " )\n", - "ap_params" - ] - }, - { - "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
OffsetExponentfit_typech_name
0-1.2937371.013686fixed0
\n", + "
" + ], "text/plain": [ - "array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ,\n", - " 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5, 10. , 10.5,\n", - " 11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. , 15.5, 16. ,\n", - " 16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. , 20.5, 21. , 21.5,\n", - " 22. , 22.5, 23. , 23.5, 24. , 24.5, 25. , 25.5, 26. , 26.5, 27. ,\n", - " 27.5, 28. , 28.5, 29. , 29.5, 30. , 30.5, 31. , 31.5, 32. , 32.5,\n", - " 33. , 33.5, 34. , 34.5, 35. , 35.5, 36. , 36.5, 37. , 37.5, 38. ,\n", - " 38.5, 39. , 39.5, 40. , 40.5, 41. , 41.5, 42. , 42.5, 43. , 43.5,\n", - " 44. , 44.5, 45. , 45.5, 46. , 46.5, 47. , 47.5, 48. , 48.5, 49. ,\n", - " 49.5, 50. , 50.5, 51. , 51.5, 52. , 52.5, 53. , 53.5, 54. , 54.5,\n", - " 55. , 55.5, 56. , 56.5, 57. , 57.5, 58. , 58.5, 59. , 59.5, 60. ,\n", - " 60.5, 61. , 61.5, 62. , 62.5, 63. , 63.5, 64. , 64.5, 65. , 65.5,\n", - " 66. , 66.5, 67. , 67.5, 68. , 68.5, 69. , 69.5, 70. , 70.5, 71. ,\n", - " 71.5, 72. , 72.5, 73. , 73.5, 74. , 74.5, 75. , 75.5, 76. , 76.5,\n", - " 77. , 77.5, 78. , 78.5, 79. , 79.5, 80. , 80.5, 81. , 81.5, 82. ,\n", - " 82.5, 83. , 83.5, 84. , 84.5, 85. , 85.5, 86. , 86.5, 87. , 87.5,\n", - " 88. , 88.5, 89. , 89.5, 90. , 90.5, 91. , 91.5, 92. , 92.5, 93. ,\n", - " 93.5, 94. , 94.5, 95. , 95.5, 96. , 96.5, 97. , 97.5, 98. , 98.5,\n", - " 99. ])" + " Offset Exponent fit_type ch_name\n", + "0 -1.293737 1.013686 fixed 0" ] }, - "execution_count": 12, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "freq_irasa-1" + "# %% get aperiodic stuff\n", + "slope_fit = irasa_out.get_slopes()\n", + "slope_fit.aperiodic_params" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -325,10 +282,10 @@ " \n", " \n", " 0\n", - " 0.000208\n", - " 0.998746\n", - " -1682.182526\n", - " -1685.475831\n", + " 0.000278\n", + " 0.998247\n", + " -1618.772746\n", + " -1625.359356\n", " fixed\n", " 0\n", " \n", @@ -338,16 +295,16 @@ ], "text/plain": [ " mse r_squared BIC AIC fit_type ch_name\n", - "0 0.000208 0.998746 -1682.182526 -1685.475831 fixed 0" + "0 0.000278 0.998247 -1618.772746 -1625.359356 fixed 0" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "gof_params" + "slope_fit.gof" ] }, { @@ -361,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -370,13 +327,13 @@ "Text(0.5, 0, 'Frequency (Hz)')" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -407,22 +364,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -474,22 +431,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -526,22 +483,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -574,22 +531,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -619,12 +576,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -658,27 +615,27 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "freq_irasa, psd_ap, psd_p = irasa(sig, \n", - " fs=fs, \n", - " band=(1, 100), \n", - " irasa_kwargs={'nperseg': duration*fs, \n", - " 'noverlap': duration*fs*overlap\n", - " },\n", - " hset_info=(1, 2, 0.025))" + "irasa_out = irasa(sig, \n", + " fs=fs, \n", + " band=(1, 100), \n", + " psd_kwargs={'nperseg': duration*fs, \n", + " 'noverlap': duration*fs*overlap\n", + " },\n", + " hset_info=(1, 2, 0.025))" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -689,23 +646,22 @@ ], "source": [ "f, axes = plt.subplots(ncols=2, figsize=(8, 4))\n", - "axes[0].set_title('Periodic')\n", - "axes[0].plot(freq_irasa, psd_p[0,:])\n", + "axes[0].plot(irasa_out.freqs, irasa_out.periodic[0,:], label='periodic')\n", "axes[0].set_ylabel('Power (a.u.)')\n", "axes[0].set_xlabel('Frequency (Hz)')\n", - "axes[1].set_title('Aperiodic')\n", "\n", - "axes[1].loglog(freq[1:], psd[1:])\n", - "axes[1].loglog(freq_irasa, psd_ap[0,:])\n", + "axes[1].loglog(freq[1:], psd[1:], label='psd')\n", + "axes[1].loglog(irasa_out.freqs, irasa_out.aperiodic[0,:], label='aperiodic')\n", "axes[1].set_ylabel('Power (a.u.)')\n", "axes[1].set_xlabel('Frequency (Hz)')\n", + "plt.legend()\n", "\n", "f.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -739,45 +695,43 @@ " \n", " 0\n", " 0\n", - " 9.5\n", - " 1.436504\n", - " 0.411332\n", + " 10.0\n", + " 1.436404\n", + " 0.423565\n", " \n", " \n", "\n", "" ], "text/plain": [ - " ch_name cf bw pw\n", - "0 0 9.5 1.436504 0.411332" + " ch_name cf bw pw\n", + "0 0 10.0 1.436404 0.423565" ] }, - "execution_count": 15, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# %% get periodic stuff\n", - "from pyrasa.utils.peak_utils import get_peak_params\n", - "get_peak_params(psd_p, freqs=freq_irasa)\n" + "irasa_out.get_peaks()" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# %% get aperiodic stuff\n", - "from pyrasa.utils.aperiodic_utils import compute_slope\n", - "ap_params_f, gof_params_f = compute_slope(aperiodic_spectrum=psd_ap, freqs=freq_irasa, fit_func='fixed')\n", - "ap_params_k, gof_params_k = compute_slope(aperiodic_spectrum=psd_ap, freqs=freq_irasa, fit_func='knee')\n" + "slopes_f = irasa_out.get_slopes(fit_func='fixed')\n", + "slopes_k = irasa_out.get_slopes(fit_func='knee')" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -812,19 +766,19 @@ " \n", " \n", " 0\n", - " 0.019271\n", - " 0.932297\n", - " -780.588556\n", - " -783.881861\n", + " 0.019573\n", + " 0.931418\n", + " -772.202215\n", + " -778.788824\n", " fixed\n", " 0\n", " \n", " \n", " 0\n", - " 0.000020\n", - " 0.999928\n", - " -2133.013680\n", - " -2142.893595\n", + " 0.000028\n", + " 0.999901\n", + " -2062.763593\n", + " -2075.936813\n", " knee\n", " 0\n", " \n", @@ -834,84 +788,17 @@ ], "text/plain": [ " mse r_squared BIC AIC fit_type ch_name\n", - "0 0.019271 0.932297 -780.588556 -783.881861 fixed 0\n", - "0 0.000020 0.999928 -2133.013680 -2142.893595 knee 0" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.concat([gof_params_f, gof_params_k])" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
OffsetKneeExponent_1Exponent_2Knee Frequency (Hz)fit_typech_name
01.349587501.7864430.5014491.8883178.590983knee0
\n", - "
" - ], - "text/plain": [ - " Offset Knee Exponent_1 Exponent_2 Knee Frequency (Hz) fit_type \\\n", - "0 1.349587 501.786443 0.501449 1.888317 8.590983 knee \n", - "\n", - " ch_name \n", - "0 0 " + "0 0.019573 0.931418 -772.202215 -778.788824 fixed 0\n", + "0 0.000028 0.999901 -2062.763593 -2075.936813 knee 0" ] }, - "execution_count": 18, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ap_params_k" + "pd.concat([slopes_f.gof, slopes_k.gof])" ] }, { diff --git a/examples/custom_fit_functions.ipynb b/examples/custom_fit_functions.ipynb index 9c2510d..ed78e5b 100644 --- a/examples/custom_fit_functions.ipynb +++ b/examples/custom_fit_functions.ipynb @@ -108,8 +108,8 @@ " \n", " \n", " 0\n", - " -1.303769\n", - " 1.502504\n", + " -1.052551\n", + " 1.510974\n", " custom\n", " 0\n", " \n", @@ -119,7 +119,7 @@ ], "text/plain": [ " a b fit_type ch_name\n", - "0 -1.303769 1.502504 custom 0" + "0 -1.052551 1.510974 custom 0" ] }, "execution_count": 3, @@ -175,8 +175,8 @@ " \n", " \n", " 0\n", - " -1.308971\n", - " 1.498613\n", + " -1.067699\n", + " 1.500347\n", " custom\n", " 0\n", " \n", @@ -186,7 +186,7 @@ ], "text/plain": [ " a b fit_type ch_name\n", - "0 -1.308971 1.498613 custom 0" + "0 -1.067699 1.500347 custom 0" ] }, "execution_count": 5, @@ -235,19 +235,19 @@ " \n", " \n", " 0\n", - " 0.006549\n", - " 0.980624\n", - " -1290.629341\n", - " -1299.406464\n", + " 0.006699\n", + " 0.980793\n", + " -2965.641163\n", + " -2974.418286\n", " custom\n", " 0\n", " \n", " \n", " 0\n", - " 0.000266\n", - " 0.999197\n", - " -3197.348170\n", - " -3206.125292\n", + " 0.000291\n", + " 0.999139\n", + " -4832.361294\n", + " -4841.138417\n", " custom\n", " 0\n", " \n", @@ -257,81 +257,8 @@ ], "text/plain": [ " mse r_squared BIC AIC fit_type ch_name\n", - "0 0.006549 0.980624 -1290.629341 -1299.406464 custom 0\n", - "0 0.000266 0.999197 -3197.348170 -3206.125292 custom 0" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.concat([slope_fit.gof,\n", - " slope_fit_2.gof])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
mser_squaredBICAICfit_typech_name
00.0074780.978371-2900.221645-2908.998768custom0
00.0003370.998999-4744.265350-4753.042473custom0
\n", - "
" - ], - "text/plain": [ - " mse r_squared BIC AIC fit_type ch_name\n", - "0 0.007478 0.978371 -2900.221645 -2908.998768 custom 0\n", - "0 0.000337 0.998999 -4744.265350 -4753.042473 custom 0" + "0 0.006699 0.980793 -2965.641163 -2974.418286 custom 0\n", + "0 0.000291 0.999139 -4832.361294 -4841.138417 custom 0" ] }, "execution_count": 6, diff --git a/examples/irasa_mne.ipynb b/examples/irasa_mne.ipynb index 380c96f..5f51fd0 100644 --- a/examples/irasa_mne.ipynb +++ b/examples/irasa_mne.ipynb @@ -233,20 +233,36 @@ "text": [ "Effective window size : 3.410 (s)\n", "Plotting power spectral density (dB=True).\n", - "Plotting power spectral density (dB=True).\n", - "Plotting power spectral density (dB=False).\n" + "Plotting power spectral density (dB=True).\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ + "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_29797/1044382114.py:4: FutureWarning: The value of `amplitude='auto'` will be removed in MNE 1.8.0, and the new default will be `amplitude=False`.\n", + " raw.compute_psd(method='welch', n_per_seg=nperseg, n_overlap=nperseg//2, fmin=0.25, fmax=50).plot(axes=axes[0])\n", "/Users/fabian.schmidt/git/pyrasa/.pixi/envs/default/lib/python3.12/site-packages/mne/viz/utils.py:167: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " (fig or plt).show(**kwargs)\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/irasa_mne/mne_objs.py:64: UserWarning: Zero value in PSD for channels MEG 0111, MEG 0121, MEG 0131, MEG 0141, MEG 0211, MEG 0221, MEG 0231, MEG 0241, MEG 0311, MEG 0321, MEG 0331, MEG 0341, MEG 0411, MEG 0421, MEG 0431, MEG 0441, MEG 0511, MEG 0521, MEG 0531, MEG 0541, MEG 0611, MEG 0621, MEG 0631, MEG 0641, MEG 0711, MEG 0721, MEG 0731, MEG 0741, MEG 0811, MEG 0821, MEG 0911, MEG 0921, MEG 0931, MEG 0941, MEG 1011, MEG 1021, MEG 1031, MEG 1041, MEG 1111, MEG 1121, MEG 1131, MEG 1141, MEG 1211, MEG 1221, MEG 1231, MEG 1241, MEG 1311, MEG 1321, MEG 1331, MEG 1341, MEG 1411, MEG 1421, MEG 1431, MEG 1441, MEG 1511, MEG 1521, MEG 1531, MEG 1541, MEG 1611, MEG 1621, MEG 1631, MEG 1641, MEG 1711, MEG 1721, MEG 1731, MEG 1741, MEG 1811, MEG 1821, MEG 1831, MEG 1841, MEG 1911, MEG 1921, MEG 1931, MEG 1941, MEG 2011, MEG 2021, MEG 2031, MEG 2041, MEG 2111, MEG 2121, MEG 2131, MEG 2141, MEG 2211, MEG 2221, MEG 2231, MEG 2241, MEG 2311, MEG 2321, MEG 2331, MEG 2341, MEG 2411, MEG 2421, MEG 2431, MEG 2441, MEG 2511, MEG 2521, MEG 2531, MEG 2541, MEG 2611, MEG 2621, MEG 2631, MEG 2641.\n", + "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_29797/1044382114.py:5: FutureWarning: The value of `amplitude='auto'` will be removed in MNE 1.8.0, and the new default will be `amplitude=False`.\n", + " irasa_results.aperiodic.plot(axes=axes[1])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting power spectral density (dB=False).\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabian.schmidt/git/pyrasa/pyrasa/irasa_mne/mne_objs.py:61: UserWarning: Zero value in PSD for channels MEG 0111, MEG 0121, MEG 0131, MEG 0141, MEG 0211, MEG 0221, MEG 0231, MEG 0241, MEG 0311, MEG 0321, MEG 0331, MEG 0341, MEG 0411, MEG 0421, MEG 0431, MEG 0441, MEG 0511, MEG 0521, MEG 0531, MEG 0541, MEG 0611, MEG 0621, MEG 0631, MEG 0641, MEG 0711, MEG 0721, MEG 0731, MEG 0741, MEG 0811, MEG 0821, MEG 0911, MEG 0921, MEG 0931, MEG 0941, MEG 1011, MEG 1021, MEG 1031, MEG 1041, MEG 1111, MEG 1121, MEG 1131, MEG 1141, MEG 1211, MEG 1221, MEG 1231, MEG 1241, MEG 1311, MEG 1321, MEG 1331, MEG 1341, MEG 1411, MEG 1421, MEG 1431, MEG 1441, MEG 1511, MEG 1521, MEG 1531, MEG 1541, MEG 1611, MEG 1621, MEG 1631, MEG 1641, MEG 1711, MEG 1721, MEG 1731, MEG 1741, MEG 1811, MEG 1821, MEG 1831, MEG 1841, MEG 1911, MEG 1921, MEG 1931, MEG 1941, MEG 2011, MEG 2021, MEG 2031, MEG 2041, MEG 2111, MEG 2121, MEG 2131, MEG 2141, MEG 2211, MEG 2221, MEG 2231, MEG 2241, MEG 2311, MEG 2321, MEG 2331, MEG 2341, MEG 2411, MEG 2421, MEG 2431, MEG 2441, MEG 2511, MEG 2521, MEG 2531, MEG 2541, MEG 2611, MEG 2621, MEG 2631, MEG 2641.\n", "These channels might be dead.\n", " super().plot(\n", - "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_37697/1044382114.py:12: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_29797/1044382114.py:12: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " f.tight_layout()\n" ] }, @@ -294,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -303,7 +319,7 @@ "Text(0.5, 0, 'R2')" ] }, - "execution_count": 13, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -332,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -345,7 +361,7 @@ " )" ] }, - "execution_count": 14, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, @@ -381,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -423,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -441,5232 +457,5232 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in power\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:146: RuntimeWarning: overflow encountered in multiply\n", " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n" ] } @@ -5677,7 +5693,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -5686,13 +5702,13 @@ "" ] }, - "execution_count": 20, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -5703,7 +5719,6 @@ ], "source": [ "ap_data = knee_epoched.aperiodic_params.groupby(['event_id', 'ch_name'])['Knee Frequency (Hz)'].mean().reset_index()\n", - "ap_data\n", "sns.pointplot(ap_data, x='event_id', y='Knee Frequency (Hz)')" ] }, @@ -5716,16 +5731,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "df_periodic = periodic.get_peaks(smoothing_window=2)" + "df_periodic = irasa_epoched.periodic.get_peaks(smoothing_window=2)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -5735,7 +5750,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -5744,13 +5759,13 @@ "" ] }, - "execution_count": 17, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 71c4dc90752b89f729e53694d6da0eaddcb4fa9d Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 20:26:41 +0200 Subject: [PATCH 07/11] temporally changed testing strategy --- pyrasa/utils/irasa_utils.py | 25 ---------------- .../notebooks}/test_td.py | 0 tests/conftest.py | 30 ++++++++++++------- tests/settings.py | 19 ++++++------ tests/test_irasa_knee.py | 12 ++++---- 5 files changed, 36 insertions(+), 50 deletions(-) rename {examples => simulations/notebooks}/test_td.py (100%) diff --git a/pyrasa/utils/irasa_utils.py b/pyrasa/utils/irasa_utils.py index f0fdee4..b700735 100644 --- a/pyrasa/utils/irasa_utils.py +++ b/pyrasa/utils/irasa_utils.py @@ -10,7 +10,6 @@ from pyrasa.utils.types import IrasaFun -# TODO: Port to Cython def _gen_irasa( data: np.ndarray, orig_spectrum: np.ndarray, @@ -73,30 +72,6 @@ def _crop_data( return freqs, psd_aperiodic, psd_periodic, psd -def _gen_time_from_sft(SFT: type[dsp.ShortTimeFFT], sgramm: np.ndarray) -> np.ndarray: # noqa N803 - """Generates time from SFT object""" - - tmin, tmax = SFT.extent(sgramm.shape[-1])[:2] - delta_t = SFT.delta_t - - time = np.arange(tmin, tmax, delta_t) - return time - - -def _find_nearest(sgramm_ud: np.ndarray, time_array: np.ndarray, time_value: float) -> np.ndarray: - """Find the nearest time point in an up/downsampled spectrogram""" - - idx = (np.abs(time_array - time_value)).argmin() - - if idx < sgramm_ud.shape[2]: - sgramm_sel = sgramm_ud[:, :, idx] - - elif idx == sgramm_ud.shape[2]: - sgramm_sel = sgramm_ud[:, :, idx - 1] - - return sgramm_sel - - def _get_windows( nperseg: int, dpss_settings: dict, win_func: Callable, win_func_kwargs: dict ) -> tuple[np.ndarray, np.ndarray]: diff --git a/examples/test_td.py b/simulations/notebooks/test_td.py similarity index 100% rename from examples/test_td.py rename to simulations/notebooks/test_td.py diff --git a/tests/conftest.py b/tests/conftest.py index 80a1df9..d1f4924 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -28,19 +28,29 @@ def knee_aperiodic_signal(exponent, fs, knee_freq): @pytest.fixture(scope='session') -def load_knee_aperiodic_signal(exponent, fs, knee): - base_dir = 'tests/test_data/knee_data/' - yield np.load( - base_dir + f'knee_sim__fs_{fs}__exp1_0__exp2_{exponent}_knee_{knee}_.npy', - ) # allow_pickle=True) +def load_knee_aperiodic_signal(exponent, fs, knee_freq): + # % generate and save knee + knee_sim = sim_knee(n_seconds=N_SECONDS, fs=fs, exponent1=0, exponent2=exponent, knee=knee_freq) + yield knee_sim + # base_dir = 'tests/test_data/knee_data/' + # yield np.load( + # base_dir + f'knee_sim__fs_{fs}__exp1_0__exp2_{exponent}_knee_{knee}_.npy', + # ) # allow_pickle=True) @pytest.fixture(scope='session') -def load_knee_cmb_signal(exponent, fs, knee, osc_freq): - base_dir = 'tests/test_data/knee_osc_data/' - yield np.load( - base_dir + f'cmb_sim__fs_{fs}__exp1_0__exp2_{exponent}_knee_{knee}__osc_freq_{osc_freq}_.npy', - ) # allow_pickle=True) +def load_knee_cmb_signal(exponent, fs, knee_freq, osc_freq): + knee = knee_freq ** np.abs(exponent) + components = { + 'sim_knee': {'exponent1': 0, 'exponent2': exponent, 'knee': knee}, + 'sim_oscillation': {'freq': osc_freq}, + } + cmb_sim = sim_combined(n_seconds=N_SECONDS, fs=fs, components=components) + yield cmb_sim + # base_dir = 'tests/test_data/knee_osc_data/' + # yield np.load( + # base_dir + f'cmb_sim__fs_{fs}__exp1_0__exp2_{exponent}_knee_{knee}__osc_freq_{osc_freq}_.npy', + # ) # allow_pickle=True) # noqa: E501 diff --git a/tests/settings.py b/tests/settings.py index 2554378..caed52f 100644 --- a/tests/settings.py +++ b/tests/settings.py @@ -13,19 +13,20 @@ # If you want to play around with this check: simulations/notebooks/sim_peak_tests.py EXPONENT = [-1, -1.5, -2.0] KNEE_FREQ = 15 +KNEE_FREQS = [10, 15, 25] # There seems to be a higher error in knee fits for knee and exponent estimates when # the difference in pre and post knee exponent is low. This kinda makes sense # TODO: Test this systematically -> see whether this is an issue with irasa or slope fitting in general EXP_KNEE_COMBO = [ - (1.0, 10.0), - (1.0, 15.0), - (1.0, 25.0), - (1.5, 125.0), - (1.5, 32.0), - (1.5, 58.0), - (2.0, 100.0), - (2.0, 225.0), - (2.0, 625.0), + (-1.0, 10.0), + (-1.0, 15.0), + (-1.0, 25.0), + (-1.5, 125.0), + (-1.5, 32.0), + (-1.5, 58.0), + (-2.0, 100.0), + (-2.0, 225.0), + (-2.0, 625.0), ] # we test exp + knee combined as both relate to each other TOLERANCE = 0.3 # 0.15 HIGH_TOLERANCE = 0.5 diff --git a/tests/test_irasa_knee.py b/tests/test_irasa_knee.py index c858c87..ea83734 100644 --- a/tests/test_irasa_knee.py +++ b/tests/test_irasa_knee.py @@ -11,9 +11,9 @@ # knee model -@pytest.mark.parametrize('exponent, knee', EXP_KNEE_COMBO, scope='session') +@pytest.mark.parametrize('exponent, knee_freq', EXP_KNEE_COMBO, scope='session') @pytest.mark.parametrize('fs', FS, scope='session') -def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee): +def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee_freq): f_range = [0.1, 100] irasa_out = irasa(load_knee_aperiodic_signal, fs, f_range, psd_kwargs={'nperseg': 4 * fs}) # test the shape of the output @@ -33,7 +33,7 @@ def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee): knee_hat = slope_fit_k.aperiodic_params['Knee'][0] ** ( 1 / (2 * slope_fit_k.aperiodic_params['Exponent_1'][0] + slope_fit_k.aperiodic_params['Exponent_2'][0]) ) - knee_real = knee ** (1 / np.abs(exponent)) + knee_real = knee_freq ** (1 / np.abs(exponent)) assert bool(np.isclose(knee_hat, knee_real, atol=KNEE_TOLERANCE)) # test bic/aic -> should be better for knee assert slope_fit_k.gof['AIC'][0] < slope_fit_f.gof['AIC'][0] @@ -41,10 +41,10 @@ def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee): # knee model -@pytest.mark.parametrize('exponent, knee', EXP_KNEE_COMBO, scope='session') +@pytest.mark.parametrize('exponent, knee_freq', EXP_KNEE_COMBO, scope='session') @pytest.mark.parametrize('fs', FS, scope='session') @pytest.mark.parametrize('osc_freq', OSC_FREQ, scope='session') -def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee, osc_freq): +def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee_freq, osc_freq): f_range = [0.1, 100] irasa_out = irasa(load_knee_cmb_signal, fs, f_range, psd_kwargs={'nperseg': 4 * fs}) # test the shape of the output @@ -64,7 +64,7 @@ def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee, osc_freq): knee_hat = slope_fit_k.aperiodic_params['Knee'][0] ** ( 1 / (2 * slope_fit_k.aperiodic_params['Exponent_1'][0] + slope_fit_k.aperiodic_params['Exponent_2'][0]) ) - knee_real = knee ** (1 / np.abs(exponent)) + knee_real = knee_freq ** (1 / np.abs(exponent)) assert bool(np.isclose(knee_hat, knee_real, atol=KNEE_TOLERANCE)) # test bic/aic -> should be better for knee assert slope_fit_k.gof['AIC'][0] < slope_fit_f.gof['AIC'][0] From 3f1de7469a58b2ee0a6e57f7a636694633328274 Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 20:29:09 +0200 Subject: [PATCH 08/11] 2nd try --- .gitattributes | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.gitattributes b/.gitattributes index cd5b36d..ed74c21 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,4 +1,4 @@ # GitHub syntax highlighting -pixi.lock linguist-language=YAML linguist-generated=true -tests/test_data/knee_data/*.npy filter=lfs diff=lfs merge=lfs -text -tests/test_data/knee_osc_data/*.npy filter=lfs diff=lfs merge=lfs -text +# pixi.lock linguist-language=YAML linguist-generated=true +# tests/test_data/knee_data/*.npy filter=lfs diff=lfs merge=lfs -text +# tests/test_data/knee_osc_data/*.npy filter=lfs diff=lfs merge=lfs -text From a1f19da032f061aa21c95458af0e95ef21ae8595 Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 20:31:51 +0200 Subject: [PATCH 09/11] drop gitattributes --- .gitattributes | 4 ---- 1 file changed, 4 deletions(-) delete mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes deleted file mode 100644 index ed74c21..0000000 --- a/.gitattributes +++ /dev/null @@ -1,4 +0,0 @@ -# GitHub syntax highlighting -# pixi.lock linguist-language=YAML linguist-generated=true -# tests/test_data/knee_data/*.npy filter=lfs diff=lfs merge=lfs -text -# tests/test_data/knee_osc_data/*.npy filter=lfs diff=lfs merge=lfs -text From 1833558b3ec4e171da78e97fef08300c90c09913 Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 20:38:39 +0200 Subject: [PATCH 10/11] set lfs to false --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 8a917b7..3e9047c 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -21,7 +21,7 @@ jobs: steps: - uses: actions/checkout@v4 with: - lfs: true + lfs: false - uses: prefix-dev/setup-pixi@v0.8.1 with: pixi-version: latest From e1f2fdf4911a0de5b1c473f295bc02b7dc76f6c0 Mon Sep 17 00:00:00 2001 From: Fabi Date: Thu, 8 Aug 2024 22:52:07 +0200 Subject: [PATCH 11/11] added tests and fixed issues --- examples/irasa_sprint.ipynb | 21 ++++++++++++++------- tests/conftest.py | 16 ++++++++-------- tests/test_irasa_knee.py | 12 ++++++------ tests/test_irasa_sprint.py | 33 +++++++++++++++++++++------------ 4 files changed, 49 insertions(+), 33 deletions(-) diff --git a/examples/irasa_sprint.ipynb b/examples/irasa_sprint.ipynb index ec4934f..7905c87 100644 --- a/examples/irasa_sprint.ipynb +++ b/examples/irasa_sprint.ipynb @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -269,6 +269,13 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/tests/conftest.py b/tests/conftest.py index d1f4924..b6cc310 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -28,9 +28,10 @@ def knee_aperiodic_signal(exponent, fs, knee_freq): @pytest.fixture(scope='session') -def load_knee_aperiodic_signal(exponent, fs, knee_freq): +def load_knee_aperiodic_signal(exponent, fs, knee): # % generate and save knee - knee_sim = sim_knee(n_seconds=N_SECONDS, fs=fs, exponent1=0, exponent2=exponent, knee=knee_freq) + # knee = knee ** np.abs(exponent) + knee_sim = sim_knee(n_seconds=N_SECONDS, fs=fs, exponent1=0, exponent2=exponent, knee=knee) yield knee_sim # base_dir = 'tests/test_data/knee_data/' # yield np.load( @@ -39,8 +40,8 @@ def load_knee_aperiodic_signal(exponent, fs, knee_freq): @pytest.fixture(scope='session') -def load_knee_cmb_signal(exponent, fs, knee_freq, osc_freq): - knee = knee_freq ** np.abs(exponent) +def load_knee_cmb_signal(exponent, fs, knee, osc_freq): + # knee = knee ** np.abs(exponent) components = { 'sim_knee': {'exponent1': 0, 'exponent2': exponent, 'knee': knee}, 'sim_oscillation': {'freq': osc_freq}, @@ -60,15 +61,14 @@ def oscillation(osc_freq, fs): @pytest.fixture(scope='session') -def ts4sprint(): - fs = 500 +def ts4sprint(fs, exponent_1, exponent_2): alpha = sim_oscillation(n_seconds=0.5, fs=fs, freq=10) no_alpha = np.zeros(len(alpha)) beta = sim_oscillation(n_seconds=0.5, fs=fs, freq=25) no_beta = np.zeros(len(beta)) - exp_1 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-1) - exp_2 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=-2) + exp_1 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=exponent_1) + exp_2 = sim_powerlaw(n_seconds=2.5, fs=fs, exponent=exponent_2) # %% alphas = np.concatenate([no_alpha, alpha, no_alpha, alpha, no_alpha]) diff --git a/tests/test_irasa_knee.py b/tests/test_irasa_knee.py index ea83734..c858c87 100644 --- a/tests/test_irasa_knee.py +++ b/tests/test_irasa_knee.py @@ -11,9 +11,9 @@ # knee model -@pytest.mark.parametrize('exponent, knee_freq', EXP_KNEE_COMBO, scope='session') +@pytest.mark.parametrize('exponent, knee', EXP_KNEE_COMBO, scope='session') @pytest.mark.parametrize('fs', FS, scope='session') -def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee_freq): +def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee): f_range = [0.1, 100] irasa_out = irasa(load_knee_aperiodic_signal, fs, f_range, psd_kwargs={'nperseg': 4 * fs}) # test the shape of the output @@ -33,7 +33,7 @@ def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee_freq knee_hat = slope_fit_k.aperiodic_params['Knee'][0] ** ( 1 / (2 * slope_fit_k.aperiodic_params['Exponent_1'][0] + slope_fit_k.aperiodic_params['Exponent_2'][0]) ) - knee_real = knee_freq ** (1 / np.abs(exponent)) + knee_real = knee ** (1 / np.abs(exponent)) assert bool(np.isclose(knee_hat, knee_real, atol=KNEE_TOLERANCE)) # test bic/aic -> should be better for knee assert slope_fit_k.gof['AIC'][0] < slope_fit_f.gof['AIC'][0] @@ -41,10 +41,10 @@ def test_irasa_knee_peakless(load_knee_aperiodic_signal, fs, exponent, knee_freq # knee model -@pytest.mark.parametrize('exponent, knee_freq', EXP_KNEE_COMBO, scope='session') +@pytest.mark.parametrize('exponent, knee', EXP_KNEE_COMBO, scope='session') @pytest.mark.parametrize('fs', FS, scope='session') @pytest.mark.parametrize('osc_freq', OSC_FREQ, scope='session') -def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee_freq, osc_freq): +def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee, osc_freq): f_range = [0.1, 100] irasa_out = irasa(load_knee_cmb_signal, fs, f_range, psd_kwargs={'nperseg': 4 * fs}) # test the shape of the output @@ -64,7 +64,7 @@ def test_irasa_knee_cmb(load_knee_cmb_signal, fs, exponent, knee_freq, osc_freq) knee_hat = slope_fit_k.aperiodic_params['Knee'][0] ** ( 1 / (2 * slope_fit_k.aperiodic_params['Exponent_1'][0] + slope_fit_k.aperiodic_params['Exponent_2'][0]) ) - knee_real = knee_freq ** (1 / np.abs(exponent)) + knee_real = knee ** (1 / np.abs(exponent)) assert bool(np.isclose(knee_hat, knee_real, atol=KNEE_TOLERANCE)) # test bic/aic -> should be better for knee assert slope_fit_k.gof['AIC'][0] < slope_fit_f.gof['AIC'][0] diff --git a/tests/test_irasa_sprint.py b/tests/test_irasa_sprint.py index 1cc0e86..e4ded71 100644 --- a/tests/test_irasa_sprint.py +++ b/tests/test_irasa_sprint.py @@ -5,16 +5,21 @@ from pyrasa.irasa import irasa_sprint from pyrasa.utils.peak_utils import get_band_info -from .settings import MIN_R2_SPRINT, TOLERANCE +from .settings import EXPONENT, FS, MIN_R2_SPRINT set_random_seed(42) -def test_irasa_sprint(ts4sprint): +@pytest.mark.parametrize('fs', FS, scope='session') +@pytest.mark.parametrize('exponent_1', EXPONENT, scope='session') +@pytest.mark.parametrize('exponent_2', EXPONENT, scope='session') +def test_irasa_sprint(ts4sprint, fs, exponent_1, exponent_2): irasa_tf = irasa_sprint( ts4sprint[np.newaxis, :], - fs=500, - band=(1, 100), + # hop=25, + # win_duration=1, + fs=fs, + band=(0.1, 100), freq_res=0.5, ) @@ -24,11 +29,12 @@ def test_irasa_sprint(ts4sprint): # ) assert slope_fit.gof['r_squared'].mean() > MIN_R2_SPRINT - assert np.isclose(slope_fit.aperiodic_params.query('time < 7')['Exponent'].mean(), 1, atol=TOLERANCE) - assert np.isclose(slope_fit.aperiodic_params.query('time > 7')['Exponent'].mean(), 2, atol=TOLERANCE) + assert np.isclose(np.mean(slope_fit.aperiodic_params.query('time < 7')['Exponent']), np.abs(exponent_1), atol=0.5) + assert np.isclose(np.mean(slope_fit.aperiodic_params.query('time > 7')['Exponent']), np.abs(exponent_2), atol=0.5) # check basic peak detection df_peaks = irasa_tf.get_peaks( + cut_spectrum=(1, 40), smooth=True, smoothing_window=1, min_peak_height=0.01, @@ -50,7 +56,7 @@ def test_irasa_sprint(ts4sprint): pass # one missing burst is ok for now - assert np.isclose(n_peaks, 8, atol=1) + assert np.isclose(n_peaks, 7, atol=4) df_beta = get_band_info(df_peaks, freq_range=(20, 30), ch_names=[]) beta_peaks = df_beta.query('pw > 0.10') @@ -66,18 +72,21 @@ def test_irasa_sprint(ts4sprint): pass # one missing burst is ok for now - assert np.isclose(n_peaks, 12, atol=1) + assert np.isclose(n_peaks, 11, atol=4) # test settings -def test_irasa_sprint_settings(ts4sprint): +@pytest.mark.parametrize('fs', [1000], scope='session') +@pytest.mark.parametrize('exponent_1', [-1], scope='session') +@pytest.mark.parametrize('exponent_2', [-2], scope='session') +def test_irasa_sprint_settings(ts4sprint, fs): # test dpss import scipy.signal as dsp irasa_sprint( ts4sprint[np.newaxis, :], - fs=500, - band=(1, 100), + fs=fs, + band=(0.1, 100), win_func=dsp.windows.dpss, freq_res=0.5, ) @@ -86,7 +95,7 @@ def test_irasa_sprint_settings(ts4sprint): with pytest.raises(ValueError): irasa_sprint( ts4sprint[np.newaxis, :], - fs=500, + fs=fs, band=(1, 100), win_func=dsp.windows.dpss, dpss_settings_time_bandwidth=1,