def ampToProb(N, psiN, marked): prob = zeros((N, 1)) probMarked = zeros((N, 1)) for x in range(N): prob[x] += (absolute(psiN[x])**2) probMarked[x] += (absolute(psiN[marked])**2) return prob, probMarked
def default_fill_value(obj): "Function to calculate default fill value for an object." if isinstance(obj, types.FloatType): return default_real_fill_value elif isinstance(obj, types.IntType) or isinstance(obj, types.LongType): return default_integer_fill_value elif isinstance(obj, types.StringType): return default_character_fill_value elif isinstance(obj, types.ComplexType): return default_complex_fill_value elif isinstance(obj, MaskedArray) or isinstance(obj, ndarray): x = obj.dtype.char if x in typecodes["Float"]: return default_real_fill_value if x in typecodes["Integer"]: return default_integer_fill_value if x in typecodes["Complex"]: return default_complex_fill_value if x in typecodes["Character"]: return default_character_fill_value if x in typecodes["UnsignedInteger"]: return umath.absolute(default_integer_fill_value) return default_object_fill_value else: return default_object_fill_value
def test_abs_blocked(self): "simd tests on abs" for dt in [np.float32, np.float64]: for out, inp, msg in _gen_alignment_data(dtype=dt, type='unary', max_size=17): tgt = [ncu.absolute(i) for i in inp] np.absolute(inp, out=out) assert_equal(out, tgt, err_msg=msg) self.assertTrue((out >= 0).all()) # will throw invalid flag depending on compiler optimizations with np.errstate(invalid='ignore'): for v in [np.nan, -np.inf, np.inf]: for i in range(inp.size): d = np.arange(inp.size, dtype=dt) inp[:] = -d inp[i] = v d[i] = -v if v == -np.inf else v assert_array_equal(np.abs(inp), d, err_msg=msg) np.abs(inp, out=out) assert_array_equal(out, d, err_msg=msg) assert_array_equal(-inp, -1 * inp, err_msg=msg) np.negative(inp, out=out) assert_array_equal(out, -1 * inp, err_msg=msg)
def denoise(self, data, wavelet): noiseSigma = median(absolute(data - median(data))) / 0.6745 levels = int(floor(log(len(data)))) WC = pywt.wavedec(data, wavelet, level=levels) threshold = noiseSigma * sqrt(2 * log(len(data))) NWC = map(lambda x: pywt.thresholding.hard(x, threshold), WC) return pywt.waverec(NWC, wavelet)
def approx (a, b, fill_value=1, rtol=1.e-5, atol=1.e-8): """Returns true if all components of a and b are equal subject to given tolerances. If fill_value is 1, masked values considered equal. If fill_value is 0, masked values considered unequal. The relative error rtol should be positive and << 1.0 The absolute error atol comes into play for those elements of b that are very small or zero; it says how small a must be also. """ m = mask_or(getmask(a), getmask(b)) d1 = filled(a) d2 = filled(b) if d1.dtype.char == "O" or d2.dtype.char == "O": return N.equal(d1,d2).ravel() x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_) y = filled(masked_array(d2, copy=False, mask=m), 1).astype(float_) d = N.less_equal(umath.absolute(x-y), atol + rtol * umath.absolute(y)) return d.ravel()
def valueOfGamma(N, H, gamma): x = [] y = [] plotName = "" for h, gamma in zip(hamList2, gammaList2): eigValues = (linalg.eig(h)) maxEig = max((absolute(eigValues[0]))) sndMaxEig = second_largest(absolute(eigValues[0])) x.append(gamma * N[0]) y.append(maxEig - sndMaxEig) plot(x, y) xlabel("γN") ylabel("ΔE") plotName = N[0] savefig( r'/home/jaime/Programming/Jaime-Santos-Dissertation/Results/Simulations/ContQuantumWalk/Search/gamma' + str(plotName)) clf()
def approx(a, b, fill_value=True, rtol=1e-5, atol=1e-8): """Returns true if all components of a and b are equal subject to given tolerances. If fill_value is True, masked values considered equal. Otherwise, masked values are considered unequal. The relative error rtol should be positive and << 1.0 The absolute error atol comes into play for those elements of b that are very small or zero; it says how small a must be also. """ m = mask_or(getmask(a), getmask(b)) d1 = filled(a) d2 = filled(b) if d1.dtype.char == "O" or d2.dtype.char == "O": return np.equal(d1, d2).ravel() x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_) y = filled(masked_array(d2, copy=False, mask=m), 1).astype(float_) d = np.less_equal(umath.absolute(x - y), atol + rtol * umath.absolute(y)) return d.ravel()
def _get_pov_index(point, line, povs): angles = [] for pov in povs: to_gevel = vector(pov, (point[X], point[Y])) dot = line[X] * to_gevel[X] + line[Y] * to_gevel[Y] # dot product det = line[X] * to_gevel[Y] - line[Y] * to_gevel[X] # determinant angle = absolute(arctan2(det, dot) - 0.5 * pi) angles.append(angle) return argmin(array(angles), axis=0)
def staggeredSearchList(N, tSpace, marked, oracleList, completeTessList, thetas, configVec): prob = [] probT = [] for n, oracle, tess, steps, theta in zip(N, oracleList, completeTessList, tSpace, thetas): evol = evo(theta, tess, oracle) psiN = init(n) prob += [absolute(psiN[marked][0])**2] for step in range(1, steps + 1): psiN = evol.dot(psiN) prob += [(absolute(psiN[marked][0])**2)] # print(prob) # pairs.append(((absolute(psiN[marked][0])**2),step)) # stepsAux.append(step) probT.append(prob) #stepsAuxT.append(stepsAux) #print("Experimental steps:%s\tTheoretical Steps:%s\n"%(max(pairs),(pi/4)*sqrt(n))) # pairs = [] # stepsAux = [] prob = [] return probT
def runSearch(N, marked, tSpace, configVec, hamList): prob = [] probT = [] for (n, T, ham) in zip(N, tSpace, hamList): for t in T: evol = evo(ham, t) psiN = fin(n, evol) prob += [(absolute(psiN[marked][0])**2)] #print(prob) # print("Sqrt(N):%s\tprob:%s\n"%(1/n,prob[0])) probT.append(prob) prob = [] return probT
def test_abs_blocked(self): "simd tests on abs" for dt in [np.float32, np.float64]: for out, inp, msg in _gen_alignment_data(dtype=dt, type="unary", max_size=17): tgt = [ncu.absolute(i) for i in inp] np.absolute(inp, out=out) assert_equal(out, tgt, err_msg=msg) self.assertTrue((out >= 0).all()) # will throw invalid flag depending on compiler optimizations with np.errstate(invalid="ignore"): for v in [np.nan, -np.inf, np.inf]: for i in range(inp.size): d = np.arange(inp.size, dtype=dt) inp[:] = -d inp[i] = v d[i] = -v if v == -np.inf else v assert_array_equal(np.abs(inp), d, err_msg=msg) np.abs(inp, out=out) assert_array_equal(out, d, err_msg=msg)
def format_float(x, parens=False): if not np.issubdtype(type(x), np.floating): return str(x) opts = np.get_printoptions() if np.isnan(x): return opts['nanstr'] elif np.isinf(x): return opts['infstr'] exp_format = False if x != 0: a = absolute(x) if a >= 1.e8 or a < 10**min(0, -(opts['precision'] - 1) // 2): exp_format = True trim, unique = '0', True if opts['floatmode'] == 'fixed': trim, unique = 'k', False if exp_format: s = dragon4_scientific(x, precision=opts['precision'], unique=unique, trim=trim, sign=opts['sign'] == '+') if parens: s = '(' + s + ')' else: s = dragon4_positional(x, precision=opts['precision'], fractional=True, unique=unique, trim=trim, sign=opts['sign'] == '+') return s
def _add_independent_index(self): affine_approximation = self._current_affine_combination independent_index = argmax( absolute(affine_approximation - self._current_candidate)) self.independence_indices.append(independent_index)
def get_format_func(self, elem, **options): missing_opt = self.check_options(**options) if missing_opt: raise Exception("Missing options: {}".format(missing_opt)) floatmode = options['floatmode'] precision = None if floatmode == 'unique' else options['precision'] suppress_small = options['suppress_small'] sign = options['sign'] infstr = options['infstr'] nanstr = options['nanstr'] exp_format = False pad_left, pad_right = 0, 0 # only the finite values are used to compute the number of digits finite = umath.isfinite(elem) finite_vals = elem[finite] nonfinite_vals = elem[~finite] # choose exponential mode based on the non-zero finite values: abs_non_zero = umath.absolute(finite_vals[finite_vals != 0]) if len(abs_non_zero) != 0: max_val = np.max(abs_non_zero) min_val = np.min(abs_non_zero) with np.errstate(over='ignore'): # division can overflow if max_val >= 1.e8 or (not suppress_small and (min_val < 0.0001 or max_val / min_val > 1000.)): exp_format = True # do a first pass of printing all the numbers, to determine sizes if len(finite_vals) == 0: trim, exp_size, unique = '.', -1, True elif exp_format: trim, unique = '.', True if floatmode == 'fixed': trim, unique = 'k', False strs = (format_float_scientific(x, precision=precision, unique=unique, trim=trim, sign=sign == '+') for x in finite_vals) frac_strs, _, exp_strs = zip(*(s.partition('e') for s in strs)) int_part, frac_part = zip(*(s.split('.') for s in frac_strs)) exp_size = max(len(s) for s in exp_strs) - 1 trim = 'k' precision = max(len(s) for s in frac_part) # this should be only 1 or 2. Can be calculated from sign. pad_left = max(len(s) for s in int_part) # pad_right is only needed for nan length calculation pad_right = exp_size + 2 + precision unique = False else: trim, unique = '.', True if floatmode == 'fixed': trim, unique = 'k', False strs = (format_float_positional(x, precision=precision, fractional=True, unique=unique, trim=trim, sign=sign == '+') for x in finite_vals) int_part, frac_part = zip(*(s.split('.') for s in strs)) pad_left = max(len(s) for s in int_part) pad_right = max(len(s) for s in frac_part) exp_size = -1 if floatmode in ['fixed', 'maxprec_equal']: precision = pad_right unique = False trim = 'k' else: unique = True trim = '.' # account for sign = ' ' by adding one to pad_left if sign == ' ' and not any(np.signbit(finite_vals)): pad_left += 1 # account for nan and inf in pad_left if len(nonfinite_vals) != 0: nanlen, inflen = 0, 0 if np.any(umath.isinf(nonfinite_vals)): neginf = sign != '-' or np.any(np.isneginf(nonfinite_vals)) inflen = len(infstr) + neginf if np.any(umath.isnan(elem)): nanlen = len(nanstr) offset = pad_right + 1 # +1 for decimal pt pad_left = max(nanlen - offset, inflen - offset, pad_left) def print_nonfinite(x): with errstate(invalid='ignore'): if umath.isnan(x): ret = ('+' if sign == '+' else '') + nanstr else: # isinf infsgn = '-' if x < 0 else '+' if sign == '+' else '' ret = infsgn + infstr return ' ' * (pad_left + pad_right + 1 - len(ret)) + ret if exp_format: def print_finite(x): return format_float_scientific(x, precision=precision, unique=unique, trim=trim, sign=sign == '+', pad_left=pad_left, exp_digits=exp_size) else: def print_finite(x): return format_float_positional(x, precision=precision, unique=unique, fractional=True, trim=trim, sign=sign == '+', pad_left=pad_left, pad_right=pad_right) def fmt(x): if umath.isfinite(x): return print_finite(x) else: return print_nonfinite(x) return fmt
def __call__(self, x): "Execute the call behavior." return umath.less(umath.absolute(umath.cos(x)), self.eps)
def __call__(self, a, b): return umath.absolute(a) * self.tolerance >= umath.absolute(b)
def ampToProb(N, psiN): prob = zeros((N, 1)) for x in range(N): for c in range(N): prob[x] += (absolute(psiN[ket2pos([x, c], [N, N])]))**2 return prob