def assert_expected_s2b_and_b2s_if_call_is_on_marker(self): """verify that if b2s and s2b are called on their respective markers, the result is consistent with their defintions. Notably, (0,0) is easy to cause errors.""" self.assertEqual(console(self.test, "b2s 1.0"), 5.0) self.assertEqual(console(self.test, "s2b 5.0"), 1.0) self.assertEqual(console(self.test, "s2b 0"), 0) self.assertEqual(console(self.test, "b2s 0"), 0)
def assert_warp_filters_invalid_b2s_and_s2p_ie_no_end_tempo(self): """ Verifies that if a end_tempo is not given, the b2s and s2b methods will have no output """ self.test.set_end_tempo(None) self.assertEqual(console(self.test, "b2s 2.0"), None) self.assertEqual(console(self.test, "s2b 6.0"), None) self.test.set_end_tempo(10.0)
def assert_end_tempo_doesnt_accept_negatives(self): """ Verifies that if a negative values is provided to end_tempo that nothing changes. """ end_tempo = self.test.end_tempo self.assertEqual(console(self.test, "end_tempo -10"), None) self.assertEqual(end_tempo, self.test.end_tempo)
def _exec(irc, event, args): """<code> Executes <code> in a Python interpreter. """ if is_owner(irc, event.source): output = utils.console({"irc": irc, "utils": utils, "event": event}).run(" ".join(args)) if output is not None: irc.reply(event, output)
def assert_warp_filters_invalid_markers_properly(self): """ Verifies that the object's marker values do not change / update when fed an invalid object. There are two invalid possibilities: 1) the marker is already defined 2) there is an intersection with another marker """ markers = self.test.markers.copy() # already defined points console(self.test, "marker 0.0 1.0") console(self.test, "marker 1.0 0.0") self.assertEqual(markers, self.test.markers) # interceting vertices console(self.test, "marker 0.5 6.0") self.assertEqual(markers, self.test.markers)
def assert_expected_s2b_and_b2s_if_only_1_marker(self): """ Verifies that the program functions as expected if only one marker exists """ warp_test = Warp() warp_test.set_marker(0, 0) warp_test.set_end_tempo(10) # after marker self.assertEqual(console(warp_test, "s2b 1"), 10) self.assertEqual(console(warp_test, "b2s 10"), 1) # before marker self.assertEqual(console(warp_test, "s2b -1"), -10) self.assertEqual(console(warp_test, "b2s -10"), -1) # on marker self.assertEqual(console(warp_test, "s2b 0"), 0) self.assertEqual(console(warp_test, "b2s 0"), 0)
def assert_accepts_end_tempo(self): """Checks if the console accepts end_tempo command""" self.assertEqual(console(self.test, "end_tempo 10.0"), None) self.assertEqual(self.test.end_tempo, 10)
def assert_expected_b2s_inbetween_the_two_markers(self): """Checks if the beats to second funciton works properly inbetween two markers""" self.assertEqual(console(self.test, "b2s 0.5"), 2.5)
def assert_console_accepts_s2b(self): """Checks if the console accepts the s2b command""" self.assertFalse( isinstance(type(console(self.test, "s2b 2.5")), type(None)))
def assert_console_accepts_b2s(self): """Checks if the console accepts the b2s command""" self.assertFalse( isinstance(type(console(self.test, "b2s 0.5")), type(None)))
def check_if_solution_is_optimal(self): """ Verifies that the optimal solutions is employed with complexity O(log(n)). The whole function must run at no less than 1000 standard units; A standard unit is defined as the time it takes for a general sorting function to sort 1,000 times; which, is only possible if the ideal O(log(n)) solution is used in all steps. """ import timeit import math import statistics as stats import time avg_log = [] test_ns = [2**i for i in range(4, 12)] start = time.time() for n in test_ns: test_warp = Warp() avg_exc = 0 avg_exc_ref = 0 for marker in range(1, n): console( test_warp, "marker " + str(float(marker)) + ' ' + str(float(marker))) repeats = 25 for _ in range(repeats): execution = timeit.timeit(lambda: [ console(test_warp, 'b2s ' + str(n - 0.1)), console(test_warp, 's2b ' + str(n // 2 - 0.1)) ], number=400) avg_exc += execution / repeats execution = timeit.timeit( lambda: [ord(x) for x in "aasdfadgasdfwr22"], number=1000) avg_exc_ref += execution / repeats avg_log.append(avg_exc / avg_exc_ref) print("(raw time, for 400 requests, and n-markers = %d)" " mean: %f, theoretical frequency: %f" % (n, avg_exc, 2 * 400 / avg_exc)) # 2 * because s2b and b2s in conjunction time_elapsed = time.time() - start exc_ref = sum( timeit.repeat(lambda: [ord(x) for x in "aasdfadgasdfwr22"], repeat=25, number=1000)) / 25 time_elapsed_normalized = time_elapsed / exc_ref self.assertTrue(time_elapsed < 1000) avg_log = [ math.log2(avg_log[i + 1] / avg_log[i]) for i in range(len(avg_log) - 1) ] print("(logarithm) mean: %f, std: %f, adjusted mean: %f" % (stats.mean(avg_log), stats.stdev(avg_log), stats.mean(avg_log) + 2 * stats.stdev(avg_log))) self.assertTrue(stats.mean(avg_log) < 0.15) # O(log(n))
def assert_s2b_b2s_act_properly_after_third_marker_introduced(self): r""" Checks that if a third marker is introduce inbetween the two prior defined markers that the funciton behvaiors are maintained (NEW / ADDED) v i.e. 0 0.5 1.0 beat line -----*---------*-----------*--------> (before all region) | section \ section \ (after all region) | A \ B \ time line ------*------------*-----------*-----> 0 4 5 """ console(self.test, "marker 0.5 4") # this change will add the marker shown in the docstring. # Pracitcally, this change should alter the value of the tempo # before all markers, add an internal section for the, and not # impact the final section # check section A self.assertEqual(console(self.test, "s2b 2"), 0.25) self.assertEqual(console(self.test, "b2s 0.25"), 2) # check section B self.assertEqual(console(self.test, "s2b 4.5"), 0.75) self.assertEqual(console(self.test, "b2s 0.75"), 4.5) # check before all region self.assertEqual(console(self.test, "s2b -2"), -0.25) self.assertEqual(console(self.test, "b2s -0.25"), -2) # check final region self.assertEqual(console(self.test, "s2b 6"), 11) self.assertEqual(console(self.test, "b2s 11"), 6) # check if call is on marker functionality self.assertEqual(console(self.test, "b2s 0.5"), 4) self.assertEqual(console(self.test, "s2b 4"), 0.5)
def assert_expected_s2b_and_b2s_after_all_2markers(self): """Checks if the s2b and b2s work properly after the markers (i.e. end_tempo)""" self.assertEqual(console(self.test, "s2b 6"), 11) self.assertEqual(console(self.test, "b2s 11"), 6)
def assert_expected_s2b_and_b2s_before_the_2markers(self): """Checks if the b2s and s2b functions work properly before the set of markers""" self.assertEqual(console(self.test, "b2s -0.5"), -2.5) self.assertEqual(console(self.test, "s2b -2.5"), -0.5)
parser.add_argument("-ps", action="store", type=int, default=None, help="pivot steps") parser.add_argument("--gn", action="store", type=str, default=None) parser.add_argument("--dn", action="store", type=str, default=None) parser.add_argument("--gangn", action="store", type=str, default=None) parser.add_argument("--gandn", action="store", type=str, default=None) limit = parser.parse_args().l num_val = parser.parse_args().v model_index = parser.parse_args().i gn_fp = parser.parse_args().gn dn_fp = parser.parse_args().dn gan_gn_fp = parser.parse_args().gangn gan_dn_fp = parser.parse_args().gandn LR = parser.parse_args().lr if parser.parse_args().lr else LR BATCHSIZE = parser.parse_args().bs if parser.parse_args().bs else BATCHSIZE PIVOT_STEPS = parser.parse_args().ps if parser.parse_args( ).ps else PIVOT_STEPS ### Load Data console("Load Data") data_loader, x_eval_train = data_loader(limit) ### Train Data console("Train Data") train(data_loader, model_index, x_eval_train, gn_fp, dn_fp, gan_gn_fp, gan_dn_fp)
def assert_console_accepts_markers(self): """Checks if the console accepts the marker command""" self.assertEqual(console(self.test, "marker 0.0 0.0"), None) self.assertEqual(console(self.test, "marker 1.0 5.0"), None)
parser.add_argument("--load", action="store", type=str, help="file path of loaded model") parser.add_argument("--version", action="store", type=int, default=0, help="version of model") limit = parser.parse_args().l valid_limit = parser.parse_args().v model_index = parser.parse_args().i load_model_fp = parser.parse_args().load cpu = parser.parse_args().cpu model_version = parser.parse_args().version LR = parser.parse_args().lr if parser.parse_args().lr else LR BATCHSIZE = parser.parse_args().bs if parser.parse_args().bs else BATCHSIZE EPOCH = parser.parse_args().e if parser.parse_args().e else EPOCH ### Building Model console("Building Model") if load_model_fp : model = tor.load(load_model_fp) else : Model = model_versions[model_version] if model_version == 0 else model_versions[model_version - 1] model = Model( input_size=INPUT_SIZE, hidden_size=HIDDEN_SIZE, ) if not cpu : model.cuda() ### Train Data console("Training Model")
def assert_expected_s2b_inbetween_the_two_markers(self): """Checks if the seconds to beats function works properly inbetween two markers""" self.assertEqual(console(self.test, "s2b 2.5"), 0.5)