def biased_regresser(size, ty, beta=1.0):
#
value = []
#
if dataset_name == "SS":
## Best fit for citation dataset
value = lognorm.rvs(1.604389429520587,
48.91174576443938,
77.36426476362374,
size=size)
elif dataset_name == "JEE":
# Best fit for JEE scoress
if ty == 0:
value = johnsonsu.rvs(-1.3358254338685507,
1.228621987785165,
-16.10471198333935,
25.658144591068066,
size=size) ## Men
if ty == 1:
value = johnsonsu.rvs(-1.1504808824385124,
1.3649066883190795,
-12.879957294149737,
27.482272133428403,
size=size) ## Women
else:
print("Unknown dataset_name=%x", dataset_name)
exit()
#
if ty == 1: value *= (beta + 1e-4)
#
return [{'val': val, 'real_type': ty} for val in value]
def johnson_su_pdf(self, system_type, order=None, _error=None, size=1):
"""
Parameters
----------
system_type
order
_error
Returns
-------
"""
params = self.config[_error][system_type][order][1]
shape, shape, location, _scale, bounds = params
rv = johnsonsu.rvs(shape, shape, loc=location, scale=_scale, size=size)
import pdb
pdb.set_trace()
while not ((-100 < rv) & (rv < 100)):
rv = johnsonsu.rvs(shape,
shape,
loc=location,
scale=_scale,
size=size)
return rv / 100
def headway_j(self, flow_rate):
assert flow_rate >= F_RATES[
0] / 2, f'Input flow rate ({flow_rate}) should not be smaller than {F_RATES[0]/2}v/h for calculating the headway!'
#assert flow_rate <= F_RATES[-1], f'Input flow rate ({flow_rate}) should not be bigger than {F_RATES[-1]}v/h, the saturation rate of one lane!'
headway = {
F_RATES[0]: lambda: johnsonsb.rvs(0.3, 1.8, loc=0.85, scale=130),
F_RATES[1]: lambda: johnsonsb.rvs(0.9, 0.71, loc=0.85, scale=60),
F_RATES[2]:
lambda: johnsonsb.rvs(2.49, 0.71, loc=0.85, scale=104.57),
F_RATES[3]:
lambda: johnsonsb.rvs(3.71, 0.98, loc=0.85, scale=104.57),
F_RATES[4]:
lambda: johnsonsu.rvs(-2.18, 1.15, loc=0.8, scale=0.52),
F_RATES[5]:
lambda: johnsonsu.rvs(-2.54, 1.31, loc=0.47, scale=0.46),
F_RATES[6]:
lambda: johnsonsu.rvs(-2.49, 1.49, loc=0.55, scale=0.49)
}
if flow_rate <= F_RATES[0]:
result = min(
900, headway[F_RATES[0]]() * F_RATES[0] / flow_rate
) # headyway should be smaller than 900s, which is the normal measure period of traffic flow
return result
for i in range(1, len(F_RATES)):
if flow_rate <= F_RATES[i]:
ratio = (flow_rate - F_RATES[i - 1]) / (F_RATES[i] -
F_RATES[i - 1])
result = (1 - ratio) * headway[F_RATES[
i - 1]]() + ratio * headway[F_RATES[i]]()
result = max(result, 0)
return result
result = max(headway[F_RATES[-1]]() * F_RATES[-1] / flow_rate,
0) # headyway should be bigger than 0
return result
def simulateDelay(currentNetwork):
'''
@description: generates a delay based on the appropriate distribution
'''
wifiDelay = [3.0659475327,
14.6918344498] # min and max delay observed for wifi
cellularDelay = [4.2531193161,
14.3172883892] # min and max delay observed for 3G
if currentNetwork == 1: # wifi
# johnson su in python (fitter.Fitter.fit()) and t location-scale in matlab (allfitdist)
# in python, error is higher for t compared to johnson su
delay = min(
max(
johnsonsu.rvs(0.29822254217554717,
0.71688524931466857,
loc=6.6093350624107909,
scale=0.5595970482712973), wifiDelay[0]),
wifiDelay[1])
else:
# t in python (fitter.Fitter.fit()) and t location-scale in matlab (allfitdist)
delay = min(
max(
t.rvs(0.43925241212097499,
loc=4.4877772816533934,
scale=0.024357324434644639), cellularDelay[0]),
cellularDelay[1])
if DEBUG >= 1:
print(
colored(
"Delay for " + str(availableNetworkName[currentNetwork - 1]) +
": " + str(delay), "cyan"))
# input()
return delay
def computeDelay(self):
'''
description: generates a delay for switching between WiFi networks, which is modeled using Johnson’s SU distribution (identified as a best fit to 500 delay values),
and delay for switching between WiFi and cellular networks, modeled using Student's t-distribution (identified as best fit to 500 delay values)
args: self
returns: a delay value
'''
wifiDelay = [3.0659475327, 14.6918344498] # min and max delay observed for wifi in some real experiments; used as caps for the delay generated
cellularDelay = [4.2531193161, 14.3172883892] # min and max delay observed for 3G in some real experiments; used as caps for the delay generated
if networkList[getListIndex(networkList, self.currentNetwork)].getWirelessTechnology() == 'WiFi':
delay = min(max(johnsonsu.rvs(0.29822254217554717, 0.71688524931466857, loc=6.6093350624107909, scale=0.5595970482712973), wifiDelay[0]), wifiDelay[1])
else:
delay = min(max(t.rvs(0.43925241212097499, loc=4.4877772816533934, scale=0.024357324434644639), cellularDelay[0]), cellularDelay[1])
return delay
def lift(self):
NStates = int(-2.5 + 0.5 * np.sqrt(25 + 4 * len(self.state)))
Means = self.state[:NStates]
Cov = self.state[NStates:NStates + NStates**2].reshape(
NStates, NStates)
Params = self.state[NStates + NStates**2:]
vals, vecs = np.linalg.eigh(Cov)
vals[vals < 0] = 0.0
randvals = np.zeros((NStates, self.NRuns))
for ii in xrange(0, NStates):
randvals[ii, :] = johnsonsu.rvs(Params[4 * ii],
Params[4 * ii + 1],
loc=Params[4 * ii + 2],
scale=Params[4 * ii + 3],
size=self.NRuns)
states = np.dot(vecs, randvals).T
randvec = states.reshape(-1) + np.tile(Means, self.NRuns)
return microMeanJohnson(self.time, probRound(randvec), self.perad)
def gen_sample(self, n):
return johnsonsu.rvs(self.a,
self.b,
loc=self.mu,
scale=self.sigma,
size=n)
x = np.linspace(johnsonsu.ppf(0.01, a, b),
johnsonsu.ppf(0.99, a, b), 100)
ax.plot(x, johnsonsu.pdf(x, a, b),
'r-', lw=5, alpha=0.6, label='johnsonsu pdf')
# Alternatively, the distribution object can be called (as a function)
# to fix the shape, location and scale parameters. This returns a "frozen"
# RV object holding the given parameters fixed.
# Freeze the distribution and display the frozen ``pdf``:
rv = johnsonsu(a, b)
ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
# Check accuracy of ``cdf`` and ``ppf``:
vals = johnsonsu.ppf([0.001, 0.5, 0.999], a, b)
np.allclose([0.001, 0.5, 0.999], johnsonsu.cdf(vals, a, b))
# True
# Generate random numbers:
r = johnsonsu.rvs(a, b, size=1000)
# And compare the histogram:
ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2)
ax.legend(loc='best', frameon=False)
plt.show()
def SAimage_fft_2(N_total=500,
rms=3,
skewness=1,
kurtosis=3,
corlength_x=10,
corlength_y=10,
alpha=0.9,
th=1000.0,
non_Gauss=True,
corr=False):
'''
Input:
Generation of non-Gaussian surfaces with predetermined
1. N_total: The dimension of our plane
2. Standard deviation (rms)
3. Skewness (skew)
4. Kurtosis (kurt)
5. Correlation lengths (ksix, ksiy)
6. Roughness exponent (aplha)
7. The threshold we choose to binarize our image
8. non_Gaus: is True if we want the non-Gaussian simulation, and False when we want the Gaussian one
9. corr: True if you want to illustrate correlation functions
The input values of kurtosis and skewness should satisfy the inequality
kurtosis > 1 + skewness^2
The method is described in Yang et al. CMES, vol.103, no.4, pp.251-279,2014
We use pearson translation to transform random noise to non-gaussian series and
inverse Fourier transform to generate Gaussian surfaces.
The method is implemented in three steps
1. Generation of a Gaussian self-affine surface z_gs with rms, ksix,ksiy,alpha
2. Generation of non-Gaussian noise z_ngn with mu,rms,skew,kurt
3. Arranging z_ngn according to the spatial arrangement of z_g to get a non-Gaussian self-affine surface z_ngs
'''
##################################################################
#
# Coded in Python by SEBASTIAN KORSAK © 2021 ([email protected])
# Original file in MATLAB by Dr. V. Costantoudis
#
##################################################################
# Input
N = N_total
numpoints = N
hhcf_y = np.zeros(int(N / 2))
Pyy = 0.0
# input moments and spatial parameters
skew = skewness
kurt = kurtosis
ksix = corlength_x
ksiy = corlength_y
alpha = alpha
mu = 0
# 1st step: Generation of a Gaussian surface
# Determine the autocorrelation function R(tx,ty)
R = np.zeros([numpoints + 1, numpoints + 1])
txmin, txmax, tymin, tymax = -numpoints / 2, numpoints / 2, -numpoints / 2, numpoints / 2
dtx, dty = (txmax - txmin) / (numpoints), (tymax - tymin) / (numpoints)
tx = np.arange(txmin, txmax, dtx)
ty = np.arange(tymin, tymax, dty)
for txx in tx:
for tyy in ty:
R[int(txx + txmax + 1), int(tyy + tymax + 1)] = (
(rms**2) *
np.exp(-(abs(np.sqrt((txx / ksix)**2 +
(tyy / ksiy)**2)))**(2 * alpha)))
# According to the Wiener-Khinchine theorem FR is the power spectrum of the desired profile
FR = np.fft.fft2(R, s=[numpoints, numpoints])
AMPR = np.sqrt(dtx**2 + dty**2) * abs(FR)
# 2nd step: Generate a white noise, normalize it and take its Fourier transform
X = np.random.rand(numpoints, numpoints)
aveX = X.mean(axis=0).mean(axis=0)
dif2X = (X - aveX)**2
stdX = np.sqrt(dif2X.mean(axis=0).mean(axis=0))
X = X / stdX
XF = np.fft.fft2(X, s=[numpoints, numpoints])
# 3nd step: Multiply the two Fourier transforms
YF = XF * np.sqrt(AMPR)
# 4th step: Perform the inverse Fourier transform of YF and get the desired surface
zaf = np.fft.ifft2(YF, s=[numpoints, numpoints])
z = np.real(zaf)
avez = z.mean(axis=0).mean(axis=0)
dif2z = (z - avez)**2
stdz = np.sqrt(dif2z.mean(axis=0).mean(axis=0))
z = ((z - avez) * rms) / stdz
# Define the fraction of the surface to be analysed
xmin, xmax, ymin, ymax = 0, N, 0, N
z_gs = z[xmin:xmax, ymin:ymax]
print(z_gs.shape)
Nh = xmax - xmin + 1
# For the Gaussian Surface Simulation
if not non_Gauss:
X = np.arange(0, N)
Y = np.arange(0, N)
X, Y = np.meshgrid(X, Y)
fig = plt.figure()
fig.set_figwidth(10)
fig.set_figheight(10)
ax = plt.axes(projection='3d')
ax.plot_surface(X, Y, z_gs, cmap='viridis', edgecolor='none')
ax.view_init(30, 150)
plt.title('Gaussian Surface', fontsize=16)
plt.show()
plt.imshow(z_gs < th,
cmap='gray',
origin='lower',
interpolation='none')
plt.title('Binarized Image from Gaussian Surface')
plt.show()
del R, AMPR, z
# For the Non-Gaussian Surface Simulator
if non_Gauss:
#2nd step: Generation of a non-Gaussian noise NxN
## Finding the parameters of JohnsonSU distribution
## Special thank to Max Pierini for this part of the code
coef, j_type, err = f_johnson_M(mu, rms, skew, kurt)
gamma, delta, xi, lam = coef
## Simulating from JohnsonSU distribution
z_ngn = johnsonsu.rvs(a=gamma, b=delta, loc=xi, scale=lam, size=[N, N])
#3rd step: Combination of z_gs with z_ngn to output a z_ngs
v_gs = z_gs.reshape(-1)
v_ngn = z_ngn.reshape(-1)
Igs = np.argsort(v_gs)
Ingn = np.argsort(v_ngn)
vs_gs = np.sort(v_gs)
vs_ngn = np.sort(v_ngn)
v_ngs = np.zeros(np.max(Igs) + 1)
for iv in range(N * N):
ivs = Igs[iv]
v_ngs[ivs] = vs_ngn[iv]
X = np.arange(0, N)
Y = np.arange(0, N)
X, Y = np.meshgrid(X, Y)
z_ngs = -v_ngs.reshape(N, N)
# Creating color map
my_cmap = plt.get_cmap('hot')
fig = plt.figure()
fig.set_figwidth(10)
fig.set_figheight(10)
ax = plt.axes(projection='3d')
ax.set_xlim(0, N)
ax.set_ylim(0, N)
ax.set_zlim(-1000, 5000)
ax.plot_surface(X, Y, z_ngs, cmap=my_cmap, edgecolor='black')
ax.view_init(30, 150)
plt.title('Non-Gaussian Surface', fontsize=16)
# Add a color bar which maps values to colors.
plt.show()
plt.imshow(z_ngs > th,
cmap='gray',
origin='lower',
interpolation='none')
plt.title('Binarized Image from Non-Gaussian Surface', fontsize=16)
plt.show()
if corr:
# Correlation Functions
# a. 1-D height-height correlation function
inpsur = z_ngs
hhcf1d = np.zeros(N // 2)
rdif = np.zeros(N // 2)
for ndif in range(N // 2):
surf1 = inpsur[0:N, 0:(N - ndif)]
surf2 = inpsur[0:N, ndif:N]
difsur2 = (surf1 - surf2)**2
hhcf1d[ndif] = np.sqrt(difsur2.mean(axis=0).mean(axis=0))
rdif[ndif] = ndif
plt.loglog(rdif, hhcf1d)
plt.grid()
plt.xlabel('log(r(nm))')
plt.ylabel('log(G(r) (nm))')
plt.title(
'1-D height-height correlation function (non-Gaussian surface)'
)
plt.show()
