Leveraging Quadratic Polynomials in Python for Advanced Data Analysis

2.1 Design and development environment

In this study, we focused on applying quadratic polynomials in Python for data analysis, highlighting the importance of these mathematical expressions in modeling and interpreting complex datasets using the following key concepts:

A quadratic polynomial is an algebraic equation of the second degree, which includes a term raised to a power of two (squared). The general form of a quadratic polynomial is$y=a{x}^2+\mathit{bx}+c$, where $\left(y\right)$ is the dependent variable; $\left(x\right)$ is the independent variable; and $\left(a\right),\left(b\right),\left(c\right)$ are the coefficients of the polynomial estimated by the regression model. The quadratic term ($a{x}^2)$ allows the model to capture the curvature in the data, which is indicative of acceleration increases or decreases that are common in many natural phenomena.

Some key features of quadratic polynomials are that they have two terms with a variable $\left(x\right)$ - one is $\left(x\right)$ - squared, and the other is $\left(x\right)$ to the first power. The $\left(x^2\right)$ term has a non-zero coefficient $\left(a\right)$. This makes it a quadratic polynomial rather than a linear polynomial. When plotted, quadratic polynomials form a parabolic shape rather than a straight line. The quadratic polynomials have up to two distinct real roots for the equation $x^2+\mathit{bx}+c=0$. These solutions were obtained by factoring or by using a quadratic formula. Examples of quadratic polynomials include the vertex form $y=a{(x-h)}^2+k$, and the standard form $y=a{x}^2+\mathit{bx}+c$. A quadratic polynomial has a squared, linear, and constant term, graphs as a parabola, and two roots at most.

Understanding their structures allows many mathematical and real-world problems to be solved. We provide an example of the Python script below, which employs a quadratic polynomial fitting technique–a method used in regression analysis to model the relationship between a dependent variable and one or more independent variables. In this case, the independent variable is time (represented in months) and the dependent variable is the metric of interest (such as pollution levels and sales figures).

After fitting the quadratic polynomial to the data, the script generated a smooth fitted curve that represented the estimated values of the dependent variable across a range of independent variables. This curve helps to visualize the overall trend and any potential seasonal patterns or anomalies in the dataset.

The coefficient of determination, commonly known as R-squared $\left(R^2\right)$, was then calculated to quantify the goodness of fit of the polynomial model. It is a statistical measure that indicates the proportion of variance in the dependent variable that is predictable from independent variable(s). An $\left(R^2\right)$ value of one (1) indicated a perfect fit, indicating that the model explained all the data variability around its mean. In contrast, an $\left(R^2\right)$ value closer to zero (0) indicates that the model fails to accurately model the data.

For more in-depth information on quadratic polynomial fitting and calculation of the coefficient of determination, the following sources (Norman R. Draper and Harry Smith, 2014; Douglas et al., 2021) provide a comprehensive overview of seminal works on regression analysis and detailed explanations of various regression techniques, including quadratic polynomial fitting and interpretation $\left(R^2\right)$.

Next, we applied quadratic polynomial fitting and R-squared in Python for the data analysis. In this case, the Python script exemplifies the application of regression analysis using the NumPy and Matplotlib libraries to model and visualize trends in time-series data. A core component of this analysis is the fitting of a quadratic polynomial to the data, grounded in the principles of statistical learning.

In Python, this was achieved using the 'Polynomial.fit' method from the NumPy library, which computes the least-squares fit of a polynomial of specified degree to the given data. The snippet calculates the optimal values for coefficients $\left(a\right),\left(b\right),\left(c\right)$ that minimize the sum of the squared differences between the observed values and values predicted by the polynomial, thereby effectively “fitting” the curve to the data, which Python-formatted version of code snippet similar to:

# Fit the quadratic polynomial
coefs = Polynomial.fit(months, values, 2).convert().coef

With the fitted polynomial, our script generates a curve across a continuum of points within the data range, which was visualized using Matplotlib’s plotting function and the Python-formatted version of the code snippet similar to:

# Generate a smooth curve by evaluating the polynomial at many points
x = np.linspace(months.min(), months.max(), 200)
y = coefs[0] + coefs[1] * x + coefs[2] * x**2

# Plot the data and the fitted curve
plt.plot(x, y, color='purple', label='Fitted curve')

The coefficient of determination, $R^2$, was subsequently computed to assess the fit quality. Python was used to compare the variance of the residuals (the differences between the observed and predicted values) with the total variance of the data, and the corresponding code snippet is similar to:

# Calculate R-squared value
residuals = values - coefs[0] + coefs[1] * months + coefs[2] * months**2
ss_res = np.sum(residuals**2)
ss_tot = np.sum((values - np.mean(values))**2)
r_squared = 1 - (ss_res / ss_tot)

