def __call__(self, X, Y):
sentinel = (sys.maxint, sys.maxint)
X = common.sentinelize(X, sentinel)
Y = common.sentinelize(Y, sentinel)
x = X.next()
y = Y.next()
if x == sentinel or y == sentinel: continue_loop = False
else: continue_loop = True
while continue_loop:
open_window = y[0]
close_window = y[1]
# Extend the y window as long as possible #
while True:
if y == sentinel: break
y = Y.next()
if y[0] > close_window: break
if y[1] > close_window: close_window = y[1]
# Read features from X until overshooting the y window #
while True:
if x[0] >= close_window: break
if x[1] > open_window: yield x
x = X.next()
if x == sentinel:
continue_loop = False
break
def __call__(self, X, Y):
# Sentinel #
sentinel = (sys.maxint, sys.maxint, 0.0)
X = common.sentinelize(X, sentinel)
# Growing and shrinking list of features in X #
F = [(-sys.maxint, -sys.maxint, 0.0)]
# --- Core loop --- #
for y in Y:
# Check that we have all the scores necessary #
xnext = F[-1]
while xnext[0] < y[1]:
xnext = X.next()
if xnext[1] > y[0]: F.append(xnext)
# Throw away the scores that are not needed anymore #
n = 0
while F[n][1] <= y[0]:
n+=1
F = F[n:]
# Compute the average #
score = 0.0
for f in F:
if y[1] <= f[0]: continue
if f[0] < y[0]: start = y[0]
else: start = f[0]
if y[1] < f[1]: end = y[1]
else: end = f[1]
score += (end-start) * f[2]
# Emit a feature #
yield y[0:3]+(score/(y[1]-y[0]),)+y[4:]
def __call__(self, X, Y):
def make_name(a, b):
if a and b: return a + ' + ' + b
elif a: return a
return b
def make_feature(a, b):
return (max(a[0],b[0]),
min(a[1],b[1]),
make_name(a[2], b[2]),
(a[3]+b[3])/2.0,
a[4]==b[4] and b[4] or 0)
# Preparation #
sentinel = (sys.maxint, sys.maxint)
X = common.sentinelize(X, sentinel)
Y = common.sentinelize(Y, sentinel)
x = X.next()
y = Y.next()
Wx = []
Wy = []
# Core loop stops when both x and y are at the sentinel
while x[0] != sentinel or y[0] != sentinel:
# Take the leftmost current feature and scan it against the other window
if x[0] < y[0]:
# Remove features from the y window that are left of x
Wy = [f for f in Wy if f[1] > x[0]]
# Yield new features with all overlaps of x in Wy
for f in [f for f in Wy if f[1] > x[0] and x[1] > f[0]]: yield make_feature(x, f)
# Put x in the window only if it is not left of y
if x[1] >= y[0]: Wx.append(x)
# Advance current x feature
x = X.next()
else:
# Remove features from the x window that are left of y
Wx = [f for f in Wx if f[1] > y[0]]
# Yield new features with all overlaps of y in Wx
for f in [f for f in Wx if f[1] > y[0] and y[1] > f[0]]: yield make_feature(y, f)
# Put y in the window only if it is not left of x
if y[1] >= x[0]: Wy.append(y)
# Advance current y feature
y = Y.next()
def __call__(self, X, L, stop_val):
# Sentinel #
sentinel = (sys.maxint, sys.maxint, 0.0)
X = common.sentinelize(X, sentinel)
# Growing and shrinking list of features around our moving window #
F = []
# Current position counting on nucleotides (first nucleotide is zero) #
p = -L-2
# Position since which the mean hasn't changed #
same_since = -L-3
# The current mean and the next mean #
curt_mean = 0
next_mean = 0
# Multipication factor instead of division #
f = 1.0 / (2*L+1)
# First feature if it exists #
F.append(X.next())
if F == [sentinel]: return
# --- Core loop --- #
while True:
# Advance one #
p += 1
# Window start and stop #
s = p-L
e = p+L+1
# Scores entering window #
if F[-1][1] < e: F.append(X.next())
if F[-1][0] < e: next_mean += F[-1][2] * f
# Scores exiting window #
if F[ 0][1] < s: F.pop(0)
if F[ 0][0] < s: next_mean -= F[ 0][2] * f
# Border condition on the left #
if p < 0:
curt_mean = 0
same_since = p
continue
# Border condition on the right #
if p == stop_val:
if curt_mean != 0: yield (same_since, p, curt_mean)
break
# Maybe emit a feature #
if next_mean != curt_mean:
if curt_mean != 0: yield (same_since, p, curt_mean)
curt_mean = next_mean
same_since = p
def __call__(self, list_of_tracks, geometric=False):
# Get all iterators #
sentinel = (sys.maxint, sys.maxint, 0.0)
tracks = [common.sentinelize(x, sentinel) for x in list_of_tracks]
elements = [x.next() for x in tracks]
# Declare meaning functions #
def arithmetic_mean(scores): return sum(scores)*tracks_denom
def geometric_mean(scores): return sum(scores)**tracks_denom
tracks_denom = 1.0/len(tracks)
# Choose meaning function #
if not geometric: mean_fn = arithmetic_mean
else: mean_fn = geometric_mean
# Check empty #
for i in xrange(len(tracks)-1, -1, -1):
if elements[i] == sentinel:
tracks.pop(i)
elements.pop(i)
# Core loop #
while tracks:
# Find the next boundaries #
start = min([x[0] for x in elements])
end = min([x[0] for x in elements if x[0] > start] + [x[1] for x in elements])
# Scores between boundaries #
scores = [x[2] for x in elements if x[1] > start and x[0] < end]
if scores: yield (start, end, mean_fn(scores))
# Iterate over elements #
for i in xrange(len(tracks)-1, -1, -1):
# Change all starts #
if elements[i][0] < end:
elements[i] = (end, elements[i][1], elements[i][2])
# Advance the elements that need to be advanced #
if elements[i][1] <= end:
elements[i] = tracks[i].next()
# Pop sentinels #
if elements[i] == sentinel:
tracks.pop(i)
elements.pop(i)
