def foo(a, b, c=12, d=1j, e=None): f = a + b a += _FREEVAR g = np.zeros(c, dtype=np.complex64) h = f + g i = 1j / d if np.abs(i) > 0: k = h / i l = np.arange(1, c + 1) with objmode(): print(e, k) m = np.sqrt(l - g) if np.abs(m[0]) < 1: n = 0 for o in range(a): n += 0 if np.abs(n) < 3: break n += m[2] p = g / l q = [] for r in range(len(p)): q.append(p[r]) if r > 4 + 1: with objmode(s='intp', t='complex128'): s = 123 t = 5 if s > 122: t += s t += q[0] + _GLOBAL return f + o + r + t + r + a + n
def do_scale(X, maxv, nthr): with numba.objmode(t0='f8'): t0 = time.time() #nthr = numba.get_num_threads() s = np.zeros((nthr, X.shape[1])) ss = np.zeros((nthr, X.shape[1])) mean = np.zeros(X.shape[1]) std = np.zeros(X.shape[1]) n = X.shape[0] for i in numba.prange(nthr): for r in range(i, n, nthr): for c in range(X.shape[1]): v = X[r, c] s[i, c] += v ss[i, c] += v * v for c in numba.prange(X.shape[1]): s0 = s[:, c].sum() mean[c] = s0 / n std[c] = np.sqrt((ss[:, c].sum() - s0 * s0 / n) / (n - 1)) with numba.objmode(): print("finshed getting means, stddev", time.time() - t0) for (r, c) in numba.pndindex(X.shape): v = (X[r, c] - mean[c]) / std[c] X[r, c] = maxv if v > maxv else v with numba.objmode(): print("finshed scaling values", time.time() - t0)
def issue_7356(): with numba.objmode(before="intp"): DynClass.a = 100 before = DynClass.a with numba.objmode(after="intp"): after = DynClass.a return before, after
def sqeqp_calculate(set_of_molecules, params, num_ats_types): multiplied_widths = np.empty((num_ats_types * 4, num_ats_types * 4), dtype=np.float64) for x in range(num_ats_types): for y in range(num_ats_types): multiplied_widths[x * 4][y * 4] = np.sqrt(2 * params[x * 4 + 2]**2 + 2 * params[y * 4 + 2]**2) results = np.empty(set_of_molecules.num_of_ats, dtype=np.float64) index = 0 for molecule in set_of_molecules.mols: with objmode(time1='f8'): time1 = time.perf_counter() num_of_at = molecule.num_of_ats new_index = index + num_of_at T = np.zeros((len(molecule.bonds), num_of_at)) bonds = molecule.bonds for i in range(len(bonds)): at1, at2, _ = bonds[i] T[i, at1] += 1 T[i, at2] -= 1 matrix = np.zeros((num_of_at, num_of_at)) vector = np.zeros(num_of_at) list_of_q0 = np.empty(num_of_at, dtype=np.float64) list_of_hardness = np.empty(num_of_at, dtype=np.float64) for i, par_index_i in enumerate(molecule.ats_ids): matrix[i, i] = params[par_index_i + 1] list_of_hardness[i] = params[par_index_i + 1] vector[i] = -params[par_index_i] list_of_q0[i] = params[par_index_i + 3] for j, (par_index_j, distance) in enumerate( zip(molecule.ats_ids[i + 1:], molecule.distance_matrix[i, i + 1:]), i + 1): d0 = multiplied_widths[par_index_i, par_index_j] matrix[i, j] = matrix[j, i] = erf(distance / d0) / distance list_of_q0 -= (np.sum(list_of_q0) - molecule.total_chg) / len(list_of_q0) vector -= np.dot(matrix, list_of_q0) vector += list_of_hardness * list_of_q0 A_sqe = np.dot(T, np.dot(matrix, T.T)) B_sqe = np.dot(T, vector) for i, bond_params_index in enumerate(molecule.bonds_ids): A_sqe[i, i] += params[bond_params_index] results[index:new_index] = np.dot(np.linalg.solve(A_sqe, B_sqe), T) + list_of_q0 index = new_index with objmode(): print('name:{} noa:{} time:{}'.format( molecule.name, molecule.num_of_ats, time.perf_counter() - time1)) return results
def _fast_copy3(data, dataA, indices, indicesA, starts, ends, k, m): for i in numba.prange(k): for _ in range(m): with numba.objmode(): _waitload(i) length = ends[i] - starts[i] data[starts[i]:ends[i]] = dataA[i * 1024 * 1024:i * 1024 * 1024 + length] indices[starts[i]:ends[i]] = indicesA[i * 1024 * 1024:i * 1024 * 1024 + length] with numba.objmode(): _signalcopy(i)
def jevolve_branch_probs(brlenQ): """ jitted wrapper to allow scipy call within numba loop """ with objmode(probs='float64[:,:]'): probs = expm(brlenQ) return probs
def unique_arrays(X): inds = np.zeros((X.shape[0], ), dtype=np.int64) with objmode(inds='i8[:]'): inds += argsort_arrays(X) print(inds) u = _unique_arrays(X[inds]) return u
def objmode_func(): """ Wrapper to call py_func from objmode. This tests large kws with objmode. If the definition for the call is not properly updated this test will fail. """ with objmode( a='int64', b='int64', c='int64', d='int64', e='int64', f='int64', g='int64', h='int64', i='int64', j='int64', k='int64', l='int64', m='int64', n='int64', o='int64', p='int64', ): (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = py_func() return (a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p)
def moderror(): with objmode(v1=types.intp, v2=types.THIS_DOES_NOT_EXIST, v3=types.float32): v1 = 12.3 v2 = 12.3 v3 = 12.3 return val
def nn_descent_internal_high_memory( current_graph, data, n_neighbors, rng_state, tried, max_candidates=50, dist=dist.euclidean, n_iters=10, delta=0.001, rho=0.5, verbose=False, ): n_vertices = data.shape[0] for n in range(n_iters): with numba.objmode(): # Call into object mode to temporarily sleep (and thus release GIL) logging.info("(obj mode) high mem nn descent iter.") time.sleep(0.05) if verbose: print("\t", n, " / ", n_iters) (new_candidate_neighbors, old_candidate_neighbors) = new_build_candidates( current_graph, n_vertices, n_neighbors, max_candidates, rng_state, rho ) c = 0 for i in range(n_vertices): for j in range(max_candidates): p = int(new_candidate_neighbors[0, i, j]) if p < 0: continue for k in range(j, max_candidates): q = int(new_candidate_neighbors[0, i, k]) if q < 0 or (p, q) in tried: continue d = dist(data[p], data[q]) c += unchecked_heap_push(current_graph, p, d, q, 1) tried.add((p, q)) if p != q: c += unchecked_heap_push(current_graph, q, d, p, 1) tried.add((q, p)) for k in range(max_candidates): q = int(old_candidate_neighbors[0, i, k]) if q < 0 or (p, q) in tried: continue d = dist(data[p], data[q]) c += unchecked_heap_push(current_graph, p, d, q, 1) tried.add((p, q)) if p != q: c += unchecked_heap_push(current_graph, q, d, p, 1) tried.add((q, p)) if c <= delta * n_neighbors * data.shape[0]: return
def evolution_rate(state_data: np.ndarray, t: float = 0) -> np.ndarray: out = np.empty(data_shape) with nb.objmode(): data_tpl = get_data_tuple(state_data) wrap(data_tpl, t, out) return out
def find_nu(bleps, leptons, met, nu_array): for idx in range(bleps.shape[0]): # blep doesn't exist for this event if (bleps[idx, 3] == -999): continue ## run NS to get nschi2 to be used solver with objmode(): pynusolver.run_nu_solver(leptons[idx], bleps[idx], met[idx], nu_array[idx]) # input order for nusolver is (lepton, jet, met, nu) return nu_array
def foo(): # t1 is a string # t2 is a global type # t3 is a non-local/freevar with objmode(t1="float64", t2=gv_type, t3=array_ty): t1 = 793856.5 t2 = t1 # to observe truncation t3 = np.arange(5).astype(np.int32) return t1, t2, t3
def numpy_algorithm(m: np.ndarray, P: np.ndarray, Q: np.ndarray): # State dimensions n_time = m.shape[0] # Original State Shape gains_shape = m.shape[1:] # Smooth State Vectors ms = np.zeros_like(m) # Smooth Covariance matrices Ps = np.zeros_like(P) G_values = np.zeros_like(P) # Set Initial Smooth Values ms[-1] = m[-1] Ps[-1] = P[-1] # Run Extended Kalman Smoother with # Numpy matrices head = "==> Extended Kalman Smoother (NUMPY|JIT): " for k in range(-2, -(n_time + 1), -1): # Progress Bar in object-mode with objmode(): bar_len = 100 total = n_time - 1 filled_len = int(round(bar_len * (-k - 1) / float(n_time - 1))) bar = u"\u2588" * filled_len + ' '\ * (bar_len - filled_len) print("\r%s%d%%|%s| %d/%d" % (head, (-k - 1) / total * 100, bar, -k - 1, total), end="") # Predict Step mp = gains_vector(m[k]) Pt = P[k].astype(np.complex128) Pp = Pt + Q # Smooth Step Pinv = np.linalg.inv(Pp).astype(np.complex128) G = Pt @ Pinv # Record Posterior Smooth Values e = gains_vector(ms[k + 1]) - mp E = (Ps[k + 1] - Pp).astype(np.complex128) ms[k] = gains_reshape(mp + G @ e, gains_shape) Ps[k] = np.diag(np.diag(Pt + G @ E @ G.T).real) G_values[k] = G.real # Newline print() # Return Posterior smooth states and covariances return ms, Ps, G_values
def warn(msg, file, context=None, return_value=None): with numba.objmode(): print(msg, file=sys.stderr) print("\tfile:", file, file=sys.stderr) if context is not None: print("\tcontext:", file=sys.stderr) for var in context: print("\t\t", var, file=sys.stderr) return return_value
def solve(a, b): with numba.objmode(ret=ret_sig): ret = scipy.linalg.solve_triangular( a, b, lower=lower, # check_finite=check_finite ) return ret
def _chunk_to_polar_njit( images, pimage_shape, delta_r, delta_theta, max_r, find_maximum, direct_beam_positions, ): polar_chunk = np.empty( (images.shape[0], images.shape[1], pimage_shape[0], pimage_shape[1]), dtype=np.float64, ) # somewhat ugly solution because numba does not accept array of None if direct_beam_positions is not None: for idx in prange(images.shape[0]): for idy in prange(images.shape[1]): image = images[idx, idy] with objmode(polar_image="float64[:,:]"): dbp = direct_beam_positions[idx, idy] polar_image = image_to_polar( image, delta_r=delta_r, delta_theta=delta_theta, max_r=max_r, find_direct_beam=find_maximum, direct_beam_position=dbp, ) polar_chunk[idx, idy] = polar_image else: for idx in prange(images.shape[0]): for idy in prange(images.shape[1]): image = images[idx, idy] with objmode(polar_image="float64[:,:]"): polar_image = image_to_polar( image, delta_r=delta_r, delta_theta=delta_theta, max_r=max_r, find_direct_beam=find_maximum, direct_beam_position=None, ) polar_chunk[idx, idy] = polar_image return polar_chunk
def numba_loop(fx, fy, fx_coord, fy_coord, xs, ys, pixelsize, force_shift, out_put_shape, h, E, sigma, u_out, v_out): for i, (f_x, f_y, x, y) in enumerate(zip(fx, fy, fx_coord, fy_coord)): dist_x = xs - x dist_y = ys - y # greens tensor, As are central elements of the tensor # makeing sure coordinates are shifted and distance is never exactly zero ... (maybe just exlude zero????) for i in range(dist_x.shape[0]): for j in range(dist_x.shape[1]): if dist_x[i, j] == 0: dist_x[i, j] += force_shift for i in range(dist_y.shape[0]): for j in range(dist_y.shape[1]): if dist_y[i, j] == 0: dist_y[i, j] += force_shift dist_x = dist_x * pixelsize dist_y = dist_y * pixelsize r = np.sqrt(dist_x**2 + dist_y**2) ### elements of the greens tensor # Usefull parts // this is just an approximation # /also only for sigma=0.49 s = r / h mu = E / (2 * (1 + sigma)) A1 = ((2 - sigma) / (4 * np.pi * mu * h * s)) * (0.12 * np.exp(-0.43 * s) + 0.88 * np.exp(-0.83 * s)) A2 = -(sigma / (4 * np.pi * mu * h * s)) * (1 + 1.22 * s + 1.31 * (s**2.23)) * np.exp(-1.25 * s) # A3_b = ((1-2*sigma)/(4*np.pi*mu*h*s)) # A3 = -0.063 * ((np.exp(-0.44 * s) - np.exp(-2.79 * s)) ** 2)#*A3_b # A4 = ((2 * (1 - sigma)) / (4 * np.pi * mu * h * s)) * (1 + 0.46 * s - 2.50 * (s ** 2.13)) * np.exp(-2.18 * s) # components of the greens tensor K1 = A1 - ((dist_x**2 - dist_y**2) / (r**2)) * A2 K2 = -(2 * dist_x * dist_y / (r**2)) * A2 # K3 = -(dist_x / r) * A3 K4 = -(2 * dist_x * dist_y / (r**2)) * A2 # is K2 K5 = A1 + ((dist_x**2 - dist_y**2) / (r**2)) * A2 def_u = f_x * K1 + f_y * K2 def_v = f_x * K4 + f_y * K5 u_out += def_u v_out += def_v # show_quiver(def_u,def_v) with objmode(): if i % 100 == 0: print("###", i) return u_out, v_out
def perform(*inputs): with numba.objmode(ret=ret_sig): outputs = [[None] for i in range(n_outputs)] op.perform(node, inputs, outputs) outputs = tuple([o[0] for o in outputs]) if n_outputs == 1: ret = outputs[0] else: ret = outputs return ret
def test_objmode(): x = np.arange(5) y = np.zeros_like(x) try: with objmode(y='intp[:]'): # annotate return type # this region is executed by object-mode. y += bar(x) except Exception: pass return y
def render(image, camera, details, start_time, thread_id=0): mempool = jit_core.MemoryPool(NUM_SAMPLES) random.seed(RANDOM_SEED) row_step = CPU_COUNT row_start = thread_id for j in range(row_start, camera.height, row_step): for i in range(camera.width): jj = camera.height - 1 - j ii = camera.width - 1 - i for sx in range(SUPERSAMPLING): for sy in range(SUPERSAMPLING): # compute shade c = np.zeros(3) for _ in range(NUM_SAMPLES): mempool.result[0:3] = 0.0 camera.get_ray(i, j, sx, sy, mempool) start_trace(details, mempool) mempool.result /= NUM_SAMPLES c += mempool.result clamp(c) c /= (SUPERSAMPLING * SUPERSAMPLING) image[jj, ii] += c gamma_correction(image[jj, ii]) with numba.objmode(): p = (j + 1) / camera.height print('. completed : %.2f' % (p * 100.0), ' %') if time.time() != start_time: t = time.time() - start_time estimated_time_left = (1.0 - p) / p * t print(' estimated time left: %.2f sec (threadId %d)' % (estimated_time_left, thread_id)) with numba.objmode(): print('Total intersections : %d (threadId %d)' % (mempool.total_intersection, thread_id)) return mempool.total_intersection
def monopole_data(r, n, domain_index, result): with numba.objmode(): result[0] = 0 for i in range(len(self.q)): pos = np.linalg.norm(r - self.r0[i]) val = self.q[i] * np.exp( 1j * k * pos) / (4 * np.pi * pos) result[0] += -( 1j * self.mu[domain_index][fi] * k * val - val / (pos * pos) * (1j * k * pos - 1) * np.dot(r - self.r0[i], n))
def beam_search(beam: Beam, conflicts: np.ndarray): """ Grows the search tree using beam """ for level in range(1, beam.n): if level == 2: ##### # Starting counting time after first iteration is done # to remove numba compilation time from measurements. # The loss in precision is negligble, the first iteration # contains only two possible child, so the computing of all children # is very cheap. ##### # print("Starting time") with objmode(time_start='f8'): time_start = time.time() index_max = compute_all_children(beam, conflicts, level) commit_children(beam, index_max) clear_children(beam) with objmode(time_search='f8'): time_search = time.time() - time_start return time_search
def homomorphic_filter(image, cutoff_freq=10, a=0.75, b=1.0): """ Performs homomorphic filter on image using gaussian high-frequency filter Implementation is adapted from https://github.com/glasgio/homomorphic-filter to be optimized with Numba :param image: uint8 ndarray to perform homomorphic filter on :param cutoff_freq: Cutoff frequency for Gaussian filter :param a, b: Floats to use on emphasis filter: H = a + b*H. Eg: a=0.5, b=1.5 :return: Filtered image """ # Replace values of 0 with the smallest >0 value, since log cannot be applied to 0. image.ravel()[image.ravel() == 0] = 1e-5 # Take the image to log domain I_log = np.log1p(image) # Take image to frequency domain. Run in Object mode because numba does not support c-compiled np.fft functions. with nb.objmode(I_fft='complex128[:,:]'): I_fft = np.fft.fft2(I_log) # Apply Gaussian Mask P = I_fft.shape[0] / 2 Q = I_fft.shape[1] / 2 with nb.objmode(U='int32[:,:]', V='int32[:,:]'): U, V = np.meshgrid(range(I_fft.shape[0]), range(I_fft.shape[1]), sparse=False, indexing='ij') Duv = (U - P)**2 + (V - Q)**2 H = np.exp((-Duv / (2 * cutoff_freq**2))) # Obtain high-pass filter by taking 1 and subtracting the low pass filter. H = 1 - H # Apply filter on frequency domain then take the image back to spatial domain with nb.objmode(H='float64[:,:]'): H = np.fft.fftshift(H) I_fft_filt = (a + b * H) * I_fft with nb.objmode(I_filt='complex128[:,:]'): I_filt = np.fft.ifft2(I_fft_filt) I = np.exp(np.real(I_filt)) - 1 return I
def generate_hash(tour: np.ndarray, number=333667, module=909090909090909091) -> int: """ Вычисления хеша по туру tour: список вершин number: чьи степени будем искать module: по какому модулю return: хеш """ with nb.objmode(h='int64'): h = generate_hash_from(rotate_zero(tour), number, module) return h
def _get_data(x, dt, a_s, s1, s2, r, normals, observations, true_states): for i, a in enumerate(a_s): with nb.objmode(x='float32[::1]'): F = np.array( [[0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, a], [0, 0, -a, 0]], dtype=np.float32) x = linalg.expm(F * dt) @ x y1 = np.arctan2(x[1] - s1[1], x[0] - s1[0]) + r * normals[i, 0] y2 = np.arctan2(x[1] - s2[1], x[0] - s2[0]) + r * normals[i, 1] observations[i] = [y1, y2] observations[i] = [y1, y2] true_states[i] = np.concatenate((x, np.array([a])))
def _compute_bispectrum(k1bins, k2bins, kn, costheta, kcoords, nsamples, sample_thresh, ndim, dim, shape, progress, exclude, error, compute_point, *ffts): knyq = max(shape) // 2 ntheta = costheta.size bispec = np.full((ntheta, dim, dim), np.nan+1.j*np.nan, dtype=np.complex128) binorm = np.full((ntheta, dim, dim), np.nan, dtype=np.float64) counts = np.full((ntheta, dim, dim), np.nan, dtype=np.float64) omega = np.zeros((dim, dim), dtype=np.int64) stderr = np.full((ntheta, dim, dim), np.nan, dtype=np.float64) for i in range(dim): k1 = kn[i] k1ind = k1bins[i] nk1 = k1ind.size for j in range(i+1): k2 = kn[j] if ntheta == 1 and (exclude and k1 + k2 > knyq): continue k2ind = k2bins[j] nk2 = k2ind.size nsamp = nsamples[i, j] nsamp = int(nsamp) if type(nsamp) is np.int64 \ else max(int(nsamp*nk1*nk2), 1) if nsamp < nk1*nk2 or nsamp > sample_thresh: samp = np.random.randint(0, nk1*nk2, size=nsamp) count = nsamp else: samp = np.arange(nk1*nk2) count = nk1*nk2 bispecbuf = np.zeros(count, dtype=np.complex128) binormbuf = np.zeros(count, dtype=np.float64) cthetabuf = np.zeros(count, dtype=np.float64) if ntheta > 1 \ else np.array([0.], dtype=np.float64) countbuf = np.zeros(count, dtype=np.float64) compute_point(k1ind, k2ind, kcoords, ntheta, nk1, nk2, shape, samp, count, bispecbuf, binormbuf, cthetabuf, countbuf, *ffts) if ntheta == 1: _fill_sum(i, j, bispec, binorm, counts, stderr, bispecbuf, binormbuf, countbuf, error) else: binned = np.searchsorted(costheta, cthetabuf) _fill_binned_sum(i, j, ntheta, binned, bispec, binorm, counts, stderr, bispecbuf, binormbuf, countbuf, error) omega[i, j], omega[j, i] = nk1*nk2, nk1*nk2 if progress: with nb.objmode(): _printProgressBar(i, dim-1) return bispec, binorm, omega, counts, stderr
def numba_algorithm(m: np.ndarray, P: np.ndarray, Q: np.ndarray): # State dimensions n_time = m.shape[0] # Original State Shape gains_shape = m.shape[1:] # Smooth State Vectors ms = np.zeros_like(m) # Smooth Covariance matrices Ps = np.zeros_like(P) G_values = np.zeros_like(P) # Set Initial Smooth Values ms[-1] = m[-1] Ps[-1] = P[-1] # Run Extended Kalman Smoother with # Numpy matrices head = "==> Extended Kalman Smoother (NUMPY|JIT): " for k in range(-2, -(n_time + 1), -1): # Progress Bar in object-mode with objmode(): progress_bar(head, n_time, -k - 1) # Predict Step mp = gains_vector(m[k]) Pt = P[k].astype(np.complex128) Pp = Pt + Q # Smooth Step Pinv = np.diag(1.0 / np.diag(Pp)) G = Pt @ Pinv # Record Posterior Smooth Values e = gains_vector(ms[k + 1]) - mp E = (Ps[k + 1] - Pp).astype(np.complex128) ms[k] = gains_reshape(mp + G @ e, gains_shape) Ps[k] = np.diag(np.diag(Pt + G @ E @ G.T).real) G_values[k] = G.real # Newline print() # Return Posterior smooth states and covariances return ms, Ps, G_values
def get_normal_array(self, n): ''' Get a normal distribuited 1D array with length 'n' ''' x = self.get_array(n) * 2.0 y = np.zeros_like(x) # The JIT has to be disabled because erfcinv is not recognized # by Numba with objmode(y='double[:]'): y = erfcinv(x) return y
def casa_fit(img_to_fit,npix_window,sampling,cutoff,delta): #ellipse_parms = np.zeros(img_to_fit.shape[2:5] + (3,)) ellipse_parms = np.zeros(img_to_fit.shape[2:5] + (3,),dtype=numba.double) img_size = np.array(img_to_fit.shape[0:2]) img_center = img_size//2 start_window = img_center - npix_window//2 end_window = img_center + npix_window//2 + 1 img_to_fit = img_to_fit[start_window[0]:end_window[0],start_window[1]:end_window[1],:,:] d0 = np.arange(0, npix_window[0])*np.abs(delta[0]) d1 = np.arange(0, npix_window[1])*np.abs(delta[1]) interp_d0 = np.linspace(0, npix_window[0]-1, sampling[0])*np.abs(delta[0]) interp_d1 = np.linspace(0, npix_window[1]-1, sampling[1])*np.abs(delta[1]) #xp1, yp1 = np.meshgrid(interp_d0, interp_d1,indexing='ij') d0_shape = interp_d0.shape[0] d1_shape = interp_d1.shape[0] xp = np.repeat(interp_d0,d1_shape).reshape((d0_shape,d1_shape)) yp = np.repeat(interp_d1,d0_shape).reshape((d1_shape,d0_shape)).T points = np.vstack((np.ravel(xp), np.ravel(yp))).T #img_to_fit = np.reshape(interpn((d0,d1),img_to_fit[:,:,0,0],points,method="splinef2d"),[sampling[1],sampling[0]]).T for time in range(img_to_fit.shape[2]): for chan in range(img_to_fit.shape[3]): for pol in range(img_to_fit.shape[4]): with objmode(res_x='f8[:]'): # annotate return type #if True: # this region is executed by object-mode. interp_img_to_fit = np.reshape(interpn((d0,d1),img_to_fit[:,:,time,chan,pol],points,method="splinef2d"),[sampling[1],sampling[0]]).T interp_img_to_fit[interp_img_to_fit<cutoff] = np.nan #print(interp_img_to_fit.shape) # Fit a gaussian to the thresholded points p0 = [2.5, 2.5, 0.] res = optimize.minimize(beam_chi2, p0, args=(interp_img_to_fit, sampling//2)) res_x = res.x # convert to useful units phi = res_x[2] - 90. if phi < -90.: phi += 180. ellipse_parms[time,chan,pol,0] = np.max(np.abs(res_x[0:2]))*np.abs(delta[0])*2.355/(sampling[0]/npix_window[0]) ellipse_parms[time,chan,pol,1] = np.min(np.abs(res_x[0:2]))*np.abs(delta[1])*2.355/(sampling[1]/npix_window[1]) ellipse_parms[time,chan,pol,2] = -phi return ellipse_parms
def foo_nonglobal(x): with numba.objmode(y="float64"): y = inverse(x) return x, y
def foo(x): with objmode(x="intp"): x += int(0x1) return x
def foo(): x = np.arange(5) with objmode(y='intp[:]'): # annotate return type # this region is executed by object-mode. y = x + bar(x) return y