Mathematical and Statistical Functions on NumPy Arrays

Various mathematical disciplines utilize operations or transformations to analyze patterns and solve problems involving mathematical objects or data. By inputting one or more statements, these operations result in a design based on a particular algorithm or rule. Mathematical functions play a crucial role in mathematics and are employed in numerous scientific and technical fields.

Multidimensional arrays and matrices are given support by NumPy, a library for scientific and mathematical computing in Python. It also has arithmetic operations for efficient array processing and mathematical functions. These functions are provided by the NumPy library for Python. NumPy is an abbreviation for Numerical Python.

NumPy math programs include functions for elementary numbers, trigonometry, logarithms, exponentials, arithmetic calculations, linear algebra, etc. These programs are designed to work easily with NumPy arrays to enable users to perform statistical operations on large data sets efficiently and with optimal performance.

Function	Description
numpy.abs(x)	Compute the absolute value of each element in the array x.
numpy.sqrt(x)	Compute the square root of each element in the array x.
numpy.square(x)	Compute the square of each element in the array x.
numpy.exp(x)	Compute the exponential function (e^x) for each element in the array x.
numpy.log(x)	Compute the natural logarithm (logarithm to base e) of each element in the array x.
numpy.log10(x)	Compute the base-10 logarithm of each element in the array x.
numpy.log2(x)	Compute the base-2 logarithm of each element in the array x.
numpy.sin(x)	Compute the sine of each angle in the array x in radians.
numpy.cos(x)	Compute the cosine of each angle in the array x in radians.
numpy.tan(x)	Compute the tangent of each angle in the array x in radians.
numpy.arcsin(x)	Compute the inverse sine of each element in the array x.
numpy.arccos(x)	Compute the inverse cosine of each element in the array x.
numpy.arctan(x)	Compute the inverse tangent of each element in the array x.
numpy.sinh(x)	Compute the hyperbolic sine of each element in the array x.
numpy.cosh(x)	Compute the hyperbolic cosine of each element in the array x.
numpy.tanh(x)	Compute the hyperbolic tangent of each element in the array x.
numpy.arcsinh(x)	Compute the inverse hyperbolic sine of each element in the array x.
numpy.arccosh(x)	Compute the inverse hyperbolic cosine of each element in the array x.
numpy.arctanh(x)	Compute the inverse hyperbolic tangent of each element in the array x.
numpy.add(x1, x2)	Add the two arrays x1 and x2 element-wise.
numpy.subtract(x1, x2)	Subtract the two arrays x1 and x2 element-wise.
numpy.multiply(x1, x2)	Multiply the two arrays x1 and x2 element-wise.
numpy.divide(x1, x2)	Divide the two arrays x1 and x2 element-wise.
numpy.power(x1, x2)	Raise each element in the array x1 to the power of the corresponding element in the array x2.
numpy.maximum(x1, x2)	Return the element-wise maximum of the two arrays x1 and x2.
numpy.minimum(x1, x2)	Return the element-wise minimum of the two arrays x1 and x2.
numpy.floor(x)	Compute the floor value of each element in the array x. The floor value is the largest integer less than or equal to the given value.
numpy.ceil(x)	Compute the ceiling value of each element in the array x. The ceiling value is the smallest integer greater than or equal to the given value.
numpy.round(x)	Round each element in the array x to the nearest integer.
numpy.isnan(x)	Check if each element in the array x is NaN (Not a Number).
numpy.isinf(x)	Check if each element in the array x is infinity.
numpy.isfinite(x)	Check if each element in the array x is finite (not NaN or infinity).

Example:

import numpy as np

# Sample NumPy array for demonstration
arr = np.array([1, 2, -3, 4, 5])

# Absolute value
abs_result = np.abs(arr)
print("Absolute Value:", abs_result)

# Square root
sqrt_result = np.sqrt(arr)
print("Square Root:", sqrt_result)

# Square
square_result = np.square(arr)
print("Square:", square_result)

# Exponential
exp_result = np.exp(arr)
print("Exponential:", exp_result)

# Natural logarithm
log_result = np.log(arr)
print("Natural Logarithm:", log_result)

