def target_probability(self, a1, a2, opposite=False):
if (self.distribution_type == "vonmises"):
# https://math.stackexchange.com/questions/1574927/what-is-the-equation-for-a-bessel-function-of-order-zero
def I(x):
return (1.0 / np.pi) * integrate.quad(
lambda t: np.exp(x * np.cos(t)), 0.0, np.pi)[0]
# https://en.wikipedia.org/wiki/Von_Mises_distribution
def pdf(x, k):
return np.exp(k * np.cos(x)) / (2.0 * np.pi * I(k))
def cdf(angle, k):
return integrate.quad(lambda t: pdf(t, k), -np.pi, angle)
start_time = time.time()
kappa = self.params[0]
self.target = [a1, a2]
a_min = min(self.target) - self.parafoveal
a_max = max(self.target) + self.parafoveal
t1 = vonmises.cdf(a_min, kappa)
t2 = vonmises.cdf(a_max, kappa)
self.results = [t1, t2]
ans = np.abs(t2 - t1)
if opposite:
ans = 1 - ans
self.distribution_time += time.time() - start_time
return ans
def interval_probability(self, tStart, tEnd, location=None, kappa=None):
if location is None:
location = self.location
if location is None:
raise ValueError("No mean is given.")
if kappa is None:
kappa = self.kappa
if kappa is None:
raise ValueError("No variance is given.")
return (vonmises.cdf(tEnd, kappa, location, 12 / np.pi) -
vonmises.cdf(tStart, kappa, location, 12 / np.pi))
def angular_linear_pdf(x,
alpha,
speed_params,
vonmises_params,
connection_params,
cartesian=False):
from scipy.stats import kappa4, vonmises
# 1. Speed
k, h, scale, loc = speed_params
x_pdf = kappa4.pdf(x, h, k, loc=loc, scale=scale)
x_cdf = kappa4.cdf(x, h, k, loc=loc, scale=scale)
# 2. Direction
alpha_pdf = np.sum(
[vonmises.pdf(alpha, k, loc=u) * w for k, u, w in vonmises_params],
axis=0)
alpha_cdf = np.sum(
[vonmises.cdf(alpha, k, loc=u) * w for k, u, w in vonmises_params],
axis=0)
# 3. Connection
phi = 2 * pi * (x_cdf - alpha_cdf)
phi_pdf = np.sum(
[vonmises.pdf(phi, k, loc=u) * w for k, u, w in connection_params],
axis=0)
if cartesian == True:
pdf = div0(2 * pi * x_pdf * alpha_pdf * phi_pdf, x)
else:
pdf = 2 * pi * x_pdf * alpha_pdf * phi_pdf
return pdf
def phi_from_speed_dir(df_speed, df_dir, kap_params, dir_params):
from scipy.stats import kappa4, vonmises
k, h, scale, loc = kap_params['k'], kap_params['h'], kap_params['scale'], kap_params['loc']
speed_cdf = kappa4.cdf(df_speed, h, k, loc=loc, scale=scale)
alpha_cdf = np.sum([vonmises.cdf(df_dir/180*pi, k, loc=u) * w for k, u, w in dir_params], axis=0)
phi = 2*pi*(speed_cdf - alpha_cdf)%(2*pi)
return phi
def vm_cdf_diff(inputs,heading_mean,kappa):
heading_cdf= lambda theta : vonmises.cdf(theta,loc=heading_mean,kappa=kappa)
scale = inputs[1]-inputs[0]
inputs_shifted = inputs-scale
outputs = np.zeros(len(inputs))
for i in range(len(inputs)):
outputs[i] = heading_cdf(inputs[i]) - heading_cdf(inputs_shifted[i])
return outputs
def vonCoordinates(mu, kappa, size, alpha):
tRads = numpy.random.vonmises(mu, kappa, size)
tPdf = vonmises.pdf(tRads, loc=mu, kappa=kappa)
tInterval = vonmises.interval(
alpha, loc=mu, kappa=kappa
) #Endpoints of the range that contains alpha percent of the distribution
tCdf = vonmises.cdf(tInterval, loc=mu, kappa=kappa)
tDegs = numpy.degrees(tRads)
tmpArray = tools.coordinatetools.pol2cart(tDegs, dictGen['stimDist'])
coordList = zip(tmpArray[0], tmpArray[1])
return (coordList, tPdf, tCdf)
def cdf(X, parameters):
"""
Calculates the cdf for each point in the data X given mean mu and
precision kappa.
Inputs:
X: a column of data (numpy)
parameters: a dict with the following keys
mu: the Von Mises mean
kappa: the precision of the Von Mises
"""
check_data_type_column_data(X)
check_model_params_dict(parameters)
return vonmises.cdf(X-math.pi, parameters['mu']-math.pi, parameters['kappa'])
def cdf(X, parameters):
"""
Calculates the cdf for each point in the data X given mean mu and
precision kappa.
Inputs:
X: a column of data (numpy)
parameters: a dict with the following keys
mu: the Von Mises mean
kappa: the precision of the Von Mises
"""
check_data_type_column_data(X)
check_model_params_dict(parameters)
return vonmises.cdf(X - math.pi, parameters['mu'] - math.pi,
parameters['kappa'])
def solve(z):
k = z[0]
c1 = vonmises.cdf(angle, k) - 0.9 #cdf(angle, k) - 0.9
return [c1]
# Display the probability density function (``pdf``): x = np.linspace(vonmises.ppf(0.01, kappa), vonmises.ppf(0.99, kappa), 100) ax.plot(x, vonmises.pdf(x, kappa), 'r-', lw=5, alpha=0.6, label='vonmises 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 = vonmises(kappa) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = vonmises.ppf([0.001, 0.5, 0.999], kappa) np.allclose([0.001, 0.5, 0.999], vonmises.cdf(vals, kappa)) # True # Generate random numbers: r = vonmises.rvs(kappa, 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 cdf(self, dist, v):
return vonmises.cdf(v, *self._get_params(dist))
def largeur95(kappa):
x = 0
while vonmises.cdf(x, kappa) < 0.975:
x += 0.01
return x * (180 / np.pi)
def largeur(kappa, ran=70):
x = 0
while vonmises.cdf(x, kappa) < 0.5 + (ran / 200.):
x += 0.001
return x * (180 / np.pi)