def FadingModel(self, Time=1, Graphs=False, Results=False):
"""
"""
from scipy.stats import rice
from scipy import integrate
#CALCULATING THE RICE CONTINUOUS DISTIBUTION
shape = 0.775
#MeanPowerGain = (1/Time) * integrate(pow(rice.logcdf(t, shape), 2), (t, 0, Time))
h = lambda x: pow(rice.logpdf(x, shape), 2)
MeanPowerGain, err = integrate.quad(h, 0, Time)
#PLOTING THE PROBABILITY DENSITY FUNCTION
if Graphs is True:
fig, ax = plt.subplots(1, 1)
x = linspace(rice.ppf(0.01, shape), rice.ppf(0.99, shape), 100)
ax.plot(x,
rice.pdf(x, shape),
'r-',
lw=5,
alpha=0.6,
label='Rice PDF')
rv = rice(shape)
ax.plot(x, rv.pdf(x), 'k-', lw=2, label='Frozen PDF')
r = rice.rvs(shape, size=1000)
ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2)
ax.legend(loc='best', frameon=False)
#PRINTING RESULTS
if Results is True:
print("Fading - Mean Power Gain: {}".format(
(1 / Time) * MeanPowerGain))
return (1 / Time) * MeanPowerGain
def _model_fit(self, x, b, off, sigma, scale):
"""Function defining the Gaussian model.
Parameters
----------
x : ndarray, shape (n_samples, )
Array for which we have to compute the PDF.
b : float
Distance between the reference point and the center of the
bivariate distribution.
off : float
Offset of the Rician model.
sigma : float
Standard deviation of the model.
scale : float
Scaling factor of the model.
Returns
-------
pdf : ndarray, shape (n_samples)
The associated PDF to x parametrize through b, off, sigma,
and scale.
"""
# The pdf with the Rice distribution should be in the interval 0-1
return rice.pdf(x, b, off, sigma) * scale
def _update_canvas(self):
"""
Update the figure when the user changes an input value.
:return:
"""
# Get the parameters from the form
loc = float(self.loc.text())
scale = float(self.scale.text())
shape_factor = float(self.shape_factor.text())
# Get the selected distribution from the form
distribution_type = self.distribution_type.currentText()
if distribution_type == 'Gaussian':
x = linspace(norm.ppf(0.001, loc, scale),
norm.ppf(0.999, loc, scale), 200)
y = norm.pdf(x, loc, scale)
elif distribution_type == 'Weibull':
x = linspace(weibull_min.ppf(0.001, shape_factor),
weibull_min.ppf(0.999, shape_factor), 200)
y = weibull_min.pdf(x, shape_factor, loc, scale)
elif distribution_type == 'Rayleigh':
x = linspace(rayleigh.ppf(0.001, loc, scale),
rayleigh.ppf(0.999, loc, scale), 200)
y = rayleigh.pdf(x, loc, scale)
elif distribution_type == 'Rice':
x = linspace(rice.ppf(0.001, shape_factor),
rice.ppf(0.999, shape_factor), 200)
y = rice.pdf(x, shape_factor, loc, scale)
elif distribution_type == 'Chi Squared':
x = linspace(chi2.ppf(0.001, shape_factor),
chi2.ppf(0.999, shape_factor), 200)
y = chi2.pdf(x, shape_factor, loc, scale)
# Clear the axes for the updated plot
self.axes1.clear()
# Display the results
self.axes1.plot(x, y, '')
# Set the plot title and labels
self.axes1.set_title('Probability Density Function', size=14)
self.axes1.set_xlabel('x', size=12)
self.axes1.set_ylabel('Probability p(x)', size=12)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Update the canvas
self.my_canvas.draw()
def single_likelihood(self, source_locations, l, z):
d = compute_distance(source_locations.reshape(-1, 2), l.reshape(-1, 2))
rss = self.rss_noiseless(d)
fading = rss - z
if np.all(fading < 0):
# ALL source locations have neg. fading, ignore this measurement
p = np.ones(fading.shape)
else:
p = rice.pdf(fading,
self.rice_b,
loc=self.rice_loc,
scale=self.sigma)
return p
def skewed_data(direction='left', amount='medium'):
'''Generate data with a left or right skew.
The amount can be:
'low' - A low amount of skew
'medium' - A medium amount of skew
'high' - A high amount of skew
'''
x = np.linspace(0, 1, 1000)
if amount == 'medium':
y = rice.pdf((x + 0.05) * 5, 1.5) + 0.025
else:
raise ArugmentError("illegal amount: {}".format(amount))
# Flip
if direction == 'right':
y = y[::-1]
return x, y
def __parametrization__(self, x, norm_factor, v, loc, sigma):
"""Function to parametrise the Rician PDF
Parameters
----------
x : 1d-array
Array containing the x values in order to compute the PDF
norm_factor: double
Amplitude of the Rician representation
v: double
Distance to center of the Rician representation
loc: double
Location of the Rician representation
sigma: double
Scale of the Rician representation
Returns
-------
pdf: 1d-array
Return the Gaussian PDF according the parameters
"""
return rice.pdf(x, v, loc, sigma) / norm_factor
def __Parametrization__(self, x, norm_factor, v, loc, sigma):
"""Function to parametrise the Rician PDF
Parameters
----------
x : 1d-array
Array containing the x values in order to compute the PDF
norm_factor: double
Amplitude of the Rician representation
v: double
Distance to center of the Rician representation
loc: double
Location of the Rician representation
sigma: double
Scale of the Rician representation
Returns
-------
pdf: 1d-array
Return the Gaussian PDF according the parameters
"""
return rice.pdf(x, v, loc, sigma) / norm_factor
ret, self.n_step)
GLOBAL_LOGGER.get_tb_logger().add_scalar('N_CH_TX_OK_' + str(self.id),
n_successful_tx, self.n_step)
self.change_position()
return float(n_successful_tx)
if __name__ == '__main__':
# err = tx_error_rate_for_n_bytes(32, 6, 1.0221785259170593, 0.000125, 180000.0)
# print(err)
for x in range(50):
err = tx_error_rate_for_n_bytes(50., x + 1, db_to_dec(0), 1e-4, 180e3)
print(err, x)
from scipy.stats import expon
import matplotlib.pyplot as plt
scale = 0.559
shape = 0.612 / scale
print(rice.rvs(shape, scale=scale))
fig, ax = plt.subplots(1, 1)
x = np.linspace(rice.ppf(0.0001, shape, scale=scale),
rice.ppf(0.9999, shape, scale=scale), 10000)
ax.plot(x, rice.pdf(x, shape, scale=scale), 'r-', label='rice pdf')
x = np.linspace(expon.ppf(0.01), expon.ppf(0.99), 100)
ax.plot(x, expon.pdf(x), 'r-', lw=5, alpha=0.6, label='expon pdf')
print(rice.rvs(shape, scale=scale))
plt.show()
def _PDF(A, B):
"""
The Rice probability distribution function for p(A|B).
"""
return rice.pdf(A, B)
def density(self, x):
return rice.pdf(x, self.b, loc=self.mu, scale=self.sigma)
def Rice(sigma=0.2, num_samples=101):
sampGrid = np.linspace(0.0, 1.0, num_samples)
mm = rice.pdf(sampGrid, 0.0, 0.0, sigma)
mm /= mm.max()
return interp1d(sampGrid, mm)
from scipy.stats import rice import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 1) # Calculate a few first moments: b = 0.775 mean, var, skew, kurt = rice.stats(b, moments='mvsk') # Display the probability density function (``pdf``): x = np.linspace(rice.ppf(0.01, b), rice.ppf(0.99, b), 100) ax.plot(x, rice.pdf(x, b), 'r-', lw=5, alpha=0.6, label='rice 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 = rice(b) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = rice.ppf([0.001, 0.5, 0.999], b) np.allclose([0.001, 0.5, 0.999], rice.cdf(vals, b)) # True # Generate random numbers:
})
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102),
loc=3,
ncol=4,
mode="expand",
borderaxespad=0.)
# define wave
N = 400
N_modes = 20
b = 0.775
phi = np.random.uniform(0, 2 * np.pi, N_modes)
t = np.linspace(100, 2100, N)
k = np.linspace(0.01, 0.2, N_modes)
x = np.linspace(-1, 5, N_modes)
amp = rice.pdf(x, b)
eta = np.dot(amp, np.sin(np.outer(k, t) + np.outer(phi, np.ones(len(t)))))
# define random masks
N_gaps = 15
mean_gap_length = 8
illu = construct_mask(N, N_gaps, mean_gap_length)
# use deconvolution directly
w = grid2spectral(t)
w1 = 0.02
w2 = 0.16
gap_filling_core = GapFillingCore(w, w1, w2)
eta_dec = gap_filling_core.deconvolve(eta * illu,
illu,
replace_all=True,
from scipy.stats import rice
import matplotlib.pyplot as plt
import numpy as np
import matplotlib
from cycler import cycler
matplotlib.rc('text', usetex=True)
fig, ax = plt.subplots(1, 1)
b = 10
mean, var, skew, kurt = rice.stats(b, moments='mvsk')
ax.set_prop_cycle(
cycler('color', ['c', 'm', 'y', 'k']) + cycler('lw', [1, 2, 3, 4]))
for i in np.arange(0, 3, 0.75):
x = np.linspace(rice.ppf(0.01, i), rice.ppf(0.99, i), 100)
ax.plot(x, rice.pdf(x, i), lw=2, alpha=0.6, label=r"$\nu =$ " + str(i))
plt.legend()
plt.xlabel(r"$\nu$")
plt.ylabel(r"$p(x | \nu)$")
plt.show()