In Python, 1j or 0+1j is a literal of complex type. You can broadcast that into an array using expressions, for example In [17]: 1j * np.arange(5) Out[17]: array([ 0.+0.j, 0.+1.j, 0.+2.j, 0.+3.j, 0.+4.j]) Create an array from literals: In [18]: np.array([1j]) Out[18]: array([ 0.+1.j]) Note that what Michael9 posted creates a complex, not a … Read more
What’s wrong with just separating it out into real and imaginary parts? scipy.integrate.quad requires the integrated function return floats (aka real numbers) for the algorithm it uses. import scipy from scipy.integrate import quad def complex_quadrature(func, a, b, **kwargs): def real_func(x): return scipy.real(func(x)) def imag_func(x): return scipy.imag(func(x)) real_integral = quad(real_func, a, b, **kwargs) imag_integral = quad(imag_func, … Read more
Why don’t you try this: http://wiki.tcl.tk/11415 or something like this too: http://wiki.tcl.tk/13885 I hope these are easy to use alternatives for the mentioned utility.
This turned out to be a bit verbose, but I hope it fully answers your question… A Gaussian integer is a complex number of the form G = a+bi where i2 = -1, and a and b are integers. The Gaussian integers form a unique factorization domain. Some of them act as units (e.g. 1, … Read more
You can’t properly implement many of the std::complex operations on integers. E.g., template <class T> T abs(const complex<T> &z); for a complex<long> cannot have T = long return value when complex numbers are represented as (real,imag) pairs, since it returns the value of sqrt(pow(z.real(), 2) + pow(z.imag(), 2)). Only a few of the operations would … Read more
The simplest way I can find to work around this issue is to simply switch the order of multiplication. If in testcplx.pyx I change varc128 = varc128 * varf64 to varc128 = varf64 * varc128 I change from the failing situation to described to one that works correctly. This scenario is useful as it allows … Read more
The key to the solution is to build a wrapper that overrides the __eq__ method and replaces it with an approximate match: import cmath class Approximately(complex): def __new__(cls, x, /, **kwargs): result = complex.__new__(cls, x) result.kwargs = kwargs return result def __eq__(self, other): try: return isclose(self, other, **self.kwargs) except TypeError: return NotImplemented It creates approximate … Read more
printf(“%f + i%f\n”, creal(result), cimag(result)); I don’t believe there’s a specific format specifier for the C99 complex type.
The free final draft of the C99 specification says on page 491 clog(+ā, +iā) returns +ā + iĻ/4. This is still the case currently. The C++ specification explains the same rules with the note The semantics of this function are intended to be consistent with the C function clog. I agree the behaviour is confusing … Read more
This seems to do what you want: numpy.apply_along_axis(lambda args: [complex(*args)], 3, Data) Here is another solution: # The ellipsis is equivalent here to “:,:,:”… numpy.vectorize(complex)(Data[…,0], Data[…,1]) And yet another simpler solution: Data[…,0] + 1j * Data[…,1] PS: If you want to save memory (no intermediate array): result = 1j*Data[…,1]; result += Data[…,0] devS’ solution below … Read more