ಪೈಥಾನ್ ಕಾಂಪ್ಲೆಕ್ಸ್ ಸಂಖ್ಯೆಗಳು: ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಪೋಲಾರ್ ರೂಪವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಗಣಿತ ಮತ್ತು ವೈಜ್ಞಾನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳು ಮೂಲಭೂತವಾಗಿವೆ. ಅವುಗಳು ಕಾಲ್ಪನಿಕ ಘಟಕವನ್ನು ಒಳಗೊಂಡಿರುವುದರಿಂದ ನೈಜ ಸಂಖ್ಯೆಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ವಿಸ್ತರಿಸುತ್ತವೆ, ಇದನ್ನು i ಘಟಕದಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ, ಇಲ್ಲಿ i² = -1. ಪೈಥಾನ್, ಜಾಗತಿಕ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ಶೈಕ್ಷಣಿಕ ವಿಭಾಗಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಅಳವಡಿಸಿಕೊಂಡಿರುವ ಬಹುಮುಖ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದ್ದು, ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳಿಗೆ ದೃಢವಾದ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಸಂಕೀರ್ಣ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸುಲಭವಾಗಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ.

ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಪೈಥಾನ್‌ನ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ನಿರ್ವಹಣೆಯನ್ನು ಆಳವಾಗಿ ವಿವರಿಸುತ್ತದೆ, ಅವುಗಳ ಪ್ರಮಾಣಿತ ಬೀಜಗಣಿತದ ನಿರೂಪಣೆ ಮತ್ತು ಅವುಗಳ ಶಕ್ತಿಶಾಲಿ ಪೋಲಾರ್ ರೂಪ ಎರಡನ್ನೂ ಅನ್ವೇಷಿಸುತ್ತದೆ. ನಾವು ಅಗತ್ಯ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಸಿಗ್ನಲ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನಿಂದ ಕ್ವಾಂಟಮ್ ಮೆಕ್ಯಾನಿಕ್ಸ್‌ವರೆಗಿನ ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ ತಿಳುವಳಿಕೆ ಮತ್ತು ಕುಶಲತೆಗಾಗಿ ಪೋಲಾರ್ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳಬೇಕು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಆಯತಾಕಾರದ (ಅಥವಾ ಕಾರ್ಟೇಶಿಯನ್) ರೂಪದಲ್ಲಿ a + bi ಎಂದು ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ, ಇಲ್ಲಿ a ನೈಜ ಭಾಗ ಮತ್ತು b ಕಾಲ್ಪನಿಕ ಭಾಗವಾಗಿದೆ. ಪೈಥಾನ್ ಸ್ಥಳೀಯವಾಗಿ ಈ a + bj ಸಂಕೇತವನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಅಲ್ಲಿ ವಿದ್ಯುತ್ ಎಂಜಿನಿಯರಿಂಗ್ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪ್ರವಾಹದೊಂದಿಗೆ ಗೊಂದಲವನ್ನು ತಪ್ಪಿಸಲು i ಬದಲಿಗೆ j ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ j ಅಥವಾ i ಅನ್ನು ಕಾಲ್ಪನಿಕ ಘಟಕವಾಗಿ ಬಳಸಿದರೂ ಪೈಥಾನ್‌ನ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರವು ಒಂದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸುವುದು

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ರಚಿಸುವುದು ನೇರವಾಗಿದೆ. ನೀವು ಅಂತರ್ನಿರ್ಮಿತ complex() ಕಾರ್ಯವನ್ನು ಬಳಸಬಹುದು ಅಥವಾ ನೇರವಾಗಿ a + bj ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು.

• complex() ಕಾರ್ಯವನ್ನು ಬಳಸುವುದು:

complex() ಕಾರ್ಯವು ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು: ನೈಜ ಭಾಗ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗ. ಒಂದೇ ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಒದಗಿಸಿದರೆ, ಅದನ್ನು ನೈಜ ಭಾಗವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗವು ಶೂನ್ಯಕ್ಕೆ ಡೀಫಾಲ್ಟ್ ಆಗುತ್ತದೆ. ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಒದಗಿಸದಿದ್ದರೆ, ಅದು 0j ಅನ್ನು ರಚಿಸುತ್ತದೆ.

            # Creating complex numbers using complex()
complex_num1 = complex(3, 5)  # Real part 3, Imaginary part 5
print(f"Complex number 1: {complex_num1}")

