computils 0.0.1__tar.gz

computils-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 k-moussa
+
+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.

computils-0.0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: computils
+Version: 0.0.1
+Summary: A package collecting functionality for various numerical computations (numerical differentiation, interpolation, optimization, sorting, ).
+Author-email: Karim Moussa <research@k-moussa.com>
+Project-URL: Homepage, https://github.com/k-moussa/computils
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# computils
+A package collecting utilities and other convenient functionality for various numerical computations:
+* Numerical differentiation: based on finite differences.
+* Interpolation: provide a common interface for several useful interpolators from the excellent 'splines' and 'scipy.interpolate' packages.
+* Numerical optimization: transformation functions to impose constraints using unconstrained optimization algorithms.
+* Fast or robust python implementations of certain matrix operations.
+* Sorting, timing, and other utilities.

computils-0.0.1/README.md

@@ -0,0 +1,7 @@
+# computils
+A package collecting utilities and other convenient functionality for various numerical computations:
+* Numerical differentiation: based on finite differences.
+* Interpolation: provide a common interface for several useful interpolators from the excellent 'splines' and 'scipy.interpolate' packages.
+* Numerical optimization: transformation functions to impose constraints using unconstrained optimization algorithms.
+* Fast or robust python implementations of certain matrix operations.
+* Sorting, timing, and other utilities.

