def linear(x, y, xx): """ Linear Interpolation Parameters ---------- x : ndarray shape:(n) x of data points y : ndarray shape:(n) y of data points xx : ndarray shape:(k) x of target points Returns ------- yy : ndarray shape:(k) y of target points """ yy = numpy.zeros(len(xx)) n = len(x) for k in range(0, n - 1): flag = ((xx >= x[k]) & (xx < x[k + 1])) yy[flag] = lagrange(x[k:k + 2], y[k:k + 2], xx[flag]) return yy
def __init__(self,points): """ @points : a dictionary whose keys are x values and values are y values to be considered as fixed points for interpolation. """ Function.__init__(self) self.polynom = lagrange.lagrange(points)
def lagrange1st(N): # Calculation of 1st derivatives of Lagrange polynomials # at GLL collocation points # out = legendre1st(N) # out is a matrix with columns -> GLL nodes # rows -> order from gll import gll from lagrange import lagrange from legendre import legendre import numpy as np out = np.zeros([N+1, N+1]) [xi, w] = gll(N) # initialize dij matrix (see Funaro 1993 or Diploma thesis Bernhard Schuberth) d = np.zeros([N+1, N+1]) for i in range (-1, N): for j in range (-1, N): if i != j: d[i+1,j+1] = legendre(N,xi[i+1])/legendre(N,xi[j+1])*1/(xi[i+1]-xi[j+1]) if i == -1: if j == -1: d[i+1,j+1] = float(-1)/float(4)*N*(N+1) if i == N-1: if j == N-1: d[i+1,j+1] = float(1)/float(4)*N*(N+1) # Calculate matrix with 1st derivatives of Lagrange polynomials for n in range (-1, N): for i in range (-1, N): sum=0 for j in range(-1, N): sum = sum + d[i+1,j+1]*lagrange(N,n,xi[j+1]) out[n+1,i+1] = sum return(out)
def lagrange1st(N): """ # Calculation of 1st derivatives of Lagrange polynomials # at GLL collocation points # out = legendre1st(N) # out is a matrix with columns -> GLL nodes # rows -> order """ out = np.zeros([N+1, N+1]) [xi, w] = gll(N) # initialize dij matrix (see Funaro 1993 or Diploma thesis Bernhard # Schuberth) d = np.zeros([N + 1, N + 1]) for i in range(-1, N): for j in range(-1, N): if i != j: d[i + 1, j + 1] = legendre(N, xi[i + 1]) / \ legendre(N, xi[j + 1]) * 1.0 / (xi[i + 1] - xi[j + 1]) if i == -1: if j == -1: d[i + 1, j + 1] = -1.0 / 4.0 * N * (N + 1) if i == N-1: if j == N-1: d[i + 1, j + 1] = 1.0 / 4.0 * N * (N + 1) # Calculate matrix with 1st derivatives of Lagrange polynomials for n in range(-1, N): for i in range(-1, N): sum = 0 for j in range(-1, N): sum = sum + d[i + 1, j + 1] * lagrange(N, n, xi[j + 1]) out[n + 1, i + 1] = sum return(out)
def keys_to_secret(xs, keys): y = np.zeros(M,dtype=int) for m in range(M): points = [] for i in range(len(keys)): x = xs[i] key = keys[i]*P/255 key = key.reshape(128*128) key = key[0:M] points.append((x,key[m])) y[m] = lagrange(points, P) secret_str = '' print(len(y)) #print(y) for yi in range(len(y)): secret_str = secret_str + '{:04x}'.format(y[yi]) print(len(secret_str)) #print(secret_str) data = bytes.fromhex(secret_str) print(len(secret_str)) print(len(data)) return data
print("pre-loop setup: " + str(elapsed)) # ====================== PERFORM MAIN TEA LOOP ====================== # while repeat: # Output iteration number if ((not doprint) & (not times)): stdout.write(' ' + str(it_num) + '\r') stdout.flush() # Time / speed testing for lagrange.py if times: ini = time.time() # Execute Lagrange minimization lagrange_data = lg.lagrange(it_num, datadir, doprint, lambdacorr_data) # Time / speed testing for lagrange.py if times: fin = time.time() elapsed = fin - ini print("lagrange" + str(it_num).rjust(4) + " : " + str(elapsed)) # Print for debugging purposes if doprint: printout('Iteration %d Lagrange complete. Starting lambda correction...', it_num) # Take final x_i mole numbers from last Lagrange calculation lagrange_x = lagrange_data[4] # Check if x_i have negative mole numbers, and if yes perform lambda correction
# -*- coding: utf-8 -*- # Linjen over er for å tillate bruk av æ, ø og å. import numpy as np # For NumPy import matplotlib.pyplot as plt # For plotting med matplotlib from lagrange import lagrange # Importerer lagrange-funksjonen fra lagrange.py. x = np.array([-1.5, -0.75, 0, 0.75, 1.5]) # Interpoleringspunkter f = np.array([-14.1014, -0.931597, 0.0, 0.931597, 14.1014]) # Kjente verdier. X = np.linspace(-1.5, 1.5, 100) # 100 jevnt fordelte punkter fra -1,5 til 1,5 F = lagrange(X, x, f) # OBS: I en tidligere utgave av koden stod det # her "interpolate" istedet for "lagrange". Beklager! # Følgende plottekode kan bare kopieres direkte. fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, f, "o", color="black", label="kjente punkter") ax.plot(X, np.tan(X), color="black", linestyle="dashed", label="tan") ax.plot(X, F, color="black", label="interpolert") ax.set_xlim(-1.55, 1.55) ax.legend(loc="upper left") plt.show()
def iterator(head, destination, location_out): # Correct location_TEA name if location_out[-1] != '/': location_out += '/' # Time / speed testing if times: end = time.time() elapsed = end - start print("iterate.py imports: " + str(elapsed)) # Read run-time arguments header = head # Name of header file desc = destination # Directory name # Create and name outputs and results directories if they do not exist datadir = location_out + desc + '/outputs/' + 'transient/' datadirr = location_out + desc + '/results' if not os.path.exists(datadir): os.makedirs(datadir) if not os.path.exists(datadirr): os.makedirs(datadirr) # Retrieve header info inhead = form.readheader(header) pressure = inhead[0] temp = inhead[1] # Locate and read initial iteration output from balance.py infile = datadir + '/lagrange-iteration-0-machine-read.txt' input = form.readoutput(infile) # Retrieve and set initial values speclist = input[2] x = input[3] x_bar = input[6] # Set up first iteration it_num = 1 repeat = True # Prepare data object for iterative process # (see description of the 'direct' object in lagrange.py) lambdacorr_data = [header, 0, speclist, x, x, 0, x_bar, x_bar, 0] # Time / speed testing if times: new = time.time() elapsed = new - end print("pre-loop setup: " + str(elapsed)) # ====================== PERFORM MAIN TEA LOOP ====================== # while repeat: # Output iteration number if ((not doprint) & (not times)): stdout.write(' ' + str(it_num) + '\r') stdout.flush() # Time / speed testing for lagrange.py if times: ini = time.time() # Execute Lagrange minimization lagrange_data = lg.lagrange(it_num, datadir, doprint, lambdacorr_data) # Time / speed testing for lagrange.py if times: fin = time.time() elapsed = fin - ini print("lagrange" + str(it_num).rjust(4) + " : " + str(elapsed)) # Print for debugging purposes if doprint: printout('Iteration %d Lagrange complete. Starting lambda correction...', it_num) # Take final x_i mole numbers from last Lagrange calculation lagrange_x = lagrange_data[4] # Check if x_i have negative mole numbers, and if yes perform lambda correction if where((lagrange_x < 0) == True)[0].size != 0: # Print for debugging purposes if doprint: printout('Correction required. Initializing...') # Time / speed testing for lambdacorr.py if times: ini = time.time() # Execute lambda correction lambdacorr_data = lc.lambdacorr(it_num, datadir, doprint, \ lagrange_data) # Print for debugging purposes if times: fin = time.time() elapsed = fin - ini print("lambcorr" + str(it_num).rjust(4) + " : " + \ str(elapsed)) # Print for debugging purposes if doprint: printout('Iteration %d lambda correction complete. Checking precision...', it_num) # Lambda correction is not needed else: # Pass previous Lagrange results as inputs to next iteration lambdacorr_data = lagrange_data # Print for debugging purposes if doprint: printout('Iteration %d did not need lambda correction.', it_num) # Retrieve most recent iteration values input_new = lambdacorr_data # Take most recent x_i and x_bar values x_new = input_new[4] x_bar_new = input_new[7] # If max iteration not met, continue with next iteration cycle if it_num < maxiter: # Add 1 to iteration number it_num += 1 # Print for debugging purposes if doprint: printout('Max interation not met. Starting next iteration...\n') # ============== Stop the loop, max iteration reached ============== # # Stop if max iteration is reached else: # Print to screen printout('Maximum iteration reached, ending minimization.\n') # Set repeat to False to stop the loop repeat = False # Calculate delta values delta = x_new - x # Calculate delta_bar values delta_bar = x_bar_new - x_bar # Name output files with corresponding iteration number name file_results = datadirr + '/results-machine-read.txt' file_fancyResults = datadirr + '/results-visual.txt' # Export all values into machine and human readable output files form.output(datadirr, header, it_num, speclist, x, x_new, delta, \ x_bar, x_bar_new, delta_bar, file_results, doprint) form.fancyout_results(datadirr, header, it_num, speclist, x, x_new, \ delta, x_bar, x_bar_new, delta_bar, pressure, \ temp, file_fancyResults, doprint)
# nova imagem new_img = np.zeros(shape=(dimensions[1], dimensions[0]), dtype=np.uint8) for row in range(0, new_img.shape[0]): for col in range(0, new_img.shape[1]): coord = np.array([[row], [col]]) new_coord = inverse @ coord if mode == "neighbor": new_img[row][col] = neighbor(img, new_coord.ravel()[0], new_coord.ravel()[1]) elif mode == "bilinear": new_img[row][col] = bilinear(img, new_coord.ravel()[0], new_coord.ravel()[1]) elif mode == "bicubic": new_img[row][col] = bicubic(img, new_coord.ravel()[0], new_coord.ravel()[1]) else: new_img[row][col] = lagrange(img, new_coord.ravel()[0], new_coord.ravel()[1]) io.imsave(outputname, new_img) elapsed_time = time.time() - start_time print("Elapsed time: %1f s" % (elapsed_time))
# minpoints, maxpoints = 5, 17 # min and max number of nodes ibeg, iend = -5, 5 # interval begin and end step = 4 func = runge_func #get_nodes = equis_nodes get_nodes = cheby_nodes xx = np.linspace(ibeg, iend, 100) yy = [func(x) for x in xx] for n in range(minpoints, maxpoints + 1, step): _, ax = plt.subplots() ax.plot(xx, yy) xpoints = get_nodes(ibeg, iend, n) ypoints = [func(x) for x in xpoints] yy1 = lagrange(xpoints, ypoints, xx) ax.plot(xx, yy1) ax.scatter(xpoints, ypoints, s=15, color='black') ax.text(0.2, 0.9, 'n={}'.format(n), fontsize=20, transform=plt.gcf().transFigure) # Print Lebesgue constant lamb = lebesgue_const(xx, xpoints) print("n = {:2} lambda = {}".format(n, lamb)) # Show the graphs plt.show()
# for as long as is necessary given max iterations, precision, etc. Loop is # performed in chunks of two to allow comparison between two most recent loops # without isolting the first loop. while repeat: # Simple progress info if ((not doprint) & (not times)): stdout.write(' ' + str(it_num) + '\r') stdout.flush() # ### Perform 'starting' iteration # Time / speed testing for first lagrange if times: ini = time.time() # Execute lagrange minimization ini_iter = lg.lagrange(it_num, datadir, doprint, fin_iter2) if times: fin = time.time() elapsed = fin - ini print("lagrange" + str(it_num).rjust(4) + " : " + str(elapsed)) # Cleanup files that are no longer needed #form.cleanup(datadir, it_num, clean) if doprint: printout('Iteration %d Lagrange complete. Starting lambda correction...', it_num) # Recieve files by memory or file #if fin_iter2: lag_dat, lag_dat2 = ini_iter[4], ini_iter[7]
import lagrange import matplotlib.pyplot as plt import numpy as np x = np.array([1, 3, 4]) y = np.array([1, 2, 5]) input_x = np.sort(np.random.rand(100) * 6 - 1) ans = lagrange.lagrange(x, y, input_x) plt.scatter(x, y) plt.plot(input_x, ans) plt.show()
# Lagrange interpolating polynomial test from lagrange import lagrange import matplotlib.pyplot as plt import numpy as np # Three points are sufficient to interpolate a polynomial of degree 2 x = np.array([15, 42, 30]) y = np.square(x) X = np.linspace(0, 100, 100) Y = lagrange(x, y, X) # Plot the result plt.scatter(x, y) plt.plot(X, Y) plt.show()