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 test_FBM_fgn_adjust_rnd(n_good, hurst_good, length_good, fbm_method_good, adjust_rnd_good): f = FBM(n_good, hurst_good, length_good, fbm_method_good) fgn_sample = f.fgn() fgn_sample = f.fgn(adjust_rnd_good) assert isinstance(fgn_sample, np.ndarray) assert len(fgn_sample) == n_good
def daviesharte_to_hosking_fallback_test(self): # Low n, high hurst f = FBM(5, 0.99, 1, method='daviesharte') # This only works on py3 # with self.assertWarns(Warning): # s = f.fbm() with warnings.catch_warnings(record=True) as w: s = f.fbm() self.assertEqual(len(w), 1) self.assertIn('invalid for Davies-Harte', str(w[-1].message)) self.assertEqual('hosking', f.method)
def generate_labeled_data(n_samples_each, sample_length, H_1, H_2): """ Generates sample fBm paths using the fbm module.""" data_1 = np.array([FBM(n=sample_length, hurst=H_1, length=1, method='daviesharte').fbm() for j in range(n_samples)]) permutation_1 = np.random.permutation(data_1.shape[0]) data_1 = data_1[permutation_1] data_2 = np.array([FBM(n=sample_length, hurst=H_2, length=1, method='daviesharte').fbm() for j in range(n_samples)]) permutation_2 = np.random.permutation(data_2.shape[0]) data_2 = data_2[permutation_2] data_1 = np.pad(data_1, ((0,0), (0,1)), mode='constant', constant_values=H_1) data_2 = np.pad(data_1, ((0,0), (0,1)), mode='constant', constant_values=H_2) return data_1, data_2
def getPriceTrajectory(N_prices, current, iterations, dt, prob, m0, N_mo, return_book): bid = np.zeros(N_prices) ask = np.zeros(N_prices) ############################metaorders_initialization + fractional brownian noise fbm = FBM(n=iterations, hurst=0.75, length=iterations * dt, method="daviesharte").fgn() # fbm = m0*np.random.normal(0,dt,iterations) #rates = np.ones(N_mo)*m0*dt #rates = np.floor(rates).astype(int) + np.random.binomial(1,rates-np.floor(rates).astype(int)) noise = m0 * fbm noise = np.floor(noise).astype(int) noise += np.random.binomial(1, m0 * fbm - noise) D = prob / (2 * dt) ll = (current / D) #Latent Liquidity index = int((N_prices / 2) + 1) ask[index:] = ll * np.arange(index - N_prices / 2, N_prices / 2, 1) ask = ask.astype(int) + np.random.binomial(1, ask - ask.astype(int)) bid[:index - 1] = ll * np.arange(N_prices / 2, 1, -1) bid = bid.astype(int) + np.random.binomial(1, bid - bid.astype(int)) #orders taken from a poisson distribution of parameter J*dt orders = np.reshape(np.random.poisson(current * dt, size=2 * iterations), (iterations, 2)) return rd_w_metaorders(ask, bid, iterations, orders, noise, prob, return_book)
class FBM2D: def __init__(self, H, N, L): """ init of FBM2D parameters: H : Hurst index with 0 < H < 1 N : number of observations along both dimensions, constructed field will contain (N x N) points L : number of one dimensional fbm used in construction of 2D Fields """ if H <= 0 or H >= 1: raise ValueError("Hurst parameter must be in interval (0, 1).") self.H = H self.N = N self.L = L self.fbb_gen = FBM( n=int(1.5 * self.N), hurst=self.H, length=1.5) #init generator for fractional Brownian motion def fbs(self): """ returnes fractional Brownian surface (scalar fractional Brownian motion) in 2D """ #generate self.L bands with equidistant angles theta between band and x-axis theta_i = np.linspace(0, np.pi, self.L + 1)[:-1] #angles oneDfbm = np.zeros((self.L, int(1.5 * self.N) + 1)) for i in range(self.L): fGn = self.fbb_gen.fgn() oneDfbm[i, 1:] = np.sqrt( np.sqrt(np.pi) * math.gamma(1 + self.H) / math.gamma(1 / 2 + self.H)) * np.cumsum(fGn) # perform turbing band algortihm in fortran return f.turningband2d(oneDfbm, theta_i, self.N)
class FractionalBrownianMotion(BlackScholes): def __init__(self, drift, volatility, hurst, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend=0, **keywords): super(FractionalBrownianMotion, self).__init__(drift, volatility, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend, **keywords) self.hurst = hurst self.fBM = FBM(n=nb_dates, hurst=hurst, length=maturity, method='cholesky') self._nb_stocks = self.nb_stocks def _generate_one_path(self): """Returns a nparray (nb_stocks * nb_dates) with prices.""" path = np.empty((self._nb_stocks, self.nb_dates + 1)) for stock in range(self._nb_stocks): path[stock, :] = self.fBM.fbm() + self.spot # print("path",path) return path def generate_one_path(self): return self._generate_one_path()
def generate_data(n_samples, sample_length, H): """ Generates sample fBm paths using the fbm module.""" data = np.array([FBM(n=sample_length, hurst=H, length=1, method='daviesharte').fbm() for j in range(n_samples)]) permutation = np.random.permutation(data.shape[0]) shuffled_data = data[permutation] return shuffled_data
def __init__(self, H, N, L): """ init of FBM2D parameters: H : Hurst index with 0 < H < 1 N : number of observations along both dimensions, constructed field will contain (N x N) points L : number of one dimensional fbm used in construction of 2D Fields """ if H <= 0 or H >= 1: raise ValueError("Hurst parameter must be in interval (0, 1).") self.H = H self.N = N self.L = L self.fbb_gen = FBM( n=int(1.5 * self.N), hurst=self.H, length=1.5) #init generator for fractional Brownian motion
def setUp(self): # For seed = 42, n = 5, H = 0.7, L = 1 self.realizations = { 'fbm': { 'daviesharte': np.array([ 0., 0.29326393, 0.57918201, 0.69236348, 1.17425979, 1.33485224 ]), 'cholesky': np.array([ 0., 0.16100061, 0.16997488, 0.38610856, 0.92328558, 1.02602397 ]), 'hosking': np.array([ 0., 0.16100061, 0.16997488, 0.38610856, 0.92328558, 1.02602397 ]), }, 'fgn': { 'daviesharte': np.array([ 0.29326393, 0.28591808, 0.11318147, 0.48189631, 0.16059245 ]), 'cholesky': np.array([ 0.16100061, 0.00897426, 0.21613369, 0.53717702, 0.10273839 ]), 'hosking': np.array([ 0.16100061, 0.00897426, 0.21613369, 0.53717702, 0.10273839 ]), } } self.seed = 42 self.n = 5 self.H = 0.7 self.L = 1 self.t = np.linspace(0, self.L, self.n + 1) self.cls_objects = { 'daviesharte': FBM(self.n, self.H, self.L, method='daviesharte'), 'cholesky': FBM(self.n, self.H, self.L, method='cholesky'), 'hosking': FBM(self.n, self.H, self.L, method='hosking'), }
def d_h_test(H=None,f=None): if not H: H = [x / 100 for x in range(1, 100)] fractal_d = [] for h in H: if not f: f = FBM(n=2000, hurst=h, length=1, method='daviesharte') series = f.fbm() G = VG(series) #Y = nx.degree_histogram(G) #print(Y) X, Y = GC(G) LogXI, LogYI = [], [] for x in X: LogXI.append(math.log(x)) for y in Y: LogYI.append(math.log(y)) fractal_d.append(-1 * np.polyfit(LogXI, LogYI, 1)[0]) #print(Y) return fractal_d
def __init__(self, drift, volatility, hurst, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend=0, **keywords): super(FractionalBlackScholes, self).__init__(drift, volatility, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend, **keywords) self.drift = drift self.hurst = hurst self.fBM = FBM(n=nb_dates, hurst=self.hurst, length=maturity, method='hosking')
def __init__(self, drift, volatility, hurst, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend=0, **keywords): super(FractionalBrownianMotion, self).__init__(drift, volatility, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend, **keywords) self.hurst = hurst self.fBM = FBM(n=nb_dates, hurst=hurst, length=maturity, method='cholesky') self._nb_stocks = self.nb_stocks
def fOU_generator(a,n=0.3,h=0.2,length=300): fbm_increments = np.diff(FBM(length, h).fbm()) # X(t+1) = X(t) - a(X(t)-m) + n(W(t+1)-W(t)) x0 = np.random.normal(1,0.1) x0 = 0.5 m = x0 price = [x0] for i in range(length): p = price[i] - a*(price[i]-m) + n*fbm_increments[i] price.append(p) return np.array(price)
def generate(M, N, h_x=0.8, h_y=0.8, scale=1., signature=False, BM=False, dim_BM=2): if BM: X = brownian(M - 1, dim_BM, time=1.) Y = brownian(N - 1, dim_BM, time=1.) else: fbm_generator_X = FBM(M - 1, h_x) fbm_generator_Y = FBM(N - 1, h_y) x = scale * fbm_generator_X.fbm() y = scale * fbm_generator_Y.fbm() X = AddTime().fit_transform([x])[0] Y = AddTime().fit_transform([y])[0] if signature: X = iisignature.sig(X, 5, 2) Y = iisignature.sig(Y, 5, 2) X0 = np.zeros_like(X[0, :].reshape(1, -1)) X0[0, 0] = 1. X = np.concatenate([X0, X]) Y = np.concatenate([X0, Y]) return X, Y
class FractionalBlackScholes(BlackScholes): def __init__(self, drift, volatility, hurst, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend=0, **keywords): super(FractionalBlackScholes, self).__init__(drift, volatility, nb_paths, nb_stocks, nb_dates, spot, maturity, dividend, **keywords) self.drift = drift self.hurst = hurst self.fBM = FBM(n=nb_dates, hurst=self.hurst, length=maturity, method='hosking') def generate_one_path(self): """Returns a nparray (nb_stocks * nb_dates) with prices.""" path = np.empty((self.nb_stocks, self.nb_dates + 1)) fracBM_noise = np.empty((self.nb_stocks, self.nb_dates)) path[:, 0] = self.spot for stock in range(self.nb_stocks): fracBM_noise[stock, :] = self.fBM.fgn() for k in range(1, self.nb_dates + 1): previous_spots = path[:, k - 1] diffusion = self.diffusion_fct(previous_spots, (k) * self.dt) path[:, k] = (previous_spots + self.drift_fct(previous_spots, (k) * self.dt) * self.dt + np.multiply(diffusion, fracBM_noise[:, k - 1])) print("path", path) return path
def getPriceTrajectory(N_prices,current,iterations,dt,prob,m0,return_book,sigma): bid = np.zeros(N_prices) ask = np.zeros(N_prices) ############################metaorders_initialization + fractional brownian noise fbm = FBM(iterations, 0.75, iterations * dt,method="daviesharte").fgn() rates = np.ones(iterations)*m0*dt rates = np.floor(rates).astype(int) + np.random.binomial(1,rates-np.floor(rates).astype(int)) noise = sigma*fbm noise = np.floor(noise).astype(int) noise += np.random.binomial(1,sigma*fbm - noise) D = prob /(2* dt) ll = (current/D) #Latent Liquidity index = int((N_prices/2)+1) ask[index:] = ll * np.arange(index- N_prices/2, N_prices/2,1) ask = ask.astype(int) + np.random.binomial(1, ask - ask.astype(int)) bid[:index-1] = ll * np.arange(N_prices/2, 1, -1) bid = bid.astype(int) + np.random.binomial(1, bid - bid.astype(int)) #orders taken from a poisson distribution of parameter J*dt orders = np.reshape(np.random.poisson(current*dt, size = 2 * iterations), (iterations, 2)) ######################################computation of participation ratio of m0 wrt all the traded volume in T) [pt,v] = rd_w_metaorders(ask,bid,iterations,orders,noise,rates,prob,return_book) phi = 1./float(1+float(v/(1+sum(rates)))+float(sigma/(dt*m0))*np.mean(abs(fbm))) return [pt,phi]
elif mf_process == 2: # multifractal random walk (c_1=0.75, c_2=-0.05, N=32768) data_file = 'example_data/mrw07005n32768.mat' # Complete path to file current_dir = os.path.dirname(os.path.abspath(__file__)) data_file = os.path.join(current_dir, data_file) #------------------------------------------------------------------------------- # Load data #------------------------------------------------------------------------------- data = get_data_from_mat_file(data_file) else: from fbm import FBM f = FBM(2**15, 0.75) fgn_sample = f.fgn() fbm_sample = f.fbm() if mf_process == 10: data = fbm_sample if mf_process == 11: data = fgn_sample from fbm import FBM f = FBM(2**15, 0.75) data_1 = data #f.fbm() f = FBM(2**15, 0.6) data_2 = f.fbm() #------------------------------------------------------------------------------- # Setup analysis #-------------------------------------------------------------------------------
def HVG(series): ''' function HVG(series) convert time series to horizon visibility graph :return:networkx graph from time series ''' N = len(series) G = nx.Graph() for ta in range(N): ya = series[ta] criterion = 0 for tb in range(ta + 1, N): yb = series[tb] if yb >= criterion: if ya >= criterion: criterion = yb G.add_edge(ta,tb) else: break #edge_list.append([ta, tb]) return G if __name__ == '__main__': f = FBM(n=1000, hurst=0.5, length=1, method='daviesharte') #series = [x for x in range(50)] series = f.fbm() #series = [2,4,1,5,6,3,6] G = HVG(series) pro_draw.draw_graph(G) #print(G.number_of_edges())
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
nlength = 14 inclength = 40 #Load model model = keras.models.load_model(".\\good_DLFNNmodels\\model3densediff_n" + str(nlength - 1) + ".h5") multipath = [] multiexp = [] estmultiexp = [] esttime = [] #stitch together multifractional fbm for i in range(0, 10): Hsim = random.uniform(0, 1) randinclength = random.randrange(20) + inclength f = FBM(n=randinclength, hurst=Hsim, length=1, method='hosking') x = f.fbm() if i == 0: for p in x: multipath.append(p) multiexp.append(Hsim) else: checkpoint = multipath[-1] for p in x[1:]: multipath.append(checkpoint + p) multiexp.append(Hsim) #symmetric window analysis eitherside = int(np.floor(float(nlength) / 2.)) for i in range(eitherside, len(multipath) - eitherside): #for differencing
def fbm(self, n, hurst, length=1, method="daviesharte"): """One off sample of fBm.""" f = FBM(n, hurst, length, method) return f.fbm()
import matplotlib.pyplot as plt import datetime def calc_msd_correct(right, left): return (right - left) ** 2 iterations = 100 size = 5000 size1 = 20 # how much particles we have myarray = np.zeros((size1, size)) myarray2 = np.zeros((size1, size)) myWmsd = np.zeros((size1, size-1)) myWmsd2 = np.zeros((size1, size-1)) coeff = 0.5 f = FBM(size-1, 0.75) f2 = FBM(size-1, 0.5) for i in range(myarray.shape[0]): myarray[i] = f.fbm() myarray2[i] = f2.fbm() plt.figure() plt.plot(np.linspace(0, 1, size), myarray[0]) plt.plot(np.linspace(0, 1, size), myarray2[0]) plt.title('fBM particles') plt.show() print('save trajectories') #np.savetxt()
N_train = int(round((N_data * Test_set_proportion), 0)) N_test = int(round((N_data * Train_step_proportion), 0)) # 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]
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()
print(tf.__version__) from tensorflow import keras from fbm import FBM, MBM import numpy as np import random nlength = 14 #Load model model = keras.models.load_model(".\\good_DLFNNmodels\\model3densediff_n" + str(nlength - 1) + ".h5") #generate fbm example simulatedH = [] testH = [] for samples in range(0, 1000): Hsim = random.uniform(0, 1) f = FBM(n=nlength - 1, hurst=Hsim, length=1, method='hosking') x = np.transpose(pd.DataFrame(f.fbm()).values) xdiff = np.transpose(pd.DataFrame(f.fbm()).values[1:]) for j in range(1, len(x)): xdiff[0, j - 1] = x[j] - x[j - 1] # /(np.amax(x)-np.amin(x)) # print(x) # print(xdiff) exp_est = model.predict(xdiff) simulatedH.append(Hsim) testH.append(exp_est[0][0]) print('simulated: ', Hsim, 'predicted: ', exp_est) plt.figure() plt.plot(simulatedH, testH, 'b.') plt.plot([0, 1], [0, 1], 'r-')
from math import exp sigma = 0.55 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:
# 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()
def generate_data(n_samples, sample_length, H): return np.array([ FBM(n=sample_length, hurst=H, length=1, method='daviesharte').fbm() for j in range(n_samples) ])
hurst = [0.60, 0.70, 0.80] #[0.08, 0.10, 0.14, 0.20, 0.30, 0.40, 0.50] hurstSimu = np.zeros(len(hurst)) v = 0.3 m = -10.0 X0 = -10.0 P0 = 100.0 alpha = 5e-4 Ndays = 2000 delta = 1.0 / 2000 output = open('simulation1.txt', 'w') n = int(np.floor(Ndays / delta)) for i, H in enumerate(hurst): f = FBM(n=n, hurst=H, length=int(Ndays), method='daviesharte') fgn_sample = f.fgn() startTime = 8 endTime = 16 sampleFreInMinuts = 5 #X = rfsv.simXEuler(X0, fgn_sample, v, alpha, m, delta, Ndays) X = rfsv.simX(X0, fgn_sample, v, alpha, m, delta, Ndays) sigma = np.exp(X) P = rfsv.simPrice(P0, sigma, delta, Ndays) #P = rfsv.simPriceEuler(P0, sigma, delta, Ndays) logP = np.log(P) realizedVariance = rfsv.realizedVariance(logP, delta, Ndays, sampleFreInMinuts, startTime,