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 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 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 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 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 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 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_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 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 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 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 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])