complex_num2 = complex(7)     # Real part 7, Imaginary part 0
print(f"Complex number 2: {complex_num2}")

complex_num3 = complex(0, -2) # Real part 0, Imaginary part -2
print(f"Complex number 3: {complex_num3}")

complex_num4 = complex()      # Real part 0, Imaginary part 0
print(f"Complex number 4: {complex_num4}")

            

              
                Copy
              
            
          

• a + bj ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುವುದು:

ಇದು ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮಾರ್ಗವಾಗಿದೆ.

            # Creating complex numbers using a + bj syntax
complex_num_a = 4 + 6j
print(f"Complex number A: {complex_num_a}")

complex_num_b = -2 - 3j
print(f"Complex number B: {complex_num_b}")

complex_num_c = 9j       # Real part is 0
print(f"Complex number C: {complex_num_c}")

complex_num_d = 1 + 1j   # Equivalent to 1 + j
print(f"Complex number D: {complex_num_d}")

            

              
                Copy
              
            
          

ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು

ಒಮ್ಮೆ ನೀವು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು ಅದರ ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಘಟಕಗಳನ್ನು ಕ್ರಮವಾಗಿ .real ಮತ್ತು .imag ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸುಲಭವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು. ಈ ಗುಣಲಕ್ಷಣಗಳು ಯಾವಾಗಲೂ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ.

            my_complex = 5.5 + 2.3j

print(f"The complex number is: {my_complex}")
print(f"Real part: {my_complex.real}")
print(f"Imaginary part: {my_complex.imag}")

            

              
                Copy
              
            
          

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಪ್ರಕಾರ

ಪೈಥಾನ್‌ನ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರವು ವಿಭಿನ್ನವಾಗಿದೆ. ನೀವು type() ಬಳಸಿ ಅದರ ಪ್ರಕಾರವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು.

            z = 3 + 4j
print(f"Type of z: {type(z)}")

            

              
                Copy
              
            
          

ಆಯತಾಕಾರದ ರೂಪದಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು

ಪೈಥಾನ್ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಮೇಲೆ ನೇರವಾಗಿ ಪ್ರಮಾಣಿತ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಗಣಿತದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಅರ್ಥಗರ್ಭಿತವಾಗಿಸುತ್ತದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಫಲಿತಾಂಶಗಳು ಸಹ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳಾಗಿವೆ.

ಕೂಡಿಸುವಿಕೆ ಮತ್ತು ಕಳೆಯುವಿಕೆ

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸುವುದು ಅಥವಾ ಕಳೆಯುವುದು ಅವುಗಳ ಅನುಗುಣವಾದ ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗಗಳನ್ನು ಕೂಡಿಸುವುದು ಅಥವಾ ಕಳೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಸೂತ್ರ:

(a + bi) + (c + di) = (a + c) + (b + d)i

(a + bi) - (c + di) = (a - c) + (b - d)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Addition
sum_result = z1 + z2
print(f"{z1} + {z2} = {sum_result}")

# Subtraction
diff_result = z1 - z2
print(f"{z1} - {z2} = {diff_result}")

            

              
                Copy
              
            
          

ಗುಣಾಕಾರ

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಗುಣಿಸುವುದು ವಿತರಣಾ ಗುಣಲಕ್ಷಣವನ್ನು ಅನುಸರಿಸುತ್ತದೆ, j² = -1 ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

ಸೂತ್ರ:

(a + bi) * (c + di) = ac + adi + bci + bdi² = (ac - bd) + (ad + bc)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Multiplication
prod_result = z1 * z2
print(f"{z1} * {z2} = {prod_result}")

            

              
                Copy
              
            
          

ಭಾಗಾಕಾರ

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಭಾಗಾಕಾರವು ಛೇದವನ್ನು ತರ್ಕಬದ್ಧಗೊಳಿಸಲು ಛೇದದ ಸಂಯೋಗದಿಂದ ಅಂಶ ಮತ್ತು ಛೇದವನ್ನು ಗುಣಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಸೂತ್ರ:

(a + bi) / (c + di) = ((a + bi) * (c - di)) / ((c + di) * (c - di)) = ((ac + bd) + (bc - ad)i) / (c² + d²)

            z1 = 2 + 3j
z2 = 1 - 5j

# Division
div_result = z1 / z2
print(f"{z1} / {z2} = {div_result}")

# Division by zero will raise a ZeroDivisionError
# zero_complex = 0 + 0j
# print(z1 / zero_complex)

            

              
                Copy
              
            
          

