diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..076b992
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,11 @@
+[flake8]
+exclude =
+    .git,
+    __pycache__,
+    build,
+    dist,
+    doc/source/conf.py
+max-line-length = 115
+# Ignore some style 'errors' produced while formatting by 'black'
+# https://black.readthedocs.io/en/stable/guides/using_black_with_other_tools.html#labels-why-pycodestyle-warnings
+extend-ignore = E203
\ No newline at end of file
diff --git a/diffpy/snmf/__init__.py b/diffpy/snmf/__init__.py
index 0fd5168..9e9f1b6 100644
--- a/diffpy/snmf/__init__.py
+++ b/diffpy/snmf/__init__.py
@@ -17,9 +17,9 @@
 """
 
 # obtain version information
-__version__ = '0.0.1'
+__version__ = "0.0.1"
 
 # top-level import
-#from diffpy.snmf.pdfmorph_api import pdfmorph, morph_default_config, plot_morph
+# from diffpy.snmf.pdfmorph_api import pdfmorph, morph_default_config, plot_morph
 
 # End of file
diff --git a/diffpy/snmf/containers.py b/diffpy/snmf/containers.py
index e25b8d5..947b07a 100644
--- a/diffpy/snmf/containers.py
+++ b/diffpy/snmf/containers.py
@@ -40,8 +40,9 @@ def apply_stretch(self, m):
           stretching operation, and one vector is the second derivative of the stretching operation.
         """
         normalized_grid = np.arange(len(self.grid))
-        func = lambda stretching_factor: np.interp(normalized_grid / stretching_factor, normalized_grid, self.iq,
-                                                   left=0, right=0)
+        func = lambda stretching_factor: np.interp(
+            normalized_grid / stretching_factor, normalized_grid, self.iq, left=0, right=0
+        )
         derivative_func = numdifftools.Derivative(func)
         second_derivative_func = numdifftools.Derivative(derivative_func)
 
@@ -49,8 +50,11 @@ def apply_stretch(self, m):
         stretched_component_gra = derivative_func(self.stretching_factors[m])
         stretched_component_hess = second_derivative_func(self.stretching_factors[m])
 
-        return np.asarray(stretched_component), np.asarray(stretched_component_gra), np.asarray(
-            stretched_component_hess)
+        return (
+            np.asarray(stretched_component),
+            np.asarray(stretched_component_gra),
+            np.asarray(stretched_component_hess),
+        )
 
     def apply_weight(self, m, stretched_component=None):
         """Applies as weight factor to a component signal.
diff --git a/diffpy/snmf/io.py b/diffpy/snmf/io.py
index 6063569..7132d70 100644
--- a/diffpy/snmf/io.py
+++ b/diffpy/snmf/io.py
@@ -42,11 +42,21 @@ def initialize_variables(data_input, number_of_components, data_type, sparsity=1
     signal_length = data_input.shape[0]
     number_of_signals = data_input.shape[1]
 
-    diagonals = [np.ones(number_of_signals - 2), -2 * np.ones(number_of_signals - 2), np.ones(number_of_signals - 2)]
-    smoothness_term = .25 * scipy.sparse.diags(diagonals, [0, 1, 2], shape=(number_of_signals - 2, number_of_signals))
+    diagonals = [
+        np.ones(number_of_signals - 2),
+        -2 * np.ones(number_of_signals - 2),
+        np.ones(number_of_signals - 2),
+    ]
+    smoothness_term = 0.25 * scipy.sparse.diags(
+        diagonals, [0, 1, 2], shape=(number_of_signals - 2, number_of_signals)
+    )
 
     hessian_helper_matrix = scipy.sparse.block_diag([smoothness_term.T @ smoothness_term] * number_of_components)
-    sequence = np.arange(number_of_signals * number_of_components).reshape(number_of_components, number_of_signals).T.flatten()
+    sequence = (
+        np.arange(number_of_signals * number_of_components)
+        .reshape(number_of_components, number_of_signals)
+        .T.flatten()
+    )
     hessian_helper_matrix = hessian_helper_matrix[sequence, :][:, sequence]
 
     return {
@@ -57,7 +67,7 @@ def initialize_variables(data_input, number_of_components, data_type, sparsity=1
         "smoothness": smoothness,
         "sparsity": sparsity,
         "smoothness_term": smoothness_term,
-        "hessian_helper_matrix": hessian_helper_matrix
+        "hessian_helper_matrix": hessian_helper_matrix,
     }
 
 
diff --git a/diffpy/snmf/optimizers.py b/diffpy/snmf/optimizers.py
index 722c102..8c94c58 100644
--- a/diffpy/snmf/optimizers.py
+++ b/diffpy/snmf/optimizers.py
@@ -20,7 +20,7 @@ def get_weights(stretched_component_gram_matrix, linear_coefficient, lower_bound
       Has length C.
 
     lower_bound: 1d array like
-      The lower bound on the values of the output weights. Has the same dimensions of the function output. Each 
+      The lower bound on the values of the output weights. Has the same dimensions of the function output. Each
       element in 'lower_bound' determines the minimum value the corresponding element in the function output may take.
 
     upper_bound: 1d array like
@@ -43,8 +43,9 @@ def get_weights(stretched_component_gram_matrix, linear_coefficient, lower_bound
     solution_variable = cvxpy.Variable(problem_size)
 
     objective = cvxpy.Minimize(
-        linear_coefficient.T @ solution_variable + 0.5 * cvxpy.quad_form(solution_variable,
-                                                                         stretched_component_gram_matrix))
+        linear_coefficient.T @ solution_variable
+        + 0.5 * cvxpy.quad_form(solution_variable, stretched_component_gram_matrix)
+    )
     constraints = [lower_bound <= solution_variable, solution_variable <= upper_bound]
 
     cvxpy.Problem(objective, constraints).solve()
diff --git a/diffpy/snmf/stretchednmfapp.py b/diffpy/snmf/stretchednmfapp.py
index 067d527..7feb5ce 100644
--- a/diffpy/snmf/stretchednmfapp.py
+++ b/diffpy/snmf/stretchednmfapp.py
@@ -5,25 +5,47 @@
 from diffpy.snmf.containers import ComponentSignal
 from diffpy.snmf.io import load_input_signals, initialize_variables
 
-ALLOWED_DATA_TYPES = ['powder_diffraction', 'pd', 'pair_distribution_function', 'pdf']
+ALLOWED_DATA_TYPES = ["powder_diffraction", "pd", "pair_distribution_function", "pdf"]
 
 
 def create_parser():
     parser = argparse.ArgumentParser(
-        prog="stretched_nmf",
-        description="Stretched Nonnegative Matrix Factorization"
+        prog="stretched_nmf", description="Stretched Nonnegative Matrix Factorization"
     )
-    parser.add_argument('-i', '--input-directory', type=str, default=None,
-                        help="Directory containing experimental data. Defaults to current working directory.")
-    parser.add_argument('-o', '--output-directory', type=str,
-                        help="The directory where the results will be written. Defaults to '<input_directory>/snmf_results'.")
-    parser.add_argument('t', '--data-type', type=str, default=None, choices=ALLOWED_DATA_TYPES,
-                        help="The type of the experimental data.")
-    parser.add_argument('-l', '--lift-factor', type=float, default=1,
-                        help="The lifting factor. Data will be lifted by lifted_data = data + abs(min(data) * lift). Default is 1.")
-    parser.add_argument('number-of-components', type=int,
-                        help="The number of component signals for the NMF decomposition. Must be an integer greater than 0")
-    parser.add_argument('-v', '--version', action='version', help='Print the software version number')
+    parser.add_argument(
+        "-i",
+        "--input-directory",
+        type=str,
+        default=None,
+        help="Directory containing experimental data. Defaults to current working directory.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-directory",
+        type=str,
+        help="The directory where the results will be written. Defaults to '<input_directory>/snmf_results'.",
+    )
+    parser.add_argument(
+        "t",
+        "--data-type",
+        type=str,
+        default=None,
+        choices=ALLOWED_DATA_TYPES,
+        help="The type of the experimental data.",
+    )
+    parser.add_argument(
+        "-l",
+        "--lift-factor",
+        type=float,
+        default=1,
+        help="The lifting factor. Data will be lifted by lifted_data = data + abs(min(data) * lift). Default is 1.",
+    )
+    parser.add_argument(
+        "number-of-components",
+        type=int,
+        help="The number of component signals for the NMF decomposition. Must be an integer greater than 0",
+    )
+    parser.add_argument("-v", "--version", action="version", help="Print the software version number")
     args = parser.parse_args()
     return args
 
@@ -35,5 +57,5 @@ def main():
     grid, input_data = load_input_signals(args.input_directory)
     lifted_input_data = lift_data(input_data, args.lift_factor)
     variables = initialize_variables(lifted_input_data, args.number_of_components, args.data_type)
-    components = initialize_components(variables['number_of_components'], variables['number_of_signals'], grid)
+    components = initialize_components(variables["number_of_components"], variables["number_of_signals"], grid)
     return components
diff --git a/diffpy/snmf/subroutines.py b/diffpy/snmf/subroutines.py
index c0052bb..e3acafb 100644
--- a/diffpy/snmf/subroutines.py
+++ b/diffpy/snmf/subroutines.py
@@ -170,11 +170,15 @@ def update_weights(components, data_input, method=None):
         stretched_components = np.zeros((signal_length, number_of_components))
         for i, component in enumerate(components):
             stretched_components[:, i] = component.apply_stretch(signal)[0]
-        if method == 'align':
+        if method == "align":
             weights = lsqnonneg(stretched_components, data_input[:, signal])
         else:
-            weights = get_weights(stretched_components.T @ stretched_components,
-                                  -stretched_components.T @ data_input[:, signal], 0, 1)
+            weights = get_weights(
+                stretched_components.T @ stretched_components,
+                -stretched_components.T @ data_input[:, signal],
+                0,
+                1,
+            )
             weight_matrix[:, signal] = weights
     return weight_matrix
 
@@ -236,13 +240,16 @@ def initialize_arrays(number_of_components, number_of_moments, signal_length):
     """
     component_matrix_guess = np.random.rand(signal_length, number_of_components)
     weight_matrix_guess = np.random.rand(number_of_components, number_of_moments)
