pybatts-mathematics 1.0.5__tar.gz

pybatts_mathematics-1.0.5/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Frank Mobley, Gregory Bowers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pybatts_mathematics-1.0.5/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pybatts-mathematics
+Version: 1.0.5
+Summary: Python representations of mathematical functions and methods that are required for acoustic processing.
+Author-Email: "Dr. Frank Mobley" <frank.mobley.1@afrl.af.mil>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.21.5
+Requires-Dist: pymeasurable_objects>1.0.0
+Description-Content-Type: text/markdown
+
+Create README.md for Mathematics

pybatts_mathematics-1.0.5/README.md

@@ -0,0 +1 @@
+Create README.md for Mathematics

pybatts_mathematics-1.0.5/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "pybatts-mathematics"
+version = "1.0.5"
+description = "Python representations of mathematical functions and methods that are required for acoustic processing."
+authors = [
+    { name = "Dr. Frank Mobley", email = "frank.mobley.1@afrl.af.mil" },
+]
+dependencies = [
+    "numpy>=1.21.5",
+    "pymeasurable_objects>1.0.0",
+]
+requires-python = ">=3.9"
+readme = "README.md"
+keywords = []
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+package-dir = "src"
+
+[tool.pdm.build]
+excludes = [
+    "tests",
+]

pybatts_mathematics-1.0.5/src/pymathematics/curve_fit/nonlinear_curve_fit.py

