Merge pull request #50 from aajayi-21/reconstruct_data

function reconsturct_data

Author: sbillinge

Diff for: diffpy/snmf/subroutines.py

@@ -449,76 +449,25 @@ def get_residual_matrix(component_matrix, weights_matrix, stretching_matrix, dat
     return residual_matrx
 
 
-def reconstruct_data(stretching_factor_matrix, component_matrix, weight_matrix, component_amount,
-                     moment_amount, signal_length):
-    """Reconstructs the experimental data from the component signals, stretching factors, and weights.
+def reconstruct_data(components):
+    """Reconstructs the `input_data` matrix
 
-    Calculates the stretched and weighted components at each moment.
+    Reconstructs the `input_data` matrix from calculated component signals, weights, and stretching factors.
 
     Parameters
     ----------
-    stretching_factor_matrix: 2d array like
-      The matrix containing the stretching factors of the component signals. Has dimensions K x M where K is the number
-      of components and M is the number of moments.
-
-    component_matrix: 2d array like
-      The matrix containing the unstretched component signals. Has dimensions N x K where N is the length of the signals
-      and K is the number of components.
-
-    weight_matrix: 2d array like
-      The matrix containing the weights of the stretched component signals at each moment in time. Has dimensions
-      K x M where K is the number of components and M is the number of moments.
-
-    component_amount: int
-      The number of component signals the user would like to obtain from the experimental data.
-
-    moment_amount: int
-      The number of patterns in the experimental data. Represents the number of moments in time in the data series.
-
-    signal_length: int
-      The length of the signals in the experimental data.
+    components: tuple of ComponentSignal objects
+      The tuple containing the component signals.
 
     Returns
     -------
-    tuple of 2d array of floats
-      The stretched and weighted component signals at each moment. Has dimensions N x (M * K) where N is the length of
-      the signals, M is the number of moments, and K is the number of components. The resulting matrix has M blocks
-      stacked horizontally where each block is the weighted and stretched components at each moment. Also contains
-      the gradient and hessian matrices of the reconstructed data.
+    2d array
+      The 2d array containing the reconstruction of input_data.
 
     """
-    stretching_factor_matrix = np.asarray(stretching_factor_matrix)
-    component_matrix = np.asarray(component_matrix)
-    weight_matrix = np.asarray(weight_matrix)
-    stretched_component_series = []
-    stretched_component_series_gra = []
-    stretched_component_series_hess = []
-    for moment in range(moment_amount):
-        for component in range(component_amount):
-            stretched_component = get_stretched_component(stretching_factor_matrix[component, moment],
-                                                          component_matrix[:, component], signal_length)
-            stretched_component_series.append(stretched_component[0])
-            stretched_component_series_gra.append(stretched_component[1])
-            stretched_component_series_hess.append(stretched_component[2])
-    stretched_component_series = np.column_stack(stretched_component_series)
-    stretched_component_series_gra = np.column_stack(stretched_component_series_gra)
-    stretched_component_series_hess = np.column_stack(stretched_component_series_hess)
-
-    reconstructed_data = []
-    reconstructed_data_gra = []
-    reconstructed_data_hess = []
-    moment = 0
-    for s_component in range(0, moment_amount * component_amount, component_amount):
-        block = stretched_component_series[:, s_component:s_component + component_amount]
-        block_gra = stretched_component_series_gra[:, s_component:s_component + component_amount]
-        block_hess = stretched_component_series_hess[:, s_component:s_component + component_amount]
-        for component in range(component_amount):
-            block[:, component] = block[:, component] * weight_matrix[component, moment]
-            block_gra[:, component] = block_gra[:, component] * weight_matrix[component, moment]
-            block_hess[:, component] = block_hess[:, component] * weight_matrix[component, moment]
-        reconstructed_data.append(block)
-        reconstructed_data_gra.append(block_gra)
-        reconstructed_data_hess.append(block_hess)
-        moment += 1
-    return np.column_stack(reconstructed_data), np.column_stack(reconstructed_data_gra), np.column_stack(
-        reconstructed_data_hess)
+    signal_length = len(components[0].iq)
+    number_of_signals = len(components[0].weights)
+    data_reconstruction = np.zeros((signal_length, number_of_signals))
+    for signal in range(number_of_signals):
+        data_reconstruction[:, signal] = reconstruct_signal(components, signal)
+    return data_reconstruction

Diff for: diffpy/snmf/tests/test_subroutines.py

@@ -108,34 +108,19 @@ def test_get_residual_matrix(tgrm):
 
 
 trd = [
-    ([np.array([[.5], [.5]]), np.array([[1, 2], [3, 4]]), np.array([[.25], [.75]]), 2, 1, 2],
-     (np.array([[.25, 1.5], [0, 0]]), np.array([[0, 0], [0, 0]]), np.array([[0, 0], [0, 0]]))),
-    ([[[.9], [.7]], [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]], [[.25], [.75]], 2, 1, 5],
-     ([[.25, 1.5], [.8056, 3.6429], [1.3611, 5.7857], [1.9167, 0], [0, 0]],
-      [[0, 0], [-.61728, -3.06122], [-1.234567, -6.12244], [-1.8518, 0], [0, 0]],
-      [[0, 0], [1.3717, 8.746355], [2.74348, 17.49271], [4.11523, 0], [0, 0]])),
-    ([[[.5, .7], [.5, .8]], [[1.1, 2.2], [3.3, 4.4]], [[.25, .5], [.75, .5]], 2, 2, 2],
-     ([[.275, 1.65, .55, 1.1], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]])),
-    ([[[.9, .9], [.9, .9], [.95, .95], [.95, .95]], [[-11, -.3, 0, -.2], [-14, -1, 0, -.75]],
-      [[.5, .5], [.2, 0], [.3, .5], [0, 0]], 4, 2, 2],
-     ([[-5.5, -0.06, 0, 0, -5.5, 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]], [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]])),
-    ([[[.7, .8, .9], [.9, .9, .95], [1, .8, .9]], [[0, 0, 0], [.3, .4, .5], [1, 1.2, 1.3]],
-      [[.33, .5, .6], [0, .25, .3], [.66, .25, .1]], 3, 3, 3],
-     ([[0, 0, 0, 0, 0, 0, 0, 0, 0], [.1980, 0, .33, .2375, .1222, .1750, .2267, .1326, .0589],
-       [0, 0, .8580, 0, 0, 0, 0, 0, 0]],
-      [[0, 0, 0, 0, 0, 0, 0, 0, 0], [-.47142, 0, -.429, -.546875, -.246913, -.3125, -.51851, -.26593, -.098765],
-       [0, 0, -0.24175643, 0, 0, 0, 0, 0, 0]],
-      [[0, 0, 0, 0, 0, 0, 0, 0, 0], [1.3469, 0, 1.96711566, 1.3671875, .548696, .78125, 1.15226, .55984, .2194787],
-       [0, 0, 0.27796989, 0, 0, 0, 0, 0, 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, 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
 ]
-
-
 @pytest.mark.parametrize('trd', trd)
 def test_reconstruct_data(trd):
-    actual = reconstruct_data(trd[0][0], trd[0][1], trd[0][2], trd[0][3], trd[0][4], trd[0][5])
-    expected = trd[1]
-    np.testing.assert_allclose(actual, expected, rtol=1e-03)
+    actual = reconstruct_data(trd)
+    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]])),