ಸಂಯೋಗಿ (Conjugate)

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆ a + bj ಯ ಸಂಯೋಗಿ a - bj ಆಗಿದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ, .conjugate() ವಿಧಾನವು ಸಂಕೀರ್ಣ ಸಂಯೋಗಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

            z = 4 + 7j
conjugate_z = z.conjugate()
print(f"The conjugate of {z} is {conjugate_z}")

            

              
                Copy
              
            
          

ಪರಿಮಾಣ (ನಿರಪೇಕ್ಷ ಮೌಲ್ಯ)

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆ a + bj ಯ ಪರಿಮಾಣ ಅಥವಾ ನಿರಪೇಕ್ಷ ಮೌಲ್ಯವು ಸಂಕೀರ್ಣ ಸಮತಲದಲ್ಲಿ ಮೂಲದಿಂದ ಅದರ ದೂರವಾಗಿದೆ, ಇದನ್ನು sqrt(a² + b²) ಎಂದು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಪೈಥಾನ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ abs() ಕಾರ್ಯವು ಇದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.

ಸೂತ್ರ:

|a + bi| = sqrt(a² + b²)

            z = 3 + 4j
magnitude_z = abs(z)
print(f"The magnitude of {z} is {magnitude_z}")

            

              
                Copy
              
            
          

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಘಾತೀಕರಣ

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಘಾತಕ್ಕೆ ಏರಿಸುವುದನ್ನು ಸಹ ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ. ಪೂರ್ಣಾಂಕ ಘಾತಗಳಿಗೆ, ಇದು ನೇರವಾಗಿರುತ್ತದೆ. ಭಾಗಶಃ ಅಥವಾ ಸಂಕೀರ್ಣ ಘಾತಗಳಿಗೆ, ಫಲಿತಾಂಶಗಳು ಬಹು-ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಲಾಗರಿಥಂಗಳ ಬಳಕೆಯಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

            z = 1 + 1j

# Squaring a complex number
squared_z = z ** 2
print(f"{z} squared is {squared_z}")

# Raising to a higher power
cubed_z = z ** 3
print(f"{z} cubed is {cubed_z}")

# Fractional power (can lead to multiple results)
# Python typically returns the principal value
sqrt_z = z ** 0.5
print(f"The square root of {z} is (principal value) {sqrt_z}")

            

              
                Copy
              
            
          

ಪೋಲಾರ್ ರೂಪದ ಶಕ್ತಿ

ಆಯತಾಕಾರದ ರೂಪ (a + bj) ಮೂಲಭೂತ ಅಂಕಗಣಿತಕ್ಕೆ ಅರ್ಥಗರ್ಭಿತವಾಗಿದ್ದರೂ, ಪೋಲಾರ್ ರೂಪವು ತಿರುಗುವಿಕೆ, ಗುಣಾಕಾರ, ಭಾಗಾಕಾರ ಮತ್ತು ಘಾತೀಕರಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಗಮನಾರ್ಹ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಎಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು ಭೌತಶಾಸ್ತ್ರದಲ್ಲಿ.

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ r(cos θ + i sin θ) ಎಂದು ಪ್ರತಿನಿಧಿಸಬಹುದು, ಅಥವಾ ಯೂಲರ್‌ನ ಸೂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತವಾಗಿ, re^iθ. ಇಲ್ಲಿ:

• r (ಮಾಡುಲಸ್): ಮೂಲದಿಂದ ಪರಿಮಾಣ ಅಥವಾ ದೂರ (ಹಿಂದೆ ಲೆಕ್ಕ ಹಾಕಿದ ನಿರಪೇಕ್ಷ ಮೌಲ್ಯದಂತೆಯೇ).
• θ (ಆರ್ಗುಮೆಂಟ್): ಮೂಲದಿಂದ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗೆ ಇರುವ ರೇಖಾಖಂಡವು ಧನಾತ್ಮಕ ನೈಜ ಅಕ್ಷದೊಂದಿಗೆ ಮಾಡುವ ಕೋನ (ರೇಡಿಯನ್‌ಗಳಲ್ಲಿ).

ಆಯತಾಕಾರದ ರೂಪದಿಂದ ಪೋಲಾರ್ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆ z = a + bj ಅನ್ನು ನೀಡಿದಾಗ, ನಾವು ಅದನ್ನು ಪೋಲಾರ್ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು:

