dfm-python 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

dfm_python/__init__.py

@@ -50,7 +50,7 @@ Example (Low-level API - For advanced usage):
 For detailed documentation, see the README.md file and the tutorial notebooks/scripts.
 """
 
-__version__ = "0.2.5"
+__version__ = "0.2.7"
 
 from .config import DFMConfig, SeriesConfig, BlockConfig, Params, DEFAULT_GLOBAL_BLOCK_NAME
 from .config import (

dfm_python/core/em.py

@@ -368,7 +368,20 @@ def init_conditions(x, r, p, blocks, opt_nan, Rcon, q, nQ, i_idio, clock='m', te
                                         # Store loadings (only up to available columns in C_block)
                                         n_loadings = min(pC_freq * r_i, C_block.shape[1])
                                         if n_loadings > 0:
-                                            C_block[j, :n_loadings] = loadings[:n_loadings]
+                                            # Clip initial loadings to prevent extreme values
+                                            # This helps prevent Q explosion during C normalization
+                                            max_loading_norm = safe_get_attr(config, "max_loading_norm", 10.0) if config is not None else 10.0
+                                            # Clip loadings: if norm is too large, scale down
+                                            loadings_to_store = loadings[:n_loadings]
+                                            if loadings_to_store.ndim == 1:
+                                                # Vector case: clip by norm
+                                                loading_norm = np.linalg.norm(loadings_to_store)
+                                                if loading_norm > max_loading_norm:
+                                                    loadings_to_store = loadings_to_store * (max_loading_norm / loading_norm)
+                                            else:
+                                                # Multi-dimensional: clip each element
+                                                loadings_to_store = np.clip(loadings_to_store, -max_loading_norm, max_loading_norm)
+                                            C_block[j, :n_loadings] = loadings_to_store
                                     except Exception:
                                         # If constrained LS fails, use unconstrained (fallback)
                                         try:
@@ -377,7 +390,19 @@ def init_conditions(x, r, p, blocks, opt_nan, Rcon, q, nQ, i_idio, clock='m', te
                                             loadings = gram_inv @ factor_projection_clean.T @ series_data_clean
                                             n_loadings = min(pC_freq * r_i, C_block.shape[1])
                                             if n_loadings > 0:
-                                                C_block[j, :n_loadings] = loadings[:n_loadings]
+                                                # Clip initial loadings to prevent extreme values
+                                                max_loading_norm = safe_get_attr(config, "max_loading_norm", 10.0) if config is not None else 10.0
+                                                # Clip loadings: if norm is too large, scale down
+                                                loadings_to_store = loadings[:n_loadings]
+                                                if loadings_to_store.ndim == 1:
+                                                    # Vector case: clip by norm
+                                                    loading_norm = np.linalg.norm(loadings_to_store)
+                                                    if loading_norm > max_loading_norm:
+                                                        loadings_to_store = loadings_to_store * (max_loading_norm / loading_norm)
+                                                else:
+                                                    # Multi-dimensional: clip each element
+                                                    loadings_to_store = np.clip(loadings_to_store, -max_loading_norm, max_loading_norm)
+                                                C_block[j, :n_loadings] = loadings_to_store
                                         except Exception:
                                             pass  # Leave as zeros
                         except Exception:
@@ -784,8 +809,8 @@ def em_step(params: EMStepParams) -> Tuple[np.ndarray, np.ndarray, np.ndarray, n
                     lambda_ridge = (trace_val / size_val) * 1e-5  # Scale factor
                     EZZ_lag_sub = EZZ_lag_sub + lambda_ridge * np.eye(size_val)
                     # Recompute condition number after regularization
-                    eigenvals = np.linalg.eigvals(EZZ_lag_sub)
-                    cond_num = (np.max(eigenvals) / max(np.min(eigenvals), 1e-12)) if np.max(eigenvals) > 0 else 1.0
+                eigenvals = np.linalg.eigvals(EZZ_lag_sub)
+                cond_num = (np.max(eigenvals) / max(np.min(eigenvals), 1e-12)) if np.max(eigenvals) > 0 else 1.0
                 EZZ_lag_inv = pinv(EZZ_lag_sub, rcond=1e-8) if cond_num > 1e12 else inv(EZZ_lag_sub)
             except _NUMERICAL_EXCEPTIONS:
                 EZZ_lag_inv = pinv(EZZ_lag_sub)
@@ -924,55 +949,55 @@ def em_step(params: EMStepParams) -> Tuple[np.ndarray, np.ndarray, np.ndarray, n
         # Keep C fixed for idio components (not updated in M-step)
     else:
         # Fallback to old approach for backward compatibility
-        i_subset = slice(idio_start_idx, idio_start_idx + n_idio)
-        i_subset_slice = slice(i_subset.start, i_subset.stop)
-        Z_idio = Zsmooth[i_subset_slice, 1:] if idio_start_idx < Zsmooth.shape[1] else np.zeros((n_idio, T))
-        n_idio_actual = Z_idio.shape[0] if Z_idio.shape[0] > 0 else n_idio
-        expected_idio_current_sq = np.sum(Z_idio**2, axis=1)
-        vsmooth_idio_block = vsmooth[i_subset_slice, :, :][:, i_subset_slice, 1:]
-        vsmooth_idio_sum = np.sum(vsmooth_idio_block, axis=2)
-        if vsmooth_idio_sum.ndim == 2 and vsmooth_idio_sum.shape[0] >= n_idio_actual and vsmooth_idio_sum.shape[1] >= n_idio_actual:
-            vsmooth_idio_diag = np.diag(vsmooth_idio_sum[:n_idio_actual, :n_idio_actual])
-        else:
-            vsmooth_idio_diag = np.zeros(n_idio_actual)
-        expected_idio_current_sq = expected_idio_current_sq + vsmooth_idio_diag
-        Z_idio_lag = Zsmooth[i_subset_slice, :-1]
-        expected_idio_lag_sq = np.sum(Z_idio_lag**2, axis=1)
-        vsmooth_lag_block = vsmooth[i_subset_slice, :, :][:, i_subset_slice, :-1]
-        vsmooth_lag_sum = np.sum(vsmooth_lag_block, axis=2)
-        if vsmooth_lag_sum.ndim == 2 and vsmooth_lag_sum.shape[0] >= n_idio_actual and vsmooth_lag_sum.shape[1] >= n_idio_actual:
-            vsmooth_lag_diag = np.diag(vsmooth_lag_sum[:n_idio_actual, :n_idio_actual])
-        else:
-            vsmooth_lag_diag = np.zeros(n_idio_actual)
-        expected_idio_lag_sq = expected_idio_lag_sq + vsmooth_lag_diag
-        min_cols = min(Z_idio.shape[1], Z_idio_lag.shape[1])
-        expected_idio_cross = np.sum(Z_idio[:, :min_cols] * Z_idio_lag[:, :min_cols], axis=1)
-        vvsmooth_block = vvsmooth[i_subset_slice, :, :][:, i_subset_slice, :]
-        vvsmooth_sum = np.sum(vvsmooth_block, axis=2)
-        if vvsmooth_sum.ndim == 2 and vvsmooth_sum.shape[0] >= n_idio_actual and vvsmooth_sum.shape[1] >= n_idio_actual:
-            vvsmooth_diag = np.diag(vvsmooth_sum[:n_idio_actual, :n_idio_actual])
-        else:
-            vvsmooth_diag = np.zeros(n_idio_actual)
-        expected_idio_cross = expected_idio_cross + vvsmooth_diag
-        ar_coeffs_diag, _ = _estimate_ar_coefficient(expected_idio_cross, expected_idio_lag_sq, vsmooth_sum=vsmooth_lag_diag)
-        A_block_idio = np.diag(ar_coeffs_diag)
-        innovation_cov_diag = (np.maximum(expected_idio_current_sq, 0.0) - ar_coeffs_diag * expected_idio_cross) / T
-        innovation_cov_diag = np.maximum(innovation_cov_diag, MIN_INNOVATION_VARIANCE)
-        Q_block_idio = np.diag(innovation_cov_diag)
-        i_subset_size = i_subset.stop - i_subset.start
-        if n_idio_actual == i_subset_size:
-            A_new[i_subset, i_subset] = A_block_idio
-            Q_new[i_subset, i_subset] = Q_block_idio
-        elif n_idio_actual < i_subset_size:
-            A_new[i_subset.start:i_subset.start + n_idio_actual, i_subset.start:i_subset.start + n_idio_actual] = A_block_idio
-            Q_new[i_subset.start:i_subset.start + n_idio_actual, i_subset.start:i_subset.start + n_idio_actual] = Q_block_idio
-        else:
-            A_new[i_subset, i_subset] = A_block_idio[:i_subset_size, :i_subset_size]
-            Q_new[i_subset, i_subset] = Q_block_idio[:i_subset_size, :i_subset_size]
-        vsmooth_sub = vsmooth[i_subset_slice, :, :][:, i_subset_slice, 0]
-        vsmooth_diag = np.diag(vsmooth_sub[:n_idio_actual, :n_idio_actual]) if vsmooth_sub.ndim == 2 else np.zeros(n_idio_actual)
-        for idx in range(min(n_idio_actual, i_subset_size)):
-            V_0_new[i_subset.start + idx, i_subset.start + idx] = vsmooth_diag[idx] if idx < len(vsmooth_diag) else 0.0
+    i_subset = slice(idio_start_idx, idio_start_idx + n_idio)
+    i_subset_slice = slice(i_subset.start, i_subset.stop)
+    Z_idio = Zsmooth[i_subset_slice, 1:] if idio_start_idx < Zsmooth.shape[1] else np.zeros((n_idio, T))
+    n_idio_actual = Z_idio.shape[0] if Z_idio.shape[0] > 0 else n_idio
+    expected_idio_current_sq = np.sum(Z_idio**2, axis=1)
+    vsmooth_idio_block = vsmooth[i_subset_slice, :, :][:, i_subset_slice, 1:]
+    vsmooth_idio_sum = np.sum(vsmooth_idio_block, axis=2)
+    if vsmooth_idio_sum.ndim == 2 and vsmooth_idio_sum.shape[0] >= n_idio_actual and vsmooth_idio_sum.shape[1] >= n_idio_actual:
+        vsmooth_idio_diag = np.diag(vsmooth_idio_sum[:n_idio_actual, :n_idio_actual])
+    else:
+        vsmooth_idio_diag = np.zeros(n_idio_actual)
+    expected_idio_current_sq = expected_idio_current_sq + vsmooth_idio_diag
+    Z_idio_lag = Zsmooth[i_subset_slice, :-1]
+    expected_idio_lag_sq = np.sum(Z_idio_lag**2, axis=1)
+    vsmooth_lag_block = vsmooth[i_subset_slice, :, :][:, i_subset_slice, :-1]
+    vsmooth_lag_sum = np.sum(vsmooth_lag_block, axis=2)
+    if vsmooth_lag_sum.ndim == 2 and vsmooth_lag_sum.shape[0] >= n_idio_actual and vsmooth_lag_sum.shape[1] >= n_idio_actual:
+        vsmooth_lag_diag = np.diag(vsmooth_lag_sum[:n_idio_actual, :n_idio_actual])
+    else:
+        vsmooth_lag_diag = np.zeros(n_idio_actual)
+    expected_idio_lag_sq = expected_idio_lag_sq + vsmooth_lag_diag
+    min_cols = min(Z_idio.shape[1], Z_idio_lag.shape[1])
+    expected_idio_cross = np.sum(Z_idio[:, :min_cols] * Z_idio_lag[:, :min_cols], axis=1)
+    vvsmooth_block = vvsmooth[i_subset_slice, :, :][:, i_subset_slice, :]
+    vvsmooth_sum = np.sum(vvsmooth_block, axis=2)
+    if vvsmooth_sum.ndim == 2 and vvsmooth_sum.shape[0] >= n_idio_actual and vvsmooth_sum.shape[1] >= n_idio_actual:
+        vvsmooth_diag = np.diag(vvsmooth_sum[:n_idio_actual, :n_idio_actual])
+    else:
+        vvsmooth_diag = np.zeros(n_idio_actual)
+    expected_idio_cross = expected_idio_cross + vvsmooth_diag
+    ar_coeffs_diag, _ = _estimate_ar_coefficient(expected_idio_cross, expected_idio_lag_sq, vsmooth_sum=vsmooth_lag_diag)
+    A_block_idio = np.diag(ar_coeffs_diag)
+    innovation_cov_diag = (np.maximum(expected_idio_current_sq, 0.0) - ar_coeffs_diag * expected_idio_cross) / T
+    innovation_cov_diag = np.maximum(innovation_cov_diag, MIN_INNOVATION_VARIANCE)
+    Q_block_idio = np.diag(innovation_cov_diag)
+    i_subset_size = i_subset.stop - i_subset.start
+    if n_idio_actual == i_subset_size:
+        A_new[i_subset, i_subset] = A_block_idio
+        Q_new[i_subset, i_subset] = Q_block_idio
+    elif n_idio_actual < i_subset_size:
+        A_new[i_subset.start:i_subset.start + n_idio_actual, i_subset.start:i_subset.start + n_idio_actual] = A_block_idio
+        Q_new[i_subset.start:i_subset.start + n_idio_actual, i_subset.start:i_subset.start + n_idio_actual] = Q_block_idio
+    else:
+        A_new[i_subset, i_subset] = A_block_idio[:i_subset_size, :i_subset_size]
+        Q_new[i_subset, i_subset] = Q_block_idio[:i_subset_size, :i_subset_size]
+    vsmooth_sub = vsmooth[i_subset_slice, :, :][:, i_subset_slice, 0]
+    vsmooth_diag = np.diag(vsmooth_sub[:n_idio_actual, :n_idio_actual]) if vsmooth_sub.ndim == 2 else np.zeros(n_idio_actual)
+    for idx in range(min(n_idio_actual, i_subset_size)):
+        V_0_new[i_subset.start + idx, i_subset.start + idx] = vsmooth_diag[idx] if idx < len(vsmooth_diag) else 0.0
 
     Z_0 = Zsmooth[0, :].copy()
     nanY = np.isnan(y)
@@ -1180,6 +1205,12 @@ def em_step(params: EMStepParams) -> Tuple[np.ndarray, np.ndarray, np.ndarray, n
     # Hard floor: enforce min diagonal on R (≥ 1e-8)
     idio_min_var = getattr(config, 'idio_min_var', 1e-8) if config is not None else 1e-8
     R_diag = np.maximum(R_diag, idio_min_var)
+    
+    # R cap to prevent explosion: maximum allowed observation error variance
+    # For standardized data, R should typically be < 10
+    R_cap = safe_get_attr(config, "max_observation_variance", 10.0) if config is not None else 10.0
+    R_diag = np.minimum(R_diag, R_cap)
+    
     R_new = np.diag(R_diag)
     
     # Final stability operations
@@ -1212,22 +1243,61 @@ def em_step(params: EMStepParams) -> Tuple[np.ndarray, np.ndarray, np.ndarray, n
     has_slower_freq = (frequencies is not None and 
                       any(freq != clock for freq in frequencies if freq is not None))
     num_clock_factors = int(np.sum(r))  # Only clock-frequency factors (ppC=1 part)
-    if num_clock_factors > 0 and not has_slower_freq:
-        # Only normalize if there are no slower-frequency series
-        # (to avoid violating tent weight constraints)
-        for j in range(num_clock_factors):
-            norm = np.linalg.norm(C_new[:, j])
-            if norm > 1e-8:
-                # Normalize C column
-                C_new[:, j] = C_new[:, j] / norm
-                # Adjust Q to preserve variance
-                # Diagonal: Q[j,j] *= norm^2
-                Q_new[j, j] = Q_new[j, j] * (norm ** 2)
-                # Off-diagonal: Q[j,k] and Q[k,j] *= norm (for k != j)
-                for k in range(Q_new.shape[0]):
-                    if k != j:
-                        Q_new[j, k] = Q_new[j, k] * norm
-                        Q_new[k, j] = Q_new[k, j] * norm
+    
+    # Q cap to prevent explosion: maximum allowed innovation variance for factors
+    Q_cap_factor = safe_get_attr(config, "max_innovation_variance", 1.0) if config is not None else 1.0
+    
+    # Normalize C for clock-frequency factors to prevent scale issues
+    # Only normalize if C norm is in reasonable range (not too small, not too large)
+    # This prevents Q from becoming too small (when C norm is small) or too large (when C norm is large)
+    if num_clock_factors > 0:
+        # Check if there are slower-frequency series (tent weight constraints)
+        has_slower_freq = (frequencies is not None and 
+                          any(freq != clock for freq in frequencies if freq is not None))
+        
+        # Only normalize if no slower-frequency series (to avoid violating tent weight constraints)
+        if not has_slower_freq:
+            for j in range(num_clock_factors):
+                norm = np.linalg.norm(C_new[:, j])
+                if norm > 1e-8:
+                    # Only normalize if norm is in reasonable range
+                    # Too small norm (< 0.1) would make Q too small
+                    # Too large norm (> 10) would make Q too large
+                    C_norm_min = 0.1  # Minimum norm to normalize
+                    C_norm_cap = safe_get_attr(config, "max_loading_norm", 10.0) if config is not None else 10.0
+                    
+                    if C_norm_min <= norm <= C_norm_cap:
+                        # Normalize C column
+                        C_new[:, j] = C_new[:, j] / norm
+                        
+                        # Adjust Q to preserve variance: Q[j,j] *= norm^2
+                        Q_adjustment = norm ** 2
+                        Q_new[j, j] = Q_new[j, j] * Q_adjustment
+                        
+                        # Off-diagonal: Q[j,k] and Q[k,j] *= norm (for k != j)
+                        for k in range(Q_new.shape[0]):
+                            if k != j:
+                                Q_new[j, k] = Q_new[j, k] * norm
+                                Q_new[k, j] = Q_new[k, j] * norm
+                    # If norm is too small or too large, skip normalization to preserve stability
+        
+        # Re-apply Q floor and cap after C normalization to prevent extreme values
+        # C normalization can make Q very large (if C norm was large) or very small (if C norm was small)
+        Q_diag_after_norm = np.diag(Q_new).copy()
+        if num_factors > 0:
+            # Apply both floor and cap to factors after normalization
+            Q_diag_after_norm[:num_factors] = np.clip(
+                Q_diag_after_norm[:num_factors],
+                Q_min_factor,  # Floor: 0.01
+                Q_cap_factor   # Cap: 1.0 (configurable)
+            )
+            # Preserve idio components (only floor, no cap needed)
+            if num_factors < len(Q_diag_after_norm):
+                Q_diag_after_norm[num_factors:] = np.maximum(Q_diag_after_norm[num_factors:], idio_min_var)
+        else:
+            Q_diag_after_norm = np.maximum(Q_diag_after_norm, idio_min_var)
+        # Update Q with re-applied floor and cap
+        Q_new = np.diag(Q_diag_after_norm) + (Q_new - np.diag(np.diag(Q_new)))  # Preserve off-diagonal
     
     # Spectral radius cap on A (< 0.99) with minimal shrinkage
     eigenvals_A = np.linalg.eigvals(A_new)

dfm_python/core/numeric.py

@@ -598,20 +598,23 @@ def _safe_determinant(M: np.ndarray, use_logdet: bool = True) -> float:
                 if np.isfinite(det) and det > 0:
                     return float(det)
             except np.linalg.LinAlgError:
-                # Not PSD, use LU decomposition
-                P, L, U = np.linalg.lu(M)
-                log_det = np.sum(np.log(np.abs(np.diag(U))))
-                # Check if log_det is too large to avoid overflow in exp
+                # Not PSD: fall back to slogdet for general matrices
+                try:
+                    sign, log_det = np.linalg.slogdet(M)
+                    # If determinant is non-positive or invalid, return 0.0
+                    if not np.isfinite(log_det) or sign <= 0:
+                        return 0.0
+                    # Avoid overflow in exp
                 if log_det > 700:
                     _logger.debug("_safe_determinant: log_det too large, returning 0.0")
                     return 0.0
-                # Account for permutation sign
-                sign = np.linalg.det(P) if P.shape[0] <= 10 else 1.0
                 with warnings.catch_warnings():
                     warnings.filterwarnings('ignore', category=RuntimeWarning)
-                    det = sign * np.exp(log_det)
+                        det = np.exp(log_det)
                 if np.isfinite(det):
                     return float(det)
+                except Exception:
+                    pass
         except (np.linalg.LinAlgError, ValueError, OverflowError, RuntimeWarning):
             pass
     

{dfm_python-0.2.5.dist-info → dfm_python-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dfm-python
-Version: 0.2.5
+Version: 0.2.7
 Summary: Dynamic Factor Model (DFM) estimation and nowcasting in Python
 Project-URL: Homepage, https://github.com/yourusername/dfm-python
 Project-URL: Documentation, https://github.com/yourusername/dfm-python#readme
@@ -709,12 +709,29 @@ Demonstrates:
 
 ## Project Status
 
-**Version**: 0.2.5  
+**Version**: 0.2.7  
 **Status**: Stable and production-ready  
 **Python**: 3.10+  
 **PyPI**: https://pypi.org/project/dfm-python/
 
-### Recent Improvements (v0.2.5)
+### Recent Improvements (v0.2.7)
+
+- ✅ **Fixed C normalization issue**: C normalization now only applies when C norm is in reasonable range (0.1 ~ 10)
+  - Prevents Q from becoming too small when C norm is very small
+  - Prevents factor values from becoming extreme
+- ✅ **Improved stability**: Conditional C normalization prevents pathological factor paths
+- ✅ **Better diagnostics**: Added variance guard binding checks in tutorial
+
+### Previous Improvements (v0.2.6)
+
+- ✅ **Q matrix cap**: Factor innovation variances bounded above by 1.0 to prevent explosion
+- ✅ **R matrix cap**: Observation error variances bounded above by 10.0 for standardized data
+- ✅ **Improved C normalization**: C norm clipping prevents Q explosion during normalization
+- ✅ **Enhanced initial values**: PCA loadings clipped to prevent extreme initial values
+- ✅ **Bug fix**: Fixed `np.linalg.lu` error by using `np.linalg.slogdet` for determinant computation
+- ✅ **Better stability**: Q and R caps ensure model convergence even with challenging data
+
+### Previous Improvements (v0.2.5)
 
 - ✅ **Q matrix floor**: Factor innovation variances bounded below by 0.01 to prevent scale issues
 - ✅ **C matrix normalization**: Clock-frequency factor loadings normalized (||C[:,j]|| = 1) for scale stability
@@ -749,7 +766,7 @@ If you use `dfm-python` in your research, please cite:
   author = {DFM Python Contributors},
   year = {2025},
   url = {https://pypi.org/project/dfm-python/},
-  version = {0.2.5}
+  version = {0.2.7}
 }
 ```
 

{dfm_python-0.2.5.dist-info → dfm_python-0.2.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dfm_python/__init__.py,sha256=8_xxzeEMbtdKxcjH48IytqGh3uSaGJnl8Q8JnCFFLhs,5589
+dfm_python/__init__.py,sha256=YYhRgV773DAFbaTrfF6LVF45rmbR8SpsH6LOYtDAHnU,5589
 dfm_python/api.py,sha256=-mmV7aaXOAqVW9HPhTEut7T6wN1EyW0rS3J0y-z-MRs,16221
 dfm_python/config.py,sha256=bBiKfoETohNVJ3brRbY1330C1nQROybCR3co9iagIKs,46978
 dfm_python/config_sources.py,sha256=6LTK7k5WJpnayMmtxtYwZ9SQi_hGXoz-Vg4sRGTabI0,21798
@@ -9,10 +9,10 @@ dfm_python/news.py,sha256=iXbJnsvH5FgKToPzKnqIpTosrZu-QHXBNHjsqwMYrHo,32583
 dfm_python/utils.py,sha256=qOAJm2KG71yP2a29iJVDGOC-ZUS_HPL5oAo16EgNXA4,15709
 dfm_python/core/__init__.py,sha256=oDrhAoc1W_ODohgufQ-gN0uri8-vZI0EXsF0dysth_A,331
 dfm_python/core/diagnostics.py,sha256=2Cm8XIN5jE9jL3FssEUmZNQy12FPuKvYs1k3bYKAySw,20224
-dfm_python/core/em.py,sha256=Y1kICJfdNyAWsWYxxJANp4TAiQ__iVR5wwhNw6h0qC0,67571
+dfm_python/core/em.py,sha256=ltMVW1izAVmMwwYKf3GIFLAP-nLAgGy9zdOenuK-SiU,72509
 dfm_python/core/helpers.py,sha256=XJvWWEZlUqozBfFNcENKgbOOFkwlm-tGwO-u0LnAf-E,31541
-dfm_python/core/numeric.py,sha256=CsufWu5feWdRjjrhGL7pKxwq5CFkaBn-1l3t1v35YQI,26323
-dfm_python-0.2.5.dist-info/METADATA,sha256=rmEAZQ0C4RPO7h4G3JJhu6Kq1itjD4dif_aH_2O121w,27552
-dfm_python-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dfm_python-0.2.5.dist-info/licenses/LICENSE,sha256=6e87br6LCDHjy2hdIR1-sdBQy351qdmSEbOg6jQ7ZXY,1063
-dfm_python-0.2.5.dist-info/RECORD,,
+dfm_python/core/numeric.py,sha256=__uwDgRj3TV4S0vXhNc_93kk8U6ewtW8smk0OBZLbdg,26403
+dfm_python-0.2.7.dist-info/METADATA,sha256=ZeeKWsk4BkRbihDNjkLkOq-DofODB9RhwG7dxMRIbQI,28599
+dfm_python-0.2.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dfm_python-0.2.7.dist-info/licenses/LICENSE,sha256=6e87br6LCDHjy2hdIR1-sdBQy351qdmSEbOg6jQ7ZXY,1063
+dfm_python-0.2.7.dist-info/RECORD,,