def Function(self, t, param):
Ktrans, ve = param
duration = self.duration
delay = self.delay
cp0 = self.cp0
# If step imput is assumed, the respons can be described as
#
# y = (Ktrans * cp0 / kep) * (1-exp(-kep*t)) (t < duration) ... (1)
# y = (Ktrans * cp0 / kep) * exp(-kep*(t-duration)) (t >= duration) ... (2)
#sys.stderr.write('t : %s\n' % t )
# Calculate shifted time
t2 = scipy.greater_equal(t, delay) * (t - delay);
# To describe C(t) in one equasion, we introduce t_dush, which is
# defined by t_dash = t (t < duration) and t_dash = duration (t >= duration):
t_dash = scipy.less(t2, duration)*t2 + scipy.greater_equal(t2, duration)*duration
# Eq. (1) and (2) can be rewritten by:
kep = Ktrans / ve
y = (Ktrans*cp0/kep)*(scipy.exp(kep*t_dash) - 1) * scipy.exp(-kep*t2)
return y
def Function(self, x, param):
#Ktrans, ve, D, delay = param
#Ktrans, ve, delay = param
Ktrans, ve = param
#Ktrans, kep = param
a1 = self.a1
a2 = self.a2
m1 = self.m1
m2 = self.m2
vp = self.vp
delay = self.delay
kep = Ktrans / ve
D = self.Dose
# Calculate shifted time and convert to minutes
# if x < delay: x_min = 0
# else x_min = (x - delay) / 60.0
x_min = (scipy.greater_equal(x, delay) * (x - delay)) / 60.0
term1 = a1*( scipy.exp(-((kep)*x_min)) - scipy.exp(-(m1*x_min))) / (m1-(kep))
term2 = a2*( scipy.exp(-((kep)*x_min)) - scipy.exp(-(m2*x_min))) / (m2-(kep))
y = 0.0
if vp > 0.0:
term3 = a1*scipy.exp(-(m1*x_min))
term4 = a2*scipy.exp(-(m2*x_min))
y = (D*Ktrans)*(term1+term2)+(vp*D)*(term3+term4)
else:
y = (D*Ktrans)*(term1+term2)
return y * scipy.greater_equal(x, delay)
def Function(self, x, param):
Ktrans, ve, D, delay = param
#Ktrans, ve, delay = param
#Ktrans, ve = param
#Ktrans, kep = param
#Ktrans, ve, D = param
a1 = self.a1
a2 = self.a2
m1 = self.m1
m2 = self.m2
vp = self.vp
#delay = self.delay
kep = Ktrans / ve
#D = self.Dose
# Calculate shifted time and convert to minutes
# if x < delay: x_min = 0
# else x_min = (x - delay) / 60.0
x_min = (scipy.greater_equal(x, delay) * (x - delay)) / 60.0
term1 = a1*( scipy.exp(-((kep)*x_min)) - scipy.exp(-(m1*x_min))) / (m1-(kep))
term2 = a2*( scipy.exp(-((kep)*x_min)) - scipy.exp(-(m2*x_min))) / (m2-(kep))
y = 0.0
if vp > 0.0:
term3 = a1*scipy.exp(-(m1*x_min))
term4 = a2*scipy.exp(-(m2*x_min))
y = (D*Ktrans)*(term1+term2)+(vp*D)*(term3+term4)
else:
y = (D*Ktrans)*(term1+term2)
#return y * scipy.greater_equal(x, delay)
return y
def Function(self, x, param):
Sp, alpha, beta, Ta = param
S0 = self.CalcS0(Ta)
x2 = (scipy.greater_equal(x, Ta) * (x - Ta))
#y = Sp * numpy.abs(scipy.power((scipy.e / (alpha*beta)), alpha)) * numpy.abs(scipy.power(x2, alpha)) * scipy.exp(-x2/beta) + S0
y = Sp * numpy.abs(scipy.power((scipy.e / (alpha*beta)), alpha) * scipy.power(x2, alpha) * scipy.exp(-x2/beta)) + S0
return y
def Function(self, x, param):
Sp, alpha, beta, Ta = param
S0 = self.CalcS0(Ta)
x2 = (scipy.greater_equal(x, Ta) * (x - Ta))
#y = Sp * numpy.abs(scipy.power((scipy.e / (alpha*beta)), alpha)) * numpy.abs(scipy.power(x2, alpha)) * scipy.exp(-x2/beta) + S0
y = Sp * numpy.abs(
scipy.power((scipy.e / (alpha * beta)), alpha) *
scipy.power(x2, alpha) * scipy.exp(-x2 / beta)) + S0
return y
def test_efficiency_range():
def eff_fun():
v = normalise([random(),random(),10])
rays_in = [Ray([0,0,0],v,wavelen,1)]
rays_out = [Ray([0,0,0],v,wavelen,1)]
wavevecs_in_mag = [r.wavevector_vac_mag for r in rays_in]
wavevecs_in_unit = [r.wavevector_unit for r in rays_in]
wavevecs_out_mag = [r.wavevector_vac_mag for r in rays_out]
wavevecs_out_unit = [r.wavevector_unit for r in rays_out]
return get_efficiency(aod, random(), wavevecs_in_mag, wavevecs_in_unit, wavevecs_out_mag, wavevecs_out_unit, [acoustics], (0,1))
effs = [ eff_fun() for _ in range(100) ]
assert all(less_equal(effs,1)) and all(greater_equal(effs,0))
def ght_alternative (img, template, indices):
"""
Alternative implementation of the general hough transform, which uses iteration over
indices rather than broadcasting rules like @see ght().
It is therefore considerably slower, especially for large, multi-dimensional arrays.
The only application are cases, where the hough transform should only be computed for
a small number of points (=template centers) in the image. In this case the indices
of interest can be provided as a list.
@param img the original image on which to search for the structure
@type img numpy.ndarray
@param template a boolean array containing the structure to search for
@type template nump.ndarray
@param indices a sequence of image indices
@type indices sequence
@return the general hough transformation
@rtype numpy.ndarray
"""
# cast template to bool and img to scipy array
img = scipy.asarray(img)
template = scipy.asarray(template).astype(scipy.bool_)
# check supplied parameters
if img.ndim != template.ndim:
raise AttributeError('The supplied image and template must be of the same dimensionality.')
if not scipy.all(scipy.greater_equal(img.shape, template.shape)):
raise AttributeError('The supplied template is bigger than the image. This setting makes no sense for a hough transform.')
# pad the original image
img_padded = pad(img, footprint=template, mode='constant')
# prepare the hough image
if scipy.bool_ == img.dtype:
img_hough = scipy.zeros(img.shape, scipy.int32)
else:
img_hough = scipy.zeros(img.shape, img.dtype)
# iterate over the pixels, apply the template center to each of these and save the sum into the hough image
for idx_hough in indices:
idx_hough = tuple(idx_hough)
slices_img_padded = [slice(idx_hough[i], None) for i in range(img_hough.ndim)]
img_hough[idx_hough] = sum(img_padded[slices_img_padded][template])
return img_hough
changing_pixels = []
time_plan0 = 0 # beginning time of a shot
time_plan1 = 0 # ending time of a shot
# We stream the video in the while loop
while cap.grab():
n_frame += 1
time_plan1 += 1 / float(fps)
ret, frame = cap.retrieve()
frame1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
temp = cv2.cvtColor(temp, cv2.COLOR_BGR2GRAY)
shape = frame1.shape
# We compute the percentage of changing pixels between two consecutive frames
diff = np.absolute(frame1 - temp)
pix_diff = 255. * sc.greater_equal(diff, ten)
n_pix_diff = float(np.count_nonzero(pix_diff))
changing_pixels.append(n_pix_diff / n_pix)
# If the percentage is higher than our threshold we say that we have a new shot
if n_pix_diff / n_pix > 0.8:
# Saving the images in a folder
if n_f_faces != 0 and n_faces != 0:
save_faces(path_visages, n_shot, shots, abs_plan, n_faces,
int(time_plan0), int(time_plan1), w_video)
time_plan0 = time_plan1
n_shot += 1
shots = {}
abs_plan = []
n_faces = 0
n_f_faces = 0
def plot_rc(self,
save=False,
hand=True,
usgs=True,
xs=True,
xsapprox=True,
sprnt=True,
ci=True,
dist=5000,
raw=False,
kind='power',
alpha=0.05,
div=5):
"""Plot HAND and xs rating curves with confidence intervals
'hand' - plot hand rating curve [T/F]
'xs' - plot xs rating curves [T/F]
'xsapprox' - plot xs rating curve approximation from n-value averages [T/F]
'ci' - plot confidence intervals [T/F]
'alpha' - alpha for confidence intervals [float(0.0,1.0)]
'div' - number of intervals for confidence interval [R]"""
with open('results/output_{0}.csv'.format(self.comid), 'w') as f:
writer = csv.writer(f)
writer.writerow(['COMID:', self.comid])
writer.writerow(['LENGTH:', self.handlen])
if xs: # Plot all linearly-interpolated XS rating curves
intervals = scipy.arange(dist, self.handlen + dist, dist)
# print 'Intervals:',intervals
cutoffub = [i / self.handlen * 100 for i in intervals]
cutofflb = scipy.copy(cutoffub)
cutofflb = scipy.insert(cutofflb, 0, 0)[:-1]
cutoffs = zip(cutofflb, cutoffub)
for l, u in cutoffs:
idx = scipy.where(
scipy.logical_and(
scipy.greater_equal(self.xs_profs, l),
scipy.less(self.xs_profs, u)))
if u > 100: u = 100.00
if len(self.xs_disch[idx]) == 0:
continue
fig, ax = plt.subplots(
) # get figure and axes for plotting
fname = 'results/sprntcompare/rc_comid_{0}_sprnt_compare.png'.format(
self.comid, ('%.2f' % l), ('%.2f' % u))
for prof, disch, stage in zip(self.xs_profs[idx],
self.xs_disch[idx],
self.xs_stage[idx]):
# Get interpolation function
# print (('%.2f' % prof) + str(disch))
# print (('%.2f' % prof) + str(stage))
f = self.interp(x=disch, y=stage, kind=kind)
if raw == True: # Plot raw data (ie. only HEC-RAS points)
# interp over discharge
writer.writerow(['PROFILE:', prof])
writer.writerow(['DISCHARGE:'])
writer.writerow(disch)
writer.writerow(['STAGE:'])
writer.writerow(f(disch))
ax.plot(disch, f(disch), c='grey', linewidth=2)
# interp over stage (switched axes) for testing
# f = self.interp(x=stage,y=disch,kind=kind)
# ax.plot(f(stage),stage,c='purple',linewidth=1)
if raw == False: # Plot interpolated data (ie. 'div' many interpolated points)
interval = disch[-1] / div
qvals = scipy.arange(0, (disch[-1] + interval),
interval) # [1:]
writer.writerow(['PROFILE:', prof])
writer.writerow(['DISCHARGE:'])
writer.writerow(qvals)
writer.writerow(['STAGE:'])
writer.writerow(f(qvals))
ax.plot(qvals, f(qvals), c='grey', linewidth=2)
# print '\n------------------------\n'
if ci: # Plot confidence interval bounds
self.get_ci(alpha=alpha,
div=div) # get upper- and lower-bound variables
# upper bounds
f = self.interp(x=self.ci_vals, y=self.ubounds, kind=kind)
writer.writerow(['UPPER CI:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(self.ci_vals)
writer.writerow(['STAGE:'])
writer.writerow(f(self.ci_vals))
ax.plot(self.ci_vals,
f(self.ci_vals),
label='{0}%CI'.format(int((1 - alpha) * 100)),
c='orange',
linewidth=5)
# lower bounds
f = self.interp(x=self.ci_vals, y=self.lbounds, kind=kind)
writer.writerow(['LOWER CI:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(self.ci_vals)
writer.writerow(['STAGE:'])
writer.writerow(f(self.ci_vals))
ax.plot(self.ci_vals, f(self.ci_vals), c='orange', linewidth=5)
if xsapprox:
# Add approximate rating curve from average n-values
qvals, hvals = self.get_xs_q(upto=83)
f = self.interp(x=qvals, y=hvals, kind=kind)
writer.writerow(['XSAPPROX:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(qvals)
writer.writerow(['STAGE:'])
writer.writerow(f(qvals))
ax.plot(qvals,
f(qvals),
label='Resistance Function',
c='red',
linewidth=5)
if usgs: # Plot interpolated USGS rating curve
# Get data
try:
self.get_usgsrc() # Fetch usgs stage and disch values
# Plot curves
for q, h in zip(self.usgsq, self.usgsh):
if kind == 'cubic':
print 'USGS interpolation plotted as power-law fit'
f = self.interp(x=q, y=h, kind='power')
else:
f = self.interp(x=q, y=h, kind=kind)
writer.writerow(['USGS:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(q)
writer.writerow(['STAGE:'])
writer.writerow(f(q))
ax.plot(q, f(q), label='usgs', c='g', linewidth=5)
except IndexError:
print 'No USGS rating curve for comid {0}'.format(
self.comid)
if hand: # Plot interpolated HAND rating curve
# Plot curves
f = self.interp(x=self.handq, y=self.handh, kind=kind)
writer.writerow(['HAND:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(list(self.handq))
writer.writerow(['STAGE:'])
writer.writerow(list(f(self.handq)))
ax.plot(self.handq,
f(self.handq),
label='hand',
c='b',
linewidth=5)
if sprnt:
f = self.interp(x=self.sprntq, y=self.sprnth, kind=kind)
writer.writerow(['SPRNT:'])
writer.writerow(['DISCHARGE:'])
writer.writerow(list(self.sprntq))
writer.writerow(['STAGE:'])
writer.writerow(list(f(self.sprntq)))
ax.plot(self.sprntq,
f(self.sprntq),
label='sprnt',
c='y',
linewidth=5)
# Add one label for all cross-section curves
ax.plot([], [], label='HEC-RAS', c='grey', linewidth=2)
# Plot graph
fig.set_size_inches(20, 16, forward=True)
plt.gca().set_xlim(left=0, right=self.max_disch)
plt.gca().set_ylim(bottom=0, top=self.max_stage)
ax.set_xticks(ax.get_xticks()[::2])
ax.set_yticks(ax.get_yticks()[::2])
title = 'COMID {0}, ({1},{2})'.format(self.comid, ('%.2f' % l),
('%.2f' % u))
ax.set_title(title, y=1.04, fontsize=56)
plt.xlabel('Q (cfs)', fontsize=56)
plt.ylabel('H (ft)', fontsize=56)
ax.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
plt.rc('font', size=56)
plt.legend(loc='upper left', fontsize=40)
plt.tick_params(axis='both', labelsize=56)
plt.grid()
if save:
fig.savefig(fname)
plt.clf()
if not save:
mng = plt.get_current_fig_manager()
mng.resize(*mng.window.maxsize())
plt.show()
plt.clf()
writer.writerow('')
time_plan0 = 0 # beginning time of a shot
time_plan1 = 0 # ending time of a shot
# We stream the video in the while loop
while cap.grab():
n_frame += 1
time_plan1 += 1/float(fps)
ret, frame = cap.retrieve()
frame1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
temp = cv2.cvtColor(temp, cv2.COLOR_BGR2GRAY)
shape = frame1.shape
# We compute the percentage of changing pixels between two consecutive frames
diff = np.absolute(frame1-temp)
pix_diff = 255.*sc.greater_equal(diff, ten)
n_pix_diff = float(np.count_nonzero(pix_diff))
changing_pixels.append(n_pix_diff/n_pix)
# If the percentage is higher than our threshold we say that we have a new shot
if n_pix_diff/n_pix > 0.8:
# Saving the images in a folder
if n_f_faces != 0 and n_faces != 0:
save_faces(path_visages, n_shot, shots, abs_plan, n_faces, int(time_plan0), int(time_plan1),
w_video)
time_plan0 = time_plan1
n_shot += 1
shots = {}
abs_plan = []
n_faces = 0
n_f_faces = 0
def plot_rc(self,
save=False,
xs=True,
xsapprox=True,
kind='power',
dist=5000,
raw=False,
alpha=0.05,
div=5,
box=False):
"""Plot HAND and xs rating curves with confidence intervals
'hand' - plot hand rating curve [T/F]
'xs' - plot xs rating curves [T/F]
'xsapprox' - plot xs rating curve approximation from n-value averages [T/F]
'ci' - plot confidence intervals [T/F]
'alpha' - alpha for confidence intervals [float(0.0,1.0)]
'div' - number of intervals for confidence interval [R]"""
if xs: # Plot all linearly-interpolated XS rating curves
intervals = scipy.arange(dist, self.handlen + dist, dist)
# print 'Intervals:',intervals
cutoffub = [i / self.handlen * 100 for i in intervals]
cutofflb = scipy.copy(cutoffub)
cutofflb = scipy.insert(cutofflb, 0, 0)[:-1]
cutoffs = zip(cutofflb, cutoffub)
for l, u in cutoffs:
idx = scipy.where(
scipy.logical_and(scipy.greater_equal(self.xs_profs, l),
scipy.less(self.xs_profs, u)))[0]
if u > 100: u = 100.00
fig, ax = plt.subplots() # get figure and axes for plotting
fname = 'results/by5000/{0}/rc__comid_{0}_from_{1}_to_{2}.png'.format(
self.comid, ('%.2f' % l), ('%.2f' % u))
for prof, disch, stage in zip(self.xs_profs[idx],
self.xs_disch[idx],
self.xs_stage[idx]):
# Get interpolation function
# print (('%.2f' % prof) + str(disch))
# print (('%.2f' % prof) + str(stage))
f = self.interp(x=disch, y=stage, kind=kind)
if raw == True: # Plot raw data (ie. only HEC-RAS points)
# interp over discharge
ax.plot(disch, f(disch), c='grey', linewidth=2)
# interp over stage (switched axes) for testing
# f = self.interp(x=stage,y=disch,kind=kind)
# ax.plot(f(stage),stage,c='purple',linewidth=1)
if raw == False: # Plot interpolated data (ie. 'div' many interpolated points)
interval = disch[-1] / div
qvals = scipy.arange(0, (disch[-1] + interval),
interval) # [1:]
ax.plot(qvals, f(qvals), c='grey', linewidth=2)
# Add one label for all cross-section curves
ax.plot([], [], label='HEC-RAS', c='grey', linewidth=2)
# Plot graph
fig.set_size_inches(20, 16, forward=True)
plt.gca().set_xlim(left=0, right=self.max_disch)
plt.gca().set_ylim(bottom=0, top=self.max_stage)
ax.set_xticks(ax.get_xticks()[::2])
ax.set_yticks(ax.get_yticks()[::2])
title = 'COMID {0}, ({1},{2})'.format(self.comid, ('%.2f' % l),
('%.2f' % u))
ax.set_title(title, y=1.04, fontsize=56)
plt.xlabel('Q (cfs)', fontsize=56)
plt.ylabel('H (ft)', fontsize=56)
ax.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
plt.rc('font', size=56)
plt.legend(loc='upper left', fontsize=40)
plt.tick_params(axis='both', labelsize=56)
plt.grid()
# print '\n------------------------\n'
if xsapprox:
# Add approximate rating curve from average n-values
qvals, hvals = self.get_xs_q(low=0, upto=83)
f = self.interp(x=qvals, y=hvals, kind=kind)
ax.plot(qvals,
f(qvals),
label='Resistance Function',
c='red',
linewidth=5)
# Add approximate rating curve for these indices
idxqvals, idxhvals = self.get_xs_q(low=idx[0],
upto=idx[-1])
if len(idxqvals) == 0:
print 'No data found for profiles {0} to {1}'.format(
('%.2f' % l), ('%.2f' % u))
break
# f = self.interp(x=idxqvals,y=idxhvals,kind=kind)
# ax.plot(idxqvals,f(idxqvals),label='Resistance Function Local Average',c='orange',linewidth=5)
else:
fig, ax = plt.subplots()
if save: fig.savefig(fname)
else:
# mng = plt.get_current_fig_manager()
# mng.resize(*mng.window.maxsize())
plt.show()
def ght(img, template):
"""
Implementation of the general hough transform for all dimensions.
Providing a template, this method searches in the image for structures similar to the
one depicted by the template. The returned hough image denotes how well the structure
fit in each index.
The indices of the returned image correspond with the centers of the template. At the
corresponding locations of the original image the template is applied (like a stamp)
and the underlying voxel values summed up to form the hough images value. It is
suggested to normalize the input image before for speaking results.
This function behaves as the general hough transform if a binary image has been
supplied. In the case of a gray-scale image, the values of the pixels under the
templates structure are summed up, thus weighting becomes possible.
@note:
The center of a structure with odd side-length is simple the arrays middle. When an
even-sided array has been supplied as template, the middle rounded down is taken as
the structures center. This means that in the second case the hough image is shifted
by half a voxel (ndim * [-0.5]).
@param img the original image on which to search for the structure
@type img numpy.ndarray
@param template a boolean array containing the structure to search for
@type template nump.ndarray
@return the general hough transformation
@rtype numpy.ndarray
"""
# cast template to bool and img to scipy array
img = scipy.asarray(img)
template = scipy.asarray(template).astype(scipy.bool_)
# check supplied parameters
if img.ndim != template.ndim:
raise AttributeError('The supplied image and template must be of the same dimensionality.')
if not scipy.all(scipy.greater_equal(img.shape, template.shape)):
raise AttributeError('The supplied template is bigger than the image. This setting makes no sense for a hough transform.')
# compute center of template array
center = (scipy.asarray(template.shape) - 1) / 2 # integer division intended
# prepare the hough image
if scipy.bool_ == img.dtype:
img_hough = scipy.zeros(img.shape, scipy.int32)
else:
img_hough = scipy.zeros(img.shape, img.dtype)
# iterate over the templates non-zero positions and sum up the images accordingly shifted
for idx in scipy.transpose(template.nonzero()):
slicers_hough = []
slicers_orig = []
for i in range(img.ndim):
pos = -1 * (idx[i] - center[i])
if 0 == pos: # no shift
slicers_hough.append(slice(None, None))
slicers_orig.append(slice(None, None))
elif pos > 0: # right shifted hough
slicers_hough.append(slice(pos, None))
slicers_orig.append(slice(None, -1 * pos))
else: # left shifted hough
slicers_hough.append(slice(None, pos))
slicers_orig.append(slice(-1 * pos, None))
img_hough[slicers_hough] += img[slicers_orig]
return img_hough
def run_simulation_fast(vol, lam, sprd_client, sprd_dealer, delta_lim,
hedge_style, dt, nsteps, nruns, seed):
'''Runs a Monte Carlo simulation and returns statics on PNL, client trades, and hedge trades.
"_fast" because it uses vectorized operations.
vol: lognormal volatility of the spot process
lam: Poisson process frequency
sprd_client: fractional bid/ask spread for client trades. eg 1e-4 means 1bp.
sprd_dealer: fractional bid/ask spread for inter-dealer hedge trades. eg 1e-4 means 1bp.
delta_lim: the delta limit at or beyond which the machine will hedge in the inter-dealer market
hedge_style: 'Zero' or 'Edge', defining the hedging style. 'Zero' means hedge to zero position,
'Edge' means hedge to the nearer delta limit.
dt: length of a time step
nsteps: number of time steps for each run of the simulation
nruns: number of Monte Carlo runs
seed: RNG seed
'''
scipy.random.seed(seed)
trade_prob = 1 - exp(-lam * dt)
sqrtdt = sqrt(dt)
spots = scipy.zeros(nruns) + 1 # initial spot == 1
posns = scipy.zeros(nruns)
trades = scipy.zeros(nruns)
hedges = scipy.zeros(nruns)
pnls = scipy.zeros(nruns)
for step in range(nsteps):
dzs = scipy.random.normal(0, sqrtdt, nruns)
qs = scipy.random.uniform(0, 1, nruns)
ps = scipy.random.binomial(
1, 0.5,
nruns) * 2 - 1 # +1 or -1 - trade quantities if a trade happens
# check if there are client trades for each path
indics = scipy.less(qs, trade_prob)
posns += indics * ps
trades += scipy.ones(nruns) * indics
pnls += scipy.ones(nruns) * indics * sprd_client * spots / 2.
# check if there are hedges to do for each path
if hedge_style == 'Zero':
indics = scipy.logical_or(scipy.less_equal(posns, -delta_lim),
scipy.greater_equal(posns, delta_lim))
pnls -= scipy.absolute(posns) * indics * sprd_dealer * spots / 2.
posns -= posns * indics
hedges += scipy.ones(nruns) * indics
elif hedge_style == 'Edge':
# first deal with cases where pos>delta_lim
indics = scipy.greater(posns, delta_lim)
pnls -= (posns - delta_lim) * indics * sprd_dealer * spots / 2.
posns = posns * scipy.logical_not(indics) + scipy.ones(
nruns) * indics * delta_lim
hedges += scipy.ones(nruns) * indics
# then the cases where pos<-delta_lim
indics = scipy.less(posns, -delta_lim)
pnls -= (-delta_lim - posns) * indics * sprd_dealer * spots / 2.
posns = posns * scipy.logical_not(indics) + scipy.ones(
nruns) * indics * (-delta_lim)
hedges += scipy.ones(nruns) * indics
else:
raise ValueError('hedge_style must be "Edge" or "Zero"')
# advance the spots and calculate period PNL
dspots = vol * spots * dzs
pnls += posns * dspots
spots += dspots
return {
'PNL': (pnls.mean(), pnls.std()),
'Trades': (trades.mean(), trades.std()),
'Hedges': (hedges.mean(), hedges.std())
}