@@ -0,0 +1,285 @@
+import numpy as np
+from scipy.special import erf, erfinv
+
+"""
+These classes and functions provide the ability to fit a variety of functions to the provided data. The ErfFitParameters
+also provides the ability to invert the function and determine the x-value that produces a specific y-value. These 
+classes map to the C# code, though the SciPy.optimize.curve_fit function can also produce the coefficients, these 
+functions reproduce the coefficients in a manual way for the three functions implemented for the auditory detection.
+"""
+
+
+class ErfFitParameters:
+    def __init__(self, a: float = 0, b: float = 0, c: float = 0, d: float = 0, n: int = 0, sigma: float = 0):
+        self._amplitude = a
+        self._horizontal_offset = b
+        self._vertical_offset = d
+        self._scale = c
+        self._iteration_count = n
+        self._uncertainty = sigma
+
+    @property
+    def amplitude(self):
+        return self._amplitude
+
+    @amplitude.setter
+    def amplitude(self, value):
+        self._amplitude = value
+
+    @property
+    def horizontal_offset(self):
+        return self._horizontal_offset
+
+    @horizontal_offset.setter
+    def horizontal_offset(self, value):
+        self._horizontal_offset = value
+
+    @property
+    def vertical_offset(self):
+        return self._vertical_offset
+
+    @vertical_offset.setter
+    def vertical_offset(self, value):
+        self._vertical_offset = value
+
+    @property
+    def scale(self):
+        return self._scale
+
+    @scale.setter
+    def scale(self, value):
+        self._scale = value
+
+    @property
+    def iteration_count(self):
+        return self._iteration_count
+
+    @iteration_count.setter
+    def iteration_count(self, value):
+        self._iteration_count = value
+
+    @property
+    def uncertainty(self):
+        return self._uncertainty
+
+    @uncertainty.setter
+    def uncertainty(self, value):
+        self._uncertainty = value
+
+    def value(self, x):
+        return self.amplitude * erf((x-self.horizontal_offset) / self.scale) + self.vertical_offset
+
+    def value_inverted(self, y):
+        return self.horizontal_offset + self.scale * erfinv((y-self.vertical_offset)/self.amplitude)
+
+
+def erf_fit(x, y, init_amp=1, init_vertical_offset=0, init_horizontal_offset=0, scale=2.5, max_iterations=100,
+            error_tolerance=1e-8):
+    """
+    Determine a least squares regression curve fit to the input arrays through an error function of the form:
+    y = a * erf((x-b)/c)+d
+
+    x : double, array-like
+        the independent variable list
+    y : double, array-like
+        the dependent variable list
+    init_amp : double
+        the initial guess for the amplitude of the error function (a)
+    init_vertical_offset : double
+        the initial guess for the vertical offset of the error function (d)
+    init_horizontal_offset : double
+        the initial guess for the horizontal offset of the error function (b)
+    scale : double
+        the initial guess of the slope of scale of the error function (b)
+    max_iterations : double or int
+        the maximum number of iterations for the looping before the algorithm terminates
+    error_tolerance : double
+        the required minimum error prior to the termination of the algorithm
+
+    returns : tuple
+        the coefficients (a, b, c, d), iteration count, and error
+    """
+
+    if isinstance(x, list):
+        x = np.array(x)
+    if isinstance(y, list):
+        y = np.array(y)
+
+    #   Set the initial conditions for the least squares regression
+    current_error = 1000
+    n = 0
+    a = init_amp
+    b = init_horizontal_offset
+    c = scale
+    d = init_vertical_offset
+
+    #   A collection of adjustments to be made to the coefficients.  This is the same size as the number of unknown
+    #   coefficients.
+    gradient = np.zeros(shape=(len(x), 4))
+
+    #   The difference in actual function using the current coefficients and the curve fit
+    residuals = [0 for num in x]
+
+    #   The current evaluation of the error function at the given independent values using the previous coefficients
+    current_approximation = [0 for num in x]
+
+    #   Loop until we either meet the maximum number of iterations or the error between the current and previous
+    #   approximations is less than the error_tolerance
+    while n < max_iterations and current_error > error_tolerance:
+
+        #   Fill the gradient and current approximation values
+        gradient[:, 0] = erf((x - b) / c)
+        gradient[:, 1] = -(2 * a * np.exp(-(x - b)**2.0 / c / c) / np.sqrt(np.pi) / c)
+        gradient[:, 2] = -(2 * a * (x - b) * np.exp(-(x - b)**2.0 / c / c)) / np.sqrt(np.pi) / c / c
+        gradient[:, 3] = 1.0
+        current_approximation = a * erf((x - b) / c) + d
+        residuals = y - current_approximation
+
+        # These may need to be dot operators, not multiplication. Is it point wise?
+        grad_mul = gradient.transpose().dot(gradient)
+        inverse = np.linalg.inv(grad_mul)
+        pseudo_inverse = inverse.dot(gradient.transpose())
+        delta_coefficients = pseudo_inverse.dot(residuals)
+        current_error = abs(max(delta_coefficients))
+
+        #   Adjust the coefficients
+        a += delta_coefficients[0]
+        b += delta_coefficients[1]
+        c += delta_coefficients[2]
+        d += delta_coefficients[3]
+
+        #   Update the iteration count
+        n += 1
+
+    return ErfFitParameters(a, b, c, d, n - 1, current_error)
+
+
+def gaussian_fit(x, y, initial_variance=0.1, initial_center=1, initial_amp=100, error_tolerance=1e-6,
+                    max_iterations=100):
+    """
+    Using the Newton approximation start with the initial guesses for the output parameters and use least-squares
+    regression to fit the data provided in the input arrays with a normal distribution (Guassian function): i.e.
+    y = a * np.exp(-((x-b)**2)/c)
+
+    x : double, array-like
+        The collection of independent variables values
+    y : double, array-like
+        The collection of dependent variable values
+    initial_variance : double, default value=0.1
+        The initial width of the normal distribution
+    initial_center : double, default value=1
+        The initial location of the center of the normal distribution
+    initial_amp : double, default value=100
+        The initial amplitude of the normal distribution
+    error_tolerance : double, default value=0.75
+        The minimum different between the variables that results in the termination of the fitting
+    max_iterations : double, default value=100
+        The maximum number of iterations prior to the termination of the fitting
+
+    returns a, b, c, iteration count, error
+    """
+    import sklearn.metrics as metrics
+
+    #   Ensure that we are using arrays rather than lists
+    if isinstance(x, list):
+        x = np.array(x)
+    if isinstance(y, list):
+        y = np.array(y)
+
+    #   Initialize the variables
+    current_error = 1000
+    iteration_count = 0
+    a = initial_amp
+    b = initial_center
+    c = initial_variance
+
+    #   Setup the arrays and matrices that will hold the data
+    gradient = np.zeros(shape=(len(x), 3))
+
+    #   Loop until either the error or iteration termination condition is reached
+    while current_error > error_tolerance and iteration_count < max_iterations:
+
+        #   Loop through the elements of the input array and build up the objects
+        gradient[:, 0] = np.exp(-(x - b)**2.0 / c)
+        gradient[:, 1] = (2 * a * (x - b) / c) * np.exp(-(b - x)**2 / c)
+        gradient[:, 2] = ((a * (b - x)**2.0) / (c**2.0)) * np.exp(-(b - x)**2.0 / c)
+        current_y = a * np.exp(-(x - b)**2.0 / c)
+        residuals = y - current_y
+
+        #   Determine the adjustments to the coefficients
+        pseudo_inverse = np.linalg.pinv(gradient)
+        delta_coefficients = pseudo_inverse.dot(residuals)
+        current_error = np.mean(abs(residuals))
+        a += delta_coefficients[0]
+        b += delta_coefficients[1]
+        c += delta_coefficients[2]
+
+        #   Increment the iteration count
+        iteration_count += 1
+
+    return a, b, c, (iteration_count - 1), current_error
+
+
+def gaussian_fit_with_floor(x, y, initial_variance=0.1, initial_center=1, initial_amp=100, initial_floor=10,
+                            error_tolerance=1e-6, max_iterations=100):
+    """
+    Using the Newton approximation start with the initial guesses for the output parameters and use least-squares
+    regression to fit the data provided in the input arrays with a normal distribution (Guassian function): i.e.
+    y = a * np.exp(-((x-b)**2)/c) + d
+
+    x : double, array-like
+        The collection of independent variables values
+    y : double, array-like
+        The collection of dependent variable values
+    initial_variance : double, default value=0.1
+        The initial width of the normal distribution
+    initial_center : double, default value=1
+        The initial location of the center of the normal distribution
+    initial_amp : double, default value=100
+        The initial amplitude of the normal distribution
+    initial_floor : double, default value=10
+        The initial floor of the normal distribution
+    error_tolerance : double, default value=0.75
+        The minimum different between the variables that results in the termination of the fitting
+    max_iterations : double, default value=100
+        The maximum number of iterations prior to the termination of the fitting
+
+    returns a, b, c, d, iteration count, error
+    """
+
+    if isinstance(x, list):
+        x = np.array(x)
+    if isinstance(y, list):
+        y = np.array(y)
+
+    #   Setup the present variables
+    current_error = 1000
+    iteration_count = 0
+    a = initial_amp
+    b = initial_center
+    c = initial_variance
+    d = initial_floor
+
+    #   Create the objects that will hold the information regarding the values during the regression
+    gradient = np.zeros(shape=(len(x), 4))
+
+    #   Loop until the terminating conditions are reached
+    while current_error > error_tolerance and iteration_count < max_iterations:
+        gradient[:, 0] = np.exp(-(x - b)**2.0 / c)
+        gradient[:, 1] = (2 * a * (x - b) / c) * np.exp(-(b - x)**2.0 / c)
+        gradient[:, 2] = ((a * (b - x)**2.0) / (c**2.0)) * np.exp(-(b - x)**2.0 / c)
+        gradient[:, 3] = 1.0
+
+        current_y = a * np.exp(-(x - b)**2.0 / c) + d
+        residuals = y - current_y
+
+        #   Invert the matrices for the determination of the adjustments for the coefficients.
+        pseudo_inverse = np.linalg.inv(gradient.transpose().dot(gradient)).dot(gradient.transpose())
+        delta_coefficients = pseudo_inverse.dot(residuals)
+        current_error = np.mean(abs(residuals))
+        a += delta_coefficients[0]
+        b += delta_coefficients[1]
+        c += delta_coefficients[2]
+        d += delta_coefficients[3]
+
+    return a, b, c, d, (iteration_count - 1), current_error

