def testIncompatibleTracks(self):
self._assertIncompatibleTracks(
SampleTV(starts=[0, 3, 5], anchor=[10, 20]))
self._assertIncompatibleTracks(
SampleTV(ends=[0, 3, 5, 10], anchor=[10, 20]))
self._assertIncompatibleTracks(
SampleTV(segments=[[3, 5], [7, 9]], anchor=[10, 20]))
def test_compute(self):
self._assertCompute([10], \
SampleTV( segments=[], vals=[], anchor=[10,20], valDType='S2', allowOverlaps=True ))
self._assertCompute([4,4,2], \
SampleTV( segments=[[3,7], [5,9]], vals=['AA','BB'], anchor=[10,20], valDType='S', allowOverlaps=True ))
self._assertCompute([4,4,1,1], \
SampleTV( segments=[[3,7], [6,7], [5,9]], vals=['AA','BB','CC'], anchor=[10,20], valDType='S', allowOverlaps=True ))
def test_compute(self):
self._assertCompute([1.119203,1.891642,2.989013], SampleTV( starts = [10,30,60], vals = [1,2,3], anchor = [0,100], valDType='int32'),\
markReq='number' ,windowSize=3, windowBpSize=5000, sdOfGaussian=10,guaranteeBpCoverByWindow='False',assertFunc=self.assertListsOrDicts)
#self._assertCompute([1.119203,1.891642,2.989013,1.119203,1.891642,2.989013], SampleTV( starts = [10,30,60,110,130,160], vals = [1,2,3,1,2,3], anchor = [0,200], valDType='int32'),\
# markReq='number' ,windowSize=3, windowBpSize=5000, sdOfGaussian=10,guaranteeBpCoverByWindow='False',assertFunc=self.assertListsOrDicts)
self._assertCompute([], SampleTV( starts=[], anchor = [0,100], valDType='int32'),\
markReq='number' )
def test_compute(self):
self._assertCompute(90, SampleTV_Num(anchor=[10, 100]))
self._assertCompute(
20, SampleTV(segments=[[10, 20], [80, 90]], anchor=[10, 100]))
self._assertCompute(3, SampleTV(starts=[2, 15, 60], anchor=[10, 100]))
self._assertCompute(90, SampleTV(ends=[15, 90], anchor=[10, 100]))
self._assertCompute(0, SampleTV(segments=[], anchor=[10, 100]))
def test_createChildren(self):
self._assertCreateChildren([CountStatUnsplittable, SumStatUnsplittable],\
SampleTV( anchor=[10,100], numElements=5 ),\
SampleTV_Num( anchor=[10,100] ), CountStat, SumStat)
self._assertCreateChildren([CountStatSplittable, SumStatSplittable],\
SampleTV( anchor=[10,121], numElements=5 ),\
SampleTV_Num( anchor=[10,121] ), CountStat, SumStat)
def test_compute(self):
self._assertCompute(111, SampleTV_Num(anchor=[10, 121]))
self._assertCompute(
41, SampleTV(segments=[[10, 20], [80, 111]], anchor=[10, 121]))
self._assertCompute(3, SampleTV(starts=[2, 15, 110], anchor=[10, 121]))
self._assertCompute(111, SampleTV(ends=[15, 111], anchor=[10, 121]))
self._assertCompute(0, SampleTV(segments=[], anchor=[10, 121]))
def testIncompatibleTracks(self):
self._assertIncompatibleTracks(SampleTV_Num( anchor=[10,100] ), \
SampleTV( anchor=[10,100], numElements=10 ))
self._assertIncompatibleTracks(SampleTV( anchor=[10,100], numElements=10 ), \
SampleTV_Num( anchor=[10,100] ))
self._assertIncompatibleTracks(SampleTV( starts=False, anchor=[10,100], numElements=10 ), \
SampleTV( starts=False, anchor=[10,100], numElements=10 ))
def test_compute(self):
resultA = { 'Result': {'sdOfMean': [0.24748737, 0.35355339, 0.28284271, 0.35355339], \
'mean':[0.35, 0.5, 0.6, 0.5]} }
self._assertCompute(resultA, \
SampleTV( segments=[[50,100], [100,105], [108,122]], anchor=[0,140] ), numSubBins=4, binRegs = \
(GenomeRegion('TestGenome','chr21',0,100), GenomeRegion('TestGenome','chr21',100,140)), \
assertFunc=self.assertListsOrDicts)
self._assertCompute({ 'Result': {'sdOfMean': [0,0,0,0], 'mean':[0,0,0,0]} }, \
SampleTV( segments=[], anchor=[0,4] ), numSubBins=4, binRegs = \
(GenomeRegion('TestGenome','chr21',0,4), GenomeRegion('TestGenome','chr21',4,4)),\
assertFunc=self.assertListsOrDicts)
#Manually force use of _computeThatHandlesOverlap, and check that it gives equal result as above.
self._assertCompute(resultA, \
SampleTV( segments=[[50,100], [100,105], [108,122]], anchor=[0,140] ), numSubBins=4, binRegs = \
(GenomeRegion('TestGenome','chr21',0,100), GenomeRegion('TestGenome','chr21',100,140)), \
assertFunc=self.assertListsOrDicts, withOverlaps='yes')
resultB = { 'Result': {'sdOfMean': [0.24748737, 0.35355339, 0.63639610306789274, 0.35355339], \
'mean':[0.35, 0.5, 1.1, 0.5]} }
self._assertCompute(resultB, \
SampleTV( segments=[[50,100],[50,75], [100,105], [108,122]], anchor=[0,140] ), numSubBins=4, binRegs = \
(GenomeRegion('TestGenome','chr21',0,100), GenomeRegion('TestGenome','chr21',100,140)), \
assertFunc=self.assertListsOrDicts, withOverlaps='yes')
def test_compute(self):
self._assertCompute({
'BinSize': 21,
(True, 0, 0):3,
(True, 0, 1):4,
(True, 0, 2):1,
(True, 1, 0):1,
(True, 1, 1):6,
(True, 1, 2):1,
(True, 2, 0):3,
(True, 2, 1):4,
(True, 2, 2):1,
(False, 0, 0):7,
(False, 0, 1):4,
(False, 0, 2):3,
(False, 1, 0):7,
(False, 1, 1):6,
(False, 1, 2):1,
(False, 2, 0):7,
(False, 2, 1):4,
(False, 2, 2):3
}, \
SampleTV( segments=[[2,4], [10,14], [18,20]], anchor=[1,22] ), \
SampleTV( segments=[[1,3], [9,11], [17,21]], anchor=[1,22] ),\
SampleTV( segments=[[1,5], [8,10], [20,22]], anchor=[1,22] ),\
assertFunc=self.assertListsOrDicts)
def test_compute(self):
self._assertCompute([13, 15, 17], SampleTV_Num( vals=range(10, 20), anchor=[0,10], valDType='float32' ), \
SampleTV( starts=[3,5,7], anchor=[0,10] ), assertFunc=self.assertListsOrDicts)
self._assertCompute([13, 14, 15, 17], SampleTV_Num( vals=range(10, 20), anchor=[0,10], valDType='float32' ), \
SampleTV( starts=[3,7], ends=[6,8], anchor=[0,10] ), assertFunc=self.assertListsOrDicts)
self._assertCompute([], SampleTV_Num( vals=range(10, 20), anchor=[0,10], valDType='float32' ), \
SampleTV( starts=[], anchor=[0,10] ), assertFunc=self.assertListsOrDicts)
def _doRandTestSegsAndPoints(self,
segments,
anchor,
vals=False,
strands=False,
ids=False,
edges=False,
weights=False,
extras=False):
origTV = SampleTV(starts=[x[0] for x in segments],
vals=vals,
strands=strands,
ids=ids,
edges=edges,
weights=weights,
extras=extras,
anchor=anchor)
self._doRandTest(origTV, [
PermutedSegsAndIntersegsTrack,
PermutedSegsAndSampledIntersegsTrack, SegsSampledByIntensityTrack
])
origTV = SampleTV(segments=segments,
vals=vals,
strands=strands,
ids=ids,
edges=edges,
weights=weights,
extras=extras,
anchor=anchor)
self._doRandTest(origTV, [
PermutedSegsAndIntersegsTrack, PermutedSegsAndSampledIntersegsTrack
])
def testIncompatibleTracks(self):
self._assertIncompatibleTracks(
SampleTV(anchor=[10, 100], numElements=5))
self._assertIncompatibleTracks(
SampleTV(starts=False, anchor=[10, 100], numElements=5))
self._assertIncompatibleTracks(
SampleTV(ends=False, anchor=[10, 100], numElements=5))
def test_compute(self):
#self._assertCompute(1, SampleTV( 2 ))
ans = {
'&&': 1 / 90.0,
'*&': 0.1 * 0.2,
'&*': 0.1 * 0.2,
'**': 0.1 * 0.2
}
answer = dict([(k + '_GivenBinPresence', v * 90)
for k, v in ans.items()])
self._assertCompute(answer, \
SampleTV( segments=[[10,28]], anchor=[10,100] ), \
SampleTV( segments=[[27,36]], anchor=[10,100] ),\
assertFunc=self.assertListsOrDicts)
exp = 0.5 * (0.1 * 0.2) + 0.5 * (1.0 * 1.0)
ans = {'&&': 91 / 180.0, '*&': exp, '&*': exp, '**': exp}
answer = dict([(k + '_GivenBinPresence', v * 180)
for k, v in ans.items()])
#NB! This test assumes splittable statistic is applied below. This is not done as of now, since ThreeWayExpectedBpOverlapGivenBinPresenceAsWholeBpsStatSplittable inherits OnlyGloballySplittable
#Must for now remove this inheritance to make test work. Should be changed to allow tests to split globally, but how?
self._assertCompute(answer, \
SampleTV( segments=[[10,28], [90,180]], anchor=[10,190] ), \
SampleTV( segments=[[27,36], [90,180]], anchor=[10,190] ),\
assertFunc=self.assertListsOrDicts, \
binRegs = (GenomeRegion('TestGenome','chr21',10,100), GenomeRegion('TestGenome','chr21',100,190)))
def test_compute(self):
self._assertCompute([1,2,3], SampleTV( starts = [10,30,50], vals = [1,2,3], anchor = [0,100], valDType='int32' ), \
assertFunc=self.assertListsOrDicts, markType='number (integer)')
self._assertCompute([1,2,3], SampleTV_Num( vals = [1,2,3], anchor = [0,3], valDType='int32' ), \
assertFunc=self.assertListsOrDicts, markType='number (integer)')
self._assertCompute([], SampleTV( vals = [], ends=False, numElements = 0, anchor = [0,100], valDType='int32' ), \
assertFunc=self.assertListsOrDicts, markType='number (integer)')
def test_compute(self):
self._assertCompute(
0.0, SampleTV(segments=[], anchor=[0, 200]),
SampleTV_Num(vals=[1.0 * x for x in range(200)], anchor=[0, 200]))
self._assertCompute(
1497.0,
SampleTV(segments=[[3, 5], [50, 70], [99, 102]], anchor=[0, 200]),
SampleTV_Num(vals=[1.0 * x for x in range(200)], anchor=[0, 200]))
def test_compute(self):
self._assertCompute(0.0, SampleTV(starts=[], anchor=[0, 0]),
SampleTV_Num(vals=[], anchor=[0, 0]))
self._assertCompute(
0.0, SampleTV(starts=[], anchor=[0, 100]),
SampleTV_Num(vals=[1.0 * x for x in range(100)], anchor=[0, 100]))
self._assertCompute(
128.0, SampleTV(starts=[3, 5, 50, 70], anchor=[0, 100]),
SampleTV_Num(vals=[1.0 * x for x in range(100)], anchor=[0, 100]))
def test_compute(self):
self._assertCompute(([3,2,1],[0.8,0.6,0.5]), \
SampleTV(segments = [[10,20],[30,40],[50,55]], vals = [1,2,3], valDType='int32'),\
SampleTV(segments = [[15,25],[34,40],[51,55]]), markReq='number (integer)', \
assertFunc=self.assertListsOrDicts)
self._assertCompute(([],[]), \
SampleTV(numElements = 0, vals=[], valDType='int32'),\
SampleTV(segments = [[15,25],[34,40],[51,55]]), markReq='number (integer)', \
assertFunc=self.assertListsOrDicts)
def test_compute(self):
self._assertCompute( [0]*5 + [5]*5 + [10]*5 + [15]*5, SampleTV(numElements=0, anchor=[0,20]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
marksStat='MarksListStat', controlTrackNameList='^^'.join([encodeTn(range(10,30)), encodeTn(range(10,30))]) )
self._assertCompute( [0,0,1,1,2,6,11,15], SampleTV(numElements=0, anchor=[0,8]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
marksStat='MarksListStat', controlTrackNameList='^^'.join([ encodeTn(range(0,8)), encodeTn([0,0,0,0,0,1,2,3]) ]) )
self._assertCompute( [0]*5 + [1]*5 + [2]*5 + [3]*5, SampleTV(numElements=0, anchor=[0,20]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
marksStat='MarksListStat', controlTrackNameList=encodeTn(range(10,30)) )
def test_compute(self):
self._assertCompute(([3,2,1], [52.0, 34.5, 14.5]), \
SampleTV( segments = [[10,20],[30,40],[50,55]], vals = [1,2,3], anchor = [0,100], valDType='int32'),\
SampleTV_Num( vals = range(100), anchor = [0,100] ), markReq='number (integer)',\
assertFunc=self.assertListsOrDicts)
self._assertCompute(([],[]), \
SampleTV( numElements = 0, vals = [], anchor = [0,100], valDType='int32'),\
SampleTV_Num( vals = range(100),anchor = [0,100]), markReq='number (integer)',\
assertFunc=self.assertListsOrDicts)
def test_compute(self):
self._assertCompute( [0.2]*16, SampleTV(starts=[0,5,10,15], anchor=[0,20]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
controlTrackNameList='^^'.join([encodeTn(range(10,30)), encodeTn(range(10,30))]) )
#[1,0.5,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
self._assertCompute( [1, 0.5, 0, 0.5, 0.5, 0.5, 0, 0.5, 0.5, 0.5, 0.5, 0, 0.5, 0.5, 0.5, 1], SampleTV(starts=[0,1,2,7], anchor=[0,8]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
controlTrackNameList='^^'.join([ encodeTn(range(0,8)), encodeTn([0,0,0,0,0,1,2,3]) ]) )
self._assertCompute( [0.2,0.2,0,0], SampleTV(starts=[0,5], anchor=[0,20]), numDiscreteVals=4, reducedNumDiscreteVals=4, \
controlTrackNameList=encodeTn(range(10,30)) )
def test_compute(self):
self._assertCompute({ 'Both':15, 'Neither':125, 'Only1':35, 'Only2':5 }, \
SampleTV( segments=[[10,20], [130,170]], anchor=[10,190] ), \
SampleTV( segments=[[15,25], [137,147]], anchor=[10,190] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({ 'Both':0, 'Neither':180, 'Only1':0, 'Only2':0 }, \
SampleTV( segments=[], anchor=[10,190] ), \
SampleTV( segments=[], anchor=[10,190] ),\
assertFunc=self.assertListsOrDicts)
def test_compute(self):
self._assertCompute(20, SampleTV_Num( vals=[2]*90, anchor=[10,100] ), \
SampleTV( segments=[[0,10]], anchor=[10,100] ), method='sum_of_sum')
self._assertCompute(40, SampleTV( segments=[[10,20], [80,85]], vals=[1,10], anchor=[10,100] ), \
SampleTV( segments=[[10,20], [80,83]], anchor=[10,100] ), method='sum_of_sum')
#self._assertCompute(10, SampleTV( starts=[2,15,60], vals=[1,10,100], anchor=[10,100] ), \
# SampleTV( segments=[[10,20], [80,85]], anchor=[10,100] ), method='sum_of_sum')
#self._assertCompute(205, SampleTV( ends=[15,90], vals=[1,10], anchor=[10,100] ), \
# SampleTV( segments=[[10,20], [40,55]], anchor=[10,100] ), method='sum_of_sum')
self._assertCompute(0, SampleTV( segments=[], vals=[], anchor=[10,100] ), \
SampleTV( segments=[], anchor=[10,100] ), method='sum_of_sum')
def test_compute(self):
#self._assertCompute([0.7, 1.0, 0.2, 0.0], \
# SampleTV( segments=[[0,5], [8,22]], anchor=[0,40] ), numSubBins=4, assertFunc=self.assertListsOrDicts)
self._assertCompute([0.0, 0.0, 0.2, 1.0, 0.3, 0.0, 0.0], \
SampleTV( segments=[[28,42],[44,45]], anchor=[0,70] ), numSubBins=7, assertFunc=self.assertListsOrDicts)
self._assertCompute([0,0,0,0], \
SampleTV( segments=[]), numSubBins=4,assertFunc=self.assertListsOrDicts)
self._assertCompute(None, \
SampleTV( segments=[], anchor=[0,1]), numSubBins=4)
def setUp(self):
self.emptyTv = SampleTV(starts=[], ids=[], edges=[], anchor = [10,100])
self.emptyPgv = LazyProtoGraphView.createInstanceFromTrackView(self.emptyTv)
self.emptyTv2 = SampleTV(starts=[], ids=[], edges=[], anchor = [100,200])
self.emptyPgv2 = LazyProtoGraphView.createInstanceFromTrackView(self.emptyTv2)
self.tv = SampleTV(starts=[1,2,3,5], ids=list('1235'), edges=[list('236'), list('125'), [], list('26')], anchor = [10,100])
self.pgv = LazyProtoGraphView.createInstanceFromTrackView(self.tv)
self.tv2 = SampleTV(starts=[0,99], ids=list('69'), edges=[list('3'), list('6')], anchor = [100,200])
self.pgv2 = LazyProtoGraphView.createInstanceFromTrackView(self.tv2)
def test_compute(self):
self._assertCompute(0.0, SampleTV(segments=[], anchor=[0, 0]),
SampleTV_Num(vals=[], anchor=[0, 0]))
self._assertCompute(numpy.nan,
SampleTV(segments=[[0, 2]], anchor=[0, 2]),
SampleTV_Num(vals=[1.0, numpy.nan], anchor=[0, 2]))
self._assertCompute(
0.0, SampleTV(segments=[], anchor=[0, 100]),
SampleTV_Num(vals=[1.0 * x for x in range(100)], anchor=[0, 100]))
self._assertCompute(
13555.0, SampleTV(segments=[[3, 5], [50, 55]], anchor=[0, 100]),
SampleTV_Num(vals=[1.0 * x for x in range(100)], anchor=[0, 100]))
def test_compute(self):
self._assertCompute({
'totNodes': 0,
'totEdges': 0
}, SampleTV(starts=[], ids=[], edges=[]))
self._assertCompute({
'totNodes': 3,
'totEdges': 4
},
SampleTV(starts=[0, 10, 20],
ids=['a', 'b', 'c'],
edges=[['b', 'c'], ['a', 'c'], []]))
def test_compute(self):
from gold.application.StatRunner import StatJob
#from quick.application.UserBinSource import UserBinSource
from gold.track.GenomeRegion import GenomeRegion
StatJob.USER_BIN_SOURCE = [GenomeRegion('TestGenome', 'chr21', 0, 100), GenomeRegion('TestGenome', 'chr21', 100, 200)]
self._assertCompute([2.0,None], \
SampleTV( starts=[0,10,120,130], ids=['a','b','c','d'], edges=[['d'],['d'],['d'],list('abc')], anchor=[0,200] ), \
globalSource='userbins', weightThreshold='0')
self._assertCompute([None,None], \
SampleTV( starts=[], ids=[], edges=[], anchor=[0,200] ), \
globalSource='userbins', weightThreshold='0')
def test_compute(self):
#self._assertCompute(1, SampleTV( 2 ))
#answer = {'11': 1, '10': 18, '01': 9}
#self._assertCompute(answer, \
# SampleTV( segments=[[10,28]], anchor=[10,100] ), \
# SampleTV( segments=[[27,36]], anchor=[10,100] ),\
# assertFunc=self.assertListsOrDicts)
answer = {'Proportion of extra coverage given depth 0':116.0/180, 'Proportion of extra coverage given depth 1':91.0/116, 'BinSize':180}
self._assertCompute(answer, \
SampleTV( segments=[[10,28], [90,180]], anchor=[10,190] ), \
SampleTV( segments=[[27,36], [90,180]], anchor=[10,190] ),\
assertFunc=self.assertListsOrDicts)
def test_compute(self):
#self._assertCompute(1, SampleTV( 2 ))
answer = {'11': 1 / 90.0, '10': 18 / 90.0, '01': 9 / 90.0}
self._assertCompute(answer, \
SampleTV( segments=[[10,28]], anchor=[10,100] ), \
SampleTV( segments=[[27,36]], anchor=[10,100] ),\
assertFunc=self.assertListsOrDicts)
answer = {'11': 91 / 180.0, '10': 108 / 180.0, '01': 99 / 180.0}
self._assertCompute(answer, \
SampleTV( segments=[[10,28], [90,180]], anchor=[10,190] ), \
SampleTV( segments=[[27,36], [90,180]], anchor=[10,190] ),\
assertFunc=self.assertListsOrDicts)
def test_compute(self):
self._assertCompute({'c1':2,'c2':1}, SampleTV_Num( anchor=[99,102], valDType='S', vals=['c1','c2','c1'] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({'c1':120,'c2':105}, SampleTV( segments=[[10,20], [50,155], [80,190]], vals=['c1','c2','c1'], valDType='S', anchor=[10,200] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({'c1':180,'c2':115}, SampleTV( segments=[[10,50], [40,155], [40,170], [40,190]], vals=['c1','c2','c1','c1'], valDType='S', anchor=[10,200] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({'c1':2,'c2':1}, SampleTV( starts=[2,15,160], vals=['c1','c2','c1'], valDType='S', anchor=[10,200] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({'c1':185,'c2':5}, SampleTV( ends=[15,20,190], vals=['c1','c2','c1'], valDType='S', anchor=[10,200] ),\
assertFunc=self.assertListsOrDicts)
self._assertCompute({}, SampleTV( segments=[], vals=[], valDType='S2', anchor=[10,200] ),\
assertFunc=self.assertListsOrDicts)
