Author name: Vikram Chiluka

cmath.log() Method in Python:

The logarithm of a complex value is returned by the cmath.log() method.

This method takes a single argument and returns the natural logarithm of that argument with base e.

This method takes two arguments and returns the logarithm of the first argument (x) multiplied by the base of the second argument (base).

Syntax:

cmath.log(x, base)

Parameters

x: This is Required. Specifies the value for which the logarithm should be calculated.

• If the value is 0 or a negative number, a ValueError is returned.
• If the value is not a number, a TypeError is returned.

base: This is Optional. The logarithmic base that should be used. ‘e’ is the default.

Return Value:

Returns a complex value that represents the natural logarithm of a number or the base logarithm of a number.

Changelog: The base parameter has been added.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) logarithm value = 
(1.6094379124341003+0.9272952180016122j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2
Given base value = 4

Output:

The given complex number's (5+2j) logarithm value for the given base{ 4.0 } = 
(1.214495248781893+0.27447733164331733j)

Note: The above input format is for dynamic input.

cmath.log() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

1)With a single argument

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.log() method that returns the given complex number’s logarithm value.
• Store it in another variable.
• Print the logarithm value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.log() method that
# returns the the given complex number's logarithm value.
# Store it in another variable.
rslt = cmath.log(complexnumb)
# Print the logarithm value of the given complex number.
print("The given complex number's", complexnumb,
      "logarithm value = ")
print(rslt)

Output:

The given complex number's (3+4j) logarithm value = 
(1.6094379124341003+0.9272952180016122j)

2)With two arguments

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Give the base value as static input and store it in another variable.
• Pass the given complex number, base value as the arguments to the cmath.log() method that returns the given complex number’s logarithm value for the given base.
• Store it in another variable.
• Print the logarithm value of the given complex number for the given base.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 4
# Give the base value as static input and store it in another variable.
gvn_basevalu = 8
# Pass the given complex number, base value as the arguments to the cmath.log()
# method that returns the given complex number's logarithm value for
# the given base.
# Store it in another variable.
rslt = cmath.log(complexnumb, gvn_basevalu)
# Print the logarithm value of the given complex number for the given base.
print("The given complex number's", complexnumb,
      "logarithm value for the given base{", gvn_basevalu, "} = ")
print(rslt)

Output:

The given complex number's 4 logarithm value for the given base{ 8 } = 
(0.6666666666666667+0j)

Method #2: Using Built-in Functions (User Input)

1)With a single argument

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.log() method that returns the given complex number’s logarithm value.
• Store it in another variable.
• Print the logarithm value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.log() method that
# returns the the given complex number's logarithm value.
# Store it in another variable.
rslt = cmath.log(complexnumb)
# Print the logarithm value of the given complex number.
print("The given complex number's", complexnumb,
      "logarithm value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) logarithm value = 
(1.6836479149932368+0.3805063771123649j)

2)With two arguments

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Give the base value as user input using the float(input()) function and store it in another variable.
• Pass the given complex number, base value as the arguments to the cmath.log() method that returns the given complex number’s logarithm value for the given base.
• Store it in another variable.
• Print the logarithm value of the given complex number for the given base.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Give the base value as user input using the float(input()) function and
# store it in another variable.
gvn_basevalu = float(input("Enter some random number = "))
# Pass the given complex number, base value as the arguments to the cmath.log()
# method that returns the given complex number's logarithm value for
# the given base.
# Store it in another variable.
rslt = cmath.log(complexnumb, gvn_basevalu)
# Print the logarithm value of the given complex number for the given base.
print("The given complex number's", complexnumb,
      "logarithm value for the given base{", gvn_basevalu, "} = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
Enter some random number = 4
The given complex number's (5+2j) logarithm value for the given base{ 4.0 } = 
(1.214495248781893+0.27447733164331733j)

cmath.phase() Method in Python:

The phase of a complex number is returned by the cmath.phase() method.

The magnitude and angle of a complex number can be expressed. Phase is the angle formed by a vector (representing a complex number) and the positive x-axis.

Note: It should be noted that the output is always between -π and π.

Syntax:

cmath.phase(x)

Parameters

x: This is Required. The number used to determine the phase of

Return Value:

Returns a float value that represents a complex number’s phase.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) phase value = 
0.9272952180016122

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) phase value = 
0.3805063771123649