pybatts_mathematics-1.0.5/src/pymathematics/curve_fit/polyfit.py

@@ -0,0 +1,88 @@
+import numpy as np
+from numpy import zeros, linalg, asarray, array
+
+"""
+The polyfit/polyval function implement a solution that relies on the singular value decomposition on the coefficient
+matrix, which have caused issues on certain matricies that are close to a singular value (determinant close to zero).
+These functions implement the least-squares regression to construct the coefficient matrix and determine the 
+coefficients in a more direct and manual way.
+"""
+
+
+def regression(x, y, order):
+    """
+    Determine the polynomial regression for the set of data in x and y
+
+    x : double, array-like
+        the independent variables
+    y : double, array-like
+        the dependent variables
+    order : int
+        the maximum order of the polynomial
+
+    returns : double, array-like
+        The list of coefficients ordered from the smallest to largest magnitude of the polynomial coefficients, i.e.
+        the c[0] coefficients corresponds with x**0 term.
+    """
+
+    z = zeros(shape=(order + 1, order + 1))
+
+    #   Build the matrix that forms the L.H.S. of the matrix inversion equation
+
+    for row in range(order + 1):
+        for col in range(order + 1):
+            for index in range(len(x)):
+                val = x[index] ** (row + col)
+                z[row, col] += val
+
+    #   Form the vector that is the R.H.S. of the matrix inversion equation
+
+    a = zeros((order + 1,))
+
+    for row in range(order + 1):
+        for index in range(len(y)):
+            val = y[index] * x[index] ** row
+            a[row] += val
+
+    #   Compute the coefficients as the inversion of Z and multiplication with a
+
+    c = linalg.inv(z).dot(a)
+
+    return c
+
+
+def polynomial_value(c, x):
+    """
+    Determine the value of hte polynomial curve fit based on the coefficients that were returned with the regression
+    function
+
+    c : double, array-like
+        The collection of coefficients that were determined with regression
+    x : double, possible array-like
+
+    returns : double, possible array-like
+        the values of the polynomial at the provided x values
+    """
+    c = asarray(c)
+    c = c.flatten()
+
+    if isinstance(x, float):
+        y = 0
+
+        for i in range(len(c)):
+            y += c[i] * x ** i
+
+        return y
+
+    if isinstance(x, list):
+        x = array(x)
+
+    if isinstance(x, np.ndarray) or isinstance(x, list):
+        y = zeros(x.shape)
+
+        for j in range(len(x)):
+
+            for i in range(len(c)):
+                y[j] += c[i] * x[j] ** i
+
+        return y

