Python numpy.isrealobj() Examples
The following are 30
code examples of numpy.isrealobj().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: extract_features.py From DeepFormants with MIT License | 6 votes |
def atal(x, order, num_coefs): x = np.atleast_1d(x) n = x.size if x.ndim > 1: raise ValueError("Only rank 1 input supported for now.") if not np.isrealobj(x): raise ValueError("Only real input supported for now.") a, e, kk = lpc(x, order) c = np.zeros(num_coefs) c[0] = a[0] for m in range(1, order+1): c[m] = - a[m] for k in range(1, m): c[m] += (float(k)/float(m)-1)*a[k]*c[m-k] for m in range(order+1, num_coefs): for k in range(1, order+1): c[m] += (float(k)/float(m)-1)*a[k]*c[m-k] return c
Example #2
Source File: test_polynomial.py From recruit with Apache License 2.0 | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #3
Source File: test_polynomial.py From mxnet-lambda with Apache License 2.0 | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #4
Source File: creator_em.py From spins-b with GNU General Public License v3.0 | 6 votes |
def grad(self, input_vals: List[np.ndarray], grad_val: np.ndarray) -> List[np.ndarray]: """Computes gradient via a adjoint calculation. Args: input_vals: List of the input values. grad_val: Gradient of the output. Returns: Gradient. """ omega = 2 * np.pi / self._wlen efields = self._simulate(input_vals[0]) B = omega**2 * scipy.sparse.diags(efields, 0) d = self._simulate_adjoint(input_vals[0], np.conj(grad_val) / (-1j * omega)) total_df_dz = np.conj(np.transpose(d)) @ B # If this is a function that maps from real to complex, we have to # to take the real part to make gradient real. if np.isrealobj(input_vals[0]): total_df_dz = np.real(total_df_dz) return [total_df_dz]
Example #5
Source File: test_polynomial.py From pySINDy with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #6
Source File: test_polynomial.py From predictive-maintenance-using-machine-learning with Apache License 2.0 | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #7
Source File: pychebfun.py From fluids with MIT License | 6 votes |
def polyval(self, chebcoeff): """ Compute the interpolation values at Chebyshev points. chebcoeff: Chebyshev coefficients """ N = len(chebcoeff) if N == 1: return chebcoeff data = even_data(chebcoeff)/2 data[0] *= 2 data[N-1] *= 2 fftdata = 2*(N-1)*fftpack.ifft(data, axis=0) complex_values = fftdata[:N] # convert to real if input was real if np.isrealobj(chebcoeff): values = np.real(complex_values) else: values = complex_values return values
Example #8
Source File: tags.py From pumpp with ISC License | 6 votes |
def inverse(self, encoded, duration=None): '''Inverse static tag transformation''' ann = jams.Annotation(namespace=self.namespace, duration=duration) if np.isrealobj(encoded): detected = (encoded >= 0.5) else: detected = encoded for vd in self.encoder.inverse_transform(np.atleast_2d(detected))[0]: vid = np.flatnonzero(self.encoder.transform(np.atleast_2d(vd))) ann.append(time=0, duration=duration, value=vd, confidence=encoded[vid]) return ann
Example #9
Source File: gcacgmm.py From pb_bss with MIT License | 6 votes |
def predict(self, observation, embedding): """ Args: observation: Shape (F, T, D) embedding: Shape (F, T, E) Returns: affiliation: Shape (F, K, T) """ assert np.iscomplexobj(observation), observation.dtype assert np.isrealobj(embedding), embedding.dtype observation = observation / np.maximum( np.linalg.norm(observation, axis=-1, keepdims=True), np.finfo(observation.dtype).tiny, ) affiliation, quadratic_form = self._predict(observation, embedding) return affiliation
Example #10
Source File: datahandling.py From postpic with GNU General Public License v3.0 | 6 votes |
def _shift_grid_by_linear(self, dx): axes = sorted(dx.keys()) shift = np.zeros(len(self.axes)) for i, d in dx.items(): shift[i] = d shift_px = shift/self.spacing ret = copy.copy(self) if np.isrealobj(self.matrix): ret.matrix = spnd.shift(self.matrix, -shift_px, order=1, mode='nearest') else: real, imag = self.matrix.real.copy(), self.matrix.imag.copy() ret.matrix = np.empty_like(matrix) spnd.shift(real, -shift_px, output=ret.matrix.real, order=1, mode='nearest') spnd.shift(imag, -shift_px, output=ret.matrix.imag, order=1, mode='nearest') for i in axes: ret.axes[i] = Axis(grid_node=self.axes[i].grid_node + dx[i], grid=self.axes[i].grid + dx[i]) return ret
Example #11
Source File: gaussian.py From pb_bss with MIT License | 6 votes |
def fit(self, y, saliency=None, covariance_type="full"): """ Args: y: Shape (..., N, D) saliency: Importance weighting for each observation, shape (..., N) covariance_type: Either 'full', 'diagonal', or 'spherical' Returns: """ assert np.isrealobj(y), y.dtype if saliency is not None: assert is_broadcast_compatible(y.shape[:-1], saliency.shape), ( y.shape, saliency.shape ) return self._fit(y, saliency=saliency, covariance_type=covariance_type)
Example #12
Source File: pychebfun.py From fluids with MIT License | 6 votes |
def dct(data): """ Compute DCT using FFT """ N = len(data)//2 fftdata = fftpack.fft(data, axis=0)[:N+1] fftdata /= N fftdata[0] /= 2. fftdata[-1] /= 2. if np.isrealobj(data): data = np.real(fftdata) else: data = fftdata return data # ---------------------------------------------------------------- # Add overloaded operators # ----------------------------------------------------------------
Example #13
Source File: gmm.py From pb_bss with MIT License | 6 votes |
def predict(self, x): """ Args: x: Shape (N, D) Returns: Affiliation with shape (K, N) """ N, D = x.shape assert np.isrealobj(x), x.dtype labels = self.kmeans.predict(x) affiliations = labels_to_one_hot( labels, self.kmeans.n_clusters, axis=-2, keepdims=False, dtype=x.dtype ) assert affiliations.shape == (self.kmeans.n_clusters, N) return affiliations
Example #14
Source File: signal.py From arlpy with BSD 3-Clause "New" or "Revised" License | 6 votes |
def correlate_periodic(a, v=None): """Cross-correlation of two 1-dimensional periodic sequences. a and v must be sequences with the same length. If v is not specified, it is assumed to be the same as a (i.e. the function computes auto-correlation). :param a: input sequence #1 :param v: input sequence #2 :returns: discrete periodic cross-correlation of a and v """ a_fft = _np.fft.fft(_np.asarray(a)) if v is None: v_cfft = a_fft.conj() else: v_cfft = _np.fft.fft(_np.asarray(v)).conj() x = _np.fft.ifft(a_fft * v_cfft) if _np.isrealobj(a) and (v is None or _np.isrealobj(v)): x = x.real return x
Example #15
Source File: linear_prediction.py From spectrum with BSD 3-Clause "New" or "Revised" License | 6 votes |
def rc2is(k): """Convert reflection coefficients to inverse sine parameters. :param k: reflection coefficients :return: inverse sine parameters .. seealso:: :func:`is2rc`, :func:`rc2poly`, :func:`rc2acC`, :func:`rc2lar`. Reference: J.R. Deller, J.G. Proakis, J.H.L. Hansen, "Discrete-Time Processing of Speech Signals", Prentice Hall, Section 7.4.5. """ assert numpy.isrealobj(k), 'Inverse sine parameters not defined for complex reflection coefficients.' if max(numpy.abs(k)) >= 1: raise ValueError('All reflection coefficients should have magnitude less than unity.') return (2/numpy.pi)*numpy.arcsin(k)
Example #16
Source File: __init__.py From sporco with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _fftconv(a, b, axes=(0, 1)): """Patched version of :func:`sporco.fft.fftconv`.""" if cp.isrealobj(a) and cp.isrealobj(b): fft = cp.fft.rfftn ifft = cp.fft.irfftn else: fft = cp.fft.fftn ifft = cp.fft.ifftn dims = cp.maximum(cp.asarray([a.shape[i] for i in axes]), cp.asarray([b.shape[i] for i in axes])) dims = [int(d) for d in dims] af = fft(a, dims, axes) bf = fft(b, dims, axes) return ifft(af * bf, dims, axes) # Construct sporco.cupy.fft
Example #17
Source File: test_polynomial.py From elasticintel with GNU General Public License v3.0 | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #18
Source File: test_polynomial.py From coffeegrindsize with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #19
Source File: SVA.py From PyRAT with Mozilla Public License 2.0 | 6 votes |
def filter(self, array, *args, **kwargs): # 1-D Real Arrays if array.ndim == 1 and np.isrealobj(array): return self.svafilter(array, self.ov) # 1-D Complex Arrays if array.ndim == 1 and np.iscomplexobj(array): return self.sva1D(array, self.ov) # 2-D Complex Arrays if array.ndim == 2 and np.iscomplexobj(array): return self.sva2D(array, self.ov) # 3-D Complex Arrays if array.ndim == 3 and np.iscomplexobj(array): p = array.shape for k in range(0,p[0]): array[k,:,:] = self.sva2D(array[k,:,:], self.ov) return array else: print(" ERROR: Bad input.") return None
Example #20
Source File: test_polynomial.py From GraphicDesignPatternByPython with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #21
Source File: linear_prediction.py From spectrum with BSD 3-Clause "New" or "Revised" License | 6 votes |
def rc2lar(k): """Convert reflection coefficients to log area ratios. :param k: reflection coefficients :return: inverse sine parameters The log area ratio is defined by G = log((1+k)/(1-k)) , where the K parameter is the reflection coefficient. .. seealso:: :func:`lar2rc`, :func:`rc2poly`, :func:`rc2ac`, :func:`rc2ic`. :References: [1] J. Makhoul, "Linear Prediction: A Tutorial Review," Proc. IEEE, Vol.63, No.4, pp.561-580, Apr 1975. """ assert numpy.isrealobj(k), 'Log area ratios not defined for complex reflection coefficients.' if max(numpy.abs(k)) >= 1: raise ValueError('All reflection coefficients should have magnitude less than unity.') # Use the relation, atanh(x) = (1/2)*log((1+k)/(1-k)) return -2 * numpy.arctanh(-numpy.array(k))
Example #22
Source File: test_polynomial.py From Serverless-Deep-Learning-with-TensorFlow-and-AWS-Lambda with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #23
Source File: test_polynomial.py From Mastering-Elasticsearch-7.0 with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #24
Source File: test_polynomial.py From twitter-stock-recommendation with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #25
Source File: test_polynomial.py From vnpy_crypto with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #26
Source File: test_polynomial.py From lambda-packs with MIT License | 6 votes |
def test_poly(self): assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]), [1, -3, -2, 6]) # From matlab docs A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] assert_array_almost_equal(np.poly(A), [1, -6, -72, -27]) # Should produce real output for perfect conjugates assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j]))) assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j, 1-2j, 1.+3.5j, 1-3.5j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j]))) assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j]))) assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j]))) assert_(np.isrealobj(np.poly([1j, -1j]))) assert_(np.isrealobj(np.poly([1, -1]))) assert_(np.iscomplexobj(np.poly([1j, -1.0000001j]))) np.random.seed(42) a = np.random.randn(100) + 1j*np.random.randn(100) assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
Example #27
Source File: util.py From scaper with BSD 3-Clause "New" or "Revised" License | 6 votes |
def is_real_number(num): ''' Check if a value is a real scalar by aggregating several numpy checks. Parameters ---------- num : any type The parameter to check Returns ------ check : bool True if ```num``` is a real scalar, False otherwise. ''' if (not np.isreal(num) or not np.isrealobj(num) or not np.isscalar(num)): return False else: return True
Example #28
Source File: matfuncs.py From Splunking-Crime with GNU Affero General Public License v3.0 | 5 votes |
def _maybe_real(A, B, tol=None): """ Return either B or the real part of B, depending on properties of A and B. The motivation is that B has been computed as a complicated function of A, and B may be perturbed by negligible imaginary components. If A is real and B is complex with small imaginary components, then return a real copy of B. The assumption in that case would be that the imaginary components of B are numerical artifacts. Parameters ---------- A : ndarray Input array whose type is to be checked as real vs. complex. B : ndarray Array to be returned, possibly without its imaginary part. tol : float Absolute tolerance. Returns ------- out : real or complex array Either the input array B or only the real part of the input array B. """ # Note that booleans and integers compare as real. if np.isrealobj(A) and np.iscomplexobj(B): if tol is None: tol = {0:feps*1e3, 1:eps*1e6}[_array_precision[B.dtype.char]] if np.allclose(B.imag, 0.0, atol=tol): B = B.real return B ############################################################################### # Matrix functions.
Example #29
Source File: psd.py From spectrum with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _setData(self, data): if type(data) == list: from numpy import array self.__data = array(data) else: self.__data = data.copy() self.__N = self.data.size # N has no setter, so we use the private version self.modified = True if numpy.isrealobj(self.__data): self.__datatype = 'real' else: self.__datatype = 'complex'
Example #30
Source File: simulate.py From spins-b with GNU General Public License v3.0 | 5 votes |
def grad(self, input_vals: List[goos.Flow], grad_val: goos.ArrayFlow.Grad) -> List[goos.Flow.Grad]: eps = input_vals[0].array sim = FdfdSimProp(eps=eps, source=np.zeros_like(eps), wlen=self._wlen, dxes=self._dxes, pml_layers=self._pml_layers, bloch_vec=self._bloch_vector, grid=self._grid, symmetry=self._symmetry) omega = 2 * np.pi / sim.wlen for out, g in zip(self._outputs, grad_val.flows_grad): out.before_adjoint_sim(sim, g) adjoint_fields = self._solver.solve( omega=2 * np.pi / sim.wlen, dxes=sim.dxes, epsilon=fdfd_tools.vec(sim.eps), mu=None, J=fdfd_tools.vec(sim.source), pml_layers=sim.pml_layers, bloch_vec=sim.bloch_vec, symmetry=sim.symmetry, adjoint=True, ) adjoint_fields = np.stack(fdfd_tools.unvec(adjoint_fields, eps[0].shape), axis=0) grad = -1j * omega * np.conj(adjoint_fields) * self._last_results.fields if np.isrealobj(eps): grad = 2 * np.real(grad) return [goos.NumericFlow.Grad(array_grad=grad)]