-    stretching_matrix_guess = np.ones(number_of_components, number_of_moments) + np.random.randn(number_of_components,
-                                                                                                 number_of_moments) * 1e-3
+    stretching_matrix_guess = (
+        np.ones(number_of_components, number_of_moments)
+        + np.random.randn(number_of_components, number_of_moments) * 1e-3
+    )
     return component_matrix_guess, weight_matrix_guess, stretching_matrix_guess
 
 
-def objective_function(residual_matrix, stretching_factor_matrix, smoothness, smoothness_term, component_matrix,
-                       sparsity):
+def objective_function(
+    residual_matrix, stretching_factor_matrix, smoothness, smoothness_term, component_matrix, sparsity
+):
     """Defines the objective function of the algorithm and returns its value.
 
     Calculates the value of '(||residual_matrix||_F) ** 2 + smoothness * (||smoothness_term *
@@ -284,8 +291,11 @@ def objective_function(residual_matrix, stretching_factor_matrix, smoothness, sm
     residual_matrix = np.asarray(residual_matrix)
     stretching_factor_matrix = np.asarray(stretching_factor_matrix)
     component_matrix = np.asarray(component_matrix)
-    return .5 * np.linalg.norm(residual_matrix, 'fro') ** 2 + .5 * smoothness * np.linalg.norm(
-        smoothness_term @ stretching_factor_matrix.T, 'fro') ** 2 + sparsity * np.sum(np.sqrt(component_matrix))
+    return (
+        0.5 * np.linalg.norm(residual_matrix, "fro") ** 2
+        + 0.5 * smoothness * np.linalg.norm(smoothness_term @ stretching_factor_matrix.T, "fro") ** 2
+        + sparsity * np.sum(np.sqrt(component_matrix))
+    )
 
 
 def get_stretched_component(stretching_factor, component, signal_length):
@@ -325,11 +335,23 @@ def stretched_component_func(stretching_factor):
     stretched_component_gra = derivative_func(stretching_factor)
     stretched_component_hess = second_derivative_func(stretching_factor)
 
-    return np.asarray(stretched_component), np.asarray(stretched_component_gra), np.asarray(stretched_component_hess)
-
-
-def update_weights_matrix(component_amount, signal_length, stretching_factor_matrix, component_matrix, data_input,
-                          moment_amount, weights_matrix, method):
+    return (
+        np.asarray(stretched_component),
+        np.asarray(stretched_component_gra),
+        np.asarray(stretched_component_hess),
+    )
+
+
+def update_weights_matrix(
+    component_amount,
+    signal_length,
+    stretching_factor_matrix,
+    component_matrix,
+    data_input,
+    moment_amount,
+    weights_matrix,
+    method,
+):
     """Update the weight factors matrix.
 
     Parameters
@@ -376,21 +398,25 @@ def update_weights_matrix(component_amount, signal_length, stretching_factor_mat
     for i in range(moment_amount):
         stretched_components = np.zeros((signal_length, component_amount))
         for n in range(component_amount):
-            stretched_components[:, n] = get_stretched_component(stretching_factor_matrix[n, i], component_matrix[:, n],
-                                                                 signal_length)[0]
-        if method == 'align':
+            stretched_components[:, n] = get_stretched_component(
+                stretching_factor_matrix[n, i], component_matrix[:, n], signal_length
+            )[0]
+        if method == "align":
             weight = lsqnonneg(stretched_components[0:signal_length, :], data_input[0:signal_length, i])
         else:
             weight = get_weights(
                 stretched_components[0:signal_length, :].T @ stretched_components[0:signal_length, :],
                 -1 * stretched_components[0:signal_length, :].T @ data_input[0:signal_length, i],
-                0, 1)
+                0,
+                1,
+            )
         weights_matrix[:, i] = weight
     return weights_matrix
 
 