• ಮಾಡುಲಸ್ (r): r = abs(z)
• ಆರ್ಗುಮೆಂಟ್ (θ): θ = atan2(b, a). math ಮಾಡ್ಯೂಲ್‌ನ (ಅಥವಾ cmath) atan2(y, x) ಕಾರ್ಯವು ನಿರ್ಣಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಸರಳ atan(b/a) ಗಿಂತ ಭಿನ್ನವಾಗಿ, ಎಲ್ಲಾ ನಾಲ್ಕು ಚತುರ್ಥಾಂಶಗಳಲ್ಲಿ ಕೋನವನ್ನು ಸರಿಯಾಗಿ ನಿರ್ಧರಿಸುತ್ತದೆ.

ಪೈಥಾನ್‌ನ cmath ಮಾಡ್ಯೂಲ್ ಪೋಲಾರ್ ನಿರ್ದೇಶಾಂಕಗಳೊಂದಿಗೆ ನೇರವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

            import cmath

z_rect = 3 + 4j

# Convert to polar coordinates
polar_coords = cmath.polar(z_rect)
r = polar_coords[0]     # This is 'r'
angle_radians = polar_coords[1] # This is 'theta'

print(f"Rectangular: {z_rect}")
print(f"Polar: Radius = {r:.2f}, Angle (radians) = {angle_radians:.2f}")

# For degrees, convert radians to degrees
angle_degrees = cmath.degrees(angle_radians)
print(f"Polar: Angle (degrees) = {angle_degrees:.2f}")

            

              
                Copy
              
            
          

ಪೋಲಾರ್ ರೂಪದಿಂದ ಆಯತಾಕಾರದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ r(cos θ + i sin θ) ಅಥವಾ re^iθ ಇರುವ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿದಾಗ, ನಾವು ಅದನ್ನು ಆಯತಾಕಾರದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು:

• ನೈಜ ಭಾಗ (a): a = r * cos(θ)
• ಕಾಲ್ಪನಿಕ ಭಾಗ (b): b = r * sin(θ)

ಪೈಥಾನ್‌ನ cmath ಮಾಡ್ಯೂಲ್ ಇದಕ್ಕಾಗಿ cmath.rect() ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ.

            import cmath

radius = 5.0
angle_radians = 0.927 # Approximately 53.13 degrees

# Convert from polar to rectangular coordinates
rectangular_coords = cmath.rect(radius, angle_radians)

print(f"Polar: Radius = {radius}, Angle (radians) = {angle_radians:.2f}")
print(f"Rectangular: {rectangular_coords}")

# Using degrees with cmath.rect is not direct; convert degrees to radians first
angle_degrees_example = 45.0
angle_radians_example = cmath.radians(angle_degrees_example)
rect_from_deg = cmath.rect(1.0, angle_radians_example)
print(f"Polar (45 deg): {rect_from_deg}")

            

              
                Copy
              
            
          

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳು

ಗುಣಾಕಾರ, ಭಾಗಾಕಾರ ಮತ್ತು ಘಾತೀಕರಣವನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಪೋಲಾರ್ ರೂಪದ ನಿಜವಾದ ಶಕ್ತಿ ಹೊರಹೊಮ್ಮುತ್ತದೆ. ಆಯತಾಕಾರದ ರೂಪಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಈ ಕಾರ್ಯಾಚರಣೆಗಳು ಗಣನೀಯವಾಗಿ ಸರಳವಾಗುತ್ತವೆ.

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ಗುಣಾಕಾರ

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ಎರಡು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಗುಣಿಸಲು, ನೀವು ಅವುಗಳ ಮಾಡುಲಸ್‌ಗಳನ್ನು ಗುಣಿಸಿ ಮತ್ತು ಅವುಗಳ ಆರ್ಗುಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತೀರಿ.

ಸೂತ್ರ:

z1 = r1(cos θ1 + i sin θ1) ಮತ್ತು z2 = r2(cos θ2 + i sin θ2) ಆಗಿದ್ದರೆ, ಆಗ

z1 * z2 = (r1 * r2) * [cos(θ1 + θ2) + i sin(θ1 + θ2)]