# Base-10 logarithm
log10_result = np.log10(arr)
print("Base-10 Logarithm:", log10_result)

# Base-2 logarithm
log2_result = np.log2(arr)
print("Base-2 Logarithm:", log2_result)

# Sine
sin_result = np.sin(arr)
print("Sine:", sin_result)

# Cosine
cos_result = np.cos(arr)
print("Cosine:", cos_result)

# Tangent
tan_result = np.tan(arr)
print("Tangent:", tan_result)

# Inverse sine
arcsin_result = np.arcsin(arr/10)
print("Inverse Sine:", arcsin_result)

# Inverse cosine
arccos_result = np.arccos(arr/10)
print("Inverse Cosine:", arccos_result)

# Inverse tangent
arctan_result = np.arctan(arr/10)
print("Inverse Tangent:", arctan_result)

# Hyperbolic sine
sinh_result = np.sinh(arr)
print("Hyperbolic Sine:", sinh_result)

# Hyperbolic cosine
cosh_result = np.cosh(arr)
print("Hyperbolic Cosine:", cosh_result)

# Hyperbolic tangent
tanh_result = np.tanh(arr)
print("Hyperbolic Tangent:", tanh_result)

# Inverse hyperbolic sine
arcsinh_result = np.arcsinh(arr/10)
print("Inverse Hyperbolic Sine:", arcsinh_result)

# Inverse hyperbolic cosine
arccosh_result = np.arccosh(arr/10)
print("Inverse Hyperbolic Cosine:", arccosh_result)

# Inverse hyperbolic tangent
arctanh_result = np.arctanh(arr/10)
print("Inverse Hyperbolic Tangent:", arctanh_result)

# Addition
x1 = np.array([1, 2, 3])
x2 = np.array([4, 5, 6])
add_result = np.add(x1, x2)
print("Addition:", add_result)

# Subtraction
subtract_result = np.subtract(x1, x2)
print("Subtraction:", subtract_result)

# Multiplication
multiply_result = np.multiply(x1, x2)
print("Multiplication:", multiply_result)

# Division
divide_result = np.divide(x1, x2)
print("Division:", divide_result)

# Power
power_result = np.power(x1, 2)
print("Power:", power_result)

# Maximum
max_result = np.maximum(arr, [2, 3, 4, 1, 6])
print("Maximum:", max_result)

# Minimum
min_result = np.minimum(arr, [2, 3, 4, 1, 6])
print("Minimum:", min_result)

# Floor
floor_result = np.floor(arr/2.5)
print("Floor:", floor_result)

# Ceiling
ceil_result = np.ceil(arr/2.5)
print("Ceiling:", ceil_result)

# Round
round_result = np.round(arr/2.5)
print("Round:", round_result)

# Check for NaN (Not a Number)
arr_with_nan = np.array([1.0, np.nan, 3.0, np.nan, 5.0])
isnan_result = np.isnan(arr_with_nan)
print("Check for NaN:", isnan_result)

# Check for Infinity
arr_with_inf = np.array([1.0, np.inf, 3.0, -np.inf, 5.0])
isinf_result = np.isinf(arr_with_inf)
print("Check for Infinity:", isinf_result)

# Check for Finite (not NaN or Infinity)
isfinite_result = np.isfinite(arr_with_inf)
print("Check for Finite:", isfinite_result)

Output:

