def shorfactor(n, p_alg=findp, seed=None): random.seed(seed) keepgoing = True guess1 = None guess2 = None global steps g = 2 while (keepgoing): steps += 1 g += 1 #random.randint(2,n-1) if VERBOSE: print("g is ", g) common_den = np.gcd(g, n) if (common_den != 1): if VERBOSE: print("g shares a factor with n, breaking out") result = common_den, n // common_den guessG(n, result[1]) return result p = p_alg(n, g) guess1 = g**(p // 2) + 1 if VERBOSE: print(guess1) guess2 = g**(p // 2) - 1 #print(guess2) if (p % 2 == 1): continue if (guess1 % n == 0): continue if (guess2 % n == 0): continue keepgoing = False factor1 = np.gcd(guess1, n) result = (factor1, n // factor1) guessG(n, result[1]) return (factor1, n // factor1)
def comp_periodicity_spatial(self): """Compute the (anti)-periodicities of the machine in space domain Parameters ---------- self : Machine A Machine object Returns ------- pera : int Number of spatial periodicities of the machine over 2*pi is_apera : bool True if an anti-periodicity is possible after the periodicities """ p = self.get_pole_pair_number() # Get stator (anti)-periodicity in spatial domain pera_s, is_antipera_s = self.stator.comp_periodicity_spatial() # Get rotor (anti)-periodicities in spatial domain pera_r, is_antipera_r = self.rotor.comp_periodicity_spatial() # Get machine spatial periodicity pera = int(gcd(gcd(pera_s, pera_r), p)) # Get machine time and spatial anti-periodicities is_apera = bool(is_antipera_s and is_antipera_r) return pera, is_apera
def poly_template_transform(data, var_names, run_ids=None, growth_pruning=False, num_cross=None, max_deg=2, var_degs=None, v=False, max_relative_degree=None, max_poly_const_terms=1, problem_number=0, drop_high_order_consts=False, limit_poly_terms_to_unique_vars=False): data_dict = {var_names[i]:data[:, i] for i in range(1, len(var_names))} terms_dict = get_poly_template(data, var_names, growth_pruning, run_ids=run_ids, num_cross=num_cross, max_deg=max_deg, var_degs_assigned=var_degs, v=v, max_relative_degree=max_relative_degree, max_poly_const_terms=max_poly_const_terms, limit_poly_terms_to_unique_vars=limit_poly_terms_to_unique_vars, drop_high_order_consts=drop_high_order_consts) if v: print("filtered poly terms: {}".format(", ".join(terms_dict.keys()))) new_data, new_var_names = [], [] term_tuple_list = sorted([(k, v) for k, v in terms_dict.items()]) for i in range(len(term_tuple_list)): term_str, term_degs = term_tuple_list[i] new_var_names.append(term_str) new_col = np.ones(len(data), dtype=np.float) for var, var_deg in term_degs.items(): new_col *= data_dict[var] ** var_deg new_data.append(new_col) if problem_number in ('egcd2', 'egcd3', 'lcm1', 'lcm2'): new_data.append(np.gcd(data_dict['x'].astype(int), data_dict['y'].astype(int))) new_data.append(np.gcd(data_dict['a'].astype(int), data_dict['b'].astype(int))) new_var_names += ['GCD(x,y)', 'GCD(a,b)'] elif problem_number in ('fermat1', 'fermat2'): new_data.append(data_dict['u'].astype(int) % 2) new_data.append(data_dict['v'].astype(int) % 2) new_var_names += ['(% u 2)', '(% v 2)'] new_data = np.asarray(new_data).transpose() return new_data, new_var_names
def getinvmodmat2(A, M): """ :param A: 矩阵 :param M: 模 :return: 模逆矩阵 """ N = len(A) E = np.eye(N, dtype=int) # 单位矩阵 # print(E) A = np.hstack((A, E)) # 合并 print(A) for j in range(N): for i in range(j, N): if np.gcd(A.item(i, j), M) > 1: print(np.gcd(A.item(i, j), M)) continue tmp = mul_inv(A.item(i, j), M) print(j, i, tmp) A[i] *= tmp A[i] %= M if i != j: A[[i, j], :] = A[[j, i], :] break for i in range(N): if i != j: A[i] -= (A.item(i, j) * A[j] % M) # A[i]=A[i]*A.item(j,j)-A[j]*A.item(i,j) A[i] %= M print(A) return A[:, N:N * 2]
def shor(N): if isprime(N): #print('{} is a prime'.format(N)) return -1 if N%2==0: #print('{}: N is even'.format(N)) return 2 for i in range(3,int(np.log2(N))): j=i while(j<=N): if j==N: #print(str(N)+': trivially, N={}^a for some int a'.format(i)) return i j*=i while(1): x=random.randint(2,int(np.sqrt(N))) if (np.gcd(x,N)!=1): #print('{}: by randoming, got factor {}'.format(N,np.gcd(x,N))) return(np.gcd(x,N)) #print('Attempting: N={}, x={}'.format(N,x)) r=classical_find_r_U(x,N) #print('found r={}'.format(r)) if (r%2==1): continue #print('(N,x,r)=({},{},{})'.format(N,x,r)) a=np.gcd((x**(int(r/2))-1)%N,N) #print('a={}, ie {}'.format(a, int(a))) if (a==1 or a==N): continue print('{}: Found (N,x,r)={},{},{} with factor {}'.format(N,N,x,r,np.gcd(int(a),N))) return np.gcd(int(a), N)
def mask_sphere(self, radius, cx, cy, cz): """ Create a mask for a sphere with radius=radius, centered at cx, cy, cz. Args: radius: (flaot) of the mask (in Angstroms) cx, cy, cz: (float) the fractional coordinates of the center of the sphere """ dx, dy, dz = ( np.floor(radius / np.linalg.norm(self.X)).astype(int), np.floor(radius / np.linalg.norm(self.Y)).astype(int), np.floor(radius / np.linalg.norm(self.Z)).astype(int), ) gcd = max(np.gcd(dx, dy), np.gcd(dy, dz), np.gcd(dx, dz)) sx, sy, sz = dx // gcd, dy // gcd, dz // gcd r = min(dx, dy, dz) x0, y0, z0 = int(np.round(self.NX * cx)), int(np.round(self.NY * cy)), int(np.round(self.NZ * cz)) centerx, centery, centerz = self.NX // 2, self.NY // 2, self.NZ // 2 a = np.roll(self.data, (centerx - x0, centery - y0, centerz - z0)) i, j, k = np.indices(a.shape, sparse=True) a = np.sqrt((sx * i - sx * centerx) ** 2 + (sy * j - sy * centery) ** 2 + (sz * k - sz * centerz) ** 2) indices = a > r a[indices] = 0 return a
def makeslab(self, miller_index, length=-1.0, layer=-1, method="bf", origin_shift=0.0, vacuum=15.0): ''' self is unit-cell ''' P=np.mat(np.eye(3, dtype=np.float64)) h,k,l=miller_index e=np.gcd(h, np.gcd(k,l)) if e>1: h=h//e k=k//e l=l//e print("find miller index ( ",h,k,l," ) instead.") if h==0 and k==0 and l==0: print("miller_index cannot be 0 0 0!") raise AssertionError elif h==0 and k==0: P[2,2]=layer elif k==0 and l==0: # slab not along z P[0,0]=layer elif h==0 and l==0: P[1,1]=layer else: p,q, _ =ext_euclid(k,l) c1,c2,c3=self.cell k1=np.dot(p*(k*c1-h*c2)+q*(l*c1-h*c3), l*c2-k*c3) k2=np.dot(l*(k*c1-h*c2)-k*(l*c1-h*c3), l*c2-k*c3) if np.fabs(k2) > self.eps1: i=-int(round(k1/k2)) p,q=p+i*l,q-i*k P[0]=(p * k + q * l, -p * h, -q * h) P[1]=np.array((0, l, -k)) // abs(np.gcd(l, k)) P[2]=(h,k,l) P[2]*=layer P=P.T if np.linalg.det(P)<0: P[0,2]*=-1 P[1,2]*=-1 P[2,2]*=-1 print("P1 = ", P) slab=CELL.cell2supercell(self,P) slab.cell_redefine() slab.add_vacuum(vacuum) reduced_slab=CELL.reduce_slab(slab) print("reduced slab cell \n", reduced_slab.cell) ang_B=fan(reduced_slab.cell[0],reduced_slab.cell[1]) edg_a=np.linalg.norm(reduced_slab.cell[0]) edg_c=np.linalg.norm(reduced_slab.cell[1]) print("reduced slab No. of atoms: ", reduced_slab.nat) print("slab and vacuum length: ", abs(reduced_slab.cell[2,2])-reduced_slab.get_vac(), reduced_slab.get_vac(), "Ang.") print("inplane edge and angle: ", edg_a, edg_c," Ang. ", ang_B," degree.") print("reduced slab cell area: ", np.sin(ang_B/180*np.pi)*edg_a*edg_c, " Ang^2.") return reduced_slab
def eratosthenes(n, lim): Beta = [-1, 2] for num in PRIMES[1:]: if gmpy2.legendre(n, num) == 1: Beta.append(num) if len(Beta) == lim - 1: break m = int(math.sqrt(n)) df = pd.DataFrame({ 'x': interval, 'x + m': [x + m for x in interval], 'b': [q(x, m, n) for x in interval] }) df['lg|b|'] = [math.log(abs(b), 10) for b in df['b']] for p in Beta[1:]: X = [] for x in congruence(m, n, p): X = find_x('+', X, x, p, lim) X = find_x('-', X, x, p, lim) if X == []: Beta.remove(p) else: df[f'lg{p}'] = [(1 if df['x'][i] in X else 0) for i in range(len(interval))] if sum(df[f'lg{p}'].values) == 1: del df[f'lg{p}'] Beta.remove(p) diff = [] for i in range(len(interval)): ans = df['lgb'][i] for p in Beta[1:]: ans -= math.log(p, 10) * df[f'lg{p}'][i] diff.append(ans) df['lg|b| - lgp'] = diff potential_Beta_numbers = df['b'][ df['lg|b| - lgp'] < np.mean(df['lg|b| - lgp'])].values.tolist() vectors, Beta_numbers = [], [] for num in potential_Beta_numbers: factorization = factorization_small_n(num) if np.in1d(factorization, Beta).all(): Beta_numbers.append(num) vectors.append([factorization.count(j) for j in Beta]) df['v'] = [(vectors[Beta_numbers.index(num)] if num in Beta_numbers else 'Not Beta') for num in df['b']] for comb in combination(vectors): if sum_vectors(comb) == len(Beta) * [0]: X, Y = 1, 1 for v in comb: X *= int( df['x + m'][df['b'] == Beta_numbers[vectors.index(v)]]) Y *= int(abs(Beta_numbers[vectors.index(v)])) Y = int(math.sqrt(Y)) d = np.gcd(X + Y, n) if 1 < d < n: return d, df d = np.gcd(X - Y, n) if 1 < d < n: return d, df return 0
def _gcd_recursive(*args): """ Get the greatest common denominator among any number of ints """ if len(args) == 2: return np.gcd(*args) else: return np.gcd(args[0], _gcd_recursive(*args[1:]))
def getqpm(rate, bdepth, maxp=100): """Return integer (q,p,m) such that q/p ~ rate, m/p ~ bdepth.""" denom = np.arange(maxp, dtype=np.int64) + 1 rerr, berr = denom * rate, denom * bdepth err = (rerr - np.floor(rerr) + berr - np.floor(berr)) / denom p = denom[np.argmin(err)] q = np.int64(np.floor(rate * p)) m = np.int64(np.floor(bdepth * p)) gcd = np.gcd(np.gcd(q, p), m) return q // gcd, p // gcd, m // gcd
def find_co_prime_stochastic(n): """ Find a factor that is coprime with n randomly. :param n: The number that should be factored into primes. :return: A number co-prime with n. """ a = int(np.random.randint(2, high=n)) if np.gcd(n, a) != 1: return -np.gcd(n, a) return a
def run(self, fnprovider): fns = {} size = 1500 fn = fnprovider.get_filename('.png', 'pairwise') fns['Are pairwise divisible'] = fn Image.fromarray( np.fromfunction( lambda x, y: 255 * np.uint8(np.gcd(x + 1, y + 1) != 1), shape=(size, size), dtype=np.uint32), 'L').save(fn) fn = fnprovider.get_filename('.png', 'gcd') fns['GCD / MAX'] = fn Image.fromarray( np.fromfunction(lambda x, y: np.uint8( np.gcd(x + 1, y + 1) * 255 / np.maximum(x + 1, y + 1)), shape=(size, size), dtype=np.uint32), 'L').save(fn) fn = fnprovider.get_filename('.png', 'gcdmod') fns['GCD mod time'] = fn stepsmod: np.ndarray = np.fromfunction( lambda x, y: np.vectorize(gcd_mod)(x + 1, y + 1), shape=(size, size), dtype=np.uint32) stepsmod_n = stepsmod * 255 / np.max(stepsmod) Image.fromarray(np.uint8(stepsmod_n), 'L').save(fn) fn = fnprovider.get_filename('.png', 'gcdsub') fns['GCD sub time'] = fn stepssub: np.ndarray = np.fromfunction( lambda x, y: np.vectorize(gcd_sub)(x + 1, y + 1), shape=(size, size), dtype=np.uint32) stepssub_n = stepssub * 255 / np.max( stepssub) # Normalize the step counts Image.fromarray(np.uint8(stepssub_n), 'L').save(fn) fn = fnprovider.get_filename('.png', 'gcdboth') fns['both GCD (blue = SUB, red = MOD) (log scale)'] = fn stepssub = np.log(stepssub) stepsmod = np.log(stepsmod) mx = max(np.max(stepssub), np.max(stepsmod)) stepssub_n2 = np.uint8(stepssub * 255 / mx) stepsmod_n2 = np.uint8(stepsmod * 255 / mx) Image.fromarray( np.dstack((stepssub_n2, np.zeros( (size, size), dtype=np.uint8), stepsmod_n2)), 'RGB').save(fn) return ',\n'.join('{}: {}'.format(i, j) for i, j in fns.items())
def CFRAC_Brillhart_Morrison(n, lim, v=1, Beta=[-1, 2], d=0): TABLE = pd.DataFrame({ 'S': ['a', 'bmodn', 'b^2modn'], '-1': ['-', 1, 1] }).set_index('S') alpha = math.sqrt(n) a = int(alpha) u = a b = counting_b2(a, n) TABLE['0'] = [a, a, b] Beta, w = update_factor_base(Beta, n, b, [], TABLE, lim) it = 1 while True: v1 = (n - u**2) / v alpha1 = (alpha + u) / v1 a1 = int(alpha1) u1 = v1 * a1 - u b = (a1 * TABLE[f'{it-1}'][1] + TABLE[f'{it-2}'][1]) % n b2 = counting_b2(b, n) TABLE[f'{it}'] = [a1, b, b2] Beta, w = update_factor_base(Beta, n, b2, w, TABLE, lim) for comb in combination(w): if sum_vectors(comb) == (len(Beta)) * [0]: X, Y = 1, 1 for vec in comb[:-1]: X = float(X * TABLE[f'{w.index(vec)}'][1] % n) Y = float(Y * TABLE[f'{w.index(vec)}'][2]) X = X * TABLE[f'{it}'][1] % n Y = math.sqrt(Y * TABLE[f'{it}'][2]) d1 = np.gcd(int(X + Y), n) if 1 < d1 < n: d = d1 break else: d2 = np.gcd(int(X - Y), n) if 1 < d2 < n: d = d2 break if d == 0: it += 1 if it > 21: return 0 u = u1 v = v1 a = a1 else: print(TABLE) print('\nФактор-база: ', Beta) for vec in comb[:-1]: print(f'\nν_{w.index(vec)} = {w[w.index(vec)]}') print(f'\nν_{it} = {w[it]}') return d
def rational_sum(numerator, denominator, *argv): """Sum of rational numbers.""" if len(argv) < 2: gcd = numpy.gcd(numerator, denominator) num_out, den_out = numerator//gcd, denominator//gcd else: num_2 = argv[0] den_2 = argv[1] num_3 = numerator*den_2 + num_2*denominator den_3 = denominator*den_2 gcd = numpy.gcd(num_3, den_3) num_out, den_out = rational_sum(num_3//gcd, den_3//gcd, argv[2:]) return num_out, den_out
def addell(p1, p2, a, b, n): '''This function add points on the elliptic curve y^2 = x^3 + ax + b mod n The points are represented by p1(1) = x1 p1(2) = y1 p2(1) = x2 p2(2) = y2''' if p1[0] == Inf and p1[1] == Inf: return p2 if p2[0] == Inf and p2[1] == Inf: return p1 x1 = p1[0] x2 = p2[0] y1 = p1[1] y2 = p2[1] z1 = 1 # this will store the gcd incase the addition produced a factor of n if (x1 == x2) and ((y1 == y2 == 0) or (y1 != y2)): # infinity cases return (inf, inf) if p1 == p2 and np.gcd(y1, n) != 1 and np.gcd(y1, n) != n: z1 = np.gcd(y1, n) #print('Elliptic Curve addition produced a factor of n, factor = ', z1) return (z1, ) if p1 == p2: temp = np.mod(2 * y1, n) if temp == 0: return (inf, inf) den = invmodn(2 * y1, n) num = np.mod(x1 * x1, n) num = np.mod(np.mod(3 * num, n) + a, n) else: # case p1 ~= p2 if np.gcd(x2 - x1, n) != 1: #print('Elliptic Curve addition produced a factor of n, factor = ', np.gcd(x2 - x1, n)) return (np.gcd(x2 - x1, n), ) temp = np.mod(x2 - x1, n) if np.mod(n, temp) == 0: # Infinity case return (inf, inf) den = invmodn(temp, n) num = np.mod(y2 - y1, n) m = np.mod(num * den, n) temp = np.mod(m * m, n) x3 = np.mod(temp - x1 - x2, n) temp = x1 - x3 y3 = np.mod(m * temp, n) y3 = np.mod(y3 - y1, n) return (x3, y3)
def compute_shors(self): """ Putting the states through shor's\n @return: Output of Shors \n """ thing = Shors.compute_r(self) r = Shors.cf(self, thing) while r % 2 != 0: r = Shors.cf(self, Shors.compute_r(self)) a1 = int((self.a**(r / 2)) - 1) a2 = int((self.a**(r / 2)) + 1) a1 = int((self.a**(r / 2)) - 1) a2 = int((self.a**(r / 2)) + 1) return np.gcd(a1, self.N), np.gcd(a2, self.N)
def dS(p, q, i): # checking input values are positive integers if ((not isinstance(p, int)) or (p <= 0)): raise Exception('p must be a positive integer. p was {}.'.format(p)) # if ((not isinstance(q, int)) or (q <= 0)): # raise Exception('q must be a positive integer. q was {}.'.format(q)) if ((not isinstance(i, int)) or (i < 0)): raise Exception( 'i must be a non-negative integer. i was {}.'.format(i)) # checking p and q are coprime if (np.gcd(p, q) != 1): raise Exception('p and q must be coprime.') # we terminate if p = 1 if (p == 1): return Fraction(0, 1) q = q % p i = i % p r = Fraction(((((2 * i) + 1 - p - q)**2) - p * q), (4 * p * q)) # our recursive step is safe since we have checked for bad input and reduced q and i mod p. return r - dS(q, p, i)
def preprocess(stream): # time alignment start_time = max([trace.stats.starttime for trace in stream]) end_time = min([trace.stats.endtime for trace in stream]) if start_time>end_time: print('bad data!'); return [] st = stream.slice(start_time, end_time) # resample data org_rate = int(st[0].stats.sampling_rate) rate = np.gcd(org_rate, samp_rate) if rate==1: print('warning: bad sampling rate!'); return [] decim_factor = int(org_rate / rate) resamp_factor = int(samp_rate / rate) st = st.decimate(decim_factor) if resamp_factor!=1: st = st.interpolate(samp_rate) # filter st = st.detrend('demean').detrend('linear').taper(max_percentage=0.05, max_length=10.) freq_min, freq_max = freq_band if freq_min and freq_max: return st.filter('bandpass', freqmin=freq_min, freqmax=freq_max) elif not freq_max and freq_min: return st.filter('highpass', freq=freq_min) elif not freq_min and freq_max: return st.filter('lowpass', freq=freq_max) else: print('filter type not supported!'); return []
def zero_determinant_binary_reduction(form): if form.det() != 0: raise Exception("The determinant of the form", form, "isn't zero.") a = form[0, 0] b = form[0, 1] c = form[1, 1] if a == 0: raise Exception( "Something's wrong. This method shouldn't have been called, right?" ) m = np.gcd(a, c) # Why math and not numpy? Because numpy yields a stupid error. It's easier just to use math in this case. g = int(math.sqrt(a // m)) h = int(math.sqrt(c // m)) if g * h != b // m: h *= -1 _, goth_g, goth_h = xgcd(g, h) return Matrix([[h, h + goth_g], [-g, -g + goth_h]])
def are_pairwise_coprime(l): return functools.reduce( lambda x, y: x and y, list( map(lambda t: np.gcd(t[0], t[1]) == 1, [[l[i], l[j]] for i in range(len(l)) for j in range(len(l)) if i != j])))
def resample(self, data, src_rate=30, dst_rate=50, axis=0): """ Upsamples data using FFT """ denom = np.gcd(dst_rate, src_rate) new_data = signal.resample_poly(data, dst_rate/denom, src_rate/denom, axis) return new_data
def _resample_window_oct(p, q): """Port of Octave code to Python""" gcd = np.gcd(p, q) if gcd > 1: p /= gcd q /= gcd # Properties of the antialiasing filter log10_rejection = -3.0 stopband_cutoff_f = 1. / (2 * max(p, q)) roll_off_width = stopband_cutoff_f / 10 # Determine filter length rejection_dB = -20 * log10_rejection L = np.ceil((rejection_dB - 8) / (28.714 * roll_off_width)) # Ideal sinc filter t = np.arange(-L, L + 1) ideal_filter = 2 * p * stopband_cutoff_f \ * np.sinc(2 * stopband_cutoff_f * t) # Determine parameter of Kaiser window if (rejection_dB >= 21) and (rejection_dB <= 50): beta = 0.5842 * (rejection_dB - 21)**0.4 \ + 0.07886 * (rejection_dB - 21) elif rejection_dB > 50: beta = 0.1102 * (rejection_dB - 8.7) else: beta = 0.0 # Apodize ideal filter response h = np.kaiser(2 * L + 1, beta) * ideal_filter return h
def main(): # read input with open("input", 'r') as inhandle: arrival = int(next(inhandle).strip()) busses = next(inhandle).strip().split(",") #least_min_waited, earliest_bus_number = find_earliest_bus(arrival, busses) #print(f"min waited: {least_min_waited}, bus num: {earliest_bus_number}, product: {least_min_waited*earliest_bus_number}") a = [] n = [] for i, bus in enumerate(busses): if bus == 'x': continue print(f"bus {bus} at time t + {i}") a.append(i) n.append(int(bus)) # check pairwaise coprime for i in n: for j in n: if i == j: continue if np.gcd(i, j) != 1: print(f"{i}, {j} are not coprime") i = satisfy_constraints(busses) print(int(i)) print()
def calc1(data): a = np.array([list(line) for line in data.split()]) coords = np.argwhere(a.T == '#') # print('coords', coords) counts = np.zeros(coords.shape[0], int) for i in range(len(coords)): cx, cy = coords[i] rest = np.delete(coords, i, axis=0) rest -= coords[i] # print('considering:', cx, cy) # print('rebased', rest) rest = np.array(sorted(rest, key=lambda p: np.max(np.abs(p)))) # print('sorted', rest) masked = np.zeros(len(rest), bool) for j in range(len(rest)-1): if masked[j]: continue # print('masking:', rest[j]) x, y = rest[j] // np.gcd(*rest[j]) # eg (4, 2) masks (2, 1), (4, 2), (6, 3) # multiples ds = rest[j+1:,0] * y == rest[j+1:,1] * x # print(ds) # same quarter q = ((rest[j+1:] * rest[j]) >= 0).all(axis=1) # print(q) masked[j+1:] = masked[j+1:] | (ds & q) # print('result:', masked) # print('amsked:', masked) sees = (~masked).sum() counts[i] = sees return coords, counts
def med(x): ''' Calculate the middle divisor. This program is used to determine the optimal grid line spacing for regional maps. Usage: y = med(x) Inputs: x -> [int] The longitude or latitude span of a map. It cannot be a prime number. Outputs: y -> [int] the optimal grid line spacing Examples: >>> print(med(20)) 4 >>> print(med(25)) 5 ''' y = np.unique(np.gcd(np.arange(x),x)) n = len(y) if n%2 == 1: return y[n//2] else: return y[n//2-1]
def zcsequence(u, seq_length, q=0): """ Generate a Zadoff-Chu (ZC) sequence. Parameters ---------- u : int Root index of the the ZC sequence: u>0. seq_length : int Length of the sequence to be generated. Usually a prime number: u<seq_length, greatest-common-denominator(u,seq_length)=1. q : int Cyclic shift of the sequence (default 0). Returns ------- zcseq : 1D ndarray of complex floats ZC sequence generated. """ for el in [u, seq_length, q]: if not float(el).is_integer(): raise ValueError('{} is not an integer'.format(el)) if u <= 0: raise ValueError('u is not stricly positive') if u >= seq_length: raise ValueError('u is not stricly smaller than seq_length') if np.gcd(u, seq_length) != 1: raise ValueError( 'the greatest common denominator of u and seq_length is not 1') cf = seq_length % 2 n = np.arange(seq_length) zcseq = np.exp(-1j * np.pi * u * n * (n + cf + 2. * q) / seq_length) return zcseq
def main(): continueflag = '' while continueflag != 'quit': #get and validate operation from user operation = input('encipher (e) or decipher (d): ') while operation != 'e' and operation != 'd': operation = input('encipher (e) or decipher (d): ') message = input('message: ') #get the a and b keys flag = False while not flag: try: a = int(input('a: ')) b = int(input('b: ')) #make sure a and m (the length #of the alphabet) are coprime if np.gcd(a, len(ALPHABET)) == 1: flag = True else: print(f'length of alphabet, m, is {len(ALPHABET)}') print('a and m must be coprime') #make sure a and b are integers except TypeError: pass if operation == 'e': ciphertext = encipher(message, a, b) print(f'ciphertext: {ciphertext}') else: plaintext = decipher(message, a, b) print(f'plaintext: {plaintext}') #see if the user wants to quit continueflag = input("'quit' to quit: ") print('exiting')
def phi(n): num = 0 for i in range(1, n): if np.gcd(i, n) == 1: num += 1 return num
def _get_n_batches_and_batch_sizes( n1: int, n2: int, batch_size: int, device_count: int) -> Tuple[int, int, int, int]: # TODO(romann): if dropout batching works for different batch sizes, relax. max_serial_batch_size = onp.gcd(n1, n2) // device_count n2_batch_size = min(batch_size, max_serial_batch_size) if n2_batch_size != batch_size: warnings.warn( 'Batch size is reduced from requested %d to effective %d to ' 'fit the dataset.' % (batch_size, n2_batch_size)) n1_batch_size = n2_batch_size * device_count n1_batches, ragged = divmod(n1, n1_batch_size) if ragged: # TODO(schsam): Relax this constraint. msg = ( 'Number of rows of kernel must divide batch size. Found n1 = {} ' 'and batch size = {}.').format(n1, n1_batch_size) if device_count > 1: msg += ( ' Note that device parallelism was detected and so the batch ' 'size was expanded by a factor of {}.'.format(device_count)) raise ValueError(msg) n2_batches, ragged = divmod(n2, n2_batch_size) if ragged: # TODO(schsam): Relax this constraint. raise ValueError(('Number of columns of kernel must divide batch ' 'size. Found n2 = {} ' 'and batch size = {}').format(n2, n2_batch_size)) return n1_batches, n1_batch_size, n2_batches, n2_batch_size
def get_visible(coord, mapp): direction_bins = {} for tgt in mapp: if np.array_equal(tgt, coord): continue diff = tgt - coord x = diff[0] y = diff[1] n = np.gcd(x, y) distance = np.linalg.norm(diff) direction = tuple(diff / n) # print("{:10s} {:10d} {:10g} {:20s}".format(str(tgt),n,distance,str(direction))) if not direction in direction_bins: direction_bins[direction] = [] direction_bins[direction].append((distance, tgt)) angle_bins = {my_angle(d): sorted(v) for d, v in direction_bins.items()} # for angle in angle_bins: # print("{:15s} {}".format(str(angle),angle_bins[angle])) return angle_bins
def resample(y, orig_sr, target_sr, res_type='kaiser_best', fix=True, scale=False, **kwargs): """Resample a time series from orig_sr to target_sr Parameters ---------- y : np.ndarray [shape=(n,) or shape=(2, n)] audio time series. Can be mono or stereo. orig_sr : number > 0 [scalar] original sampling rate of `y` target_sr : number > 0 [scalar] target sampling rate res_type : str resample type (see note) .. note:: By default, this uses `resampy`'s high-quality mode ('kaiser_best'). To use a faster method, set `res_type='kaiser_fast'`. To use `scipy.signal.resample`, set `res_type='fft'` or `res_type='scipy'`. To use `scipy.signal.resample_poly`, set `res_type='polyphase'`. .. note:: When using `res_type='polyphase'`, only integer sampling rates are supported. fix : bool adjust the length of the resampled signal to be of size exactly `ceil(target_sr * len(y) / orig_sr)` scale : bool Scale the resampled signal so that `y` and `y_hat` have approximately equal total energy. kwargs : additional keyword arguments If `fix==True`, additional keyword arguments to pass to `librosa.util.fix_length`. Returns ------- y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)] `y` resampled from `orig_sr` to `target_sr` Raises ------ ParameterError If `res_type='polyphase'` and `orig_sr` or `target_sr` are not both integer-valued. See Also -------- librosa.util.fix_length scipy.signal.resample resampy.resample Notes ----- This function caches at level 20. Examples -------- Downsample from 22 KHz to 8 KHz >>> y, sr = librosa.load(librosa.util.example_audio_file(), sr=22050) >>> y_8k = librosa.resample(y, sr, 8000) >>> y.shape, y_8k.shape ((1355168,), (491671,)) """ # First, validate the audio buffer util.valid_audio(y, mono=False) if orig_sr == target_sr: return y ratio = float(target_sr) / orig_sr n_samples = int(np.ceil(y.shape[-1] * ratio)) if res_type in ('scipy', 'fft'): y_hat = scipy.signal.resample(y, n_samples, axis=-1) elif res_type == 'polyphase': if int(orig_sr) != orig_sr or int(target_sr) != target_sr: raise ParameterError('polyphase resampling is only supported for integer-valued sampling rates.') # For polyphase resampling, we need up- and down-sampling ratios # We can get those from the greatest common divisor of the rates # as long as the rates are integrable orig_sr = int(orig_sr) target_sr = int(target_sr) gcd = np.gcd(orig_sr, target_sr) y_hat = scipy.signal.resample_poly(y, target_sr // gcd, orig_sr // gcd, axis=-1) else: y_hat = resampy.resample(y, orig_sr, target_sr, filter=res_type, axis=-1) if fix: y_hat = util.fix_length(y_hat, n_samples, **kwargs) if scale: y_hat /= np.sqrt(ratio) return np.ascontiguousarray(y_hat, dtype=y.dtype)