ಪೈಥಾನ್‌ನ cmath ಮಾಡ್ಯೂಲ್ ಪೋಲಾರ್ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಒಂದೇ ಹಂತದಲ್ಲಿ ಪೋಲಾರ್ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುವ ನೇರ ಗುಣಾಕಾರ ಕಾರ್ಯವನ್ನು ಹೊಂದಿಲ್ಲ. ಅಗತ್ಯವಿದ್ದರೆ ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಆಯತಾಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಿ, ಗುಣಿಸಿ, ಮತ್ತು ನಂತರ ಮತ್ತೆ ಪರಿವರ್ತಿಸುತ್ತೀರಿ, ಅಥವಾ ತರ್ಕವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೀರಿ.

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Convert to polar
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Perform multiplication in polar domain
product_r = r1 * r2
product_theta = theta1 + theta2

# Convert the result back to rectangular
product_rect_polar_method = cmath.rect(product_r, product_theta)

# For comparison, direct multiplication in rectangular form
product_rect_direct = z1_rect * z2_rect

print(f"z1 = {z1_rect}, Polar: r={r1:.2f}, theta={cmath.degrees(theta1):.2f} deg")
print(f"z2 = {z2_rect}, Polar: r={r2:.2f}, theta={cmath.degrees(theta2):.2f} deg")
print(f"Product (Polar Method): {product_rect_polar_method}")
print(f"Product (Direct Method): {product_rect_direct}")

# Note: Small floating-point differences might occur

            

              
                Copy
              
            
          

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ಭಾಗಾಕಾರ

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ಎರಡು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಭಾಗಿಸಲು, ನೀವು ಅವುಗಳ ಮಾಡುಲಸ್‌ಗಳನ್ನು ಭಾಗಿಸಿ ಮತ್ತು ಅವುಗಳ ಆರ್ಗುಮೆಂಟ್‌ಗಳನ್ನು ಕಳೆಯುತ್ತೀರಿ (ಅಂಶದ ಆರ್ಗುಮೆಂಟ್ ಮೈನಸ್ ಛೇದದ ಆರ್ಗುಮೆಂಟ್).

ಸೂತ್ರ:

z1 = r1(cos θ1 + i sin θ1) ಮತ್ತು z2 = r2(cos θ2 + i sin θ2) ಆಗಿದ್ದರೆ, ಆಗ

z1 / z2 = (r1 / r2) * [cos(θ1 - θ2) + i sin(θ1 - θ2)]

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Convert to polar
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Perform division in polar domain
quotient_r = r1 / r2
quotient_theta = theta1 - theta2

# Convert the result back to rectangular
quotient_rect_polar_method = cmath.rect(quotient_r, quotient_theta)

# For comparison, direct division in rectangular form
quotient_rect_direct = z1_rect / z2_rect

print(f"Quotient (Polar Method): {quotient_rect_polar_method}")
print(f"Quotient (Direct Method): {quotient_rect_direct}")

            

              
                Copy
              
            
          

ಘಾತೀಕರಣ (ಡಿ ಮೊಯ್ವರ್‌ನ ಪ್ರಮೇಯ)

ಪೋಲಾರ್ ರೂಪದಲ್ಲಿರುವ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಪೂರ್ಣಾಂಕ ಘಾತ n ಗೆ ಏರಿಸುವುದನ್ನು ಡಿ ಮೊಯ್ವರ್‌ನ ಪ್ರಮೇಯದಿಂದ ಸರಳೀಕರಿಸಲಾಗುತ್ತದೆ:

ಸೂತ್ರ:

[r(cos θ + i sin θ)]ⁿ = rⁿ(cos(nθ) + i sin(nθ))

ಈ ಪ್ರಮೇಯವು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಮೂಲಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು ಮತ್ತು ಬಹುಪದೋಕ್ತಿ ಸಮೀಕರಣಗಳನ್ನು ಪರಿಹರಿಸಲು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ. ಸಂಕೀರ್ಣ ಘಾತಗಳಿಗೆ, ಇದು ಲಾಗರಿಥಂಗಳ ಬಳಕೆಯಿಂದ ವಿಸ್ತರಿಸುತ್ತದೆ.

            import cmath

z_rect = 1 + 1j

# Convert to polar
r, theta = cmath.polar(z_rect)

n = 5  # The power

# Calculate z^n using De Moivre's Theorem
hesized_r = r ** n
hesized_theta = n * theta

# Convert the result back to rectangular
hesized_rect_polar_method = cmath.rect(hesized_r, hesized_theta)

# For comparison, direct exponentiation in Python
hesized_rect_direct = z_rect ** n

print(f"z = {z_rect}, Polar: r={r:.2f}, theta={cmath.degrees(theta):.2f} deg")
print(f"{z_rect}^{n} (Polar Method): {hesized_rect_polar_method}")
print(f"{z_rect}^{n} (Direct Method): {hesized_rect_direct}")

