def test_ufunc_two_outputs(self): mantissa, exponent = np.frexp(2 ** -3) expected = (ArrayLike(mantissa), ArrayLike(exponent)) _assert_equal_type_and_value( np.frexp(ArrayLike(2 ** -3)), expected) _assert_equal_type_and_value( np.frexp(ArrayLike(np.array(2 ** -3))), expected)
def computeActivity(self, inputActivity): logger.debug('computing activity.') self.ensureLength(inputActivity.max()) # numpy array magic idx = numpy.mgrid[0:self.dims[0], 0:self.dims[1], 0:self.dims[2]] tInputActivity = numpy.tile(inputActivity, self.dims[:-1] + (1,)) factors = 2 * self.counts[idx[0],idx[1],idx[2],tInputActivity] / numpy.sum(self.counts, axis=3) mans,exps = numpy.frexp(factors) mantissas, exponents = numpy.frexp(numpy.prod(mans, axis=2)) exponents += exps.sum(axis=2) if self.maxexp is not None: maxexp = self.maxexp else: maxexp = exponents.max() exponents -= maxexp logger.debug("Maximum exponent: %d", maxexp) activity = mantissas * numpy.exp2(exponents) if self.p != 0: conscience = (self.coff / self.con)**self.p activity *= conscience activity *= numpy.prod(activity.shape) / activity.sum() return activity
def _detectEndian (self): if (self.endian != 'Auto'): self._maybePrint('%s endian specified... Not autodetecting.'%(self.endian,)) if (self.endian != self.mendian): self._maybePrint('%s endian != %s endian, therefore Foreign.'%(self.endian,self.mendian)) self.endian = 'Foreign' else: self._maybePrint('Auto endian specified... Trying to autodetect data endianness.') for i in xrange(1, self.ntr+1): locar = self.readTraces(i) if ((not abs(locar).sum() == 0.) and (not _np.isnan(locar.mean()))): nexp = abs(_np.frexp(locar.mean())[1]) locar = locar.newbyteorder() fexp = abs(_np.frexp(locar.mean())[1]) if (fexp > nexp): self.endian = 'Native' else: self.endian = 'Foreign' self._maybePrint('Scanned %d trace(s). Endian appears to be %s.'%(i, self.endian)) break if (self.endian == 'Foreign'): self._maybePrint('Will attempt to convert to %s endian when traces are read.\n'%(self.mendian,)) elif (self.endian == 'Auto'): self._maybePrint('Couldn\'t find any non-zero traces to test!\nAssuming Native endian.\n')
def _detectFileEndian (self): if (self.endian != 'Auto'): self._maybePrint('%s endian specified... Not autodetecting.'%(self.endian,)) if (self.endian != self.mendian): self._maybePrint('%s endian != %s endian, therefore Foreign.'%(self.endian,self.mendian)) self.endian = 'Foreign' else: self._maybePrint('Auto endian specified... Trying to autodetect data endianness.') with warnings.catch_warnings(): warnings.simplefilter('ignore') for i in xrange(self.ntr): locar = self[i] if ((not abs(locar).sum() == 0.) and (not np.isnan(locar.mean()))): nexp = abs(np.frexp(locar.astype(np.float64)**2)[1]).mean() locar = locar.newbyteorder() fexp = abs(np.frexp(locar.astype(np.float64)**2)[1]).mean() if (fexp > nexp): self.endian = 'Native' else: self.endian = 'Foreign' self._maybePrint('Scanned %d trace(s). Endian appears to be %s.'%(i, self.endian)) break if (self.endian == 'Foreign'): self._maybePrint('Will attempt to convert to %s endian when traces are read.\n'%(self.mendian,)) elif (self.endian == 'Auto'): self._maybePrint('Couldn\'t find any non-zero traces to test!\nAssuming Native endian.\n')
def nextpow2(n): """Return the next power of 2 such as 2^p >= n. Notes ----- Infinite and nan are left untouched, negative values are not allowed.""" if np.any(n < 0): raise ValueError("n should be > 0") if np.isscalar(n): f, p = np.frexp(n) if f == 0.5: return p-1 elif np.isfinite(f): return p else: return f else: f, p = np.frexp(n) res = f bet = np.isfinite(f) exa = (f == 0.5) res[bet] = p[bet] res[exa] = p[exa] - 1 return res
def test_frexp_invalid_units(self): # Can't use prod() with non-dimensionless quantities with pytest.raises(TypeError) as exc: np.frexp(3.0 * u.m / u.s) assert exc.value.args[0] == ("Can only apply 'frexp' function to " "unscaled dimensionless quantities") # also does not work on quantities that can be made dimensionless with pytest.raises(TypeError) as exc: np.frexp(np.array([2.0, 3.0, 6.0]) * u.m / (6.0 * u.cm)) assert exc.value.args[0] == ("Can only apply 'frexp' function to " "unscaled dimensionless quantities")
def saveArray(filename, data): # https://gist.github.com/edouardp/3089602 f = open(filename, "wb") f.write("#?RADIANCE\n# Made with Python & Numpy\nFORMAT=32-bit_rle_rgbe\n\n") f.write("-Y {0} +X {1}\n".format(data.shape[0], data.shape[1])) brightest = np.maximum(np.maximum(data[...,0], data[...,1]), data[...,2]) exp = np.zeros_like(brightest) man = np.zeros_like(brightest) np.frexp(brightest, man, exp) scman = np.nan_to_num(man * 256.0 / brightest) rgbe = np.zeros((data.shape[0], data.shape[1], 4), dtype=np.uint8) rgbe[...,0:3] = np.minimum(np.maximum(np.around(data[...,0:3] * scman[...,None]), 0), 255) rgbe[...,3] =np.minimum(np.maximum(np.around(exp + 128), 0), 255) rgbe.flatten().tofile(f) f.close()
def expm(A): # EXPM Matrix exponential. # EXPM(X) is the matrix exponential of X. EXPM is computed using # a scaling and squaring algorithm with a Pade approximation. # # Julia implementation closely based on MATLAB code by Nicholas Higham # # Initialization m_vals, theta = expmchk() normA = 0 if issparse(A): normA = np.amax((A.multiply(A.sign())).sum(0)) else: normA = nlin.norm(A,1) if normA <= theta[-1]: # no scaling and squaring is required. for i in range(len(m_vals)): if normA <= theta[i]: F = PadeApproximantOfDegree(A, m_vals[i]) break else: t,s = frexp(normA/float(theta[-1])) s = s - (t == 0.5) # adjust s if normA/theta(end) is a power of 2. A = A/(2.0**s) # Scaling F = PadeApproximantOfDegree(A, m_vals[-1]) for i in range(s): if issparse(A): F = F*F else: F = np.dot(F,F) return F
def _sp_expm(qo): """ Sparse matrix exponential of a quantum operator. Called by the Qobj expm method. """ A = qo.data.tocsc() # extract Qobj data (sparse matrix) m_vals = np.array([3, 5, 7, 9, 13]) theta = np.array([0.01495585217958292, 0.2539398330063230, 0.9504178996162932, 2.097847961257068, 5.371920351148152], dtype=float) normA = _sp_one_norm(qo) if normA <= theta[-1]: for ii in range(len(m_vals)): if normA <= theta[ii]: F = _pade(A, m_vals[ii]) break else: t, s = np.frexp(normA / theta[-1]) s = s - (t == 0.5) A = A / 2.0 ** s F = _pade(A, m_vals[-1]) for i in range(s): F = F * F return F
def frexp(x): tmp = elemwise(np.frexp, x) left = next(names) right = next(names) ldsk = dict(((left,) + key[1:], (getitem, key, 0)) for key in core.flatten(tmp._keys())) rdsk = dict(((right,) + key[1:], (getitem, key, 1)) for key in core.flatten(tmp._keys())) if x._dtype is not None: a = np.empty((1,), dtype=x._dtype) l, r = np.frexp(a) ldt = l.dtype rdt = r.dtype else: ldt = None rdt = None L = Array(merge(tmp.dask, ldsk), left, blockdims=tmp.blockdims, dtype=ldt) R = Array(merge(tmp.dask, rdsk), right, blockdims=tmp.blockdims, dtype=rdt) return L, R
def pSpectrum(data=None, samplefreq=44100): npts = len(data) # we should window the data here if npts == 0: print "? no data in pSpectrum" return # pad to the nearest higher power of 2 (a,b) = numpy.frexp(npts) if a <= 0.5: b = b = 1 npad = 2**b -npts if debugFlag: print "npts: %d npad: %d npad+npts: %d" % (npts, npad, npad+npts) padw = numpy.append(data, numpy.zeros(npad)) npts = len(padw) sigfft = spFFT.fft(padw) nUniquePts = numpy.ceil((npts+1)/2.0) sigfft = sigfft[0:nUniquePts] spectrum = abs(sigfft) spectrum = spectrum / float(npts) # scale by the number of points so that # the magnitude does not depend on the length # of the signal or on its sampling frequency spectrum = spectrum**2 # square it to get the power spmax = numpy.amax(spectrum) spectrum = spectrum + 1e-12*spmax # multiply by two (see technical document for details) # odd nfft excludes Nyquist point if npts % 2 > 0: # we've got odd number of points fft spectrum[1:len(spectrum)] = spectrum[1:len(spectrum)] * 2 else: spectrum[1:len(spectrum) -1] = spectrum[1:len(spectrum) - 1] * 2 # we've got even number of points fft freqAzero = numpy.arange(0, nUniquePts, 1.0) * (samplefreq / npts) return(spectrum, freqAzero)
def test_half_ufuncs(self): """Test the various ufuncs""" a = np.array([0, 1, 2, 4, 2], dtype=float16) b = np.array([-2, 5, 1, 4, 3], dtype=float16) c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16) assert_equal(np.add(a, b), [-2, 6, 3, 8, 5]) assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1]) assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6]) assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625]) assert_equal(np.equal(a, b), [False, False, False, True, False]) assert_equal(np.not_equal(a, b), [True, True, True, False, True]) assert_equal(np.less(a, b), [False, True, False, False, True]) assert_equal(np.less_equal(a, b), [False, True, False, True, True]) assert_equal(np.greater(a, b), [True, False, True, False, False]) assert_equal(np.greater_equal(a, b), [True, False, True, True, False]) assert_equal(np.logical_and(a, b), [False, True, True, True, True]) assert_equal(np.logical_or(a, b), [True, True, True, True, True]) assert_equal(np.logical_xor(a, b), [True, False, False, False, False]) assert_equal(np.logical_not(a), [True, False, False, False, False]) assert_equal(np.isnan(c), [False, False, False, True, False]) assert_equal(np.isinf(c), [False, False, True, False, False]) assert_equal(np.isfinite(c), [True, True, False, False, True]) assert_equal(np.signbit(b), [True, False, False, False, False]) assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3]) assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3]) x = np.maximum(b, c) assert_(np.isnan(x[3])) x[3] = 0 assert_equal(x, [0, 5, 1, 0, 6]) assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2]) x = np.minimum(b, c) assert_(np.isnan(x[3])) x[3] = 0 assert_equal(x, [-2, -1, -np.inf, 0, 3]) assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3]) assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6]) assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2]) assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3]) assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0]) assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2]) assert_equal(np.divmod(a, b), ([0, 0, 2, 1, 0], [0, 1, 0, 0, 2])) assert_equal(np.square(b), [4, 25, 1, 16, 9]) assert_equal(np.reciprocal(b), [-0.5, 0.199951171875, 1, 0.25, 0.333251953125]) assert_equal(np.ones_like(b), [1, 1, 1, 1, 1]) assert_equal(np.conjugate(b), b) assert_equal(np.absolute(b), [2, 5, 1, 4, 3]) assert_equal(np.negative(b), [2, -5, -1, -4, -3]) assert_equal(np.positive(b), b) assert_equal(np.sign(b), [-1, 1, 1, 1, 1]) assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b)) assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2])) assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
def write_hdr(filename, image): '''Writes a HDR image into disk. Assumes you have a np.array((height,width,3), dtype=float) as your HDR image''' f = open(filename, "wb") f.write("#?RADIANCE\n# Made with Python & Numpy\nFORMAT=32-bit_rle_rgbe\n\n") f.write("-Y {0} +X {1}\n".format(image.shape[0], image.shape[1])) brightest = np.maximum(np.maximum(image[...,0], image[...,1]), image[...,2]) mantissa = np.zeros_like(brightest) exponent = np.zeros_like(brightest) np.frexp(brightest, mantissa, exponent) scaled_mantissa = mantissa * 256.0 / brightest rgbe = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8) rgbe[..., 0:3] = np.around(image[..., 0:3] * scaled_mantissa[..., None]) rgbe[..., 3] = np.around(exponent + 128) rgbe.flatten().tofile(f) f.close()
def test_frexp(self, dtype): numpy_a = numpy.array([-300, -20, -10, -1, 0, 1, 10, 20, 300], dtype=dtype) numpy_b, numpy_c = numpy.frexp(numpy_a) cupy_a = cupy.array(numpy_a) cupy_b, cupy_c = cupy.frexp(cupy_a) testing.assert_allclose(cupy_b, numpy_b) testing.assert_array_equal(cupy_c, numpy_c)
def nextfloat(fin): """Return (approximately) next float value (for f>0).""" d = 2**-52 split = N.frexp(fin) while True: fout = N.ldexp(split[0] + d, split[1]) if fin != fout: return fout d *= 2
def compare_float(var, ref, cut_digit=1, verbose=False): # x = mantissa * 2**exponent if type(var) != np.ndarray: var = np.array(var) if type(ref) != np.ndarray: ref = np.array(ref) m_var, e_var = np.frexp(var) m_ref, e_ref = np.frexp(ref) num_exp_diff = np.count_nonzero(e_var != e_ref) if num_exp_diff > 0: try: # check 0 and 1e-16 idxs = np.where(e_var != e_ref) aa_equal(var[idxs], ref[idxs], 15) return True, 15 except: if verbose: print("idxs : ", idxs) print("Actual : ", var[idxs]) print("Desired: ", ref[idxs]) return False, "The exponents are not same at {} points".format(num_exp_diff) num_man_diff = np.count_nonzero(m_var != m_ref) if num_man_diff == 0: return True, "exact" digit = 17 percents = [] while(True): try: aa_equal(m_var, m_ref, digit-1) return True, "{}, ({})".format(digit, ', '.join(percents)) except Exception as e: percent = float(re.findall('mismatch (\d+.\S+)%',str(e))[0]) percents.insert(0, "{}:{:.2f}%".format(digit,percent)) #print('>>>>', digit, str(e), percent, percents) if digit == cut_digit: return False, "{}, ({})".format(cut_digit, ', '.join(percents)) else: digit -= 1
def test_binary_out(): args = [1, np.ones(2), xr.Variable(['x'], [1, 1]), xr.DataArray([1, 1], dims='x'), xr.Dataset({'y': ('x', [1, 1])})] for arg in args: actual_mantissa, actual_exponent = np.frexp(arg) assert_identical(actual_mantissa, 0.5 * arg) assert_identical(actual_exponent, arg)
def hadamard(n): """ HADAMARD Hadamard matrix. HADAMARD(N) is a Hadamard matrix of order N, that is, a matrix H with elements 1 or -1 such that H*H' = N*EYE(N). An N-by-N Hadamard matrix with N>2 exists only if REM(N,4) = 0. This function handles only the cases where N, N/12 or N/20 is a power of 2. Reference: S.W. Golomb and L.D. Baumert, The search for Hadamard matrices, Amer. Math. Monthly, 70 (1963) pp. 12-17. http://en.wikipedia.org/wiki/Hadamard_matrix Weisstein, Eric W. "Hadamard Matrix." From MathWorld-- A Wolfram Web Resource: http://mathworld.wolfram.com/HadamardMatrix.html """ f, e = np.frexp(np.array([n, n / 12., n / 20.])) try: # If more than one condition is satified, this will always # pick the first one. k = [i for i in range(3) if (f == 0.5)[i] and (e > 0)[i]].pop() except IndexError: raise ValueError('N, N/12 or N/20 must be a power of 2.') e = e[k] - 1 if k == 0: # N = 1 * 2^e; h = np.array([1]) elif k == 1: # N = 12 * 2^e; tp = rogues.toeplitz(np.array([-1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1]), np.array([-1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1])) h = np.vstack((np.ones((1, 12)), np.hstack((np.ones((11, 1)), tp)))) elif k == 2: # N = 20 * 2^e; hk = rogues.hankel( np.array([-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1]), np.array([1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1])) h = np.vstack((np.ones((1, 20)), np.hstack((np.ones((19, 1)), hk)))) # Kronecker product construction. mh = -1 * h for i in range(e): ht = np.hstack((h, h)) hb = np.hstack((h, mh)) h = np.vstack((ht, hb)) mh = -1 * h return h
def exercise_frexp_t(self, tp): a = np.arange(5, dtype=tp) b = np.frexp(a) coeff = b[0] exp = b[1] for i in range(len(coeff)): x = coeff[i] * pow(2, exp[i]) assert x == a[i]
def pSpectrum(data=None, samplefreq=44100): """Power spectrum computation. Compute the power spectrum of a data set using standard ffts, after padding the data set to the next higher power of 2. Assumes data is regularly sampled in the time domain. Parameters data : list or numpy array the signal for which the power spectrume will be computed arg2 : float The sample frequency for the data set, in Hz Returns ------- (powerspectrum, frequency) Tuple of numpy arrays with the computed power spectrum, and the associated frequency arrays (in Hz) """ npts = len(data) # we should window the data here if npts == 0: print( "? no data in pSpectrum") return # pad to the nearest higher power of 2 (a,b) = np.frexp(npts) if a <= 0.5: b = b = 1 npad = 2**b -npts if debugFlag: print("npts: %d npad: %d npad+npts: %d" % (npts, npad, npad+npts)) padw = np.append(data, np.zeros(npad)) npts = len(padw) sigfft = spFFT.fft(padw) nUniquePts = int(np.ceil((npts+1)/2.0)) # print nUniquePts sigfft = sigfft[0:nUniquePts] spectrum = abs(sigfft) spectrum = spectrum / float(npts) # scale by the number of points so that # the magnitude does not depend on the length # of the signal or on its sampling frequency spectrum = spectrum**2 # square it to get the power spmax = np.amax(spectrum) spectrum = spectrum + 1e-12*spmax # multiply by two (see technical document for details) # odd nfft excludes Nyquist point if npts % 2 > 0: # we've got odd number of points fft spectrum[1:len(spectrum)] = spectrum[1:len(spectrum)] * 2 else: spectrum[1:len(spectrum) -1] = spectrum[1:len(spectrum) - 1] * 2 # we've got even number of points fft freqAzero = np.arange(0, nUniquePts, 1.0) * (samplefreq / npts) return(spectrum, freqAzero)
def print_signum_latex(segments): print "=============\nLaTeX/Desmos signum (not simplified)\n-------------" sys.stdout.write("\\frac{{(1-\\operatorname{{signum}}(x-{}))}}{{2}}*{}".format( segments[0][XCOORD], segments[0][YCOORD])) for i in xrange(1, len(segments)): m, e = np.frexp(segments[i][SLOPE]) sys.stdout.write("+\\frac{{(\\operatorname{{signum}}" + "(x-{})+1)".format(segments[i-1][XCOORD]) + "(1-\\operatorname{{signum}}(x-{}))}}{{4}}".format(segments[i][XCOORD]) + "*({}+(x-{})*{}\\cdot 2^{{{}}})".format(segments[i-1][YCOORD], segments[i-1][XCOORD], m, e)) print "+\\frac{{(\\operatorname{{signum}}(x-{})+1)}}{{2}}*{}".format(segments[-1][XCOORD], segments[-1][YCOORD])
def from_npfloat(x, prec=113, rnd=round_fast): """Create a raw mpf from a numpy float, rounding if necessary. If prec >= 113, the result is guaranteed to represent exactly the same number as the input. If prec is not specified, use prec=113.""" y = float(x) if x == y: # ldexp overflows for float16 return from_float(y, prec, rnd) import numpy as np if np.isfinite(x): m, e = np.frexp(x) return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd) if np.isposinf(x): return finf if np.isneginf(x): return fninf return fnan
def encode(self, data): data = np.array(data) s = MuLaw.scale * data s = np.minimum(abs(s), MuLaw.clip) [f,e] = np.frexp(s + MuLaw.bias) step = np.floor(32 * f) - 16 # 4 bits chord = e - 8 # 3 bits sgn = (MuLaw.sign(data) == 1) # 1 bit mu = 16 * chord + step # 7-bit coding mu = 127 - mu # bits inversion mu = 128 * sgn + mu # final 8-bit coding return np.array(mu, dtype=np.uint8)
def frexp(x): # Not actually object dtype, just need to specify something tmp = elemwise(np.frexp, x, dtype=object) left = 'mantissa-' + tmp.name right = 'exponent-' + tmp.name ldsk = {(left,) + key[1:]: (getitem, key, 0) for key in core.flatten(tmp.__dask_keys__())} rdsk = {(right,) + key[1:]: (getitem, key, 1) for key in core.flatten(tmp.__dask_keys__())} a = np.empty((1, ), dtype=x.dtype) l, r = np.frexp(a) ldt = l.dtype rdt = r.dtype L = Array(sharedict.merge(tmp.dask, (left, ldsk)), left, chunks=tmp.chunks, dtype=ldt) R = Array(sharedict.merge(tmp.dask, (right, rdsk)), right, chunks=tmp.chunks, dtype=rdt) return L, R
def round_to_n(x, n): if not (type(n) is int or np.issubdtype(n, np.integer)): raise TypeError("RoundToSigFigs: sigfigs must be an integer.") if not np.all(np.isreal(x)): raise TypeError("RoundToSigFigs: all x must be real.") if n <= 0: raise ValueError("RoundtoSigFigs: sigfigs must be positive.") mantissas, binary_exps = np.frexp(x) decimal_exps = __logBase10of2 * binary_exps intParts = np.floor(decimal_exps) mantissas *= 10.0 ** (decimal_exps - intParts) return np.around(mantissas, decimals=n - 1) * 10.0 ** intParts
def round_to_sigfigs(x, sigfigs): """ N.B Stolen from stack overflow: http://stackoverflow.com/questions/18915378/rounding-to-significant-figures-in-numpy Rounds the value(s) in x to the number of significant figures in sigfigs. Restrictions: sigfigs must be an integer type and store a positive value. x must be a real value or an array like object containing only real values. """ #The following constant was computed in maxima 5.35.1 using 64 bigfloat digits of precision __logBase10of2 = 3.010299956639811952137388947244930267681898814621085413104274611e-1 if not ( type(sigfigs) is int or np.issubdtype(sigfigs, np.integer)): raise TypeError( "RoundToSigFigs: sigfigs must be an integer." ) if not np.all(np.isreal( x )): raise TypeError( "RoundToSigFigs: all x must be real." ) if sigfigs <= 0: raise ValueError( "RoundtoSigFigs: sigfigs must be positive." ) mantissas, binaryExponents = np.frexp(x) decimalExponents = __logBase10of2 * binaryExponents intParts = np.floor(decimalExponents) mantissas *= 10.0**(decimalExponents - intParts) return np.around(mantissas, decimals=sigfigs - 1 ) * 10.0**intParts
def sp_expm(data, sparse=True): """ Sparse matrix exponential. """ A = data.tocsc() # extract Qobj data (sparse matrix) m_vals = np.array([3, 5, 7, 9, 13]) theta = np.array([0.01495585217958292, 0.2539398330063230, 0.9504178996162932, 2.097847961257068, 5.371920351148152], dtype=float) normA = sp_one_norm(data) if normA <= theta[-1]: for ii in range(len(m_vals)): if normA <= theta[ii]: F = _pade(A, m_vals[ii], sparse) break else: t, s = np.frexp(normA / theta[-1]) s = s - (t == 0.5) A = A / 2.0 ** s F = _pade(A, m_vals[-1], sparse) for i in range(s): F = F * F return F
def pbdesign(n, keep=None): """ Generate a Plackett-Burman design Parameter --------- n : int The multiple of 4 higher than the number of factors. Optional -------- keep : int The actual number of factors that the matrix will be used for (default: n). Returns ------- H : 2d-array An orthogonal design matrix with n rows, and (n-1) columns. Example ------- Create a 5-factor design:: >>> pbdesign(8) # since 8 is the next heigher multiple of 4 array([[ 1., 1., 1., 1., 1., 1., 1.], [-1., 1., -1., 1., -1., 1., -1.], [ 1., -1., -1., 1., 1., -1., -1.], [-1., -1., 1., 1., -1., -1., 1.], [ 1., 1., 1., -1., -1., -1., -1.], [-1., 1., -1., -1., 1., -1., 1.], [ 1., -1., -1., -1., -1., 1., 1.], [-1., -1., 1., -1., 1., 1., -1.]]) And if we only want to keep the needed five columns:: >>> pbdesign(8, keep=5) array([[ 1., 1., 1., 1., 1.], [-1., 1., -1., 1., -1.], [ 1., -1., -1., 1., 1.], [-1., -1., 1., 1., -1.], [ 1., 1., 1., -1., -1.], [-1., 1., -1., -1., 1.], [ 1., -1., -1., -1., -1.], [-1., -1., 1., -1., 1.]]) """ f, e = np.frexp([n, n/12., n/20.]) k = [idx for idx, val in enumerate(np.logical_and(f==0.5, e>0)) if val] assert isinstance(n, int) and k!=[], 'Invalid inputs. n must be a multiple of 4.' k = k[0] e = e[k] - 1 if k==0: # N = 1*2**e H = np.ones((1, 1)) elif k==1: # N = 12*2**e H = np.vstack((np.ones((1, 12)), np.hstack((np.ones((11, 1)), toeplitz([-1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1], [-1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1]))))) elif k==2: # N = 20*2**e H = np.vstack((np.ones((1, 20)), np.hstack((np.ones((19, 1)), hankel( [-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1], [1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1]) )))) # Kronecker product construction for i in xrange(e): H = np.vstack((np.hstack((H, H)), np.hstack((H, -H)))) if keep is not None: assert keep<=(H.shape[1]-1), 'Too many variables specified in "keep" for matrix' return H[:, 1:(keep + 1)] else: return H[:, 1:]
def test_ufunc_two_outputs(self): mantissa, exponent = np.frexp(2**-3) expected = (ArrayLike(mantissa), ArrayLike(exponent)) _assert_equal_type_and_value(np.frexp(ArrayLike(2**-3)), expected) _assert_equal_type_and_value(np.frexp(ArrayLike(np.array(2**-3))), expected)
def ValueWithUncsRounding( x, uncs, uncsigfigs=1 ): """ Rounds all of the values in uncs (the uncertainties) to the number of significant figures in uncsigfigs. Then rounds the values in x to the same decimal pace as the values in uncs. Return value is a two element tuple each element of which has the same type as x and uncs, respectively. Restrictions: - uncsigfigs must be a positive integer. - x must be a real value or an array like object containing only real values. - uncs must be a real value or an array like object containing only real values. """ if not ( type(uncsigfigs) is int or type(uncsigfigs) is long or isinstance(uncsigfigs, np.integer) ): raise TypeError( "ValueWithUncsRounding: uncsigfigs must be an integer." ) if uncsigfigs <= 0: raise ValueError( "ValueWithUncsRounding: uncsigfigs must be positive." ) if not np.all(np.isreal( x )): raise TypeError( "ValueWithUncsRounding: all x must be real." ) if not np.all(np.isreal( uncs )): raise TypeError( "ValueWithUncsRounding: all uncs must be real." ) if np.any( uncs <= 0 ): raise ValueError( "ValueWithUncsRounding: uncs must all be positive." ) #temporarily suppres floating point errors errhanddict = np.geterr() np.seterr(all="ignore") matrixflag = False if isinstance(x, np.matrix): #Convert matrices to arrays matrixflag = True x = np.asarray(x) #Pre-round unc to correctly handle cases where rounding alters the # most significant digit of unc. uncs = RoundToSigFigs_fp( uncs, uncsigfigs ) mantissas, binaryExponents = np.frexp( uncs ) decimalExponents = __logBase10of2 * binaryExponents omags = np.floor(decimalExponents) mantissas *= 10.0**(decimalExponents - omags) if type(mantissas) is float or np.issctype(np.dtype(mantissas)): if mantissas < 1.0: mantissas *= 10.0 omags -= 1.0 else: #elif np.all(np.isreal( mantissas )): fixmsk = mantissas < 1.0 mantissas[fixmsk] *= 10.0 omags[fixmsk] -= 1.0 scales = 10.0**omags prec = uncsigfigs - 1 result = ( np.around( x / scales, decimals=prec ) * scales, np.around( mantissas, decimals=prec ) * scales ) if matrixflag: result = np.matrix(result, copy=False) np.seterr(**errhanddict) return result
# construct the response curve and plot the figure exp = [ 32, 16, 8, 4, 2, 1, 0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625, 0.007125, 0.00390625, 0.001953125, 0.00097656525 ] cur = Constructing.ResponseCurve(num, img, exp) hdr = Constructing.RadianceMap(num, img, exp, cur) print(np.array(hdr)[:, :, 0]) # np.save("hdr", np.array(hdr)) # hdr = np.load("hdr.npy") # create hdr resultant image (brighter = mantissa * 2 ^ exponent) brighter = np.max(hdr, axis=2) mantissa = np.zeros_like(brighter) exponent = np.zeros_like(brighter) np.frexp(brighter, mantissa, exponent) rgbvalue = mantissa * 256.0 / brighter res = np.zeros((np.shape(hdr)[0], np.shape(hdr)[1], 4), dtype=np.uint8) res[:, :, 0] = np.around(hdr[:, :, 2] * rgbvalue) res[:, :, 1] = np.around(hdr[:, :, 1] * rgbvalue) res[:, :, 2] = np.around(hdr[:, :, 0] * rgbvalue) res[:, :, 3] = np.around(exponent + 128) fin = np.zeros((np.shape(hdr)[0], np.shape(hdr)[1], 3)) fin[:, :, 0] = res[:, :, 2] * np.power(2, exponent) fin[:, :, 1] = res[:, :, 1] * np.power(2, exponent) fin[:, :, 2] = res[:, :, 0] * np.power(2, exponent) ImageFileIO.Write(1, ".", fin)
def compress_float_array(arr: np.array) -> np.array: """ Takes a numpy array with dtype.kind = 'f', and checks to see which bits are used in the float, then returns the compressed array as a float16, float32, or float64 in a loss-less format :param arr: numpy array of floats :return: compressed array """ if arr.dtype.kind != 'f': raise ArrayNotFloatException # filter out NaN values not_nan = arr[~np.isnan(arr)] if not_nan.size == 0: return arr.astype(np.float16) # put the array into a byte array bytes_dtype = np.dtype([('byte_{}'.format(i), np.uint8) for i in range(0, arr.itemsize)]) byte_array = np.frombuffer(not_nan.tobytes(), dtype=bytes_dtype) byte_arr_len = byte_array['byte_0'].shape[0] # mantissa is X bits long, with left-right having value of # 0.5 * 2^(i) big_endian_nth_byte = dict([('byte_{}'.format(i), 'byte_{}'.format(arr.itemsize - i - 1)) for i in range(0, arr.itemsize)]) if arr.itemsize == 8: # numpy 64-bit float has 52 bits of mantissa # in order to compress to 32-bit float, we need to pack mantissa into # 23 bits. This means we need 52-23=29 bits of zeros on the end. # that means that the 3 right-most bytes must be zero # and that the 4th right-most byte must have 5 right-most bits = 0 # we'll check this by seeing if '0001 1111' & byte == 0. (0001 1111 is 31) # finally, we'll need to check the exponent compression # first check the 4th right-most byte. it's most likely to have the # significant bits we can't drop bitwise_reduction = np.bitwise_and( byte_array[big_endian_nth_byte['byte_4']], np.full(byte_arr_len, 31, dtype=np.uint8)) if np.count_nonzero(bitwise_reduction) > 0: return arr # next check the remaining bits if np.count_nonzero(byte_array[big_endian_nth_byte['byte_5']]) > 0 \ or np.count_nonzero(byte_array[big_endian_nth_byte['byte_6']]) > 0 \ or np.count_nonzero(byte_array[big_endian_nth_byte['byte_7']]) > 0: return arr # finally check the exponent. in 64-bit float, exponent can be +/- 1024. # in 32-bit float, exponent can be +/-128 # do this the easy way and get this from numpy bitwise_exponent = np.frexp(not_nan)[1] if np.amax(bitwise_exponent) > 128 or np.amin(bitwise_exponent) < -128: return arr # else, we're good to go onto 32-bit reduction return compress_float_array(arr.astype(np.float32)) if arr.itemsize == 4: # numpy 32-bit float has 23 bits of mantissa. # numpy 16-bit float has 10 bits mantissa. # we require the right-most 13-bits to be zero. byte_3 (4th byte) # must be all zero, and byte_2 (3rd byte) must have # the 5 right-most bits be zero. We will bitwise-and against 31 # (0001 1111) to see if it complies bitwise_reduction = np.bitwise_and( byte_array[big_endian_nth_byte['byte_2']], np.full(byte_arr_len, 31, dtype=np.uint8)) if np.count_nonzero(bitwise_reduction) > 0: return arr # next check the 4th byte for zeros if np.count_nonzero(byte_array[big_endian_nth_byte['byte_3']]) > 0: return arr # finally, check exponent. In 32-bit float, exponent can be +/- 128 # in 16-bit float, exponent can be +/-16 bitwise_exponent = np.frexp(not_nan)[1] if np.amax(bitwise_exponent) > 16 or np.amin(bitwise_exponent) < -16: return arr # else, return compressed return arr.astype(np.float16) return arr
def main(): parser = create_parser() args = parser.parse_args() if args.params_json: with open(args.params_json, "r") as f: models_params = json.load(f) else: models_params = {} print(models_params) fft_lut_file = args.fft_lut_file if not "fft_lut_file" in models_params else models_params[ "fft_lut_file"] mfcc_bf_lut_file = args.mfcc_bf_lut_file if not "mfcc_bf_lut_file" in models_params else models_params[ "mfcc_bf_lut_file"] use_tf_mfcc = args.use_tf_mfcc if not "use_tf_mfcc" in models_params else models_params[ "use_tf_mfcc"] use_librosa = args.use_librosa if not "use_librosa" in models_params else models_params[ "use_librosa"] sample_rate = args.sample_rate if not "sample_rate" in models_params else models_params[ "sample_rate"] frame_size = args.frame_size if not "frame_size" in models_params else models_params[ "frame_size"] frame_step = args.frame_step if not "frame_step" in models_params else models_params[ "frame_step"] window_fn = args.win_func if not "win_func" in models_params else models_params[ "win_func"] gen_inv = args.gen_inv if not "gen_inv" in models_params else models_params[ "gen_inv"] name_suffix = args.name_suffix if not "name_suffix" in models_params else models_params[ "name_suffix"] n_fft = args.n_fft if not "n_fft" in models_params else models_params[ "n_fft"] fmax = args.fmax if not "fmax" in models_params else models_params["fmax"] fmin = args.fmin if not "fmin" in models_params else models_params["fmin"] librosa_mel_norm = args.librosa_mel_norm if not "librosa_mel_norm" in models_params else models_params[ "librosa_mel_norm"] mfcc_bank_cnt = args.mfcc_bank_cnt if not "mfcc_bank_cnt" in models_params else models_params[ "mfcc_bank_cnt"] n_dct = args.n_dct if not "n_dct" in models_params else models_params[ "n_dct"] dct_type = args.dct_type if not "dct_type" in models_params else models_params[ "dct_type"] dct_norm = args.dct_norm if not "dct_norm" in models_params else models_params[ "dct_norm"] lifter_coeff = args.lifter_coeff if not "lifter_coeff" in models_params else models_params[ "lifter_coeff"] dtype = args.dtype if not "dtype" in models_params else models_params[ "dtype"] mel_filterbanks_file = args.mel_filterbanks_file if not "mel_filterbanks_file" in models_params else models_params[ "mel_filterbanks_file"] dct_matrix_file = args.dct_matrix_file if not "dct_matrix_file" in models_params else models_params[ "dct_matrix_file"] lut_dtype = "int" if dtype == "fix16" or dtype == "fix32_scal" else dtype n_fft_int = n_fft if dtype == "fix32_scal" else n_fft // 2 if lut_dtype == "int": data_type = "short int" elif lut_dtype == "float16": data_type = "F16_DSP" elif lut_dtype == "float32": data_type = "float" else: raise NotImplemented( f"lut_dtype = {lut_dtype} not implemeted, available ['fix16' 'fix32_scal' 'float32' 'float16']" ) print(lut_dtype, name_suffix, n_fft_int) win_func = getattr(np, window_fn) win_lut = win_func(frame_size) if lut_dtype == "int": Window = (win_lut * 2**(15)).astype(np.int16) else: Window = win_lut.astype(np.float32) if gen_inv: inv_win_lut = win_lut / (win_lut**2 + 1e-8) if lut_dtype == "int": base, exp = np.frexp(inv_win_lut) InvWindow = np.empty(base.size + exp.size) InvWindow[0::2] = np.round(base * 2**8).astype(np.uint8) InvWindow[1::2] = exp.astype(np.uint8) InvWindow = InvWindow.astype(np.int32) else: InvWindow = inv_win_lut.astype(np.float32) Twiddles_cos, Twiddles_sin = SetupTwiddlesLUT(n_fft_int, dtype=lut_dtype) if round(math.log(n_fft_int, 4)) == math.log(n_fft_int, 4): SwapTableR4 = SetupSwapTableR4(n_fft_int) Twiddles_cosR4, Twiddles_sinR4 = Twiddles_cos[:int( 3 / 4 * n_fft_int)], Twiddles_sin[:int(3 / 4 * n_fft_int)] print("Setting up twiddles for radix 4 ", len(Twiddles_cosR4)) SwapTableR2 = SetupSwapTable(n_fft_int) Twiddles_cosR2, Twiddles_sinR2 = Twiddles_cos[:int( n_fft_int // 2)], Twiddles_sin[:int(n_fft_int // 2)] print("Setting up twiddles for radix 2 ", len(Twiddles_cosR2)) RFFTTwiddles_real, RFFTTwiddles_imag = SetupTwiddlesRFFT(n_fft, dtype=lut_dtype) if n_dct > 0: if dct_matrix_file: DCT_Coeff = convert_dtype(np.load(dct_matrix_file), lut_dtype, DCT_TWIDDLE_DYN) else: DCT_Coeff = SetupDCTTable(n_dct, dct_type, lut_dtype, dct_norm) if lifter_coeff > 0: Lift_Coeff = SetupLiftCoeff(lifter_coeff, n_dct, lut_dtype) ################################ WRITE TO FILE ####################################### Out_str = array_to_def_c_file(Window, f"WindowLUT{name_suffix}", data_type, frame_size, elem_in_rows=12) if gen_inv: if dtype == "int": Out_str += array_to_def_c_file(InvWindow, f"InvWindowLUT{name_suffix}", "unsigned char", 2 * frame_size, elem_in_rows=12) else: Out_str += array_to_def_c_file(InvWindow, f"InvWindowLUT{name_suffix}", data_type, frame_size, elem_in_rows=12) if round(math.log(n_fft_int, 4)) == math.log( n_fft_int, 4) and not dtype == "fix32_scal": Out_str += array_to_def_c_file(SwapTableR4.astype(np.int16), f"SwapTable{name_suffix}", "short int", n_fft_int, elem_in_rows=2) else: Out_str += array_to_def_c_file(SwapTableR2.astype(np.int16), f"SwapTable{name_suffix}", "short int", n_fft_int, elem_in_rows=2) # FFT if dtype == "fix32_scal": # only rad2 for fix32_scale Out_str += "PI_L2 {} TwiddlesLUT{}[{}] = {{\n".format( data_type, name_suffix, 2 * len(Twiddles_cosR2)) for i in range(len(Twiddles_cosR2)): Out_str += "\t {:>6}, {:>6}, \n".format(Twiddles_cosR2[i], Twiddles_sinR2[i]) Out_str += "\n};\n\n" else: if round(math.log(n_fft_int, 4)) == math.log(n_fft_int, 4): Out_str += "PI_L2 {} TwiddlesLUT{}[{}] = {{\n".format( data_type, name_suffix, 2 * len(Twiddles_cosR4)) for i in range(len(Twiddles_cosR4)): Out_str += "\t {:>6}, {:>6}, \n".format( Twiddles_cosR4[i], Twiddles_sinR4[i]) Out_str += "\n};\n\n" else: Out_str += "PI_L2 {} TwiddlesLUT{}[{}] = {{\n".format( data_type, name_suffix, 2 * len(Twiddles_cosR2)) for i in range(len(Twiddles_cosR2)): Out_str += "\t {:>6}, {:>6}, \n".format( Twiddles_cosR2[i], Twiddles_sinR2[i]) Out_str += "\n};\n\n" Out_str += "PI_L2 {} RFFTTwiddlesLUT{}[{}] = {{\n".format( data_type, name_suffix, 2 * len(RFFTTwiddles_real)) for i in range(len(RFFTTwiddles_real)): Out_str += "\t {:>6}, {:>6}, \n".format(RFFTTwiddles_real[i], RFFTTwiddles_imag[i]) Out_str += "\n};\n\n" # DCT if n_dct > 0: Out_str += array_to_def_c_file(DCT_Coeff.flatten(), f"DCT_Coeff{name_suffix}", data_type, n_dct * n_dct, elem_in_rows=n_dct) if lifter_coeff > 0: Out_str += array_to_def_c_file(Lift_Coeff.flatten(), f"Lift_Coeff{name_suffix}", data_type, n_dct, elem_in_rows=n_dct) with open(fft_lut_file, 'w') as f: f.write(Out_str) if mfcc_bf_lut_file: ##################################################################################### # MFCC if mel_filterbanks_file: filters = np.load(mel_filterbanks_file) elif use_tf_mfcc: from SetupLUT import GenMFCC_FB_tf filters = GenMFCC_FB_tf(n_fft, mfcc_bank_cnt, Fmin=fmin, Fmax=fmax, sample_rate=sample_rate, dtype=lut_dtype) elif use_librosa: from SetupLUT import GenMFCC_FB_librosa filters = GenMFCC_FB_librosa(n_fft, mfcc_bank_cnt, Fmin=fmin, Fmax=fmax, sample_rate=sample_rate, norm=librosa_mel_norm, dtype=lut_dtype) else: from SetupLUT import GenMFCC_FB filters = GenMFCC_FB(n_fft, mfcc_bank_cnt, Fmin=fmin, Fmax=fmax, sample_rate=sample_rate, dtype=lut_dtype) MfccLUT, HeadCoeff = GenMelFilterBanksCode(filters, mfcc_bank_cnt, fmin, fmax, lut_dtype, data_type, name_suffix) with open(mfcc_bf_lut_file, "w") as f: f.write(MfccLUT) if args.save_params_header: with open(args.save_params_header, "w") as f: f.write("#define\t{:21}{:>10}\n".format("SAMPLERATE", sample_rate)) f.write("#define\t{:21}{:>10}\n".format("FRAME_SIZE", frame_size)) f.write("#define\t{:21}{:>10}\n".format("FRAME_STEP", frame_step)) f.write("#define\t{:21}{:>10}\n".format("N_FFT", n_fft)) f.write("#define\t{:21}{:>10}\n".format( "DATA_TYPE", 2 if dtype == "float16" else (3 if dtype == "float32" else (1 if dtype == "fix32_scal" else 0)))) if mfcc_bf_lut_file: f.write("#define\t{:21}{:>10}\n".format( "MFCC_BANK_CNT", mfcc_bank_cnt)) f.write("#define\t{:21}{:>10}\n".format("FMIN", fmin)) f.write("#define\t{:21}{:>10}\n".format("FMAX", fmax)) f.write("#define\t{:21}{:>10}\n".format( "MFCC_COEFF_CNT", HeadCoeff + 1)) f.write("#define\t{:21}{:>10}\n".format("N_DCT", n_dct))
def test_frexp_array(self): q = np.frexp(np.array([2., 3., 6.]) * u.m / (6. * u.m)) assert all((_q0, _q1) == np.frexp(_d) for _q0, _q1, _d in zip(q[0], q[1], [1. / 3., 1. / 2., 1.]))
def test_ufunc_frexp_u(A: dace.uint32[10]): Q, R = np.frexp(A) return Q, R
def FormatValWithUncRounding( x, unc, uncsigfigs=1, sciformat=True ): """ Rounds unc (the uncertainty) to the number of significant figures in uncsigfigs. Then rounds the value in x to the same decimal pace as the value in unc. Uses the decimal package for maximal accuracy. Return value is a tuple containing two strings. The keyword argument sciformat will force scientific notation if true. Restrictions: - uncsigfigs must be a positive integer. - x must be a real value or floating point. - unc must be a real value or floating point """ if not ( type(uncsigfigs) is int or type(uncsigfigs) is long or isinstance(uncsigfigs, np.integer) ): raise TypeError( "FormatValWithUncRounding: uncsigfigs must be an integer." ) if uncsigfigs <= 0: raise ValueError( "FormatValWithUncRounding: uncsigfigs must be positive." ) if not np.isreal(x): raise TypeError( "FormatValWithUncRounding: x must be real." ) if not np.isreal(unc) or unc <= 0.0: raise TypeError( "FormatValWithUncRounding: unc must be a positive real." ) if isinstance(x, np.matrix): #Convert matrices to arrays x = np.asarray(x) #sys.stderr.write("Warning: FormatValWithUncRounding is untested.\n") #Pre-round unc to correctly handle cases where rounding alters the # most significant digit of unc. unc = RoundToSigFigs_fp( unc, uncsigfigs ) xsgn = np.sign(x) absx = xsgn * x mantissa, binaryExponent = np.frexp( absx ) uncmant, uncbinExponent = np.frexp( unc ) decimalExponent = __logBase10of2 * binaryExponent uncdecExponent = __logBase10of2 * uncbinExponent omag = np.floor(decimalExponent) uncomag = np.floor(uncdecExponent) uncmant *= 10**(uncdecExponent - uncomag) if not np.isnan(uncmant) and uncmant < 1.0: uncmant *= 10.0 uncomag -= 1.0 mantissa *= 10**(decimalExponent - omag) if not np.isnan(mantissa) and mantissa < 1.0: mantissa *= 10.0 omag -= 1.0 omagdiff = omag - uncomag prec = uncsigfigs - 1 + int(omagdiff) mantissa, uncOut = ( np.around( mantissa, decimals=prec ), np.around( unc * 10**(-omag), decimals=prec ) ) if sciformat: def formatter( m, u, e, prec ): s = "{:." + str(max(prec, 0)) + "f}e{:+d}" return (s.format(m, int(e)), s.format(u, int(e))) else: def formatter( m, u, e, prec ): s = "{:." + str(max(prec, 0)) + "g}" return (s.format(m*10.0**e), s.format(u*10**e)) return formatter( mantissa, uncOut, omag, prec )
for i in range(0, npoly - 1): A[:, i + 1] = A[:, i] * x A = np.matrix(A) # Convert A to numpy matrix d = np.matrix(y).transpose() # SVD decomposition u, s, vt = np.linalg.svd(A, False) sinv = np.matrix(np.diag( 1.0 / s)) #s comes back as a 1-d array, turn it into a 2-d matrix fit_params = vt.transpose() * sinv * (u.transpose() * d ) # Best fit Chebyshev coeffs. poly_fit = A * fit_params # Best fit truncated Chebyshev poly. ############################## ####### PLOTTING ####### ############################## #################################### ####### Return log2(t) ####### #################################### # Break down the input number into x = y1*2**y2, where y1 is in [0,1]. y1, y2 = np.frexp(t) # Take the log2(x) answer = np.polynomial.chebyshev.chebval(y1, cheb_fit_params)[0] + y2 # Print the result to the user print("log2(t) = ", answer)
def depart(in_min, in_max): tmp_l = [] a = np.frexp(in_min) b = np.frexp(in_max) tmp_j = 0 if (in_min < 0) & (in_max > 0): if in_min >= -1.0: tmp_l.append([in_min, 0]) else: for i in range(1, a[1] + 1): tmp_i = np.ldexp(-0.5, i) tmp_l.append([tmp_i, tmp_j]) tmp_j = tmp_i if in_min != tmp_j: tmp_l.append([in_min, tmp_j]) tmp_j = 0 if in_max <= 1.0: tmp_l.append([0, in_max]) else: for i in range(1, b[1] + 1): tmp_i = np.ldexp(0.5, i) tmp_l.append([tmp_j, tmp_i]) tmp_j = tmp_i if in_max != tmp_j: tmp_l.append([tmp_j, in_max]) tmp_j = 0 if (in_min < 0) & (0 >= in_max): if in_min >= -1: tmp_l.append([in_min, in_max]) return tmp_l else: if in_max > -1: tmp_l.append([-1, in_max]) tmp_j = -1.0 for i in range(2, a[1] + 1): tmp_i = np.ldexp(-0.5, i) tmp_l.append([tmp_i, tmp_j]) tmp_j = tmp_i if in_min != tmp_j: tmp_l.append([in_min, tmp_j]) else: if a[1] == b[1]: tmp_l.append([in_min, in_max]) return tmp_l else: tmp_j = np.ldexp(-0.5, b[1] + 1) tmp_l.append([tmp_j, in_max]) if tmp_j != in_min: for i in range(b[1] + 2, a[1] + 1): tmp_i = np.ldexp(-0.5, i) tmp_l.append([tmp_i, tmp_j]) tmp_j = tmp_i if in_min != tmp_j: tmp_l.append([in_min, tmp_j]) tmp_j = 0 if (in_min >= 0) & (in_max > 0): if in_max <= 1: tmp_l.append([in_min, in_max]) return tmp_l else: if in_min < 1: tmp_l.append([in_min, 1]) tmp_j = 1.0 for i in range(2, b[1] + 1): tmp_i = np.ldexp(0.5, i) tmp_l.append([tmp_j, tmp_i]) tmp_j = tmp_i if in_max != tmp_j: tmp_l.append([tmp_j, in_max]) else: if a[1] == b[1]: tmp_l.append([in_min, in_max]) return tmp_l else: tmp_j = np.ldexp(0.5, a[1] + 1) tmp_l.append([in_min, tmp_j]) if tmp_j != in_max: for i in range(a[1] + 2, b[1] + 1): tmp_i = np.ldexp(0.5, i) tmp_l.append([tmp_j, tmp_i]) tmp_j = tmp_i if in_max != tmp_j: tmp_l.append([tmp_j, in_max]) return tmp_l
import numpy as np x= np.arange(9) y1, y2=np.frexp(x) print("frexp 9 mantissa:, ", y1) print("frexp 9 exponent:, ", y2) print("result: ", y1* 2**y2)
def pbdesign(n): """ Generate a Plackett-Burman design Parameter --------- n : int The number of factors to create a matrix for. Returns ------- H : 2d-array An orthogonal design matrix with n columns, one for each factor, and the number of rows being the next multiple of 4 higher than n (e.g., for 1-3 factors there are 4 rows, for 4-7 factors there are 8 rows, etc.) Example ------- A 3-factor design:: >>> pbdesign(3) array([[-1., -1., 1.], [ 1., -1., -1.], [-1., 1., -1.], [ 1., 1., 1.]]) A 5-factor design:: >>> pbdesign(5) array([[-1., -1., 1., -1., 1.], [ 1., -1., -1., -1., -1.], [-1., 1., -1., -1., 1.], [ 1., 1., 1., -1., -1.], [-1., -1., 1., 1., -1.], [ 1., -1., -1., 1., 1.], [-1., 1., -1., 1., -1.], [ 1., 1., 1., 1., 1.]]) """ assert n>0, 'Number of factors must be a positive integer' keep = int(n) n = 4*(int(n/4) + 1) # calculate the correct number of rows (multiple of 4) f, e = np.frexp([n, n/12., n/20.]) k = [idx for idx, val in enumerate(np.logical_and(f==0.5, e>0)) if val] assert isinstance(n, int) and k!=[], 'Invalid inputs. n must be a multiple of 4.' k = k[0] e = e[k] - 1 if k==0: # N = 1*2**e H = np.ones((1, 1)) elif k==1: # N = 12*2**e H = np.vstack((np.ones((1, 12)), np.hstack((np.ones((11, 1)), toeplitz([-1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1], [-1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1]))))) elif k==2: # N = 20*2**e H = np.vstack((np.ones((1, 20)), np.hstack((np.ones((19, 1)), hankel( [-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1], [1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1]) )))) # Kronecker product construction for i in range(e): H = np.vstack((np.hstack((H, H)), np.hstack((H, -H)))) # Reduce the size of the matrix as needed H = H[:, 1:(keep + 1)] return np.flipud(H)
def func((x, err), chop=1): frac = x * m k = (frac < 0.5) + 1 # top=1, bot=2 frac *= k # normalized if term: chop += k * term return frac, chop / frac + err if not const: return func # factor <= 96 bits return lambda (x, err): func((x, err + const)) s73 = scale_func(1e-73 / 2**-242, 0.2208, 0.2987) s60 = scale_func(1e+60 / 2**+200, 0.0994, 0.2798) s25 = scale_func(1e+25 / 2**84, 0.2503) s12 = scale_func(1e+12 / 2**40) si = np.frexp(10.**np.arange(1, 13))[0] def abs_err((x, err), scales, x0_dec_err=None): frac = x for mi in scales: xf = x * mi xf *= (xf < 0.5) + 1 frac = xf if frac is x else np.maximum(frac, xf) err = err * frac # rel err -> abs err chop = bool(len(scales)) if x0_dec_err is not None: # Add dec_err generated ULP err = err + np.floor(x0_dec_err * frac) if SHOW_ABS_ERR: for i in err: print i + chop
('tanh', 'double(double)', np.tanh), ('arcsinh', 'double(double)', np.arcsinh), ('arccosh', 'double(double)', np.arccosh), ('arctanh', 'double(double)', np.arctanh), # Exp-log functions: ('exp', 'double(double)', np.exp), ('expm1', 'double(double)', np.expm1), ('exp2', 'double(double)', np.exp2), ('log', 'double(double)', np.log), ('log10', 'double(double)', np.log10), ('log2', 'double(double)', np.log2), ('log1p', 'double(double)', np.log1p), ('logaddexp', 'double(double, double)', np.logaddexp), ('logaddexp2', 'double(double, double)', np.logaddexp2), ('ldexp', 'double(double, int)', np.ldexp), ('frexp0', 'double(double)', lambda x: np.frexp(x)[0]), # Rounding functions: ('around', 'double(double)', lambda x: np.around(x)), ( 'round2', # round and round_ are not good names 'double(double)', lambda x: np.round_(x)), # force arity to 1 ('floor', 'double(double)', np.floor), ('ceil', 'double(double)', np.ceil), ('trunc', 'double(double)', np.trunc), ('rint', 'double(double)', np.rint), ('spacing', 'double(double)', np.spacing), ('nextafter', 'double(double, double)', np.nextafter), # Rational functions: ('gcd', 'int(int, int)', np.gcd), ('lcm', 'int(int, int)', np.lcm),
def g(x): x, exp = numpy.frexp(x) return numpy.array(utils.poly.eval_multi(p, mpmath.matrix(x)), numpy.double) * post_factor[exp - exp0]
def iterate(self): """Perform one step in the algorithm. Implements Algorithm 4.1(k=1) or 4.2(k=2) in [APS1995] """ self.iterations += 1 eps = np.finfo(float).eps d, fd, e, fe = self.d, self.fd, self.e, self.fe ab_width = self.ab[1] - self.ab[0] # Need the start width below c = None for nsteps in range(2, self.k+2): # If the f-values are sufficiently separated, perform an inverse # polynomial interpolation step. Otherwise nsteps repeats of # an approximate Newton-Raphson step. if _notclose(self.fab + [fd, fe], rtol=0, atol=32*eps): c0 = _inverse_poly_zero(self.ab[0], self.ab[1], d, e, self.fab[0], self.fab[1], fd, fe) if self.ab[0] < c0 < self.ab[1]: c = c0 if c is None: c = _newton_quadratic(self.ab, self.fab, d, fd, nsteps) fc = self._callf(c) if fc == 0: return _ECONVERGED, c # re-bracket e, fe = d, fd d, fd = self._update_bracket(c, fc) # u is the endpoint with the smallest f-value uix = (0 if np.abs(self.fab[0]) < np.abs(self.fab[1]) else 1) u, fu = self.ab[uix], self.fab[uix] _, A = _compute_divided_differences(self.ab, self.fab, forward=(uix == 0), full=False) c = u - 2 * fu / A if np.abs(c - u) > 0.5 * (self.ab[1] - self.ab[0]): c = sum(self.ab) / 2.0 else: if np.isclose(c, u, rtol=eps, atol=0): # c didn't change (much). # Either because the f-values at the endpoints have vastly # differing magnitudes, or because the root is very close to # that endpoint frs = np.frexp(self.fab)[1] if frs[uix] < frs[1 - uix] - 50: # Differ by more than 2**50 c = (31 * self.ab[uix] + self.ab[1 - uix]) / 32 else: # Make a bigger adjustment, about the # size of the requested tolerance. mm = (1 if uix == 0 else -1) adj = mm * np.abs(c) * self.rtol + mm * self.xtol c = u + adj if not self.ab[0] < c < self.ab[1]: c = sum(self.ab) / 2.0 fc = self._callf(c) if fc == 0: return _ECONVERGED, c e, fe = d, fd d, fd = self._update_bracket(c, fc) # If the width of the new interval did not decrease enough, bisect if self.ab[1] - self.ab[0] > self._MU * ab_width: e, fe = d, fd z = sum(self.ab) / 2.0 fz = self._callf(z) if fz == 0: return _ECONVERGED, z d, fd = self._update_bracket(z, fz) # Record d and e for next iteration self.d, self.fd = d, fd self.e, self.fe = e, fe status, xn = self.get_status() return status, xn
def test_frexp_scalar(self): q = np.frexp(3. * u.m / (6. * u.m)) assert q == (np.array(0.5), np.array(0.0))
if _uint16: ext_dat += _bzero # Check to see whether there are any NaN's or infs which might indicate # a byte-swapping problem, such as being written out on little-endian # and being read in on big-endian or vice-versa. if _code.find("float") >= 0 and (numpy.any(numpy.isnan(ext_dat)) or numpy.any(numpy.isinf(ext_dat))): errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input + "[%d]\n" % (k + 1) errormsg += "= had floating point data values =\n" errormsg += "= of NaN and/or Inf. =\n" errormsg += "===================================\n" elif _code.find("int") >= 0: # Check INT data for max values ext_dat_frac, ext_dat_exp = numpy.frexp(ext_dat) if ext_dat_exp.max() == int(_bitpix) - 1: # Potential problems with byteswapping errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input + "[%d]\n" % (k + 1) errormsg += "= had integer data values =\n" errormsg += "= with maximum bitvalues. =\n" errormsg += "===================================\n" ext_hdu = fits.ImageHDU(data=ext_dat) rec = numpy.fromstring(dat[loc + data_size : loc + group_size], dtype=formats) loc += group_size
def _compare_losses(self, loss_1, loss_2, delta=1.e-2): (digits_1, exponent_1) = np.frexp(loss_1) (digits_2, exponent_2) = np.frexp(loss_2) self.assertEqual(exponent_1, exponent_2) self.assertAlmostEqual(digits_1, digits_2, delta=delta)
def readgeis(input): """Input GEIS files "input" will be read and a HDUList object will be returned. The user can use the writeto method to write the HDUList object to a FITS file. """ global dat cardLen = fits.Card.length # input file(s) must be of the form *.??h and *.??d if input[-1] != 'h' or input[-4] != '.': raise "Illegal input GEIS file name %s" % input data_file = input[:-1] + 'd' _os = sys.platform if _os[: 5] == 'linux' or _os[: 5] == 'win32' or _os[: 5] == 'sunos' or _os[: 3] == 'osf' or _os[: 6] == 'darwin': bytes_per_line = cardLen + 1 else: raise "Platform %s is not supported (yet)." % _os geis_fmt = {'REAL': 'f', 'INTEGER': 'i', 'LOGICAL': 'i', 'CHARACTER': 'S'} end_card = 'END' + ' ' * (cardLen - 3) # open input file im = open(input) # Generate the primary HDU cards = [] while 1: line = im.read(bytes_per_line)[:cardLen] line = line[:8].upper() + line[8:] if line == end_card: break cards.append(fits.Card.fromstring(line)) phdr = fits.Header(cards) im.close() _naxis0 = phdr.get('NAXIS', 0) _naxis = [phdr['NAXIS' + str(j)] for j in range(1, _naxis0 + 1)] _naxis.insert(0, _naxis0) _bitpix = phdr['BITPIX'] _psize = phdr['PSIZE'] if phdr['DATATYPE'][:4] == 'REAL': _bitpix = -_bitpix if _naxis0 > 0: size = reduce(lambda x, y: x * y, _naxis[1:]) data_size = abs(_bitpix) * size // 8 else: data_size = 0 group_size = data_size + _psize // 8 # decode the group parameter definitions, # group parameters will become extension header groups = phdr['GROUPS'] gcount = phdr['GCOUNT'] pcount = phdr['PCOUNT'] formats = [] bools = [] floats = [] _range = range(1, pcount + 1) key = [phdr['PTYPE' + str(j)] for j in _range] comm = [phdr.cards['PTYPE' + str(j)].comment for j in _range] # delete group parameter definition header keywords _list = ['PTYPE'+str(j) for j in _range] + \ ['PDTYPE'+str(j) for j in _range] + \ ['PSIZE'+str(j) for j in _range] + \ ['DATATYPE', 'PSIZE', 'GCOUNT', 'PCOUNT', 'BSCALE', 'BZERO'] # Construct record array formats for the group parameters # as interpreted from the Primary header file for i in range(1, pcount + 1): ptype = key[i - 1] pdtype = phdr['PDTYPE' + str(i)] star = pdtype.find('*') _type = pdtype[:star] _bytes = pdtype[star + 1:] # collect boolean keywords since they need special attention later if _type == 'LOGICAL': bools.append(i) if pdtype == 'REAL*4': floats.append(i) fmt = geis_fmt[_type] + _bytes formats.append((ptype, fmt)) _shape = _naxis[1:] _shape.reverse() _code = fits.hdu.ImageHDU.NumCode[_bitpix] _bscale = phdr.get('BSCALE', 1) _bzero = phdr.get('BZERO', 0) if phdr['DATATYPE'][:10] == 'UNSIGNED*2': _uint16 = 1 _bzero = 32768 else: _uint16 = 0 # delete from the end, so it will not conflict with previous delete for i in range(len(phdr) - 1, -1, -1): if phdr.cards[i].keyword in _list: del phdr[i] # clean up other primary header keywords phdr['SIMPLE'] = True phdr['BITPIX'] = 16 phdr['GROUPS'] = False _after = 'NAXIS' if _naxis0 > 0: _after += str(_naxis0) phdr.set('EXTEND', value=True, comment="FITS dataset may contain extensions", after=_after) phdr.set('NEXTEND', value=gcount, comment="Number of standard extensions") hdulist = fits.HDUList([fits.PrimaryHDU(header=phdr, data=None)]) # Use copy-on-write for all data types since byteswap may be needed # in some platforms. f1 = open(data_file, mode='rb') dat = f1.read() # dat = memmap(data_file, mode='c') hdulist.mmobject = dat errormsg = "" loc = 0 for k in range(gcount): ext_dat = numpy.fromstring(dat[loc:loc + data_size], dtype=_code) ext_dat = ext_dat.reshape(_shape) if _uint16: ext_dat += _bzero # Check to see whether there are any NaN's or infs which might indicate # a byte-swapping problem, such as being written out on little-endian # and being read in on big-endian or vice-versa. if _code.find('float') >= 0 and \ (numpy.any(numpy.isnan(ext_dat)) or numpy.any(numpy.isinf(ext_dat))): errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input + "[%d]\n" % (k + 1) errormsg += "= had floating point data values =\n" errormsg += "= of NaN and/or Inf. =\n" errormsg += "===================================\n" elif _code.find('int') >= 0: # Check INT data for max values ext_dat_frac, ext_dat_exp = numpy.frexp(ext_dat) if ext_dat_exp.max() == int(_bitpix) - 1: # Potential problems with byteswapping errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input + "[%d]\n" % (k + 1) errormsg += "= had integer data values =\n" errormsg += "= with maximum bitvalues. =\n" errormsg += "===================================\n" ext_hdu = fits.ImageHDU(data=ext_dat) rec = numpy.fromstring(dat[loc + data_size:loc + group_size], dtype=formats) loc += group_size # Create separate PyFITS Card objects for each entry in 'rec' for i in range(1, pcount + 1): #val = rec.field(i-1)[0] val = rec[0][i - 1] if val.dtype.kind == 'S': val = val.decode('ascii') if i in bools: if val: val = True else: val = False if i in floats: # use fromstring, format in Card is deprecated in pyfits 0.9 _str = '%-8s= %20.7G / %s' % (key[i - 1], val, comm[i - 1]) _card = fits.Card.fromstring(_str) else: _card = fits.Card(keyword=key[i - 1], value=val, comment=comm[i - 1]) ext_hdu.header.append(_card) # deal with bscale/bzero if (_bscale != 1 or _bzero != 0): ext_hdu.header['BSCALE'] = _bscale ext_hdu.header['BZERO'] = _bzero hdulist.append(ext_hdu) if errormsg != "": errormsg += "===================================\n" errormsg += "= This file may have been =\n" errormsg += "= written out on a platform =\n" errormsg += "= with a different byte-order. =\n" errormsg += "= =\n" errormsg += "= Please verify that the values =\n" errormsg += "= are correct or apply the =\n" errormsg += "= '.byteswap()' method. =\n" errormsg += "===================================\n" print(errormsg) f1.close() stsci(hdulist) return hdulist
def check(result): assert_(type(result) is tuple) assert_equal(len(result), 2) mantissa, exponent = np.frexp(2**-3) _assert_equal_type_and_value(result[0], ArrayLike(mantissa)) _assert_equal_type_and_value(result[1], ArrayLike(exponent))
def test_ufunc_frexp_c(A: dace.complex64[10]): Q, R = np.frexp(A) return Q, R
def convert(input): """Input GEIS files "input" will be read and a HDUList object will be returned that matches the waiver-FITS format written out by 'stwfits' in IRAF. The user can use the writeto method to write the HDUList object to a FITS file. """ global dat cardLen = fits.Card.length # input file(s) must be of the form *.??h and *.??d if input[-1] != 'h' or input[-4] != '.': raise "Illegal input GEIS file name %s" % input data_file = input[:-1]+'d' _os = sys.platform if _os[:5] == 'linux' or _os[:5] == 'win32' or _os[:5] == 'sunos' or _os[:3] == 'osf' or _os[:6] == 'darwin': bytes_per_line = cardLen+1 else: raise "Platform %s is not supported (yet)." % _os end_card = 'END'+' '* (cardLen-3) # open input file im = open(input) # Generate the primary HDU cards = [] while 1: line = im.read(bytes_per_line)[:cardLen] line = line[:8].upper() + line[8:] if line == end_card: break cards.append(fits.Card.fromstring(line)) phdr = fits.Header(cards) im.close() # Determine starting point for adding Group Parameter Block keywords to Primary header phdr_indx = phdr.index('PSIZE') _naxis0 = phdr.get('NAXIS', 0) _naxis = [phdr['NAXIS'+str(j)] for j in range(1, _naxis0+1)] _naxis.insert(0, _naxis0) _bitpix = phdr['BITPIX'] _psize = phdr['PSIZE'] if phdr['DATATYPE'][:4] == 'REAL': _bitpix = -_bitpix if _naxis0 > 0: size = reduce(lambda x,y:x*y, _naxis[1:]) data_size = abs(_bitpix) * size // 8 else: data_size = 0 group_size = data_size + _psize // 8 # decode the group parameter definitions, # group parameters will become extension table groups = phdr['GROUPS'] gcount = phdr['GCOUNT'] pcount = phdr['PCOUNT'] formats = [] bools = [] floats = [] cols = [] # column definitions used for extension table cols_dict = {} # provides name access to Column defs _range = range(1, pcount+1) key = [phdr['PTYPE'+str(j)] for j in _range] comm = [phdr.cards['PTYPE'+str(j)].comment for j in _range] # delete group parameter definition header keywords _list = ['PTYPE'+str(j) for j in _range] + \ ['PDTYPE'+str(j) for j in _range] + \ ['PSIZE'+str(j) for j in _range] + \ ['DATATYPE', 'PSIZE', 'GCOUNT', 'PCOUNT', 'BSCALE', 'BZERO'] # Construct record array formats for the group parameters # as interpreted from the Primary header file for i in range(1, pcount+1): ptype = key[i-1] pdtype = phdr['PDTYPE'+str(i)] star = pdtype.find('*') _type = pdtype[:star] _bytes = pdtype[star+1:] # collect boolean keywords since they need special attention later if _type == 'LOGICAL': bools.append(i) if pdtype == 'REAL*4': floats.append(i) # identify keywords which require conversion to special units if ptype in kw_DOUBLE: _type = 'DOUBLE' fmt = geis_fmt[_type] + _bytes formats.append((ptype,fmt)) # Set up definitions for use in creating the group-parameter block table nrpt = '' nbits = str(int(_bytes)*8) if 'CHAR' in _type: nrpt = _bytes nbits = _bytes afmt = cols_fmt[_type]+ nbits if 'LOGICAL' in _type: afmt = cols_fmt[_type] cfmt = cols_pfmt[_type]+nrpt #print 'Column format for ',ptype,': ',cfmt,' with dtype of ',afmt cols_dict[ptype] = fits.Column(name=ptype,format=cfmt,array=numpy.zeros(gcount,dtype=afmt)) cols.append(cols_dict[ptype]) # This keeps the columns in order _shape = _naxis[1:] _shape.reverse() _code = fits.hdu.ImageHDU.NumCode[_bitpix] _bscale = phdr.get('BSCALE', 1) _bzero = phdr.get('BZERO', 0) if phdr['DATATYPE'][:10] == 'UNSIGNED*2': _uint16 = 1 _bzero = 32768 else: _uint16 = 0 # delete from the end, so it will not conflict with previous delete for i in range(len(phdr)-1, -1, -1): if phdr.cards[i].keyword in _list: del phdr[i] # clean up other primary header keywords phdr['SIMPLE'] = True phdr['GROUPS'] = False _after = 'NAXIS' if _naxis0 > 0: _after += str(_naxis0) phdr.set('EXTEND', value=True, comment="FITS dataset may contain extensions", after=_after) # Use copy-on-write for all data types since byteswap may be needed # in some platforms. f1 = open(data_file, mode='rb') dat = f1.read() errormsg = "" # Define data array for all groups arr_shape = _naxis[:] arr_shape[0] = gcount arr_stack = numpy.zeros(arr_shape,dtype=_code) loc = 0 for k in range(gcount): ext_dat = numpy.fromstring(dat[loc:loc+data_size], dtype=_code) ext_dat = ext_dat.reshape(_shape) if _uint16: ext_dat += _bzero # Check to see whether there are any NaN's or infs which might indicate # a byte-swapping problem, such as being written out on little-endian # and being read in on big-endian or vice-versa. if _code.find('float') >= 0 and \ (numpy.any(numpy.isnan(ext_dat)) or numpy.any(numpy.isinf(ext_dat))): errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input+"[%d]\n"%(k+1) errormsg += "= had floating point data values =\n" errormsg += "= of NaN and/or Inf. =\n" errormsg += "===================================\n" elif _code.find('int') >= 0: # Check INT data for max values ext_dat_frac,ext_dat_exp = numpy.frexp(ext_dat) if ext_dat_exp.max() == int(_bitpix) - 1: # Potential problems with byteswapping errormsg += "===================================\n" errormsg += "= WARNING: =\n" errormsg += "= Input image: =\n" errormsg += input+"[%d]\n"%(k+1) errormsg += "= had integer data values =\n" errormsg += "= with maximum bitvalues. =\n" errormsg += "===================================\n" arr_stack[k] = ext_dat #ext_hdu = fits.hdu.ImageHDU(data=ext_dat) rec = numpy.fromstring(dat[loc+data_size:loc+group_size], dtype=formats) loc += group_size # Add data from this GPB to table for i in range(1, pcount+1): val = rec[0][i-1] if i in bools: if val: val = 'T' else: val = 'F' cols[i-1].array[k] = val # Based on the first group, add GPB keywords to PRIMARY header if k == 0: # Create separate PyFITS Card objects for each entry in 'rec' # and update Primary HDU with these keywords after PSIZE for i in range(1, pcount+1): #val = rec.field(i-1)[0] val = rec[0][i-1] if val.dtype.kind == 'S': val = val.decode('ascii') if i in bools: if val: val = True else: val = False elif i in floats: # use fromstring, format in Card is deprecated in pyfits 0.9 _str = '%-8s= %20.13G / %s' % (key[i-1], val, comm[i-1]) _card = fits.Card.fromstring(_str) else: _card = fits.Card(key=key[i-1], value=val, comment=comm[i-1]) phdr.insert(phdr_indx+i, _card) # deal with bscale/bzero if (_bscale != 1 or _bzero != 0): phdr['BSCALE'] = _bscale phdr['BZERO'] = _bzero #hdulist.append(ext_hdu) # Define new table based on Column definitions ext_table = fits.new_table(cols,tbtype='TableHDU') ext_table.header.set('EXTNAME', value=input+'.tab', after='TFIELDS') # Add column descriptions to header of table extension to match stwfits output for i in range(len(key)): ext_table.header.append(fits.Card(keyword=key[i], value=comm[i])) if errormsg != "": errormsg += "===================================\n" errormsg += "= This file may have been =\n" errormsg += "= written out on a platform =\n" errormsg += "= with a different byte-order. =\n" errormsg += "= =\n" errormsg += "= Please verify that the values =\n" errormsg += "= are correct or apply the =\n" errormsg += "= '.byteswap()' method. =\n" errormsg += "===================================\n" print(errormsg) f1.close() hdulist = fits.HDUList([fits.PrimaryHDU(header=phdr, data=arr_stack)]) hdulist.append(ext_table) stsci2(hdulist,input) return hdulist
def test_ufunc_frexp_f(A: dace.float32[10]): Q, R = np.frexp(A) return Q, R
def normQuant(obj, sigfigs=None, full_norm=True): """Normalize quantities such that two things that *should* be equal are returned as identical objects. Handles floating point numbers, pint quantities, uncertainties, and combinations thereof as standalone objects or in sequences, dicts, or numpy ndarrays. Numerical precision issues and equal quantities represented in differently-scaled or different systems of units come out identically. Outputs from this function (**not** the inputs) deemed to be equal by the above logic will compare to be equal (via the `==` operator and via `pisa.utils.comparisons.recursiveEquality`) and will also hash to equal values (via `pisa.utils.hash.hash_obj`). Parameters ---------- obj Object to be normalized. sigfigs : None or int > 0 Number of digits to which to round numbers' significands; if None, do not round numbers. full_norm : bool If True, does full translation and normalization which is good across independent invocations and is careful about normalizing units, etc. If false, certain assumptions are made that modify the behavior described below in the Notes section which help speed things up in the case of e.g. a minimizer run, where we know certain things won't change: * Units are not normalized. They are assumed to stay the same from run to run. * sigfigs are not respected; full significant figures are returned (since it takes time to round all values appropriately). Returns ------- normed_obj : object roughly of same type as input `obj` Simple types are returned as the same type as at the input, Numpy ndarrays are returned in the same shape and representation as the input, Mappings (dicts) are returned as OrderedDict, and all other sequences or iterables are returned as (possibly nested) lists. Notes ----- Conversion logic by `obj` type or types found within `obj`: * **Sequences and OrderedDicts** (but not numpy arrays) are iterated through recursively. * **Mappings without ordering** (e.g. dicts) are iterated through recursively after sorting their keys, and are returned as OrderedDicts (such that the output is always consistent when serialized). * **Sequences** (not numpy arrays) are iterated through recursively. * **Numpy ndarrays** are treated as the below data types (according to the array's dtype). * **Simple objects** (non-floating point / non-sequence / non-numpy / etc.) are returned unaltered (e.g. strings). * **Pint quantities** (numbers with units): Convert to their base units. * **Floating-point numbers** (including the converted pint quantities): Round values to `sigfigs` significant figures. * **Numbers with uncertainties** (via the `uncertainties` module) have their nominal values rounded as above but their standard deviations are rounded to the same order of magnitude (*not* number of significant figures) as the nominal. Therefore passing obj=10.23+/-0.25 and sigfigs=2 returns 10+/-0.0. Note that **correlations are lost** in the outputs of this function, so equality of the output requires merely having equal nomial values and equal standard deviations. The calculations leading to these equal numbers might have used independent random variables to arrive at them, however, and so the `uncertainties` module would have evaluated them to be unequal. [1] To achieve rounding that masks floating point precision issues, set `sigfigs` to a value *less than* the number of decimal digits used for the significand of the calculation floating point precision. For reference, the IEEE 754 floating point standard [2] uses the following: * FP16 (half precision): **3.31** significand decimal digits (11 bits) * FP32 (single precision): **7.22** significand decimal digits (24 bits) * FP64 (double precision): **15.95** significand decimal digits (53 bits) * FP128 (quad precision): **34.02** significand decimal digits (113 bits) Logic for rounding the significand for numpy arrays was derived from [3]. References ---------- [1] https://github.com/lebigot/uncertainties/blob/master/uncertainties/test_uncertainties.py#L436 [2] https://en.wikipedia.org/wiki/IEEE_floating_point [3] http://stackoverflow.com/questions/18915378, answer by user BlackGriffin. Examples -------- Pint quantities hash to unequal values if specified in different scales or different systems of units (even if the underlying physical quantity is identical). >>> from pisa import ureg >>> from pisa.utils.hash import hash_obj >>> q0 = 1 * ureg.m >>> q1 = 100 * ureg.cm >>> q0 == q1 True >>> hash_obj(q0) == hash_obj(q1) False Even the `to_base_units()` method fails for hashing to equal values, as `q0` is a float and `q1` is an integer. >>> hash_obj(q0.to_base_units()) == hash_obj(q1.to_base_units()) False Even if both quantities are floating point numbers, finite precision effects in the `to_base_units` conversion can still cause two things which we "know" are equal to evaluate to be unequal. >>> q2 = 0.1 * ureg.m >>> q3 = 1e5 * ureg.um >>> q2 == q3 True >>> q2.to_base_units() == q3.to_base_units() False `normQuant` handles all of these issues given an appropriate `sigfigs` argument. >>> q2_normed = normQuant(q2, sigfigs=12) >>> q3_normed = normQuant(q3, sigfigs=12) >>> q2_normed == q3_normed True >>> hash_obj(q2_normed) == hash_obj(q3_normed) True """ #logging.trace('-'*80) #logging.trace('obj: %s', obj) #logging.trace('type(obj): %s', type(obj)) if not full_norm: return obj # Nothing to convert for strings, None, ... if isinstance(obj, basestring) or obj is None: return obj round_result = False if sigfigs is not None: if not (int(sigfigs) == float(sigfigs) and sigfigs > 0): raise ValueError('`sigfigs` must be an integer > 0.') round_result = True sigfigs = int(sigfigs) # Store kwargs for easily passing to recursive calls of this function kwargs = dict(sigfigs=sigfigs, full_norm=full_norm) if hasattr(obj, 'normalized_state'): return obj.normalized_state # Recurse into dict by its (sorted) keys (or into OrderedDict using keys in # their defined order) and return an OrderedDict in either case. if isinstance(obj, Mapping): #logging.trace('Mapping') if isinstance(obj, OrderedDict): keys = obj.keys() else: keys = sorted(obj.keys()) normed_obj = OrderedDict() for key in keys: normed_obj[key] = normQuant(obj[key], **kwargs) return normed_obj # Sequences, etc. but NOT numpy arrays (or pint quantities, which are # iterable) get their elements normalized and populated to a new list for # returning. # NOTE/TODO: allowing access across unit regestries for pragmatic (if # incorrect) reasons... may want to revisit this decision. # pylint: disable=protected-access misbehaving_sequences = (np.ndarray, pint.quantity._Quantity) if (isinstance(obj, (Iterable, Iterator, Sequence)) and not isinstance(obj, misbehaving_sequences)): #logging.trace('Iterable, Iterator, or Sequence but not ndarray or' # ' _Qauantity') return [normQuant(x, **kwargs) for x in obj] # Must be a numpy array or scalar if we got here... # NOTE: the order in which units (Pint module) and uncertainties # (uncertainties module) are handled is crucial! Essentially, it appears # that Pint is aware of uncertainties, but not vice versa. Hence the # ordering and descriptions used below. # The outermost "wrapper" of a number or numpy array is its Pint units. If # units are present, convert to base units, record the base units, and # strip the units off of the quantity by replacing it with its magnitude # (in the base units). has_units = False if isinstance(obj, pint.quantity._Quantity): #logging.trace('is a Quantity, converting to base units') has_units = True if full_norm: obj = obj.to_base_units() units = obj.units obj = obj.magnitude # The next layer possible for a number or numpy array to have is # uncertainties. If uncertainties are attached to `obj`, record a # "snapshot" (losing correlations) of the standard deviations. Then replace # the number or array solely with its nominal value(s). # NOTE: uncertainties.core.AffineScalarFunc includes such functions *and* # uncertainties.core.Variable objects has_uncertainties = False if isinstance(obj, AffineScalarFunc): #logging.trace('type is AffineScalarFunc') has_uncertainties = True std_devs = obj.std_dev obj = obj.nominal_value elif isinstance(obj, np.ndarray) and np.issubsctype(obj, AffineScalarFunc): #logging.trace('ndarray with subsctype is AffineScalarFunc') has_uncertainties = True std_devs = unp.std_devs(obj) obj = unp.nominal_values(obj) # What is done below will convert scalars into arrays, so get this info # before it is lost. is_scalar = isscalar(obj) if round_result: #logging.trace('rounding result') # frexp returns *binary* fraction (significand) and *binary* exponent bin_significand, bin_exponent = np.frexp(obj) exponent = LOG10_2 * bin_exponent exponent_integ = np.floor(exponent) exponent_fract = exponent - exponent_integ significand = bin_significand * 10**(exponent_fract) obj = np.around(significand, sigfigs - 1) * 10**exponent_integ # Now work our way *up* through the hierarchy: First, reintroduce # uncertainties if has_uncertainties and round_result: #logging.trace('uncertainties and rounding') std_bin_significand, std_bin_exponent = np.frexp(std_devs) std_exponent = LOG10_2 * std_bin_exponent std_exponent_integ = np.floor(std_exponent) std_exponent_fract = std_exponent - std_exponent_integ # Don't just scale magnitude by the stddev's fractional exponent; also # shift to be on the same scale (power-of-10) as the nominal value delta_order_of_mag = std_exponent_integ - exponent_integ std_significand = (std_bin_significand * 10**(std_exponent_fract + delta_order_of_mag)) # Now rounding on the stddev's significand occurs at the same order of # magnitude as rounding on the nominal value (and so scaling is done # with `exponent_integ`, NOT `std_exponent_integ`) std_devs = (np.around(std_significand, sigfigs - 1) * 10**exponent_integ) if has_uncertainties: #logging.trace('recreate uncertainties array') obj = unp.uarray(obj, std_devs) # If it was a scalar, it has become a len-1 array; extract the scalar if is_scalar: #logging.trace('converting to scalar') obj = obj[0] # Finally, attach units if they were present if has_units: #logging.trace('reattaching units') obj = obj * units return obj