An $\left(R^2\right)$ value close to one (1) suggests that the model explains a large portion of the variance in the response variable, indicating a strong fit. Conversely, a value near zero (0) suggests the model does not explain the variance well.

The following sources (VanderPlas, 2016; McKinney, 2017) provide a comprehensive overview of Python’s theoretical background and practical application. These resources offer a deep dive into data analysis using Python, including comprehensive guidance on regression analysis, and robust examples that bridge theory with practice.

2.2 Implementation

This section details the implementation of quadratic polynomial models in Python that are used in various applications, as demonstrated in this study. The core of the implementation involved the use of Python NumPy and Matplotlib libraries for mathematical operations and visualizations. The polynomial model is defined by the equation ${ax}^2+\mathit{bx}+c$, where $\left(a\right),\left(b\right),\left(c\right)$, are the coefficients optimized to fit the data points collected in different studies. The fitting process utilizes the 'Polynomial.fit' method, which employs a least-squares polynomial fit. To ensure robustness and accuracy, the implementation also included calculation of the coefficient of determination $\left(R^2\right)$ using NumPy’s correlation function. This metric helps to assess the polynomial fit to the data, which is essential for the applications discussed, ranging from trend analysis in software usage to predicting the material properties of nanocomposites.

In the next step, we used Python to present an applied exploration of quadratic polynomial fitting and the coefficient of determination (R-squared) within the context of data analysis. The following Python script is a practical implementation tool for researchers and analysts: It begins by prompting the user to describe the dataset, such as a location or a specific environmental metric, such as the PM2.5 air pollution index. This interactivity ensures that the resulting visualization is tailored and informative. The Python-formatted version of the code snippet of this part of our script similar to:

# User inputs for the descriptive elements of the plot
description = input("Enter the location description (e.g., Kyiv, Shcherbakovskaya St.):")
pollution_name = input("Enter the pollution name (e.g., PM2.5):")
y_label = input("Enter the y-axis label (e.g., PM2.5 Index):")

The script reads data from a CSV file using Pandas, a library that excels in data manipulation. The data consists of monthly observations of the chosen metric. You can see this implementation in the Python-formatted version of the code snippet similar to:

# Read data from a CSV file
# Use the direct link to the raw CSV file from the GitHub repository
data = pd.read_csv('https://raw.githubusercontent.com/rsipakov/QuadraticPolynomialsPyDA/main/notebooks/pm_data.csv')
# Or downloading CSV file to the local
# data = pd.read_csv('/path/pm_data.csv') # Update the path to your CSV file
months = data['Month'].to_numpy()
values = data['Values'].to_numpy()

As described above, with the data in hand, the NumPy library’s 'Polynomial.fit' function is employed to fit a quadratic polynomial to these observations. This is an essential step in modeling nonlinear behavior, accommodating potential fluctuations in data that a simple linear model would miss. Subsequently, the script computes the fitted values and leverages them to calculate the R-squared values. This statistic conveys the proportion of variance in the dependent variable explained by the independent variable. The Matplotlib library was then used to graphically represent the data along with the fitted curve, visually comparing the actual data points with those of the predictive model.

After developing the script using the quadratic polynomial models described above, the complete Python code was hosted on GitHub (Sipakov, 2024), enabling replication and further exploration of the findings. To facilitate ease of use and accessibility, the code was made available through MyBinder.org (https://mybinder.org/v2/gh/rsipakov/QuadraticPolynomialsPyDA/main), allowing it to operate in a live environment without the need for local setup. This implementation ensures that other researchers can directly interact with the codebase, providing a dynamic way to validate and extend research findings.

2.3 Operation

The software tool based on quadratic polynomial models requires the following system setup and workflow: Operating System—Windows, macOS, or Linux; Python Version—Python 3.6 or later; dependencies —NumPy, Matplotlib (the latest versions are recommended), memory, at least 4GB of RAM; Processor, minimum 1GHz processor, or faster. The software is accessible through MyBinder.org, requires no local installation, and is fully configured to run in any web browser, ensuring its ease of use and reproducibility.

2.4 Installation process

To begin the installation process, it is imperative to ensure that Python is installed in the operating system. If Python is not present, it can be acquired from Python’s official website python.org. After successful installation of Python, the next step involved installing the necessary libraries. This can be achieved through the Python Package Index (PyPI) using a PIP installer. Execute the following command in the command prompt or terminal to install the required libraries: 'pip install numpy matplotlib'. This command installs NumPy, which is essential for numerical computations, and Matplotlib, a library for plotting graphs and effectively visualizing the data.