def test_repr(self):
self.assertEqual(
repr(interval(1, 2)),
'<interval: [(1, 2)]>')
self.assertEqual(
repr(interval()),
'<interval: null interval>')
def test_equity_error(self):
try:
interval(1, 4) == 10
except TypeError as e:
self.assertIn(repr(int), repr(e))
else:
assert False
def test_equity_error(self):
try:
interval(1, 4) == 10
except TypeError as e:
self.assertIn(repr(int), repr(e))
else:
assert False
def test_len(self):
interv = interval(1, 2) + interval(3, 4)
self.assertEqual(interv.length(), 2)
self.assertAlmostEqual(interval(10.0, 20.1).length(), 10.1)
interv = interval(datetime(1, 1, 1), datetime(1, 1, 10))
self.assertEqual(interv.length().days, 9)
def test_len(self):
interv = interval(1, 2) + interval(3, 4)
self.assertEqual(interv.length(), 2)
self.assertAlmostEqual(interval(10.0, 20.1).length(), 10.1)
interv = interval(datetime(1, 1, 1), datetime(1, 1, 10))
self.assertEqual(interv.length().days, 9)
def test_add(self):
interv = interval(1, 3) + interval(6, 10)
self.assertEqual(interv.subintervals, [(1, 3), (6, 10)])
self.assertIn(2, interv)
self.assertIn(7, interv)
self.assertNotIn(0, interv)
self.assertNotIn(4, interv)
self.assertNotIn(11, interv)
def test_add(self):
interv = interval(1, 3) + interval(6, 10)
self.assertEqual(interv.subintervals, [(1, 3), (6, 10)])
self.assertIn(2, interv)
self.assertIn(7, interv)
self.assertNotIn(0, interv)
self.assertNotIn(4, interv)
self.assertNotIn(11, interv)
def test_contains(self):
interv = interval(-1, 1)
self.assertIn(0, interv)
self.assertIn(-1, interv)
self.assertIn(1, interv)
self.assertNotIn(-1.1, interv)
self.assertNotIn(1.1, interv)
def mergeIntervals(int1, int2):
'''
Merge two overlapping intervals. Raise error if they are not adjacent
'''
if int1.starting_value <= int2.ending_value:
if int1.ending_value <= int2.ending_value:
return int2
else:
return interval(int2.lower_bound + str(int2.input_value[0]) + ',' + str(int1.input_value[1]) + int1.upper_bound)
elif int2.starting_value <= int1.ending_value:
if int2.ending_value <= int1.ending_value:
return int1
else:
return interval(int1.lower_bound + str(int1.input_value[0]) + ',' + str(int2.input_value[1]) + int2.upper_bound)
else:
raise MergeError
def interval_translator():
"""This function takes in a list of intervals in string form from the user and then turns it into an actual list of intervals """
# These are the characters that this function is allowed to use to build an interval
white_list = "[(-0123456789)],"
# Takes in the input from the user and gets it ready to be processed
input_string = input("List of intervals? \n") + ","
ind = 0
intervals = []
# Goes through the input string and starts building the list of intervals
while ind < len(input_string):
comma_count = 0
temp_string = ""
while comma_count < 2 :
test = input_string[ind]
if test == "," :
comma_count += 1
if (test in white_list) and comma_count < 2 :
temp_string += test
ind += 1
else :
intervals.append(interval(temp_string))
print(intervals)
return intervals
def test_contains(self):
interv = interval(-1, 1)
self.assertIn(0, interv)
self.assertIn(-1, interv)
self.assertIn(1, interv)
self.assertNotIn(-1.1, interv)
self.assertNotIn(1.1, interv)
def mergeIntervals(int1, int2):
'''
Merge two overlapping intervals. Raise error if they are not adjacent
'''
if int1.starting_value <= int2.ending_value:
if int1.ending_value <= int2.ending_value:
return int2
else:
return interval(int2.lower_bound + str(int2.input_value[0]) + ',' +
str(int1.input_value[1]) + int1.upper_bound)
elif int2.starting_value <= int1.ending_value:
if int2.ending_value <= int1.ending_value:
return int1
else:
return interval(int1.lower_bound + str(int1.input_value[0]) + ',' +
str(int2.input_value[1]) + int2.upper_bound)
else:
raise MergeError
def test_equity(self):
self.assertEqual(
interval(1, 2),
interval(1, 2))
self.assertEqual(
interval(1, 2) + interval(3, 4),
interval(3, 4) + interval(1, 2))
def do_merge(i1, i2): #2 interval object
# check the lower bound of 2 intervals
if (len(set(i1.integers) & set(i2.integers)) > 0):
if i1.lower_value < i2.lower_value:
merge_interval = i1.lower_bound + str(i1.lower_value) + ','
elif i2.lower_value < i1.lower_value:
merge_interval = i2.lower_bound + str(i2.lower_value) + ','
else:
if i1.lower_bound == '(' and i2.lower_bound == '(':
merge_interval = '(' + str(i2.lower_value) + ','
else:
merge_interval = '[' + str(i2.lower_limit) + ','
#check the upper bound of the intervals
if i1.upper_value < i2.upper_value:
merged_interval = merged_interval + str(
int2.upper_value) + int2.upper_bound
elif i2.upper_value < i1.upper_value:
merge_interval = merge_interval + str(
i1.upper_value) + i1.upper_bound
else:
if i1.upper_bound == ')' and i2.upper_bound == ')':
merged_interval = merged_interval + str(i2.upper_value) + ')'
else:
merged_interval = merged_interval + str(i2.upper_value) + ']'
elif ((i1.lower_bound == '[' or i2.upper_bound == ']')
and (i1.lower_value == i2.upper_value)):
merged_interval = i2.lower_bound + str(i2.lower_value) + ',' + str(
i1.upper_value) + i1.upper_bound
elif ((i1.upper_bound == ']' or i2.lower_bound == '[')
and (int1.upper_value == int2.lower_value)):
merged_interval = i1.lower_bound + str(i1.lower_value) + ',' + str(
int2.upper_value) + int2.upper_bound
elif ((i1.lower_bound == '[' and i2.upper_bound == ']')
and (i1.lower_value - 1 == i2.upper_value)):
merged_interval = i2.lower_bound + str(i2.lower_value) + ',' + str(
i1.upper_value) + i1.upper_bound
elif ((i1.upper_bound == ']' and i2.lower_bound == '[')
and (i1.upper_value + 1 == i2.lower_value)):
merged_interval = i1.lower_bound + str(i1.lower_value) + ',' + str(
i2.upper_value) + i2.upper_bound
else:
print "not overlap"
return interval(merged_interval)
def mergeIntervals(int1, int2) :
""" This function should take in two intervals and merge them into one interval. If a merge is not possible then it will raise a NameError """
# Gets the true upper and lower limits of the new interval as well as what it is expected to contain as well as what it does contain
true_lower = min(int1.true_lower, int2.true_lower)
true_upper = max(int1.true_upper, int2.true_upper)
actlly_contain = list(int1.contains) + list(int2.contains)
should_contain = list(range(true_lower,true_upper))
# Determines if the new interval contains what it should
for number in should_contain :
if number not in actlly_contain :
mergeable = False
break
else :
mergeable = True
# If the intervals are mergeable starts building the new interval. If not raises a NameError
if mergeable :
if int1.true_lower == int2.true_lower :
lower = max(int1.lower, int2.lower)
else :
if true_lower == int1.true_lower :
lower = int1.lower
elif true_lower == int2.true_lower :
lower = int2.lower
if int1.true_upper == int2.true_upper :
if not int1.upper_inclusive:
upper = int1.upper
else :
upper = int2.upper
else :
if true_upper == int1.true_upper :
upper = int1.upper
elif true_upper == int2.true_upper :
upper = int2.upper
else :
raise NameError("Not mergeable intervals")
new_int_string = lower + "," + upper
new_int = interval(new_int_string)
return new_int
def do_merge(i1,i2): #2 interval object
# check the lower bound of 2 intervals
if (len(set(i1.integers) & set(i2.integers)) > 0):
if i1.lower_value<i2.lower_value:
merge_interval=i1.lower_bound + str(i1.lower_value) + ','
elif i2.lower_value<i1.lower_value:
merge_interval=i2.lower_bound+str(i2.lower_value)+','
else:
if i1.lower_bound=='(' and i2.lower_bound=='(':
merge_interval='('+str(i2.lower_value)+','
else:
merge_interval='['+str(i2.lower_limit)+','
#check the upper bound of the intervals
if i1.upper_value<i2.upper_value:
merged_interval = merged_interval + str(int2.upper_value) + int2.upper_bound
elif i2.upper_value<i1.upper_value:
merge_interval = merge_interval+str(i1.upper_value)+i1.upper_bound
else:
if i1.upper_bound == ')' and i2.upper_bound == ')':
merged_interval = merged_interval + str(i2.upper_value) + ')'
else:
merged_interval = merged_interval + str(i2.upper_value) + ']'
elif ((i1.lower_bound == '[' or i2.upper_bound == ']') and (i1.lower_value == i2.upper_value)):
merged_interval = i2.lower_bound + str(i2.lower_value) + ',' + str(i1.upper_value) + i1.upper_bound
elif ((i1.upper_bound == ']' or i2.lower_bound == '[') and (int1.upper_value == int2.lower_value)):
merged_interval = i1.lower_bound + str(i1.lower_value) + ',' + str(int2.upper_value) + int2.upper_bound
elif ((i1.lower_bound == '[' and i2.upper_bound == ']') and (i1.lower_value - 1 == i2.upper_value)):
merged_interval = i2.lower_bound + str(i2.lower_value) + ',' + str(i1.upper_value) + i1.upper_bound
elif ((i1.upper_bound == ']' and i2.lower_bound == '[') and (i1.upper_value + 1 == i2.lower_value)):
merged_interval = i1.lower_bound + str(i1.lower_value) + ',' + str(i2.upper_value) + i2.upper_bound
else:
print "not overlap"
return interval(merged_interval)
def test_null_interval(self):
interv = interval()
self.assertEqual(interv.subintervals, [])
self.assertNotIn(1, interv)
self.assertNotIn(-1, interv)
def test_init_naught(self):
interv = interval()
self.assertEqual(interv.subintervals, [])
def test_init_naught(self):
interv = interval()
self.assertEqual(interv.subintervals, [])
def test_init(self):
interv = interval(1, 2)
self.assertEqual(interv.subintervals, [(1, 2)])
def test_equity(self):
self.assertEqual(interval(1, 2), interval(1, 2))
self.assertEqual(
interval(1, 2) + interval(3, 4),
interval(3, 4) + interval(1, 2))
def test_add_collapses_intervals(self):
self.assertEqual(interval(1, 2) + interval(2, 3), interval(1, 3))
if __name__=="__main__":
flag=1 #set to input
while flag:
interval_list=raw_input("List of intervals?")
if interval_list=="quit":
break
process_list=re.findall(r'[[(].*?[\])]',interval_list)
if not len(process_list):
print "no input"
continue
intervals=[]
flag=0 #set to stop input
for i in process_list:
try:
intervals.append(interval(i))
except:
print "invalid input"
flag=1
break
else:
intervals.append(interval(i))
intervals=merge_intervals(intervals)
while 1:
new_interval=raw_input("interval?")
if new_interval=='quit':
break
else:
pre_pro_interval=re.findall(r'[[(].*?[\])]',new_interval)
try:
pre_pro_interval=interval(pre_pro_interval[0])
def test_null_interval(self):
interv = interval()
self.assertEqual(interv.subintervals, [])
self.assertNotIn(1, interv)
self.assertNotIn(-1, interv)
def test_add_collapses_intervals(self):
self.assertEqual(
interval(1, 2) + interval(2, 3),
interval(1, 3))
def test_datetimes(self):
start = datetime(1, 1, 1, 20, 0)
end = datetime(1, 1, 1, 23, 30)
interv = interval(start, end)
self.assertIn(datetime(1, 1, 1, 23, 0), interv)
# if intervals.index(i) != 0:
# out = out + ', ' + i.input
if __name__ == '__main__':
lists = []
try:
while True:
inputs = raw_input('List of Intervals?')
if inputs == 'quit':
sys.exit()
try:
temp = inputs.split(', ')
lists = [interval(i) for i in temp]
print len(lists)
break
except ValueError:
print temp
print "Invalid intervals: Please make sure you use comma and one whitespace between intervals"
while True:
inputs = raw_input('Intervals?')
if inputs == 'quit':
sys.exit()
try:
# print input
newint = interval(inputs)
except ValueError:
print "Invalid Interval: make sure your input is a proper interval"
intervals = interval_translator()
except NameError:
print("One of the intervals is not a valid interval")
except IndexError:
print("Not a valid list of intervals")
else:
is_proper_intervals = True
# Here the program continuely asks the user for an interval to be inserted and then merged into the list of intervals until prompted to quit.
quit = False
while quit == False :
is_proper_input = False
while is_proper_input == False:
interval_string = input("Interval? \n")
# Here the program determines if the interval can actually be made or if the user is quitting
try:
newint = interval(interval_string)
except NameError:
if interval_string == 'quit' :
quit = True
is_proper_input = True
else:
print("Invalid interval")
else:
is_proper_input = True
else:
if not quit:
intervals = insert(intervals, newint)
print(intervals)
rate = 44100
duration = 5
volume = 1
sd.default.samplerate = rate
scale = 'major'
print(scale)
chord = [0, 2, 4]
octaves = 2
notes = chain.from_iterable(
(n + o * len(SCALES[scale]) for n in chord) for o in range(octaves))
wave = None
amplitude = math.sqrt(volume) / (len(chord) * octaves)
for s in semitones(notes, scale):
f = frequency(s, base=220)
i = interval(s)
print(f'{s:02} {f:.2f} Hz : {i[0]} ({i[1]})')
w = waveform(f, rate, duration, amplitude)
if wave is None:
wave = w
else:
wave += w
crossfade(wave)
plt.plot(wave)
sd.play(wave)
plt.show()
# sd.wait()
def test_init(self):
interv = interval(1, 2)
self.assertEqual(interv.subintervals, [(1, 2)])
def test_repr(self):
self.assertEqual(repr(interval(1, 2)), '<interval: [(1, 2)]>')
self.assertEqual(repr(interval()), '<interval: null interval>')
if __name__ == "__main__":
flag = 1 #set to input
while flag:
interval_list = raw_input("List of intervals?")
if interval_list == "quit":
break
process_list = re.findall(r'[[(].*?[\])]', interval_list)
if not len(process_list):
print "no input"
continue
intervals = []
flag = 0 #set to stop input
for i in process_list:
try:
intervals.append(interval(i))
except:
print "invalid input"
flag = 1
break
else:
intervals.append(interval(i))
intervals = merge_intervals(intervals)
while 1:
new_interval = raw_input("interval?")
if new_interval == 'quit':
break
else:
pre_pro_interval = re.findall(r'[[(].*?[\])]', new_interval)
try:
pre_pro_interval = interval(pre_pro_interval[0])
def test_datetimes(self):
start = datetime(1, 1, 1, 20, 0)
end = datetime(1, 1, 1, 23, 30)
interv = interval(start, end)
self.assertIn(datetime(1, 1, 1, 23, 0), interv)