pybatts_mathematics-1.0.5/src/pymathematics/interpolation.py

@@ -0,0 +1,326 @@
+from datetime import datetime
+from pymeasurable_objects.measurables import Measurable
+import numpy as np
+import pandas as pd
+from scipy import ndimage as nd
+
+"""
+This is a simple class to determine the interpolated values for a set of input values
+
+@author: Dr. Frank Mobley, Gregory Bowers
+"""
+
+
+def linear(
+        x1: float | int | datetime | Measurable = None, x2: float | int | datetime | Measurable = None,
+        y1: float | int | datetime | Measurable = None, y2: float | int | datetime | Measurable = None,
+        xt: float | int | datetime | Measurable = None
+        ) -> float | int | datetime | Measurable:
+    """
+    This function will compute the slope and intercept for a line between the first and second elements of the
+    arguments, then return the value that is linearly at the desired point.
+
+    x1 : double, int, datetime
+        the independent variable for the first point of the data to be interpolated
+    x2 : double, int, datetime
+        the independent variable for the second point of the data to be interpolated
+    y1 : double, int, measurable
+        the dependent variable for the first point of the data to be interpolated
+    y2 : double, int, measurable
+        the dependent variable for the second point of the data to be interpolated
+    xt : double, int, datetime
+        the independent variable value to the evaluated
+
+    returns : double, int, measurable
+        Returns the linearly interpolated value at the xt argument.  If xt is a number, this function returns the
+        same type.  If xt is a datetime, the expectation is that y1, and y2 are measurable and the interpolated
+        measurable is returned.
+    """
+    if all([isinstance(x, datetime) for x in [x1, x2, xt]]):
+        x1 = (datetime.combine(datetime.min, x1.time()) - datetime.min).total_seconds()
+        x2 = (datetime.combine(datetime.min, x2.time()) - datetime.min).total_seconds()
+        xt = (datetime.combine(datetime.min, xt.time()) - datetime.min).total_seconds()
+
+    if isinstance(y1, Measurable) and isinstance(y2, Measurable):
+        y1 = y1.underlying_value()
+        y2 = y2.underlying_value()
+
+    m = (y2 - y1) / (x2 - x1)
+    b = y1 - m * x1
+
+    return m * xt + b
+
+    """
+    def bilinear(self, corner_sequence: Sequence = list(), coor_interest: Sequence = list()) -> float | int:
+        /// <summary>
+        /// Determine the value using a bilinear interpolation.  This is accomplished with the
+        /// following geometric considerations:
+        /// (x2,y2,z2) o----------------o(x3,y3,z3)
+        ///            |                |
+        ///            |                |
+        ///            |     o(x,y)     |
+        ///            |                |
+        ///            |                |
+        /// (x1,y1,z1) o----------------o(x4,y4,z4)
+        ///
+        /// To determine the value at (x,y) we first interpolate between (x1,y1) and (x2,y2) and
+        /// determine the value on that edge at y.  This is repeated for the (x3,y3) and (x4,y4)
+        /// edge.  Then the value for each edge is interpolated to determine the value for the
+        /// horizontal interpolation.
+        /// </summary>
+        /// <returns></returns>
+        if not all([isinstance(x, Sequence) for x in [corner_sequence, coor_interest]]):
+            raise TypeError("Incorrect argument type. bilinear takes python sequences as arguments.")
+        if not all([isinstance(x, {float, int})] for x in corner_sequence) and all(
+                isinstance(x, (float, int)) for x in coor_interest):
+            raise TypeError("Incorrect argument type. Passed sequences should only contain float or int data types.")
+        if not all([len(x) == 3] for x in corner_sequence):
+            raise ValueError("Incorrect argument lengths for required corner 3-dimensional coordinates. "
+                             "Bilinear interpolation requires 3-dimensional coordinates.")
+        coor_1, coor_2, coor_3, coor_4 = corner_sequence
+        x, y = coor_interest
+        y1_to_4 = self.linear(coor_1[0], coor_4[0], coor_1[2], coor_4[2], x)
+        y2_to_3 = self.linear(coor_2[0], coor_3[0], coor_2[2], coor_3[2], x)
+        return self.linear(coor_2[1], coor_1[1], y2_to_3, y1_to_4, y)
+        """
+
+"""
+Conducting acoustic measurements over large areas often requires significant numbers of conditions, or measurement 
+sites. In effort to understand the acoustic area where airmen operate during routine maintenance, a measurement was 
+conducted on a single engine fighter aircraft. Due to the complexity of the measurement array, fewer sites were used 
+than required to completely characterize this region. In order to complete the analysis, a series of Python scripts 
+were developed to use nearest-neighbor interpolation of the sparse matrix, which was subsequently smoothed using a 
+bi-linear interpolation. 
+
+This collection of functions grew out of this research. If you intend to use this work, please reference: 
+Mobley, Frank S., Alan T. Wall, and Stephen C. Campbell. "Translating jet noise measurements to near-field level 
+maps with nearest neighbor bilinear smoothing interpolation." The Journal of the Acoustical Society of America 150.2 
+(2021): 687-693.
+"""
+
+
+def bi_linear_smoothing(starting_mesh, measured_data, measured_x_index, measured_y_index,
+                        tolerance: float = 1e-4, maximum_iterations: int = 1000,
+                        verbose_info: bool = True):
+    """
+    This computes the bilinear average of the mesh until the RMSE reaches the
+    tolerance passed as an argument.
+
+    Parameters
+    ----------
+    :param verbose_info: bool
+        Flag detailing whether information is printed to the Python console during execution of the algorithm
+    :param starting_mesh : double array-like
+        the starting dense matrix determined from the nearest neighbor
+    :param tolerance : double
+        The minimum error level to finish the averaging
+    :param measured_data : DataFrame
+        A data frame with the X, Y, La values for each of the measured points
+    :param measured_x_index : array-like double
+        The X indices for where to insert the measured levels
+    :param measured_y_index : array-like double
+        The X indices for where to insert the measured levels
+    :param maximum_iterations: int
+        The maximum number of iterations that we want to iterate through before returning an error.
+
+    Returns
+    -------
+    The dense matrix smoothed
+
+
+    """
+
+    zz = starting_mesh.copy()
+
+    #   Perform the iterative smoothing
+    rmse = 100
+    i = 0
+
+    zz_last = zz.copy()
+
+    while rmse > tolerance and i < maximum_iterations:
+        #   Replace the data with the measured information
+        zz[measured_y_index, measured_x_index] = measured_data
+
+        if verbose_info:
+            print('Starting iteration {}'.format(i + 1))
+
+        #   Loop through the array and create an approximate of the interpolation
+        if verbose_info:
+            print('iterating over the surface')
+
+        npts = 3
+        for xidx in range(zz.shape[0]):
+            for yidx in range(zz.shape[1]):
+
+                #   Add the central point
+                nn_mean = 0
+
+                #   Set the count for the points in the average
+                n = 0
+
+                #   Determine the span in each direction
+                span = int((npts - 1) / 2)
+
+                #   Try to determine the value for the lower index of the y-axis
+                ylo = yidx - span
+                if ylo < 0:
+                    ylo = 0
+
+                yhi = yidx + span
+                if yhi >= zz.shape[1]:
+                    yhi = zz.shape[1] - 1
+
+                #   Now the x-axis
+                xlo = xidx - span
+                if xlo < 0:
+                    xlo = 0
+                xhi = xidx + span
+                if xhi >= zz.shape[0]:
+                    xhi = zz.shape[0] - 1
+
+                for p in range(ylo, yhi + 1):
+                    for q in range(xlo, xhi + 1):
+                        nn_mean += zz[q, p]
+                        n += 1
+
+                zz[xidx, yidx] = nn_mean / n
+
+        #   Compute the error between this and the previous surface
+        rmse = np.std(np.std(zz - zz_last, axis=1))
+
+        if verbose_info:
+            print('RMSE:{:.5f}\n***************************'.format(rmse))
+
+        #   Copy the current surface to the previous surface
+        zz_last = zz.copy()
+        i += 1
+    return zz, i, rmse
+
+
+def nearest_neighbor_dense_sampling(true_data: pd.DataFrame, out_x: np.ndarray, out_y: np.ndarray,
+                                    smoothing_error_tolerance: float = 1e-5, iteration_max: int = 1000,
+                                    verbose_info: bool = True):
+    """
+    From research in the acoustic measurement of near-field noise around fifth generation fighter aircraft (see
+    Mobley, Frank S., Alan T. Wall, and Stephen C. Campbell. Translating jet noise measurements to near-field level maps
+    with nearest neighbor bilinear smoothing interpolation. The Journal of the Acoustical Society of America 150.2
+    (2021): 687-693) this code was created. Initially it was focused on the methods and data storage for the research
+    within the paper. However, this version has been made more generic to assist in using this interpolation method
+    across a wider range of data.
+
+    To use this you must supply a DataFrame that contains the sparse matrix in column representation. You must have a
+    column called 'x', 'y', and 'z'. These will be used to determine the 'measured', 'known', or 'true' points on the
+    sparse surface. This object is the 'true_data' argument of the function.
+
+    Parameters
+    ----------
+    :param verbose_info: bool
+        A flag to determine whether debug information is shown in the Python console
+    :param true_data : Pandas.DataFrame
+        This is the sparse data that we want to interpolate. It must contain a column for the 'x', 'y', and 'z' data
+        elements. These will be used in the replacement step.
+    :param out_x : Numpy.ndarray
+        This is the desired output values for the x-axis of the dense matrix surface
+    :param out_y : Numpy.ndarray
+        This is the desired output values for the y-axis of the dense matrix surface
+    :param smoothing_error_tolerance : double
+        The error tolerance that terminate the smoothing
+    :param iteration_max : int
+        The maximum number of iterations that are required for the construction of the dense mesh
+
+    Returns
+    -------
+    tuple containing the dense matrix x, y, smoothed z, and rough z values
+
+    """
+
+    #   Run checks on the input surface
+    if not _check_true_data_arguments(true_data):
+        raise ValueError("The input true_data is not properly formed")
+
+    #   Build the mesh of output Cartesian Locations
+    xx, yy = np.meshgrid(out_x, out_y)
+    zz = np.ones(xx.shape) * -999
+
+    #   Find the index within the desired mesh where these data fall
+    m_x_idx, m_y_idx = _find_true_data_indices(out_x, out_y, true_data)
+
+    #   Update the values of the surface with the information from the true data
+    zz[m_y_idx, m_x_idx] = true_data['z']
+
+    #   Perform the nearest neighbor approximation
+    invalid = np.isin(zz, -999)
+    ind = nd.distance_transform_edt(invalid, return_distances=False, return_indices=True)
+
+    #   Assign the value based on the selected indices
+    zz = zz[tuple(ind)]
+
+    #   Smooth the coarse surface
+    smoothed_zz, iterations, error = bi_linear_smoothing(starting_mesh=zz,
+                                                         measured_x_index=m_x_idx,
+                                                         measured_y_index=m_y_idx,
+                                                         measured_data=true_data['z'],
+                                                         tolerance=smoothing_error_tolerance,
+                                                         maximum_iterations=iteration_max,
+                                                         verbose_info=verbose_info)
+
+    return xx, yy, smoothed_zz, zz
+
+
+def _check_true_data_arguments(x):
+    """
+    This function checks the input argument of the interpolation to ensure that it possesses all the correct
+    information prior to running the analysis.
+
+    :param x: Pandas.DataFrame
+        The collection of input data that we want to ensure is the correct format prior to creating the interpolation
+        grid.
+    :return:
+        True if the DataFrame is correctly formed, otherwise it raises ValueError exceptions.
+    """
+
+    if not isinstance(x, pd.DataFrame):
+        raise ValueError("The true data input must be a Pandas.DataFrame")
+
+    if 'x' not in x.columns.values or 'y' not in x.columns.values or 'z' not in x.columns.values:
+        raise ValueError("The DataFrame must contain a column for each of the standard Cartesian coordinates")
+
+    return True
+
+
+def _find_true_data_indices(x, y, true_data):
+    """
+    Part of this algorithm determines where in the dense grid the true/measured data exists. Then it will replace the
+    current value in the matrix with the true data. In this manner was can constrain some of the simplification of
+    the system to ensure that we are close to the points that we know.
+
+    This function will determine where in the dense matrix the true data will exist, insert the true data into the
+    list, and return the indices and the new surface.
+    :param x: Numpy.ndarray
+        This is the single dimensioned array of the values of the function along the x-direction
+    :param y: Numpy.ndarray
+        This is the single dimensioned array of the values of the function along the y-direction
+    :param true_data: Pandas.DataFrame
+        The collection of true data. This must contain columns for the 'x', 'y', and 'z' elements of the sparse data
+    :return: tuple
+        The first element of the tuple is the x-direction indices of the placement for the true data, and the second
+        is the y-direction indices.
+    """
+
+    measured_x_index = np.zeros(shape=(true_data.shape[0],), dtype=int)
+    measured_y_index = np.zeros(shape=(true_data.shape[0],), dtype=int)
+
+    x_idx = np.where(true_data.columns.values == 'x')[0][0]
+    y_idx = np.where(true_data.columns.values == 'y')[0][0]
+
+    #   Find the indices for the measured data
+    for i in range(true_data.shape[0]):
+        try:
+            measured_x_index[i] = np.where(x - true_data.iloc[i, x_idx] >= 0)[0][0]
+            measured_y_index[i] = np.where(y - true_data.iloc[i, y_idx] >= 0)[0][0]
+
+        except IndexError:
+            print('Error at the {}th element'.format(i))
+
+    return measured_x_index, measured_y_index