# Calculating roots (e.g., cube root, n=1/3)
n_root = 1/3

r_root = r ** n_root
theta_root_principal = n_root * theta

# The principal root
principal_root = cmath.rect(r_root, theta_root_principal)
print(f"Principal cube root of {z_rect}: {principal_root}")

# Note: For roots, there are 'n' distinct values. De Moivre's theorem applied directly
# usually gives the principal root. To find all roots, you'd add multiples of 2*pi/n to the angle.

for k in range(3):
    current_angle = (theta + 2 * cmath.pi * k) / 3
    root_k = cmath.rect(r_root, current_angle)
    print(f"Cube root {k+1}: {root_k}")

            

              
                Copy
              
            
          

cmath ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಕಾರ್ಯಗಳು

cmath ಮಾಡ್ಯೂಲ್ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅನೇಕ ಸುಧಾರಿತ ಗಣಿತದ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ತ್ರಿಕೋನಮಿತೀಯ, ಹೈಪರ್ಬೋಲಿಕ್ ಮತ್ತು ಲಾಗರಿಥಮಿಕ್ ಕಾರ್ಯಗಳು ಸೇರಿವೆ.

• cmath.sqrt(z): ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ವರ್ಗಮೂಲವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಪ್ರಧಾನ ವರ್ಗಮೂಲವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
• cmath.exp(z): z ನ ಘಾತಕ್ಕೆ ಏರಿಸಿದ e ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
• cmath.log(z[, base]): z ನ ಲಾಗರಿಥಮ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. base ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಅದು ಆ ಬೇಸ್‌ನೊಂದಿಗೆ ಲಾಗರಿಥಮ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಇದು ನೈಸರ್ಗಿಕ ಲಾಗರಿಥಮ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
• cmath.sin(z), cmath.cos(z), cmath.tan(z): ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳಿಗಾಗಿ ತ್ರಿಕೋನಮಿತೀಯ ಕಾರ್ಯಗಳು.
• cmath.sinh(z), cmath.cosh(z), cmath.tanh(z): ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳಿಗಾಗಿ ಹೈಪರ್ಬೋಲಿಕ್ ಕಾರ್ಯಗಳು.

            import cmath

z = 1 + 1j

# Square root
print(f"sqrt({z}) = {cmath.sqrt(z)}")

# Exponential
print(f"exp({z}) = {cmath.exp(z)}")

# Natural logarithm
print(f"log({z}) = {cmath.log(z)}")

# Sine
print(f"sin({z}) = {cmath.sin(z)}")

            

              
                Copy
              
            
          

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಅನ್ವಯಗಳು

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಅವುಗಳ ಪೋಲಾರ್ ನಿರೂಪಣೆಯು ಅನೇಕ ವೈಜ್ಞಾನಿಕ ಮತ್ತು ಎಂಜಿನಿಯರಿಂಗ್ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಅನಿವಾರ್ಯವಾಗಿವೆ:

• ವಿದ್ಯುತ್ ಇಂಜಿನಿಯರಿಂಗ್: AC ಸರ್ಕ್ಯೂಟ್ ವಿಶ್ಲೇಷಣೆ, ಪ್ರತಿರೋಧ ಮತ್ತು ಸಿಗ್ನಲ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಪರ್ಯಾಯ ಪ್ರವಾಹಗಳು ಮತ್ತು ವೋಲ್ಟೇಜ್‌ಗಳ ಪರಿಮಾಣ ಮತ್ತು ಹಂತವನ್ನು ವಿವರಿಸಲು ಪೋಲಾರ್ ರೂಪವು ನೈಸರ್ಗಿಕವಾಗಿದೆ.
• ಸಿಗ್ನಲ್ ಪ್ರೊಸೆಸಿಂಗ್: ಫೋರಿಯರ್ ಪರಿವರ್ತನೆಗಳು, ಇದು ಸಂಕೇತಗಳನ್ನು ಅವುಗಳ ಘಟಕ ಆವರ್ತನಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ, ಸಂಕೀರ್ಣ ಘಾತೀಯಗಳ ಮೇಲೆ (e^iωt) ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ, ಇವುಗಳನ್ನು ಸ್ವಾಭಾವಿಕವಾಗಿ ಪೋಲಾರ್ ರೂಪದಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ.
• ಕ್ವಾಂಟಮ್ ಮೆಕ್ಯಾನಿಕ್ಸ್: ಕ್ವಾಂಟಮ್ ಮೆಕ್ಯಾನಿಕ್ಸ್‌ನ ಮೂಲಭೂತ ಸಮೀಕರಣಗಳು, ಶ್ರೋಡಿಂಗರ್ ಸಮೀಕರಣದಂತೆ, ಸಂಕೀರ್ಣ ತರಂಗ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ.
• ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳು: ಸಿಸ್ಟಮ್ ಸ್ಥಿರತೆ ಮತ್ತು ಆವರ್ತನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು ಲ್ಯಾಪ್ಲೇಸ್ ಡೊಮೈನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
• ದ್ರವ ಚಲನಶಾಸ್ತ್ರ: ದ್ರವ ಯಂತ್ರಶಾಸ್ತ್ರದಲ್ಲಿ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಸಂಕೀರ್ಣ ಸಂಭಾವ್ಯ ಸಿದ್ಧಾಂತವನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳಗೊಳಿಸಬಹುದು.
• ಫ್ರ್ಯಾಕ್ಟಲ್ ಜ್ಯಾಮಿತಿ: ಮ್ಯಾಂಡೆಲ್ಬ್ರೋಟ್ ಸೆಟ್‌ನಂತಹ ಫ್ರ್ಯಾಕ್ಟಲ್‌ಗಳನ್ನು ಸಂಕೀರ್ಣ ಕಾರ್ಯಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವ ಮೂಲಕ ಉತ್ಪಾದಿಸಲಾಗುತ್ತದೆ.

