def test_exact_interpolants(): order1 = lambda x: 3 * x + 7 order4 = lambda x: 4.123 * x**4 - 5.6 * x**3 - x**2 + 4.5 order6 = lambda x: x**6 - 3 * x**5 - 2 * x**4 + x - 3 order8 = lambda x: x**8 - 42 * x**7 + 7.5 * x**5 - 4.1234 * x**4 - 1.2 * x**2 a, b = -10, 10 x = np.linspace(a, b, 1e5, dtype=np.float64) est1 = adapt_i.make_interpolant(a, b, order1, 1, 1e-9, "monomial").evaluate(x) est4 = adapt_i.make_interpolant(a, b, order4, 4, 1e-9, "monomial").evaluate(x) est6 = adapt_i.make_interpolant(a, b, order6, 6, 1e-9, "monomial").evaluate(x) est8 = adapt_i.make_interpolant(a, b, order8, 8, 1e-9, "monomial").evaluate(x) print(la.norm(est1 - order1(x), np.inf) / la.norm(order1(x), np.inf)) print(la.norm(est4 - order4(x), np.inf) / la.norm(order4(x), np.inf)) print(la.norm(est6 - order6(x), np.inf) / la.norm(order6(x), np.inf)) print(la.norm(est8 - order8(x), np.inf) / la.norm(order8(x), np.inf)) assert la.norm(est1 - order1(x), np.inf) / la.norm(order1(x), np.inf) < 1e-15 assert la.norm(est4 - order4(x), np.inf) / la.norm(order4(x), np.inf) < 1e-15 assert la.norm(est6 - order6(x), np.inf) / la.norm(order6(x), np.inf) < 1e-15 assert la.norm(est8 - order8(x), np.inf) / la.norm(order8(x), np.inf) < 1e-15
def test_all_parallel_methods(): a, b = 0, 10 est1 = adapt_i.make_interpolant(a, b, f, 3, 1e-9, "monomial") est2 = adapt_i.make_interpolant(a, b, f, 3, 1e-9, "chebyshev") est3 = adapt_i.make_interpolant(a, b, f, 3, 1e-9, "legendre") test_parallel(est1) test_parallel(est2) test_parallel(est3)
def test_remez_incorrect(): # tests the lookup table size for incorrect remez algorithm and polynomial interpolation a, b = 0, 20 order, precision = 6, 1e-6 opt = ["arrays", "map", "calc intervals", "random", "remez incorrect"] approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=opt) #adapt_i.write_to_file("./testingclass", approx) #approx = adapt_i.load_from_file("./testingclass") run_one(approx, opt=opt) opt = ["arrays", "map", "calc intervals", "random"] approx1 = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=opt) run_one(approx1, opt=opt) opt = ["arrays", "map", "calc intervals", "random"] approx2 = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=opt, adapt_type="Trivial") run_one(approx2, opt=opt) print("Incorrect Remez, Correct, Polynomial Interpolation") print(len(approx.map), len(approx1.map), len(approx2.map)) print('{0:.16f}'.format(la.norm(approx.coeff, 2)), '{0:.16f}'.format(la.norm(approx1.coeff, 2)), '{0:.16f}'.format(la.norm(approx2.coeff, 2))) print('{0:.16f}'.format(la.norm(approx.coeff, np.inf)), '{0:.16f}'.format(la.norm(approx1.coeff, np.inf)), '{0:.16f}'.format(la.norm(approx2.coeff, np.inf)))
def save_approximations(a, b, orders, precisions): # Change dtypes and precisions manually size, num_samples = 2**12, 2 opt = ["arrays", "map", "random"] for precision in precisions: for order in orders: print(order, precision) if precision > 1e-7: try: name = "./approximations/32o" + str(order) + "-p" + str( precision) approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=opt) adapt_i.write_to_file(name, approx) run_one(approx, size, num_samples, opt) run_one(approx, size, num_samples, opt + ["scalar"]) run_one(approx, size, num_samples, opt + ["calc intervals"]) run_one(approx, size, num_samples, opt + ["scalar", "calc intervals"]) except: pass opt = ["arrays", "map", "calc intervals", "random"] name = "./approximations/64o" + str(order) + "-p" + str(precision) approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=opt) adapt_i.write_to_file(name, approx) run_one(approx, size, num_samples, opt) run_one(approx, size, num_samples, opt + ["scalar"]) run_one(approx, size, num_samples, opt + ["calc intervals"]) run_one(approx, size, num_samples, opt + ["scalar", "calc intervals"])
def make_code(size, order, precision, d, vectorized=True, approx=None, code=None, opt=[]): a, b = 0, 20 if approx is None: approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=d, optimizations=opt) else: approx.optimizations = opt if code is None: if vectorized: # vector width is actually set depending on data type. code = adapt_i.generate_code(approx, size=size, vector_width=8, cpu=True) else: code = adapt_i.generate_code(approx, size=size, cpu=True) dt = approx.dtype_name var = "uniform " if vectorized else "" if vectorized: header = "export void eval(" else: header = 'extern "C" void eval(' if "arrays" in opt: header += "const " + var + dt + " mid[], " header += "const " + var + dt + " left[], " header += "const " + var + dt + " right[], " header += "const " + var + dt + " interval_a[], " header += "const " + var + dt + " interval_b[], " header += "const " + var + dt + " coeff[], " else: header += "const " + var + dt + " tree[], " if "map" in opt: fdt = "int64" if "calc intervals" in approx.optimizations else dt header += "const " + var + fdt + " f[], " header += var + dt + " x[], " + var + dt + " y[])" code = code.replace("\n", "\n\t") full_code = header + "{\n\n" + code + "\n}" return approx, full_code
def test_guaranteed_accuracy(): func1 = lambda x: np.sin(np.sin(x)) func2 = lambda x: np.cos(np.sin(x)) func3 = lambda x: np.sqrt(x) a, b = -10, 10 x = np.linspace(a, b, 100, dtype=np.float64) est31 = adapt_i.make_interpolant(a, b, func1, 10, 1e-3, "monomial").evaluate(x) est32 = adapt_i.make_interpolant(a, b, func2, 10, 1e-3, "chebyshev").evaluate(x) est33 = adapt_i.make_interpolant(a, b, func3, 10, 1e-3, "legendre").evaluate(x) est61 = adapt_i.make_interpolant(a, b, func1, 10, 1e-6, "monomial").evaluate(x) est62 = adapt_i.make_interpolant(a, b, func2, 10, 1e-6, "chebyshev").evaluate(x) est63 = adapt_i.make_interpolant(a, b, func3, 10, 1e-6, "legendre").evaluate(x) est91 = adapt_i.make_interpolant(a, b, func1, 10, 1e-9, "monomial").evaluate(x) est92 = adapt_i.make_interpolant(a, b, func2, 10, 1e-9, "chebyshev").evaluate(x) est93 = adapt_i.make_interpolant(a, b, func3, 10, 1e-9, "legendre").evaluate(x) assert la.norm(est31 - func1(x), np.inf) / la.norm(func1(x), np.inf) < 1e-3 assert la.norm(est32 - func2(x), np.inf) / la.norm(func2(x), np.inf) < 1e-3 assert la.norm(est33 - func3(x), np.inf) / la.norm(func3(x), np.inf) < 1e-3 assert la.norm(est61 - func1(x), np.inf) / la.norm(func1(x), np.inf) < 1e-6 assert la.norm(est62 - func2(x), np.inf) / la.norm(func2(x), np.inf) < 1e-6 assert la.norm(est63 - func3(x), np.inf) / la.norm(func3(x), np.inf) < 1e-6 assert la.norm(est91 - func1(x), np.inf) / la.norm(func1(x), np.inf) < 1e-9 assert la.norm(est92 - func2(x), np.inf) / la.norm(func2(x), np.inf) < 1e-9 assert la.norm(est93 - func3(x), np.inf) / la.norm(func3(x), np.inf) < 1e-9
def get_asm(): a, b = 0, 20 order, precision = 5, 1e-6 print("make approximation") approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=["arrays"]) print("Run approximation") run_one(approx, opt=['test first loop', 'get asm']) run_one(approx, opt=['test second loop', 'get asm']) run_one(approx, opt=['arrays', 'map', 'test first loop', 'get asm']) run_one(approx, opt=['arrays', 'map', 'test second loop', 'get asm'])
def test_guaranteed_accuracy(): func1 = lambda x: np.sin(1. / (x)) func2 = lambda x: np.abs(x * np.sin(x)) func3 = lambda x: np.sqrt(x) func4 = lambda x: np.abs(x * np.cos(x)) a, b = 0.01, 10 x = np.linspace(a, b, 1e5, dtype=np.float64) for func in [func4, func2, func3, func1]: for err in [1e-3, 1e-6, 1e-9]: for interpolant in ["monomial", "chebyshev", "legendre"]: est = adapt_i.make_interpolant(a, b, func, 6, err, interpolant).evaluate(x) abs_err = la.norm(est - func(x), np.inf) rel_err = abs_err / la.norm(func(x), np.inf) print(interpolant, err, rel_err) plt.figure() plt.plot(x, func(x), 'r') plt.plot(x, est, 'b') plt.show() assert rel_err < err
def scalar_test(): # decreasing the size causes the GFLOPS to go down... # size of 0 takes about 1e-5 seconds to run function. # with 2**10 and 2**15 size its still about that. # 2**20 is better but 2**26 guarentees its good # takes long enough for the measurement to make sense. a, b = 1, 21 order, precision = 3, np.finfo(np.float32).eps * 10 size, num_samples = 2**23, 50 d = 32 opt = ["arrays", "map", "random"] approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=d, optimizations=opt) run_one(approx, size, num_samples, opt=opt + ["calc intervals"]) run_one(approx, size, num_samples, opt=opt) # scalar does something incorrect? oh.. data race? run_one(approx, size, num_samples, opt=opt + ["scalar", "calc intervals"]) run_one(approx, size, num_samples, opt=opt + ["scalar"])
def test_throughput(n, d, precision, size): if d != '32' and d != '64': return throw_out = 20 a, b = 0, 20 vws = [1] # vector widths used GB = size * float(d) / (8 * 2**20 ) # number of bits / a GB in bits = # of GB orders = [1] tests = [[0 for __ in range(len(vws))] for _ in range(len(orders) + 1)] for j in range(len(orders)): approx = adapt_i.make_interpolant(a, b, f, orders[j], precision, 'chebyshev', dtype=d) for v in range(len(vws)): # see how much time to process array adapt_i.generate_code(approx, size, vws[v]) print() knl, q, treed = generate.build_code(approx) print(approx.code) for trial in range(n + throw_out): print("order: " + repr(j) + "/" + repr(len(orders)) + "\ttrial:" + repr(trial + 1) + "/" + repr(n + throw_out) + "\r") o = np.float32 if d == '32' else np.float64 x = np.random.uniform(a, b, size=size).astype(o) run_time, _ = generate.run_single(x, approx) # run code multiple times before actually adding to tests if trial > throw_out: tests[j + 1][v] += GB / run_time # only evaluate scipy's speed the first time if j == 0: start_time = time.time() val = f0(x, v) run_time = time.time() - start_time tests[0][v] += GB / run_time print() # average out each test for i in range(len(tests)): for j in range(len(vws)): tests[i][j] /= float(n) fig = plt.figure() plt.title("throughput {0} single, {1} trials, vw={2}".format( precision, n, vws[0])) plt.xlabel("Function Evaluated") plt.ylabel("Average Throughput (GB/s)") #plt.yscale("log") #plt.xscale("log") #plt.bar(0, tests[0][0], width=.5, align='center', color='r') i = 0 z = np.linspace(-.2, .2, len(vws)) colors = ['b', 'g', 'y', 'k', 'm', 'c'] for v in range(len(vws)): plt.bar(i + z[v], tests[i][v], width=.3 / len(vws), align='center', color=colors[i]) xticks = ['scipy specials'] for order in orders: z = np.linspace(-.2, .2, len(vws)) for v in range(len(vws)): plt.bar(i + 1 + z[v], tests[i + 1][v], width=.3 / len(vws), align='center', color=colors[i]) i += 1 xticks.append("{0}th order approx".format(order)) plt.xticks(range(len(orders) + 1), xticks) string = "../data/00" + repr(d) + "t" + repr(time.time() % 100) + "n" string += repr(n) + "+vw" + repr(vws[0]) + repr(vws[-1]) + "o" string += repr(orders[0]) + repr(precision) + repr(size) + ".png" fig.savefig(string)
def make_data(size, order, precision, d, vectorized=True, approx=None, code=None, opt=[]): a, b = 0, 20 if code == None and approx == None: approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=d, optimizations=opt) # see how much time to process array, vector width = 1 if vectorized: code = adapt_i.generate_code(approx, size=size, vector_width=8, cpu=True) else: code = adapt_i.generate_code(approx, size=size, cpu=True) #print(code) dt = approx.dtype_name var = "uniform " if vectorized else "" header = "export void eval(" if "arrays" in opt: header += "const " + var + dt + " mid[], " header += "const " + var + dt + " left[], " header += "const " + var + dt + " right[], " header += "const " + var + dt + " interval_a[], " header += "const " + var + dt + " interval_b[], " header += "const " + var + dt + " coeff[], " else: header += "const " + var + dt + " tree[], " if "map" in opt: header += "const " + var + dt + " f[], " header += var + dt + " x[], " + var + dt + " y[])" code = code.replace("\n", "\n\t") full_code = header + "{\n\n" + code + "\n}" with open("simple_ispc.ispc", "w") as h: h.writelines(full_code) s = [size, size] if "arrays" in opt: s.append(len(approx.mid)) s.append(len(approx.left)) s.append(len(approx.right)) s.append(len(approx.interval_a)) s.append(len(approx.interval_b)) s.append(len(approx.coeff)) else: s.append(len(approx.tree_1d)) if "map" in opt: s.append(len(approx.map)) dt = float if "arrays" in opt: save("left.txt", approx.left, dt) save("right.txt", approx.right, dt) save("interval_a.txt", approx.interval_a, dt) save("interval_b.txt", approx.interval_b, dt) save("coeff.txt", approx.coeff, dt) save("mid.txt", approx.mid, dt) os.system("mv left.txt tests/perf/") os.system("mv right.txt tests/perf/") os.system("mv interval_a.txt tests/perf/") os.system("mv interval_b.txt tests/perf/") os.system("mv coeff.txt tests/perf/") os.system("mv mid.txt tests/perf/") else: save("tree.txt", approx.tree_1d, dt) os.system("mv tree.txt tests/perf/") if "map" in opt: save("f.txt", approx.map, dt) os.system("mv f.txt tests/perf/") # add changing eval function in tests/perf/simple.cpp """ with open("tests/perf/simple.cpp", 'rw') as sim: cpp = sim.readlines() # actually this only needs to comment and uncomment correct lines if "arrays" in opt or "map" in opt: cpp.replace("", "eval(mid, left, right, interval_a, interval_b, coeff, f, x, y);\n") else: cpp.repalce("", "eval(tree, x, y);") sim.writelines(cpp) """ save("sizes.txt", s, int) os.system("mv sizes.txt tests/perf/") os.system("mv *.ispc tests/perf/") return approx, full_code
def demo_adapt(function, order, allowed_error, basis, adapt_type="Trivial", accurate=True, animate=False, a=0, b=10, opt=[]): print("Creating Interpolant") my_approx = adapt_i.make_interpolant(a, b, function, order, allowed_error, basis, adapt_type, '32', accurate, optimizations=opt) print("\nGenerated Code:\n") N = 2**10 adapt_i.generate_code(my_approx, size=N, cpu=True) print(my_approx.code) print("Evaluating Interpolant") x = np.linspace(a, b, N, dtype=np.float64) if with_pyopencl and False: est = adapt_i.run_approximation(x, my_approx) else: est = my_approx.evaluate_tree(x) print("Evaluating Function") true = function(x) print("Plotting") #not working with tree version if animate: fig = plt.figure() ax1 = fig.add_subplot(1, 2, 2) ax2 = fig.add_subplot(1, 2, 1) #ax1.set_ylim(-2, 2) ax2.set_yscale("log") ims = [] # traverse levels 1 to end for i in range(int(my_approx.num_levels)): print("Plotting Level: ", i, '/', my_approx.num_levels - 1) ims.append([]) im0, = ax1.plot(x, function(x), 'r') rel, = ax2.plot(x, 0 * x + allowed_error, 'r') ax1.set_xlabel("x") ax1.set_ylabel("y") ax1.set_title("True Function vs. Approximation") ax2.set_xlabel("x") ax2.set_ylabel("Errors") ax2.set_title("Relative and Absolute Errors on Intervals") ims[i].append(im0) ims[i].append(rel) t = np.linspace(a, b, 1e5) y, data = my_approx.evaluate_tree(t, i + 1, 1) midpoints = [elem[0] for elem in data] ranges = [elem[2] for elem in data] rel_errors = [elem[3] for elem in data] er = abs(np.array(y) - function(t)) im2, = ax1.plot(t, y, 'b') im3, = ax2.plot(t, er, 'g') for r in ranges: im4 = ax2.axvline(x=r[0]) ims[i].append(im4) im5, = ax2.plot(midpoints, rel_errors, 'bs') ims[i].append(im2) ims[i].append(im3) ims[i].append(im5) im6 = ax2.axvline(x=ranges[-1][1]) ims[i].append(im6) ani = animation.ArtistAnimation(fig, ims, interval=1000) ani.save("adapt.mp4") plt.show() else: my_plot(x, true, est, abs(true - est), allowed_error, my_approx)
def test_speed(): n = 10 throw_out = 40 a, b = 0, 20 sizes = 2**np.arange(1, 13) #sizes = np.linspace(1e2, 5e6, 5, dtype=np.int) tests = [] orders = [9, 16] tests.append(0 * np.zeros(sizes.shape)) tests.append(0 * np.zeros(sizes.shape)) for j in range(len(orders)): tests.append(0 * np.zeros(sizes.shape)) approx = adapt_i.make_interpolant(a, b, f, orders[j], 1e-9, 'chebyshev') if True: # test interpolant is accurate y = np.linspace(a, b, 8 * 5e3) adapt_i.generate_code(approx, 8 * 5e3, 32) knl, q, xd, yd, treed = generate.build_code(y, approx) _, z = generate.run_single(approx) rel_err = la.norm(z - f(y), np.inf) / la.norm(f(y), np.inf) print("rel_error", orders[j], rel_err) for i in range(sizes.shape[0]): index = 0 x = np.linspace(a, b, sizes[i]) adapt_i.generate_code(approx, sizes[i], 1) knl, q, xd, yd, treed = generate.build_code(x, approx) for trial in range(n + throw_out): print("order: " + repr(j) + "/" + repr(len(orders)) + "\ttrial:" + repr(trial + 1) + "/" + repr(n + throw_out) + "\r") run_time, _ = generate.run_single(approx) # run code multiple times before actually adding to tests if trial >= throw_out: tests[j + 1][i] += run_time if j == 0: if trial - throw_out > 17: print("mine", run_time) start_time = time.time() val = f(x) run_time = time.time() - start_time #print(la.norm(_-val,np.inf)/la.norm(val, np.inf)) if trial - throw_out > 17: print("scipy", run_time, sizes[i], trial - throw_out) tests[0][i] += run_time print() # average out each test for i in range(len(tests)): tests[i] /= float(n) fig = plt.figure() plt.title("Runtimes 1E-9 prec. bessel 0-20, {0} trials, vw=1".format(n)) plt.xlabel("Size of evaluated array") plt.ylabel("Time to evaluate (seconds)") #plt.yscale("log") #plt.xscale("log") sp, = plt.plot(sizes, tests[0], 'r', label='scipy bessel') i = 0 hand = [sp] colors = ['b', 'g', 'y', 'k', 'm', 'c'] for order in orders: a1, = plt.plot(sizes, tests[i + 1], colors[i], label="{0}th order approx".format(order)) i += 1 hand.append(a1) plt.legend(handles=hand) #plt.show() string = "data/t" + repr(time.time()) + "n" + repr(n) + "vw1o" + repr( orders[0]) + ".png" fig.savefig(string)
# maybe im using the wrong dtype somewhere? # its actually not. The scaling/L is imprecise for some reason.. #2/(b-a) is accurate though.. at least I figured it out... if 0: order, num_samples = 3, 10 a, b = -3, 23 size = 2**23 precision = 90000 * np.finfo(np.float32).eps opt = ["arrays", "map", "verbose"] #name = "./approximations/64o" + str(order) + "-p" + str(precision) #approx = adapt_i.load_from_file(name) approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=opt) print(2 * approx.D + approx.lgD) scaling = (approx.upper_bound - approx.lower_bound) / len(approx.map) c = list( map( lambda x: ( int(bin(x)[:-2 * approx.D], 2), int("0b" + bin(x)[-2 * approx.D:-approx.D], 2), int("0b" + bin(x)[-approx.D:], 2), bin(x), int("0b" + bin(x)[-2 * approx.D:-approx.D], 2) * scaling + approx.lower_bound, int(bin(x)[:-2 * approx.D], 2) * scaling,
def new_test(): # Function used to obtain results. DONT CHANGE a, b = 0, 20 order, precision = 5, 1e-6 approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=["arrays"]) run_one(approx, precision, opt=['test flops']) run_one(approx, precision, opt=['none']) run_one(approx, precision, opt=['arrays', 'map']) run_one(approx, precision, opt=['arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['arrays', 'map', 'test second loop']) run_one(approx, precision, opt=[]) run_one(approx, precision, opt=['test first loop']) run_one(approx, precision, opt=['test second loop']) print("Doubles: Same Precision") approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=["arrays"]) # give peak flop estimate run_one(approx, precision, opt=['64', 'test flops']) run_one(approx, precision, opt=['64', 'none']) run_one(approx, precision, opt=['64', 'arrays', 'map']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test second loop']) run_one(approx, precision, opt=['64']) run_one(approx, precision, opt=['64', 'test first loop']) run_one(approx, precision, opt=['64', 'test second loop']) print("Doubles: Higher Precision") order, precision = 5, 1e-13 approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=["arrays"]) # give peak flop estimate run_one(approx, precision, opt=['64', 'test flops']) run_one(approx, precision, opt=['64', 'none']) run_one(approx, precision, opt=['64', 'arrays', 'map']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test second loop']) run_one(approx, precision, opt=['64']) run_one(approx, precision, opt=['64', 'test first loop']) run_one(approx, precision, opt=['64', 'test second loop'])
def test(): # Function used to obtain results. DONT CHANGE a, b = 0, 20 order, precision = 5, 1e-4 approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=32, optimizations=["arrays"]) run_one(approx, precision, opt=[]) #run_one(approx, precision, opt=['unroll']) #run_one(approx, precision, opt=['unroll_order']) #run_one(approx, precision, opt=['prefetch']) #run_one(approx, precision, opt=['unroll', 'unroll_order', 'prefetch']) run_one(approx, precision, opt=['test first loop']) run_one(approx, precision, opt=['test second loop']) run_one(approx, precision, opt=['arrays', 'map']) #run_one(approx, precision, opt=['arrays', 'map', 'unroll']) #run_one(approx, precision, opt=['arrays', 'map', 'unroll_order']) #run_one(approx, precision, opt=['arrays', 'map', 'prefetch']) #run_one(approx, precision, opt=['arrays', 'map', 'unroll', 'unroll_order', 'prefetch']) run_one(approx, precision, opt=['arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['arrays', 'map', 'test second loop']) #run_one(approx, precision, opt=['none']) print("USING DOUBLES") approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=["arrays"]) run_one(approx, precision, opt=['64']) #run_one(approx, precision, opt=['64', 'unroll']) #run_one(approx, precision, opt=['64', 'unroll_order']) #run_one(approx, precision, opt=['64', 'prefetch']) #run_one(approx, precision, opt=['64', 'unroll', 'unroll_order', 'prefetch']) run_one(approx, precision, opt=['64', 'test first loop']) run_one(approx, precision, opt=['64', 'test second loop']) run_one(approx, precision, opt=['64', 'arrays', 'map']) #run_one(approx, precision, opt=['64', 'arrays', 'map', 'unroll']) #run_one(approx, precision, opt=['64', 'arrays', 'map', 'unroll_order']) #run_one(approx, precision, opt=['64', 'arrays', 'map', 'prefetch']) #run_one(approx, precision, opt=['64', 'arrays', 'map', 'unroll', 'unroll_order', 'prefetch']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test second loop']) #run_one(approx, opt=['64', 'none']) precision = 1e-13 approx = adapt_i.make_interpolant(a, b, f, order, precision, 'chebyshev', dtype=64, optimizations=["arrays"]) run_one(approx, precision, opt=['64']) run_one(approx, precision, opt=['64', 'test first loop']) run_one(approx, precision, opt=['64', 'test second loop']) run_one(approx, precision, opt=['64', 'arrays', 'map']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test first loop']) run_one(approx, precision, opt=['64', 'arrays', 'map', 'test second loop']) """