def get_wavelet_var(wavelet, H=0.3, samp_size=1024, plot_sil=1):
f = FBM(n=samp_size, hurst=H, length=0.5, method='daviesharte')
fbm_sample = f.fbm()
t_values = f.times()
cA, cD = pywt.dwt(fbm_sample, wavelet)
M = len(cD)
R = np.zeros(M + 1)
for k in range(M + 1):
cD_shift = shift(cD, k, cval=0)
R[k] = np.sum(cD * np.conjugate(cD_shift))
print(M + 1)
print(np.argmin(R))
plt.plot(R)
plt.show()
AutoCorr_mat = toeplitz(R[0:M], R[0:M]) + 2.5
#pdb.set_trace()
mean_corr = (np.sum(AutoCorr_mat) - M * AutoCorr_mat[0][0]) / (M**2 - M)
#print(mean_corr)
max_corr = np.max(R[1:])
#pdb.set_trace()
U, S, V = svd(AutoCorr_mat)
if (plot_sil != 1):
plt.plot(np.log10(np.arange(M) + 1), np.log10(S))
return S[0], 1 + (M - 1) * mean_corr
def simulate_fbm_df(d_const, n_dim, n_steps, dt, loc_std=0, hurst=0.5):
"""Simulate and output a single trajectory of fractional brownian motion in a specified number of dimensions.
:param d_const: diffusion constant in um2/s
:param n_dim: number of spatial dimensions for simulation (1, 2, or 3)
:param n_steps: trajectory length (number of steps)
:param dt: timestep size (s)
:param loc_std: standard deviation for Gaussian localization error (um)
:param hurst: Hurst index in range (0,1), hurst=0.5 gives brownian motion
:return: trajectory dataframe (position in n_dim dimensions, at each timepoint)
"""
np.random.seed()
# create fractional brownian motion trajectory generator
# Package ref: https://github.com/crflynn/fbm
f = FBM(n=n_steps, hurst=hurst, length=n_steps * dt, method='daviesharte')
# get time list and trajectory where each timestep has and n-dimensional vector step size
t_values = f.times()
fbm_sim = []
for dim in range(n_dim):
fbm_sim.append(f.fbm() * np.sqrt(2 * d_const))
df = pd.DataFrame()
for i in range(n_steps):
x_curr = [fbm_sim[dim][i] for dim in range(n_dim)]
# for initial time point, start at origin and optionally add noise
if i == 0:
x_obs_curr = [
x_curr[dim] + loc_std * np.random.randn()
for dim in range(n_dim)
]
# for latter timepoints, set "current" position to position determined by displacement out of the last timepoint
else:
x_obs_curr = x_obs_next
# Get next n-dimensional position
x_next = [fbm_sim[dim][i + 1] for dim in range(n_dim)]
# Get noise to add to next position, to get the observed position
noise_next = [loc_std * np.random.randn() for _dim in range(n_dim)]
x_obs_next = [x_next[dim] + noise_next[dim] for dim in range(n_dim)]
# break current and next position into vector and magnitdue displacements
dx_obs = [x_obs_next[dim] - x_obs_curr[dim] for dim in range(n_dim)]
dx = [x_next[dim] - x_curr[dim] for dim in range(n_dim)]
dr_obs = np.linalg.norm(dx_obs)
dr = np.linalg.norm(dx)
t = t_values[i]
# Add timestep data to dataframe
data = {
't_step': t,
'x': x_curr,
'x_obs': x_obs_curr,
'dx': dx,
'dx_obs': dx_obs,
'dr': dr,
'dr_obs': dr_obs
}
df = df.append(data, ignore_index=True)
return df
from fbm import FBM import matplotlib.pyplot as plt f = FBM(n=100, hurst=0.9, length=1, method='daviesharte') # Generate a fBm realization fbm_sample = f.fbm() # Generate a fGn realization fgn_sample = f.fgn() # Get the times associated with the fBm t_values = f.times() plt.plot(t_values, fbm_sample) plt.show()
phi = norm.cdf(u * T**(-H) + c2 * T**(1 - H))
phi = norm.cdf((u + c2 * T) / (sigma * T**H))
print("u=%.4f H=%.4f" % (u, H))
print("theoretical upper bound = %.3f" %
(1 - phi + exp(-2 * u * c2 * T**(1 - 2 * H) / sigma**2) * phi))
## =================================================================
## 分形布朗运动模拟
## =================================================================
from fbm import FBM
from tqdm import trange
f = FBM(n=1000, hurst=H, length=T, method='daviesharte')
for i in trange(实验次数, ncols=80):
fbm_ts = f.times()
fbm_asset = f.fbm()
fbm_asset = [
u + c2 * fbm_ts[i] - amp**H * fbm_asset[i]
for i in range(len(fbm_asset))
]
for i in range(len(fbm_asset)):
if fbm_asset[i] < 0:
fbm_ts = fbm_ts[:i + 1]
fbm_asset = fbm_asset[:i + 1]
break
if fbm_asset[-1:][0] < 0:
#print("Ruin time=",fbm_ts[len(fbm_asset)-1],"asset=",fbm_asset[-1:][0])
破产次数 += 1
# flake8: noqa
from fbm import FBM
import matplotlib.pyplot as plt
import time
import math
import numpy as np
def h(s):
# return 0.499*math.sin(t) + 0.5
# return 0.6 * t + 0.3
return 0.5 * np.exp(-8.0 * s**2)
fbm_generator = FBM(2**8, 0.85)
t = fbm_generator.times()
fbm_realization = fbm_generator.fbm()
fgn_realization = fbm_generator.fgn()
h_t = np.array(h(fbm_realization))
plt.plot(t, fbm_realization)
plt.plot(t, h_t)
# plt.plot(t[0:-1], fgn_realization)
plt.show()
# Generate Unaltered Test Data
data_x_test = np.sort(
np.random.uniform(low=-(1 + Extrapolation_size),
high=(1 + Extrapolation_size),
size=N_test))
data_y_test = unknown_f(data_x_test)
# Generate Unaltered Training Data
data_x = np.sort(np.random.uniform(low=-1, high=1, size=N_train))
data_y = unknown_f(data_x)
else:
# Generate Fractional Data
FBM_Generator = FBM(n=N_data, hurst=0.75, length=1, method='daviesharte')
data_y_outputs_full = FBM_Generator.fbm()
data_x_outputs_full = FBM_Generator.times()
# Partition Data
data_x, data_x_test, data_y, data_y_test = train_test_split(
data_x_outputs_full,
data_y_outputs_full,
test_size=Test_set_proportion,
random_state=2020,
shuffle=True)
# Reorder Train Set
indices_train = np.argsort(data_x)
data_x = data_x[indices_train]
data_y = data_y[indices_train]
# Reorder Test Set
indices_test = np.argsort(data_x_test)
def test_FBM_times(n_good, hurst_good, length_good, fbm_method_good):
f = FBM(n_good, hurst_good, length_good, fbm_method_good)
ts = f.times()
assert isinstance(ts, np.ndarray)
assert len(ts) == n_good + 1