ಜಾಗತಿಕ ಉದಾಹರಣೆ: ಆಡಿಯೋ ಪ್ರೊಸೆಸಿಂಗ್‌ನಲ್ಲಿ ಫೋರಿಯರ್ ಪರಿವರ್ತನೆ

ವಿಶ್ವಾದ್ಯಂತ ಆಡಿಯೋ ಸಿಗ್ನಲ್ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಧ್ವನಿ ತರಂಗವನ್ನು ವಿಶ್ಲೇಷಿಸುವಾಗ, ಎಂಜಿನಿಯರ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಡಿಸ್ಕ್ರೀಟ್ ಫೋರಿಯರ್ ಪರಿವರ್ತನೆ (DFT) ಅಥವಾ ಅದರ ಪರಿಣಾಮಕಾರಿ ಅನುಷ್ಠಾನ, ಫಾಸ್ಟ್ ಫೋರಿಯರ್ ಪರಿವರ್ತನೆ (FFT) ಅನ್ನು ಬಳಸುತ್ತಾರೆ. DFT ಒಂದು ಸಮಯ-ಡೊಮೈನ್ ಸಿಗ್ನಲ್ ಅನ್ನು (ಸಮಯದೊಂದಿಗೆ ಧ್ವನಿ ಒತ್ತಡ ಹೇಗೆ ಬದಲಾಗುತ್ತದೆ) ಅದರ ಆವರ್ತನ-ಡೊಮೈನ್ ನಿರೂಪಣೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಈ ನಿರೂಪಣೆಯು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಸರಣಿಯಾಗಿದೆ, ಅಲ್ಲಿ ಪ್ರತಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯು ನಿರ್ದಿಷ್ಟ ಆವರ್ತನಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ. ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಪರಿಮಾಣವು ಆ ಆವರ್ತನ ಘಟಕದ ವಿಸ್ತಾರವನ್ನು (ಗಟ್ಟಿತನ) ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ಅದರ ಆರ್ಗುಮೆಂಟ್ (ಕೋನ) ಅದರ ಹಂತವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಇದು ಶಬ್ದ ಕಡಿತ, ಸಮೀಕರಣ ಮತ್ತು ಸಂಗೀತ ಸಂಶ್ಲೇಷಣೆಯಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಇದು ಜಾಗತಿಕ ಆಡಿಯೋ ಉತ್ಪಾದನೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಪ್ರಮಾಣಿತವಾಗಿದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಸರಿಯಾದ ರೂಪವನ್ನು ಆರಿಸಿ: ಮೂಲ ಅಂಕಗಣಿತಕ್ಕಾಗಿ (ಕೂಡಿಸುವಿಕೆ, ಕಳೆಯುವಿಕೆ), ಆಯತಾಕಾರದ ರೂಪವು ಸಾಮಾನ್ಯವಾಗಿ ಸರಳವಾಗಿದೆ. ಗುಣಾಕಾರ, ಭಾಗಾಕಾರ ಮತ್ತು ಘಾತೀಕರಣ/ಮೂಲಗಳಿಗೆ, ವಿಶೇಷವಾಗಿ ಕೋನಗಳು ಮತ್ತು ತಿರುಗುವಿಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವಾಗ, ಪೋಲಾರ್ ರೂಪ (ಅಥವಾ ಇದನ್ನು ಅಮೂರ್ತಗೊಳಿಸುವ cmath ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವುದು) ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಪರಿಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ.
• cmath ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಿ: ಮೂಲ ಅಂಕಗಣಿತವನ್ನು ಮೀರಿ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯ ಗಣಿತಕ್ಕಾಗಿ ಯಾವಾಗಲೂ cmath ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿ. ಇದು ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಸುಧಾರಿತ ಕಾರ್ಯಗಳನ್ನು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಒದಗಿಸುತ್ತದೆ.
• ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ನಿಖರತೆಯ ಬಗ್ಗೆ ಜಾಗೃತರಾಗಿರಿ: ಎಲ್ಲಾ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಲೆಕ್ಕಾಚಾರಗಳಂತೆ, ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡ ಫಲಿತಾಂಶಗಳು ಸಣ್ಣ ನಿಖರತೆಯ ದೋಷಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ನಿಖರ ಸಮಾನತೆಗಾಗಿ ಹೋಲಿಸುವಾಗ ಜಾಗರೂಕರಾಗಿರಿ.
• ರೇಡಿಯನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಪೈಥಾನ್‌ನ math ಮತ್ತು cmath ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿನ ತ್ರಿಕೋನಮಿತೀಯ ಕಾರ್ಯಗಳು ರೇಡಿಯನ್‌ಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನಿಮ್ಮ ಕೋನಗಳು ಸರಿಯಾದ ಘಟಕದಲ್ಲಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಕೋನಗಳಿಗಾಗಿ `atan2` ಬಳಸಿ: ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗಗಳಿಂದ ಆರ್ಗುಮೆಂಟ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಾಗ, ನಿಖರವಾದ ಚತುರ್ಥಾಂಶ ನಿರ್ಣಯಕ್ಕಾಗಿ math.atan2(imaginary, real) ಅಥವಾ cmath.phase(complex_number) ಬಳಸಿ.

