Python

cmath.isclose() Method in Python:

The cmath.isclose() method determines whether or not two complex values are close. This method gives the following Boolean value: If the values are close, True; otherwise, False.

To determine whether the values are close, this method employs either a relative tolerance or an absolute tolerance.

It compares the values using the following formula:

abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

Syntax:

cmath.isclose(a, b, rel_tol= value, abs_tol= value)

Parameters

a: This is Required. The first value used to determine closeness

b: This is Required. The second value used to determine closeness

rel_tol: This is Optional. It is relative tolerance. It is the greatest (maximum) possible difference between values a and b. 1e-09 is the default value.

abs_tol: This is Optional. The absolute minimum tolerance. It is used to compare values close to zero. The value must be greater than zero.

Return Value:

Returns a true or false value. If the values are close, True; otherwise, False.

Examples:

Example1:

Input:

Given first Complex Number = 3+4j
Given second Complex Number = 3+4j

Output:

Checking if the given two complex values are close or not = True

Example2:

Input:

Given first Complex Number = 5+2j
Given second Complex Number = 5+26j

Output:

Checking if the given two complex values are close or not = False

cmath.isclose() 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 first complex number as static input and store it in a variable.
• Give the second complex number as static input and store it in another variable.
• Pass the given two complex numbers as the arguments to the cmath.isclose() method that determines whether or not given two complex values is close.
• Store it in another variable.
• Print the above result.
• 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.
complexnumb1 = 3+4j
# Give the second complex number as static input and store it in another variable.
complexnumb2 = 3+4j
# Pass the given two complex numbers as the arguments to the cmath.isclose()
# method that determines whether or not given two complex values are close.
# Store it in another variable.
rslt = cmath.isclose(complexnumb1, complexnumb2)
# Print the above result
print("Checking if the given two complex values are close or not =", rslt)

Output:

Checking if the given two complex values are close or not = True

With giving absolute tolerance

Approach:

• Import cmath module(for complex number operations) using the import keyword.
• Give the first complex number as static input and store it in a variable.
• Give the second complex number as static input and store it in another variable.
• Pass the given two complex numbers and absolute tolerance as some random number as the arguments to the cmath.isclose() method that determines whether or not given two complex values is close.
• Store it in another variable.
• Print the above result.
• 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.
complexnumb1 = 5+2j
# Give the second complex number as static input and store it in another variable.
complexnumb2 = 5+2j
# Pass the given two complex numbers and absolute tolerance as some random number
# as the arguments to the cmath.isclose() method that determines whether or
# not given two complex values are close.
# Store it in another variable.
rslt = cmath.isclose(complexnumb1, complexnumb2, abs_tol=0.005)
# Print the above result
print("Checking if the given two complex values are close or not =", rslt)

Output:

Checking if the given two complex values are close or not = 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 first 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 real part and imaginary part of the second 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 two complex numbers as the arguments to the cmath.isclose() method that determines whether or not given two complex values is close.
• Store it in another variable.
• Print the above result.
• 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 first complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb1, imaginarynumb1 = 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.
complexnumb1 = complex(realnumb1, imaginarynumb1)
# Give the real part and imaginary part of the second complex number as user input
# using map(), int(), split().
# Store it in two variables.
realnumb2, imaginarynumb2 = 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.
complexnumb2 = complex(realnumb2, imaginarynumb2)

# Pass the given two complex numbers as the arguments to the cmath.isclose()
# method that determines whether or not given two complex values are close.
# Store it in another variable.
rslt = cmath.isclose(complexnumb1, complexnumb2)
# Print the above result
print("Checking if the given two complex values are close or not =", rslt)

Output:

Enter real part and complex part of the complex number = 5 2
Enter real part and complex part of the complex number = 3 2
Checking if the given two complex values are close or not = False

cmath.atan() Method in Python:

The cmath.atan() method returns the complex number’s arc tangent.

There are primarily two types of branch cuts:

1. Extend from 1j along the imaginary axis to ∞ j to the right.
2. Extending from -1j to -∞ j to the left along the imaginary axis

Syntax:

cmath.atan(x)

Parameters

x: This is Required. A number used to calculate the arc tangent of

Return Value:

Returns a complex value that represents the complex number’s arc tangent.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) arc tangent value = 
(1.4483069952314644+0.15899719167999918j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) arc tangent value = 
(1.399284356584545+0.06706599664866984j)

Note: The above input format is for dynamic input.