computils-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = [
+"setuptools>=61.0",
+"numpy >= 1.26.4",
+"scipy >= 1.13.0",
+"numba >= 0.59.1",
+"splines >= 0.3.1",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "computils"
+version = "0.0.1"
+authors = [
+  { name="Karim Moussa", email="research@k-moussa.com" },
+]
+description = "A package collecting functionality for various numerical computations (numerical differentiation, interpolation, optimization, sorting, )."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/k-moussa/computils"
+# Issues = "https://github.com/pypa/sampleproject/issues"

computils-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

computils-0.0.1/src/computils/__init__.py

@@ -0,0 +1,22 @@
+""" This module serves as the interface of the computils package.
+
+    References:
+        FC80: Frederick N. Fritsch and Ralph E. Carlson. Monotone piecewise cubic interpolation. SIAM Journal on
+            Numerical Analysis, 17(2):238–246, 1980. doi:10.1137/0717021.
+        FB84: Frederick N. Fritsch and Judy Butland. A method for constructing local monotone piecewise cubic
+            interpolants. SIAM Journal on Scientific and Statistical Computing, 5(2):300–304, 1984. doi:10.1137/0905021.
+"""
+
+from .globals import *
+from .factory import create_interpolator
+from .sorting_algorithms import index_eq, find_le, find_ge, find_gt, find_lt
+from .finite_difference import compute_derivative, compute_gradient, compute_jacobian, compute_hessian
+from .type_utils import size
+from .fast_eval import fast_matrix_inversion, fast_determinant, fast_quadratic_form, fast_diag_mult_AD, \
+    fast_diag_mult_DA, fast_columnwise_bilinear_form
+from .gaussian_elim_spp import compute_inverse_using_gauss_elim_spp
+from .matrix_computations import robust_inverse, is_diagonal
+from .parameter_transformations import impose_lower_bound, inverse_impose_lower_bound, impose_upper_bound, \
+    inverse_impose_upper_bound, impose_bounds, inverse_impose_bounds, impose_upper_bound_sum, \
+    inverse_impose_upper_bound_sum
+from .performance_checking import compute_average_running_time

computils-0.0.1/src/computils/factory.py

@@ -0,0 +1,12 @@
+""" This module is used to instantiate classes in the package. """
+
+from .globals import *
+from .interpolation import InternalInterpolator
+
+
+def create_interpolator(x: np.ndarray,
+                        y: np.ndarray,
+                        inter_type: InterpolationType,
+                        extra_type: ExtrapolationType = ExtrapolationType.nan) -> Interpolator:
+
+    return InternalInterpolator(x=x, y=y, inter_type=inter_type, extra_type=extra_type)

computils-0.0.1/src/computils/fast_eval.py

@@ -0,0 +1,68 @@
+""" This module collects functionality for fast evaluation of matrix operations. """
+
+import numpy as np
+from scipy.sparse import issparse
+from scipy.sparse.linalg import inv as sparse_inv
+from scipy.linalg import inv, det
+
+
+def fast_matrix_inversion(M: np.ndarray) -> np.ndarray:
+    if M.size == 1:
+        return 1.0 / M
+    elif issparse(M):
+        return sparse_inv(M)
+    else:
+        return inv(M)
+
+
+def fast_determinant(M: np.ndarray) -> float:
+    if M.size == 1:
+        return np.abs(M[0, 0])
+    else:
+        return det(M)
+
+
+def fast_quadratic_form(A: np.ndarray,
+                        x: np.ndarray) -> float:
+    return (np.dot(x.T, np.dot(A, x)))[0, 0]
+
+
+def fast_diag_mult_AD(A: np.ndarray,
+                      D: np.ndarray) -> np.ndarray:
+    return np.multiply(A, np.diag(D))
+
+
+def fast_diag_mult_DA(A: np.ndarray,
+                      D: np.ndarray) -> np.ndarray:
+    return np.multiply(np.diag(D)[:, None], A)
+
+
+def fast_columnwise_bilinear_form(A: np.ndarray,
+                                  B: np.ndarray,
+                                  C: np.ndarray) -> np.ndarray:
+    """ Efficiently compute the bilinear form A_i.T @ B @ C_i for i = 1,...,n, with A_i and C_i denoting the columns
+        of the matrices A_i and C_i, respectively.
+
+    :param A: (m, n) np array
+    :param B: (m, m) np array
+    :param C: (m, n) np array
+    :return: an (n,) np array containing the results
+    """
+
+    return ((A.T @ B) * C.T).sum(axis=1)
+
+
+if __name__ == "__main__":
+    A = np.array([[1, 2], [3, 5]])
+    B = 3.0 * A + 4.2
+    C = np.array([[9, 4], [2, 1]])
+    x = np.array([[9], [1]])
+
+    from computils.performance_checking import compute_average_running_time
+    n_repeats = 1000
+    regular_quadratic_form = lambda M, z: z.T @ M @ z
+    average_time_regular = compute_average_running_time(regular_quadratic_form, args=(A, x), n_repeats=n_repeats)
+    average_time_fast_eval = compute_average_running_time(fast_quadratic_form, args=(A, x), n_repeats=n_repeats)
+
+    print("Regular / fast eval time = {:f}".format(average_time_regular/average_time_fast_eval))
+    pass

computils-0.0.1/src/computils/finite_difference.py

@@ -0,0 +1,240 @@
+""" This module contains functionality for the numerical computation of derivatives using finite difference
+    based on the discussion in Numerical Recipes. """
+
+import numpy as np
+from typing import Callable, Final
+from .globals import CUBE_ROOT_MACHINE_EPS, FOURTH_ROOT_MACHINE_EPS, FloatOrArray
+from .type_utils import size as size_func
+
+_LOWER_BOUND_CHARACTERISTIC_SCALE: Final = 0.001
+
+
+def compute_derivative(func: Callable[[float], float],
+                       x: FloatOrArray,
+                       order: int,
+                       args: tuple = (),
+                       step_size: float = None) -> FloatOrArray:
+    """ Computes the first- or second-order derivative using finite differences for a given function at the point x.
+
+    Remarks: x is assumed to correspond to the first parameter of func.
+
+    :param func: a function f: R -> R, with x corresponding to its first parameter.
+    :param x: the point(s) of interest.
+    :param order: 1 or 2, the order of which to compute the derivative.
+    :param args: additional arguments to the function in the correct order.
+    :param step_size: a scalar > 0.
+    :return: the fd estimate(s) of the first-order derivative.
+    """
+
+    if order != 1 and order != 2:
+        raise RuntimeError("order must be 1 or 2.")
+
+    scalar_input = size_func(x) == 1
+    if scalar_input:
+        x = np.array([x])
+
+    fd_derivatives = np.full(fill_value=np.nan, shape=x.shape)
+    x_arg = np.full(fill_value=np.nan, shape=(1,))
+    for i in range(x.size):
+        x_arg[0] = x[i]
+        if order == 1:
+            fd_derivatives[i] = compute_gradient(func=func, x=x_arg, args=args, step_size=step_size)[0]
+        else:  # order == 2:
+            fd_derivatives[i] = compute_hessian(func=func, x=x_arg, args=args, step_size=step_size)[0, 0]
+
+    if scalar_input:
+        return fd_derivatives[0]
+    else:
+        return fd_derivatives
+
+
+def compute_gradient(func: Callable[..., float],
+                     x: np.ndarray,
+                     args: tuple = (),
+                     step_size: float = None) -> np.ndarray:
+    """ Computes the gradient using finite differences for a given function at the point x.
+
+    Remarks: x is assumed to correspond to the first parameter of func.
+
+    :param func: a function f: R^n -> R, with x corresponding to its first parameter.
+    :param x: an (n,) np array corresponding to the point of interest.
+    :param args: additional arguments to the function in the correct order.
+    :param step_size: a scalar > 0.
+    :return: an (n, 1) array containing the numerical approximation of the gradient.
+    """
+
+    jacobian = compute_jacobian(func=func, x=x, args=args, step_size=step_size)
+    gradient = jacobian.T
+    return gradient
+
+
+def compute_jacobian(func: Callable[[np.ndarray], np.ndarray],
+                     x: np.ndarray,
+                     args: tuple = (),
+                     step_size: float = None) -> np.ndarray:
+    """ Computes the Jacobian using finite differences for a given function at the point x.
+
+    :param func: a function f: R^n -> R^m (i.e. returns an (m,) np array of function values), with x corresponding to
+        its first parameter.
+    :param x: an (n,) np array corresponding to the point of interest.
+    :param args: additional arguments to the function in the correct order.
+    :param step_size: a scalar > 0.
+    :return: an (m, n) array containing the numerical approximation of the Jacobian.
+    """
+
+    func = _get_func_given_args(func, args)
+
+    function_value = func(x)
+    if isinstance(function_value, np.ndarray):
+        m = func(x).size
+    else:
+        m = 1
+
+    n = x.size
+    jacobian = np.zeros((m, n))
+    step_sizes = get_step_sizes(x, derivative_order=1, step_size=step_size)
+
+    for i in range(n):
+        selection_vector = _get_selection_vector(n, index=i)
+
+        if m == 1:
+            jacobian[0, i] = _compute_1st_derivative_fd(func, x, step_sizes[i], selection_vector)
+        else:
+            jacobian[:, i] = _compute_1st_derivative_fd(func, x, step_sizes[i], selection_vector)
+
+    return jacobian
+
+
+def compute_hessian(func: Callable[[np.ndarray], float],
+                    x: np.ndarray,
+                    args: tuple = (),
+                    step_size: float = None) -> np.ndarray:
+    """ Computes the Hessian matrix using finite differences for a given function at the point x.
+
+    :param func: a function f: R^n -> R, with x corresponding to its first parameter..
+    :param x: an (n,) np array corresponding to the point of interest.
+    :param args: additional arguments to the function in the correct order.
+    :param step_size: a scalar > 0.
+    :return: an (n, n) array containing the numerical approximation of the hessian.
+    """
+
+    func = _get_func_given_args(func, args)
+
+    n = x.size
+    hessian = np.zeros((n, n))
+    step_sizes = get_step_sizes(x, derivative_order=2, step_size=step_size)
+
+    for i in range(n):
+        for j in range(i, n):
+            step_size = step_sizes[i, j]
+            selection_vector_i = _get_selection_vector(n, index=i)
+            selection_vector_j = _get_selection_vector(n, index=j)
+            hessian[i, j] = _compute_2nd_derivative_fd(func, x, step_size, selection_vector_i, selection_vector_j)
+
+    diagonal = np.diag(hessian).copy()
+    hessian += hessian.T
+    np.fill_diagonal(hessian, diagonal)
+
+    return hessian
+
+
+def _get_func_given_args(func: Callable[..., FloatOrArray], args: tuple = ()) -> Callable[[np.ndarray], FloatOrArray]:
+    return lambda x: func(x, *args)
+
+
+def get_step_sizes(x: np.ndarray,
+                   derivative_order: int,
+                   step_size: float = None) -> np.ndarray:
+    """ Returns an (x.size, 1) array for derivative_order 1, and an (x.size, x.size) array for derivative_order 2 """
+
+    if step_size is None:
+        optimal_relative_step_size = _get_optimal_relative_step_size(derivative_order)
+        abs_curvature_scale_estimates = _get_abs_curvature_scale_estimates(x, derivative_order)
+        optimal_step_sizes = optimal_relative_step_size * abs_curvature_scale_estimates
+
+        # trick from Numerical Recipes to ensure that x + h and x differ by an exactly-representable number
+        x_2dim = x.copy()
+        x_2dim.shape = (x_2dim.size, 1)
+        temp = optimal_step_sizes + x_2dim
+        optimal_step_sizes = temp - x_2dim
+
+        return optimal_step_sizes
+
+    elif step_size <= 0.0:
+        raise RuntimeError("step_size {:.2f} <= 0 not allowed..".format(step_size))
+    else:
+        if derivative_order == 1:
+            shape = (x.size, 1)
+        elif derivative_order == 2:
+            shape = (x.size, x.size)
+        else:
+            raise RuntimeError("derivative_order {:} not implemented.".format(derivative_order))
+
+        step_sizes = np.full(shape=shape, fill_value=step_size)
+        return step_sizes
+
+
+def _get_abs_curvature_scale_estimates(x: np.ndarray,
+                                       derivative_order: int) -> np.ndarray:
+    """ Returns an (x.size, 1) array for derivative_order 1, and an (x.size, x.size) array for derivative_order 2 """
+
+    if derivative_order == 1:
+        abs_curvature_scale_estimates = np.clip(np.abs(x), a_min=_LOWER_BOUND_CHARACTERISTIC_SCALE, a_max=np.inf)
+        abs_curvature_scale_estimates.shape = (x.size, 1)
+        return abs_curvature_scale_estimates
+    elif derivative_order == 2:
+        abs_x = np.abs(x)
+        abs_x.shape = (abs_x.size, 1)
+        abs_curvature_scale_estimates = (abs_x + abs_x.T) / 2.0  # use the average argument values as estimates
+        return np.clip(abs_curvature_scale_estimates, a_min=_LOWER_BOUND_CHARACTERISTIC_SCALE, a_max=np.inf)
+    else:
+        raise RuntimeError("derivative_order {:} not implemented.".format(derivative_order))
+
+
+def _get_optimal_relative_step_size(derivative_order: int) -> float:
+    if derivative_order == 1:
+        return CUBE_ROOT_MACHINE_EPS
+    elif derivative_order == 2:
+        return FOURTH_ROOT_MACHINE_EPS
+    else:
+        raise RuntimeError("derivative_order {:} not implemented.".format(derivative_order))
+
+
+def _get_selection_vector(size: int,
+                          index: int) -> np.ndarray:
+    selection_vector = np.zeros((size,))
+    selection_vector[index] = 1.0
+
+    return selection_vector
+
+
+def _compute_1st_derivative_fd(func: Callable[[np.ndarray], FloatOrArray],
+                               x: np.ndarray,
+                               step_size: float,
+                               selection_vector: np.ndarray) -> FloatOrArray:
+    """ Computes either a single 1st-order derivative, or an entire column of the Jacobian matrix. """
+
+    step_size_selection_vector = step_size * selection_vector
+    forward_value = func(x + step_size_selection_vector)
+    backward_value = func(x - step_size_selection_vector)
+
+    fd_approximation = (forward_value - backward_value) / (2.0 * step_size)
+    return fd_approximation
+
+
+def _compute_2nd_derivative_fd(func: Callable[[np.ndarray], float],
+                               x: np.ndarray,
+                               step_size: float,
+                               selection_vector_i: np.ndarray,
+                               selection_vector_j: np.ndarray) -> float:
+    step_size_selection_vector_i = step_size * selection_vector_i
+    step_size_selection_vector_j = step_size * selection_vector_j
+
+    func_value_plus_i_plus_j = func(x + step_size_selection_vector_i + step_size_selection_vector_j)
+    func_value_plus_i_minus_j = func(x + step_size_selection_vector_i - step_size_selection_vector_j)
+    func_value_minus_i_plus_j = func(x - step_size_selection_vector_i + step_size_selection_vector_j)
+    func_value_minus_i_minus_j = func(x - step_size_selection_vector_i - step_size_selection_vector_j)
+
+    fd_approximation = (func_value_plus_i_plus_j - func_value_plus_i_minus_j - func_value_minus_i_plus_j +
+                        func_value_minus_i_minus_j) / (4.0 * step_size ** 2)
+    return fd_approximation

computils-0.0.1/src/computils/gaussian_elim_spp.py

@@ -0,0 +1,62 @@
+""" This module implements functionality related to Gaussian elimination with scaled partial pivoting. """
+
+import numpy as np
+from numba import jit
+
+
+def compute_inverse_using_gauss_elim_spp(square_matrix: np.ndarray) -> np.ndarray:
+    """ Uses Gaussian elimination with scaled partial pivoting to compute the inverse of the given square matrix. """
+
+    n_rows = square_matrix.shape[0]
+    b = np.eye(n_rows)
+    echelon_matrix = perform_gauss_elim_spp(a=square_matrix, b=b)
+    reduced_matrix = perform_back_substitution(echelon_matrix)
+    inverse_matrix = reduced_matrix[:, n_rows:]
+    return inverse_matrix
+
+
+def perform_gauss_elim_spp(a: np.ndarray,
+                           b: np.ndarray) -> np.ndarray:
+    """ Performs Gaussian elimination with scaled partial pivoting to put the matrix [a b] in echelon form.
+
+    :param a: an (n, n) array representing a square matrix.
+    :param b: an (n, n_b) array.
+    :return: echelon_matrix: an (n, n + n_b) matrix corresponding to [a b] in reduced echelon form, in which
+        the rows may have been swapped.
+    """
+
+    echelon_matrix = np.hstack((a, b))
+    n_rows = a.shape[0]
+
+    for j in range(n_rows - 1):
+        submatrix_a_right_to_pivot = echelon_matrix[j:, (j + 1):n_rows]
+        max_value_per_row = np.amax(np.abs(submatrix_a_right_to_pivot), axis=1)
+        r = np.divide(np.abs(echelon_matrix[j:, j]), max_value_per_row)
+        k = j + np.argmax(r)  # k = row with largest r_k
+
+        if j != k:
+            echelon_matrix[[j, k]] = echelon_matrix[[k, j]]  # swap rows
+
+        for i in range(j + 1, n_rows):
+            ratio = echelon_matrix[i, j] / echelon_matrix[j, j]
+            echelon_matrix[i, :] -= ratio * echelon_matrix[j, :]
+
+    return echelon_matrix
+
+
+def perform_back_substitution(echelon_matrix: np.ndarray) -> np.ndarray:
+    """ Transforms a matrix in echelon form to reduced echelon form using back substitution.
+    
+    :param echelon_matrix: a matrix [A B] in echelon form.
+    :return: reduced_matrix: the result of the matrix [A B] after back substitution.
+    """
+
+    reduced_matrix = echelon_matrix.copy()
+    n_rows = reduced_matrix.shape[0] 
+    for j in reversed(range(n_rows)):
+        reduced_matrix[j, j:] /= reduced_matrix[j, j]
+    
+        for i in range(j):
+            reduced_matrix[i, j:] -= reduced_matrix[i, j] * reduced_matrix[j, j:]
+        
+    return reduced_matrix

computils-0.0.1/src/computils/globals.py

@@ -0,0 +1,64 @@
+""" This module collects all exposed types."""
+
+import numpy as np
+from enum import Enum
+from abc import ABC, abstractmethod
+from typing import final, Union
+
+MACHINE_EPS: final = float(2 ** (-53))  # max relative error corresponding to 1/2 ULP
+SQUARE_ROOT_MACHINE_EPS: final = np.sqrt(MACHINE_EPS)
+CUBE_ROOT_MACHINE_EPS: final = np.cbrt(MACHINE_EPS)
+FOURTH_ROOT_MACHINE_EPS: final = np.power(MACHINE_EPS, 1/4)
+
+Integer: final = Union[int, np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64]
+Float: final = Union[float, np.float16, np.float32, np.float64, np.float128]
+Complex: final = Union[complex, np.complex64, np.complex128, np.complex256]
+Scalar: final = Union[Integer, Float, Complex]
+
+IntOrArray: final = Union[Integer, np.ndarray]
+FloatOrArray: final = Union[Float, np.ndarray]
+ComplexOrArray: final = Union[Complex, np.ndarray]
+ScalarOrArray: final = Union[Scalar, np.ndarray]
+
+
+# 128-bit integers generated using entropy gathered from the OS, for fixing the seed of NumPy generators.
+SEED128_1: final = 137088887599416403785824428186011523708
+SEED128_2: final = 230453062773196406322953725600125856954
+SEED128_3: final = 334883455271001690768699206953238296696
+SEED128_4: final = 69805789651723487751993596682833892465
+SEED128_5: final = 107997836754270478432192384195731366045
+SEED128_6: final = 61384398454038591198002507585631369346
+SEED128_7: final = 165303562401480433055547884045914282112
+SEED128_8: final = 215418768511176275020128984871223831370
+SEED128_9: final = 247520618467519227348322182729719821192
+SEED128_10: final = 260473913589332506348144405693894964574
+
+
+class InterpolationType(Enum):
+    linear = 0
+    ncs = 1  # natural cubic spline
+    ccs = 2  # clamped cubic spline
+    pmc = 3  # piecewise monotone cubic [FC80]
+    pchip = 4  # [FB84]
+
+
+class ExtrapolationType(Enum):
+    nan = 0
+    flat = 1
+
+
+class Interpolator(ABC):
+    def __init__(self,
+                 inter_type: InterpolationType,
+                 extra_type: ExtrapolationType):
+
+        self.inter_type: InterpolationType = inter_type
+        self.extra_type: ExtrapolationType = extra_type
+
+    @abstractmethod
+    def __call__(self, x: ScalarOrArray) -> ScalarOrArray:
+        """
+
+        :param x:
+        :return:
+        """

computils-0.0.1/src/computils/interpolation.py

@@ -0,0 +1,104 @@
+""" This module implements various interpolation methods. """
+
+import splines
+from scipy.interpolate import CubicSpline, PchipInterpolator
+from typing import Callable
+from .type_utils import size
+from .globals import *
+
+
+class InternalInterpolator(Interpolator, ABC):
+    def __init__(self,
+                 x: np.ndarray,
+                 y: np.ndarray,
+                 inter_type: InterpolationType,
+                 extra_type: ExtrapolationType):
+        """
+
+        :param x: independent variables; data must be sorted in ascending order.
+        :param y: dependent variables corresponding to x.
+        :param inter_type:
+        :param extra_type:
+        """
+
+        super().__init__(inter_type=inter_type, extra_type=extra_type)
+
+        self._x: np.ndarray = x  # independent variables
+        self._y: np.ndarray = y  # dependent variables
+        self._interpolant: Callable[[ScalarOrArray], ScalarOrArray] = self._get_interpolant(x=x, y=y,
+                                                                                            inter_type=inter_type)
+
+    def __call__(self, x: ScalarOrArray) -> ScalarOrArray:
+        """
+
+        :param x:
+        :return:
+        """
+
+        y = self._interpolant(x)
+        extra_masks = self._get_extrapolation_masks(x)
+        no_extrapolation = np.sum(extra_masks) == 0
+        if no_extrapolation:
+            return y
+        else:
+            y[extra_masks] = self._extrapolate(x[extra_masks])
+
+        return y
+
+    def _get_extrapolation_masks(self, x: ScalarOrArray) -> IntOrArray:
+        """ Returns masks for points in extrapolation region. """
+
+        return self._exceeds_lhs(x) | self._exceeds_rhs(x)
+
+    def _exceeds_lhs(self, x: ScalarOrArray) -> IntOrArray:
+        return x < self._x[0]
+
+    def _exceeds_rhs(self, x: ScalarOrArray) -> IntOrArray:
+        return x > self._x[-1]
+
+    def _extrapolate(self, x_extra: ScalarOrArray) -> ScalarOrArray:
+        y_extra = np.full(shape=(size(x_extra),), fill_value=np.nan)
+        if self.extra_type is ExtrapolationType.nan:
+            return y_extra
+
+        lhs_masks = self._exceeds_lhs(x_extra)
+        rhs_masks = self._exceeds_rhs(x_extra)
+        if self.extra_type is ExtrapolationType.flat:
+            y_extra[lhs_masks] = self._y[0]
+            y_extra[rhs_masks] = self._y[-1]
+
+        return y_extra
+
+    @staticmethod
+    def _get_interpolant(x: np.ndarray,
+                         y: np.ndarray,
+                         inter_type: InterpolationType) -> Callable[[ScalarOrArray], ScalarOrArray]:
+
+        if inter_type is InterpolationType.linear:
+            interpolant = lambda z: np.interp(x=z, xp=x, fp=y)
+            return interpolant
+        elif inter_type is InterpolationType.ncs:
+            return CubicSpline(x=x, y=y, bc_type='natural')
+        elif inter_type is InterpolationType.ccs:
+            return CubicSpline(x=x, y=y, bc_type='clamped')
+        elif inter_type is InterpolationType.pmc:
+            return PmcSplineFunctor(x=x, y=y)
+        elif inter_type is InterpolationType.pchip:
+            return PchipInterpolator(x=x, y=y)
+        else:
+            raise RuntimeError(f"Unhandled inter_type {inter_type.name}.")
+
+
+class PmcSplineFunctor:
+    def __init__(self,
+                 x: np.ndarray,
+                 y: np.ndarray):
+
+        self.x: np.ndarray = x
+        self._spline = splines.PiecewiseMonotoneCubic(values=y, grid=x)
+
+    def __call__(self, x: np.ndarray):
+        inter_masks = (x >= self.x[0]) & (x <= self.x[-1])
+        y_eval = np.full(shape=(size(x),), fill_value=np.nan)
+        y_eval[inter_masks] = self._spline.evaluate(x[inter_masks])
+        return y_eval

computils-0.0.1/src/computils/matrix_computations.py

@@ -0,0 +1,23 @@
+""" This module contains functionality related to matrix computations. """
+
+import numpy as np
+from numpy.linalg import solve
+
+
+def robust_inverse(square_matrix: np.ndarray) -> np.ndarray:
+    """ Computes the inverse of the square matrix.
+
+    :param square_matrix: (n, n) array corresponding to an invertible matrix.
+    :return: inverse_matrix: (n, n) array.
+    """
+
+    if is_diagonal(square_matrix):
+        main_diagonal_inverse = np.divide(1.0, np.diagonal(square_matrix))
+        return np.diag(main_diagonal_inverse)
+    else:
+        inverse_matrix = solve(square_matrix, np.eye(square_matrix.shape[0]))
+        return inverse_matrix
+
+
+def is_diagonal(matrix: np.ndarray) -> bool:
+    return np.count_nonzero(matrix - np.diag(np.diagonal(matrix))) == 0

computils-0.0.1/src/computils/parameter_transformations.py

@@ -0,0 +1,54 @@
+""" This module contains transformations and their inverse functions for imposing parameter restrictions. """
+
+import numpy as np
+
+
+def impose_lower_bound(transformed_parameter: float, lower_bound: float) -> float:
+    return np.exp(transformed_parameter) + lower_bound
+
+
+def inverse_impose_lower_bound(parameter: float, lower_bound: float) -> float:
+    return np.log(parameter - lower_bound)
+
+
+def impose_upper_bound(transformed_parameter: float, upper_bound: float) -> float:
+    return -np.exp(transformed_parameter) + upper_bound
+
+
+def inverse_impose_upper_bound(parameter: float, upper_bound: float) -> float:
+    return np.log(upper_bound - parameter)
+
+
+def impose_bounds(transformed_parameter: float, lower_bound: float, upper_bound: float) -> float:
+    return lower_bound + (upper_bound - lower_bound)/(1.0 + np.exp(-transformed_parameter))
+
+
+def inverse_impose_bounds(parameter: float, lower_bound: float, upper_bound: float) -> float:
+    z = (parameter - lower_bound)/(upper_bound - lower_bound)
+    return np.log(z) - np.log(1.0 - z)
+
+
+def impose_upper_bound_sum(transformed_params: np.ndarray, upper_bound: float) -> np.ndarray:
+    """ Imposes an upper bound on the sum of params, such that all params are in (0, upper_bound).
+
+    :param transformed_params: (n_params,) array of transformed parameters, real numbers
+    :param upper_bound: real number
+    :return: constrained_params: (n_params,) array of parameters with constraints
+    """
+
+    exp_trans_params = np.exp(transformed_params)
+    constrained_params = upper_bound * np.divide(exp_trans_params, np.sum(exp_trans_params) + 1.0)
+    return constrained_params
+
+
+def inverse_impose_upper_bound_sum(params: np.ndarray, upper_bound: float) -> np.ndarray:
+    """  Inverse transformation function of impose_upper_bound_sum.
+
+    :param params: (n_params,) array of params that are all in (0, upper_bound)
+    :param upper_bound: real number
+    :return: unconstrained_params
+    """
+
+    sum_params = np.sum(params)
+    unconstrained_params = np.log(params / (upper_bound - sum_params))
+    return unconstrained_params

computils-0.0.1/src/computils/performance_checking.py

@@ -0,0 +1,31 @@
+""" This module provides functionality for checking the running time performance of code. """
+
+from time import time
+from typing import Callable
+
+
+def compute_average_running_time(callback_func: Callable, args: tuple = (),
+                                 n_repeats: int = 10) -> float:
+    """ Computes the average running time of a function evaluation for given number of repeats.
+
+    :param callback_func: the function to be evaluated
+    :param args: arguments to the callback
+    :param n_repeats: > 1, number of repeats of the function evaluation
+    :return: average_running_time_in_seconds
+    """
+
+    t = time()
+
+    for i in range(n_repeats):
+        callback_func(*args)
+
+    running_time_in_seconds = time() - t
+    average_running_time_in_seconds = running_time_in_seconds / n_repeats
+    return average_running_time_in_seconds
+
+
+if __name__ == "__main__":
+    import numpy as np
+    n_reps = 100
+    print("Average running time = {:.4f}s (repeats = {:d}).".format(
+        compute_average_running_time(np.exp, (np.zeros((10 ** 7,)),), n_reps), n_reps))

computils-0.0.1/src/computils/sorting_algorithms.py

@@ -0,0 +1,102 @@
+""" This module implements various sorting algorithms based on Python's bisect module. It is based on the implementation 
+    suggested in https://stackoverflow.com/questions/6628744/search-for-before-and-after-values-in-a-long-sorted-list 
+    """
+
+import bisect
+from typing import Sequence, Any, Optional
+
+
+def _check_args(a: Sequence,
+                x: Any):
+    """ Checks the arguments a and x and raises a RuntimeError for invalid input. """
+
+    if len(a) == 0:
+        raise RuntimeError("a is empty.")
+
+
+def index_eq(a: Sequence,
+             x: Any) -> Optional[int]:
+    """ Returns the index of the leftmost value in a that is exactly equal to x.
+    
+    :param a: 
+    :param x: an object with '<' and '==' operators.
+    :return: the index, or None if the x is not in a.
+    """
+
+    _check_args(a=a, x=x)
+
+    i = bisect.bisect_left(a, x)
+    if i != len(a) and a[i] == x:
+        return i
+    else:
+        return None
+
+
+def find_lt(a: Sequence, 
+            x: Any) -> Any:
+    """ Returns the rightmost value in a that is less than x.
+    
+    :param a: 
+    :param x: an object with '<' and '==' operators.
+    :return: 
+    """
+
+    _check_args(a=a, x=x)
+
+    i = bisect.bisect_left(a, x)
+    if i:
+        return a[i-1]
+    raise ValueError
+
+
+def find_le(a: Sequence, 
+            x: Any) -> Any:
+    """ Returns the rightmost value in a that is less than or equal to x.
+
+    :param a: 
+    :param x: an object with '<' and '==' operators.
+    :return: 
+    """
+
+    _check_args(a=a, x=x)
+
+    i = bisect.bisect_right(a, x)
+    if i:
+        return a[i-1]
+    raise ValueError
+
+
+def find_gt(a: Sequence, 
+            x: Any) -> Any:
+    """ Returns the leftmost value in a that is greater than x.
+
+    :param a: 
+    :param x: an object with '<' and '==' operators.
+    :return: 
+    """
+
+    _check_args(a=a, x=x)
+
+    i = bisect.bisect_right(a, x)
+    if i != len(a):
+        return a[i]
+    raise ValueError
+
+
+def find_ge(a: Sequence, 
+            x: Any) -> Any:
+    """ Returns the leftmost value in a that is greater than or equal to x.
+
+        Remark: raises a value error if 
+
+    :param a: 
+    :param x: an object with '<' and '==' operators.
+    :return: 
+    """
+
+    _check_args(a=a, x=x)
+
+    i = bisect.bisect_left(a, x)
+    if i != len(a):
+        return a[i]
+    raise ValueError

computils-0.0.1/src/computils/type_utils.py

@@ -0,0 +1,11 @@
+""" Implements helping functions for the introduced types. """
+
+import numpy as np
+from .globals import ScalarOrArray
+
+
+def size(x: ScalarOrArray) -> int:
+    if isinstance(x, np.ndarray):
+        return x.size
+    else:
+        return 1

computils-0.0.1/src/computils.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: computils
+Version: 0.0.1
+Summary: A package collecting functionality for various numerical computations (numerical differentiation, interpolation, optimization, sorting, ).
+Author-email: Karim Moussa <research@k-moussa.com>
+Project-URL: Homepage, https://github.com/k-moussa/computils
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# computils
+A package collecting utilities and other convenient functionality for various numerical computations:
+* Numerical differentiation: based on finite differences.
+* Interpolation: provide a common interface for several useful interpolators from the excellent 'splines' and 'scipy.interpolate' packages.
+* Numerical optimization: transformation functions to impose constraints using unconstrained optimization algorithms.
+* Fast or robust python implementations of certain matrix operations.
+* Sorting, timing, and other utilities.

computils-0.0.1/src/computils.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/computils/__init__.py
+src/computils/factory.py
+src/computils/fast_eval.py
+src/computils/finite_difference.py
+src/computils/gaussian_elim_spp.py
+src/computils/globals.py
+src/computils/interpolation.py
+src/computils/matrix_computations.py
+src/computils/parameter_transformations.py
+src/computils/performance_checking.py
+src/computils/sorting_algorithms.py
+src/computils/type_utils.py
+src/computils.egg-info/PKG-INFO
+src/computils.egg-info/SOURCES.txt
+src/computils.egg-info/dependency_links.txt
+src/computils.egg-info/top_level.txt
+src/tests/matrix_computations_tests.py
+src/tests/numerical_derivatives_tests.py
+src/tests/parameter_transformation_tests.py
+src/tests/test_utils.py

computils-0.0.1/src/computils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

computils-0.0.1/src/computils.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+computils
+tests

computils-0.0.1/src/tests/matrix_computations_tests.py

@@ -0,0 +1,25 @@
+""" This module tests functionality related to matrix computations. """
+
+import unittest
+import numpy as np
+from numpy.linalg import inv
+from scipy.stats import wishart
+from test_utils import compute_max_abs_diff
+from computils import SEED128_1
+from computils.gaussian_elim_spp import compute_inverse_using_gauss_elim_spp
+
+
+class MatrixComputationsTests(unittest.TestCase):
+
+    def test_inverse_gauss_elim_spp(self):
+        rng = np.random.default_rng(SEED128_1)
+        n = 50
+        df = n + 1.0
+        scale_matrix = np.eye(n)
+
+        for i in range(100):
+            matrix = wishart.rvs(df=df, scale=scale_matrix, random_state=rng)
+            inverse_matrix = inv(matrix)
+            inverse_matrix_gespp = compute_inverse_using_gauss_elim_spp(matrix)
+            max_diff = compute_max_abs_diff(inverse_matrix, inverse_matrix_gespp)
+            self.assertAlmostEqual(0.0, max_diff, delta=10**-8)

computils-0.0.1/src/tests/numerical_derivatives_tests.py

@@ -0,0 +1,129 @@
+""" This module tests the computation of numerical derivatives. """
+
+import unittest
+import numpy as np
+from computils.finite_difference import compute_gradient, compute_jacobian, compute_hessian
+
+
+def func_r2_to_r3(x: np.ndarray, scaling_factor: float = 1.0) -> np.ndarray:
+    """ A test function f: R^2 -> R^3
+
+    :param x: a (2,) np array of argument values.
+    :param scaling_factor: real number (nonzero).
+    :return: a (3,) array containing the function values
+    """
+
+    function_values = np.zeros((3,))
+    function_values[0] = 2.0 * x[0]
+    function_values[1] = func_r2_to_r(x)
+    function_values[2] = -3.0 * x[1]
+    
+    return scaling_factor * function_values
+
+
+def analytical_jacobian_test_func_r2_to_r3(x: np.ndarray) -> np.ndarray:
+    """ Analytical Jacobian of the test function f: R^2 -> R^3
+
+    :param x: a (2,) np array of argument values.
+    :return: jacobian: a (3, 2) array of first-order derivatives.
+    """
+    
+    jacobian = np.zeros((3, 2))
+    jacobian[0, 0] = 2.0
+    jacobian[1, :] = analytical_gradient_test_func_r2_to_r(x).flatten()
+    jacobian[2, 1] = -3.0
+    return jacobian
+
+
+def func_r2_to_r(x: np.ndarray, scaling_factor: float = 1.0) -> float:
+    """ A test function f: R^2 -> R
+
+    :param x: a (2,) array of argument values.
+    :param scaling_factor: real number (nonzero).
+    :return: the function value (scalar).
+    """
+
+    return scaling_factor * (2.0 * x[0] ** 2 + 4.0 * x[1] ** 3 + 6.0 * x[0] * x[1])
+
+
+def analytical_gradient_test_func_r2_to_r(x: np.ndarray) -> np.ndarray:
+    """ Analytical gradient of the test function f: R^2 -> R
+
+    :param x: a (2,) array of argument values.
+    :return: gradient: a (2, 1) np array of first-order derivatives.
+    """
+
+    gradient = np.zeros((2, 1))
+    gradient[0, 0] = 4.0 * x[0] + 6.0 * x[1]
+    gradient[1, 0] = 12.0 * x[1] ** 2 + 6.0 * x[0]
+    return gradient
+
+
+def analytical_hessian_test_func_r2_to_r(x: np.ndarray) -> np.ndarray:
+    """ Analytical hessian of the test function f: R^2 -> R
+
+    :param x: a (2,) array of argument values.
+    :return: hessian: a (2, 1) np array of first-order derivatives.
+    """
+
+    hessian = np.zeros((2, 2))
+    hessian[0, 0] = 4.0
+    hessian[0, 1] = hessian[1, 0] = 6.0
+    hessian[1, 1] = 24.0 * x[1]
+    return hessian
+
+
+class FiniteDifferenceTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.x_values = [n * np.array([0.5, 1.0]) for n in range(-1, 10)]
+        cls.scaling_factor = 0.9
+
+    def test_gradient(self):
+        for x in self.x_values:
+            for include_args in (True, False):
+                analytical_gradient = analytical_gradient_test_func_r2_to_r(x)
+
+                if include_args:
+                    analytical_gradient *= self.scaling_factor
+                    numerical_gradient = compute_gradient(func_r2_to_r, x, args=(self.scaling_factor,))
+                else:
+                    numerical_gradient = compute_gradient(func_r2_to_r, x)
+
+                diffs = numerical_gradient - analytical_gradient
+                max_diff = np.amax(np.abs(diffs))
+                self.assertAlmostEqual(0.0, max_diff, delta=10**-8)
+
+    def test_jacobian(self):
+        for x in self.x_values:
+            for include_args in (True, False):
+                analytical_jacobian = analytical_jacobian_test_func_r2_to_r3(x)
+
+                if include_args:
+                    analytical_jacobian *= self.scaling_factor
+                    numerical_jacobian = compute_jacobian(func_r2_to_r3, x, args=(self.scaling_factor,))
+                else:
+                    numerical_jacobian = compute_jacobian(func_r2_to_r3, x)
+
+                diffs = numerical_jacobian - analytical_jacobian
+                max_diff = np.amax(np.abs(diffs))
+                self.assertAlmostEqual(0.0, max_diff, delta=10**-8)
+
+    def test_hessian(self):
+        for x in self.x_values:
+            for include_args in (True, False):
+                analytical_hessian = analytical_hessian_test_func_r2_to_r(x)
+
+                if include_args:
+                    analytical_hessian *= self.scaling_factor
+                    numerical_hessian = compute_hessian(func_r2_to_r, x, args=(self.scaling_factor,))
+                else:
+                    numerical_hessian = compute_hessian(func_r2_to_r, x)
+
+                diffs = numerical_hessian - analytical_hessian
+                max_diff = np.amax(np.abs(diffs))
+                self.assertAlmostEqual(0.0, max_diff, delta=10**-6)
+
+
+if __name__ == '__main__':
+    unittest.main()

computils-0.0.1/src/tests/parameter_transformation_tests.py

@@ -0,0 +1,122 @@
+""" This module implements tests for the parameter transformation functions. """
+
+import unittest
+import numpy as np
+import computils.parameter_transformations as pt
+
+
+class ParameterTransformationTests(unittest.TestCase):
+    def test_impose_lower_bound(self):
+        n_values = 100
+        lower_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for lower_bound in lower_bounds:
+            expected_value = 1.0 + lower_bound
+            actual_value = pt.impose_lower_bound(transformed_parameter=0.0, lower_bound=lower_bound)
+
+            self.assertAlmostEqual(expected_value, actual_value, delta=10 ** (-10))
+
+    def test_consistency_lower_bound_transformations(self):
+        """ Tests consistency of the lower bound transformations by checking whether their
+            composition yields the identity function. """
+
+        n_values = 100
+        lower_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+        transformed_values = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for lower_bound in lower_bounds:
+            for value in transformed_values:
+                actual_value = pt.inverse_impose_lower_bound(
+                    pt.impose_lower_bound(value, lower_bound), lower_bound)
+
+                self.assertAlmostEqual(value, actual_value, delta=10 ** (-10))
+
+    def test_impose_upper_bound(self):
+        n_values = 100
+        upper_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for upper_bound in upper_bounds:
+            expected_value = -1.0 + upper_bound
+            actual_value = pt.impose_upper_bound(transformed_parameter=0.0, upper_bound=upper_bound)
+
+            self.assertAlmostEqual(expected_value, actual_value, delta=10 ** (-10))
+
+    def test_consistency_upper_bound_transformations(self):
+        """ Tests consistency of the upper bound transformations by checking whether their
+            composition yields the identity function. """
+
+        n_values = 100
+        upper_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+        transformed_values = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for upper_bound in upper_bounds:
+            for value in transformed_values:
+                actual_value = pt.inverse_impose_upper_bound(
+                    pt.impose_upper_bound(value, upper_bound), upper_bound)
+
+                self.assertAlmostEqual(value, actual_value, delta=10 ** (-10))
+
+    def test_impose_bounds(self):
+        n_values = 100
+        lower_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+        upper_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for lower_bound in lower_bounds:
+            for upper_bound in upper_bounds:
+                expected_value = (lower_bound + upper_bound) / 2.0
+                actual_value = pt.impose_bounds(
+                    transformed_parameter=0.0, lower_bound=lower_bound, upper_bound=upper_bound)
+
+                self.assertAlmostEqual(expected_value, actual_value, delta=10 ** (-10))
+
+    def test_consistency_bounds_transformations(self):
+        """ Tests consistency of the double bound transformations by checking whether their
+            composition yields the identity function. """
+
+        n_values = 100
+        lower_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+        transformed_values = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for lower_bound in lower_bounds:
+            upper_bound = lower_bound + 1.0
+
+            for value in transformed_values:
+                actual_value = pt.inverse_impose_bounds(
+                    pt.impose_bounds(value, lower_bound, upper_bound), lower_bound, upper_bound)
+
+                self.assertAlmostEqual(value, actual_value, delta=10 ** (-10))
+
+    def test_impose_upper_bound_sum(self):
+        n_params = 3
+        transformed_params = np.zeros((n_params,))
+        n_values = 100
+        upper_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+
+        for upper_bound in upper_bounds:
+            expected_param_value = upper_bound / (n_params + 1.0)
+            actual_params = pt.impose_upper_bound_sum(transformed_params=transformed_params, upper_bound=upper_bound)
+
+            for param in actual_params:
+                self.assertAlmostEqual(expected_param_value, param, delta=10 ** (-10))
+
+    def test_consistency_upper_bound_sum_transformations(self):
+        """ Tests consistency of the upper bound sum transformations by checking whether their
+            composition yields the identity function. """
+
+        n_values = 100
+        upper_bounds = np.linspace(start=-10.0, stop=10.0, num=n_values)
+        transformed_values = np.random.normal(size=(n_values, 2))
+
+        for upper_bound in upper_bounds:
+            for i in range(n_values):
+                transformed_params = transformed_values[i]
+                result = pt.inverse_impose_upper_bound_sum(
+                    pt.impose_upper_bound_sum(transformed_params, upper_bound), upper_bound)
+
+                diffs = result - transformed_params
+                max_abs_diff = np.amax(np.abs(diffs))
+                self.assertAlmostEqual(0.0, max_abs_diff, delta=10 ** (-10))
+
+
+if __name__ == '__main__':
+    unittest.main()

computils-0.0.1/src/tests/test_utils.py

@@ -0,0 +1,12 @@
+"This module collects functionality for testing. "
+
+import numpy as np
+from computils import FloatOrArray
+
+
+def compute_max_abs_diff(expected: np.ndarray, actual: np.ndarray) -> float:
+    return float(np.amax(compute_abs_diff(expected, actual)))
+
+
+def compute_abs_diff(expected: FloatOrArray, actual: FloatOrArray) -> FloatOrArray:
+    return np.abs(actual - expected)