def test_log2(self): """log2: should work fine on positive/negative numbers and zero""" self.assertEqual(log2(1),0) self.assertEqual(log2(2),1) self.assertEqual(log2(4),2) self.assertEqual(log2(8),3) #SUPPORT2425 #with numpy_err(divide='ignore'): ori_err = numpy.geterr() numpy.seterr(divide='ignore') try: try: self.assertEqual(log2(0),float('-inf')) except (ValueError, OverflowError): #platform-dependent pass finally: numpy.seterr(**ori_err) #SUPPORT2425 ori_err = numpy.geterr() numpy.seterr(divide='raise') try: #with numpy_err(divide='raise'): self.assertRaises(FloatingPointError, log2, 0) finally: numpy.seterr(**ori_err) #nan is the only thing that's not equal to itself try: self.assertNotEqual(log2(-1),log2(-1)) #now nan except ValueError: pass
def less(a, b): """return a < b, while comparing nan results in False without warning""" current_err_setting = np.geterr() np.seterr(invalid='ignore') res = a < b np.seterr(**current_err_setting) return res
def H_mag(num, den, z, H_max, H_min = None, log = False, div_by_0 = 'ignore'): """ Calculate `|H(z)|` at the complex frequency(ies) `z` (scalar or array-like). The function `H(z)` is given in polynomial form with numerator and denominator. When log = True, `20 log_10 (|H(z)|)` is returned. The result is clipped at H_min, H_max; clipping can be disabled by passing None as the argument. Parameters ---------- num : float or array-like The numerator polynome of H(z). den : float or array-like The denominator polynome of H(z). z : float or array-like The complex frequency(ies) where `H(z)` is to be evaluated H_max : float The maximum value to which the result is clipped H_min : float, optional The minimum value to which the result is clipped (default: 0) log : boolean, optional When true, return 20 * log10 (|H(z)|). The clipping limits have to be given as dB in this case. div_by_0 : string, optional What to do when division by zero occurs during calculation (default: 'ignore'). As the denomintor of H(z) becomes 0 at each pole, warnings are suppressed by default. This parameter is passed to numpy.seterr(), hence other valid options are 'warn', 'raise' and 'print'. Returns ------- H_mag : float or ndarray The magnitude |`H(z)`| for each value of `z`. """ try: len(num) except TypeError: num_val = abs(num) # numerator is a scalar else: num_val = abs(np.polyval(num, z)) # evaluate numerator at z try: len(den) except TypeError: den_val = abs(den) # denominator is a scalar else: den_val = abs(np.polyval(den, z)) # evaluate denominator at z olderr = np.geterr() # store current floating point error behaviour # turn off divide by zero warnings, just return 'inf': np.seterr(divide = 'ignore') if log: H_val = 20 * np.log10(num_val / den_val) else: H_val = num_val / den_val np.seterr(**olderr) # restore previous floating point error behaviour # clip result to H_min / H_max return np.clip(H_val, H_min, H_max)
def test_numerical_stability(): """Check numerical stability.""" old_settings = np.geterr() np.seterr(all="raise") X = np.array( [ [152.08097839, 140.40744019, 129.75102234, 159.90493774], [142.50700378, 135.81935120, 117.82884979, 162.75781250], [127.28772736, 140.40744019, 129.75102234, 159.90493774], [132.37025452, 143.71923828, 138.35694885, 157.84558105], [103.10237122, 143.71928406, 138.35696411, 157.84559631], [127.71276855, 143.71923828, 138.35694885, 157.84558105], [120.91514587, 140.40744019, 129.75102234, 159.90493774], ] ) y = np.array([1.0, 0.70209277, 0.53896582, 0.0, 0.90914464, 0.48026916, 0.49622521]) dt = tree.DecisionTreeRegressor() dt.fit(X, y) dt.fit(X, -y) dt.fit(-X, y) dt.fit(-X, -y) np.seterr(**old_settings)
def VMLookupTable(): try: # try loading ordered dict from collections import OrderedDict except ImportError: # not installed, try on pythonpath try: from OrderedDict import OrderedDict except ImportError: "PyNoddy requires OrderedDict to run. Please download it and make it available on the pythonpath." kappa_lookup = OrderedDict() #disable numpy warnings err = np.geterr() np.seterr(all='ignore') # build lookup table for k in range(1000, 100, -20): ci = sc.stats.vonmises.interval(0.95, k) kappa_lookup[ci[1]] = k for k in range(100, 10, -1): ci = sc.stats.vonmises.interval(0.95, k) kappa_lookup[ci[1]] = k for k in np.arange(10, 0, -0.1): ci = sc.stats.vonmises.interval(0.95, k) kappa_lookup[ci[1]] = k #re-enable numpy warnings np.seterr(**err) # return lookup table return kappa_lookup
def setUp(self): # Most generic way to get the actual data directory. self.data_dir = os.path.join(os.path.dirname(os.path.abspath( inspect.getfile(inspect.currentframe()))), "data") self.image_dir = os.path.join(os.path.dirname(__file__), 'images') self.nperr = np.geterr() np.seterr(all='ignore')
def test_ppsd_plot_cumulative(self): """ Test plot of ppsd example data, cumulative style. """ # Catch underflow warnings due to plotting on log-scale. _t = np.geterr() np.seterr(all="ignore") try: with ImageComparison(self.path, 'ppsd_cumulative.png', reltol=1.5) as ic: self.ppsd.plot( show=False, show_coverage=True, show_histogram=True, show_noise_models=True, grid=True, period_lim=(0.02, 100), cumulative=True, # This does not do anything but silences a warning that # the `cumulative` and `max_percentage` arguments cannot # be used at the same time. max_percentage=None) fig = plt.gcf() ax = fig.axes[0] ax.set_ylim(-160, -130) plt.draw() fig.savefig(ic.name) finally: np.seterr(**_t)
def __init__(self, hidden_layers=[32]): restore_these_settings = np.geterr() temp_settings = restore_these_settings.copy() temp_settings["over"] = "ignore" temp_settings["under"] = "ignore" np.seterr(**temp_settings) np.seterr(**restore_these_settings) self.input_nodes = 65 # number of input nodes + 1 for the bias self.hidden_layers = hidden_layers # list containing the number of hidden nodes and number of nodes per layer self.output_nodes = 10 # number of output nodes self.alpha = 1.0 # scalar used when back propagating the errors # initialize the weights which are is a list of nxm 2d arrays where each weight corresponds to a layer self.weights = [ np.random.random_sample((self.input_nodes, self.hidden_layers[0])) * .09 + .01 ] for i in range(len(hidden_layers) - 1): self.weights.append( np.random.random_sample((self.hidden_layers[i], self.hidden_layers[i + 1])) * .09 + .01) self.weights.append( np.random.random_sample((self.hidden_layers[-1], self.output_nodes)) * .09 + .01)
def test_numpy_err_state_is_default(): expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"} import numpy as np # The error state should be unchanged after that import. assert np.geterr() == expected
def test_scale_trace(self): """scale_trace should scale trace to correct values""" #should scale to -1 by default #WARNING: won't work with integer matrices m = array([[-2., 0],[0,-2]]) scale_trace(m) self.assertFloatEqual(m, [[-0.5, 0],[0,-0.5]]) #should work even with zero rows m = array([ [1.0,2,3,4], [2,4,4,0], [1,1,0,1], [0,0,0,0] ]) m_orig = m.copy() scale_trace(m) self.assertFloatEqual(m, m_orig / -5) #but should fail if trace is zero m = array([[0,1,1],[1,0,1],[1,1,0]]) #SUPPORT2425 ori_err = numpy.geterr() numpy.seterr(divide='raise') try: #with numpy_err(divide='raise'): self.assertRaises((ZeroDivisionError, FloatingPointError), \ scale_trace, m) finally: numpy.seterr(**ori_err)
def test_smoothingMatrix(self): """ Tests some aspects of the matrix. """ # Disable div by zero errors. temp = np.geterr() np.seterr(all="ignore") frequencies = np.array([0.0, 1.0, 2.0, 10.0, 25.0, 50.0, 100.0], dtype=np.float32) matrix = calculateSmoothingMatrix(frequencies, 20.0) self.assertEqual(matrix.dtype, np.float32) for _i, freq in enumerate(frequencies): np.testing.assert_array_equal(matrix[_i], konnoOhmachiSmoothingWindow(frequencies, freq, 20.0)) # Should not be normalized. Test only for larger frequencies # because smaller ones have a smaller window. if freq >= 10.0: self.assertTrue(matrix[_i].sum() > 1.0) # Input should be output dtype. frequencies = np.array([0.0, 1.0, 2.0, 10.0, 25.0, 50.0, 100.0], dtype=np.float64) matrix = calculateSmoothingMatrix(frequencies, 20.0) self.assertEqual(matrix.dtype, np.float64) # Check normalization. frequencies = np.array([0.0, 1.0, 2.0, 10.0, 25.0, 50.0, 100.0], dtype=np.float32) matrix = calculateSmoothingMatrix(frequencies, 20.0, normalize=True) self.assertEqual(matrix.dtype, np.float32) for _i, freq in enumerate(frequencies): np.testing.assert_array_equal( matrix[_i], konnoOhmachiSmoothingWindow(frequencies, freq, 20.0, normalize=True) ) # Should not be normalized. Test only for larger frequencies # because smaller ones have a smaller window. self.assertAlmostEqual(matrix[_i].sum(), 1.0, 5) np.seterr(**temp)
def test_smoothingWindow(self): """ Tests the creation of the smoothing window. """ # Disable div by zero errors. temp = np.geterr() np.seterr(all="ignore") # Frequency of zero results in a delta peak at zero (there usually # should be just one zero in the frequency array. window = konnoOhmachiSmoothingWindow(np.array([0, 1, 0, 3], dtype=np.float32), 0) np.testing.assert_array_equal(window, np.array([1, 0, 1, 0], dtype=np.float32)) # Wrong dtypes raises. self.assertRaises(ValueError, konnoOhmachiSmoothingWindow, np.arange(10, dtype=np.int32), 10) # If frequency=center frequency, log results in infinity. Limit of # whole formulae is 1. window = konnoOhmachiSmoothingWindow(np.array([5.0, 1.0, 5.0, 2.0], dtype=np.float32), 5) np.testing.assert_array_equal(window[[0, 2]], np.array([1.0, 1.0], dtype=np.float32)) # Output dtype should be the dtype of frequencies. self.assertEqual(konnoOhmachiSmoothingWindow(np.array([1, 6, 12], dtype=np.float32), 5).dtype, np.float32) self.assertEqual(konnoOhmachiSmoothingWindow(np.array([1, 6, 12], dtype=np.float64), 5).dtype, np.float64) # Check if normalizing works. window = konnoOhmachiSmoothingWindow(self.frequencies, 20) self.assertTrue(window.sum() > 1.0) window = konnoOhmachiSmoothingWindow(self.frequencies, 20, normalize=True) self.assertAlmostEqual(window.sum(), 1.0, 5) # Just one more to test if there are no invalid values and the range if # ok. window = konnoOhmachiSmoothingWindow(self.frequencies, 20) self.assertEqual(np.any(np.isnan(window)), False) self.assertEqual(np.any(np.isinf(window)), False) self.assertTrue(np.all(window <= 1.0)) self.assertTrue(np.all(window >= 0.0)) np.seterr(**temp)
def gaussian_highpass(img, high_cutoff, pad=1): ''' Apply a Gaussian highpass filter to an image .. seealso:: :py:func:`gaussian_highpass_kernel` :Parameters: img : array Image high_cutoff : float High-frequency cutoff pad : int Padding :Returns: out : array Filtered image ''' ctype = numpy.complex128 if img.dtype is numpy.float64 else numpy.complex64 if pad > 1: shape = img.shape img = pad_image(img.astype(ctype), (int(img.shape[0]*pad), int(img.shape[1]*pad)), 'e') else: img = img.astype(ctype) state = numpy.geterr() numpy.seterr(all='ignore') img = filter_image(img, gaussian_highpass_kernel(img.shape, high_cutoff, img.dtype), pad) numpy.seterr(**state) if pad > 1: img = depad(img, shape) return img
def wrapped(e): old_settings = np.geterr() np.seterr(invalid="raise") try: return func(e) except exception: warnings.warn(msg + " " + e.fname, exc.EmptyStep) np.seterr(**old_settings)
def test_numpy_errstate_is_default(): # The defaults since numpy 1.6.0 expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"} import numpy as np from pandas.compat import numpy # noqa # The errstate should be unchanged after that import. tm.assert_equal(np.geterr(), expected)
def test_numpy_errstate_is_default(): # The defaults since numpy 1.6.0 expected = {'over': 'warn', 'divide': 'warn', 'invalid': 'warn', 'under': 'ignore'} import numpy as np from pandas.compat import numpy # noqa # The errstate should be unchanged after that import. assert np.geterr() == expected
def __enter__(self): try: import numpy except ImportError: return None self.errstate = numpy.geterr() numpy.seterr(invalid="ignore") return numpy
def summarize(self, interval, bins=None, method='summarize', function='mean'): # We may be dividing by zero in some cases, which raises a warning in # NumPy based on the IEEE 754 standard (see # http://docs.scipy.org/doc/numpy/reference/generated/ # numpy.seterr.html) # # That's OK -- we're expecting that to happen sometimes. So temporarily # disable this error reporting for the duration of this method. orig = np.geterr()['invalid'] np.seterr(invalid='ignore') if (bins is None) or (method == 'get_as_array'): bw = BigWigFile(open(self.fn)) s = bw.get_as_array( interval.chrom, interval.start, interval.stop,) if s is None: s = np.zeros((interval.stop - interval.start,)) else: s[np.isnan(s)] = 0 elif method == 'ucsc_summarize': if function in ['mean', 'min', 'max', 'std', 'coverage']: return self.ucsc_summarize(interval, bins, function=function) else: raise ValueError('function "%s" not supported by UCSC\'s' 'bigWigSummary') else: bw = BigWigFile(open(self.fn)) s = bw.summarize( interval.chrom, interval.start, interval.stop, bins) if s is None: s = np.zeros((bins,)) else: if function == 'sum': s = s.sum_data if function == 'mean': s = s.sum_data / s.valid_count s[np.isnan(s)] = 0 if function == 'min': s = s.min_val s[np.isinf(s)] = 0 if function == 'max': s = s.max_val s[np.isinf(s)] = 0 if function == 'std': s = (s.sum_squares / s.valid_count) s[np.isnan(s)] = 0 # Reset NumPy error reporting np.seterr(divide=orig) return s
def check_typecast(self, val, dtype): operators = [operator.add, operator.sub, operator.mul, operator.div] for op in operators: err = numpy.geterr() numpy.seterr(divide='ignore', invalid='ignore') a = op(val, (testing.shaped_arange((5,), numpy, dtype) - 2)) numpy.seterr(**err) b = op(val, (testing.shaped_arange((5,), cupy, dtype) - 2)) self.assertEqual(a.dtype, b.dtype)
def _prepare_amr_slice(self, selection): """ return list of patches that contain selection """ # FIXME: it's not good to reach in to src_field[0]'s private methods # like this, but it's also not good to implement these things twice # print("??", len(self.patches)) if len(self.patches) == 0: raise ValueError("AMR field must contain patches to be slicable") selection, _ = self.patches[0]._prepare_slice(selection) extent = self.patches[0]._src_crds.get_slice_extent(selection) inds = [] maybe = [] # these are patches that look like they contain selection # but might not due to finite precision errors when # calculating xh for i, fld in enumerate(self.patches): # - if xl - atol > the extent of the slice in any direction, then # there's no overlap # - if xh <= the lower corner of the slice in any direction, then # there's no overlap # the atol and equals are done to match cases where extent overlaps # the lower corner, but not the upper corner # logic goes this way cause extent has NaNs in # dimensions that aren't specified in selection... super-kludge # also, temporarily disable warnings on NaNs in numpy invalid_err_level = np.geterr()['invalid'] np.seterr(invalid='ignore') atol = 100 * np.finfo(fld.crds.xl_nc.dtype).eps if (not np.any(np.logical_or(fld.crds.xl_nc - atol > extent[1], fld.crds.xh_nc <= extent[0]))): if np.any(np.isclose(fld.crds.xh_nc, extent[0], atol=atol)): maybe.append(i) else: inds.append(i) np.seterr(invalid=invalid_err_level) # if we found some maybes, but no real hits, then use the maybes if maybe and not inds: inds = maybe if len(inds) == 0: viscid.logger.error("selection {0} not in any patch @ time {1}" "".format(selection, self.patches[0].time)) if self.skeleton: s = (" skeleton: xl= {0} xh = {1}" "".format(self.skeleton.global_xl, self.skeleton.global_xh)) viscid.logger.error(s) inds = None flds = None elif len(inds) == 1: inds = inds[0] flds = self.patches[inds] else: flds = [self.patches[i] for i in inds] return flds, inds
def setUp(self): # directory where the test files are located self.path = PATH self.path_images = os.path.join(PATH, os.pardir, "images") # some pre-computed ppsd used for plotting tests: # (ppsd._psd_periods was downcast to np.float16 to save space) self.example_ppsd_npz = os.path.join(PATH, "ppsd_kw1_ehz.npz") # ignore some "RuntimeWarning: underflow encountered in multiply" self.nperr = np.geterr() np.seterr(all='ignore')
def do_replot(star): d, attrs, \ x,y,err, \ freq,power_rv,power_fwhm,power_bis,power_rhk, \ bfreq, bpower_rv = get_data(h5file, star) # w1.removeItem(label) try: teff = attrs.teff feh, feh_error = attrs.feh, attrs.feh_error logg, logg_error = attrs.logg, attrs.logg_error prot = attrs.prot except AttributeError: teff = feh = feh_error = logg = logg_error = 0 prot = 0 l = w1.children()[1] l.setText(label_text % (star, attrs.bmag, attrs.vmag, attrs.spect_type, teff, feh, feh_error, logg, logg_error, len(x), 'HARPS') ) # w1.addWidget(label, row=0, col=0) ## dock 3, the radial velocity data w3.plot(x, y, pen=None, symbol='o', symbolSize=5) errItem = pg.ErrorBarItem(x=x, y=y, height=err, beam=0.5) w3.addItem(errItem) w3.autoRange() ## dock 5, periodogram BIS w5.plot(1./freq, power_bis, title="Periodogram BIS") ## dock 6, periodogram RVs w6.plot(1./freq, power_rv, title="Periodogram") if bfreq is not None: w6.plot(1./bfreq, bpower_rv*max(power_rv), pen='r') w6.autoRange() ## make sure we catch the FP error if prot=0 for some reason old_settings = np.geterr() np.seterr(divide='raise') try: vline_prot.setPos(np.log10(prot)) except FloatingPointError: pass w6.addItem(vline_prot, ignoreBounds=True) w6.addItem(vLine, ignoreBounds=True) w6.addItem(hLine, ignoreBounds=True) ## dock 7, periodogram FWHM w7.plot(1./freq, power_fwhm, title="Periodogram FWHM") ## dock 8, periodogram RHK w8.plot(1./freq, power_rhk, title="Periodogram FWHM")
def __init__(self, decimals=None, casting='same_kind', err=None, dtype=None, sparse=False, **kw): err = err if err is not None else np.geterr() super(TensorAround, self).__init__(_decimals=decimals, _casting=casting, _err=err, _dtype=dtype, _sparse=sparse, **kw)
def test_plot_tfr(self): n = 295 t, dt = np.linspace(0., 20 * np.pi, n, retstep=True) sig = np.sin(t) _t = np.geterr() np.seterr(all="ignore") try: with ImageComparison(self.path, 'time_frequency_representation.png') as ic: plot_tfr(sig, dt=dt, show=False) plt.savefig(ic.name) finally: np.seterr(**_t)
def __init__(self, deg=None, casting='same_kind', err=None, dtype=None, sparse=False, **kw): err = err if err is not None else np.geterr() super().__init__(_deg=deg, _casting=casting, _err=err, _dtype=dtype, _sparse=sparse, **kw)
def u_star_func(u3, z3, zom, psi_z3, wind_coef=1): """""" u_star = np.array(zom, copy=True, ndmin=1) np.reciprocal(u_star, out=u_star) u_star *= z3 oldsettings = np.geterr() np.seterr(invalid='ignore') np.log(u_star, out=u_star) np.seterr(invalid=oldsettings['invalid']) u_star -= psi_z3 np.reciprocal(u_star, out=u_star) u_star *= (u3 * wind_coef * 0.41) # u_star = ((u3 * wind_coef * 0.41) / (np.log(z3 / zom) - psi_z3)) return u_star
def pip_array_cn(p_a, poly): """Return bool array of 2D points inclusion, True where point is inside polygon. Uses crossing number algorithm. arguments: p_a (2D numpy float array): set of xy points to test for inclusion in polygon poly (2D numpy array, tuple or list of tuples or lists of at least 2 floats): the xy points defining a polygon returns: numpy boolean vector: True where corresponding point in p_a is within the polygon note: if the polygon is represented by a closed resqpy Polyline, pass Polyline.coordinates as poly """ # p_array should be a numpy array of 2 or more axes; the final axis has extent at least 2, being x, y, ... # returned boolean array has shape of p_array less the final axis elements = np.prod(list(p_a.shape)[:-1], dtype=int) if elements == 0: return np.zeros((0, ), dtype=bool) p = p_a.reshape((elements, -1)) crossings = np.zeros((elements, ), dtype=int) np_err_dict = np.geterr() np.seterr(divide='ignore', invalid='ignore') for edge in range(len(poly)): v1 = poly[edge - 1] v2 = poly[edge] crossings += np.where( np.logical_and( np.logical_and( np.logical_or(v1[0] > p[:, 0], v2[0] > p[:, 0]), np.logical_or( np.logical_and(v1[1] <= p[:, 1], v2[1] > p[:, 1]), np.logical_and(v1[1] > p[:, 1], v2[1] <= p[:, 1]))), np.logical_or(np.logical_and(v1[0] > p[:, 0], v2[0] > p[:, 0]), (p[:, 0] < (v1[0] + (v2[0] - v1[0]) * (p[:, 1] - v1[1]) / (v2[1] - v1[1]))))), 1, 0) if 'divide' in np_err_dict: np.seterr(divide=np_err_dict['divide']) if 'invalid' in np_err_dict: np.seterr(invalid=np_err_dict['invalid']) return np.array(np.bitwise_and(crossings, 1), dtype=bool).reshape(list(p_a.shape)[:-1])
def calc_nlqq(qest, clXX, clXY, clYY, flX, flY): errs = np.geterr(); np.seterr(divide='ignore', invalid='ignore') print( "[%s]"%watch.elapsed(), "calculating flat-sky noise level for estimator of type", type(qest)) clqq_flatsky = qest.fill_clqq(ql.maps.cfft(nx,dx), clXX*flX*flX, clXY*flX*flY, clYY*flY*flY) resp_flatsky = qest.fill_resp(qest, ql.maps.cfft(nx, dx), flX, flY) nlqq_flatsky = clqq_flatsky / resp_flatsky**2 print("[%s]"%watch.elapsed(), "calculating full-sky noise level for estimator of type", type(qest)) clqq_fullsky = qest.fill_clqq(np.zeros(lmax+1, dtype=np.complex), clXX*flX*flX, clXY*flX*flY, clYY*flY*flY) resp_fullsky = qest.fill_resp(qest, np.zeros(lmax+1, dtype=np.complex), flX, flY) nlqq_fullsky = clqq_fullsky / resp_fullsky**2 np.seterr(**errs) return nlqq_flatsky, nlqq_fullsky
def _edges_intersect(self, edge1, edge2): """ Return 1 if edges intersect completely (endpoints excluded) """ h12 = self._intersect_edge_arrays(self.pts[np.array(edge1)], self.pts[np.array(edge2)]) h21 = self._intersect_edge_arrays(self.pts[np.array(edge2)], self.pts[np.array(edge1)]) err = np.geterr() np.seterr(divide='ignore', invalid='ignore') try: out = (0 < h12 < 1) and (0 < h21 < 1) finally: np.seterr(**err) return out
def convert_to_log(x, zero_case=None): """Return the log of a matrix. Silences the divide-by-zero warning before calculating the log. If zero_case is specified, all the -inf's in the resulting logged matrix are replaced with that value. """ old = np.geterr()['divide'] np.seterr(divide='ignore') out = np.log(x) if zero_case is not None: out = np.where(out == -np.inf, zero_case, out) np.seterr(divide=old) return out
def calc_nlqq(qest, clXX, clXY, clYY, flX, flY): errs = np.geterr(); np.seterr(divide='ignore', invalid='ignore') print "[%s]"%watch.elapsed(), "calculating flat-sky noise level for estimator of type", type(qest) clqq_flatsky = qest.fill_clqq(ql.maps.cfft(nx,dx), clXX*flX*flX, clXY*flX*flY, clYY*flY*flY) resp_flatsky = qest.fill_resp(qest, ql.maps.cfft(nx, dx), flX, flY) nlqq_flatsky = clqq_flatsky / resp_flatsky**2 print "[%s]"%watch.elapsed(), "calculating full-sky noise level for estimator of type", type(qest) clqq_fullsky = qest.fill_clqq(np.zeros(lmax+1, dtype=np.complex), clXX*flX*flX, clXY*flX*flY, clYY*flY*flY) resp_fullsky = qest.fill_resp(qest, np.zeros(lmax+1, dtype=np.complex), flX, flY) nlqq_fullsky = clqq_fullsky / resp_fullsky**2 np.seterr(**errs) return nlqq_flatsky, nlqq_fullsky
def print_settings(): print "data_dir: %s" % orca.get_injectable('data_dir') print "configs_dir: %s" % orca.get_injectable('configs_dir') print "households_sample_size = %s" % orca.get_injectable( 'settings')['households_sample_size'] print "preload_3d_skims = %s" % orca.get_injectable('preload_3d_skims') print "chunk_size = %s" % orca.get_injectable('chunk_size') print "hh_chunk_size = %s" % orca.get_injectable('hh_chunk_size') print "garbage collection enabled: %s" % gc.isenabled() print "garbage collection threshold: %s" % str(gc.get_threshold()) print "numpy floating-point error-handling settings: %s" % np.geterr() print "pandas display options max_rows=%s max_columns=%s" % \ (pd.options.display.max_rows, pd.options.display.max_columns)
def edges_intersect(self, edge1, edge2): """ Return 1 if edges intersect completely (endpoints excluded) """ h12 = self.intersect_edge_arrays(self.pts[np.array(edge1)], self.pts[np.array(edge2)]) h21 = self.intersect_edge_arrays(self.pts[np.array(edge2)], self.pts[np.array(edge1)]) err = np.geterr() np.seterr(divide='ignore', invalid='ignore') try: out = (0 < h12 < 1) and (0 < h21 < 1) finally: np.seterr(**err) return out
def apply(self, times, data): """ Apply this filter. """ pixels = data.shape[1:] # Average in time over all pixels in the image time_median = np.zeros(data.shape) for i in range(pixels[0]): for j in range(pixels[1]): time_median[:, i, j] = scipy.ndimage.median_filter(data[:, i, j], size=3) # Ignore divide-by-zero for a bit errs = np.geterr() np.seterr(divide='ignore') # Find pixels which vary alot, but only briefly # Basically, we compare the value of each pixel v(t) at times # (t1, t2, t3). If v(t1)~v(t3), but v(t2) ">>" v(t1), then we # interpolate the value of the pixel in time. tf_forward = np.abs(time_median[:-1, :] / data[1:, :]) tf_backward = np.abs(time_median[1:, :] / data[:-1, :]) # Restore 'divide-by-zero' warnings np.seterr(**errs) # Locate all pixels that exceed the threshold # (make 'tfilter' all True to begin with) tfilter = (data >= 0) tfilter[1:-1] = (tf_forward[:-1] < self.threshold) & (tf_backward[1:] < self.threshold) # Interpolate anomalous pixels sframes = np.copy(data) for i in range(pixels[0]): for j in range(pixels[1]): tslice = np.copy(data[:, i, j]) tf_slice = tfilter[:, i, j] # In every time point where this pixel is anomalously bright, # we interpolate its value based on its previous and next (in time) value tslice[tf_slice] = np.interp(times[tf_slice], times[~tf_slice], tslice[~tf_slice]) sframes[:, i, j] = tslice return sframes
def calc_ci(self, para, direction): """ Calculate the ci for a single parameter for a single direction. Direction is either positive or negative 1. """ if isinstance(para, str): para = self.params[para] #function used to calculate the pro calc_prob = lambda val, prob: self.calc_prob(para, val, prob) if self.trace: x = [i.value for i in self.params.values()] self.trace_dict[para.name].append(x + [0]) para.vary = False limit, max_prob = self.find_limit(para, direction) start_val = para.value.copy() a_limit = start_val.copy() ret = [] orig_warn_settings = np.geterr() np.seterr(all='ignore') for prob in self.sigmas: if prob > max_prob: ret.append((prob, direction * np.inf)) continue try: val = brentq(calc_prob, a_limit, limit, rtol=.5e-4, args=prob) except ValueError: self.reset_vals() try: val = brentq(calc_prob, start_val, limit, rtol=.5e-4, args=prob) except ValueError: val = np.nan a_limit = val ret.append((prob, val)) para.vary = True self.reset_vals() np.seterr(**orig_warn_settings) return ret
def test_big_vals(nums): """ Test that nums is within iinfo limits :param nums: numpy array :return: bool numpy array Note switches off and restores warning on nans. Other way: ok = np.zeros_like(nums, dtype=np.bool8) not_na = ~np.isnan(nums) nums_not_na = nums[not_na] """ save_invalid = np.geterr()['invalid'] # save floating-point errors handling np.seterr(invalid='ignore') # switch off warning on nans ok = np.logical_and(iinfo.min < nums, nums < iinfo.max) np.seterr(invalid=save_invalid) # restore floating-point errors handling return ok
def __init__(self, rtol=None, atol=None, equal_nan=None, casting="same_kind", err=None, sparse=False, **kw): err = err if err is not None else np.geterr() super().__init__(_rtol=rtol, _atol=atol, _equal_nan=equal_nan, _casting=casting, _err=err, sparse=sparse, **kw)
def calc_ci(self, para, direction): """ Calculate the ci for a single parameter for a single direction. Direction is either positive or negative 1. """ if isinstance(para, str): para = self.minimizer.params[para] #function used to calculate the pro calc_prob = lambda val, prob: self.calc_prob(para, val, prob) if self.trace: x = [i.value for i in self.minimizer.params.values()] self.trace_dict[para.name].append(x + [0]) para.vary = False self.minimizer.prepare_fit(self.params) limit, max_prob = self.find_limit(para, direction) start_val = para.value.copy() a_limit = start_val.copy() ret = [] orig_warn_settings = np.geterr() np.seterr(all='ignore') for prob in self.sigmas: if prob > max_prob: ret.append((prob, direction*np.inf)) continue try: val = brentq(calc_prob, a_limit, limit, rtol=.5e-4, args=prob) except ValueError: self.reset_vals() try: val = brentq(calc_prob, start_val, limit, rtol=.5e-4, args=prob) except ValueError: val = np.nan a_limit = val ret.append((prob, val)) para.vary = True self.reset_vals() np.seterr(**orig_warn_settings) return ret
def _find_edge_intersections(self): """ Return a dictionary containing, for each edge in self.edges, a list of the positions at which the edge should be split. """ edges = self.pts[self.edges] cuts = {} # { edge: [(intercept, point), ...], ... } for i in range(edges.shape[0]-1): # intersection of edge i onto all others int1 = self._intersect_edge_arrays(edges[i:i+1], edges[i+1:]) # intersection of all edges onto edge i int2 = self._intersect_edge_arrays(edges[i+1:], edges[i:i+1]) # select for pairs that intersect err = np.geterr() np.seterr(divide='ignore', invalid='ignore') try: mask1 = (int1 >= 0) & (int1 <= 1) mask2 = (int2 >= 0) & (int2 <= 1) mask3 = mask1 & mask2 # all intersections finally: np.seterr(**err) # compute points of intersection inds = np.argwhere(mask3)[:, 0] if len(inds) == 0: continue h = int2[inds][:, np.newaxis] pts = (edges[i, 0][np.newaxis, :] * (1.0 - h) + edges[i, 1][np.newaxis, :] * h) # record for all edges the location of cut points edge_cuts = cuts.setdefault(i, []) for j, ind in enumerate(inds): if 0 < int2[ind] < 1: edge_cuts.append((int2[ind], pts[j])) if 0 < int1[ind] < 1: other_cuts = cuts.setdefault(ind+i+1, []) other_cuts.append((int1[ind], pts[j])) # sort all cut lists by intercept, remove duplicates for k, v in cuts.items(): v.sort(key=lambda x: x[0]) for i in range(len(v)-2, -1, -1): if v[i][0] == v[i+1][0]: v.pop(i+1) return cuts
def reduce(self, other, op=add, normalize_input=True, normalize_output=True): """Reduces two profiles with some operator and returns a new Profile other: Profile object op: operator (e.g. add, subtract, multiply, divide) normalize_input: whether the input profiles will be normalized before collapsing. The default is True. normalize_output: whether the output profile will be normalized. The default is True This function is intented for use on normalized profiles. For safety it'll try to normalize the data before collapsing them. If you do not normalize your data and set normalize_input to False, you might get unexpected results. It does check whether self.Data and other.Data have the same shape It does not check whether self and other have the same CharOrder. The resulting Profile gets the alphabet and char order from self. """ if self.Data.shape != other.Data.shape: raise ProfileError, "Cannot collapse profiles of different size: %s, %s" % ( self.Data.shape, other.Data.shape, ) if normalize_input: self.normalizePositions() other.normalizePositions() try: ##SUPPORT2425 ori_err = numpy.geterr() numpy.seterr(divide="raise") try: new_data = op(self.Data, other.Data) finally: numpy.seterr(**ori_err) # with numpy_err(divide='raise'): # new_data = op(self.Data, other.Data) except (OverflowError, ZeroDivisionError, FloatingPointError): raise ProfileError, "Can't do operation on input profiles" result = Profile(new_data, self.Alphabet, self.CharOrder) if normalize_output: result.normalizePositions() return result
def find_edge_intersections(self): """ Return a dictionary containing, for each edge in self.edges, a list of the positions at which the edge should be split. """ edges = self.pts[self.edges] cuts = {} # { edge: [(intercept, point), ...], ... } for i in range(edges.shape[0] - 1): # intersection of edge i onto all others int1 = self.intersect_edge_arrays(edges[i:i + 1], edges[i + 1:]) # intersection of all edges onto edge i int2 = self.intersect_edge_arrays(edges[i + 1:], edges[i:i + 1]) # select for pairs that intersect err = np.geterr() np.seterr(divide='ignore', invalid='ignore') try: mask1 = (int1 >= 0) & (int1 <= 1) mask2 = (int2 >= 0) & (int2 <= 1) mask3 = mask1 & mask2 # all intersections finally: np.seterr(**err) # compute points of intersection inds = np.argwhere(mask3)[:, 0] if len(inds) == 0: continue h = int2[inds][:, np.newaxis] pts = (edges[i, 0][np.newaxis, :] * (1.0 - h) + edges[i, 1][np.newaxis, :] * h) # record for all edges the location of cut points edge_cuts = cuts.setdefault(i, []) for j, ind in enumerate(inds): if 0 < int2[ind] < 1: edge_cuts.append((int2[ind], pts[j])) if 0 < int1[ind] < 1: other_cuts = cuts.setdefault(ind + i + 1, []) other_cuts.append((int1[ind], pts[j])) # sort all cut lists by intercept, remove duplicates for k, v in cuts.items(): v.sort(key=lambda x: x[0]) for i in range(len(v) - 2, -1, -1): if v[i][0] == v[i + 1][0]: v.pop(i + 1) return cuts
def __apply_tsne(self, data): """ :param data: :return: """ restore_these_settings = np.geterr() temp_settings = restore_these_settings.copy() temp_settings["over"] = "ignore" temp_settings["under"] = "ignore" np.seterr(**temp_settings) tsne2 = TSNE(n_components=2, random_state=SEED) X_2d = tsne2.fit_transform(data) np.seterr(**restore_these_settings) return X_2d
def test_helmholtz_assemble(dtype, rtol, parallel): """Test the Laplace kernel.""" from fast_green_kernel.direct_evaluator import assemble_helmholtz_kernel wavenumber = 2.5 nsources = 10 ntargets = 20 if dtype == np.complex128: real_type = np.float64 elif dtype == np.complex64: real_type = np.float32 else: raise ValueError(f"Unsupported type: {dtype}.") rng = np.random.default_rng(seed=0) # Construct target and sources so that they do not overlap # apart from the first point. targets = 1.5 + rng.random((3, ntargets), dtype=real_type) sources = rng.random((3, nsources), dtype=real_type) sources[:, 0] = targets[:, 0] # Test what happens if source = target actual = assemble_helmholtz_kernel( targets, sources, wavenumber, dtype=dtype, parallel=parallel ) # Calculate expected result # A divide by zero error is expected to happen here. # So just ignore the warning. old_params = np.geterr() np.seterr(all="ignore") expected = np.empty((ntargets, nsources), dtype=dtype) for index, target in enumerate(targets.T): dist = np.linalg.norm(sources - target.reshape(3, 1), axis=0) expected[index, :] = np.exp(1j * wavenumber * dist) / (4 * np.pi * dist) expected[index, dist == 0] = 0 # Reset the warnings np.seterr(**old_params) np.testing.assert_allclose(actual, expected, rtol=rtol)
def distance_along_vector_to_limit(self, alpha, duvec): """ Returns a new alpha so that new_u = current_u + alpha*duvec does not violate any `lower` or `upper` limits if specified. Args ----- alpha: float Initial value for step in gradient direction. duvec: `Vecwrapper` Direction to apply step. generally the gradient. Returns -------- float New step size, backtracked to prevent violation.""" # A single index of the gradient can be zero, so we want to suppress # the warnings from numpy. old_warn = numpy.geterr() numpy.seterr(divide='ignore') new_alpha = alpha for name, meta in iteritems(self): if 'remote' in meta: continue val = self[name] upper = meta.get('upper') if upper is not None: alpha_bound = numpy.min((upper - val)/duvec[name]) if alpha_bound >= 0.0: new_alpha = min(new_alpha, alpha_bound) lower = meta.get('lower') if lower is not None: alpha_bound = numpy.min((lower - val)/duvec[name]) if alpha_bound >= 0.0: new_alpha = min(new_alpha, alpha_bound) # Return numpy warn to what it was numpy.seterr(divide=old_warn['divide']) return max(0.0, new_alpha)
def test_testScalarArithmetic(self): xm = array(0, mask=1) #TODO FIXME: Find out what the following raises a warning in r8247 err_status = numpy.geterr() try: numpy.seterr(divide='ignore') self.assertTrue((1 / array(0)).mask) finally: numpy.seterr(**err_status) self.assertTrue((1 + xm).mask) self.assertTrue((-xm).mask) self.assertTrue((-xm).mask) self.assertTrue(maximum(xm, xm).mask) self.assertTrue(minimum(xm, xm).mask) self.assertTrue(xm.filled().dtype is xm._data.dtype) x = array(0, mask=0) self.assertTrue(x.filled() == x._data) self.assertEqual(str(xm), str(masked_print_option))
def __apply_tsne(self, data): """ method used to apply the t-sne algorithm to reduce the problem dimension to 2d :param data: input data :return: 2d data """ restore_these_settings = np.geterr() temp_settings = restore_these_settings.copy() temp_settings["over"] = "ignore" temp_settings["under"] = "ignore" np.seterr(**temp_settings) tsne2 = TSNE(n_components=2, random_state=SEED) X_2d = tsne2.fit_transform(data) np.seterr(**restore_these_settings) return X_2d
def __init__(self, rtol=None, atol=None, equal_nan=None, casting='same_kind', err=None, dtype=None, sparse=False, **kw): err = err if err is not None else np.geterr() super(TensorIscloseConstant, self).__init__(_rtol=rtol, _atol=atol, _equal_nan=equal_nan, _casting=casting, _err=err, _dtype=dtype, _sparse=sparse, **kw)
def intersect(v_origin, v_direction, plane_origin, plane_normal): vo = v_origin vd = v_direction po = plane_origin pn = plane_normal np_err = np.geterr() try: np.seterr(divide="ignore") t = np.stack( [np.sum(pn * (po - vo), axis=1) / np.sum(pn * vd, axis=1)], 1) # t[t < 0] = np.nan # TODO: remove? t[np.isinf(t)] = np.nan intersection = vo + np.multiply(t, vd) finally: np.seterr(**np_err) return intersection
def reduce(self,other,op=add,normalize_input=True,normalize_output=True): """Reduces two profiles with some operator and returns a new Profile other: Profile object op: operator (e.g. add, subtract, multiply, divide) normalize_input: whether the input profiles will be normalized before collapsing. The default is True. normalize_output: whether the output profile will be normalized. The default is True This function is intented for use on normalized profiles. For safety it'll try to normalize the data before collapsing them. If you do not normalize your data and set normalize_input to False, you might get unexpected results. It does check whether self.Data and other.Data have the same shape It does not check whether self and other have the same CharOrder. The resulting Profile gets the alphabet and char order from self. """ if self.Data.shape != other.Data.shape: raise ProfileError,\ "Cannot collapse profiles of different size: %s, %s"\ %(self.Data.shape,other.Data.shape) if normalize_input: self.normalizePositions() other.normalizePositions() try: ##SUPPORT2425 ori_err = numpy.geterr() numpy.seterr(divide='raise') try: new_data = op(self.Data, other.Data) finally: numpy.seterr(**ori_err) #with numpy_err(divide='raise'): #new_data = op(self.Data, other.Data) except (OverflowError, ZeroDivisionError, FloatingPointError): raise ProfileError, "Can't do operation on input profiles" result = Profile(new_data, self.Alphabet, self.CharOrder) if normalize_output: result.normalizePositions() return result
def join(self, rhs, func: Callable[[Union[np.ndarray, V], Union[np.ndarray, V]], Union[np.ndarray, M]], dtype: Optional[Type[M]] = None, inplace=False, ) -> "Chunk[M]": dtype = self.__dtype(dtype) rhs_is_chunk = isinstance(rhs, Chunk) # Fill value rhs_fill_value = rhs._fill_value if rhs_is_chunk else rhs fill_value = self._fill_value try: fill_value = func(self._fill_value, rhs_fill_value) except Exception as e: handling = np.geterr()['invalid'] if handling == 'raise': raise e elif handling == 'ignore': pass else: warnings.warn("Fill value operand", RuntimeWarning, source=e) # Inplace selection if inplace: assert self._dtype == dtype c = self c._fill_value = fill_value else: c = self.copy(empty=True, dtype=dtype, fill_value=fill_value) # Func on values if rhs_is_chunk: val = func(self._value, rhs._value) if self._is_filled and rhs._is_filled: c.set_fill(val) else: c.set_array(val) else: val = func(self._value, rhs) if self._is_filled: c.set_fill(func(self._value, rhs)) else: c.set_array(func(self._value, rhs)) return c
def setup_module(module, verbosity=None): "set up test fixtures for testing" if __debug__: from mvpa2.base import debug # Lets add some targets which provide additional testing debug.active += ['CHECK_.*'] verbosity = _get_verbosity(verbosity) # provide people with a hint about the warnings that might show up in a # second if verbosity: print("T: MVPA_SEED=%s" % _random_seed) if verbosity > 1: print('T: Testing for availability of external software packages.') # fully test of externals verbosity_dependencies = max(0, verbosity - 1) if verbosity_dependencies: externals.check_all_dependencies(verbosity=verbosity_dependencies) elif __debug__ and verbosity: # pragma: no cover print( 'T: Skipping testing of all dependencies since verbosity ' '(MVPA_TESTS_VERBOSITY) is too low') # So we could see all warnings about missing dependencies _sys_settings['maxcount'] = warning.maxcount warning.maxcount = 1000 if verbosity < 3: # no MVPA warnings during whole testsuite (but restore handlers later on) _sys_settings['handlers'] = warning.handlers warning.handlers = [] # No python warnings (like ctypes version for slmr) import warnings warnings.simplefilter('ignore') if verbosity < 4: # No NumPy _sys_settings['np_errsettings'] = np.geterr() np.seterr(**dict([(x, 'ignore') for x in _sys_settings['np_errsettings']]))
def test_smoothingWindow(self): """ Tests the creation of the smoothing window. """ # Disable div by zero erros. temp = np.geterr() np.seterr(all='ignore') # Frequency of zero results in a delta peak at zero (there usually # should be just one zero in the frequency array. window = konnoOhmachiSmoothingWindow( np.array([0, 1, 0, 3], dtype='float32'), 0) np.testing.assert_array_equal(window, np.array([1, 0, 1, 0], dtype='float32')) # Wrong dtypes raises. self.assertRaises(ValueError, konnoOhmachiSmoothingWindow, np.arange(10, dtype='int32'), 10) # If frequency=center frequency, log results in infinity. Limit of # whole formulae is 1. window = konnoOhmachiSmoothingWindow( np.array([5.0, 1.0, 5.0, 2.0], dtype='float32'), 5) np.testing.assert_array_equal(window[[0, 2]], np.array([1.0, 1.0], dtype='float32')) # Output dtype should be the dtype of frequencies. self.assertEqual( konnoOhmachiSmoothingWindow(np.array([1, 6, 12], dtype='float32'), 5).dtype, np.float32) self.assertEqual( konnoOhmachiSmoothingWindow(np.array([1, 6, 12], dtype='float64'), 5).dtype, np.float64) # Check if normalizing works. window = konnoOhmachiSmoothingWindow(self.frequencies, 20) self.assertTrue(window.sum() > 1.0) window = konnoOhmachiSmoothingWindow(self.frequencies, 20, normalize=True) self.assertAlmostEqual(window.sum(), 1.0, 5) # Just one more to test if there are no invalid values and the range if # ok. window = konnoOhmachiSmoothingWindow(self.frequencies, 20) self.assertEqual(np.any(np.isnan(window)), False) self.assertEqual(np.any(np.isinf(window)), False) self.assertTrue(np.all(window <= 1.0)) self.assertTrue(np.all(window >= 0.0)) np.seterr(**temp)
def test_laplace_evaluate_values_and_deriv(dtype, rtol, parallel): """Test the Laplace kernel.""" from fast_green_kernel.direct_evaluator import evaluate_laplace_kernel nsources = 10 ntargets = 20 ncharge_vecs = 2 rng = np.random.default_rng(seed=0) # Construct target and sources so that they do not overlap # apart from the first point. targets = 1.5 + rng.random((3, ntargets), dtype=dtype) sources = rng.random((3, nsources), dtype=dtype) sources[:, 0] = targets[:, 0] # Test what happens if source = target charges = rng.random((ncharge_vecs, nsources), dtype=dtype) actual = evaluate_laplace_kernel( targets, sources, charges, dtype=dtype, return_gradients=True, parallel=parallel ) # Calculate expected result # A divide by zero error is expected to happen here. # So just ignore the warning. old_params = np.geterr() np.seterr(all="ignore") expected = np.empty((nsources, ntargets, 4), dtype=dtype) for index, target in enumerate(targets.T): diff = sources - target.reshape(3, 1) dist = np.linalg.norm(diff, axis=0) expected[:, index, 0] = 1.0 / (4 * np.pi * dist) expected[:, index, 1:] = diff.T / (4 * np.pi * dist.reshape(nsources, 1) ** 3) expected[dist == 0, index, :] = 0 # Reset the warnings np.seterr(**old_params) expected = np.tensordot(charges, expected, 1) np.testing.assert_allclose(actual, expected, rtol=rtol)
def setup(self, np=np, numpy_version=numpy_version, StrictVersion=StrictVersion, new_pandas=new_pandas): """Lives in zipline.__init__ for doctests.""" if numpy_version >= StrictVersion('1.14'): self.old_opts = np.get_printoptions() np.set_printoptions(legacy='1.13') else: self.old_opts = None if new_pandas: self.old_err = np.geterr() # old pandas has numpy compat that sets this np.seterr(all='ignore') else: self.old_err = None
def test_laplace_evaluate_only_values(dtype, rtol, parallel): """Test the Laplace kernel.""" from fast_green_kernel.direct_evaluator import evaluate_laplace_kernel nsources = 10 ntargets = 20 ncharge_vecs = 2 rng = np.random.default_rng(seed=0) # Construct target and sources so that they do not overlap # apart from the first point. targets = 1.5 + rng.random((3, ntargets), dtype=dtype) sources = rng.random((3, nsources), dtype=dtype) sources[:, 0] = targets[:, 0] # Test what happens if source = target charges = rng.random((ncharge_vecs, nsources), dtype=dtype) actual = evaluate_laplace_kernel( targets, sources, charges, dtype=dtype, parallel=parallel ) # Calculate expected result # A divide by zero error is expected to happen here. # So just ignore the warning. old_param = np.geterr()["divide"] np.seterr(divide="ignore") expected = np.empty((nsources, ntargets), dtype=dtype) for index, target in enumerate(targets.T): expected[:, index] = 1.0 / ( 4 * np.pi * np.linalg.norm(sources - target.reshape(3, 1), axis=0) ) # Reset the warnings np.seterr(divide=old_param) expected[0, 0] = 0 # First source and target are identical. expected = np.expand_dims(charges @ expected, -1) np.testing.assert_allclose(actual, expected, rtol=rtol)
def _calc_rot_mtx(self, c1, c2, c3, dbg=False): """Return rotation matrix transforming Cartesian system to system of alpha carbon c2 in sequence of alpha carbons c1, c2, c3. Arguments: c1, c2, c3 -- position vectors of subsequent alpha carbons. Returns matrix and distance detween c1 and c3. """ if dbg: import imp pdbx = imp.load_source('test', '/usr/lib/python2.7/pdb.py') pdbx.set_trace() x, y, z, rdnorm = self._mk_local_system(c1, c2, c3) setting = np.geterr() np.seterr(all='raise') try: w = self._calc_nodes_line(np.array((0, 0, 1)), z) except FloatingPointError: w = x np.seterr(**setting) cph, sph = self._calc_trig_fnc(np.array((1, 0, 0)), w, np.array((0, 0, 1))) # phi angle trig fncs -- rotation around z axis so x -> w #~ sph = np.linalg.norm(cpht) * np.sign(np.dot(cpht, np.array((0, 0, 1)))) cps, sps = self._calc_trig_fnc(w, x, z) # psi angle -- rotation around z' so x -> x' #~ sps = np.linalg.norm(cwx) * np.sign(np.dot(cwx, z)) cth, sth = self._calc_trig_fnc(np.array((0, 0, 1)), z, w) # theta angle -- rotation around nodes line to transform z on z' rot = np.matrix([[ cps * cph - sps * sph * cth, sph * cps + sps * cth * cph, sps * sth ], [ -1 * sps * cph - sph * cps * cth, -1 * sps * sph + cps * cth * cph, cps * sth ], [sth * sph, -sth * cph, cth]]) return rot, rdnorm
def newell_surf_normal(poly): # This algorithm is from the Newell's method pseudo-code found at: # https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal old_settings = np.geterr() np.seterr(invalid='ignore') norm = np.array([0.0, 0.0, 0.0]) for i in range(len(poly)): v_curr = poly[i] v_next = poly[(i + 1) % len(poly)] norm[0] += (v_curr[1] - v_next[1]) * (v_curr[2] + v_next[2]) norm[1] += (v_curr[2] - v_next[2]) * (v_curr[0] + v_next[0]) norm[2] += (v_curr[0] - v_next[0]) * (v_curr[1] + v_next[1]) mag_norm = algc.mag(norm) unit_norm = norm / mag_norm np.seterr(invalid=old_settings['invalid']) return unit_norm