Absolute Value: [1 2 3 4 5]
Square Root: [1. 1.41421356 nan 2. 2.23606798]
Square: [ 1 4 9 16 25]
Exponential: [ 2.71828183 7.3890561 0.04978707 54.59815003 148.4131591 ]
Natural Logarithm: [0. 0.69314718 nan 1.38629436 1.60943791]
Base-10 Logarithm: [0. 0.30103 nan 0.60205999 0.69897 ]
Base-2 Logarithm: [0. nan nan 2. 2.32192809]
Sine: [ 0.90929743 0.90929743 -0.14112001 -0.7568025 -0.95892427]
Cosine: [ 0.41614684 -0.41614684 -0.9899925 -0.65364362 0.28366219]
Tangent: [ 2.18503986 -2.18503986 0.14254654 1.15782128 -3.38051501]
Inverse Sine: [ 0.10016742 0.10016742 -0.14159265 -0.14159265 -0.14159265]
Inverse Cosine: [1.47062891 1.47062891 1.71229429 1.71229429 1.71229429]
Inverse Tangent: [0.09966865 0.09966865 0.09966936 0.09966936 0.09966936]
Hyperbolic Sine: [ 1.17520119 3.62686041 -10.01787493 27.2899172 74.20321058]
Hyperbolic Cosine: [ 1.54308063 3.76219569 10.06766199 27.30823284 74.20994852]
Hyperbolic Tangent: [0.76159416 0.91715234 0.9993293 0.99996373 0.99998771]
Inverse Hyperbolic Sine: [ 0.10000333 0.34657359 -0. 1.13532711 2.31243834]
Inverse Hyperbolic Cosine: [1.47221949 1.46312035 nan 1.51102431 1.51742713]
Inverse Hyperbolic Tangent: [0.09966841 0.31968226 nan 1.02486954 2.05223585]
Addition: [5 7 9]
Subtraction: [-3 -3 -3]
Multiplication: [ 4 10 18]
Division: [0.25 0.4 0.5 ]
Power: [1 4 9]
Maximum: [2 3 4 4 6]
Minimum: [ 1 2 -3 1 5]
Floor: [ 0. 0. -2. 1. 2.]
Ceiling: [ 1. 1. -1. 2. 2.]
Round: [ 0. 1. -1. 2. 2.]
Check for NaN: [False True False True False]
Check for Infinity: [False True False True False]
Check for Finite: [ True False True False True]

A Few Statistical Functions on NumPy

Quantifying data characteristics, identifying patterns, making predictions, and testing hypotheses are all tasks that are made possible through the use of statistical functions. These functions are methods utilized to analyze, summarize, and derive insights from data in various scientific and technical fields. Statistical applications play a central role in areas such as data analysis and statistics by allowing for an in-depth analysis of data sets.

In NumPy, one can access arithmetic functions specifically designed for calculating mathematical operations on data that is contained within NumPy arrays. These functions involve diverse calculations, such as the means, medians, standard deviations, variances, percentages, covariances, and other similar numerical measures. Because of its strong optimization and capacity for managing large sets of data with ease, NumPy statistical programming proves to be an essential resource for studies involving data analysis, scientific inquiries, and machine learning.

Function	Description
numpy.mean(x, axis=None)	Compute the mean (average) of array elements along the specified axis.
numpy.median(x, axis=None)	Compute the median (middle value) of array elements along the specified axis.
numpy.var(x, axis=None)	Compute the variance of array elements along the specified axis.
numpy.std(x, axis=None)	Compute the standard deviation of array elements along the specified axis.
numpy.min(x, axis=None)	Find the minimum value in the array along the specified axis.
numpy.max(x, axis=None)	Find the maximum value in the array along the specified axis.
numpy.percentile(x, q, axis=None)	Compute the percentile of the data along thegiven axis.
numpy.histogram(a, bins=10, range=None)	Compute the histogram of a dataset. Returns histogram values and bin edges.
numpy.corrcoef(x, y=None, rowvar=True)	Compute the correlation coefficient between two or more arrays.
numpy.cov(m, y=None, rowvar=True, bias=False)	Estimate a covariance matrix between two or more arrays.
numpy.histogram2d(x, y, bins=10, range=None)	Compute a 2D histogram of two datasets. Returns histogram values and bin edges.

Conclusion:

Within the Python programming environment, NumPy’s mathematical and statistical functions allow for the efficient execution of complex mathematical and statistical operations. These functions are important tools, proving useful in a wide range of tasks including data analysis, scientific investigations, and other mathematical endeavors.

By enhancing Python’s numerical computation capabilities, NumPy makes the language an impressive platform for tackling intricate numerical challenges. To put it simply, NumPy’s functions are indispensable for maximizing Python’s potential. Happy Coding with this guide!