renaming function, code style unit test

Author: greinerth

pydmd/varprodmd.py

@@ -424,7 +424,7 @@ def compute_varprodmd_any(  # pylint: disable=unused-variable
     return xi / eigenf[None], omegas, eigenf, indices, opt
 
 
-def optdmd_predict(
+def varprodmd_predict(
     phi: np.ndarray,
     omegas: np.ndarray,
     eigenf: np.ndarray,
@@ -575,14 +575,12 @@ def compute_operator(
             if self._sorted_eigs == "auto":
                 eigs_real = self._eigenvalues.real
                 eigs_imag = self._eigenvalues.imag
-                __eigs_abs = np.abs(self._eigenvalues)
+                _eigs_abs = np.abs(self._eigenvalues)
                 var_real = np.var(eigs_real)
                 var_imag = np.var(eigs_imag)
-                var_abs = np.var(__eigs_abs)
-                __array = np.array([var_real, var_imag, var_abs])
-                eigs_abs = (eigs_real, eigs_imag, __eigs_abs)[
-                    np.argmax(__array)
-                ]
+                var_abs = np.var(_eigs_abs)
+                array = np.array([var_real, var_imag, var_abs])
+                eigs_abs = (eigs_real, eigs_imag, _eigs_abs)[np.argmax(array)]
 
             elif self._sorted_eigs == "real":
                 eigs_abs = np.abs(self._eigenvalues.real)
@@ -726,7 +724,7 @@ def forecast(self, time: np.ndarray) -> np.ndarray:
         if not self.fitted:
             raise ValueError("Nothing fitted yet. Call fit-method first!")
 
-        return optdmd_predict(
+        return varprodmd_predict(
             self._Atilde.modes, self._Atilde.eigenvalues, self._b, time
         )
 

tests/test_varprodmd.py

@@ -11,7 +11,7 @@
     _compute_dmd_rho,
     _OptimizeHelper,
     compute_varprodmd_any,
-    optdmd_predict,
+    varprodmd_predict,
     select_best_samples_fast,
 )
 
@@ -26,9 +26,9 @@ def signal(x_loc: np.ndarray, time: np.ndarray) -> np.ndarray:
     :return: Spatiotemporal signal.
     :rtype: np.ndarray
     """
-    __f_1 = 1.0 / np.cosh(x_loc + 3) * np.exp(1j * 2.3 * time)
-    __f_2 = 2.0 / np.cosh(x_loc) * np.tanh(x_loc) * np.exp(1j * 2.8 * time)
-    return __f_1 + __f_2
+    f_1 = 1.0 / np.cosh(x_loc + 3) * np.exp(1j * 2.3 * time)
+    f_2 = 2.0 / np.cosh(x_loc) * np.tanh(x_loc) * np.exp(1j * 2.8 * time)
+    return f_1 + f_2
 
 
 def test_varprodmd_rho():
@@ -40,23 +40,25 @@ def test_varprodmd_rho():
     alphas = np.array([1.0 + 0j, 1.0 + 0j], np.complex128)
     alphas_in = np.array([1.0, 1.0, 0.0, 0.0], np.float64)
     phi = np.exp(np.outer(time, alphas))
-    __u, __s, __v_t = np.linalg.svd(phi, hermitian=False, full_matrices=False)
-    __idx = np.where(__s.real != 0.0)[0]
-    __s_inv = np.zeros_like(__s)
-    __s_inv[__idx] = np.reciprocal(__s[__idx])
+    U_svd, s_svd, V_svd_t = np.linalg.svd(
+        phi, hermitian=False, full_matrices=False
+    )
+    idx = np.where(s_svd.real != 0.0)[0]
+    s_inv = np.zeros_like(s_svd)
+    s_inv[idx] = np.reciprocal(s_svd[idx])
 
-    res = data - np.linalg.multi_dot([__u, __u.conj().T, data])
+    res = data - np.linalg.multi_dot([U_svd, U_svd.conj().T, data])
     res_flat = np.ravel(res)
     res_flat_reals = np.zeros((2 * res_flat.shape[-1]))
     res_flat_reals[: res_flat_reals.shape[-1] // 2] = res_flat.real
     res_flat_reals[res_flat_reals.shape[-1] // 2 :] = res_flat.imag
     opthelper = _OptimizeHelper(2, *data.shape)
     rho_flat_out = _compute_dmd_rho(alphas_in, time, data, opthelper)
-    assert np.array_equal(rho_flat_out, res_flat_reals)
-    assert np.array_equal(__u, opthelper.u_svd)
-    assert np.array_equal(__s_inv, opthelper.s_inv)
-    assert np.array_equal(__v_t.conj().T, opthelper.v_svd)
 
+    assert np.array_equal(rho_flat_out, res_flat_reals)
+    assert np.array_equal(U_svd, opthelper.u_svd)
+    assert np.array_equal(s_inv, opthelper.s_inv)
+    assert np.array_equal(V_svd_t.conj().T, opthelper.v_svd)
     assert np.array_equal(phi, opthelper.phi)
 
 
@@ -74,16 +76,16 @@ def test_varprodmd_jac():  # pylint: disable=too-many-locals,too-many-statements
     d_phi_1[:, 0] = time * phi[:, 0]
     d_phi_2[:, 1] = time * phi[:, 1]
 
-    __u, __s, __v = np.linalg.svd(phi, hermitian=False, full_matrices=False)
-    __idx = np.where(__s.real != 0.0)[0]
-    __s_inv = np.zeros_like(__s)
-    __s_inv[__idx] = np.reciprocal(__s[__idx])
-    phi_inv = (__v.conj().T * __s_inv.reshape((1, -1))) @ __u.conj().T
+    U_svd, s_svd, __v = np.linalg.svd(phi, hermitian=False, full_matrices=False)
+    idx = np.where(s_svd.real != 0.0)[0]
+    s_inv = np.zeros_like(s_svd)
+    s_inv[idx] = np.reciprocal(s_svd[idx])
+    phi_inv = (__v.conj().T * s_inv.reshape((1, -1))) @ U_svd.conj().T
 
     opthelper = _OptimizeHelper(2, *data.shape)
-    opthelper.u_svd = __u
+    opthelper.u_svd = U_svd
     opthelper.v_svd = __v.conj().T
-    opthelper.s_inv = __s_inv
+    opthelper.s_inv = s_inv
     opthelper.phi = phi
     opthelper.phi_inv = phi_inv
     opthelper.b_matrix = phi_inv @ data
@@ -93,11 +95,11 @@ def test_varprodmd_jac():  # pylint: disable=too-many-locals,too-many-statements
     rho_real[: rho_flat.shape[0]] = rho_flat.real
     rho_real[rho_flat.shape[0] :] = rho_flat.imag
     A_1 = d_phi_1 @ opthelper.b_matrix - np.linalg.multi_dot(
-        [__u, __u.conj().T, d_phi_1, opthelper.b_matrix]
+        [U_svd, U_svd.conj().T, d_phi_1, opthelper.b_matrix]
     )
 
     A_2 = d_phi_2 @ opthelper.b_matrix - np.linalg.multi_dot(
-        [__u, __u.conj().T, d_phi_2, opthelper.b_matrix]
+        [U_svd, U_svd.conj().T, d_phi_2, opthelper.b_matrix]
     )
 
     G_1 = np.linalg.multi_dot(
@@ -122,34 +124,34 @@ def test_varprodmd_jac():  # pylint: disable=too-many-locals,too-many-statements
     JAC_REAL[J_1_flat.shape[-1] :, 2] = J_1_flat.real
     JAC_REAL[: J_2_flat.shape[-1], 3] = -J_2_flat.imag
     JAC_REAL[J_2_flat.shape[-1] :, 3] = J_2_flat.real
-    __JAC_OUT_REAL = _compute_dmd_jac(alphas_in, time, data, opthelper)
+    JAC_OUT_REAL = _compute_dmd_jac(alphas_in, time, data, opthelper)
 
     GRAD_REAL = JAC_REAL.T @ rho_real
-    __GRAD_REAL = __JAC_OUT_REAL.T @ rho_real
+    GRAD_OUT_REAL = JAC_OUT_REAL.T @ rho_real
     GRAD_IMAG = JAC_IMAG.conj().T @ rho_flat
 
-    assert np.linalg.norm(JAC_REAL - __JAC_OUT_REAL) < 1e-12
-    assert np.linalg.norm(GRAD_REAL - __GRAD_REAL) < 1e-12
+    assert np.linalg.norm(JAC_REAL - JAC_OUT_REAL) < 1e-12
+    assert np.linalg.norm(GRAD_REAL - GRAD_OUT_REAL) < 1e-12
 
-    __imag2real = np.zeros_like(GRAD_REAL)
-    __imag2real[: __imag2real.shape[-1] // 2] = GRAD_IMAG.real
-    __imag2real[__imag2real.shape[-1] // 2 :] = GRAD_IMAG.imag
+    imag2real = np.zeros_like(GRAD_REAL)
+    imag2real[: imag2real.shape[-1] // 2] = GRAD_IMAG.real
+    imag2real[imag2real.shape[-1] // 2 :] = GRAD_IMAG.imag
 
-    __rec_grad = np.zeros_like(GRAD_IMAG)
-    __rec_grad.real = GRAD_REAL[: GRAD_REAL.shape[-1] // 2]
-    __rec_grad.imag = GRAD_REAL[GRAD_REAL.shape[-1] // 2 :]
+    rec_grad = np.zeros_like(GRAD_IMAG)
+    rec_grad.real = GRAD_REAL[: GRAD_REAL.shape[-1] // 2]
+    rec_grad.imag = GRAD_REAL[GRAD_REAL.shape[-1] // 2 :]
 
     # funny numerical errors leads to
     # np.array_equal(GRAD_IMAG, __rec_grad) to fail
-    assert np.linalg.norm(GRAD_IMAG - __rec_grad) < 1e-9
+    assert np.linalg.norm(GRAD_IMAG - rec_grad) < 1e-9
 
-    __rec_grad = np.zeros_like(GRAD_IMAG)
-    __rec_grad.real = __GRAD_REAL[: __GRAD_REAL.shape[-1] // 2]
-    __rec_grad.imag = __GRAD_REAL[__GRAD_REAL.shape[-1] // 2 :]
+    rec_grad = np.zeros_like(GRAD_IMAG)
+    rec_grad.real = GRAD_OUT_REAL[: GRAD_OUT_REAL.shape[-1] // 2]
+    rec_grad.imag = GRAD_OUT_REAL[GRAD_OUT_REAL.shape[-1] // 2 :]
 
     # funny numerical errors leads to
     # np.array_equal(GRAD_IMAG, __rec_grad) to fail
-    assert np.linalg.norm(GRAD_IMAG - __rec_grad) < 1e-9
+    assert np.linalg.norm(GRAD_IMAG - rec_grad) < 1e-9
 
 
 def test_varprodmd_any():
@@ -158,45 +160,44 @@ def test_varprodmd_any():
     """
     time = np.linspace(0, 4 * np.pi, 100)
     x_loc = np.linspace(-10, 10, 1024)
-    __x, __time = np.meshgrid(x_loc, time)
 
-    z = signal(__x, __time).T
+    z = signal(*np.meshgrid(x_loc, time)).T
 
-    __idx = select_best_samples_fast(z, 0.6)
+    idx = select_best_samples_fast(z, 0.6)
 
-    __z_sub = z[:, __idx]
-    __t_sub = time[__idx]
+    z_sub = z[:, idx]
+    t_sub = time[idx]
 
     with pytest.raises(ValueError):
         compute_varprodmd_any(
-            __z_sub[:, 0],
-            __t_sub,
+            z_sub[:, 0],
+            t_sub,
             OPT_DEF_ARGS,
             rank=0.0,
         )
 
     with pytest.raises(ValueError):
         compute_varprodmd_any(
-            __z_sub, __t_sub.reshape((-1, 1)), OPT_DEF_ARGS, rank=0.0
+            z_sub, t_sub.reshape((-1, 1)), OPT_DEF_ARGS, rank=0.0
         )
 
     phi, lambdas, eigenf, _, _ = compute_varprodmd_any(
-        __z_sub, __t_sub, OPT_DEF_ARGS, rank=0.0
+        z_sub, t_sub, OPT_DEF_ARGS, rank=0.0
     )
-    __pred = optdmd_predict(phi, lambdas, eigenf, time)
-    __diff = np.abs(__pred - z)
-    __mae_0 = np.sum(np.sum(__diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
+    pred = varprodmd_predict(phi, lambdas, eigenf, time)
+    diff = np.abs(pred - z)
+    mae = np.sum(np.sum(diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
 
-    assert __mae_0 < 1.0
+    assert mae < 1.0
 
     phi, lambdas, eigenf, _, _ = compute_varprodmd_any(
-        __z_sub, __t_sub, OPT_DEF_ARGS, rank=0.0, use_proj=False
+        z_sub, t_sub, OPT_DEF_ARGS, rank=0.0, use_proj=False
     )
-    __pred = optdmd_predict(phi, lambdas, eigenf, time)
-    __diff = np.abs(__pred - z)
-    __mae_0 = np.sum(np.sum(__diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
+    pred = varprodmd_predict(phi, lambdas, eigenf, time)
+    diff = np.abs(pred - z)
+    mae = np.sum(np.sum(diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
 
-    assert __mae_0 < 1.0
+    assert mae < 1.0
 
 
 def test_varprodmd_class():
@@ -205,22 +206,21 @@ def test_varprodmd_class():
     """
     time = np.linspace(0, 4 * np.pi, 100)
     x_loc = np.linspace(-10, 10, 1024)
-    __x, __time = np.meshgrid(x_loc, time)
 
-    z = signal(__x, __time).T
+    z = signal(*np.meshgrid(x_loc, time)).T
     dmd = VarProDMD(0, False, False, 0)
 
     with pytest.raises(ValueError):
-        __ = dmd.forecast(time)
+        _ = dmd.forecast(time)
 
     with pytest.raises(ValueError):
-        __ = dmd.ssr
+        _ = dmd.ssr
 
     with pytest.raises(ValueError):
-        __ = dmd.selected_samples
+        _ = dmd.selected_samples
 
     with pytest.raises(ValueError):
-        __ = dmd.opt_stats
+        _ = dmd.opt_stats
 
     dmd.fit(z, time)
     assert dmd.fitted
@@ -232,12 +232,12 @@ def test_varprodmd_class():
     assert dmd.growth_rate.size == dmd.amplitudes.size
     assert dmd.eigs.size == dmd.amplitudes.size
 
-    __pred = dmd.forecast(time)
+    pred = dmd.forecast(time)
 
-    __diff = np.abs(__pred - z)
-    __mae = np.sum(np.sum(__diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
+    diff = np.abs(pred - z)
+    mae = np.sum(np.sum(diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
 
-    assert __mae < 1
+    assert mae < 1
     assert dmd.ssr < 1e-3
 
     dmd = VarProDMD(0, False, "unkown_sort", 0.8)
@@ -250,10 +250,8 @@ def test_varprodmd_class():
     for arg in sort_args:
         dmd = VarProDMD(0, False, arg, 0.6)
         dmd.fit(z, time)
-        __pred = dmd.forecast(time)
-        __diff = np.abs(__pred - z)
-        __mae = (
-            np.sum(np.sum(__diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
-        )
+        pred = dmd.forecast(time)
+        diff = np.abs(pred - z)
+        mae = np.sum(np.sum(diff, axis=0), axis=-1) / z.shape[0] / z.shape[-1]
         assert dmd.selected_samples.size == int((1 - 0.6) * 100)
-        assert __mae < 1.0
+        assert mae < 1.0