pybatts_mathematics-1.0.5/src/pymathematics/matrix_rotations.py

@@ -0,0 +1,76 @@
+from numpy import array
+from pymeasurable_objects.measurables import InvalidUnitOfMeasureException, Angle
+
+"""
+A collection of functions that provide the matrices for specific canonical rotations about Cartesian coordinate
+direction vectors.
+"""
+
+
+def geo_to_body():
+    """
+    This is the matrix that converts the coordinate system from a geographic reference to the center of mass of the
+    vehicle.  This amounts to a rz(numpy.pi/2).dot(rz(numpy.pi)).
+    """
+    return array([
+        [0, 1, 0],
+        [1, 0, 0],
+        [0, 0, -1]
+    ])
+
+
+def rx(x):
+    """
+    Canonical rotation about the Cartesian X-axis
+
+    x : Angle
+        The rotation that must be executed
+
+    returns : double, array-like
+        the 3x3 matrix that represents the rotation around the x-axis
+    """
+    if isinstance(x, Angle):
+        return array([[1, 0, 0],
+                      [0, x.cos(), x.sin()],
+                      [0, -x.sin(), x.cos()]])
+    else:
+        raise InvalidUnitOfMeasureException
+
+
+def ry(y):
+    """
+    Canonical rotation about the Cartesian y-axis
+
+    y : Angle
+        The rotation that must be executed
+
+    returns : double, array-like
+        the 3x3 matrix that represents the rotation around the y-axis
+    """
+    if isinstance(y, Angle):
+        return array([[y.cos(), 0, -y.sin()],
+                      [0, 1, 0],
+                      [y.sin(), 0, y.cos()]])
+
+    else:
+        raise InvalidUnitOfMeasureException
+
+
+def rz(z):
+    """
+    Canonical rotation about the Cartesian z-axis
+
+    z : Angle
+        The rotation that must be executed
+
+    returns : double, array-like
+        the 3x3 matrix that represents the rotation around the z-axis
+    """
+
+    if isinstance(z, Angle):
+        return array([[z.cos(), z.sin(), 0],
+                      [-z.sin(), z.cos(), 0],
+                      [0, 0, 1]])
+
+    else:
+        raise InvalidUnitOfMeasureException