ತೀರ್ಮಾನ

ಪೈಥಾನ್‌ನ ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲ, ಪ್ರಬಲ cmath ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಪೂರಕವಾಗಿ, ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಗಣಿತ ಮತ್ತು ವೈಜ್ಞಾನಿಕ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಲು ಸಮಗ್ರ ಟೂಲ್‌ಕಿಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ನೇರ ಬೀಜಗಣಿತದ ಕುಶಲತೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರಲಿ ಅಥವಾ ತಿರುಗುವಿಕೆ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್‌ನಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಪೋಲಾರ್ ನಿರ್ದೇಶಾಂಕಗಳ ಸೊಗಸಾದ ಜಗತ್ತನ್ನು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತಿರಲಿ, ಪೈಥಾನ್ ನಿಮಗೆ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ದಕ್ಷತೆಯೊಂದಿಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ.

ಆಯತಾಕಾರದ ಮತ್ತು ಪೋಲಾರ್ ರೂಪಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದಿಂದ ಒದಗಿಸಲಾದ ಕಾರ್ಯಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಅನ್ವಯಿಸುವ ಮೂಲಕ, ವಿಶ್ವಾದ್ಯಂತ ಅಭಿವರ್ಧಕರು ಮತ್ತು ಸಂಶೋಧಕರು ದೂರಸಂಪರ್ಕ ಮತ್ತು ಏರೋಸ್ಪೇಸ್‌ನಿಂದ ಆರ್ಥಿಕ ಮಾದರಿ ಮತ್ತು ಕ್ವಾಂಟಮ್ ಕಂಪ್ಯೂಟಿಂಗ್‌ವರೆಗಿನ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಹೊಸ ಸಾಧ್ಯತೆಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು. ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ನಿಸ್ಸಂದೇಹವಾಗಿ ಹೆಚ್ಚುತ್ತಿರುವ ಸಂಕೀರ್ಣ ಮತ್ತು ಪರಸ್ಪರ ಸಂಪರ್ಕಿತ ಜಗತ್ತಿನಲ್ಲಿ ನಿಮ್ಮ ಸಮಸ್ಯೆ-ಪರಿಹಾರ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.