Note: The above input format is for dynamic input.

cmath.phase() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.phase() method that returns the given complex number’s phase value.
• Store it in another variable.
• Print the phase value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.phase() method that
# returns the the given complex number's phase value.
# Store it in another variable.
rslt = cmath.phase(complexnumb)
# Print the phase value of the given complex number.
print("The given complex number's", complexnumb,
      "phase value = ")
print(rslt)

Output:

The given complex number's (3+4j) phase value = 
0.9272952180016122

Similarly, try for the other examples

import cmath
complexnumb = -2-1j
rslt = cmath.phase(complexnumb)
print("The given complex number's", complexnumb,
      "phase value = ")
print(rslt)

Output:

The given complex number's (-2-1j) phase value = 
-2.677945044588987

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.phase() method that returns the given complex number’s phase value.
• Store it in another variable.
• Print the phase value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.phase() method that
# returns the the given complex number's phase value.
# Store it in another variable.
rslt = cmath.phase(complexnumb)
# Print the phase value of the given complex number.
print("The given complex number's", complexnumb,
      "phase value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) phase value = 
0.3805063771123649

cmath.isnan() Method in Python:

The cmath.isnan() method determines whether a value is a nan (Not a Number).

This method gives the following Boolean value: True if the value is nan, False otherwise.

Syntax:

cmath.isnan(x)

Parameters

x: This is Required. The value used to test for NaN

Return Value:

Returns a bool value that is True if any part of a complex number (real or imaginary) is NaN, otherwise False.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The result after applying isnan() method to the given complex number (3+4j)  = 
False

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The result after applying isnan() method to the given complex number (5+2j) = 
False

Note: The above input format is for dynamic input.

cmath.isnan() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.isnan() method that determines whether a given complex number’s value is nan (Not a Number) or not.
• Store it in another variable.
• Print the above result after applying isnan() method to the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.isnan() method
# that determines whether a given complex number's value is nan (Not a Number)or not.
# Store it in another variable.
rslt = cmath.isnan(complexnumb)
# Print the above result after applying isnan() method to the given complex number.
print("The result after applying isnan() method to the given complex number", complexnumb,
      " = ")
print(rslt)

Output:

The result after applying isnan() method to the given complex number (3+4j)  = 
False

Similarly, try for the other examples

import cmath
complexnumb = 10 + float('nan')
rslt = cmath.isnan(complexnumb)
print("The result after applying isnan() method to the given complex number = ")
print(rslt)

Output:

The result after applying isnan() method to the given complex number = 
True

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.isnan() method that determines whether a given complex number’s value is nan (Not a Number) or not.
• Store it in another variable.
• Print the above result after applying isnan() method to the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.isnan() method
# that determines whether a given complex number's value is nan (Not a Number)
# or not.
# Store it in another variable.
rslt = cmath.isnan(complexnumb)
# Print the above result after applying isnan() method to the given complex number.
print("The result after applying isnan() method to the given complex number", complexnumb,
      " = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The result after applying isnan() method to the given complex number (5+2j) = 
False

cmath.isinf() Method in Python:

The cmath.isinf() method determines whether or not a value is positive or negative infinity.

This method gives the following Boolean value: If the value is infinity, True; otherwise, False.

Syntax:

cmath.isinf(x)

Parameters

x: This is Required. The value used to test for infinity

Return Value:

Returns a bool value that is True if the value is infinite and False otherwise.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The result after applying isinf() method to the given complex number (3+4j)  = 
False

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

Enter real part and complex part of the complex number = 5 2
The result after applying isinf() method to the given complex number (5+2j) = 
False

Note: The above input format is for dynamic input.

cmath.isinf() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.isinf() method that determines whether a given complex number’s value is positive or negative infinity.
• Store it in another variable.
• Print the above result after applying isinf() method to the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3 + 4j
# Pass the given complex number as an argument to the cmath.isinf() method
# that determines whether a given complex number's value is positive or
# negative infinity.
# Store it in another variable.
rslt = cmath.isinf(complexnumb)
# Print the above result after applying isinf() method to the given complex number.
print("The result after applying isinf() method to the given complex number", complexnumb,
      " = ")
print(rslt)

Output:

The result after applying isinf() method to the given complex number (3+4j)  = 
False

Similarly, try for the other examples

import cmath
complexnumb = complex(10 + float('inf'))
rslt = cmath.isinf(complexnumb)
print("The result after applying isinf() method to the given complex number", complexnumb,
      " = ")
print(rslt)

Output:

The result after applying isinf() method to the given complex number (inf+0j)  = 
True

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.isinf() method that determines whether a given complex number’s value is positive or negative infinity.
• Store it in another variable.
• Print the above result after applying isinf() method to the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.isinf() method
# that determines whether a given complex number's value is positive or
# negative infinity.
# Store it in another variable.
rslt = cmath.isinf(complexnumb)
# Print the above result after applying isinf() method to the given complex number.
print("The result after applying isinf() method to the given complex number", complexnumb,
      " = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The result after applying isinf() method to the given complex number (5+2j) = 
False

cmath.tanh() Method in Python:

The cmath.tanh() method returns the complex number’s hyperbolic tangent.

Syntax:

cmath.tanh(x)

Parameters

x: This is Required. It is a number that will be used to calculate the hyperbolic tangent.

If the value is not a number, a TypeError is returned.

Return Value:

Returns a complex value that represents a complex number’s hyperbolic tangent.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) hyperbolic tangent value = 
(1.000709536067233+0.00490825806749606j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) hyperbolic tangent value = 
(1.0000593501490003-6.872163880119276e-05j)

Note: The above input format is for dynamic input.

cmath.tanh() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.tanh() method that returns the given complex number’s hyperbolic tangent value.
• Store it in another variable.
• Print the hyperbolic tangent value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.tanh() method that
# returns the the given complex number's hyperbolic tangent value.
# Store it in another variable.
rslt = cmath.tanh(complexnumb)
# Print the hyperbolic tangent value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic tangent value = ")
print(rslt)

Output:

The given complex number's (3+4j) hyperbolic tangent value = 
(1.000709536067233+0.00490825806749606j)

Similarly, try for the other examples

import cmath
complexnumb = -2-1j
rslt = cmath.tanh(complexnumb)
print("The given complex number's", complexnumb,
      "hyperbolic tangent value = ")
print(rslt)

Output:

The given complex number's (-2-1j) hyperbolic tangent value = 
(-1.0147936161466335-0.0338128260798967j)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.tanh() method that returns the given complex number’s hyperbolic tangent value.
• Store it in another variable.
• Print the hyperbolic tangent value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.tanh() method that
# returns the the given complex number's hyperbolic tangent value.
# Store it in another variable.
rslt = cmath.tanh(complexnumb)
# Print the hyperbolic tangent value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic tangent value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) hyperbolic tangent value = 
(1.0000593501490003-6.872163880119276e-05j)

cmath.exp() Method in Python:

The cmath.exp() method takes a complex number as an argument and returns the exponential value. If the number is x, it returns e**x, where e is the natural logarithm base.

Syntax:

cmath.exp(x)

Parameters

x: This is Required. A number whose exponential value is to be determined.

Return Value:

Returns a  complex value that represents a complex number’s exponential.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) exponential value = 
(-13.128783081462158-15.200784463067954j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) exponential value = 
(-61.761666662504986+134.9517036790434j)

Note: The above input format is for dynamic input.

cmath.exp() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.exp() method that returns the given complex number’s exponential value.
• Store it in another variable.
• Print the exponential value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.exp() method that
# returns the the given complex number's exponential value.
# Store it in another variable.
rslt = cmath.exp(complexnumb)
# Print the exponential value of the given complex number.
print("The given complex number's", complexnumb,
      "exponential value = ")
print(rslt)

Output:

The given complex number's (3+4j) exponential value = 
(-13.128783081462158-15.200784463067954j)

Similarly, try for the other examples

import cmath
complexnumb = -1-2j
rslt = cmath.exp(complexnumb)
print("The given complex number's", complexnumb,
      "exponential value = ")
print(rslt)

Output:

The given complex number's (-1-2j) exponential value = 
(-0.1530918656742263-0.33451182923926226j)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.exp() method that returns the given complex number’s exponential value.
• Store it in another variable.
• Print the exponential value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.exp() method that
# returns the the given complex number's exponential value.
# Store it in another variable.
rslt = cmath.exp(complexnumb)
# Print the exponential value of the given complex number.
print("The given complex number's", complexnumb,
      "exponential value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) exponential value = 
(-61.761666662504986+134.9517036790434j)

cmath.polar() Method in Python:

A complex number is converted to polar coordinates using the cmath.polar() method. It returns a tuple consisting of modulus and phase.

A complex number in polar coordinates is defined by modulus r and phase angle phi.

Syntax:

cmath.polar(x)

Parameters

x: This is Required. A number used to calculate the polar coordinates of

Return Value:

Returns a tuple value containing polar coordinates.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The polar coordinates of given complex number (3+4j)  = 
(5.0, 0.9272952180016122)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The polar coordinates of given complex number (5+2j) = 
(5.385164807134504, 0.3805063771123649)

Note: The above input format is for dynamic input.

cmath.polar() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.polar() method that converts the given complex number to polar coordinates and returns a tuple consisting of modulus and phase.
• Store it in another variable.
• Print the result tuple consisting of modulus and phase.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.polar() method
# that converts the given complex number to polar coordinates and returns a
# tuple consisting of modulus and phase.
# Store it in another variable.
rslt = cmath.polar(complexnumb)
# Print the result tuple consisting of modulus and phase.
print("The polar coordinates of given complex number", complexnumb,
      " = ")
print(rslt)

Output:

The polar coordinates of given complex number (3+4j)  = 
(5.0, 0.9272952180016122)

Similarly, try for the other examples

import cmath
complexnumb = -1-2j
rslt = cmath.polar(complexnumb)
print("The polar coordinates of given complex number", complexnumb,
      " = ")
print(rslt)

Output:

The polar coordinates of given complex number (-1-2j)  = 
(2.23606797749979, -2.0344439357957027)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.polar() method that converts the given complex number to polar coordinates and returns a tuple consisting of modulus and phase.
• Store it in another variable.
• Print the result tuple consisting of modulus and phase.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.polar() method
# that converts the given complex number to polar coordinates and returns a
# tuple consisting of modulus and phase.
# Store it in another variable.
rslt = cmath.polar(complexnumb)
# Print the above result tuple consisting of modulus and phase.
print("The polar coordinates of given complex number", complexnumb,
      " = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The polar coordinates of given complex number (5+2j) = 
(5.385164807134504, 0.3805063771123649)

cmath.sin() Method in Python:

The sine of a number is returned by the cmath.sin() method.

Sine is a trigonometric function that represents the ratio of a right triangle’s opposite side to its hypotenuse.

Syntax:

cmath.sin(x)

Parameters

x: This is Required. It is a number that can be used to calculate the sine of

Return Value:

Returns a complex value that denotes the sine of a complex number.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) sine value = 
(3.853738037919377-27.016813258003932j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) sine value = 
(-3.6076607742131563+1.0288031496599335j)

Note: The above input format is for dynamic input.

cmath.sin() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.sin() method that returns the given complex number’s sine value.
• Store it in another variable.
• Print the sine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.sin() method that
# returns the given complex number's sine value.
# Store it in another variable.
rslt = cmath.sin(complexnumb)
# Print the sine value of the given complex number.
print("The given complex number's", complexnumb,
      "sine value = ")
print(rslt)

Output:

The given complex number's (3+4j) sine value = 
(3.853738037919377-27.016813258003932j)

Similarly, try for the other examples

import cmath
complexnumb = -1-2j
rslt = cmath.sin(complexnumb)
print("The given complex number's", complexnumb,
      "sine value = ")
print(rslt)

Output:

The given complex number's (-1-2j) sine value = 
(-3.165778513216168-1.9596010414216063j)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.sin() method that returns the given complex number’s sine value.
• Store it in another variable.
• Print the sine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.sin() method that
# returns the given complex number's sine value.
# Store it in another variable.
rslt = cmath.sin(complexnumb)
# Print the sine value of the given complex number.
print("The given complex number's", complexnumb,
      "sine value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) sine value = 
(-3.6076607742131563+1.0288031496599335j)

cmath.sinh() Method in Python:

The cmath.sinh() method returns the given complex number’s hyperbolic sine.

Syntax:

cmath.sinh(x)

Parameters

x: This is Required. It is a number used to calculate the hyperbolic sine of

Return Value:

Returns a complex value that represents the complex number’s hyperbolic sine.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) hyperbolic sine value = 
(-6.5481200409110025-7.61923172032141j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) hyperbolic sine value = 
(-30.879431343588244+67.47891523845588j)

Note: The above input format is for dynamic input.

cmath.sinh() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.sinh() method that returns the given complex number’s hyperbolic sine value.
• Store it in another variable.
• Print the hyperbolic sine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.sinh() method that
# returns the given complex number's hyperbolic sine value.
# Store it in another variable.
rslt = cmath.sinh(complexnumb)
# Print the hyperbolic sine value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic sine value = ")
print(rslt)

Output:

The given complex number's (3+4j) hyperbolic sine value = 
(-6.5481200409110025-7.61923172032141j)

Similarly, try for the other examples

import cmath
complexnumb = -1-3j
rslt = cmath.sinh(complexnumb)
print("The given complex number's", complexnumb,
      "hyperbolic sine value = ")
print(rslt)

Output:

The given complex number's (-1-3j) hyperbolic sine value = 
(1.1634403637032504-0.21775955162215221j)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.sinh() method that returns the given complex number’s hyperbolic sine value.
• Store it in another variable.
• Print the hyperbolic sine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.sinh() method that
# returns the given complex number's hyperbolic sine value.
# Store it in another variable.
rslt = cmath.sinh(complexnumb)
# Print the hyperbolic sine value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic sine value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) hyperbolic sine value = 
(-30.879431343588244+67.47891523845588j)

cmath.cosh() Method in Python:

The cmath.cosh() method returns the given complex number’s hyperbolic cosine.

Syntax:

cmath.cosh(x)

Parameters

x: This is Required. It is a number for calculating the hyperbolic cosine of

Return Value:

Returns a complex value that represents the complex number’s hyperbolic cosine.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) hyperbolic cosine value = 
(-6.580663040551157-7.581552742746545j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) hyperbolic cosine value = 
(-30.88223531891674+67.47278844058752j)

Note: The above input format is for dynamic input.

cmath.cosh() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the complex number as static input and store it in a variable.
• Pass the given complex number as an argument to the cmath.cosh() method that returns the given complex number’s hyperbolic cosine value.
• Store it in another variable.
• Print the hyperbolic cosine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the complex number as static input and store it in a variable.
complexnumb = 3+4j
# Pass the given complex number as an argument to the cmath.cosh() method that
# returns the given complex number's hyperbolic cosine value.
# Store it in another variable.
rslt = cmath.cosh(complexnumb)
# Print the hyperbolic cosine value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic cosine value. = ")
print(rslt)

Output:

The given complex number's (3+4j) hyperbolic cosine value. = 
(-6.580663040551157-7.581552742746545j)

Similarly, try for the other examples

import cmath
complexnumb = -5-1j
rslt = cmath.cosh(complexnumb)
print("The given complex number's", complexnumb,
      "hyperbolic cosine value = ")
print(rslt)

Output:

The given complex number's (-5-1j) hyperbolic cosine value = 
(40.09580630629883+62.43984868079963j)

Method #2: Using Built-in Functions (User Input)

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the real part and imaginary part of the complex number as user input using map(), int(), split().
• Store it in two variables.
• Using a complex() function convert those two variables into a complex number and store them in a variable.
• Pass the given complex number as an argument to the cmath.cosh() method that returns the given complex number’s hyperbolic cosine value.
• Store it in another variable.
• Print the hyperbolic cosine value of the given complex number.
• The Exit of the Program.

Below is the implementation:

# Import cmath module(for complex number operations) using the import keyword.
import cmath
# Give the real part and imaginary part of the complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb, imaginarynumb = map(int, input(
    'Enter real part and complex part of the complex number = ').split())
# Using a complex() function convert those two variables into a complex number.
complexnumb = complex(realnumb, imaginarynumb)

# Pass the given complex number as an argument to the cmath.cosh() method that
# returns the given complex number's hyperbolic cosine value.
# Store it in another variable.
rslt = cmath.cosh(complexnumb)
# Print the hyperbolic cosine value of the given complex number.
print("The given complex number's", complexnumb,
      "hyperbolic cosine value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) hyperbolic cosine value = 
(-30.88223531891674+67.47278844058752j)