def findAvgs(npEmpArr):
import time
st=time.process_time_ns()
avg,height=np.average(npEmpArr['age']),np.average(npEmpArr['age'])
et=time.process_time_ns()
print("Numpy time:{}".format(et-st))
return et-st
def helper(data):
"""
if self.lang=="python":
tracemalloc.start()
start = time.process_time_ns()
self.func(*data)
current, peak = tracemalloc.get_traced_memory()
end = time.process_time_ns()
tracemalloc.stop()
return end-start, peak
else:
params=param_gen.signature(self.func)
l=[] #list of parameters
for k in params:
config=params[k].annotation
l.append(config)
return cpp_executor.execute(self.func_str,self.func.__name__,l,data)
"""
tracemalloc.start()
start = time.process_time_ns()
self.func(*data)
current, peak = tracemalloc.get_traced_memory()
end = time.process_time_ns()
tracemalloc.stop()
return end - start, peak
def readInt(self, regName):
"""
reads a single register in the Trinamic chip. Records the status in self.status
Note: if you want to read multiple registers, use readWriteMultiple.
regName: Either the name of a register present in the register definition dictionary or an integer in the range 0 - 127
returns the integer value of the register.
"""
if self.SPIlog:
cstart=time.perf_counter_ns()
cpustart=time.process_time_ns()
regint, regdef = self._checkRegName(regName, 'R')
ba = bytes([regint
, 0, 0, 0, 0])
self.pigp.spi_write(self.spidev, ba)
bblen, bytesback = self.pigp.spi_xfer(self.spidev, ba)
if self.SPIrawlog:
self.SPIrawlog.debug('SPI_WRITE: ' + ':'.join("{:02x}".format(c) for c in ba))
self.SPIrawlog.debug('SPI_XFER : ' + ':'.join("{:02x}".format(c) for c in ba) + ' returned ' + ':'.join("{:02x}".format(c) for c in bytesback))
assert bblen==5
if 'readconv' in regdef:
resint=regdef['readconv'](bytesback)
else:
resint=(bytesback[1]<<24)+(bytesback[2]<<16)+(bytesback[3]<<8)+bytesback[4]
self.status=bytesback[0]
if self.SPIlog:
clockns=time.perf_counter_ns()-cstart
cpuratio=(time.process_time_ns()-cpustart)/clockns*100
self.SPIlog.log(self.loglvl," READ {regname:10s}: {resint:9d} ({resint:08x}) status: {stat:02x} {clockus:6.1f}uS {cpu:4.1f}%CPU".format(
stat=bytesback[0], regname=str(regName), clockus=clockns/1000, cpu=cpuratio))
return resint
def doubling_flow_values_const_node_edges(nodes, edges, min_cap, max_cap,
iterations):
tab_array = []
for i in range(iterations):
array_graph = flow_utilities.generate_flow_network_given_links(
nodes, edges, min_cap, max_cap)
graph = FlowNetwork.Graph(array_graph)
source = 0
sink = nodes - 1
start_time = time.process_time_ns()
res = graph.FordFulkerson(source, sink)
time_elapsed = time.process_time_ns() - start_time
time_elapsed = time_elapsed / (10**6)
if (time_elapsed != 0 and i > 0):
if (tab_array[i - 1][3] != 0):
ratio = time_elapsed / tab_array[i - 1][3]
lg_ratio = math.log2(ratio)
else:
ratio = "-"
lg_ratio = "-"
tab_array.append([nodes, edges, res[0], time_elapsed, ratio, lg_ratio])
min_cap = min_cap * 20
max_cap = max_cap * 20
print(
tabulate(
tab_array,
["Nodes", "edges", "max flow", " time(ms)", "ratio", "log2 ratio"],
tablefmt="plain"))
def analyse_multiple_datasets(num_datasets):
tab_array = []
result_array = []
edges_array = []
for i in range(num_datasets):
f = open("dataset-" + str(i), "r")
num_links = f.readline()
enc_flow_array = f.readline()
flow_network = json.loads(enc_flow_array)
f.close()
flow_network_graph = FlowNetwork.Graph(flow_network)
start_time = time.process_time_ns()
result = flow_network_graph.FordFulkerson(0, len(flow_network) - 1)
time_elapsed = time.process_time_ns() - start_time
time_elapsed_ms = time_elapsed / (10**6)
edges_array.append(int(num_links))
result_array.append(time_elapsed_ms)
if (time_elapsed != 0):
if (tab_array[i - 1][3] != 0):
ratio = time_elapsed / tab_array[i - 1][3]
else:
ratio = "-"
tab_array.append(("dataset-" + str(i), num_links, result[0],
time_elapsed_ms, ratio))
plt.plot(edges_array, result_array)
plt.show()
print(
tabulate(tab_array,
["dataset ", "edges", "max flow", "time taken(ms)", "ratio"],
tablefmt="plain"))
def get_pred(classifier, text, length, batch_size=100,
sent_dict={"LABEL_0":-1, "LABEL_1":0, "LABEL_2":1}):
res = np.zeros((length,2))
cur_row = 0
loading = 0
t_start = time.process_time_ns()
print(f"Row: {cur_row}. Progress: {loading}/100")
for row in range(0,length,batch_size):
output = classifier(list(text[row:min(length,row+batch_size)]))
for i,elem in enumerate(output):
senti = sent_dict[elem["label"]]
score = elem["score"]
cur_row = row + i
res[cur_row] = [senti, score]
if round(cur_row/length*100,0) > loading:
loading = round(cur_row/length*100,0)
t_stop = time.process_time_ns()
elapsed_time = t_stop - t_start
time_left = ((100-loading) * elapsed_time)*1e-9
mins = round(time_left/60, 0)
secs = round(time_left%60, 0)
print(f"Row: {cur_row}. Progress: {loading}/100. \
Time left: {mins} mins {secs} secs")
t_start = time.process_time_ns()
print("Processing complete!")
return res
def simulate(algName, algPath, funcname, funcpath, heuris_args, initpoint):
# loading the heuristic object into the namespace and memory
spec = importlib.util.spec_from_file_location(algName, algPath)
heuristic = importlib.util.module_from_spec(spec)
spec.loader.exec_module(heuristic)
# loading the test function object into the namespace and memory
testspec = importlib.util.spec_from_file_location(funcname, funcpath)
func = importlib.util.module_from_spec(testspec)
testspec.loader.exec_module(func)
# defining a countable test function
@counter
def testfunc(args):
return func.main(args)
# using a try statement to handle potential exceptions raised by child processes like the algorithm or test functions or the pooling algorithm
try:
#This timer calculates directly the CPU time of the process (Nanoseconds)
tic = time.process_time_ns()
# running the test by calling the heuritic script with the test function as argument
quality = heuristic.main(testfunc, initpoint, heuris_args)
toc = time.process_time_ns()
# ^^ The timer ends right above this; the CPU time is then calculated below by simple difference ^^
# CPU time in seconds
cpuTime = (toc - tic) * (10**-9)
numCalls = testfunc.count
converged = 1
except:
quality = NaN
cpuTime = NaN
numCalls = testfunc.count
converged = 0
return cpuTime, quality, numCalls, converged
def on_post(self, req, resp):
"""Handles POST requests"""
resp.set_header('Access-Control-Allow-Origin', '*')
resp.set_header('Access-Control-Allow-Methods', '*')
resp.set_header('Access-Control-Allow-Headers', '*')
resp.set_header('Access-Control-Allow-Credentials', 'true')
resp.set_header("Cache-Control", "no-cache")
start = time.process_time_ns()
# input_file = req.get_param('file')
# if input_file.filename:
# bin = input_file.file.read()
# print(bin)
data = req.stream.read(req.content_length)
filename = "data/{}.png".format(time.time())
open(filename, 'wb').write(data)
img = cv2.imread(filename)
print(img)
# jsondata = json.loads(data)
# clean_title = shortenlines(jsondata['1'])
# clean_content = cleanall(jsondata['2'])
# resp.media = self.bert_classification(clean_title, clean_content)
logger.info("tot:{}ns".format(time.process_time_ns() - start))
logger.info("###")
def trial_division_improved(n):
t = time.process_time_ns()
p_list = []
it_count = 0
while (n % 2 == 0):
p_list.append(2)
n /= 2
it_count += 1
p = Decimal(3)
while (p * p <= n):
while (n % p == 0):
p_list.append(p)
n /= p
p += 2
it_count += 1
if (n != 1):
p_list.append(n)
if (len(p_list) > 2):
print("AAAAAA")
return int(p_list[0]), int(p_list[1]), it_count, time.process_time_ns() - t
def nn_model(trainx, trainy, valx, valy, bt_size, epochs, layers):
model = Sequential()
model.add(
Dense(layers[0], activation='relu', input_shape=(trainx.shape[1], )))
for l in layers[1:]:
model.add(Dense(l, activation='relu'))
model.add(Dropout(0.30))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy', f1_m, precision_m, recall_m])
#model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
hist = model.fit(trainx,
trainy,
batch_size=bt_size,
epochs=epochs,
shuffle=True,
validation_data=(valx, valy),
verbose=True)
model.save('dnn.h5')
loss, accuracy, f1_score, precision, recall = model.evaluate(valx,
valy,
verbose=0)
start = time.process_time_ns()
res = model.predict(valx)
print("model evaluation time in clock",
(time.process_time_ns() - start) / valx.shape[0], "ns for ",
valx.shape[0], valx.shape[1], "test data in average")
print("loss", loss, "accuracy", accuracy * 100, "f1_score", f1_score,
"precision", precision, "recall", recall)
return hist
def main() -> int:
args = parser.parse_args()
if args.mode == 'auto':
args.mode = 'run'
source = args.script.read()
try:
filename = args.script.name
except Exception:
filename = '<unknown>'
tree = parse(source, filename)
if args.mode == 'dump':
print(ast.dump(tree, indent=3, include_attributes=True))
elif args.mode == 'run':
compiled = compile(tree, filename, 'exec')
_run_code(compiled, {
'__builtins__': builtins
}, mod_name='__main__', script_name=filename)
elif args.mode == 'py':
print(ast.unparse(tree))
elif args.mode == 'compile_only':
error: None
start = time.process_time_ns()
try:
compile(tree, filename, 'exec')
except SyntaxError as e:
error = e
end = time.process_time_ns()
if error is None:
print(f'Successfully compiled "{filename}" (AST had {count_nodes(tree)} nodes) in {end - start}ns.')
else:
print(f'Failed to compile "{filename}" (AST had {count_nodes(tree)} nodes) in {end - start}ns.')
import traceback
traceback.print_exception(SyntaxError, error, error.__traceback__, 0)
return 1
def test(state, kindOfTime:str):
if kindOfTime == "p":
start = time.process_time_ns()
elif kindOfTime == "r":
start = time.time()
else:
raise Exception("Wrong Format")
threads = [ChangerThread(state) for i in range(1,18)]
for t in threads:
t.start()
for t in threads:
t.join()
took =0
if kindOfTime == "p":
took = (time.process_time_ns() - start)/1000000
elif kindOfTime == "r":
took = (time.time() - start)/1000000
else:
raise Exception("Wrong Format")
return took
def revisions(self, path: Union[str, os.PathLike]) -> int:
"""Count revisions of a file
This function can also take deleted paths into account while _find returns only undeleted paths.
:returns: number of revisions
:throws: DecentFsFileNotFound if not found
"""
logging.debug('Searching for %s', path)
revisions = 0
seq = 0
timer = time.process_time_ns()
for entry in self.metafeed:
# skip special block
if seq == 0:
seq += 1
continue
findpath, flags, timestamp, size, _ = cbor2.loads(entry.content())
if findpath == path.__str__():
timer = time.process_time_ns() - timer
logging.info('Found with flags %s from %i with %i bytes',
flags, timestamp, size)
logging.debug('Found at %i within %i ms', seq, timer / 1000000)
revisions += 1
seq += 1
if revisions == 0:
raise DecentFsFileNotFound('File {} not found'.format(
path.__str__()))
return revisions
def _glob(self, glob: Union[str, os.PathLike]) -> list:
"""List files matich a glob pattern
:returns: list of matching paths
:throws: DecentFsFileNotFound if not found
"""
logging.debug('Searching for %s', glob)
seq = 0
timer = time.process_time_ns()
matchs = set()
for entry in self.metafeed:
# skip special block
if seq == 0:
seq += 1
continue
findpath, flags, _, _, _ = cbor2.loads(entry.content())
logging.debug('Found %s with flags %s', findpath, flags)
if pathlib.PurePosixPath(findpath).match(glob.__str__()):
timer = time.process_time_ns() - timer
logging.debug('Got a match at %i with flags %s within %i ms',
seq, flags, timer / 1000000)
if flags == 'R':
matchs.remove(findpath)
else:
matchs.add(findpath)
seq += 1
if len(matchs) == 0:
raise DecentFsFileNotFound('File {} not found'.format(
glob.__str__()))
return matchs
def test_filereader_book1xlsx():
path = Path(__file__).parent / "data" / 'book1.xlsx'
assert path.exists()
start = process_time_ns()
tables = list(file_reader(path))
end = process_time_ns()
fields = sum(len(t) * len(t.columns) for t in tables)
print("{:,} fields/seccond".format(
round(1e9 * fields / max(1, end - start), 0)))
sheet1 = Table(filename=path.name, sheet_name='Sheet1')
for column_name in list('abcdef'):
sheet1.add_column(column_name, int, False)
sheet2 = Table(
filename=path.name,
sheet_name='Sheet2 ') # there's a deliberate white space at the end!
sheet2.add_column('a', int, False)
for column_name in list('bcdef'):
sheet2.add_column(column_name, float, False)
books = [sheet1, sheet2]
for book, table in zip(books, tables):
table.show(slice(5))
assert table.compare(book)
assert len(table) == 45, len(table)
def _updater(self):
last_update = None
try:
updates = methods.get_updates(self.token, self.offset, 120)
for update in updates:
last_update = update
t = time.process_time_ns()
self._update_elaborator(update)
elapsed_time = (time.process_time_ns() - t) / 1_000_000
if elapsed_time > 50:
log.w(f"Update #{update['update_id']} elaboration "
f"took {elapsed_time} ms")
last_update = None
except Unauthorized:
log.e(f"Unauthorized bot {self.bot_id}, detaching...")
lotus_interface.detach_bot(self.token)
except Conflict:
log.e(
f"Telegram said that bot {self.bot_id} is already running, detaching..."
)
lotus_interface.detach_bot(self.token)
except requests.ConnectionError:
log.e(
f"A connection error happened, waiting {_connection_retry_time} seconds before reconnecting"
)
time.sleep(_connection_retry_time)
except BadRequest as e:
log.w(f"Warning, telegram said: {e.message}")
except Exception as e:
log.e('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
type(e).__name__, e)
traceback.print_tb(e.__traceback__)
if last_update:
pprint(last_update)
def readInt(self, regName):
"""
immediately reads a single register in the Trinamic chip. Records the status in SHORTSTAT register
Note: if you want to read multiple registers, use readWriteMultiple.
regName: Either the name of a register present in the register definition dictionary or an integer in the range 0 - 127
returns the integer value of the register.
"""
if self.SPIlog:
cstart=time.perf_counter_ns()
cpustart=time.process_time_ns()
ba=[0]*5
rrr=self['chipregs/'+regName]
rrr.readBytes(ba)
self.pigp.spi_write(self.spidev, ba)
bblen, bytesback = self.pigp.spi_xfer(self.spidev, ba)
assert bblen==5
if self.SPIrawlog:
self.SPIrawlog.debug('SPI_WRITE: ' + ':'.join("{:02x}".format(c) for c in ba))
self.SPIrawlog.debug('SPI_XFER : ' + ':'.join("{:02x}".format(c) for c in ba) + ' returned ' + ':'.join("{:02x}".format(c) for c in bytesback))
rrr.loadBytes(bytesback)
resint=rrr.curval
self['chipregs/SHORTSTAT'].loadByte(bytesback[0])
if self.SPIlog:
clockns=time.perf_counter_ns()-cstart
cpuratio=(time.process_time_ns()-cpustart)/clockns*100
self.SPIlog.log(self.loglvl," READ {regname:10s}: {resint:9d} ({resint:08x}) status: {stat:02x} {clockus:6.1f}uS {cpu:4.1f}%CPU".format(
stat=bytesback[0], regname=str(regName), resint=resint, clockus=clockns/1000, cpu=cpuratio))
return resint
def run_timed_test(test, counter, loop_count = 1, maximum_time = -1.0):
Logs.debug("\trunning test", test.__name__)
counter.total += 1
timed = True
try:
start_time = time.process_time_ns()
except AttributeError:
Logs.debug("No timer module. Defaulting to untimed test")
timed = False
maximum_time = -1
try:
if (timed):
for _ in range(loop_count):
test()
result_time = (time.process_time_ns() - start_time) / 1000000000.0
Logs.debug("\texecuted in", result_time, "seconds.", result_time/loop_count, "seconds per test.", "Reference time:", maximum_time, "seconds")
else:
test()
except Exception as e:
Logs.error("\ttest failed.")
Logs.error(e)
else:
if maximum_time >= 0.0 and result_time > maximum_time:
Logs.error("\ttest successful but too slow")
else:
counter.passed += 1
def writeInt(self, regName, regValue):
"""
Writes to a single register in the Trinamic chip
regName: Either the name of a register present in the register definition dictionary or an integer in the range 0 - 127
regValue: a value interpreted as a simple 32 bit integer that will be written to the chip.
"""
if self.SPIlog:
cstart=time.perf_counter_ns()
cpustart=time.process_time_ns()
regint, _ = self._checkRegName(regName, 'W')
valueint=regValue
ba = bytes([regint|128
, (valueint>>24) & 255
, (valueint>>16) & 255
, (valueint>>8) & 255
, valueint & 255])
self.pigp.spi_write(self.spidev, ba)
self.lastwritten[regName]=regValue
if self.SPIrawlog:
self.SPIrawlog.debug('SPI_WRITE: ' + ':'.join("{:02x}".format(c) for c in ba))
if self.SPIlog:
clockns=time.perf_counter_ns()-cstart
cpuratio=(time.process_time_ns()-cpustart)/clockns*100
self.SPIlog.debug("WRITE" + " {regname:10s}: {regval:9d} ({regval:08x}) {clockus:6.1f}uS {cpu:4.1f}%CPU".format(
regname=str(regName), regval=valueint, clockus=clockns/1000, cpu=cpuratio,))
def test_model(train_set,
test_set,
model,
filename=None,
prefix="test",
epochs=300):
""":key
"""
training = model.build_slice_set(train_set)
print("debug - start training " + prefix)
tmr = time.process_time_ns()
model.train(training, training, epochs)
train_time = time.process_time_ns() - tmr
print("debug - start testing")
true_map = LTMap.LiteTuxMap(1, 1)
for lvlfile in test_set:
s = prefix + "," + str(train_time) + "," + lvlfile + "," + str(
epochs) + ","
lvl_chunks = model.build_slice_set([lvlfile], True)
true_map.load(lvlfile)
predicted_map = LTMap.LiteTuxMap(true_map.width, true_map.height)
for i in range(lvl_chunks.shape[0]):
slc = model.predict(lvl_chunks[i])
model.decode_slice(slc[0], predicted_map, i * model.cols)
print(predicted_map.to_vertical_string())
test = MapTest(true_map, predicted_map)
s += str(test.get_total_tile_errors()) + ","
s += str(test.get_average_tile_hamming_error()) + ","
s += str(test.get_average_distance_error()) + ","
print(s)
if filename is not None:
with open(filename, "a") as f:
f.write(s)
f.write("\n")
def time_execution(DATASET):
# pro asserty
time1 = []
time2 = []
for _ in range(0, 4):
start_time1 = time.process_time_ns()
tree1 = alternative_kruskal(load_dataset(DATASET))
time1.append(time.process_time_ns() - start_time1)
start_time2 = time.process_time_ns()
tree2 = og_kruskal(load_dataset(DATASET))
time2.append(time.process_time_ns() - start_time2)
print("Asserting minimum spanning trees...")
assert (len(tree1) == len(tree2))
assert (count_minimum_spanning_tree_weight(tree1) ==
count_minimum_spanning_tree_weight(tree2))
assert (find_vertices_in_tree(tree1) == find_vertices_in_tree(tree2))
print("Assert passed. Executing...\n")
print("Time of execution of my kruskal implementation on the dataset '{}'".
format(DATASET))
print(str((sum(time1) / len(time1)) / 1000000000.0) + " s")
print(
"-----------------------------------------------------------------------"
)
print("Timing of the original kruskal implementation on the dataset {}".
format(DATASET))
print(str((sum(time2) / len(time2)) / 1000000000.0) + " s")
print("\n")
def execute_this(code_to_execute):
# I was tired of importing time and then making a start variable, calling the execution time function, I just wrote this
clear_output_screen()
print(f"Running {code_to_execute.__name__}\n")
start = process_time_ns()
code_to_execute()
execution_time(process_time_ns()-start)
def measure_time(strings: list) -> float:
print("measuring")
start = time.process_time_ns()
for num in strings:
hashlib.sha1(num.encode()).hexdigest()
end = time.process_time_ns() - start
return end
def test_model(data_size, model_name, outfile, mode):
print("Testing model ")
f = open(outfile, mode)
outstring = ""
model = load_model(model_name)
data_test = generate_data(data_size)
outstring += "Count on {} | Count off {} Percent on {} % \n".format(
data_test["count_on"], data_test["count_off"], data_test["percent_on"])
time_count = time.process_time_ns()
t = model.predict(data_test["data"][0], verbose=0)
time_count = time.process_time_ns() - time_count
outstring += "Predict time {} = {}s\n".format(time_count,
time_count / 1000000000)
count_miss = 0
missed = []
for i in range(len(t)):
pred_val = 0 if t[i][0] < 0.5 else 1
#print("{} {}".format(x_test[i],pred_val))
if pred_val != data_test["data"][1][i]:
count_miss = (count_miss + 1)
missed.append([data_test["data"][0][i], pred_val])
outstring += "Wrong {} true_val {} != {} predict\n".format(
data_test["data"][0][i], data_test["data"][1][i], t[i])
outstring += "Missed {} in {} = {}% \n".format(count_miss, len(t),
count_miss / len(t) * 100)
f.write(outstring)
f.close()
print("Finished testing model ")
def wrapper(*args, **kwargs):
start = time.process_time_ns()
result = func(*args, **kwargs)
end = time.process_time_ns()
print(
f'{func.__qualname__}({args}, {kwargs}) Elapsed: {(end-start)/10**6} ms'
)
return result
def testIsSubsequence():
start = process_time_ns()
for test in tests:
print(runTest(tests[test][0], tests[test][1], test))
end = process_time_ns()
print("Time elapsed:", end - start, "ns")
def test_process_time_ns(self):
import time
t1 = time.process_time_ns()
assert isinstance(t1, int)
time.sleep(0.1)
t2 = time.process_time_ns()
# process_time_ns() should not include time spent during sleep
assert (t2 - t1) < 5 * 10**7
assert abs(time.process_time() - time.process_time_ns() * 1e-9) < 0.1
def add_movies(self):
index = 0
for titles in self.movie_collection:
if index == 0: # Skips extraneous data in first entry.
time.process_time_ns()
else:
self.movies.append(titles.text)
index += 1
def test_compress_action(state, action, n_colors):
state_len = len(state)
power_list = [n_colors**i for i in range(state_len)]
x = compress_state(state, n_colors)
# print(decompress_state(x, n_colors, state_len))
start = time.process_time_ns()
x = perform_compressed_action(x, action, power_list, n_colors)
end = time.process_time_ns()
return decompress_state(x, n_colors, state_len), end - start
def testSortedSquareArray():
start = process_time_ns()
if (sortedSquaredArray([1, 2, 3, 5, 6, 8, 9]) == [1, 4, 9, 25, 36, 64,
81]):
print(True)
else:
print(f"returned {sortedSquaredArray([1, 2, 3, 5, 6, 8, 9])}")
print("expected [1, 4, 9, 25, 36, 64,81]")
if (sortedSquaredArray([1]) == [1]):
print(True)
else:
print(f"returned {sortedSquaredArray([1])}")
print("expected [1]")
if (sortedSquaredArray([1, 4]) == [1, 16]):
print(True)
else:
print(f"returned {sortedSquaredArray([1, 4])}")
print("expected [1, 16]")
# if(sortedSquaredArray([1, 4]) == [1, 16]):
# print(True)
# else:
# print(f"returned {sortedSquaredArray([1, 4])}")
# print("expected [1, 16]")
# print(sortedSquaredArray([1, 2, 3, 4, 5]))
# -> [1, 4, 9, 16, 25]
# print(sortedSquaredArray([0]))
# -> [0]
# print(sortedSquaredArray([100]))
# -> [100]
# print(sortedSquaredArray([-1]))
# -> [1]
# print(sortedSquaredArray([-1, -4]))
# -> [1, 4]
# print(sortedSquaredArray([-5, -4, -3, -2, -1]))
# -> [1, 4, 9, 16, 25]
# print(sortedSquaredArray([-10]))
# -> [100]
# print(sortedSquaredArray([-10, -5, 0, 5, 10]))
# -> [0, 25, 25, 100, 100]
# print(sortedSquaredArray([-7, -3, 1, 9, 22, 30]))
# -> [1, 9, 49, 81, 484, 900]
# print(sortedSquaredArray([-50, -13, -2, -1, 0, 0, 1, 1, 2, 3, 19, 20]))
# -> [0, 0, 1, 1, 1, 4, 4, 9, 169, 361, 400, 2500]
# print(sortedSquaredArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
# -> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
# print(sortedSquaredArray([-1, -1, 2, 3, 3, 3, 4]))
# -> [1, 1, 4, 9, 9, 9, 16]
# print(sortedSquaredArray([-3, -2, -1]))
# -> [1, 4, 9]
end = process_time_ns()
print("Time elapsed:", end - start, "ns")
def test_time_ns_type(self):
def check_ns(sec, ns):
self.assertIsInstance(ns, int)
sec_ns = int(sec * 1e9)
# tolerate a difference of 50 ms
self.assertLess((sec_ns - ns), 50 ** 6, (sec, ns))
check_ns(time.time(),
time.time_ns())
check_ns(time.monotonic(),
time.monotonic_ns())
check_ns(time.perf_counter(),
time.perf_counter_ns())
check_ns(time.process_time(),
time.process_time_ns())
if hasattr(time, 'clock_gettime'):
check_ns(time.clock_gettime(time.CLOCK_REALTIME),
time.clock_gettime_ns(time.CLOCK_REALTIME))
