def test():
kernels = [lambda a: numpy.c_[a, a]]
r = [2**k for k in range(4)]
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
)
out.show()
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=True,
logy=False,
)
out.show()
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=False,
logy=True,
)
out.show()
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=True,
logy=True,
)
out.show()
return
def test2():
out = perfplot.bench(
setup=np.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
)
print(out)
def test_no_labels():
def mytest(a):
return numpy.c_[a, a]
kernels = [mytest]
r = [2**k for k in range(4)]
out = perfplot.bench(setup=numpy.random.rand,
kernels=kernels,
n_range=r,
xlabel="len(a)")
out.show()
return
def test_save():
def mytest(a):
return numpy.c_[a, a]
kernels = [mytest]
r = [2**k for k in range(4)]
out = perfplot.bench(setup=numpy.random.rand,
kernels=kernels,
n_range=r,
xlabel='len(a)',
title='mytest')
out.save('out.png')
return
def test_save():
def mytest(a):
return numpy.c_[a, a]
kernels = [mytest]
r = [2**k for k in range(4)]
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
n_range=r,
xlabel="len(a)",
title="mytest",
)
out.save("out.png")
return
def test():
perfplot.show(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
)
perfplot.show(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=True,
logy=False,
)
out = perfplot.bench(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=False,
logy=True,
)
print(out)
perfplot.show(
setup=numpy.random.rand,
kernels=kernels,
labels=["c_"],
n_range=r,
xlabel="len(a)",
logx=True,
logy=True,
)
return
def get_graph_for_n(n: int) -> Graph:
G = Graph(n)
for v in range(n):
# connect each vertices to three other random vertices
G.add_edge(v, randint(0, n - 1))
G.add_edge(v, randint(0, n - 1))
G.add_edge(v, randint(0, n - 1))
return G
if __name__ == '__main__':
output = perfplot.bench(setup=lambda n: get_graph_for_n(n),
kernels=[
lambda G: GraphSearch(G, 0, 'bfs'),
lambda G: GraphSearch(G, 0, 'dfs_recursive'),
lambda G: GraphSearch(G, 0, 'dfs_iterative'),
],
labels=[
'Breadth-first', 'Depth-first (recursive)',
'Depth-first (iterative)'
],
xlabel="Graph with N vertices, randomly connected",
title='Searching a graph',
n_range=range(10, SAMPLE_SIZE),
equality_check=None)
output.save(f'output/graph-search_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
import perfplot
from src.implementations.dynamic_programming.fibonacci import (
fibonacci_recursive, fibonacci_memoized, fibonacci_bottom_up,
fibonacci_bottom_up_minified)
from src.perf_plots.config import SAMPLE_SIZES
SAMPLE_SIZE = SAMPLE_SIZES['FIBONACCI']
if __name__ == '__main__':
output = perfplot.bench(
setup=lambda n: n,
kernels=[
lambda n: fibonacci_recursive(n),
lambda n: fibonacci_memoized(n, {}),
lambda n: fibonacci_bottom_up(n, {}),
lambda n: fibonacci_bottom_up_minified(n)
],
labels=['recursive', 'memoized', 'bottom_up', 'bottom_up_minified'],
xlabel="n'th Fibonacci number",
title='Calculating the n\'th Fibonacci number',
n_range=range(1, SAMPLE_SIZE),
equality_check=None)
output.save(f'output/fibonacci_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
def search_for_integer_in_symbol_table(symbol_table, n):
try:
symbol_table.get(n)
except:
symbol_table.contains(n)
if __name__ == '__main__':
output = perfplot.bench(
setup=lambda n: get_symbol_tables(n),
kernels=[
lambda ST: search_for_integer_in_symbol_table(
ST['HM_CHAINING'], 1),
lambda ST: search_for_integer_in_symbol_table(ST['HS_PROBING'], 1),
lambda ST: search_for_integer_in_symbol_table(ST['BST'], 1),
lambda ST: search_for_integer_in_symbol_table(ST['RBT'], 1)
],
labels=[
'HashMap with separate chaining', 'HashSet with linear probing',
'Binary Search Tree', 'Red-Black Tree'
],
xlabel="Searching for one integer in a collection of N integers",
title='Integer search',
n_range=range(1, SAMPLE_SIZE),
equality_check=None)
output.save(f'output/searching-integers_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
from matplotlib import pyplot as plt
from kdenumba import KDE_Numba
plt.figure(figsize=(6, 5))
for ii in range(1, 5):
def pdf_scipy(x):
smpl = np.random.gumbel(0, 0.1, 10**ii)
weights = np.ones(smpl.shape)
return stats.gaussian_kde(smpl, weights=weights)(x)
def pdf_numba(x):
smpl = np.random.gumbel(0, 0.1, 10**ii)
weights = np.ones(smpl.shape)
return KDE_Numba(smpl, weights=weights)(x)
plt.subplot(2, 2, ii)
out = perfplot.bench(setup=np.random.rand,
n_range=[10**k for k in range(1, 7)],
kernels=[pdf_numba, pdf_scipy],
xlabel='Length of x',
labels=['Numba', 'Scipy'],
title='Number of samples: $10^' + str(ii) + '$',
equality_check=None)
out.plot()
plt.tight_layout()
plt.savefig('perf.svg')
plt.show()
# import tikzplotlib
rng = np.random.default_rng(1)
osa = colorio.cs.OsaUcs()
cielab = colorio.cs.CIELAB()
# cam16 = colorio.CAM16(0.69, 20, L_A=64 / np.pi / 5)
ciecam02 = colorio.cs.CIECAM02(0.69, 20, L_A=64 / np.pi / 5)
b = perfplot.bench(
# Don't use np.random.rand(3, n) to avoid the CIECAM breakdown
setup=lambda n: np.outer(rng.random(3) * 10, np.ones(n)),
equality_check=None,
kernels=[
osa.to_xyz100,
cielab.to_xyz100,
# cam16.to_xyz100,
lambda Jsh: ciecam02.to_xyz100(Jsh, "Jsh"),
np.cbrt,
],
labels=["OSA-UCS", "CIELAB", "CIECAM02", "cbrt"],
n_range=[2**n for n in range(23)],
)
b.plot()
plt.title("Runtime [s]")
plt.ylabel("")
plt.savefig("speed-absolute.svg", transparent=True, bbox_inches="tight")
# tikzplotlib.save(
# "figures/speed-absolute.tex",
# externalize_tables=True,
# override_externals=True,
# externals_search_path="./figures/",
# out.save('toDimacs.png')
def setup_touples_iter(n):
a = list(range(n))
return a
out2 = perfplot.bench(
setup=setup_touples_iter, # or simply setup=numpy.random.rand
kernels=[
fast_three_touples,
slow_three_touples,
],
labels=["fast_three_touples", "slow_three_touples"],
n_range=[
k for k in reversed([2, 5, 10, 50, 100, 150, 200, 400, 600, 1000])
],
xlabel="Length of array",
# More optional arguments with their default values:
title="3 touple creation",
# logx=True,
# logy=False,
equality_check=None, # set to None to disable "correctness" assertion
# equality_check=numpy.allclose, # set to None to disable "correctness" assertion
# automatic_order=True,
# colors=None,
# target_time_per_measurement=1.0,
)
out2.save('3Touples.png')
"title":
"Rayleigh-wave",
"filename":
"perf_rayleigh.svg",
},
"love": {
"kernels": [
lambda n: perf_pysurf96(n, periods, "love"),
lambda n: perf_disba(n, periods, "love"),
],
"labels": ["pysurf96", "disba"],
"title":
"Love-wave",
"filename":
"perf_love.svg",
},
}
periods = numpy.logspace(0.0, 1.0, 60)
for wave in config.values():
out = perfplot.bench(
setup=lambda n: n,
n_range=numpy.arange(19) + 2,
kernels=wave["kernels"],
equality_check=lambda a, b: numpy.allclose(a, b, atol=0.02),
title=wave["title"],
xlabel="Number of layers",
labels=wave["labels"],
)
out.save(wave["filename"], transparent=True, bbox_inches="tight")
from src.implementations.sorting.mergesort import \
mergesort_iterative, mergesort_recursive
from src.implementations.sorting.radixsort import radixsort_LSD
from src.perf_plots.config import SAMPLE_SIZES
SAMPLE_SIZE = SAMPLE_SIZES['SORTING_INTEGERS']
if __name__ == '__main__':
output = perfplot.bench(setup=lambda n: sample(range(n + 1), n + 1),
kernels=[
lambda a: selection_sort(a),
lambda a: insertion_sort(a),
lambda a: shell_sort(a),
lambda a: heapsort(a),
lambda a: mergesort_recursive(a),
lambda a: mergesort_iterative(a),
],
labels=[
'selection sort', 'insertion sort',
'shell sort', 'heapsort', 'mergesort (rec)',
'mergesort (itr)'
],
xlabel="Array of N integers in [0, N)",
title='Sorting an array of integers',
n_range=range(1, SAMPLE_SIZE),
equality_check=None)
output.save(f'output/sorting-integers_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
config = {
"rayleigh": {
"kernels": [
lambda n: perf_pysurf96(n, periods, "rayleigh"),
lambda n: perf_disba(n, periods, "rayleigh"),
lambda n: perf_disba(n, periods, "rayleigh", "fast-delta"),
],
"labels": ["pysurf96", "disba-dunkin", "disba-fast-delta"],
"title": "Rayleigh-wave",
},
"love": {
"kernels": [
lambda n: perf_pysurf96(n, periods, "love"),
lambda n: perf_disba(n, periods, "love"),
],
"labels": ["pysurf96", "disba"],
"title": "Love-wave",
},
}
periods = numpy.logspace(0.0, 1.0, 60)
for k, v in config.items():
out = perfplot.bench(
setup=lambda n: n,
n_range=numpy.arange(19) + 2,
equality_check=lambda a, b: numpy.allclose(a, b, atol=0.02),
xlabel="Number of layers",
**v,
)
out.save(f"perf_{k}.svg", transparent=True, bbox_inches="tight")
from src.implementations.priority_queue.binary_heap import BinaryHeap
from src.perf_plots.config import SAMPLE_SIZES
SAMPLE_SIZE = SAMPLE_SIZES['PRIORITY_QUEUE']
def get_n_random_items(n):
return [randint(0, n) for _ in range(n)]
def insert_n_items_into_binary_heap(n_items):
PQ = BinaryHeap()
for item in n_items:
PQ.insert(item)
if __name__ == '__main__':
output = perfplot.bench(
setup=lambda n: get_n_random_items(n),
kernels=[lambda n_items: insert_n_items_into_binary_heap(n_items)],
labels=['Binary heap'],
xlabel="Inserting n items into a priority queue",
title='Priority Queue',
n_range=range(1, SAMPLE_SIZE + 1),
equality_check=None)
output.save(f'output/priority-queue_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
import ks_recursive_weight, ks_bottom_up
from src.perf_plots.config import SAMPLE_SIZES
SAMPLE_SIZE = SAMPLE_SIZES['KNAPSACK']
if __name__ == '__main__':
output = perfplot.bench(
setup=lambda n: n,
kernels=[
lambda n: ks_recursive_weight(
[randint(1, n * 2) for _ in range(1, n + 1)],
[randint(1, n * 2) for _ in range(1, n + 1)],
n * 3
),
lambda n: ks_bottom_up(
[randint(1, n * 2) for _ in range(1, n + 1)],
[randint(1, n * 2) for _ in range(1, n + 1)],
n * 3
),
],
labels=['recursive', 'bottom_up'],
xlabel="N weights and values at N*3 capacity",
title='Solving the 0-1 Knapsack problem',
n_range=range(1, SAMPLE_SIZE),
equality_check=None
)
output.save(f'output/knapsack_sample-size-{SAMPLE_SIZE}.png',
transparent=False,
bbox_inches="tight")