cmath.atan() 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.atan() method that returns the given complex number’s arc tangent value.
• Store it in another variable.
• Print the arc 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.atan() method that
# returns the the given complex number's arc tangent value.
# Store it in another variable.
rslt = cmath.atan(complexnumb)
# Print the arc tangent value of the given complex number.
print("The given complex number's", complexnumb,
      "arc tangent value = ")
print(rslt)

Output:

The given complex number's (3+4j) arc tangent value = 
(1.4483069952314644+0.15899719167999918j)

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 it in a variable.
• Pass the given complex number as an argument to the cmath.atan() method that returns the given complex number’s arc tangent value.
• Store it in another variable.
• Print the arc 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.atan() method that
# returns the the given complex number's arc tangent value.
# Store it in another variable.
rslt = cmath.atan(complexnumb)
# Print the arc tangent value of the given complex number.
print("The given complex number's", complexnumb,
      "arc tangent value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) arc tangent value = 
(1.399284356584545+0.06706599664866984j)

cmath.asinh() Method in Python:

The cmath.asinh() method returns a number’s inverse hyperbolic sine.

There are primarily two types of branch cuts:

1. Extend from 1j along the imaginary axis to ∞ j to the right.
2. Extending from -1j to -∞ j to the left along the imaginary axis

Syntax:

cmath.asinh(x)

Parameters

x: This is Required. The number used to calculate the inverse hyperbolic sine of

Return Value:

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

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) inverse hyperbolic sine value = 
(2.2999140408792695+0.9176168533514787j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) inverse hyperbolic sine value = 
(2.3830308809003258+0.374670804825527j)

Note: The above input format is for dynamic input.

cmath.asinh() 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.asinh() method that returns the given complex number’s inverse hyperbolic sine value.
• Store it in another variable.
• Print the inverse 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.asinh() method that
# returns the given complex number's inverse hyperbolic sine value.
# Store it in another variable.
rslt = cmath.asinh(complexnumb)
# Print the inverse hyperbolic sine value of the given complex number.
print("The given complex number's", complexnumb,
      "inverse hyperbolic sine value = ")
print(rslt)

Output:

The given complex number's (3+4j) inverse hyperbolic sine value = 
(2.2999140408792695+0.9176168533514787j)

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 it in a variable.
• Pass the given complex number as an argument to the cmath.asinh() method that returns the given complex number’s inverse hyperbolic sine value.
• Store it in another variable.
• Print the inverse 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.asinh() method that
# returns the given complex number's inverse hyperbolic sine value.
# Store it in another variable.
rslt = cmath.asinh(complexnumb)
# Print the inverse hyperbolic sine value of the given complex number.
print("The given complex number's", complexnumb,
      "inverse 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) inverse hyperbolic sine value = 
(2.3830308809003258+0.374670804825527j)

cmath.asin() Method in Python:

The cmath.asin() method returns the complex number’s arc sine.

There are two types of branch cuts:

1. Extends right from 1 to ∞ along the real axis.
2. Extends left along the real axis from -1 to -∞

Syntax:

cmath.asin(x)

Parameters

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

Return Value:

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

Examples:

Example1:

Input:

Given Complex Number = 4+2j

Output:

The given complex number's (4+2j) arc sine value  = 
(1.096921548830143+2.183585216564564j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) arc sine value = 
(1.184231684275022+2.37054853731792j)

Note: The above input format is for dynamic input.

cmath.asin() 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.asin() method that returns the given complex number’s arc sine value.
• Store it in another variable.
• Print the arc 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 = 4+2j
# Pass the given complex number as an argument to the cmath.asin() method that
# returns the given complex number's arc sine value.
# Store it in another variable.
rslt = cmath.asin(complexnumb)
# Print the arc sine value of the given complex number.
print("The given complex number's", complexnumb,
      "arc sine value  = ")
print(rslt)

Output:

The given complex number's (4+2j) arc sine value  = 
(1.096921548830143+2.183585216564564j)

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 it in a variable.
• Pass the given complex number as an argument to the cmath.asin() method that returns the given complex number’s arc sine value.
• Store it in another variable.
• Print the arc 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.asin() method that
# returns the given complex number's arc sine value.
# Store it in another variable.
rslt = cmath.asin(complexnumb)
# Print the arc sine value of the given complex number.
print("The given complex number's", complexnumb,
      "arc sine value  = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) arc sine value = 
(1.184231684275022+2.37054853731792j)

cmath.acosh() Method in Python:

The cmath.acosh() method returns the complex number’s inverse hyperbolic cosine.

There is one branch cut:

Extending left along the real axis from 1 to -∞ , continuous from above

Syntax:

cmath.acosh(x)

Parameters

x: This is Required. The number used to calculate the inverse hyperbolic cosine of

Return Value:

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

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j) inverse hyperbolic cosine value  = 
(2.305509031243477+0.9368124611557198j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j) inverse hyperbolic cosine value = 
(2.37054853731792+0.38656464251987466j)

Note: The above input format is for dynamic input.

cmath.acosh() 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.acosh() method that returns the given complex number’s inverse hyperbolic cosine value.
• Store it in another variable.
• Print the inverse 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.
gvn_numb = 3+4j
# Pass the given complex number as an argument to the cmath.acosh() method that
# returns the given complex number's inverse hyperbolic cosine value.
# Store it in another variable.
rslt = cmath.acosh(gvn_numb)
# Print the inverse hyperbolic cosine value of the given complex number.
print("The given complex number's", gvn_numb,
      "inverse hyperbolic cosine value  = ")
print(rslt)

Output:

The given complex number's (3+4j) inverse hyperbolic cosine value  = 
(2.305509031243477+0.9368124611557198j)

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 it in a variable.
• Pass the given complex number as an argument to the cmath.acosh() method that returns the given complex number’s inverse hyperbolic cosine value.
• Store it in another variable.
• Print the inverse 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.acosh() method that
# returns the given complex number's inverse hyperbolic cosine value.
# Store it in another variable.
rslt = cmath.acosh(complexnumb)
# Print the inverse hyperbolic cosine value of the given complex number.
print("The given complex number's", complexnumb,
      "inverse 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) inverse hyperbolic cosine value = 
(2.37054853731792+0.38656464251987466j)

cmath.acos() Method in Python:

The cmath.acos() method returns the complex number’s arc cosine.

There are two types of branch cuts:

1. Extends to the right from 1 to ∞ along the real axis.
2. Extends to the left from -1 to -∞ along the real axis.

Syntax:

cmath.acos(x)

Parameters

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

Return Value:

Returns a complex value that represents a number’s arc cosine.

If the return value is expressed as a real number, it has an imaginary part of 0.

Examples:

Example1:

Input:

Given Complex Number = 3+4j

Output:

The given complex number's (3+4j)  arc cosine value = 
(0.9368124611557198-2.305509031243477j)

Example2:

Input:

Given realpart = 5
Given imaginary part = 2

Output:

The given complex number's (5+2j)  arc cosine value = 
(0.38656464251987466-2.37054853731792j)

Note: The above input format is for dynamic input.

cmath.acos() 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.acos() method that returns the given complex number’s arc cosine value.
• Store it in another variable.
• Print the arc 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.
gvn_numb = 3+4j
# Pass the given complex number as an argument to the cmath.acos() method that
# returns the given complex number's arc cosine value.
# Store it in another variable.
rslt = cmath.acos(gvn_numb)
# Print the arc cosine value of the given complex number.
print("The given complex number's", gvn_numb, " arc cosine value = ")
print(rslt)

Output:

The given complex number's (3+4j)  arc cosine value = 
(0.9368124611557198-2.305509031243477j)

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 it in a variable.
• Pass the given complex number as an argument to the cmath.acos() method that returns the given complex number’s arc cosine value.
• Store it in another variable.
• Print the arc 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.acos() method that
# returns the given complex number's arc cosine value.
# Store it in another variable.
rslt = cmath.acos(complexnumb)
# Print the arc cosine value of the given complex number.
print("The given complex number's", complexnumb, " arc cosine value = ")
print(rslt)

Output:

Enter real part and complex part of the complex number = 5 2
The given complex number's (5+2j) arc cosine value = 
(0.38656464251987466-2.37054853731792j)

math.degrees() Method in Python:

The math. degrees() method converts a radian angle to a degree angle.

PI (3.14… ) radians are equal to 180 degrees, so 1 radian equals 57.2957795 degrees.

Syntax:

math.degrees(x)

Parameters

x: This is Required. It is a number. A radian value that can be converted into a degree value.

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

Return Value:

Returns a float value indicating the value in degrees.

Examples:

Example1:

Input:

Given Angle = 7.5

Output:

The given angle{ 7.5 } in degrees =  429.7183463481174

Example2:

Input:

Given Angle = 14

Output:

The given angle{ 14 } in degrees =  802.1409131831525

math.degrees() 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 math module using the import keyword.
• Give the number (angle) as static input and store it in a variable.
• Pass the given angle as an argument to the math.degrees() function that converts the given radian angle to a degree angle.
• Store it in another variable.
• Print the given angle in degrees.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number(angle) as static input and store it in a variable.
gvn_angl = 7.5
# Pass the given angle as an argument to the math.degrees() function that
# converts the given radian angle to a degree angle.
# Store it in another variable.
degre_angl = math.degrees(gvn_angl)
# Print the given angle in degrees.
print("The given angle{", gvn_angl, "} in degrees = ", degre_angl)

Output:

The given angle{ 7.5 } in degrees =  429.7183463481174

Similarly, try for other numbers.

import math
gvn_angl = 4
degre_angl = math.degrees(gvn_angl)
print("The given angle{", gvn_angl, "} in degrees = ", degre_angl)

Output:

The given angle{ 4 } in degrees =  229.1831180523293

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

Approach:

• Import math module using the import keyword.
• Give the number (angle) as user input using the float(input()) function and store it in a variable.
• Pass the given angle as an argument to the math.degrees() function that converts the given radian angle to a degree angle.
• Store it in another variable.
• Print the given angle in degrees.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number(angle) as user input using the float(input()) function 
# and store it in a variable.
gvn_angl =  float(input("Enter some random number = "))
# Pass the given angle as an argument to the math.degrees() function that
# converts the given radian angle to a degree angle.
# Store it in another variable.
degre_angl = math.degrees(gvn_angl)
# Print the given angle in degrees.
print("The given angle{", gvn_angl, "} in degrees = ", degre_angl)

Output:

Enter some random number = -10.5
The given angle{ -10.5 } in degrees = -601.6056848873644

math.erfc() Method in Python:

The math.erfc() method returns a number’s complementary error function.

This method accepts values between – inf and + inf and returns between 0 and 2.

Syntax:

math.erfc(x)

Parameters

x: This is Required. It is a number used to calculate the complementary error function of

Return Value:

Returns a float value that represents a number’s complementary error function.

Examples:

Example1:

Input:

Given Number = 0.35

Output:

The given number's { 0.35 } complementary error function =  0.6206179464376897

Example2:

Input:

Given Number = -5.6

Output:

The given number's { -5.6 } complementary error function =  1.9999999999999976

math.erfc() 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 math module using the import keyword.
• Give the number as static input and store it in a variable.
• Pass the given number as an argument to the math.erfc() function to get the given number’s complementary error function.
• Store it in another variable.
• Print the complementary error function of the given number.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number as static input and store it in a variable.
gvn_numb = 0.35
# Pass the given number as an argument to the math.erfc() function to get
# the given number's complementary error function.
# Store it in another variable.
rslt = math.erfc(gvn_numb)
# Print the complementary error function of the given number.
print("The given number's {", gvn_numb,
      "} complementary error function = ", rslt)

Output:

The given number's { 0.35 } complementary error function =  0.6206179464376897

Similarly, try for other numbers.

import math
gvn_numb = -1
rslt = math.erfc(gvn_numb)
print("The given number's {", gvn_numb,
      "} complementary error function = ", rslt)

Output:

The given number's { -1 } complementary error function =  1.842700792949715

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

Approach:

• Import math module using the import keyword.
• Give the number as user input using the float(input()) function and store it in a variable.
• Pass the given number as an argument to the math.erfc() function to get the given number’s complementary error function.
• Store it in another variable.
• Print the complementary error function of the given number.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number as user input using the float(input()) function and store it in a variable.
gvn_numb = float(input("Enter some random number = "))
# Pass the given number as an argument to the math.erfc() function to get
# the given number's complementary error function.
# Store it in another variable.
rslt = math.erfc(gvn_numb)
# Print the complementary error function of the given number.
print("The given number's {", gvn_numb,
      "} complementary error function = ", rslt)

Output:

Enter some random number = -5.6
The given number's { -5.6 } complementary error function = 1.9999999999999976

math.erf() Method in Python:

The math.erf() method returns a number’s error function.

This method accepts values ranging from – inf to + inf and returns a value ranging from – 1 to + 1.

Syntax:

math.erf(x)

Parameters

x: This is Required. It is a number used to calculate the error function of

Return Value:

Returns a float value that represents a number’s error function.

Examples:

Example1:

Input:

Given Number = 0.5

Output:

The given number's { 0.5 } error function =  0.5204998778130465

Example2:

Input:

Given Number = -4.5

Output:

The given number's { -4.5 } error function =  -0.9999999998033839

math.erf() 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 math module using the import keyword.
• Give the number(angle) as static input and store it in a variable.
• Pass the given  as an argument to the math.erf() function to get the given number’s error function.
• Store it in another variable.
• Print the error function of the given number.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number as static input and store it in a variable.
gvn_numb = 0.5
# Pass the given number as an argument to the math.erf() function to get
# the given number's error function.
# Store it in another variable.
rslt = math.erf(gvn_numb)
# Print the error function of the given number.
print("The given number's {", gvn_numb, "} error function = ", rslt)

Output:

The given number's { 0.5 } error function =  0.5204998778130465

Similarly, try for other numbers.

import math
gvn_numb = -15.2
rslt = math.erf(gvn_numb)
print("The given number's {", gvn_numb, "} error function = ", rslt)

Output:

The given number's { -15.2 } error function =  -1.0

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

Approach:

• Import math module using the import keyword.
• Give the number as user input using the float(input()) function and store it in a variable.
• Pass the given number as an argument to the math.erf() function to get the given number’s error function.
• Store it in another variable.
• Print the error function of the given number.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number as user input using the float(input()) function and store it in a variable.
gvn_numb = float(input("Enter some random number = "))
# Pass the given number as an argument to the math.erf() function to get
# the given number's error function.
# Store it in another variable.
rslt = math.erf(gvn_numb)
# Print the error function of the given number.
print("The given number's {", gvn_numb, "} error function = ", rslt)

Output:

Enter some random number = -4.5
The given number's { -4.5 } error function = -0.9999999998033839

math.comb() Method in Python:

The math. comb() method, also known as combinations, returns the number of ways to choose k unordered outcomes from n possibilities without repetition.

Note: It should be noted that the parameters passed in this method must be positive integers.

Syntax:

math.comb(n, k)

Parameters

n: This is Required. It is the positive integers of items from which to choose

k: This is Required. It is the positive integers of items to choose

Note:

• It should be noted that if the value of k is greater than the value of n, the result will be 0.
• A ValueError occurs if the parameters are negative. A TypeError occurs if the parameters are not integers.

Return Value:

Returns an integer value representing the total number of possible combinations.

Examples:

Example1:

Input:

Given n = 5
Given k = 3

Output:

The total number of combinations possible for the given n, k values = 10

Example2:

Input:

Given n = 6
Given k = 4

Output:

The total number of combinations possible for the given n, k values = 15

math.comb() 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 math module using the import keyword.
• Give the number of items from which to choose(n) as static input and store it in a variable.
• Give the number of possibilities to choose(k) as static input and store it in another variable.
• Pass the given n, k values as the arguments to the math.comb() function to get the total number of combinations possible.
• Store it in another variable.
• Print the above result.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number of items from which to choose(n) as static input and
# store it in a variable.
gvn_n_valu = 5
# Give the number of possibilities to choose as static input and
# store it in another variable.
gvn_k_valu = 3
# Pass the given n, k values as the arguments to the math.comb() function to get
# the total number of combinations possible.
# Store it in another variable.
totl_combintns = math.comb(gvn_n_valu, gvn_k_valu)
# Print the above result.
print("The total number of combinations possible for the given n, k values = ", totl_combintns)

Output:

The total number of combinations possible for the given n, k values = 10

Note:

This function works only in latest versions like 3.8

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

Approach:

• Import math module using the import keyword.
• Give the number of items from which to choose(n) as user input using the int(input()) function and store it in a variable.
• Give the number of possibilities to choose(k) as user input using the int(input()) function and store it in another variable.
• Pass the given n, k values as the arguments to the math.comb() function to get the total number of combinations possible.
• Store it in another variable.
• Print the above result.
• The Exit of the Program.

Below is the implementation:

# Import math module using the import keyword
import math
# Give the number of items from which to choose(n) as user input using 
# the int(input()) function and store it in a variable.
gvn_n_valu = int(input("Enter some random number = "))
# Give the number of possibilities to choose(k) as user input using the int(input()) 
# function and store it in another variable.
gvn_k_valu = int(input("Enter some random number = "))
# Pass the given n, k values as the arguments to the math.comb() function to get
# the total number of combinations possible.
# Store it in another variable.
totl_combintns = math.comb(gvn_n_valu, gvn_k_valu)
# Print the above result.
print("The total number of combinations possible for the given n, k values = ", totl_combintns)

Output:

Enter some random number = 6
Enter some random number = 4
The total number of combinations possible for the given n, k values = 15