-def get_residual_matrix(component_matrix, weights_matrix, stretching_matrix, data_input, moment_amount,
-                        component_amount, signal_length):
+def get_residual_matrix(
+    component_matrix, weights_matrix, stretching_matrix, data_input, moment_amount, component_amount, signal_length
+):
     """Obtains the residual matrix between the experimental data and calculated data
 
     Calculates the difference between the experimental data and the reconstructed experimental data created from the
@@ -442,9 +468,11 @@ def get_residual_matrix(component_matrix, weights_matrix, stretching_matrix, dat
     for m in range(moment_amount):
         residual = residual_matrx[:, m]
         for k in range(component_amount):
-            residual = residual + weights_matrix[k, m] * get_stretched_component(stretching_matrix[k, m],
-                                                                                 component_matrix[:, k], signal_length)[
-                0]
+            residual = (
+                residual
+                + weights_matrix[k, m]
+                * get_stretched_component(stretching_matrix[k, m], component_matrix[:, k], signal_length)[0]
+            )
         residual_matrx[:, m] = residual
     return residual_matrx
 
diff --git a/diffpy/snmf/tests/test_containers.py b/diffpy/snmf/tests/test_containers.py
index a80a876..2ccb036 100644
--- a/diffpy/snmf/tests/test_containers.py
+++ b/diffpy/snmf/tests/test_containers.py
@@ -2,32 +2,84 @@
 import numpy as np
 from diffpy.snmf.containers import ComponentSignal
 
-tas = [([np.arange(10), 3, 0, [6.55, .357, 8.49, 9.33, 6.78, 7.57, 7.43, 3.92, 6.55, 1.71], .25],
-        [[6.55, 6.78, 6.55, 0, 0, 0, 0, 0, 0, 0], [0, 14.07893122, 35.36478086, 0, 0, 0, 0, 0, 0, 0],
-         [0, -19.92049156, 11.6931482, 0, 0, 0, 0, 0, 0, 0]]),
-       ([np.arange(5), 10, 0, [-11.47, -10.688, -8.095, -29.44, 14.38], 1.25],
-        [[-11.47, -10.8444, -9.1322, -16.633, -20.6760], [0, -.50048, -3.31904, 40.9824, -112.1792],
-         [0, .800768, 5.310464, -65.57184, 179.48672]]),
-       ([np.arange(5), 2, 0, [-11.47, -10.688, -8.095, -29.44, 14.38], .88],
-        [[-11.47, -10.3344, -13.9164, -11.5136, 0], [0, -3.3484, 55.1265, -169.7572, 0],
-         [0, 7.609997, -125.2876, 385.81189, 0]]),
-       ([np.arange(10), 1, 2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], .88],
-        [[1, 2.1364, 3.2727, 4.4091, 5.5455, 6.6818, 7.8182, 8.9545, 0, 0],
-         [0, -1.29, -2.58, -3.87, -5.165, -6.45, -7.74, -9.039, 0, 0],
-         [0, 2.93, 5.869, 8.084, 11.739, 14.674, 17.608, 20.5437, 0, 0]]),
-       ([np.arange(14), 100, 3,
-         [-2.9384, -1.4623, -2.0913, 4.6304, -1.2127, 1.4737, -0.3791, 1.7506, -1.5068, -2.7625, .9617, -.3494, -.3862,
-          2.7960], .55], [[-2.9384, -1.9769, 0.9121, .6314, .8622, -2.4239, -.2302, 1.9281, 0, 0, 0, 0, 0, 0],
-                          [0, 2.07933, 38.632, 18.3748, 43.07305, -61.557, 26.005, -73.637, 0, 0, 0, 0, 0, 0],
-                          [0, -7.56, -140.480, -66.81, -156.6293, 223.84, -94.564, 267.7734, 0, 0, 0, 0, 0, 0]]),
-       ([np.arange(11), 20, 4, [0, .25, .5, .75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5], .987],
-        [[0, .2533, .5066, .7599, 1.0132, 1.2665, 1.5198, 1.7730, 2.0263, 2.2796, 0],
-         [0, -.2566, -.5132, -.7699, -1.0265, -1.2831, -1.5398, -1.7964, -2.0530, -2.3097, 0],
-         [0, .5200, 1.0400, 1.56005, 2.08007, 2.6000, 3.1201, 3.6401, 4.1601, 4.6801, 0]]),
-       ([np.arange(9), 15, 3, [-1, -2, -3, -4, -5, -6, -7, -8, -9], -0.4],
-        [[-1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]])
-       ]
-@pytest.mark.parametrize('tas', tas)
+tas = [
+    (
+        [np.arange(10), 3, 0, [6.55, 0.357, 8.49, 9.33, 6.78, 7.57, 7.43, 3.92, 6.55, 1.71], 0.25],
+        [
+            [6.55, 6.78, 6.55, 0, 0, 0, 0, 0, 0, 0],
+            [0, 14.07893122, 35.36478086, 0, 0, 0, 0, 0, 0, 0],
+            [0, -19.92049156, 11.6931482, 0, 0, 0, 0, 0, 0, 0],
+        ],
+    ),
+    (
+        [np.arange(5), 10, 0, [-11.47, -10.688, -8.095, -29.44, 14.38], 1.25],
+        [
+            [-11.47, -10.8444, -9.1322, -16.633, -20.6760],
+            [0, -0.50048, -3.31904, 40.9824, -112.1792],
+            [0, 0.800768, 5.310464, -65.57184, 179.48672],
+        ],
+    ),
+    (
+        [np.arange(5), 2, 0, [-11.47, -10.688, -8.095, -29.44, 14.38], 0.88],
+        [
+            [-11.47, -10.3344, -13.9164, -11.5136, 0],
+            [0, -3.3484, 55.1265, -169.7572, 0],
+            [0, 7.609997, -125.2876, 385.81189, 0],
+        ],
+    ),
+    (
+        [np.arange(10), 1, 2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0.88],
+        [
+            [1, 2.1364, 3.2727, 4.4091, 5.5455, 6.6818, 7.8182, 8.9545, 0, 0],
+            [0, -1.29, -2.58, -3.87, -5.165, -6.45, -7.74, -9.039, 0, 0],
+            [0, 2.93, 5.869, 8.084, 11.739, 14.674, 17.608, 20.5437, 0, 0],
+        ],
+    ),
+    (
+        [
+            np.arange(14),
+            100,
+            3,
+            [
+                -2.9384,
+                -1.4623,
+                -2.0913,
+                4.6304,
+                -1.2127,
+                1.4737,
+                -0.3791,
+                1.7506,
+                -1.5068,
+                -2.7625,
+                0.9617,
+                -0.3494,
+                -0.3862,
+                2.7960,
+            ],
+            0.55,
+        ],
+        [
+            [-2.9384, -1.9769, 0.9121, 0.6314, 0.8622, -2.4239, -0.2302, 1.9281, 0, 0, 0, 0, 0, 0],
+            [0, 2.07933, 38.632, 18.3748, 43.07305, -61.557, 26.005, -73.637, 0, 0, 0, 0, 0, 0],
+            [0, -7.56, -140.480, -66.81, -156.6293, 223.84, -94.564, 267.7734, 0, 0, 0, 0, 0, 0],
+        ],
+    ),
+    (
+        [np.arange(11), 20, 4, [0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5], 0.987],
+        [
+            [0, 0.2533, 0.5066, 0.7599, 1.0132, 1.2665, 1.5198, 1.7730, 2.0263, 2.2796, 0],
+            [0, -0.2566, -0.5132, -0.7699, -1.0265, -1.2831, -1.5398, -1.7964, -2.0530, -2.3097, 0],
+            [0, 0.5200, 1.0400, 1.56005, 2.08007, 2.6000, 3.1201, 3.6401, 4.1601, 4.6801, 0],
+        ],
+    ),
+    (
+        [np.arange(9), 15, 3, [-1, -2, -3, -4, -5, -6, -7, -8, -9], -0.4],
+        [[-1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]],
+    ),
+]
+
+
+@pytest.mark.parametrize("tas", tas)
 def test_apply_stretch(tas):
     component = ComponentSignal(tas[0][0], tas[0][1], tas[0][2])
     component.iq = tas[0][3]
@@ -37,14 +89,17 @@ def test_apply_stretch(tas):
     np.testing.assert_allclose(actual, expected, rtol=1e-01)
 
 
-taw = [([np.arange(5), 2, 0, [0, 1, 2, 3, 4], .5], [0, .5, 1, 1.5, 2]),
-       ([np.arange(5), 20, 2, [0, -1, -2, -3, -4], .25], [0, -.25, -.5, -.75, -1]),
-       ([np.arange(40), 200, 4, np.arange(0, 10, .25), .3], np.arange(0, 10, .25) * .3),
-       ([np.arange(1), 10, 2, [10.5, 11.5, -10.5], 0], [0, 0, 0]),
-       ([[-12, -10, -15], 5, 2, [-.5, -1, -1.2], .9], [-.45, -.9, -1.08]),
-       ([[-12, -10, -15], 5, 2, [0, 0, 0], .9], [0, 0, 0])
-       ]
-@pytest.mark.parametrize('taw', taw)
+taw = [
+    ([np.arange(5), 2, 0, [0, 1, 2, 3, 4], 0.5], [0, 0.5, 1, 1.5, 2]),
+    ([np.arange(5), 20, 2, [0, -1, -2, -3, -4], 0.25], [0, -0.25, -0.5, -0.75, -1]),
+    ([np.arange(40), 200, 4, np.arange(0, 10, 0.25), 0.3], np.arange(0, 10, 0.25) * 0.3),
+    ([np.arange(1), 10, 2, [10.5, 11.5, -10.5], 0], [0, 0, 0]),
+    ([[-12, -10, -15], 5, 2, [-0.5, -1, -1.2], 0.9], [-0.45, -0.9, -1.08]),
+    ([[-12, -10, -15], 5, 2, [0, 0, 0], 0.9], [0, 0, 0]),
+]
+
+
+@pytest.mark.parametrize("taw", taw)
 def test_apply_weight(taw):
     component = ComponentSignal(taw[0][0], taw[0][1], taw[0][2])
     component.iq = np.array(taw[0][3])
diff --git a/diffpy/snmf/tests/test_factorizers.py b/diffpy/snmf/tests/test_factorizers.py
index 65aa0ac..a0c4546 100644
--- a/diffpy/snmf/tests/test_factorizers.py
+++ b/diffpy/snmf/tests/test_factorizers.py
@@ -4,17 +4,17 @@
 from diffpy.snmf.factorizers import lsqnonneg
 
 tl = [
-    ([[[1, 0], [1, 0], [0, 1]], [2, 1, 1]], [1.5, 1.]),
+    ([[[1, 0], [1, 0], [0, 1]], [2, 1, 1]], [1.5, 1.0]),
     ([[[2, 3], [1, 2], [0, 0]], [7, 7, 2]], [0, 2.6923]),
-    ([[[3, 2, 4, 1]], [3.2]], [0, 0, .8, 0]),
-    ([[[-.4, 0], [0, 0], [-9, -18]], [-2, -3, -4.9]], [.5532, 0]),
-    ([[[-.1, -.2], [-.8, -.9]], [0, 0]], [0, 0]),
+    ([[[3, 2, 4, 1]], [3.2]], [0, 0, 0.8, 0]),
+    ([[[-0.4, 0], [0, 0], [-9, -18]], [-2, -3, -4.9]], [0.5532, 0]),
+    ([[[-0.1, -0.2], [-0.8, -0.9]], [0, 0]], [0, 0]),
     ([[[0, 0], [0, 0]], [10, 10]], [0, 0]),
-    ([[[2], [1], [-4], [-.3]], [6, 4, .33, -5]], 0.767188240872451),
+    ([[[2], [1], [-4], [-0.3]], [6, 4, 0.33, -5]], 0.767188240872451),
 ]
 
 
-@pytest.mark.parametrize('tl', tl)
+@pytest.mark.parametrize("tl", tl)
 def test_lsqnonneg(tl):
     actual = lsqnonneg(tl[0][0], tl[0][1])
     expected = tl[1]
diff --git a/diffpy/snmf/tests/test_optimizers.py b/diffpy/snmf/tests/test_optimizers.py
index e686250..25d90e7 100644
--- a/diffpy/snmf/tests/test_optimizers.py
+++ b/diffpy/snmf/tests/test_optimizers.py
@@ -5,15 +5,15 @@
     ([[[1, 0], [0, 1]], [1, 1], [0, 0], [1, 1]], [0, 0]),
     ([[[1, 0], [0, 1]], [1, 1], -1, 1], [-1, -1]),
     ([[[1.75, 0], [0, 1.5]], [1, 1.2], -1, 1], [-0.571428571428571, -0.8]),
-    ([[[.75, .2], [.2, .75]], [-.1, -.2], -1, 1], [0.066985645933014, 0.248803827751196]),
+    ([[[0.75, 0.2], [0.2, 0.75]], [-0.1, -0.2], -1, 1], [0.066985645933014, 0.248803827751196]),
     ([[[2, -1, 0], [-1, 2, -1], [0, -1, 2]], [1, 1, 1], -10, 12], [-1.5, -2, -1.5]),
     ([[[2, -1, 0], [-1, 2, -1], [0, -1, 2]], [1, -1, -1], -10, 12], [0, 1, 1]),
-    ([[[4, 0, 0, 0], [0, 3, 0, 0], [0, 0, 2, 0], [0, 0, 0, 1]], [-2, -3, -4, -1], 0, 1000], [.5, 1, 2, 1]),
+    ([[[4, 0, 0, 0], [0, 3, 0, 0], [0, 0, 2, 0], [0, 0, 0, 1]], [-2, -3, -4, -1], 0, 1000], [0.5, 1, 2, 1]),
 ]
 
 
-@pytest.mark.parametrize('tm', tm)
+@pytest.mark.parametrize("tm", tm)
 def test_get_weights(tm):
     expected = tm[1]
     actual = get_weights(tm[0][0], tm[0][1], tm[0][2], tm[0][3])
-    assert (actual == pytest.approx(expected, rel=1e-4, abs=1e-6))
+    assert actual == pytest.approx(expected, rel=1e-4, abs=1e-6)
diff --git a/diffpy/snmf/tests/test_polynomials.py b/diffpy/snmf/tests/test_polynomials.py
index a75baca..6078b26 100644
--- a/diffpy/snmf/tests/test_polynomials.py
+++ b/diffpy/snmf/tests/test_polynomials.py
@@ -15,7 +15,7 @@
     ([-9, 3], 2.8169),
     ([[2, 2], 2], [0, 0]),
     ([[[2, 2], [2, 2]], 2], [[0, 0], [0, 0]]),
-    ([[[[3, 2], [-2, -2], [100, 0]]], 2], [[[0, 0], [0, 0], [0, 0]]])
+    ([[[[3, 2], [-2, -2], [100, 0]]], 2], [[[0, 0], [0, 0], [0, 0]]]),
 ]
 
 
diff --git a/diffpy/snmf/tests/test_subroutines.py b/diffpy/snmf/tests/test_subroutines.py
index 1a93971..bdb721f 100644
--- a/diffpy/snmf/tests/test_subroutines.py
+++ b/diffpy/snmf/tests/test_subroutines.py
@@ -1,13 +1,25 @@
 import pytest
 import numpy as np
 from diffpy.snmf.containers import ComponentSignal
-from diffpy.snmf.subroutines import objective_function, get_stretched_component, reconstruct_data, get_residual_matrix, \
-    update_weights_matrix, initialize_arrays, lift_data, initialize_components, construct_stretching_matrix, \
-    construct_component_matrix, construct_weight_matrix, update_weights, reconstruct_signal
+from diffpy.snmf.subroutines import (
+    objective_function,
+    get_stretched_component,
+    reconstruct_data,
+    get_residual_matrix,
+    update_weights_matrix,
+    initialize_arrays,
+    lift_data,
+    initialize_components,
+    construct_stretching_matrix,
+    construct_component_matrix,
+    construct_weight_matrix,
+    update_weights,
+    reconstruct_signal,
+)
 
 to = [
     ([[[1, 2], [3, 4]], [[5, 6], [7, 8]], 1e11, [[1, 2], [3, 4]], [[1, 2], [3, 4]], 1], 2.574e14),
-    ([[[11, 2], [31, 4]], [[5, 63], [7, 18]], .001, [[21, 2], [3, 4]], [[11, 22], [3, 40]], 1], 650.4576),
+    ([[[11, 2], [31, 4]], [[5, 63], [7, 18]], 0.001, [[21, 2], [3, 4]], [[11, 22], [3, 40]], 1], 650.4576),
     ([[[1, 2], [3, 4]], [[5, 6], [7, 8]], 1e11, [[1, 2], [3, 4]], [[1, 2], [3, 4]], 0], 2.574e14),
 ]
 
@@ -20,31 +32,77 @@ def test_objective_function(to):
 
 
 tgso = [
-    ([.25, [6.55, .357, 8.49, 9.33, 6.78, 7.57, 7.43, 3.92, 6.55, 1.71], 10], (
-        [6.55, 6.78, 6.55, 0, 0, 0, 0, 0, 0, 0], [0, 14.07893122, 35.36478086, 0, 0, 0, 0, 0, 0, 0],
-        [0, -19.92049156, 11.6931482, 0, 0, 0, 0, 0, 0, 0])),
-    ([1.25, [-11.47, -10.688, -8.095, -29.44, 14.38], 5], (
-        [-11.47, -10.8444, -9.1322, -16.633, -20.6760], [0, -.50048, -3.31904, 40.9824, -112.1792],
-        [0, .800768, 5.310464, -65.57184, 179.48672])),
-    ([.88, [-11.47, -10.688, -8.095, -29.44, 14.38], 5], (
-        [-11.47, -10.3344, -13.9164, -11.5136, 0], [0, -3.3484, 55.1265, -169.7572, 0],
-        [0, 7.609997, -125.2876, 385.81189, 0])),
-    (
-        [.88, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10],
-        ([1, 2.1364, 3.2727, 4.4091, 5.5455, 6.6818, 7.8182, 8.9545, 0, 0],
-         [0, -1.29, -2.58, -3.87, -5.165, -6.45, -7.74, -9.039, 0, 0],
-         [0, 2.93, 5.869, 8.084, 11.739, 14.674, 17.608, 20.5437, 0, 0])),
-    ([.55,
-      [-2.9384, -1.4623, -2.0913, 4.6304, -1.2127, 1.4737, -0.3791, 1.7506, -1.5068, -2.7625, .9617, -.3494, -.3862,
-       2.7960], 14], ([-2.9384, -1.9769, 0.9121, .6314, .8622, -2.4239, -.2302, 1.9281, 0, 0, 0, 0, 0, 0],
-                      [0, 2.07933, 38.632, 18.3748, 43.07305, -61.557, 26.005, -73.637, 0, 0, 0, 0, 0, 0],
-                      [0, -7.56, -140.480, -66.81, -156.6293, 223.84, -94.564, 267.7734, 0, 0, 0, 0, 0, 0])),
-    ([.987, [0, .25, .5, .75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5], 11],
-     ([0, .2533, .5066, .7599, 1.0132, 1.2665, 1.5198, 1.7730, 2.0263, 2.2796, 0],
-      [0, -.2566, -.5132, -.7699, -1.0265, -1.2831, -1.5398, -1.7964, -2.0530, -2.3097, 0],
-      [0, .5200, 1.0400, 1.56005, 2.08007, 2.6000, 3.1201, 3.6401, 4.1601, 4.6801, 0])),
-    ([-0.4, [-1, -2, -3, -4, -5, -6, -7, -8, -9], 9],
-     ([-1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]))
+    (
+        [0.25, [6.55, 0.357, 8.49, 9.33, 6.78, 7.57, 7.43, 3.92, 6.55, 1.71], 10],
+        (
+            [6.55, 6.78, 6.55, 0, 0, 0, 0, 0, 0, 0],
+            [0, 14.07893122, 35.36478086, 0, 0, 0, 0, 0, 0, 0],
+            [0, -19.92049156, 11.6931482, 0, 0, 0, 0, 0, 0, 0],
+        ),
+    ),
+    (
+        [1.25, [-11.47, -10.688, -8.095, -29.44, 14.38], 5],
+        (
+            [-11.47, -10.8444, -9.1322, -16.633, -20.6760],
+            [0, -0.50048, -3.31904, 40.9824, -112.1792],
+            [0, 0.800768, 5.310464, -65.57184, 179.48672],
+        ),
+    ),
+    (
+        [0.88, [-11.47, -10.688, -8.095, -29.44, 14.38], 5],
+        (
+            [-11.47, -10.3344, -13.9164, -11.5136, 0],
+            [0, -3.3484, 55.1265, -169.7572, 0],
+            [0, 7.609997, -125.2876, 385.81189, 0],
+        ),
+    ),
+    (
+        [0.88, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10],
+        (
+            [1, 2.1364, 3.2727, 4.4091, 5.5455, 6.6818, 7.8182, 8.9545, 0, 0],
+            [0, -1.29, -2.58, -3.87, -5.165, -6.45, -7.74, -9.039, 0, 0],
+            [0, 2.93, 5.869, 8.084, 11.739, 14.674, 17.608, 20.5437, 0, 0],
+        ),
+    ),
+    (
+        [
+            0.55,
+            [
+                -2.9384,
+                -1.4623,
+                -2.0913,
+                4.6304,
+                -1.2127,
+                1.4737,
+                -0.3791,
+                1.7506,
+                -1.5068,
+                -2.7625,
+                0.9617,
+                -0.3494,
+                -0.3862,
+                2.7960,
+            ],
+            14,
+        ],
+        (
+            [-2.9384, -1.9769, 0.9121, 0.6314, 0.8622, -2.4239, -0.2302, 1.9281, 0, 0, 0, 0, 0, 0],
+            [0, 2.07933, 38.632, 18.3748, 43.07305, -61.557, 26.005, -73.637, 0, 0, 0, 0, 0, 0],
+            [0, -7.56, -140.480, -66.81, -156.6293, 223.84, -94.564, 267.7734, 0, 0, 0, 0, 0, 0],
+        ),
+    ),
+    (
+        [0.987, [0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5], 11],
+        (
+            [0, 0.2533, 0.5066, 0.7599, 1.0132, 1.2665, 1.5198, 1.7730, 2.0263, 2.2796, 0],
+            [0, -0.2566, -0.5132, -0.7699, -1.0265, -1.2831, -1.5398, -1.7964, -2.0530, -2.3097, 0],
+            [0, 0.5200, 1.0400, 1.56005, 2.08007, 2.6000, 3.1201, 3.6401, 4.1601, 4.6801, 0],
+        ),
+    ),
+    (
+        [-0.4, [-1, -2, -3, -4, -5, -6, -7, -8, -9], 9],
+        ([-1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]),
+    ),
 ]
 
 
@@ -55,139 +113,279 @@ def test_get_stretched_component(tgso):
     np.testing.assert_allclose(actual, expected, rtol=1e-01)
 
 
-tuwm = [([2, 2, [[.5, .6], [.7, .8]], [[1, 2], [4, 8]], [[1.6, 2.8], [5, 8.8]], 2, [[.78, .12], [.5, .5]], None],
-         [[0, 1], [1, 1]]),
-        ([2, 3, [[.5], [.5]], [[1, 2.5], [1.5, 3], [2, 3.5]], [[1, 2], [3, 4], [5, 6]], 1, [[.5], [.5]], None],
-         [[1], [.1892]]),
-        ([2, 3, [[.5, .6, .7], [.5, .6, .7]], [[1, 2.5], [1.5, 3], [2, 3.5]], [[1, 2, 3], [3, 4, 5], [5, 6, 7]], 3,
-          [[.5, .45, .4], [.5, .45, .4]], None], [[1, 1, 1], [.1892, .5600, .938]]),
-        ([3, 3, [[.7, .8, .9], [.71, .72, .73], [.8, .85, .9]], [[-1, -2.7, -3], [-11, -6, -5.1], [0, -1, -.5]],
-          [[-2, -3, -4], [-9, -5, -5], [0, -2, -1]], 3, [[.9, .4, .5], [1, 0, .4], [0, 0, .98]], None],
-         [[1, .0651, 0], [.5848, .0381, .1857], [0, 1, 1]]),
-        ([2, 2, [[.5], [.5]], [[0, 0], [0, 0]], [[0, 0], [0, 0]], 1, [[.6], [.4]], 'align'], [[0], [0]]),
-        ([1, 3, [[.5, .3]], [[1], [1.1], [1.3]], [[1, 2], [2, 3], [3, 2]], 2, [[.6, .4]], None], [[1, 1]]),
-        ([2, 2, [[.5, .6], [.7, .8]], [[1, 2], [4, 8]], [[1.6, 2.8], [5, 8.8]], 2, [[.78, .12], [.5, .5]], 'align'],
-         [[0, 0], [1.0466, 1.46]]),
-        ([2, 3, [[.5], [.5]], [[1, 2.5], [1.5, 3], [2, 3.5]], [[1, 2], [3, 4], [5, 6]], 1, [[.5], [.5]], 'align'],
-         [[1.4], [0]]),
-        ([3, 3, [[.7, .8, .9], [.71, .72, .73], [.8, .85, .9]], [[-1, -2.7, -3], [-11, -6, -5.1], [0, -1, -.5]],
-          [[-2, -3, -4], [-9, -5, -5], [0, -2, -1]], 3, [[.9, .4, .5], [1, 0, .4], [0, 0, .98]], 'align'],
-         [[1.2605, .0552, 0], [.2723, 0, 0], [0, 1.0538, 1.1696]]),
-        ([2, 2, [[.5], [.5]], [[0, 0], [0, 0]], [[0, 0], [0, 0]], 1, [[.6], [.4]], 'align'], [[0], [0]]),
-        ([1, 3, [[.5, .3]], [[1], [1.1], [1.3]], [[1, 2], [2, 3], [3, 2]], 2, [[.6, .4]], 'align'], [[1.3383, 2]])
-        ]
+tuwm = [
+    (
+        [
+            2,
+            2,
+            [[0.5, 0.6], [0.7, 0.8]],
+            [[1, 2], [4, 8]],
+            [[1.6, 2.8], [5, 8.8]],
+            2,
+            [[0.78, 0.12], [0.5, 0.5]],
+            None,
+        ],
+        [[0, 1], [1, 1]],
+    ),
+    (
+        [2, 3, [[0.5], [0.5]], [[1, 2.5], [1.5, 3], [2, 3.5]], [[1, 2], [3, 4], [5, 6]], 1, [[0.5], [0.5]], None],
+        [[1], [0.1892]],
+    ),
+    (
+        [
+            2,
+            3,
+            [[0.5, 0.6, 0.7], [0.5, 0.6, 0.7]],
+            [[1, 2.5], [1.5, 3], [2, 3.5]],
+            [[1, 2, 3], [3, 4, 5], [5, 6, 7]],
+            3,
+            [[0.5, 0.45, 0.4], [0.5, 0.45, 0.4]],
+            None,
+        ],
+        [[1, 1, 1], [0.1892, 0.5600, 0.938]],
+    ),
+    (
+        [
+            3,
+            3,
+            [[0.7, 0.8, 0.9], [0.71, 0.72, 0.73], [0.8, 0.85, 0.9]],
+            [[-1, -2.7, -3], [-11, -6, -5.1], [0, -1, -0.5]],
+            [[-2, -3, -4], [-9, -5, -5], [0, -2, -1]],
+            3,
+            [[0.9, 0.4, 0.5], [1, 0, 0.4], [0, 0, 0.98]],
+            None,
+        ],
+        [[1, 0.0651, 0], [0.5848, 0.0381, 0.1857], [0, 1, 1]],
+    ),
+    ([2, 2, [[0.5], [0.5]], [[0, 0], [0, 0]], [[0, 0], [0, 0]], 1, [[0.6], [0.4]], "align"], [[0], [0]]),
+    ([1, 3, [[0.5, 0.3]], [[1], [1.1], [1.3]], [[1, 2], [2, 3], [3, 2]], 2, [[0.6, 0.4]], None], [[1, 1]]),
+    (
+        [
+            2,
+            2,
+            [[0.5, 0.6], [0.7, 0.8]],
+            [[1, 2], [4, 8]],
+            [[1.6, 2.8], [5, 8.8]],
+            2,
+            [[0.78, 0.12], [0.5, 0.5]],
+            "align",
+        ],
+        [[0, 0], [1.0466, 1.46]],
+    ),
+    (
+        [
+            2,
+            3,
+            [[0.5], [0.5]],
+            [[1, 2.5], [1.5, 3], [2, 3.5]],
+            [[1, 2], [3, 4], [5, 6]],
+            1,
+            [[0.5], [0.5]],
+            "align",
+        ],
+        [[1.4], [0]],
+    ),
+    (
+        [
+            3,
+            3,
+            [[0.7, 0.8, 0.9], [0.71, 0.72, 0.73], [0.8, 0.85, 0.9]],
+            [[-1, -2.7, -3], [-11, -6, -5.1], [0, -1, -0.5]],
+            [[-2, -3, -4], [-9, -5, -5], [0, -2, -1]],
+            3,
+            [[0.9, 0.4, 0.5], [1, 0, 0.4], [0, 0, 0.98]],
+            "align",
+        ],
+        [[1.2605, 0.0552, 0], [0.2723, 0, 0], [0, 1.0538, 1.1696]],
+    ),
+    ([2, 2, [[0.5], [0.5]], [[0, 0], [0, 0]], [[0, 0], [0, 0]], 1, [[0.6], [0.4]], "align"], [[0], [0]]),
+    ([1, 3, [[0.5, 0.3]], [[1], [1.1], [1.3]], [[1, 2], [2, 3], [3, 2]], 2, [[0.6, 0.4]], "align"], [[1.3383, 2]]),
+]
 
 
-@pytest.mark.parametrize('tuwm', tuwm)
+@pytest.mark.parametrize("tuwm", tuwm)
 def test_update_weights_matrix(tuwm):
-    actual = update_weights_matrix(tuwm[0][0], tuwm[0][1], tuwm[0][2], tuwm[0][3], tuwm[0][4], tuwm[0][5], tuwm[0][6],
-                                   tuwm[0][7])
+    actual = update_weights_matrix(
+        tuwm[0][0], tuwm[0][1], tuwm[0][2], tuwm[0][3], tuwm[0][4], tuwm[0][5], tuwm[0][6], tuwm[0][7]
+    )
     expected = tuwm[1]
-    np.testing.assert_allclose(actual, expected, rtol=1e-03, atol=.5)
+    np.testing.assert_allclose(actual, expected, rtol=1e-03, atol=0.5)
 
 
 tgrm = [
-    ([[[1, 2], [3, 4]], [[.25], [.75]], [[.9], [.7]], [[11, 22], [33, 44]], 1, 2, 2], [[-9, -22], [-33, -44]]),
+    ([[[1, 2], [3, 4]], [[0.25], [0.75]], [[0.9], [0.7]], [[11, 22], [33, 44]], 1, 2, 2], [[-9, -22], [-33, -44]]),
     ([[[1, 2], [3, 4]], [[1], [1]], [[1], [1]], [[11, 22], [33, 44]], 1, 2, 2], [[-8, -22], [-26, -44]]),
-    ([[[1.1, 4.4], [1.2, 4.5], [14, 7.8]], [[.4, .6], [.75, .25]], [[.9, .89], [.98, .88]],
-      [[10, 20], [-10.5, -20.6], [0.6, .9]], 2, 2, 3], [[-6.26, -18.24], [14.9744, 23.5067], [-.6, -.9]]),
+    (
+        [
+            [[1.1, 4.4], [1.2, 4.5], [14, 7.8]],
+            [[0.4, 0.6], [0.75, 0.25]],
+            [[0.9, 0.89], [0.98, 0.88]],
+            [[10, 20], [-10.5, -20.6], [0.6, 0.9]],
+            2,
+            2,
+            3,
+        ],
+        [[-6.26, -18.24], [14.9744, 23.5067], [-0.6, -0.9]],
+    ),
     # positive float
-    ([[[-1.1, -4.4], [-1.2, -4.5], [-14, -7.8]], [[.4, .6], [.75, .25]], [[.9, .89], [.98, .88]],
-      [[10, 20], [-10.5, -20.6], [0.6, .9]], 2, 2, 3], [[-13.74, -21.76], [6.0256, 17.6933], [-.6, -.9]]),
+    (
+        [
+            [[-1.1, -4.4], [-1.2, -4.5], [-14, -7.8]],
+            [[0.4, 0.6], [0.75, 0.25]],
+            [[0.9, 0.89], [0.98, 0.88]],
+            [[10, 20], [-10.5, -20.6], [0.6, 0.9]],
+            2,
+            2,
+            3,
+        ],
+        [[-13.74, -21.76], [6.0256, 17.6933], [-0.6, -0.9]],
+    ),
     # negative floats
-    ([[[0, 0, 0, 0], [0, 0, 0, 0]], [[.4], [.2], [.3], [.3]], [[.9], [.9], [.9], [.9]], [[0, 0, 0, 0], [0, 0, 0, 0]], 1,
-      4, 2], [[0, 0, 0, 0], [0, 0, 0, 0]])
+    (
+        [
+            [[0, 0, 0, 0], [0, 0, 0, 0]],
+            [[0.4], [0.2], [0.3], [0.3]],
+            [[0.9], [0.9], [0.9], [0.9]],
+            [[0, 0, 0, 0], [0, 0, 0, 0]],
+            1,
+            4,
+            2,
+        ],
+        [[0, 0, 0, 0], [0, 0, 0, 0]],
+    ),
 ]
 
 
-@pytest.mark.parametrize('tgrm', tgrm)
+@pytest.mark.parametrize("tgrm", tgrm)
 def test_get_residual_matrix(tgrm):
-    actual = get_residual_matrix(tgrm[0][0], tgrm[0][1], tgrm[0][2], tgrm[0][3], tgrm[0][4], tgrm[0][5], tgrm[0][6])
+    actual = get_residual_matrix(
+        tgrm[0][0], tgrm[0][1], tgrm[0][2], tgrm[0][3], tgrm[0][4], tgrm[0][5], tgrm[0][6]
+    )
     expected = tgrm[1]
     np.testing.assert_allclose(actual, expected, rtol=1e-04)
 
 
 trd = [
-    ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-     ComponentSignal([0, .25, .5, .75, 1], 2, 2)]),
-    ([ComponentSignal([0, .25, .5, .75, 1], 2, 0)]),
-    ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-     ComponentSignal([0, .25, .5, .75, 1], 2, 2), ComponentSignal([0, .25, .5, .75, 1], 2, 3),
-      ComponentSignal([0, .25, .5, .75, 1], 2, 4)]),
-    #([]) # Exception expected
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ]
+    ),
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0)]),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 3),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 4),
+        ]
+    ),
+    # ([]) # Exception expected
 ]
-@pytest.mark.parametrize('trd', trd)
+
+
+@pytest.mark.parametrize("trd", trd)
 def test_reconstruct_data(trd):
     actual = reconstruct_data(trd)
-    assert actual.shape == (len(trd[0].iq),len(trd[0].weights))
+    assert actual.shape == (len(trd[0].iq), len(trd[0].weights))
     print(actual)
 
 
-tld = [(([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], 1]), ([[4, 2, 4], [3, 3, 3], [5, 13, 0]])),
-       (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], 0]), ([[1, -1, 1], [0, 0, 0], [2, 10, -3]])),
-       (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], .5]), ([[2.5, .5, 2.5], [1.5, 1.5, 1.5], [3.5, 11.5, -1.5]])),
-       (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], -1]), ([[4, 2, 4], [3, 3, 3], [5, 13, 0]])),
-       (([[[0, 0, 0], [0, 0, 0], [0, 0, 0]], 100]), ([[0, 0, 0], [0, 0, 0], [0, 0, 0]])),
-       (([[[1.5, 2], [10.5, 1], [0.5, 2]], 1]), ([[2, 2.5], [11, 1.5], [1, 2.5]])),
-       (([[[-10, -10.5], [-12.2, -12.2], [0, 0]], 1]), ([[2.2, 1.7], [0, 0], [12.2, 12.2]])),
-       ]
+tld = [
+    (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], 1]), ([[4, 2, 4], [3, 3, 3], [5, 13, 0]])),
+    (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], 0]), ([[1, -1, 1], [0, 0, 0], [2, 10, -3]])),
+    (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], 0.5]), ([[2.5, 0.5, 2.5], [1.5, 1.5, 1.5], [3.5, 11.5, -1.5]])),
+    (([[[1, -1, 1], [0, 0, 0], [2, 10, -3]], -1]), ([[4, 2, 4], [3, 3, 3], [5, 13, 0]])),
+    (([[[0, 0, 0], [0, 0, 0], [0, 0, 0]], 100]), ([[0, 0, 0], [0, 0, 0], [0, 0, 0]])),
+    (([[[1.5, 2], [10.5, 1], [0.5, 2]], 1]), ([[2, 2.5], [11, 1.5], [1, 2.5]])),
+    (([[[-10, -10.5], [-12.2, -12.2], [0, 0]], 1]), ([[2.2, 1.7], [0, 0], [12.2, 12.2]])),
+]
 
 
-@pytest.mark.parametrize('tld', tld)
+@pytest.mark.parametrize("tld", tld)
 def test_lift_data(tld):
     actual = lift_data(tld[0][0], tld[0][1])
     expected = tld[1]
     np.testing.assert_allclose(actual, expected)
 
-tcc = [(2, 3,[0, .5, 1, 1.5]), # Regular usage
-       #(0, 3,[0, .5, 1, 1.5]), # Zero components raise an exception. Not tested
-       ]
-@pytest.mark.parametrize('tcc', tcc)
+
+tcc = [
+    (2, 3, [0, 0.5, 1, 1.5]),  # Regular usage
+    # (0, 3,[0, .5, 1, 1.5]), # Zero components raise an exception. Not tested
+]
+
+
+@pytest.mark.parametrize("tcc", tcc)
 def test_initialize_components(tcc):
     actual = initialize_components(tcc[0], tcc[1], tcc[2])
     assert len(actual) == tcc[0]
     assert len(actual[0].weights) == tcc[1]
     assert (actual[0].grid == np.array(tcc[2])).all()
 
-tcso =[([ComponentSignal([0,.5,1,1.5],20,0)],1,20),
-       ([ComponentSignal([0,.5,1,1.5],20,0)],4,20),
-       # ([ComponentSignal([0,.5,1,1.5],20,0)],0,20), # Raises an exception
-       # ([ComponentSignal([0,.5,1,1.5],20,0)],-2,20), # Raises an exception
-       # ([ComponentSignal([0,.5,1,1.5],20,0)],1,0), # Raises an Exception
-       # ([ComponentSignal([0,.5,1,1.5],20,0)],1,-3), # Raises an exception
-       ([ComponentSignal([0,.5,1,1.5],20,0),ComponentSignal([0,.5,1,1.5],20,1)],2,20),
-       ([ComponentSignal([0,.5,1,1.5],20,0),ComponentSignal([0,.5,1,21.5],20,1)],2,20),
-       ([ComponentSignal([0,1,1.5],20,0),ComponentSignal([0,.5,1,21.5],20,1)],2,20),
-       # ([ComponentSignal([0,.5,1,1.5],20,0),ComponentSignal([0,.5,1,1.5],20,1)],1,-3), # Negative signal length. Raises an exception
-       #([],1,20), # Empty components. Raises an Exception
-       #([],-1,20), # Empty components with negative number of components. Raises an exception
-       #([],0,20), # Empty components with zero number of components. Raises an exception
-       #([],1,0), # Empty components with zero signal length. Raises an exception.
-       #([],-1,-2), # Empty components with negative number of components and signal length Raises an exception.
 
+tcso = [
+    ([ComponentSignal([0, 0.5, 1, 1.5], 20, 0)], 1, 20),
+    ([ComponentSignal([0, 0.5, 1, 1.5], 20, 0)], 4, 20),
+    # ([ComponentSignal([0,.5,1,1.5],20,0)],0,20), # Raises an exception
+    # ([ComponentSignal([0,.5,1,1.5],20,0)],-2,20), # Raises an exception
+    # ([ComponentSignal([0,.5,1,1.5],20,0)],1,0), # Raises an Exception
+    # ([ComponentSignal([0,.5,1,1.5],20,0)],1,-3), # Raises an exception
+    ([ComponentSignal([0, 0.5, 1, 1.5], 20, 0), ComponentSignal([0, 0.5, 1, 1.5], 20, 1)], 2, 20),
+    ([ComponentSignal([0, 0.5, 1, 1.5], 20, 0), ComponentSignal([0, 0.5, 1, 21.5], 20, 1)], 2, 20),
+    ([ComponentSignal([0, 1, 1.5], 20, 0), ComponentSignal([0, 0.5, 1, 21.5], 20, 1)], 2, 20),
+    # ([ComponentSignal([0,.5,1,1.5],20,0),ComponentSignal([0,.5,1,1.5],20,1)],1,-3), # Negative signal length. Raises an exception
+    # ([],1,20), # Empty components. Raises an Exception
+    # ([],-1,20), # Empty components with negative number of components. Raises an exception
+    # ([],0,20), # Empty components with zero number of components. Raises an exception
+    # ([],1,0), # Empty components with zero signal length. Raises an exception.
+    # ([],-1,-2), # Empty components with negative number of components and signal length Raises an exception.
 ]
-@pytest.mark.parametrize('tcso',tcso)
+
+
+@pytest.mark.parametrize("tcso", tcso)
 def test_construct_stretching_matrix(tcso):
-    actual = construct_stretching_matrix(tcso[0],tcso[1],tcso[2])
+    actual = construct_stretching_matrix(tcso[0], tcso[1], tcso[2])
     for component in tcso[0]:
-        np.testing.assert_allclose(actual[component.id,:], component.stretching_factors)
-        #assert actual[component.id, :] == component.stretching_factors
+        np.testing.assert_allclose(actual[component.id, :], component.stretching_factors)
+        # assert actual[component.id, :] == component.stretching_factors
+
 
 tccm = [
-        ([ComponentSignal([0,.25,.5,.75,1],20,0)]),
-        ([ComponentSignal([0,.25,.5,.75,1],0,0)]),
-        ([ComponentSignal([0,.25,.5,.75,1],20,0),ComponentSignal([0,.25,.5,.75,1],20,1),ComponentSignal([0,.25,.5,.75,1],20,2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, .75, 1], 20, 1),
-          ComponentSignal([0, .25, .5, .75, 1], 20, 2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, 2.75, 1], 20, 1),
-          ComponentSignal([0, .25, .5, .75, 1], 20, 2)]),
-        ([ComponentSignal([.25], 20, 0), ComponentSignal([.25], 20, 1), ComponentSignal([.25], 20, 2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, .75, 1], 20, 1)]),
-        # ([ComponentSignal([[0, .25, .5, .75, 1],[0, .25, .5, .75, 1]], 20, 0), ComponentSignal([[0, .25, .5, .75, 1],[0, .25, .5, .75, 1]], 20, 1)]), # iq is multidimensional. Expected to fail
-        # (ComponentSignal([], 20, 0)), # Expected to fail
-        # ([]), #Expected to fail
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0)]),
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 0, 0)]),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
+        ]
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
         ]
-@pytest.mark.parametrize('tccm',tccm)
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 2.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
+        ]
+    ),
+    ([ComponentSignal([0.25], 20, 0), ComponentSignal([0.25], 20, 1), ComponentSignal([0.25], 20, 2)]),
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0), ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1)]),
+    # ([ComponentSignal([[0, .25, .5, .75, 1],[0, .25, .5, .75, 1]], 20, 0), ComponentSignal([[0, .25, .5, .75, 1],[0, .25, .5, .75, 1]], 20, 1)]), # iq is multidimensional. Expected to fail
+    # (ComponentSignal([], 20, 0)), # Expected to fail
+    # ([]), #Expected to fail
+]
+
+
+@pytest.mark.parametrize("tccm", tccm)
 def test_construct_component_matrix(tccm):
     actual = construct_component_matrix(tccm)
     for component in tccm:
@@ -195,59 +393,144 @@ def test_construct_component_matrix(tccm):
 
 
 tcwm = [
-        ([ComponentSignal([0,.25,.5,.75,1],20,0)]),
-        # ([ComponentSignal([0,.25,.5,.75,1],0,0)]), # 0 signal length. Failure expected
-        ([ComponentSignal([0,.25,.5,.75,1],20,0),ComponentSignal([0,.25,.5,.75,1],20,1),ComponentSignal([0,.25,.5,.75,1],20,2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, .75, 1], 20, 1),
-          ComponentSignal([0, .25, .5, .75, 1], 20, 2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, 2.75, 1], 20, 1),
-          ComponentSignal([0, .25, .5, .75, 1], 20, 2)]),
-        ([ComponentSignal([.25], 20, 0), ComponentSignal([.25], 20, 1), ComponentSignal([.25], 20, 2)]),
-        ([ComponentSignal([0, .25, .5, .75, 1], 20, 0), ComponentSignal([0, .25, .5, .75, 1], 20, 1)]),
-        #(ComponentSignal([], 20, 0)), # Expected to fail
-        #([]), #Expected to fail
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0)]),
+    # ([ComponentSignal([0,.25,.5,.75,1],0,0)]), # 0 signal length. Failure expected
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
+        ]
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
+        ]
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0),
+            ComponentSignal([0, 0.25, 0.5, 2.75, 1], 20, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 2),
+        ]
+    ),
+    ([ComponentSignal([0.25], 20, 0), ComponentSignal([0.25], 20, 1), ComponentSignal([0.25], 20, 2)]),
+    ([ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 0), ComponentSignal([0, 0.25, 0.5, 0.75, 1], 20, 1)]),
+    # (ComponentSignal([], 20, 0)), # Expected to fail
+    # ([]), #Expected to fail
 ]
-@pytest.mark.parametrize('tcwm',tcwm)
+
+
+@pytest.mark.parametrize("tcwm", tcwm)
 def test_construct_weight_matrix(tcwm):
     actual = construct_weight_matrix(tcwm)
     for component in tcwm:
         np.testing.assert_allclose(actual[component.id], component.weights)
 
 
-tuw = [([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]], None),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]], "align"),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], None),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], "align"),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[-.5, 1], [1.2, -1.3], [1.1, -1], [0, -1.5], [0, .1]], None),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [[-.5, 1], [1.2, -1.3], [1.1, -1], [0, -1.5], [0, .1]], "align"),
-       # ([ComponentSignal([0, .25, .5, .75, 1], 0, 0), ComponentSignal([0, .25, .5, .75, 1], 0, 1),
-         # ComponentSignal([0, .25, .5, .75, 1], 0, 2)], [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]], None),
-       # ([ComponentSignal([0, .25, .5, .75, 1], 0, 0), ComponentSignal([0, .25, .5, .75, 1], 0, 1),
-         # ComponentSignal([0, .25, .5, .75, 1], 0, 2)], [], None),
-       # ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         # ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [], 170),
-       ]
-@pytest.mark.parametrize('tuw', tuw)
+tuw = [
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]],
+        None,
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]],
+        "align",
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]],
+        None,
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]],
+        "align",
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[-0.5, 1], [1.2, -1.3], [1.1, -1], [0, -1.5], [0, 0.1]],
+        None,
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        [[-0.5, 1], [1.2, -1.3], [1.1, -1], [0, -1.5], [0, 0.1]],
+        "align",
+    ),
+    # ([ComponentSignal([0, .25, .5, .75, 1], 0, 0), ComponentSignal([0, .25, .5, .75, 1], 0, 1),
+    # ComponentSignal([0, .25, .5, .75, 1], 0, 2)], [[1, 1], [1.2, 1.3], [1.3, 1.4], [1.4, 1.5], [2, 2.1]], None),
+    # ([ComponentSignal([0, .25, .5, .75, 1], 0, 0), ComponentSignal([0, .25, .5, .75, 1], 0, 1),
+    # ComponentSignal([0, .25, .5, .75, 1], 0, 2)], [], None),
+    # ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
+    # ComponentSignal([0, .25, .5, .75, 1], 2, 2)], [], 170),
+]
+
+
+@pytest.mark.parametrize("tuw", tuw)
 def test_update_weights(tuw):
     actual = update_weights(tuw[0], tuw[1], tuw[2])
     assert np.shape(actual) == (len(tuw[0]), len(tuw[0][0].weights))
 
-trs = [([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], 1),
-       ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 2, 2)], 0),
-       ([ComponentSignal([0, .25, .5, .75, 1], 3, 0), ComponentSignal([0, .25, .5, .75, 1], 3, 1),
-         ComponentSignal([0, .25, .5, .75, 1], 3, 2)], 2),
-       # ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
-        # ComponentSignal([0, .25, .5, .75, 1], 2, 2)], -1),
+
+trs = [
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        1,
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 2, 2),
+        ],
+        0,
+    ),
+    (
+        [
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 3, 0),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 3, 1),
+            ComponentSignal([0, 0.25, 0.5, 0.75, 1], 3, 2),
+        ],
+        2,
+    ),
+    # ([ComponentSignal([0, .25, .5, .75, 1], 2, 0), ComponentSignal([0, .25, .5, .75, 1], 2, 1),
+    # ComponentSignal([0, .25, .5, .75, 1], 2, 2)], -1),
 ]
-@pytest.mark.parametrize('trs',trs)
+
+
+@pytest.mark.parametrize("trs", trs)
 def test_reconstruct_signal(trs):
     actual = reconstruct_signal(trs[0], trs[1])
     assert len(actual) == len(trs[0][0].grid)
diff --git a/diffpy/snmf/version.py b/diffpy/snmf/version.py
index bf3c080..d7a5c1c 100644
--- a/diffpy/snmf/version.py
+++ b/diffpy/snmf/version.py
@@ -20,9 +20,9 @@
 # obtain version information
 from pkg_resources import get_distribution
 
-__version__ = get_distribution('diffpy.snmf').version
+__version__ = get_distribution("diffpy.snmf").version
 
 # we assume that tag_date was used and __version__ ends in YYYYMMDD
-__date__ = __version__[-8:-4] + '-' + __version__[-4:-2] + '-' + __version__[-2:]
+__date__ = __version__[-8:-4] + "-" + __version__[-4:-2] + "-" + __version__[-2:]
 
 # End of file
diff --git a/doc/source/conf.py b/doc/source/conf.py
index a6cf4b5..4c28b45 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -12,17 +12,18 @@
 #
 import sys
 import os
-sys.path.insert(0, os.path.abspath('../..'))
+
+sys.path.insert(0, os.path.abspath("../.."))
 
 
 # -- Project information -----------------------------------------------------
 
-project = 'snmf'
-copyright = '2009-2023, Trustees of Columbia University in the City of New York, all rights reserved.'
-author = 'Ran Gu, Adeolu Ajayi, Qiang Du,  Simon J.L. Billinge'
+project = "snmf"
+copyright = "2009-2023, Trustees of Columbia University in the City of New York, all rights reserved."
+author = "Ran Gu, Adeolu Ajayi, Qiang Du,  Simon J.L. Billinge"
 
 # The full version, including alpha/beta/rc tags
-release = '0.1.0'
+release = "0.1.0"
 
 
 # -- General configuration ---------------------------------------------------
@@ -31,29 +32,35 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 import sphinx_rtd_theme
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.napoleon', 
-	'sphinx.ext.todo', 'sphinx.ext.viewcode', 
-	'sphinx.ext.intersphinx', 'm2r']
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.todo",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.intersphinx",
+    "m2r",
+]
 napoleon_google_docstring = False
 napoleon_use_param = False
 napoleon_use_ivar = False
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 from jinja2 import Template, Environment, FileSystemLoader
 
-source_suffix = '.rst'
+source_suffix = ".rst"
 
-master_doc = 'index'
+master_doc = "index"
 
-language = 'en'
+language = "en"
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['Thumbs.db', '.DS_Store'] 
+exclude_patterns = ["Thumbs.db", ".DS_Store"]
 
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 todo_include_todos = True
 
@@ -61,7 +68,7 @@
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
 
 html_theme_options = {}
@@ -69,22 +76,26 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
-htmlhelp_basename = 'snmfdoc'
+htmlhelp_basename = "snmfdoc"
 
 latex_documents = [
-	(master_doc, 'snmf.tex', 'Snmf Documentation',
-	'author', 'manual'),
+    (master_doc, "snmf.tex", "Snmf Documentation", "author", "manual"),
 ]
 
-man_pages = [
-	(master_doc, 'snmf', 'Snmf Documentation', [author], 1)
-]
+man_pages = [(master_doc, "snmf", "Snmf Documentation", [author], 1)]
 
 texinfo_documents = [
-	(master_doc, 'snmf', 'Snmf Documentation', author,
-	'snmf', 'One line description of project.', 'Miscellaneous'),
+    (
+        master_doc,
+        "snmf",
+        "Snmf Documentation",
+        author,
+        "snmf",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
 
 epub_title = project
@@ -92,4 +103,4 @@
 epub_publisher = author
 epub_copyright = copyright
 
-epub_exclude_files = ['search.html']
+epub_exclude_files = ["search.html"]
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..e537e24
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,22 @@
+[tool.black]
+line-length = 115
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | \.rst
+  | \.txt
+  | _build
+  | buck-out
+  | build
+  | dist
+
+  # The following are specific to Black, you probably don't want those.
+  | blib2to3
+  | tests/data
+)/
+'''
diff --git a/run_tests.py b/run_tests.py
index 108efd3..69cde5f 100644
--- a/run_tests.py
+++ b/run_tests.py
@@ -3,16 +3,15 @@
 import sys
 import pytest
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # show output results from every test function
-    args = ['-v']
+    args = ["-v"]
     # show the message output for skipped and expected failure tests
     if len(sys.argv) > 1:
         args.extend(sys.argv[1:])
-    print('pytest arguments: {}'.format(args))
+    print("pytest arguments: {}".format(args))
     # # compute coverage stats for xpdAcq
     # call pytest and exit with the return code from pytest so that
     # travis will fail correctly if tests fail
     exit_res = pytest.main(args)
     sys.exit(exit_res)
-
diff --git a/setup.py b/setup.py
index 4e022e3..54d138c 100644
--- a/setup.py
+++ b/setup.py
@@ -16,49 +16,49 @@
 # with open(os.path.join(MYDIR, 'requirements/run.txt')) as fp:
 #     requirements = [line.strip() for line in fp]
 
-with open(os.path.join(MYDIR, 'README.md')) as fp:
+with open(os.path.join(MYDIR, "README.md")) as fp:
     long_description = fp.read()
 
 
 # define distribution
 setup(
     name="diffpy.snmf",
-    version='0.0.1',
-    packages=find_packages(exclude=['tests', 'applications']),
+    version="0.0.1",
+    packages=find_packages(exclude=["tests", "applications"]),
     entry_points={
         # define console_scripts here, see setuptools docs for details.
-        'console_scripts': [
-            'snmf = diffpy.snmf.stretchednmfapp:main',
+        "console_scripts": [
+            "snmf = diffpy.snmf.stretchednmfapp:main",
         ],
     },
-    test_suite='tests',
+    test_suite="tests",
     # install_requires=requirements,
-    author='Ran Gu, Simon J.L. Billinge',
-    author_email='sb2896@columbia.edu',
-    maintainer='Simon J.L. Billinge',
-    maintainer_email='sb2896@columbia.edu',
-    url='https://github.com/diffpy/diffpy.snmf',
+    author="Ran Gu, Simon J.L. Billinge",
+    author_email="sb2896@columbia.edu",
+    maintainer="Simon J.L. Billinge",
+    maintainer_email="sb2896@columbia.edu",
+    url="https://github.com/diffpy/diffpy.snmf",
     description="A python package implementing the stretched NMF algorithm.",
-    long_description = long_description,
-    long_description_content_type = 'text/x-rst',
-    license='BSD',
+    long_description=long_description,
+    long_description_content_type="text/x-rst",
+    license="BSD",
     keywords="diffpy PDF",
-    classifiers = [
+    classifiers=[
         # List of possible values at
         # http://pypi.python.org/pypi?:action=list_classifiers
-        'Development Status :: 4 - Beta',
-        'Environment :: Console',
-        'Intended Audience :: Science/Research',
-        'License :: OSI Approved :: BSD License',
-        'Operating System :: MacOS :: MacOS X',
-        'Operating System :: Microsoft :: Windows',
-        'Operating System :: POSIX',
-        'Operating System :: Unix',
-        'Programming Language :: Python :: 3.9',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Topic :: Scientific/Engineering :: Chemistry',
-        'Topic :: Scientific/Engineering :: Physics',
+        "Development Status :: 4 - Beta",
+        "Environment :: Console",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: BSD License",
+        "Operating System :: MacOS :: MacOS X",
+        "Operating System :: Microsoft :: Windows",
+        "Operating System :: POSIX",
+        "Operating System :: Unix",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Chemistry",
+        "Topic :: Scientific/Engineering :: Physics",
     ],
 )