What is the equivalent of element-wise division in python when denominator contains complex number

The line:

V_modif(j-1,:)=Y_modif(j-1,:)./(i*2*pi*f);

contains i (iota ) in denominator.

It's python equivalent line would be:

V_modif[j - 1] = Y_modif[j - 1,:] / ( 1j*2 * np.pi * f)

but this gives zero in ouput and if you remove "1j" from denominator it gives corrcet output but contains only real part no imaginary part.

Answer 1

[John D'Errico]

That is the correct expression. Why it gives zero is hard to tell. You may have defined the variable i in your code already as a number. That would be a bad thing, if you then want to use i as sqrt(-1). However, 1i (OR 1j) will always work as sqrt(-1). Note my use of 1i there, just as you used 1j in python. Again, 1j also always works.

V_modif(j-1,:)=Y_modif(j-1,:)./(1i*2*pi*f);

Another possibility is it is not truly zero, but just a small number. If it shows up as 0.0000 in the command window, that means your format is simply a poor choice, and not truly zero.

help format

So you might try this command to show the true number.

format long g

[Arslan Saif]

I just wanted to know how matlab treats it when real matrix is divide by imaginary part only

[Arslan Saif]

The issues lies here that python python don't allow dividing an array by pure imaginary number like matlab

[John D'Errico]

And so? MATLAB is not Python. MATLAB does allow it.

(1:3)./1i

ans = 
   0.0000 - 1.0000i   0.0000 - 2.0000i   0.0000 - 3.0000i

The only pertinent question is why you think MATLAB failed to produce the correct result. I suggested two possibilities for why you may be confused, or have done something incorrectly. Beyond that, if you do now show us code we can reproduce that you THINK does something strange, then it is impossible to help you.

Again, MATLAB has no problem at all with element-wise division of complex or purely imaginary numbers.

[Arslan Saif]

Yes you are right, this whole time I was discussing that I I have problem with python, matlab is working absolutely fine. I wanted to implement the same functionality in python.

[John D'Errico]

For that, you need to ask a question on a Python forum. I am quite sure it is doable, but you need to find a place where people are far more conversant in python.

Answer 2

[Al Danial]

Your Python code has a typographical bug, an easy one to make: if you work with complex numbers in Python, you cannot use j as a variable. Your Python code uses j as a subscript to V_modif and Y_modif and as the marker for the imaginary component, 1j, suggesting, as @John D'Errico aluded, that you defined j yourself to an integer value. That destroys j's property of defining complex literals. You'll need to use something else, maybe k ?, as the subscript to V_modif and Y_modif.

The problem doesn't appear in the matlab code because it uses i for the imaginary component, so j is OK to use as a subscript.

[Al Danial]

Ignore everything I wrote above, it's wrong! There's no problem using j as both a subscript and as a marker for a complex value; my test session had errors. I'll revisit this when I have a better idea.

Answer 3

[Al Danial]

Here's my next theory: your code uses the default np.float64 datatype for V_modif. The problem with this is the right hand side is complex but the left hand side only has room for the real parts. Consequently the complex terms are dropped. Here's code that demonstrates this:

import numpy as np

V_modif = np.zeros((2,3))   # default type of np.float64
Y_modif = np.ones((2,3))
f = np.array([12., 13., 14.])
j = 1
V_modif[j - 1] = Y_modif[j - 1,:] / ( 1j*2 * np.pi * f)
print('V_modif with default dtype=np.float64')
print(V_modif)

# redo, this time explicitly making V_modif complex
V_modif = np.zeros((2,3), dtype=np.complex128)
Y_modif = np.ones((2,3))
f = np.array([12., 13., 14.])
j = 1
V_modif[j - 1] = Y_modif[j - 1,:] / ( 1j*2 * np.pi * f)
print('V_modif with default dtype=np.complex128')
print(V_modif)

The output first shows the incorrect result because V_modif is real-only, then shows the correct result when V_modif is explicitly defined as a complex variable:

V_modif with default dtype=np.float64
[[0. 0. 0.]
    [0. 0. 0.]]

V_modif with default dtype=np.complex128
[[0.-0.01326291j 0.-0.01224269j 0.-0.01136821j]
    [0.+0.j         0.+0.j         0.+0.j        ]]