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

4 views (last 30 days)

Show older comments

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.

##### 0 Comments

### Answers (3)

John D'Errico
on 7 Jan 2023

Edited: John D'Errico
on 7 Jan 2023

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

##### 5 Comments

John D'Errico
on 8 Jan 2023

Al Danial
on 13 Jan 2023

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.

##### 1 Comment

Al Danial
on 14 Jan 2023

Al Danial
on 15 Jan 2023

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 ]]

##### 0 Comments

### See Also

### Categories

### Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!