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")