pybatts_mathematics-1.0.5/src/pymathematics/special_functions.py

@@ -0,0 +1,108 @@
+def erfc(a):
+    """
+    The complex error function that is required for the determination of the excess ground attenuation.
+
+    a : complex
+        the independent variable to determine the complex error function value.
+
+    returns : complex
+        the value of the complex error function at a
+
+    Remarks:
+    2022-11-29 - FSM - Running the F-35 A data suggests that there may be instances where the calculation of P2 and
+    Q2 may result in Infinite/NaN values
+    """
+    from numpy import sin, cos, pi, exp, isinf
+
+    if isinstance(a, complex):
+        x = a.real
+        y = a.imag
+        rho2 = a ** 2
+        if x > 6.0 or y > 6.0:
+            return complex(0, 1) * a * (0.5124242 / (rho2 - 0.2752551) + 0.05176536 / (rho2 - 2.724745))
+        else:
+            if x > 3.9 or y > 3.0:
+                w = 0.4613135 / (rho2 - 0.1901635)
+                w += (0.09999216 / (rho2 - 1.7844927))
+                w += (0.002883894 / (rho2 - 5.5253437))
+                w *= (complex(0, 1) * a)
+                return w
+            else:
+                h = 0.8
+                A = cos(2 * x * y)
+                B = sin(2 * x * y)
+                C = exp(-2 * y * pi / h) - cos(2 * x * pi / h)
+                D = sin(2 * x * pi / h)
+                P2 = 2.0 * exp(-(x * x + (2.0 * y * pi / h) - y * y)) * ((A * C - B * D) /
+                                                                         (C * C + D * D))
+                Q2 = 2.0 * exp(-(x * x + (2.0 * y * pi / h) - y * y)) * ((A * D + B * C) /
+                                                                         (C * C + D * D))
+
+                if isinf(P2) or isinf(Q2):
+                    raise ValueError(
+                        "There is an issue determining the correct values for the curve fit for the "
+                        "complex error function"
+                        )
+
+                H = 0
+                K = 0
+                for n in range(1, 5):
+                    H += (2.0 * y * h / pi) * (exp(-n * n * h * h) * (y * y + x * x + n * n * h * h)) / (
+                            ((y * y - x * x + n * n * h * h) ** 2.0) + 4 * y * y * x * x)
+                    K += (2.0 * x * h / pi) * (exp(-n * n * h * h) * (y * y + x * x - n * n * h * h)) / (
+                            ((y * y - x * x + n * n * h * h) ** 2.0) + 4 * y * y * x * x)
+                H += h * y / (pi * (y * y + x * x))
+                K += h * x / (pi * (y * y + x * x))
+
+                if y == pi / h:
+                    H = H + 0.5 * P2
+                    K = K - 0.5 * Q2
+                elif y < (pi / h):
+                    H = H + P2
+                    K = K - Q2
+                return complex(H, K)
+
+def yml(l, m, polar, azimuthal):
+    """
+    Calculate the normalized spherical harmonics for the provided order (l) and power (m) at the provided angle set.
+    This function was replaced with the scipy function for the calculation of the spherical harmonics.
+
+    l : int
+        the order of the series
+    m : int
+        the power of the series
+    polar : double (units: radians)
+        the polar angle of the spherical harmonics
+    azimuthal : double (units: radians)
+        the azimuthal angle of the spherical harmonics
+
+    returns : complex
+        the values of the spherical harmonics at these angles, order and power.
+
+    20220329 - FSM - Refactored the calculation of the angles that are used within the determination of the
+        spherical harmonic value
+    """
+
+    from scipy.special import sph_harm
+    from measurable_objects.measurables import Angle
+
+    if isinstance(azimuthal, Angle):
+        az_angle_radians = azimuthal.radians
+    elif isinstance(azimuthal, tuple):
+        if isinstance(azimuthal[0], Angle):
+            az_angle_radians = azimuthal[0].radians
+        else:
+            az_angle_radians = azimuthal[0]
+    else:
+        az_angle_radians = azimuthal
+
+    if isinstance(polar, Angle):
+        pol_angle_radians = polar.radians
+    elif isinstance(polar, tuple):
+        if isinstance(polar[0], Angle):
+            pol_angle_radians = polar[0].radians
+        else:
+            pol_angle_radians = polar[0]
+    else:
+        pol_angle_radians = polar
+    return sph_harm(m, l, az_angle_radians, pol_angle_radians)