def Shinohara3(retI = False): """ no = 14: Shinohara3 { y(0) = p*p*p - 2.*p*q + r + 0.75*p + 1. { y(1) = p*p*q - q*q - p*r +s + 0.75*q + 0.25 { y(2) = p*p*r - p*s - q*r + t + 0.75*r + 0.75 { y(3) = p*p*s - p*t - q*s + 0.75*s { y(4) = p*p*t - q*t + 0.75*t - 0.25 true value = ? """ y = [0.0 for i in range(5)] x[0], x[1], x[2], x[3], x[4] = fd.oovars('x0', 'x1', 'x2', 'x3', 'x4') p = x[0]; q = x[1]; r = x[2]; s = x[3]; t = x[4]; y[0] = p*p*p - 2.*p*q + r + 0.75*p + 1. y[1] = p*p*q - q*q - p*r +s + 0.75*q + 0.25 y[2] = p*p*r - p*s - q*r + t + 0.75*r + 0.75 y[3] = p*p*s - p*t - q*s + 0.75*s y[4] = p*p*t - q*t + 0.75*t - 0.25 if retI == True: return np.matrix([[interval(-1.5, 2.)],\ [interval(-0.6, 3.)],\ [interval(-1.5, 2.5)],\ [interval(-0.5, 1.9)],\ [interval(-1., 1.)]]) return y
def test_insert(self): # test the function of insert interval_list = [] interval_list.append(interval('(2,5)')) interval_list.append(interval('[4,10)')) interval_list.append(interval('(-10,0]')) new_interval = interval('[-20,-14)') self.assertEqual('[[-20,-14), (-10,0], (2,10)]', str(insert(interval_list,new_interval)))
def Shinohara1(retI = False): """ no = 12: Shinohara1 { y(0) = p*p*p*p*p - 10.*p*p*p*q*q + 5.*p*q*q*q*q - 2.*p*p*p*p + 12.*p*p*q*q - 2.*q*q*q*q + 10.*p*p*p - 30.*p*q*q - 9.*p + 3. { y(1) = q*q*q*q*q - 10.*p*p*q*q*q + 5.*p*p*p*p*q - 8.*p*p*p*q + 8.*p*q*q*q + 30.*p*p*q -10.*q*q*q - 9.*q true value = ? """ y = [0.0 for i in range(2)] x[0], x[1] = fd.oovars('x0', 'x1') p = x[0] q= x[1] y[0] = p*p*p*p*p - 10.*p*p*p*q*q + 5.*p*q*q*q*q\ - 2.*p*p*p*p + 12.*p*p*q*q - 2.*q*q*q*q\ + 10.*p*p*p - 30.*p*q*q - 9.*p + 3. y[1] = q*q*q*q*q - 10.*p*p*q*q*q + 5.*p*p*p*p*q\ - 8.*p*p*p*q + 8.*p*q*q*q + 30.*p*p*q\ -10.*q*q*q - 9.*q if retI == True: return np.matrix([[interval(-5.1, 5.)], [interval(-5., 5.1)]]) return y
def test_insert_1(self): int1 = interval('[1,2]') int2 = interval('[4,5)') int3 = interval('[10,12)') int4 = interval('[5,9]') intervals = [int1, int2, int3] self.assertEqual(str(insert(intervals,int4)), '[[1, 2], [4, 12)]')
def mergeIntervals(interval_1, interval_2): '''merge two intervals by using interval class to understand the real interval and judge whether two can merge''' interval_1 = interval(interval_1) interval_2 = interval(interval_2) interval_1.realInterval() interval_2.realInterval() if interval_1.realLowerBound > interval_2.realUpperBound + 1 or interval_1.realUpperBound + 1 < interval_2.realLowerBound: # the intervals not overlap on adjacent would raise an error raise merge_bad() else: if int(interval_1.lowerBound) <= int(interval_2.lowerBound): if int(interval_1.upperBound) > int(interval_2.upperBound): return '%s%s,%s%s' % ( interval_1.leftBound, int(interval_1.lowerBound), int(interval_1.upperBound), interval_1.rightBound) else: return '%s%s,%s%s' % ( interval_1.leftBound, int(interval_1.lowerBound), int(interval_2.upperBound), interval_2.rightBound) else: if int(interval_2.upperBound) > int(interval_1.upperBound): return '%s%s,%s%s' % ( interval_2.leftBound, int(interval_2.lowerBound), int(interval_2.upperBound), interval_2.rightBound) else: return '%s%s,%s%s' % ( interval_2.leftBound, int(interval_2.lowerBound), int(interval_1.upperBound), interval_1.rightBound)
def test_mergeOverlapping_2(self): int1 = interval("[1,2]") int2 = interval("[3,5)") int3 = interval("[10,12)") int4 = interval("[12,15]") intervals = [int1, int2, int3, int4] self.assertEqual(str(mergeOverlapping(intervals)), "[[1, 5), [10, 15]]")
def main(): while True: try: user_inp = input('List of intervals? ') user_inp = user_inp.replace(' ','').lower() if user_inp == 'quit': break else: inp_list = user_inp.split(',') lis = [] for i in range(0, len(inp_list), 2): lis.append(interval(inp_list[i] + ',' + inp_list[i+1])) lis = mergeOverlapping(lis) break except (KeyboardInterrupt, SystemExit): raise except (EOFError, SystemExit): raise while True: try: inserted_inp = input("Intervals?") if inserted_inp.lower() == 'quit': break else: inserted_inp = interval(inserted_inp) lis = insert(lis,inserted_inp) print(lis) except (KeyboardInterrupt, SystemExit): raise except (EOFError, SystemExit): raise
def main(): # Run this loop to check out whether the input intervals is valid. while True: intervals = input('List of Intervals?') if intervals == 'quit': sys.exit(0) else: # If the input is invalid, turn to the next step try: intervals = intervals.split(', ') intervals = mergeOverlapping(intervals) break # If the input is invalid, try another intervals except ValueError: print('Invalid Intervals.') # Run this loop to merge the intervals with a new interval. while True: newint = input('Interval?') if newint == 'quit': break else: try: interval(newint) intervals = intervals.split(', ') intervals = insert(intervals, newint) print(intervals) except ValueError: print('Invalid Interval.') sys.exit(0)
def mergeIntervals(int1, int2): ''' The function takes two intervals as arguments. If the intervals overlap or are adjacent, it returns a merged interval. If the intervals cannot be merged, it throws an exception. ''' if int1.lower_integer <= int2.lower_integer: if int1.upper_integer >= int2.lower_integer - 1: if int1.upper_integer > int2.upper_integer: return int1 else: return interval( str(int1)[0] + str(int1.lower) + ', ' + str(int2.upper) + str(int2)[-1]) else: raise Exception('The intervals cannot be merged') else: if int1.lower_integer <= int2.upper_integer + 1: if int1.upper_integer > int2.upper_integer: return interval( str(int2)[0] + str(int2.lower) + ', ' + str(int1.upper) + str(int1)[-1]) else: return int2 else: raise Exception('The intervals cannot be merged')
def testInsertEndMerge(self): ''' Test that insert merges interval at an extremity of list ''' intervals = [interval("(4,8]"), interval("(6,10)")] insertInt = interval("(0,5)") self.assertEqual(insert(intervals, insertInt), [interval("[1, 9]")])
def testInsertWithoutMerge(self): ''' Test that insert adds interval to list when none can be merged ''' intervals = [interval("(0,3)"), interval("(6,10)")] insertInt = interval("(4,5]") self.assertEqual(insert(intervals, insertInt), [interval("(0,3)"), interval("(4,5]"), interval("(6,10)")])
def test_interval_contains(self): intvl1 = interval("[1, 3]") for n in (1, 2, 3): self.assertTrue(intvl1.contains(n)) self.assertFalse(intvl1.contains(0)) self.assertFalse(intvl1.contains(4)) intvl2 = interval("(1, 3)") self.assertTrue(intvl2.contains(2)) self.assertFalse(intvl2.contains(1)) self.assertFalse(intvl2.contains(3)) intvl3 = interval("(-3, 1]") for n in (-2, -1, 0, 1): self.assertTrue(intvl3.contains(n)) self.assertFalse(intvl3.contains(-3)) self.assertFalse(intvl3.contains(2)) # In a future version, we may allow non-integer tests, but not now self.assertFalse(intvl3.contains(-3.0)) # Allow anything that can be cast to integer with self.assertRaises(ValueError): self.assertTrue(intvl3.contains(-2.5)) with self.assertRaises(ValueError): self.assertTrue(intvl3.contains(0.999)) with self.assertRaises(ValueError): self.assertFalse(intvl3.contains(1.01))
def testeq(self): ''' Test overloaded "=" operator for interval objects ''' self.assertTrue(interval("(-1,3)") == interval("(-1,3)")) self.assertFalse(interval("(-1,3)") == interval("[0,2]"), "Error: Normalized equal intervals should not be literally equal")
def test_mergeIntervals(self): """ Assuming have passed the test_interval test; This test function examines the mergeIntervals function from three aspects: 1) adjacent merge 2) overlapping merge 3) merge exceptions """ t1 = interval('(1, 8]') t2 = interval('[9, 19)') t3 = interval('[16, 26)') t4 = interval('(30, 166)') t5 = interval('[60, 100]') # test adjacent merge self.assertEqual('(1,19)', mergeIntervals(t1, t2)) # test overlapping merge self.assertEqual('[9,26)', mergeIntervals(t2, t3)) self.assertEqual('(30,166)', mergeIntervals(t4, t5)) # test merge exceptions with self.assertRaises(NoOverlapError): mergeIntervals(t3, t4) with self.assertRaises(NoOverlapError): mergeIntervals(t5, t1)
def test_mergeOverlapping_2(self): int1 = interval('[1,2]') int2 = interval('[3,5)') int3 = interval('[10,12)') int4 = interval('[12,15]') intervals = [int1,int2,int3,int4] self.assertEqual(str(mergeOverlapping(intervals)), '[[1, 5), [10, 15]]')
def main(): input_line = str(input("Interval? ")) int_list = input_line.split(', ') intervals = [] for ints in int_list: try: lower_bound, upper_bound, lower_exclusive, upper_exclusive = parseString_Interval( ints) intervals.append( interval(lower_bound, upper_bound, lower_exclusive, upper_exclusive)) except IntervalException: print('Invalid Intervals') while True: input_line = input_line = input("Interval? ") if input_line == 'quit': break try: lower_bound, upper_bound, lower_exclusive, upper_exclusive = parseString_Interval( input_line) newint = interval(lower_bound, upper_bound, lower_exclusive, upper_exclusive) intervals = insert(intervals, newint) print(intervals) except (IntervalException, MergeException): print('Invalid interval')
def test_insert_1(self): int1 = interval("[1,2]") int2 = interval("[4,5)") int3 = interval("[10,12)") int4 = interval("[5,9]") intervals = [int1, int2, int3] self.assertEqual(str(insert(intervals, int4)), "[[1, 2], [4, 12)]")
def trigger(): """ trigger func for calcurating time """ no = 0 I = np.matrix([[interval(-0.11, 0.1)], [interval(-0.1, 0.1)]]) krawczyk(no, I)
def test_no_overlapping_situation(self): ''' when 2 do not overlap :return: ''' with self.assertRaises(notOverlappingException): #raise exception mergeInterval(interval('[3,7)'), interval('[12,15)'))
def test_insert(self): intervals = [] intervals.append(interval("[1,5]")) intervals.append(interval("[2,6]")) intervals.append(interval("[9,10]")) newint = interval("[8,11]") insert(intervals, newint) self.assertEqual(str(intervals), "[[1,6], [8,11]]")
def test_insert(self): # test the function of insert interval_list = [] interval_list.append(interval('(2,5)')) interval_list.append(interval('[4,10)')) interval_list.append(interval('(-10,0]')) new_interval = interval('[-20,-14)') self.assertEqual('[[-20,-14), (-10,0], (2,10)]', str(insert(interval_list, new_interval)))
def test_overlapping_situation(self): ''' when 2 intervals overlap :return: ''' self.assertEqual( mergeInterval(interval('[1,4)'), interval('[3,8)')).__repr__(), '[1,8)')
def test_containing_situation(self): ''' when 1 contains the other :return: ''' self.assertEqual( mergeInterval(interval('[2,12)'), interval('[4,9]')).__repr__(), '[2,12)')
def test_insert(self): intervals = [ interval('[1,2]'), interval('[2,3]'), interval('(3,5]'), interval('(7,8]') ] self.assertEqual(str(insert(intervals, interval('[3,8]'))), '[[1,8]]')
def test_mergeOverlapping(self): interval_list = [] interval_list.append(interval('(3,5)')) interval_list.append(interval('[5,8)')) interval_list.append(interval('(-1,0]')) interval_list.append(interval('[4,12)')) interval_list.append(interval('(7,9)')) self.assertEqual('[(-1,0], (3,12)]', str(mergeOverlapping(interval_list)))
def mergeIntervals(int1, int2): '''Takes two intervals. If the intervals overlap or are adjacent, returns a merged interval. If the intervals cannot be merged, an exception should be thrown.''' #First sort the intervals based on their lower bounds int1, int2 = sorted((int1, int2), key=by_lower) #Turns the inputs into interval class objects int1 = interval(int1) int2 = interval(int2) #If the input intervals are not valid print out an error message. if int1.intervalNumbers() == 'Invalid interval' or int2.intervalNumbers( ) == 'Invalid interval': return ('Invalid interval') #If the input intervals are valid continue. else: #Find out if the two interval are overlapping not. if list(set(int1.intervalNumbers()) & set(int2.intervalNumbers())) == []: #If they are not overlapping, find out if they are adjacent or not if max(int1.intervalNumbers()) + 1 == min(int2.intervalNumbers()): #If they are adjacent, merge them return int1.opening + str(int1.lower) + ',' + str( int2.upper) + int2.closing #If they are not overlapping or adjacent, return the following message else: return 'Error: The two lists cannot be merged' #If they are overlapping, merge them. Using conditionals to form the right interval. else: if max(int1.intervalNumbers()) > max(int2.intervalNumbers()): if int1.lower == int2.lower and int2.opening == '[': return int2.opening + str(int1.lower) + ',' + str( int1.upper) + int1.closing else: return int1.opening + str(int1.lower) + ',' + str( int1.upper) + int1.closing elif max(int1.intervalNumbers()) < max(int2.intervalNumbers()): if int1.lower == int2.lower and int2.opening == '[': return int2.opening + str(int1.lower) + ',' + str( int2.upper) + int2.closing else: return int1.opening + str(int1.lower) + ',' + str( int2.upper) + int2.closing else: if int1.upper >= int2.upper: return int1.opening + str(int1.lower) + ',' + str( int1.upper) + int1.closing else: return int1.opening + str(int1.lower) + ',' + str( int2.upper) + int2.closing
def test_invalid_intervals_do_not_validate(self): with self.assertRaises(InvalidIntervalException): intvl1 = interval("(1, 1)") with self.assertRaises(InvalidIntervalException): intvl2 = interval("(-1, -3)") with self.assertRaises(InvalidIntervalException): intvl3 = interval("[3, 1]") with self.assertRaises(InvalidIntervalException): intvl4 = interval("(1, 1]")
def testisMergeable2(self): test_input1 = "[1,2]" param = parseString_Interval(test_input1) myInt1 = interval(param[0], param[1], param[2], param[3]) test_input2 = "[3,4]" param = parseString_Interval(test_input2) myInt2 = interval(param[0], param[1], param[2], param[3]) self.assertEqual(False, isMergeable(myInt1, myInt2))
def setUp(self): self.list = [ interval('[1,5)'), interval('[2,6)'), interval('(8,10]'), interval('[8,18]') ] self.answer = [interval('[1,6)'), interval('[8,18]')] self.list2 = [interval('(1,5)'), interval('[7,10)')] self.answer2 = [interval('(1,5)'), interval('[7,10)')]
def test_insert(self): intervals = [ interval(1, 3), interval(2, 4), interval(9, 11), ] newint = interval(4, 7) target = [interval(1, 11)] inserted = insert(intervals, newint) self.assertEqual(target, inserted)
def test_mergeIntervals(self): a = interval('(5, 7)') b = interval('(4, 9)') c = interval('(-4, 1)') d = interval('(-4, 2)') e = interval('(3, 8)') self.assertEqual(mergeIntervals(a, b), c) self.assertEqual(mergeIntervals(a, c), c) self.assertEqual(mergeIntervals(d, a), d) with self.assertRaises(ValueError): mergeIntervals(a, e)
def split(I): """ splitting List """ # Deep-copy による区間の複製 Isucc = np.mat(I.copy()) Ipred = np.mat(I.copy()) # 区間幅の最も大きいものを分割 Isucc[maxElementInMatrix(I)] = interval(I.item(maxElementInMatrix(I)).inf, interval.medsucc(I.item(maxElementInMatrix(I)))) Ipred[maxElementInMatrix(I)] = interval(interval.medpred(I.item(maxElementInMatrix(I))), I.item(maxElementInMatrix(I)).sup) return [Ipred, Isucc]
def testmergeintervals(self): test_input1 = "[1,3]" param = parseString_Interval(test_input1) myInt1 = interval(param[0], param[1], param[2], param[3]) test_input2 = "[2,4]" param = parseString_Interval(test_input2) myInt2 = interval(param[0], param[1], param[2], param[3]) answer = "[1,4]" self.assertEqual(answer, str(mergeIntervals(myInt1, myInt2)))
def testisMergeable3(self): #test if adjacency is flagged test_input1 = "[1,2)" param = parseString_Interval(test_input1) myInt1 = interval(param[0], param[1], param[2], param[3]) test_input2 = "[2,4]" param = parseString_Interval(test_input2) myInt2 = interval(param[0], param[1], param[2], param[3]) self.assertEqual(True, isMergeable(myInt1, myInt2))
def test_valid_interval_creation_and_representation(self): intvl1 = interval("[0,1]") self.assertEqual(str(intvl1), "[0,1]") intvl2 = interval("( -10 , +1)") self.assertEqual(intvl2.__str__(), "(-10,1)") intvl3 = interval(" [ -3, 3 )") self.assertEqual(intvl3.__str__(), "[-3,3)") intvl4 = interval("[1, 1]") self.assertEqual(intvl4.__str__(), "[1,1]") intvl5 = interval("[1, 2)") self.assertEqual(intvl5.__str__(), "[1,2)")
def test_sort_intervals(self): list_of_intervals = [interval('[-1,3]'),interval('(3,5]'),interval('(-10,-3]'),interval('[100,105]'),interval('(0,1]')] list_of_correct_ordered_intervals_by_lowest_value = [interval('(-10,-3]'),interval('[-1,3]'),interval('(0,1]'),interval('(3,5]'),interval('[100,105]')] sorted_list = sort_intervals(list_of_intervals) for ii in range(0,len(list_of_intervals)): self.assertEqual(sorted_list[ii].str,list_of_correct_ordered_intervals_by_lowest_value[ii].str) self.assertEqual(sorted_list[ii].lower_value,list_of_correct_ordered_intervals_by_lowest_value[ii].lower_value) self.assertEqual(sorted_list[ii].higher_value,list_of_correct_ordered_intervals_by_lowest_value[ii].higher_value) self.assertEqual(sorted_list[ii].lower_brac,list_of_correct_ordered_intervals_by_lowest_value[ii].lower_brac) self.assertEqual(sorted_list[ii].higher_brac,list_of_correct_ordered_intervals_by_lowest_value[ii].higher_brac) self.assertEqual(sorted_list[ii].lowest_value,list_of_correct_ordered_intervals_by_lowest_value[ii].lowest_value) self.assertEqual(sorted_list[ii].highest_value,list_of_correct_ordered_intervals_by_lowest_value[ii].highest_value)
def test_insert(self): list_of_intervals = [interval('(-10,-3]'),interval('[-1,3)')] int1 = interval('[-3,2]') inserted_list = insert(list_of_intervals,int1) corr_list = [interval('(-10,3)')] for ii in range(0,len(inserted_list)): self.assertEqual(inserted_list[ii].str,corr_list[ii].str) self.assertEqual(inserted_list[ii].lower_value,corr_list[ii].lower_value) self.assertEqual(inserted_list[ii].higher_value,corr_list[ii].higher_value) self.assertEqual(inserted_list[ii].lower_brac,corr_list[ii].lower_brac) self.assertEqual(inserted_list[ii].higher_brac,corr_list[ii].higher_brac) self.assertEqual(inserted_list[ii].lowest_value,corr_list[ii].lowest_value) self.assertEqual(inserted_list[ii].highest_value,corr_list[ii].highest_value)
def sorting(int1,int2): ''' this is a function that sorts intervals by the smallest number in the interval ''' int1=no_space(int1) int2=no_space(int2) int1 = interval(int1) int2 = interval(int2) if int1.lower_real < int2.lower_real: return -1 if int1.lower_real > int2.lower_real: return 1 else: return 0
def fineAdjustI(I): """ spreading width of interval if mid is 0. """ adjustI = [] for i in xrange(len(I)): if interval.mid(I.item(i)) == 0.: if (i+1)%2 == 0: adjustI.append([interval(I.item(i).inf, I.item(i).sup + 1e-3)]) else: adjustI.append([interval(I.item(i).inf - 1e-3, I.item(i).sup)]) else: adjustI.append([interval(I.item(i).inf, I.item(i).sup)]) return np.mat(adjustI)
def test_mergeOverlapping(self): intervals = [] int1 = interval("[1,2]") intervals.append(int1) int2 = interval("(3,5]") intervals.append(int2) int13 = mergeOverlapping(intervals) self.assertEqual("[[1,2], (3,5]]", str(int13)) int4 = interval("[1,13]") intervals.append(int4) int14 = mergeOverlapping(intervals) self.assertEqual("[[1,13]]", str(int14)) int5 = interval("[12,13]") int6 = interval("[3,13]") int7 = interval("[1,4]") int8 = interval("(5,8]") """ int9 = mergeOverlapping([int1, int2]) self.assertEqual('[[1,5]]', str(int9)) int10 = mergeOverlapping([int1, int2, int3]) self.assertEqual('[[1,5]]', str(int10)) int11 = mergeOverlapping([int1, int2, int4, int9]) self.assertEqual('[[1,12)]', str(int11)) int12 = mergeOverlapping([int4, int5]) self.assertEqual('[[3,13]]', str(int12)) """ with self.assertRaises(InvalidException): int10 = interval("foo") int9 = mergeOverlapping([int7, int8, int10])
def mergeIntervals(int1, int2): '''Takes two intervals. If the intervals overlap or are adjacent, returns a merged interval. If the intervals cannot be merged, an exception should be thrown.''' #First sort the intervals based on their lower bounds int1 , int2 = sorted((int1, int2), key=by_lower) #Turns the inputs into interval class objects int1 = interval(int1) int2 = interval(int2) #If the input intervals are not valid print out an error message. if int1.intervalNumbers() == 'Invalid interval' or int2.intervalNumbers() == 'Invalid interval': return('Invalid interval') #If the input intervals are valid continue. else: #Find out if the two interval are overlapping not. if list(set(int1.intervalNumbers()) & set(int2.intervalNumbers())) == []: #If they are not overlapping, find out if they are adjacent or not if max(int1.intervalNumbers()) + 1 == min(int2.intervalNumbers()): #If they are adjacent, merge them return int1.opening + str(int1.lower) + ',' + str(int2.upper) + int2.closing #If they are not overlapping or adjacent, return the following message else: return 'Error: The two lists cannot be merged' #If they are overlapping, merge them. Using conditionals to form the right interval. else: if max(int1.intervalNumbers()) > max(int2.intervalNumbers()): if int1.lower == int2.lower and int2.opening == '[': return int2.opening + str(int1.lower) + ',' + str(int1.upper) + int1.closing else: return int1.opening + str(int1.lower) + ',' + str(int1.upper) + int1.closing elif max(int1.intervalNumbers()) < max(int2.intervalNumbers()): if int1.lower == int2.lower and int2.opening == '[': return int2.opening + str(int1.lower) + ',' + str(int2.upper) + int2.closing else: return int1.opening + str(int1.lower) + ',' + str(int2.upper) + int2.closing else: if int1.upper >= int2.upper: return int1.opening + str(int1.lower) + ',' + str(int1.upper) + int1.closing else: return int1.opening + str(int1.lower) + ',' + str(int2.upper) + int2.closing
def testmergeOverlapping(self): test_input1 = "[1,3]" param = parseString_Interval(test_input1) myInt1 = interval(param[0], param[1], param[2], param[3]) test_input2 = "[2,4]" param = parseString_Interval(test_input2) myInt2 = interval(param[0], param[1], param[2], param[3]) test_input3 = "[5,6]" param = parseString_Interval(test_input3) myInt3 = interval(param[0], param[1], param[2], param[3]) intervals = [myInt1, myInt2, myInt3] answer = "[[1,4], [5,6]]" self.assertEqual(answer, str(mergeOverlapping(intervals)))
def sortIntervals(intervalList): '''sort the list of intervals to be an ascending order by comparing the real lower bound of the intervals''' realIntervalList = [] for i in range(len(intervalList)): oneInterval = interval(intervalList[i]) oneInterval.realInterval() realIntervalList.append(oneInterval) # each loop would return an interval with a minimum real lower bound and add it to the intervalListSorted list. intervalLength = len(intervalList) intervalListSorted = [] while intervalLength > 0: #there are n = intervalLength intervals so sort n times. minimumLower = float("inf") listLength = 0 listNumber = 0 for i in range(0,len(realIntervalList)): #each loop to find a minimum. if minimumLower > realIntervalList[i].realLowerBound: minimumLower = realIntervalList[i].realLowerBound listNumber = i listLength = len(realIntervalList[i].realIntervalInput) elif minimumLower == realIntervalList[i].realLowerBound: if len(realIntervalList[i].realIntervalInput) > listLength: listNumber = i listLength = len(realIntervalList[i].realIntervalInput) intervalListSorted.append(intervalList[listNumber]) #add the interval to the new list del intervalList[listNumber] del realIntervalList[listNumber] intervalLength = intervalLength - 1 return intervalListSorted
def offset(self, start=None, end=None) : """ Modifies globally the intervals by offsetting the start and end of the stimulation. The start and/or stop arguments should be tuples (limit, offset) where limit defines the reference limit (0 : start, 1: end) from where the new value is defined by adding the offset value to the current start/end. """ n_intervals = len(list(self.interval_data)) new_iv = zeros((n_intervals,2)) if start is None : for i in range(n_intervals) : new_iv[i,0] = self.interval_data[i][0] else : if start[0] == 0 : for i in range(n_intervals) : new_iv[i,0] = self.interval_data[i][0] + start[1] if start[0] == 1 : for i in range(n_intervals) : new_iv[i,0] = self.interval_data[i][1] + start[1] if end is None : for i in range(n_intervals) : new_iv[i,1] = self.interval_data[i][1] else : if end[0] == 0 : for i in range(n_intervals) : new_iv[i,1] = self.interval_data[i][0] + end[1] if end[0] == 1 : for i in range(n_intervals) : new_iv[i,1] = self.interval_data[i][1] + end[1] self.interval_data = interval(*list(new_iv))
def mergeIntervals(int1, int2): """Attempts to merge two adjacent or overlapping intervals""" if isMergeable(int1, int2): l_bound = min(int1.lower_bound, int2.lower_bound) u_bound = max(int1.upper_bound, int2.upper_bound) else: raise MergeException() if (int1.lower_bound < int2.lower_bound): exclusive_lower = int1.exclusive_lower elif (int2.lower_bound < int1.lower_bound): exclusive_lower = int2.exclusive_lower ##Inclusive takes precedence if bounds are the same else: exclusive_lower = (int1.exclusive_lower or int2.exclusive_lower) if (int1.upper_bound > int2.upper_bound): exclusive_upper = int1.exclusive_upper elif (int2.upper_bound < int1.upper_bound): exclusive_upper = int2.exclusive_upper ##Inclusive takes precedence if bounds are the same else: exclusive_upper = (int1.exclusive_upper or int2.exclusive_upper) mergeInt = interval(l_bound, u_bound, exclusive_lower, exclusive_upper) return mergeInt
def testEmptyList(self): ''' Test that insert works on empty list ''' intervals = [] insertInt = interval("(1,3)") self.assertEqual(insert(intervals, insertInt), [insertInt])